- 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 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,30 +374,16 @@ 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) {
- PrintLiteralPoolStats (stdout);
- PrintMacroStats (stdout);
- }
-
}
- /* Leave the main lexical level */
- LeaveGlobalLevel ();
+ if (Debug) {
+ PrintMacroStats (stdout);
+ }
/* Print an error report */
ErrorReport ();
@@ -404,4 +391,34 @@ void Compile (const char* FileName)
+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 ();
+}
+
+
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
+#include
/* 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 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 */
+/* Definition of a literal */
+struct Literal {
+ unsigned Label; /* Asm label for this literal */
+ int RefCount; /* Reference count */
+ StrBuf Data; /* Literal data */
};
-/* The current literal pool */
-static LiteralPool* LP = 0;
+/* Definition of the literal pool */
+struct LiteralPool {
+ struct SymEntry* Func; /* Function that owns the pool */
+ Collection WritableLiterals; /* Writable literals in the pool */
+ Collection ReadOnlyLiterals; /* Readonly literals in the pool */
+};
+
+/* 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,144 +248,225 @@ 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);
+}
+
+
+
+static void DumpWritableLiterals (Collection* Literals)
+/* Dump the given writable literals */
+{
+ unsigned I;
+
+ /* If nothing there, exit... */
+ if (CollCount (Literals) == 0) {
+ return;
+ }
+
+ /* Switch to the correct segment */
+ g_usedata ();
+
+ /* Emit all literals that have a reference */
+ for (I = 0; I < CollCount (Literals); ++I) {
+
+ /* 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);
+
+ /* Define the label for the literal */
+ g_defdatalabel (L->Label);
+
+ /* Output the literal data */
+ g_defbytes (SB_GetConstBuf (&L->Data), SB_GetLen (&L->Data));
+
+ }
+}
+
+
+
+static void DumpReadOnlyLiterals (Collection* Literals)
+/* Dump the given readonly literals merging (even partial) duplicates */
+{
+ unsigned I;
+
+ /* If nothing there, exit... */
+ if (CollCount (Literals) == 0) {
+ return;
+ }
+
+ /* Switch to the correct segment */
+ g_userodata ();
+
+ /* 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;
+
+ /* 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);
+
+ /* 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));
+
+
+ } 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));
+
+ }
+ }
}
void DumpLiteralPool (void)
-/* Dump the literal pool */
+/* Dump the global literal pool */
{
- /* If nothing there, exit... */
- if (SB_GetLen (&LP->Pool) == 0) {
- return;
- }
-
- /* Switch to the correct segment */
- if (LP->Writable) {
- g_usedata ();
- } else {
- g_userodata ();
- }
-
- /* Define the label */
- g_defdatalabel (LP->Label);
-
- /* Translate the buffer contents into the target charset */
- TranslateLiteralPool (0);
-
- /* Output the buffer data */
- g_defbytes (SB_GetConstBuf (&LP->Pool), SB_GetLen (&LP->Pool));
+ /* Dump both sorts of literals */
+ DumpWritableLiterals (&GlobalPool->WritableLiterals);
+ DumpReadOnlyLiterals (&GlobalPool->ReadOnlyLiterals);
}
-unsigned GetLiteralPoolLabel (void)
-/* Return the asm label for the current literal pool */
-{
- return LP->Label;
-}
-
-
-
-unsigned GetLiteralPoolOffs (void)
-/* Return the current offset into the literal pool */
-{
- return SB_GetLen (&LP->Pool);
-}
-
-
-
-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);
-}
-
-
-
-unsigned AddLiteral (const char* S)
-/* Add a literal string to the literal pool. Return the starting offset into
- * the pool
- */
+Literal* AddLiteral (const char* S)
+/* Add a literal string to the literal pool. Return the literal. */
{
return AddLiteralBuf (S, strlen (S) + 1);
}
-unsigned AddLiteralBuf (const void* Buf, unsigned Len)
+Literal* 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.
+ * literal.
*/
{
- /* Remember the starting offset */
- unsigned Start = SB_GetLen (&LP->Pool);
+ /* Create a new literal */
+ Literal* L = NewLiteral (Buf, Len);
- /* Append the buffer */
- SB_AppendBuf (&LP->Pool, Buf, Len);
+ /* Add the literal to the correct pool */
+ if (IS_Get (&WritableStrings)) {
+ CollAppend (&LP->WritableLiterals, L);
+ } else {
+ CollAppend (&LP->ReadOnlyLiterals, L);
+ }
- /* Return the starting offset */
- return Start;
+ /* Return the new literal */
+ return L;
}
-unsigned AddLiteralStr (const StrBuf* S)
-/* Add a literal string to the literal pool. Return the starting offset into
- * the pool for this string.
- */
+Literal* AddLiteralStr (const StrBuf* S)
+/* Add a literal string to the literal pool. Return the literal. */
{
return AddLiteralBuf (SB_GetConstBuf (S), SB_GetLen (S));
}
-const char* GetLiteral (unsigned Offs)
-/* Get a pointer to the literal with the given offset in the pool */
-{
- CHECK (Offs < SB_GetLen (&LP->Pool));
- return SB_GetConstBuf (&LP->Pool) + Offs;
-}
-
-
-
-void GetLiteralStrBuf (StrBuf* Target, unsigned Offs)
-/* Copy the string starting at Offs and lasting to the end of the buffer
- * into Target.
- */
-{
- CHECK (Offs <= SB_GetLen (&LP->Pool));
- SB_Slice (Target, &LP->Pool, Offs, SB_GetLen (&LP->Pool) - Offs);
-}
-
-
-
-void PrintLiteralPoolStats (FILE* F)
-/* Print statistics about the literal space used */
-{
- fprintf (F, "Literal space used: %u bytes\n", SB_GetLen (&LP->Pool));
-}
-
-
-
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,10 +54,45 @@
/* 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 */
+/*****************************************************************************/
+
+
+
+Literal* UseLiteral (Literal* L);
+/* Increase the reference counter for the literal and return it */
+
+void ReleaseLiteral (Literal* L);
+/* Decrement the reference counter for the literal */
+
+void TranslateLiteral (Literal* L);
+/* Translate a literal into the target charset. */
+
+unsigned GetLiteralLabel (const Literal* L);
+/* Return the asm label for a literal */
+
+const char* GetLiteralStr (const Literal* L);
+/* Return the data for a literal as pointer to char */
+
+const StrBuf* GetLiteralStrBuf (const Literal* L);
+/* Return the data for a literal as pointer to the string buffer */
+
+unsigned GetLiteralSize (const Literal* L);
+/* Get the size of a literal string */
+
+
+
+/*****************************************************************************/
+/* Code */
/*****************************************************************************/
@@ -68,53 +103,29 @@ void InitLiteralPool (void);
void PushLiteralPool (struct SymEntry* Func);
/* Push the current literal pool onto the stack and create a new one */
-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.
+ */
-void TranslateLiteralPool (unsigned Offs);
-/* Translate the literals starting from the given offset into the target
- * charset.
+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.
*/
void DumpLiteralPool (void);
/* Dump the literal pool */
-unsigned GetLiteralPoolLabel (void);
-/* Return the asm label for the current literal pool */
+Literal* AddLiteral (const char* S);
+/* Add a literal string to the literal pool. Return the literal. */
-unsigned GetLiteralPoolOffs (void);
-/* Return the current offset into the literal pool */
-
-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);
+Literal* 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.
+ * literal.
*/
-unsigned AddLiteralStr (const StrBuf* S);
-/* Add a literal string to the literal pool. Return the starting offset into
- * the pool for this string.
- */
-
-const char* GetLiteral (unsigned Offs);
-/* Get a pointer to the literal with the given offset in the pool */
-
-void GetLiteralStrBuf (StrBuf* Target, unsigned Offs);
-/* Copy the string starting at Offs and lasting to the end of the buffer
- * into Target.
- */
-
-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)