/* */
/* */
/* */
-/* (C) 2000-2001 Ullrich von Bassewitz */
-/* Wacholderweg 14 */
-/* D-70597 Stuttgart */
+/* (C) 2000-2006 Ullrich von Bassewitz */
+/* Römerstrasse 52 */
+/* D-70794 Filderstadt */
/* EMail: uz@cc65.org */
/* */
/* */
#include "locals.h"
#include "scanner.h"
#include "segments.h"
+#include "stackptr.h"
+#include "standard.h"
#include "stmt.h"
#include "symtab.h"
#include "function.h"
/* Structure that holds all data needed for function activation */
struct Function {
- struct SymEntry* FuncEntry; /* Symbol table entry */
- type* ReturnType; /* Function return type */
- struct FuncDesc* Desc; /* Function descriptor */
- int Reserved; /* Reserved local space */
+ struct SymEntry* FuncEntry; /* Symbol table entry */
+ Type* ReturnType; /* Function return type */
+ struct FuncDesc* Desc; /* Function descriptor */
+ int Reserved; /* Reserved local space */
unsigned RetLab; /* Return code label */
int TopLevelSP; /* SP at function top level */
+ unsigned RegOffs; /* Register variable space offset */
};
/* Pointer to current function */
/* Initialize the fields */
F->FuncEntry = Sym;
F->ReturnType = GetFuncReturn (Sym->Type);
- F->Desc = (FuncDesc*) DecodePtr (Sym->Type + 1);
+ F->Desc = GetFuncDesc (Sym->Type);
F->Reserved = 0;
F->RetLab = GetLocalLabel ();
F->TopLevelSP = 0;
+ F->RegOffs = RegisterSpace;
/* Return the new structure */
return F;
-const char* GetFuncName (const Function* F)
+const char* F_GetFuncName (const Function* F)
/* Return the name of the current function */
{
return F->FuncEntry->Name;
-unsigned GetParamCount (const Function* F)
+unsigned F_GetParamCount (const Function* F)
/* Return the parameter count for the current function */
{
return F->Desc->ParamCount;
-unsigned GetParamSize (const Function* F)
+unsigned F_GetParamSize (const Function* F)
/* Return the parameter size for the current function */
{
return F->Desc->ParamSize;
-type* GetReturnType (Function* F)
+Type* F_GetReturnType (Function* F)
/* Get the return type for the function */
{
return F->ReturnType;
-int HasVoidReturn (const Function* F)
+int F_HasVoidReturn (const Function* F)
/* Return true if the function does not have a return value */
{
return IsTypeVoid (F->ReturnType);
-int IsVariadic (const Function* F)
+int F_IsVariadic (const Function* F)
/* Return true if this is a variadic function */
{
return (F->Desc->Flags & FD_VARIADIC) != 0;
-unsigned GetRetLab (const Function* F)
+int F_IsOldStyle (const Function* F)
+/* Return true if this is an old style (K&R) function */
+{
+ return (F->Desc->Flags & FD_OLDSTYLE) != 0;
+}
+
+
+
+int F_HasOldStyleIntRet (const Function* F)
+/* Return true if this is an old style (K&R) function with an implicit int return */
+{
+ return (F->Desc->Flags & FD_OLDSTYLE_INTRET) != 0;
+}
+
+
+
+unsigned F_GetRetLab (const Function* F)
/* Return the return jump label */
{
return F->RetLab;
-int GetTopLevelSP (const Function* F)
+int F_GetTopLevelSP (const Function* F)
/* Get the value of the stack pointer on function top level */
{
return F->TopLevelSP;
-int ReserveLocalSpace (Function* F, unsigned Size)
+int F_ReserveLocalSpace (Function* F, unsigned Size)
/* Reserve (but don't allocate) the given local space and return the stack
* offset.
*/
{
F->Reserved += Size;
- return oursp - F->Reserved;
+ return StackPtr - F->Reserved;
}
-void AllocLocalSpace (Function* F)
+void F_AllocLocalSpace (Function* F)
/* Allocate any local space previously reserved. The function will do
* nothing if there is no reserved local space.
*/
{
if (F->Reserved > 0) {
- /* Create space on the stack */
- g_space (F->Reserved);
+ /* Create space on the stack */
+ g_space (F->Reserved);
+
+ /* Correct the stack pointer */
+ StackPtr -= F->Reserved;
+
+ /* Nothing more reserved */
+ F->Reserved = 0;
+ }
+}
+
+
+
+int F_AllocRegVar (Function* F, const Type* Type)
+/* Allocate a register variable for the given variable type. 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.
+ */
+{
+ /* Allow register variables only on top level and if enabled */
+ if (IS_Get (&EnableRegVars) && GetLexicalLevel () == LEX_LEVEL_FUNCTION) {
+
+ /* Get the size of the variable */
+ unsigned Size = CheckedSizeOf (Type);
+
+ /* Do we have space left? */
+ if (F->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.
+ */
+ F->RegOffs -= Size;
+ return F->RegOffs;
+ }
+ }
+
+ /* No space left or no allocation */
+ return -1;
+}
+
+
+
+static void F_RestoreRegVars (Function* F)
+/* Restore the register variables for the local function if there are any. */
+{
+ const SymEntry* Sym;
+
+ /* If we don't have register variables in this function, bail out early */
+ if (F->RegOffs == RegisterSpace) {
+ return;
+ }
+
+ /* Save the accumulator if needed */
+ if (!F_HasVoidReturn (F)) {
+ g_save (CF_CHAR | CF_FORCECHAR);
+ }
+
+ /* Get the first symbol from the function symbol table */
+ Sym = F->FuncEntry->V.F.Func->SymTab->SymHead;
+
+ /* Walk through all symbols checking for register variables */
+ while (Sym) {
+ if (SymIsRegVar (Sym)) {
+
+ /* Check for more than one variable */
+ int Offs = Sym->V.R.SaveOffs;
+ unsigned Bytes = CheckedSizeOf (Sym->Type);
+
+ while (1) {
+
+ /* Find next register variable */
+ const SymEntry* NextSym = Sym->NextSym;
+ while (NextSym && !SymIsRegVar (NextSym)) {
+ NextSym = NextSym->NextSym;
+ }
- /* Correct the stack pointer */
- oursp -= F->Reserved;
+ /* If we have a next one, compare the stack offsets */
+ if (NextSym) {
- /* Nothing more reserved */
- F->Reserved = 0;
+ /* We have a following register variable. Get the size */
+ int Size = CheckedSizeOf (NextSym->Type);
+
+ /* Adjacent variable? */
+ if (NextSym->V.R.SaveOffs + Size != Offs) {
+ /* No */
+ break;
+ }
+
+ /* Adjacent variable */
+ Bytes += Size;
+ Offs -= Size;
+ Sym = NextSym;
+
+ } else {
+ break;
+ }
+ }
+
+ /* Restore the memory range */
+ g_restore_regvars (Offs, Sym->V.R.RegOffs, Bytes);
+
+ }
+
+ /* Check next symbol */
+ Sym = Sym->NextSym;
+ }
+
+ /* Restore the accumulator if needed */
+ if (!F_HasVoidReturn (F)) {
+ g_restore (CF_CHAR | CF_FORCECHAR);
}
}
/* Parse argument declarations and function body. */
{
int HadReturn;
- int IsVoidFunc;
- unsigned Flags;
+ SymEntry* Param;
/* Get the function descriptor from the function entry */
FuncDesc* D = Func->V.F.Func;
*/
AddConstSym ("__fixargs__", type_uint, SC_DEF | SC_CONST, D->ParamSize);
if (D->Flags & FD_VARIADIC) {
- /* Variadic function. The variable must be const. */
- static const type T [] = { T_UCHAR | T_QUAL_CONST, T_END };
- AddLocalSym ("__argsize__", T, SC_DEF | SC_REF | SC_AUTO, 0);
+ /* Variadic function. The variable must be const. */
+ static const Type T[] = { TYPE(T_UCHAR | T_QUAL_CONST), TYPE(T_END) };
+ AddLocalSym ("__argsize__", T, SC_DEF | SC_REF | SC_AUTO, 0);
} else {
- /* Non variadic */
+ /* Non variadic */
AddConstSym ("__argsize__", type_uchar, SC_DEF | SC_CONST, D->ParamSize);
}
/* Function body now defined */
Func->Flags |= SC_DEF;
- /* Setup register variables */
- InitRegVars ();
-
/* Allocate code and data segments for this function */
Func->V.F.Seg = PushSegments (Func);
+ /* Special handling for main() */
+ if (strcmp (Func->Name, "main") == 0) {
+ /* Main cannot be a fastcall function */
+ if (IsFastCallFunc (Func->Type)) {
+ Error ("`main' cannot be declared as __fastcall__");
+ }
+
+ /* If cc65 extensions aren't enabled, don't allow a main function that
+ * doesn't return an int.
+ */
+ if (IS_Get (&Standard) != STD_CC65 && CurrentFunc->ReturnType[0].C != T_INT) {
+ Error ("`main' must always return an int");
+ }
+
+ /* If main() takes parameters, generate a forced import to a function
+ * that will setup these parameters. This way, programs that do not
+ * need the additional code will not get it.
+ */
+ if (D->ParamCount > 0 || (D->Flags & FD_VARIADIC) != 0) {
+ g_importmainargs ();
+ }
+ }
+
/* If this is a fastcall function, push the last parameter onto the stack */
if (IsFastCallFunc (Func->Type) && D->ParamCount > 0) {
- SymEntry* LastParam;
- unsigned Flags;
-
- /* Fastcall functions may never have an ellipsis or the compiler is buggy */
- CHECK ((D->Flags & FD_VARIADIC) == 0);
+ unsigned Flags;
- /* Get a pointer to the last parameter entry */
- LastParam = D->SymTab->SymTail;
+ /* Fastcall functions may never have an ellipsis or the compiler is buggy */
+ CHECK ((D->Flags & FD_VARIADIC) == 0);
- /* Generate the push */
- if (IsTypeFunc (LastParam->Type)) {
+ /* Generate the push */
+ if (IsTypeFunc (D->LastParam->Type)) {
/* Pointer to function */
Flags = CF_PTR;
} else {
- Flags = TypeOf (LastParam->Type) | CF_FORCECHAR;
+ Flags = TypeOf (D->LastParam->Type) | CF_FORCECHAR;
}
g_push (Flags, 0);
}
+ /* Generate function entry code if needed */
+ g_enter (TypeOf (Func->Type), F_GetParamSize (CurrentFunc));
+
/* If stack checking code is requested, emit a call to the helper routine */
- if (CheckStack) {
- g_stackcheck ();
+ if (IS_Get (&CheckStack)) {
+ g_stackcheck ();
}
- /* Generate function entry code if needed */
- g_enter (TypeOf (Func->Type), GetParamSize (CurrentFunc));
-
/* Setup the stack */
- oursp = 0;
+ StackPtr = 0;
+
+ /* Walk through the parameter list and allocate register variable space
+ * for parameters declared as register. Generate code to swap the contents
+ * of the register bank with the save area on the stack.
+ */
+ Param = D->SymTab->SymHead;
+ while (Param && (Param->Flags & SC_PARAM) != 0) {
+
+ /* Check for a register variable */
+ if (SymIsRegVar (Param)) {
+
+ /* Allocate space */
+ int Reg = F_AllocRegVar (CurrentFunc, Param->Type);
+
+ /* Could we allocate a register? */
+ if (Reg < 0) {
+ /* No register available: Convert parameter to auto */
+ CvtRegVarToAuto (Param);
+ } else {
+ /* Remember the register offset */
+ Param->V.R.RegOffs = Reg;
+
+ /* Generate swap code */
+ g_swap_regvars (Param->V.R.SaveOffs, Reg, CheckedSizeOf (Param->Type));
+
+ }
+ }
+
+ /* Next parameter */
+ Param = Param->NextSym;
+ }
/* Need a starting curly brace */
ConsumeLCurly ();
/* Remember the current stack pointer. All variables allocated elsewhere
* must be dropped when doing a return from an inner block.
*/
- CurrentFunc->TopLevelSP = oursp;
+ CurrentFunc->TopLevelSP = StackPtr;
/* Now process statements in this block */
HadReturn = 0;
- while (curtok != TOK_RCURLY) {
- if (curtok != TOK_CEOF) {
- HadReturn = Statement ();
+ while (CurTok.Tok != TOK_RCURLY) {
+ if (CurTok.Tok != TOK_CEOF) {
+ HadReturn = Statement (0);
} else {
break;
}
}
- /* If the function has a return type but no return statement, flag
- * a warning
- */
- IsVoidFunc = HasVoidReturn (CurrentFunc);
-#if 0
- /* Does not work reliably */
- if (!IsVoidFunc && !HadReturn) {
- Warning ("Function `%s' should return a value", Func->Name);
- }
-#endif
-
/* Output the function exit code label */
- g_defcodelabel (GetRetLab (CurrentFunc));
+ g_defcodelabel (F_GetRetLab (CurrentFunc));
/* Restore the register variables */
- RestoreRegVars (!IsVoidFunc);
+ F_RestoreRegVars (CurrentFunc);
/* Generate the exit code */
- Flags = IsVoidFunc? CF_NONE : CF_REG;
- g_leave (Flags, 0);
-
- /* Eat the closing brace */
- ConsumeRCurly ();
+ g_leave ();
/* Emit references to imports/exports */
EmitExternals ();
- /* Cleanup register variables */
- DoneRegVars ();
-
/* Leave the lexical level */
LeaveFunctionLevel ();
+ /* Eat the closing brace */
+ ConsumeRCurly ();
+
/* Switch back to the old segments */
- PopSegments ();
+ PopSegments ();
/* Reset the current function pointer */
FreeFunction (CurrentFunc);