6502
/
cc65
mirror of https://github.com/cc65/cc65.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
cc65/src/cc65/litpool.c

491 lines
13 KiB
C
Raw Blame History

/*****************************************************************************/
/* */
/* litpool.c */
/* */
/* Literal string handling for the cc65 C compiler */
/* */
/* */
/* */
/* (C) 1998-2013, Ullrich von Bassewitz */
/* Roemerstrasse 52 */
/* D-70794 Filderstadt */
/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
/* warranty. In no event will the authors be held liable for any damages */
/* arising from the use of this software. */
/* */
/* Permission is granted to anyone to use this software for any purpose, */
/* including commercial applications, and to alter it and redistribute it */
/* freely, subject to the following restrictions: */
/* */
/* 1. The origin of this software must not be misrepresented; you must not */
/* claim that you wrote the original software. If you use this software */
/* in a product, an acknowledgment in the product documentation would be */
/* appreciated but is not required. */
/* 2. Altered source versions must be plainly marked as such, and must not */
/* be misrepresented as being the original software. */
/* 3. This notice may not be removed or altered from any source */
/* distribution. */
/* */
/*****************************************************************************/
#include <stdio.h>
#include <string.h>
/* common */
#include "attrib.h"
#include "check.h"
#include "coll.h"
#include "tgttrans.h"
#include "xmalloc.h"
/* cc65 */
#include "asmlabel.h"
#include "codegen.h"
#include "error.h"
#include "global.h"
#include "litpool.h"
/*****************************************************************************/
/* Data */
/*****************************************************************************/
/* Definition of a literal */
struct Literal {
unsigned Label; /* Asm label for this literal */
int RefCount; /* Reference count */
int Output; /* True if output has been generated */
StrBuf Data; /* Literal data */
};
/* 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
** collection anyway, so the code is prepared for nested functions or
** whatever.
*/
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 = GetPooledLiteralLabel ();
L->RefCount = 0;
L->Output = 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);
}
static void OutputLiteral (Literal* L)
/* Output one literal to the currently active data segment */
{
/* Define the label for the literal */
g_defliterallabel (L->Label);
/* Output the literal data */
g_defbytes (SB_GetConstBuf (&L->Data), SB_GetLen (&L->Data));
/* Mark the literal as output */
L->Output = 1;
}
Literal* UseLiteral (Literal* L)
/* Increase the reference counter for the literal and return it */
{
/* Increase the reference count */
++L->RefCount;
/* Return the literal */
return L;
}
void ReleaseLiteral (Literal* L)
/* Decrement the reference counter for the literal */
{
--L->RefCount;
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 */
/*****************************************************************************/
static LiteralPool* NewLiteralPool (struct SymEntry* Func)
/* Create a new literal pool and return it */
{
/* Allocate memory */
LiteralPool* LP = xmalloc (sizeof (*LP));
/* Initialize the fields */
LP->Func = Func;
InitCollection (&LP->WritableLiterals);
InitCollection (&LP->ReadOnlyLiterals);
/* Return the new pool */
return LP;
}
static void FreeLiteralPool (LiteralPool* LP)
/* Free a LiteralPool structure */
{
/* Free the collections contained within the struct */
DoneCollection (&LP->WritableLiterals);
DoneCollection (&LP->ReadOnlyLiterals);
/* Free the struct itself */
xfree (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 the global literal pool */
GlobalPool = LP = NewLiteralPool (0);
}
void PushLiteralPool (struct SymEntry* Func)
/* Push the current literal pool onto the stack and create a new one */
{
/* We must have a literal pool to push! */
PRECONDITION (LP != 0);
/* Push the old pool */
CollAppend (&LPStack, LP);
/* Create a new one */
LP = NewLiteralPool (Func);
}
LiteralPool* PopLiteralPool (void)
/* Pop the last literal pool from TOS and activate it. Return the old
** literal pool.
*/
{
/* Remember the current literal pool */
LiteralPool* Old = LP;
/* Pop one from stack */
LP = CollPop (&LPStack);
/* Return the old one */
return Old;
}
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 and not output, add it to the Target pool,
** otherwise free it
*/
if (L->RefCount && !L->Output) {
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.
*/
{
/* Move the literals */
MoveLiterals (&LocalPool->WritableLiterals, &GlobalPool->WritableLiterals);
MoveLiterals (&LocalPool->ReadOnlyLiterals, &GlobalPool->ReadOnlyLiterals);
/* Free the local literal pool */
FreeLiteralPool (LocalPool);
}
static void OutputWritableLiterals (Collection* Literals)
/* Output 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 a pointer to the literal */
Literal* L = CollAtUnchecked (Literals, I);
/* Output this one, if it has references and wasn't already output */
if (L->RefCount > 0 && !L->Output) {
OutputLiteral (L);
}
}
}
static void OutputReadOnlyLiterals (Collection* Literals)
/* Output 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 or was already output */
if (L->RefCount == 0 || L->Output) {
continue;
}
/* 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_aliasliterallabel (L->Label, C->Label, GetLiteralSize (C) - GetLiteralSize (L));
} else {
/* Define the label for the literal */
g_defliterallabel (L->Label);
/* Output the literal data */
g_defbytes (SB_GetConstBuf (&L->Data), SB_GetLen (&L->Data));
}
/* Mark the literal */
L->Output = 1;
}
}
void OutputLocalLiteralPool (LiteralPool* Pool)
/* Output the local literal pool */
{
/* Output both sorts of literals */
OutputWritableLiterals (&Pool->WritableLiterals);
OutputReadOnlyLiterals (&Pool->ReadOnlyLiterals);
}
void OutputGlobalLiteralPool (void)
/* Output the global literal pool */
{
OutputLocalLiteralPool (GlobalPool);
}
Literal* AddLiteral (const char* S)
/* Add a literal string to the literal pool. Return the literal. */
{
return AddLiteralBuf (S, strlen (S) + 1);
}
Literal* AddLiteralBuf (const void* Buf, unsigned Len)
/* Add a buffer containing a literal string to the literal pool. Return the
** literal.
*/
{
/* 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;
}
Literal* AddLiteralStr (const StrBuf* S)
/* Add a literal string to the literal pool. Return the literal. */
{
return AddLiteralBuf (SB_GetConstBuf (S), SB_GetLen (S));
}
Reference in New Issue View Git Blame Copy Permalink