From: uz <uz@b7a2c559-68d2-44c3-8de9-860c34a00d81>
Date: Sat, 5 Dec 2009 22:39:45 +0000 (+0000)
Subject: Rewrote literal handling. Literals are now saved together with other function
X-Git-Tag: V2.13.1~28
X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=3976746735629a689cd22863d79d9efc13743364;p=cc65

Rewrote literal handling. Literals are now saved together with other function
data, and at the end of compilation merged if possible. Literals for unused
functions are removed together with the function.


git-svn-id: svn://svn.cc65.org/cc65/trunk@4501 b7a2c559-68d2-44c3-8de9-860c34a00d81
---

diff --git a/doc/cc65.sgml b/doc/cc65.sgml
index fddb37937..6ae45dcac 100644
--- a/doc/cc65.sgml
+++ b/doc/cc65.sgml
@@ -244,7 +244,7 @@ Here is a description of all the command line options:
   better way is to declare characters explicitly as "signed" if needed. You
   can also use <tt><ref id="pragma-signed-chars"
   name="#pragma&nbsp;signed-chars"></tt> for better control of this option.
-                                                                        
+
 
   <label id="option--standard">
   <tag><tt>--standard std</tt></tag>
@@ -301,8 +301,8 @@ Here is a description of all the command line options:
 
   Make string literals writable by placing them into the data segment instead
   of the rodata segment. You can also use <tt><ref id="pragma-writable-strings"
-  name="#pragma&nbsp;writable-strings"></tt> to control this option on a
-  per function basis.
+  name="#pragma&nbsp;writable-strings"></tt> to control this option from within
+  the source file.
 
 
   <label id="option-static-locals">
@@ -979,9 +979,9 @@ parameter with the <tt/#pragma/.
 
 <sect1><tt>#pragma writable-strings ([push,] on|off)</tt><label id="pragma-writable-strings"><p>
 
-  Changes the storage location of string literals. For historical reasons, 
-  the C standard defines that string literals are of type "char[]", but 
-  writing to such a literal causes undefined behaviour. Most compilers 
+  Changes the storage location of string literals. For historical reasons,
+  the C standard defines that string literals are of type "char[]", but
+  writing to such a literal causes undefined behaviour. Most compilers
   (including cc65) place string literals in the read-only data segment, which
   may cause problems with old C code that writes to string literals.
 
@@ -990,10 +990,6 @@ parameter with the <tt/#pragma/.
   literals to be placed in the data segment so they can be written to without
   worry.
 
-  Please note that the value of this flag that is in effect when a function
-  is encountered, determines where the literals are stored. Changing the 
-  <tt/#pragma/ within a function doesn't have an effect for this function.
-
   The <tt/#pragma/ understands the push and pop parameters as explained above.
 
 
diff --git a/src/cc65/asmcode.c b/src/cc65/asmcode.c
index 83ea3b252..c70675c01 100644
--- a/src/cc65/asmcode.c
+++ b/src/cc65/asmcode.c
@@ -38,7 +38,6 @@
 
 /* cc65 */
 #include "asmcode.h"
-#include "codeopt.h"
 #include "codeseg.h"
 #include "dataseg.h"
 #include "segments.h"
@@ -124,12 +123,8 @@ void WriteAsmOutput (void)
     SymTab = GetGlobalSymTab ();
     Entry  = SymTab->SymHead;
     while (Entry) {
-       	if (IsTypeFunc (Entry->Type) 	  	&&
-       	    SymIsDef (Entry)   	                &&
-       	    (Entry->Flags & (SC_REF | SC_EXTERN)) != 0) {
-       	    /* Function which is defined and referenced or extern */
-       	    CS_MergeLabels (Entry->V.F.Seg->Code);
-       	    RunOpt (Entry->V.F.Seg->Code);
+       	if (SymIsOutputFunc (Entry)) {
+            /* Function which is defined and referenced or extern */
        	    OutputSegments (Entry->V.F.Seg);
        	}
        	Entry = Entry->NextSym;
diff --git a/src/cc65/asmstmt.c b/src/cc65/asmstmt.c
index b54771aa9..3f858c679 100644
--- a/src/cc65/asmstmt.c
+++ b/src/cc65/asmstmt.c
@@ -321,8 +321,7 @@ static void ParseStrArg (StrBuf* T, unsigned Arg attribute ((unused)))
 
         case TOK_SCONST:
             /* String constant */
-            SB_AppendStr (T, GetLiteral (CurTok.IVal));
-            ResetLiteralPoolOffs (CurTok.IVal);
+            SB_Append (T, GetLiteralStrBuf (CurTok.SVal));
             NextToken ();
             break;
 
@@ -347,14 +346,7 @@ static void ParseAsm (void)
 
     /* Create a string buffer from the string literal */
     StrBuf S = AUTO_STRBUF_INITIALIZER;
-    GetLiteralStrBuf (&S, CurTok.IVal);
-
-    /* Reset the string pointer, effectivly clearing the string from the
-     * string table. Since we're working with one token lookahead, this
-     * will fail if the next token is also a string token, but that's a
-     * syntax error anyway, because we expect a right paren.
-     */
-    ResetLiteralPoolOffs (CurTok.IVal);
+    SB_Append (&S, GetLiteralStrBuf (CurTok.SVal));
 
     /* Skip the string token */
     NextToken ();
diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c
index 8287ca84e..07d6597dd 100644
--- a/src/cc65/codegen.c
+++ b/src/cc65/codegen.c
@@ -41,9 +41,9 @@
 #include "check.h"
 #include "cpu.h"
 #include "strbuf.h"
-#include "version.h"
 #include "xmalloc.h"
 #include "xsprintf.h"
+#include "version.h"
 
 /* cc65 */
 #include "asmcode.h"
@@ -346,6 +346,24 @@ void g_defdatalabel (unsigned label)
 
 
 
+void g_aliasdatalabel (unsigned label, unsigned baselabel, long offs)
+/* Define label as a local alias for baselabel+offs */
+{
+    /* We need an intermediate buffer here since LocalLabelName uses a
+     * static buffer which changes with each call.
+     */
+    StrBuf L = AUTO_STRBUF_INITIALIZER;
+    SB_AppendStr (&L, LocalLabelName (label));
+    SB_Terminate (&L);
+    AddDataLine ("%s\t:=\t%s+%ld",
+                 SB_GetConstBuf (&L),
+                 LocalLabelName (baselabel),
+                 offs);
+    SB_Done (&L);
+}
+
+
+
 /*****************************************************************************/
 /*           	       Functions handling global labels			     */
 /*****************************************************************************/
diff --git a/src/cc65/codegen.h b/src/cc65/codegen.h
index 9d17ebe69..a3b6df128 100644
--- a/src/cc65/codegen.h
+++ b/src/cc65/codegen.h
@@ -136,6 +136,9 @@ void g_defcodelabel (unsigned label);
 void g_defdatalabel (unsigned label);
 /* Define a local data label */
 
+void g_aliasdatalabel (unsigned label, unsigned baselabel, long offs);
+/* Define label as a local alias for baselabel+offs */
+
 
 
 /*****************************************************************************/
diff --git a/src/cc65/compile.c b/src/cc65/compile.c
index 9d92b4ace..0fcbfdf42 100644
--- a/src/cc65/compile.c
+++ b/src/cc65/compile.c
@@ -46,6 +46,7 @@
 #include "asmlabel.h"
 #include "asmstmt.h"
 #include "codegen.h"
+#include "codeopt.h"
 #include "compile.h"
 #include "declare.h"
 #include "error.h"
@@ -373,35 +374,51 @@ void Compile (const char* FileName)
         /* Close the output file */
         CloseOutputFile ();
 
-        if (Debug) {
-            PrintMacroStats (stdout);
-        }
-
     } else {
 
         /* Ok, start the ball rolling... */
         Parse ();
 
-        /* Dump the literal pool. */
-        DumpLiteralPool ();
+    }
 
-        /* Write imported/exported symbols */
-        EmitExternals ();
+    if (Debug) {
+        PrintMacroStats (stdout);
+    }
+
+    /* Print an error report */
+    ErrorReport ();
+}
 
-        if (Debug) {
-            PrintLiteralPoolStats (stdout);
-            PrintMacroStats (stdout);
-        }
 
+
+void FinishCompile (void)
+/* Emit literals, externals, do cleanup and optimizations */
+{
+    SymTable* SymTab;
+    SymEntry* Func;
+
+    /* Walk over all functions, doing cleanup, optimizations ... */
+    SymTab = GetGlobalSymTab ();
+    Func   = SymTab->SymHead;
+    while (Func) {
+        if (SymIsOutputFunc (Func)) {
+            /* Function which is defined and referenced or extern */
+            MoveLiteralPool (Func->V.F.LitPool);
+            CS_MergeLabels (Func->V.F.Seg->Code);
+            RunOpt (Func->V.F.Seg->Code);
+        }
+        Func = Func->NextSym;
     }
 
+    /* Dump the literal pool */
+    DumpLiteralPool ();
+
+    /* Write imported/exported symbols */
+    EmitExternals ();
+
     /* Leave the main lexical level */
     LeaveGlobalLevel ();
-
-    /* Print an error report */
-    ErrorReport ();
 }
 
 
 
-
diff --git a/src/cc65/compile.h b/src/cc65/compile.h
index e1be3ee24..27dae0778 100644
--- a/src/cc65/compile.h
+++ b/src/cc65/compile.h
@@ -6,10 +6,10 @@
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 2000-2001 Ullrich von Bassewitz                                       */
-/*               Wacholderweg 14                                             */
-/*               D-70597 Stuttgart                                           */
-/* EMail:        uz@cc65.org                                                 */
+/* (C) 2000-2009, Ullrich von Bassewitz                                      */
+/*                Roemerstrasse 52                                           */
+/*                D-70794 Filderstadt                                        */
+/* EMail:         uz@cc65.org                                                */
 /*                                                                           */
 /*                                                                           */
 /* This software is provided 'as-is', without any expressed or implied       */
@@ -47,6 +47,9 @@
 void Compile (const char* FileName);
 /* Top level compile routine. Will setup things and call the parser. */
 
+void FinishCompile (void);
+/* Emit literals, externals, do cleanup and optimizations */
+
 
 
 /* End of compile.h */
diff --git a/src/cc65/declare.c b/src/cc65/declare.c
index 1e0b610ed..2b5e5fb63 100644
--- a/src/cc65/declare.c
+++ b/src/cc65/declare.c
@@ -1769,7 +1769,6 @@ static unsigned ParseArrayInit (Type* T, int AllowFlexibleMembers)
 
         /* Char array initialized by string constant */
         int NeedParen;
-        const char* Str;
 
         /* If we initializer is enclosed in brackets, remember this fact and
          * skip the opening bracket.
@@ -1779,16 +1778,13 @@ static unsigned ParseArrayInit (Type* T, int AllowFlexibleMembers)
             NextToken ();
         }
 
-        /* Get the initializer string and its size */
-        Str = GetLiteral (CurTok.IVal);
-        Count = GetLiteralPoolOffs () - CurTok.IVal;
-
         /* Translate into target charset */
-        TranslateLiteralPool (CurTok.IVal);
+        TranslateLiteral (CurTok.SVal);
 
         /* If the array is one too small for the string literal, omit the
          * trailing zero.
          */
+        Count = GetLiteralSize (CurTok.SVal);
         if (ElementCount != UNSPECIFIED &&
             ElementCount != FLEXIBLE    &&
             Count        == ElementCount + 1) {
@@ -1797,10 +1793,9 @@ static unsigned ParseArrayInit (Type* T, int AllowFlexibleMembers)
         }
 
         /* Output the data */
-        g_defbytes (Str, Count);
+        g_defbytes (GetLiteralStr (CurTok.SVal), Count);
 
-        /* Remove string from pool */
-        ResetLiteralPoolOffs (CurTok.IVal);
+        /* Skip the string */
         NextToken ();
 
         /* If the initializer was enclosed in curly braces, we need a closing
diff --git a/src/cc65/expr.c b/src/cc65/expr.c
index ee658fbb5..ff5cde4f0 100644
--- a/src/cc65/expr.c
+++ b/src/cc65/expr.c
@@ -578,6 +578,7 @@ static void Primary (ExprDesc* E)
 /* This is the lowest level of the expression parser. */
 {
     SymEntry* Sym;
+    Literal*  L;
 
     /* Initialize fields in the expression stucture */
     ED_Init (E);
@@ -748,10 +749,11 @@ static void Primary (ExprDesc* E)
         case TOK_SCONST:
         case TOK_WCSCONST:
             /* String literal */
-            E->Type  = GetCharArrayType (GetLiteralPoolOffs () - CurTok.IVal);
+            L = UseLiteral (CurTok.SVal);
+            E->Type  = GetCharArrayType (GetLiteralSize (CurTok.SVal));
             E->Flags = E_LOC_LITERAL | E_RTYPE_RVAL;
-            E->IVal  = CurTok.IVal;
-            E->Name  = GetLiteralPoolLabel ();
+            E->IVal  = 0;
+            E->Name  = GetLiteralLabel (CurTok.SVal);                         
             NextToken ();
             break;
 
diff --git a/src/cc65/function.c b/src/cc65/function.c
index dcc625a69..8944d1007 100644
--- a/src/cc65/function.c
+++ b/src/cc65/function.c
@@ -359,7 +359,7 @@ static void F_RestoreRegVars (Function* F)
 }
 
 
-
+    
 /*****************************************************************************/
 /*     	      	  	    	     code	      		 	     */
 /*****************************************************************************/
@@ -542,9 +542,8 @@ void NewFunc (SymEntry* Func)
     /* Eat the closing brace */
     ConsumeRCurly ();
 
-    /* Dump the literal pool, the restore the old one */
-    DumpLiteralPool ();
-    PopLiteralPool ();
+    /* Restore the old literal pool, remembering the one for the function */
+    Func->V.F.LitPool = PopLiteralPool ();
 
     /* Switch back to the old segments */
     PopSegments ();
diff --git a/src/cc65/litpool.c b/src/cc65/litpool.c
index 30c605d5f..6f3456621 100644
--- a/src/cc65/litpool.c
+++ b/src/cc65/litpool.c
@@ -1,6 +1,6 @@
 /*****************************************************************************/
 /*                                                                           */
-/*				   litpool.c				     */
+/*			 	   litpool.c				     */
 /*                                                                           */
 /*		Literal string handling for the cc65 C compiler		     */
 /*                                                                           */
@@ -34,8 +34,10 @@
 
 
 #include <stdio.h>
+#include <string.h>
 
 /* common */
+#include "attrib.h"
 #include "check.h"
 #include "coll.h"
 #include "tgttrans.h"
@@ -56,20 +58,23 @@
 
 
 
-/* Forward for struct SymEntry */
-struct SymEntry;
+/* Definition of a literal */
+struct Literal {
+    unsigned    Label;                  /* Asm label for this literal */
+    int         RefCount;               /* Reference count */
+    StrBuf      Data;                   /* Literal data */
+};
 
 /* Definition of the literal pool */
-typedef struct LiteralPool LiteralPool;
 struct LiteralPool {
-    int                 Writable;       /* True if strings are writable */
-    unsigned            Label;          /* Pool asm label */
-    struct SymEntry*    Func;           /* Function that contains the pool */
-    StrBuf              Pool;           /* The pool itself */
+    struct SymEntry*    Func;               /* Function that owns the pool */
+    Collection          WritableLiterals;   /* Writable literals in the pool */
+    Collection          ReadOnlyLiterals;   /* Readonly literals in the pool */
 };
 
-/* The current literal pool */
-static LiteralPool*     LP = 0;
+/* The global and current literal pool */
+static LiteralPool*     GlobalPool = 0;
+static LiteralPool*     LP         = 0;
 
 /* Stack that contains the nested literal pools. Since TOS is in LiteralPool
  * and functions aren't nested in C, the maximum depth is 1. I'm using a
@@ -80,6 +85,99 @@ static Collection       LPStack  = STATIC_COLLECTION_INITIALIZER;
 
 
 
+/*****************************************************************************/
+/*                              struct Literal                               */
+/*****************************************************************************/
+
+
+
+static Literal* NewLiteral (const void* Buf, unsigned Len)
+/* Create a new literal and return it */
+{
+    /* Allocate memory */
+    Literal* L = xmalloc (sizeof (*L));
+
+    /* Initialize the fields */
+    L->Label    = GetLocalLabel ();
+    L->RefCount = 0;
+    SB_Init (&L->Data);
+    SB_AppendBuf (&L->Data, Buf, Len);
+
+    /* Return the new literal */
+    return L;
+}
+
+
+
+static void FreeLiteral (Literal* L)
+/* Free a literal */
+{
+    /* Free the literal data */
+    SB_Done (&L->Data);
+
+    /* Free the structure itself */
+    xfree (L);
+}
+
+
+
+Literal* UseLiteral (Literal* L)
+/* Increase the reference counter for the literal and return it */
+{
+    ++L->RefCount;
+    return L;
+}
+
+
+
+void ReleaseLiteral (Literal* L)
+/* Decrement the reference counter for the literal */
+{
+    CHECK (--L->RefCount >= 0);
+}
+
+
+
+void TranslateLiteral (Literal* L)
+/* Translate a literal into the target charset. */
+{
+    TgtTranslateBuf (SB_GetBuf (&L->Data), SB_GetLen (&L->Data));
+}
+
+
+
+unsigned GetLiteralLabel (const Literal* L)
+/* Return the asm label for a literal */
+{
+    return L->Label;
+}
+
+
+
+const char* GetLiteralStr (const Literal* L)
+/* Return the data for a literal as pointer to char */
+{
+    return SB_GetConstBuf (&L->Data);
+}
+
+
+
+const StrBuf* GetLiteralStrBuf (const Literal* L)
+/* Return the data for a literal as pointer to the string buffer */
+{
+    return &L->Data;
+}
+
+
+
+unsigned GetLiteralSize (const Literal* L)
+/* Get the size of a literal string */
+{
+    return SB_GetLen (&L->Data);
+}
+
+
+
 /*****************************************************************************/
 /*  	       	       	   	     Code		     		     */
 /*****************************************************************************/
@@ -93,10 +191,9 @@ static LiteralPool* NewLiteralPool (struct SymEntry* Func)
     LiteralPool* LP = xmalloc (sizeof (*LP));
 
     /* Initialize the fields */
-    LP->Writable = IS_Get (&WritableStrings);
-    LP->Label = GetLocalLabel ();
     LP->Func  = Func;
-    SB_Init (&LP->Pool);
+    InitCollection (&LP->WritableLiterals);
+    InitCollection (&LP->ReadOnlyLiterals);
 
     /* Return the new pool */
     return LP;
@@ -107,8 +204,9 @@ static LiteralPool* NewLiteralPool (struct SymEntry* Func)
 static void FreeLiteralPool (LiteralPool* LP)
 /* Free a LiteralPool structure */
 {
-    /* Free the string buffer contained within the struct */
-    SB_Done (&LP->Pool);
+    /* Free the collections contained within the struct */
+    DoneCollection (&LP->WritableLiterals);
+    DoneCollection (&LP->ReadOnlyLiterals);
 
     /* Free the struct itself */
     xfree (LP);
@@ -116,11 +214,21 @@ static void FreeLiteralPool (LiteralPool* LP)
 
 
 
+static int Compare (void* Data attribute ((unused)),
+                    const void* Left, const void* Right)
+/* Compare function used when sorting the literal pool */
+{
+    /* Larger strings are considered "smaller" */
+    return (int) GetLiteralSize (Right) - (int) GetLiteralSize (Left);
+}
+
+
+
 void InitLiteralPool (void)
 /* Initialize the literal pool */
 {
-    /* Create a new pool */
-    LP = NewLiteralPool (0);
+    /* Create the global literal pool */
+    GlobalPool = LP = NewLiteralPool (0);
 }
 
 
@@ -140,143 +248,224 @@ void PushLiteralPool (struct SymEntry* Func)
 
 
 
-void PopLiteralPool (void)
-/* Free the current literal pool and restore the one from TOS */
+LiteralPool* PopLiteralPool (void)
+/* Pop the last literal pool from TOS and activate it. Return the old
+ * literal pool.
+ */
 {
-    /* Free the current literal pool */
-    FreeLiteralPool (LP);
+    /* Remember the current literal pool */
+    LiteralPool* Old = LP;
 
     /* Pop one from stack */
     LP = CollPop (&LPStack);
+
+    /* Return the old one */
+    return Old;
 }
 
 
 
-void TranslateLiteralPool (unsigned Offs)
-/* Translate the literals starting from the given offset into the target
- * charset.
+static void MoveLiterals (Collection* Source, Collection* Target)
+/* Move referenced literals from Source to Target, delete unreferenced ones */
+{
+    unsigned I;
+
+    /* Move referenced literals, remove unreferenced ones */
+    for (I = 0; I < CollCount (Source); ++I) {
+
+        /* Get the literal */
+        Literal* L = CollAt (Source, I);
+
+        /* If it is referenced, add it to the Target pool, otherwise free it */
+        if (L->RefCount) {
+            CollAppend (Target, L);
+        } else {
+            FreeLiteral (L);
+        }
+    }
+}
+
+
+
+void MoveLiteralPool (LiteralPool* LocalPool)
+/* Move all referenced literals in LocalPool to the global literal pool. This
+ * function will free LocalPool after moving the used string literals.
  */
 {
-    TgtTranslateBuf (SB_GetBuf (&LP->Pool) + Offs, SB_GetLen (&LP->Pool) - Offs);
+    /* Move the literals */
+    MoveLiterals (&LocalPool->WritableLiterals, &GlobalPool->WritableLiterals);
+    MoveLiterals (&LocalPool->ReadOnlyLiterals, &GlobalPool->ReadOnlyLiterals);
+
+    /* Free the local literal pool */
+    FreeLiteralPool (LocalPool);
 }
 
 
 
-void DumpLiteralPool (void)
-/* Dump the literal pool */
+static void DumpWritableLiterals (Collection* Literals)
+/* Dump the given writable literals */
 {
+    unsigned I;
+
     /* If nothing there, exit... */
-    if (SB_GetLen (&LP->Pool) == 0) {
-	return;
+    if (CollCount (Literals) == 0) {
+    	return;
     }
 
     /* Switch to the correct segment */
-    if (LP->Writable) {
-     	g_usedata ();
-    } else {
-       	g_userodata ();
-    }
+    g_usedata ();
 
-    /* Define the label */
-    g_defdatalabel (LP->Label);
+    /* Emit all literals that have a reference */
+    for (I = 0; I < CollCount (Literals); ++I) {
 
-    /* Translate the buffer contents into the target charset */
-    TranslateLiteralPool (0);
+        /* Get the next literal */
+        Literal* L = CollAt (Literals, I);
 
-    /* Output the buffer data */
-    g_defbytes (SB_GetConstBuf (&LP->Pool), SB_GetLen (&LP->Pool));
-}
+        /* Ignore it, if it doesn't have references */
+        if (L->RefCount == 0) {
+            continue;
+        }
 
+        /* Translate the literal into the target charset */
+        TranslateLiteral (L);
 
+        /* Define the label for the literal */
+        g_defdatalabel (L->Label);
 
-unsigned GetLiteralPoolLabel (void)
-/* Return the asm label for the current literal pool */
-{
-    return LP->Label;
+        /* Output the literal data */
+        g_defbytes (SB_GetConstBuf (&L->Data), SB_GetLen (&L->Data));
+
+    }
 }
 
 
 
-unsigned GetLiteralPoolOffs (void)
-/* Return the current offset into the literal pool */
+static void DumpReadOnlyLiterals (Collection* Literals)
+/* Dump the given readonly literals merging (even partial) duplicates */
 {
-    return SB_GetLen (&LP->Pool);
-}
+    unsigned I;
 
+    /* If nothing there, exit... */
+    if (CollCount (Literals) == 0) {
+    	return;
+    }
 
+    /* Switch to the correct segment */
+    g_userodata ();
 
-void ResetLiteralPoolOffs (unsigned Offs)
-/* Reset the offset into the literal pool to some earlier value, effectively
- * removing values from the pool.
- */
-{
-    CHECK (Offs <= SB_GetLen (&LP->Pool));
-    SB_Cut (&LP->Pool, Offs);
-}
+    /* Sort the literal pool by literal size. Larger strings go first */
+    CollSort (Literals, Compare, 0);
 
+    /* Emit all literals that have a reference */
+    for (I = 0; I < CollCount (Literals); ++I) {
 
+        unsigned J;
+        Literal* C;
 
-unsigned AddLiteral (const char* S)
-/* Add a literal string to the literal pool. Return the starting offset into
- * the pool
- */
-{
-    return AddLiteralBuf (S, strlen (S) + 1);
-}
+        /* Get the next literal */
+        Literal* L = CollAt (Literals, I);
 
+        /* Ignore it, if it doesn't have references */
+        if (L->RefCount == 0) {
+            continue;
+        }
 
+        /* Translate the literal into the target charset */
+        TranslateLiteral (L);
 
-unsigned AddLiteralBuf (const void* Buf, unsigned Len)
-/* Add a buffer containing a literal string to the literal pool. Return the
- * starting offset into the pool for this string.
- */
-{
-    /* Remember the starting offset */
-    unsigned Start = SB_GetLen (&LP->Pool);
+        /* Check if this literal is part of another one. Since the literals
+         * are sorted by size (larger ones first), it can only be part of a
+         * literal with a smaller index.
+         * Beware: Only check literals that have actually been referenced.
+         */
+        C = 0;
+        for (J = 0; J < I; ++J) {
+
+            const void* D;
+
+            /* Get a pointer to the compare literal */
+            Literal* L2 = CollAt (Literals, J);
+
+            /* Ignore literals that have no reference */
+            if (L2->RefCount == 0) {
+                continue;
+            }
+
+            /* Get a pointer to the data */
+            D = SB_GetConstBuf (&L2->Data) + SB_GetLen (&L2->Data) - SB_GetLen (&L->Data);
+
+            /* Compare the data */
+            if (memcmp (D, SB_GetConstBuf (&L->Data), SB_GetLen (&L->Data)) == 0) {
+                /* Remember the literal and terminate the loop */
+                C = L2;
+                break;
+            }
+        }
+
+        /* Check if we found a match */
+        if (C != 0) {
+
+            /* This literal is part of a longer literal, merge them */
+            g_aliasdatalabel (L->Label, C->Label, GetLiteralSize (C) - GetLiteralSize (L));
 
-    /* Append the buffer */
-    SB_AppendBuf (&LP->Pool, Buf, Len);
 
-    /* Return the starting offset */
-    return Start;
+        } else {
+
+            /* Define the label for the literal */
+            g_defdatalabel (L->Label);
+
+            /* Output the literal data */
+            g_defbytes (SB_GetConstBuf (&L->Data), SB_GetLen (&L->Data));
+
+        }
+    }
 }
 
 
 
-unsigned AddLiteralStr (const StrBuf* S)
-/* Add a literal string to the literal pool. Return the starting offset into
- * the pool for this string.
- */
+void DumpLiteralPool (void)
+/* Dump the global literal pool */
 {
-    return AddLiteralBuf (SB_GetConstBuf (S), SB_GetLen (S));
+    /* Dump both sorts of literals */
+    DumpWritableLiterals (&GlobalPool->WritableLiterals);
+    DumpReadOnlyLiterals (&GlobalPool->ReadOnlyLiterals);
 }
 
 
 
-const char* GetLiteral (unsigned Offs)
-/* Get a pointer to the literal with the given offset in the pool */
+Literal* AddLiteral (const char* S)
+/* Add a literal string to the literal pool. Return the literal. */
 {
-    CHECK (Offs < SB_GetLen (&LP->Pool));
-    return SB_GetConstBuf (&LP->Pool) + Offs;
+    return AddLiteralBuf (S, strlen (S) + 1);
 }
 
 
 
-void GetLiteralStrBuf (StrBuf* Target, unsigned Offs)
-/* Copy the string starting at Offs and lasting to the end of the buffer
- * into Target.
+Literal* AddLiteralBuf (const void* Buf, unsigned Len)
+/* Add a buffer containing a literal string to the literal pool. Return the
+ * literal.
  */
 {
-    CHECK (Offs <= SB_GetLen (&LP->Pool));
-    SB_Slice (Target, &LP->Pool, Offs, SB_GetLen (&LP->Pool) - Offs);
+    /* Create a new literal */
+    Literal* L = NewLiteral (Buf, Len);
+
+    /* Add the literal to the correct pool */
+    if (IS_Get (&WritableStrings)) {
+        CollAppend (&LP->WritableLiterals, L);
+    } else {
+        CollAppend (&LP->ReadOnlyLiterals, L);
+    }
+
+    /* Return the new literal */
+    return L;
 }
 
 
 
-void PrintLiteralPoolStats (FILE* F)
-/* Print statistics about the literal space used */
+Literal* AddLiteralStr (const StrBuf* S)
+/* Add a literal string to the literal pool. Return the literal. */
 {
-    fprintf (F, "Literal space used: %u bytes\n", SB_GetLen (&LP->Pool));
+    return AddLiteralBuf (SB_GetConstBuf (S), SB_GetLen (S));
 }
 
 
diff --git a/src/cc65/litpool.h b/src/cc65/litpool.h
index 26f602ca3..f89ffda8b 100644
--- a/src/cc65/litpool.h
+++ b/src/cc65/litpool.h
@@ -54,67 +54,78 @@
 /* Forward for struct SymEntry */
 struct SymEntry;
 
+/* Forward for a literal */
+typedef struct Literal Literal;
+
+/* Forward for a literal pool */
+typedef struct LiteralPool LiteralPool;
+
 
 
 /*****************************************************************************/
-/*		 	    	     Code				     */
+/*                              struct Literal                               */
 /*****************************************************************************/
 
 
 
-void InitLiteralPool (void);
-/* Initialize the literal pool */
+Literal* UseLiteral (Literal* L);
+/* Increase the reference counter for the literal and return it */
 
-void PushLiteralPool (struct SymEntry* Func);
-/* Push the current literal pool onto the stack and create a new one */
+void ReleaseLiteral (Literal* L);
+/* Decrement the reference counter for the literal */
 
-void PopLiteralPool (void);
-/* Free the current literal pool and restore the one from TOS */
+void TranslateLiteral (Literal* L);
+/* Translate a literal into the target charset. */
 
-void TranslateLiteralPool (unsigned Offs);
-/* Translate the literals starting from the given offset into the target
- * charset.
- */
+unsigned GetLiteralLabel (const Literal* L);
+/* Return the asm label for a literal */
 
-void DumpLiteralPool (void);
-/* Dump the literal pool */
+const char* GetLiteralStr (const Literal* L);
+/* Return the data for a literal as pointer to char */
 
-unsigned GetLiteralPoolLabel (void);
-/* Return the asm label for the current literal pool */
+const StrBuf* GetLiteralStrBuf (const Literal* L);
+/* Return the data for a literal as pointer to the string buffer */
 
-unsigned GetLiteralPoolOffs (void);
-/* Return the current offset into the literal pool */
+unsigned GetLiteralSize (const Literal* L);
+/* Get the size of a literal string */
 
-void ResetLiteralPoolOffs (unsigned Offs);
-/* Reset the offset into the literal pool to some earlier value, effectively
- * removing values from the pool.
- */
 
-unsigned AddLiteral (const char* S);
-/* Add a literal string to the literal pool. Return the starting offset into
- * the pool for this string.
- */
 
-unsigned AddLiteralBuf (const void* Buf, unsigned Len);
-/* Add a buffer containing a literal string to the literal pool. Return the
- * starting offset into the pool for this string.
+/*****************************************************************************/
+/*  	       	       	   	     Code		     		     */
+/*****************************************************************************/
+
+
+
+void InitLiteralPool (void);
+/* Initialize the literal pool */
+
+void PushLiteralPool (struct SymEntry* Func);
+/* Push the current literal pool onto the stack and create a new one */
+
+LiteralPool* PopLiteralPool (void);
+/* Pop the last literal pool from TOS and activate it. Return the old
+ * literal pool.
  */
 
-unsigned AddLiteralStr (const StrBuf* S);
-/* Add a literal string to the literal pool. Return the starting offset into
- * the pool for this string.
+void MoveLiteralPool (LiteralPool* LocalPool);
+/* Move all referenced literals in LocalPool to the global literal pool. This
+ * function will free LocalPool after moving the used string literals.
  */
 
-const char* GetLiteral (unsigned Offs);
-/* Get a pointer to the literal with the given offset in the pool */
+void DumpLiteralPool (void);
+/* Dump the literal pool */
+
+Literal* AddLiteral (const char* S);
+/* Add a literal string to the literal pool. Return the literal. */
 
-void GetLiteralStrBuf (StrBuf* Target, unsigned Offs);
-/* Copy the string starting at Offs and lasting to the end of the buffer
- * into Target.
+Literal* AddLiteralBuf (const void* Buf, unsigned Len);
+/* Add a buffer containing a literal string to the literal pool. Return the
+ * literal.
  */
 
-void PrintLiteralPoolStats (FILE* F);
-/* Print statistics about the literal space used */
+Literal* AddLiteralStr (const StrBuf* S);
+/* Add a literal string to the literal pool. Return the literal. */
 
 
 
diff --git a/src/cc65/main.c b/src/cc65/main.c
index 3785716df..a0f570d21 100644
--- a/src/cc65/main.c
+++ b/src/cc65/main.c
@@ -938,10 +938,13 @@ int main (int argc, char* argv[])
     /* Create the output file if we didn't had any errors */
     if (PreprocessOnly == 0 && (ErrorCount == 0 || Debug)) {
 
-	/* Open the file */
+        /* Emit literals, externals, do cleanup and optimizations */
+        FinishCompile ();
+
+     	/* Open the file */
         OpenOutputFile ();
 
-	/* Write the output to the file */
+     	/* Write the output to the file */
        	WriteAsmOutput ();
        	Print (stdout, 1, "Wrote output to `%s'\n", OutputFilename);
 
diff --git a/src/cc65/pragma.c b/src/cc65/pragma.c
index 37ae1bbb1..9ca493137 100644
--- a/src/cc65/pragma.c
+++ b/src/cc65/pragma.c
@@ -652,14 +652,7 @@ static void ParsePragma (void)
 
     /* Create a string buffer from the string literal */
     StrBuf B = AUTO_STRBUF_INITIALIZER;
-    GetLiteralStrBuf (&B, CurTok.IVal);
-
-    /* Reset the string pointer, effectivly clearing the string from the
-     * string table. Since we're working with one token lookahead, this
-     * will fail if the next token is also a string token, but that's a
-     * syntax error anyway, because we expect a right paren.
-     */
-    ResetLiteralPoolOffs (CurTok.IVal);
+    SB_Append (&B, GetLiteralStrBuf (CurTok.SVal));
 
     /* Skip the string token */
     NextToken ();
diff --git a/src/cc65/scanner.c b/src/cc65/scanner.c
index 2bf684268..3dee4239f 100644
--- a/src/cc65/scanner.c
+++ b/src/cc65/scanner.c
@@ -454,7 +454,7 @@ static void StringConst (void)
     SB_AppendChar (&S, '\0');
 
     /* Add the whole string to the literal pool */
-    NextTok.IVal = AddLiteralStr (&S);
+    NextTok.SVal = AddLiteralStr (&S);
 
     /* Free the buffer */
     SB_Done (&S);
@@ -760,7 +760,7 @@ void NextToken (void)
      	if (token[0] == '_' && token[1] == '_') {
      	    /* Special symbols */
             if (strcmp (token+2, "FILE__") == 0) {
-	       	NextTok.IVal = AddLiteral (GetCurrentFile());
+	       	NextTok.SVal = AddLiteral (GetCurrentFile());
 	       	NextTok.Tok  = TOK_SCONST;
 	       	return;
 	    } else if (strcmp (token+2, "LINE__") == 0) {
@@ -771,7 +771,7 @@ void NextToken (void)
        	    } else if (strcmp (token+2, "func__") == 0) {
 	       	/* __func__ is only defined in functions */
 	       	if (CurrentFunc) {
-	       	    NextTok.IVal = AddLiteral (F_GetFuncName (CurrentFunc));
+	       	    NextTok.SVal = AddLiteral (F_GetFuncName (CurrentFunc));
 	       	    NextTok.Tok  = TOK_SCONST;
 	       	    return;
 	       	}
diff --git a/src/cc65/scanner.h b/src/cc65/scanner.h
index 6c3db2ed2..f186e8343 100644
--- a/src/cc65/scanner.h
+++ b/src/cc65/scanner.h
@@ -186,20 +186,24 @@ typedef enum token_t {
 
 
 /*****************************************************************************/
-/*				     data				     */
+/*				     Data		   		     */
 /*****************************************************************************/
 
 
 
-/* Token stuff */
+/* Forward for struct Literal */
+struct Literal;
+
+/* Token stuff */                     
 typedef struct Token Token;
 struct Token {
-    token_t 	Tok;		/* The token itself */
-    long    	IVal;		/* The integer attribute */
-    Double      FVal;		/* The float attribute */
-    ident   	Ident;		/* Identifier if IDENT */
-    LineInfo*   LI;		/* Source line where the token comes from */
-    Type*	Type;		/* Type if integer or float constant */
+    token_t    	    Tok;        /* The token itself */
+    long    	    IVal;  	/* The integer attribute */
+    Double          FVal;  	/* The float attribute */
+    struct Literal* SVal;       /* String literal is any */
+    ident   	    Ident; 	/* Identifier if IDENT */
+    LineInfo*       LI;    	/* Source line where the token comes from */
+    Type*      	    Type;  	/* Type if integer or float constant */
 };
 
 extern Token CurTok;		/* The current token */
@@ -208,7 +212,7 @@ extern Token NextTok;		/* The next token */
 
 
 /*****************************************************************************/
-/*	   			     code     				     */
+/*	   			     Code     				     */
 /*****************************************************************************/
 
 
diff --git a/src/cc65/stdfunc.c b/src/cc65/stdfunc.c
index 4f48c4fc4..0c3e2779d 100644
--- a/src/cc65/stdfunc.c
+++ b/src/cc65/stdfunc.c
@@ -933,7 +933,8 @@ static void StdFunc_strlen (FuncDesc* F attribute ((unused)), ExprDesc* Expr)
 
     /* Do type conversion */
     TypeConversion (&Arg, ArgType);
-
+      
+#if 0
     /* If the expression is a literal, and if string literals are read
      * only, we can calculate the length of the string and remove it
      * from the literal pool. Otherwise we have to calculate the length
@@ -942,14 +943,15 @@ static void StdFunc_strlen (FuncDesc* F attribute ((unused)), ExprDesc* Expr)
     if (ED_IsLocLiteral (&Arg) && IS_Get (&WritableStrings) == 0) {
 
         /* Constant string literal */
-        ED_MakeConstAbs (Expr, strlen (GetLiteral (Arg.IVal)), type_size_t);
-        ResetLiteralPoolOffs (Arg.IVal);
+        ED_MakeConstAbs (Expr, GetLiteralSize (GetLiteral (Arg.IVal)), type_size_t);
 
     /* We will inline strlen for arrays with constant addresses, if either the
      * inlining was forced on the command line, or the array is smaller than
      * 256, so the inlining is considered safe.
      */
-    } else if (ED_IsLocConst (&Arg) && IsArray &&
+    } else
+#endif
+    if (ED_IsLocConst (&Arg) && IsArray &&
                (IS_Get (&InlineStdFuncs) || IsByteIndex)) {
 
         /* Generate the strlen code */
diff --git a/src/cc65/symentry.c b/src/cc65/symentry.c
index aedf2652e..e42c8bbaa 100644
--- a/src/cc65/symentry.c
+++ b/src/cc65/symentry.c
@@ -153,6 +153,19 @@ void DumpSymEntry (FILE* F, const SymEntry* E)
 
 
 
+int SymIsOutputFunc (const SymEntry* Sym)
+/* Return true if this is a function that must be output */
+{
+    /* Symbol must be a function which is defined and either extern or
+     * static and referenced.
+     */
+    return IsTypeFunc (Sym->Type)               &&
+           SymIsDef (Sym)                       &&
+           (Sym->Flags & (SC_REF | SC_EXTERN));
+}                                               
+
+
+
 const DeclAttr* SymGetAttr (const SymEntry* Sym, DeclAttrType AttrType)
 /* Return an attribute for this symbol or NULL if the attribute does not exist */
 {
diff --git a/src/cc65/symentry.h b/src/cc65/symentry.h
index d83113809..900d2ee5f 100644
--- a/src/cc65/symentry.h
+++ b/src/cc65/symentry.h
@@ -57,6 +57,7 @@
 
 
 struct Segments;
+struct LiteralPool;
 
 
 
@@ -147,6 +148,7 @@ struct SymEntry {
 	struct {
 	    struct FuncDesc*	Func;	  /* Function descriptor */
        	    struct Segments*	Seg;	  /* Segments for this function */
+            struct LiteralPool* LitPool;  /* Literal pool for this function */
        	} F;
 
     } V;
@@ -221,6 +223,9 @@ INLINE int SymIsRegVar (const SymEntry* Sym)
 #  define SymIsRegVar(Sym)      (((Sym)->Flags & (SC_REGISTER|SC_TYPE)) == SC_REGISTER)
 #endif
 
+int SymIsOutputFunc (const SymEntry* Sym);
+/* Return true if this is a function that must be output */
+
 #if defined(HAVE_INLINE)
 INLINE const char* SymGetAsmName (const SymEntry* Sym)
 /* Return the assembler label name for the symbol (beware: may be NULL!) */
@@ -238,7 +243,7 @@ const DeclAttr* SymGetAttr (const SymEntry* Sym, DeclAttrType AttrType);
 INLINE int SymHasAttr (const SymEntry* Sym, DeclAttrType A)
 /* Return true if the symbol has the given attribute */
 {
-    return (SymGetAttr (Sym, A) != 0);    
+    return (SymGetAttr (Sym, A) != 0);
 }
 #else
 #  define SymHasAttr(Sym, A)       (SymGetAttr (Sym, A) != 0)