/* */
/* */
/* */
-/* (C) 2000 Ullrich von Bassewitz */
-/* Wacholderweg 14 */
-/* D-70597 Stuttgart */
-/* EMail: uz@musoftware.de */
+/* (C) 2000-2003 Ullrich von Bassewitz */
+/* Roemerstrasse 52 */
+/* D-70794 Filderstadt */
+/* EMail: uz@cc65.org */
/* */
/* */
/* This software is provided 'as-is', without any expressed or implied */
-#include "../common/xmalloc.h"
+/* common */
+#include "xmalloc.h"
+#include "xsprintf.h"
+/* cc65 */
#include "anonname.h"
#include "asmlabel.h"
#include "codegen.h"
/*****************************************************************************/
-/* Data */
+/* Code */
/*****************************************************************************/
-/* Register variable management */
-unsigned MaxRegSpace = 6; /* Maximum space available */
-static unsigned RegOffs = 0; /* Offset into register space */
-static const SymEntry** RegSyms = 0; /* The register variables */
-static unsigned RegSymCount = 0; /* Number of register variables */
+static unsigned ParseRegisterDecl (Declaration* Decl, unsigned* SC, int Reg)
+/* Parse the declaration of a register variable. The function returns the
+ * symbol data, which is the offset of the variable in the register bank.
+ */
+{
+ unsigned Flags;
+ unsigned InitLabel;
+ /* Determine if this is a compound variable */
+ int IsCompound = IsClassStruct (Decl->Type) || IsTypeArray (Decl->Type);
+ /* Get the size of the variable */
+ unsigned Size = SizeOf (Decl->Type);
-/*****************************************************************************/
-/* Code */
-/*****************************************************************************/
+ /* Save the current contents of the register variable on stack */
+ F_AllocLocalSpace (CurrentFunc);
+ g_save_regvars (Reg, Size);
+ /* Check for an optional initialization */
+ if (CurTok.Tok == TOK_ASSIGN) {
+ ExprDesc lval;
-void InitRegVars (void)
-/* Initialize register variable control data */
-{
- /* If the register space is zero, bail out */
- if (MaxRegSpace == 0) {
- return;
- }
+ /* Skip the '=' */
+ NextToken ();
- /* The maximum number of register variables is equal to the register
- * variable space available. So allocate one pointer per byte. This
- * will usually waste some space but we don't need to dynamically
- * grow the array.
- */
- RegSyms = xmalloc (MaxRegSpace * sizeof (RegSyms[0]));
- RegOffs = MaxRegSpace;
-}
+ /* Special handling for compound types */
+ if (IsCompound) {
+ /* Switch to read only data */
+ g_userodata ();
+ /* Define a label for the initialization data */
+ InitLabel = GetLocalLabel ();
+ g_defdatalabel (InitLabel);
-void DoneRegVars (void)
-/* Free the register variables */
-{
- xfree (RegSyms);
- RegSyms = 0;
- RegOffs = MaxRegSpace;
- RegSymCount = 0;
-}
+ /* Parse the initialization generating a memory image of the
+ * data in the RODATA segment.
+ */
+ ParseInit (Decl->Type);
+ /* Generate code to copy this data into the variable space */
+ g_initregister (InitLabel, Reg, Size);
+ } else {
-static int AllocRegVar (const SymEntry* Sym, const type* tarray)
-/* Allocate a register variable with the given amount of storage. If the
- * allocation was successful, return the offset of the register variable in
- * the register bank (zero page storage). If there is no register space left,
- * return -1.
- */
-{
- /* Maybe register variables are disabled... */
- if (EnableRegVars) {
-
- /* Get the size of the variable */
- unsigned Size = SizeOf (tarray);
-
- /* Do we have space left? */
- if (RegOffs >= Size) {
-
- /* Space left. We allocate the variables from high to low addresses,
- * so the adressing is compatible with the saved values on stack.
- * This allows shorter code when saving/restoring the variables.
- */
- RegOffs -= Size;
- RegSyms [RegSymCount++] = Sym;
- return RegOffs;
- }
+ /* Setup the type flags for the assignment */
+ Flags = CF_NONE;
+ if (Size == SIZEOF_CHAR) {
+ Flags |= CF_FORCECHAR;
+ }
+
+ /* Get the expression into the primary */
+ if (evalexpr (Flags, hie1, &lval) == 0) {
+ /* Constant expression. Adjust the types */
+ assignadjust (Decl->Type, &lval);
+ Flags |= CF_CONST;
+ /* Load it into the primary */
+ exprhs (Flags, 0, &lval);
+ } else {
+ /* Expression is not constant and in the primary */
+ assignadjust (Decl->Type, &lval);
+ }
+
+ /* Store the value into the variable */
+ Flags |= CF_REGVAR;
+ g_putstatic (Flags | TypeOf (Decl->Type), Reg, 0);
+
+ }
+
+ /* Mark the variable as referenced */
+ *SC |= SC_REF;
}
- /* No space left or no allocation */
- return -1;
+ /* Cannot allocate a variable of zero size */
+ if (Size == 0) {
+ Error ("Variable `%s' has unknown size", Decl->Ident);
+ }
+
+ /* Return the symbol data */
+ return Reg;
}
-static void ParseOneDecl (const DeclSpec* Spec)
-/* Parse one variable declaration */
+static unsigned ParseAutoDecl (Declaration* Decl, unsigned* SC)
+/* Parse the declaration of an auto variable. The function returns the symbol
+ * data, which is the offset for variables on the stack, and the label for
+ * static variables.
+ */
{
- int Size; /* Size of an auto variable */
- int SC; /* Storage class for symbol */
- int SymData = 0; /* Symbol data (offset, label name, ...) */
- unsigned flags = 0; /* Code generator flags */
- Declaration Decl; /* Declaration data structure */
+ unsigned Flags;
+ unsigned SymData;
+ unsigned InitLabel;
- /* Remember the storage class for the new symbol */
- SC = Spec->StorageClass;
+ /* Determine if this is a compound variable */
+ int IsCompound = IsClassStruct (Decl->Type) || IsTypeArray (Decl->Type);
- /* Read the declaration */
- ParseDecl (Spec, &Decl, DM_NEED_IDENT);
+ /* Get the size of the variable */
+ unsigned Size = SizeOf (Decl->Type);
- /* Set the correct storage class for functions */
- if (IsFunc (Decl.Type)) {
- /* Function prototypes are always external */
- if ((SC & SC_EXTERN) == 0) {
- Warning (WARN_FUNC_MUST_BE_EXTERN);
- }
- SC |= SC_FUNC | SC_EXTERN;
+ /* Check if this is a variable on the stack or in static memory */
+ if (StaticLocals == 0) {
- }
+ /* Check for an optional initialization */
+ if (CurTok.Tok == TOK_ASSIGN) {
- /* If we don't have a name, this was flagged as an error earlier.
- * To avoid problems later, use an anonymous name here.
- */
- if (Decl.Ident[0] == '\0') {
- AnonName (Decl.Ident, "param");
- }
+ ExprDesc lval;
- /* Handle anything that needs storage (no functions, no typdefs) */
- if ((SC & SC_FUNC) != SC_FUNC && (SC & SC_TYPEDEF) != SC_TYPEDEF) {
+ /* Skip the '=' */
+ NextToken ();
- /* Get the size of the variable */
- Size = SizeOf (Decl.Type);
+ /* Special handling for compound types */
+ if (IsCompound) {
- if (SC & (SC_AUTO | SC_REGISTER)) {
+ /* First reserve space for the variable */
+ SymData = F_ReserveLocalSpace (CurrentFunc, Size);
- /* Auto variable */
- if (StaticLocals == 0) {
+ /* Next, allocate the space on the stack. This means that the
+ * variable is now located at offset 0 from the current sp.
+ */
+ F_AllocLocalSpace (CurrentFunc);
- /* Change SC in case it was register */
- SC = (SC & ~SC_REGISTER) | SC_AUTO;
- if (curtok == TOK_ASSIGN) {
+ /* Switch to read only data */
+ g_userodata ();
- struct expent lval;
+ /* Define a label for the initialization data */
+ InitLabel = GetLocalLabel ();
+ g_defdatalabel (InitLabel);
- /* Allocate previously reserved local space */
- AllocLocalSpace (CurrentFunc);
+ /* Parse the initialization generating a memory image of the
+ * data in the RODATA segment.
+ */
+ ParseInit (Decl->Type);
- /* Switch to the code segment. */
- g_usecode ();
+ /* Generate code to copy this data into the variable space */
+ g_initauto (InitLabel, Size);
- /* Skip the '=' */
- NextToken ();
+ } else {
- /* Setup the type flags for the assignment */
- flags = Size == 1? CF_FORCECHAR : CF_NONE;
+ /* Allocate previously reserved local space */
+ F_AllocLocalSpace (CurrentFunc);
- /* Get the expression into the primary */
- if (evalexpr (flags, hie1, &lval) == 0) {
- /* Constant expression. Adjust the types */
- assignadjust (Decl.Type, &lval);
- flags |= CF_CONST;
- } else {
- /* Expression is not constant and in the primary */
- assignadjust (Decl.Type, &lval);
- }
+ /* Setup the type flags for the assignment */
+ Flags = (Size == SIZEOF_CHAR)? CF_FORCECHAR : CF_NONE;
- /* Push the value */
- g_push (flags | TypeOf (Decl.Type), lval.e_const);
+ /* Get the expression into the primary */
+ if (evalexpr (Flags, hie1, &lval) == 0) {
+ /* Constant expression. Adjust the types */
+ assignadjust (Decl->Type, &lval);
+ Flags |= CF_CONST;
+ } else {
+ /* Expression is not constant and in the primary */
+ assignadjust (Decl->Type, &lval);
+ }
- /* Mark the variable as referenced */
- SC |= SC_REF;
+ /* Push the value */
+ g_push (Flags | TypeOf (Decl->Type), lval.ConstVal);
- /* Variable is located at the current SP */
- SymData = oursp;
+ }
- } else {
- /* Non-initialized local variable. Just keep track of
- * the space needed.
- */
- SymData = ReserveLocalSpace (CurrentFunc, Size);
- }
+ /* Mark the variable as referenced */
+ *SC |= SC_REF;
- } else {
+ /* Variable is located at the current SP */
+ SymData = oursp;
- /* Static local variables. */
- SC = (SC & ~(SC_REGISTER | SC_AUTO)) | SC_STATIC;
+ } else {
+ /* Non-initialized local variable. Just keep track of
+ * the space needed.
+ */
+ SymData = F_ReserveLocalSpace (CurrentFunc, Size);
+ }
- /* Put them into the BSS */
- g_usebss ();
+ } else {
- /* Define the variable label */
- SymData = GetLabel ();
- g_defloclabel (SymData);
+ /* Static local variables. */
+ *SC = (*SC & ~SC_AUTO) | SC_STATIC;
- /* Reserve space for the data */
- g_res (Size);
+ /* Put them into the BSS */
+ g_usebss ();
- /* Allow assignments */
- if (curtok == TOK_ASSIGN) {
+ /* Define the variable label */
+ SymData = GetLocalLabel ();
+ g_defdatalabel (SymData);
- struct expent lval;
+ /* Reserve space for the data */
+ g_res (Size);
- /* Switch to the code segment. */
- g_usecode ();
+ /* Allow assignments */
+ if (CurTok.Tok == TOK_ASSIGN) {
- /* Skip the '=' */
- NextToken ();
+ ExprDesc lval;
- /* Get the expression into the primary */
- expression1 (&lval);
+ /* Skip the '=' */
+ NextToken ();
- /* Make type adjustments if needed */
- assignadjust (Decl.Type, &lval);
+ if (IsCompound) {
- /* Setup the type flags for the assignment */
- flags = TypeOf (Decl.Type);
- if (Size == 1) {
- flags |= CF_FORCECHAR;
- }
+ /* Switch to read only data */
+ g_userodata ();
- /* Store the value into the variable */
- g_putstatic (flags, SymData, 0);
+ /* Define a label for the initialization data */
+ InitLabel = GetLocalLabel ();
+ g_defdatalabel (InitLabel);
- /* Mark the variable as referenced */
- SC |= SC_REF;
- }
- }
+ /* Parse the initialization generating a memory image of the
+ * data in the RODATA segment.
+ */
+ ParseInit (Decl->Type);
- } else if ((SC & SC_STATIC) == SC_STATIC) {
+ /* Generate code to copy this data into the variable space */
+ g_initstatic (InitLabel, SymData, Size);
- /* Static data */
- if (curtok == TOK_ASSIGN) {
+ } else {
- /* Initialization ahead, switch to data segment */
- g_usedata ();
+ /* Setup the type flags for the assignment */
+ Flags = (Size == SIZEOF_CHAR)? CF_FORCECHAR : CF_NONE;
- /* Define the variable label */
- SymData = GetLabel ();
- g_defloclabel (SymData);
+ /* Get the expression into the primary */
+ if (evalexpr (Flags, hie1, &lval) == 0) {
+ /* Constant expression. Adjust the types */
+ assignadjust (Decl->Type, &lval);
+ Flags |= CF_CONST;
+ /* Load it into the primary */
+ exprhs (Flags, 0, &lval);
+ } else {
+ /* Expression is not constant and in the primary */
+ assignadjust (Decl->Type, &lval);
+ }
- /* Skip the '=' */
- NextToken ();
+ /* Store the value into the variable */
+ g_putstatic (Flags | TypeOf (Decl->Type), SymData, 0);
- /* Allow initialization of static vars */
- ParseInit (Decl.Type);
+ }
- /* Mark the variable as referenced */
- SC |= SC_REF;
+ /* Mark the variable as referenced */
+ *SC |= SC_REF;
+ }
+ }
- } else {
+ /* Cannot allocate a variable of zero size */
+ if (Size == 0) {
+ Error ("Variable `%s' has unknown size", Decl->Ident);
+ }
- /* Uninitialized data, use BSS segment */
- g_usebss ();
+ /* Return the symbol data */
+ return SymData;
+}
- /* Define the variable label */
- SymData = GetLabel ();
- g_defloclabel (SymData);
- /* Reserve space for the data */
- g_res (Size);
- }
- }
+static unsigned ParseStaticDecl (Declaration* Decl, unsigned* SC)
+/* Parse the declaration of a static variable. The function returns the symbol
+ * data, which is the asm label of the variable.
+ */
+{
+ unsigned SymData;
+
+ /* Get the size of the variable */
+ unsigned Size = SizeOf (Decl->Type);
+
+ /* Static data */
+ if (CurTok.Tok == TOK_ASSIGN) {
+
+ /* Initialization ahead, switch to data segment */
+ if (IsQualConst (Decl->Type)) {
+ g_userodata ();
+ } else {
+ g_usedata ();
+ }
+
+ /* Define the variable label */
+ SymData = GetLocalLabel ();
+ g_defdatalabel (SymData);
+
+ /* Skip the '=' */
+ NextToken ();
+
+ /* Allow initialization of static vars */
+ ParseInit (Decl->Type);
+
+ /* If the previous size has been unknown, it must be known now */
+ if (Size == 0) {
+ Size = SizeOf (Decl->Type);
+ }
+
+ /* Mark the variable as referenced */
+ *SC |= SC_REF;
+
+ } else {
+
+ /* Uninitialized data, use BSS segment */
+ g_usebss ();
+ /* Define the variable label */
+ SymData = GetLocalLabel ();
+ g_defdatalabel (SymData);
+
+ /* Reserve space for the data */
+ g_res (Size);
+
+ }
+
+ /* Cannot allocate a variable of zero size */
+ if (Size == 0) {
+ Error ("Variable `%s' has unknown size", Decl->Ident);
+ }
+
+ /* Return the symbol data */
+ return SymData;
+}
+
+
+
+static void ParseOneDecl (const DeclSpec* Spec)
+/* Parse one variable declaration */
+{
+ unsigned SC; /* Storage class for symbol */
+ unsigned SymData = 0; /* Symbol data (offset, label name, ...) */
+ Declaration Decl; /* Declaration data structure */
+
+
+ /* Remember the storage class for the new symbol */
+ SC = Spec->StorageClass;
+
+ /* Read the declaration */
+ ParseDecl (Spec, &Decl, DM_NEED_IDENT);
+
+ /* Set the correct storage class for functions */
+ if (IsTypeFunc (Decl.Type)) {
+ /* Function prototypes are always external */
+ if ((SC & SC_EXTERN) == 0) {
+ Warning ("Function must be extern");
+ }
+ SC |= SC_FUNC | SC_EXTERN;
+
+ }
+
+ /* If we don't have a name, this was flagged as an error earlier.
+ * To avoid problems later, use an anonymous name here.
+ */
+ if (Decl.Ident[0] == '\0') {
+ AnonName (Decl.Ident, "param");
}
- /* If the symbol is not marked as external, it will be defined */
+ /* Handle anything that needs storage (no functions, no typdefs) */
+ if ((SC & SC_FUNC) != SC_FUNC && (SC & SC_TYPEDEF) != SC_TYPEDEF) {
+
+ /* If we have a register variable, try to allocate a register and
+ * convert the declaration to "auto" if this is not possible.
+ */
+ int Reg = 0; /* Initialize to avoid gcc complains */
+ if ((SC & SC_REGISTER) != 0 && (Reg = F_AllocRegVar (CurrentFunc, Decl.Type)) < 0) {
+ /* No space for this register variable, convert to auto */
+ SC = (SC & ~SC_REGISTER) | SC_AUTO;
+ }
+
+ /* Check the variable type */
+ if ((SC & SC_REGISTER) == SC_REGISTER) {
+ /* Register variable */
+ SymData = ParseRegisterDecl (&Decl, &SC, Reg);
+ } else if ((SC & SC_AUTO) == SC_AUTO) {
+ /* Auto variable */
+ SymData = ParseAutoDecl (&Decl, &SC);
+ } else if ((SC & SC_STATIC) == SC_STATIC) {
+ /* Static variable */
+ SymData = ParseStaticDecl (&Decl, &SC);
+ } else {
+ Internal ("Invalid storage class in ParseOneDecl: %04X", SC);
+ }
+ }
+
+ /* If the symbol is not marked as external, it will be defined now */
if ((SC & SC_EXTERN) == 0) {
- SC |= SC_DEF;
+ SC |= SC_DEF;
}
/* Add the symbol to the symbol table */
void DeclareLocals (void)
/* Declare local variables and types. */
{
+ /* Remember the current stack pointer */
+ int InitialStack = oursp;
+
/* Loop until we don't find any more variables */
while (1) {
/* Check variable declarations. We need to distinguish between a
- * default int type and the end of variable declarations. So we
+ * default int type and the end of variable declarations. So we
* will do the following: If there is no explicit storage class
- * specifier *and* no explicit type given, it is assume that we
- * have reached the end of declarations.
+ * specifier *and* no explicit type given, *and* no type qualifiers
+ * have been read, it is assumed that we have reached the end of
+ * declarations.
*/
DeclSpec Spec;
ParseDeclSpec (&Spec, SC_AUTO, T_INT);
- if ((Spec.Flags & DS_DEF_STORAGE) != 0 && (Spec.Flags & DS_DEF_TYPE) != 0) {
+ if ((Spec.Flags & DS_DEF_STORAGE) != 0 && /* No storage spec */
+ (Spec.Flags & DS_DEF_TYPE) != 0 && /* No type given */
+ GetQualifier (Spec.Type) == T_QUAL_NONE) { /* No type qualifier */
break;
}
/* Accept type only declarations */
- if (curtok == TOK_SEMI) {
+ if (CurTok.Tok == TOK_SEMI) {
/* Type declaration only */
CheckEmptyDecl (&Spec);
NextToken ();
ParseOneDecl (&Spec);
/* Check if there is more */
- if (curtok == TOK_COMMA) {
+ if (CurTok.Tok == TOK_COMMA) {
/* More to come */
NextToken ();
} else {
}
/* Be sure to allocate any reserved space for locals */
- AllocLocalSpace (CurrentFunc);
-
- /* In case we switched away from code segment, switch back now */
- g_usecode ();
-}
-
-
-
-void RestoreRegVars (int HaveResult)
-/* Restore the register variables for the local function if there are any.
- * The parameter tells us if there is a return value in ax, in that case,
- * the accumulator must be saved across the restore.
- */
-{
- unsigned I, J;
- int Bytes, Offs;
-
- /* If we don't have register variables in this function, bail out early */
- if (RegSymCount == 0) {
- return;
- }
+ F_AllocLocalSpace (CurrentFunc);
- /* Save the accumulator if needed */
- if (!HasVoidReturn (CurrentFunc) && HaveResult) {
- g_save (CF_CHAR | CF_FORCECHAR);
- }
-
- /* Walk through all variables. If there are several variables in a row
- * (that is, with increasing stack offset), restore them in one chunk.
+ /* In case we've allocated local variables in this block, emit a call to
+ * the stack checking routine if stack checks are enabled.
*/
- I = 0;
- while (I < RegSymCount) {
-
- /* Check for more than one variable */
- const SymEntry* Sym = RegSyms[I];
- Offs = Sym->V.Offs;
- Bytes = SizeOf (Sym->Type);
- J = I+1;
-
- while (J < RegSymCount) {
-
- /* Get the next symbol */
- const SymEntry* NextSym = RegSyms [J];
-
- /* Get the size */
- int Size = SizeOf (NextSym->Type);
-
- /* Adjacent variable? */
- if (NextSym->V.Offs + Size != Offs) {
- /* No */
- break;
- }
-
- /* Adjacent variable */
- Bytes += Size;
- Offs -= Size;
- Sym = NextSym;
- ++J;
- }
-
- /* Restore the memory range */
- g_restore_regvars (Offs, Sym->V.Offs, Bytes);
-
- /* Next round */
- I = J;
- }
-
- /* Restore the accumulator if needed */
- if (!HasVoidReturn (CurrentFunc) && HaveResult) {
- g_restore (CF_CHAR | CF_FORCECHAR);
+ if (CheckStack && InitialStack != oursp) {
+ g_cstackcheck ();
}
}