From: cuz Date: Sat, 24 Mar 2001 13:00:16 +0000 (+0000) Subject: Inline parameter frame building X-Git-Tag: V2.12.0~2901 X-Git-Url: https://git.sur5r.net/?a=commitdiff_plain;h=c18453ebcb1ecd80cdde83fb08c61534cac47e48;p=cc65 Inline parameter frame building git-svn-id: svn://svn.cc65.org/cc65/trunk@661 b7a2c559-68d2-44c3-8de9-860c34a00d81 --- diff --git a/src/cc65/codegen.c b/src/cc65/codegen.c index 416be40da..97c5c1fce 100644 --- a/src/cc65/codegen.c +++ b/src/cc65/codegen.c @@ -652,63 +652,63 @@ void g_getimmed (unsigned flags, unsigned long val, unsigned offs) { if ((flags & CF_CONST) != 0) { - /* Numeric constant */ - switch (flags & CF_TYPE) { + /* Numeric constant */ + switch (flags & CF_TYPE) { - case CF_CHAR: - if ((flags & CF_FORCECHAR) != 0) { - ldaconst (val); - break; - } - /* FALL THROUGH */ - case CF_INT: - ldxconst ((val >> 8) & 0xFF); - ldaconst (val & 0xFF); - break; + case CF_CHAR: + if ((flags & CF_FORCECHAR) != 0) { + ldaconst (val); + break; + } + /* FALL THROUGH */ + case CF_INT: + ldxconst ((val >> 8) & 0xFF); + ldaconst (val & 0xFF); + break; - case CF_LONG: - if (val < 0x100) { - AddCodeLine ("\tldx\t#$00"); - AddCodeLine ("\tstx\tsreg+1"); - AddCodeLine ("\tstx\tsreg"); - AddCodeLine ("\tlda\t#$%02X", (unsigned char) val); - } else if ((val & 0xFFFF00FF) == 0) { - AddCodeLine ("\tlda\t#$00"); - AddCodeLine ("\tsta\tsreg+1"); - AddCodeLine ("\tsta\tsreg"); - AddCodeLine ("\tldx\t#$%02X", (unsigned char) (val >> 8)); - } else if ((val & 0xFFFF0000) == 0 && FavourSize == 0) { - AddCodeLine ("\tlda\t#$00"); - AddCodeLine ("\tsta\tsreg+1"); - AddCodeLine ("\tsta\tsreg"); - AddCodeLine ("\tlda\t#$%02X", (unsigned char) val); - AddCodeLine ("\tldx\t#$%02X", (unsigned char) (val >> 8)); - } else if ((val & 0xFFFFFF00) == 0xFFFFFF00) { - AddCodeLine ("\tldx\t#$FF"); - AddCodeLine ("\tstx\tsreg+1"); - AddCodeLine ("\tstx\tsreg"); - if ((val & 0xFF) == 0xFF) { - AddCodeLine ("\ttxa"); - } else { - AddCodeLine ("\tlda\t#$%02X", (unsigned char) val); - } - } else if ((val & 0xFFFF00FF) == 0xFFFF00FF) { - AddCodeLine ("\tlda\t#$FF"); - AddCodeLine ("\tsta\tsreg+1"); - AddCodeLine ("\tsta\tsreg"); - AddCodeLine ("\tldx\t#$%02X", (unsigned char) (val >> 8)); - } else { - /* Call a subroutine that will load following value */ - AddCodeLine ("\tjsr\tldeax"); - AddCodeLine ("\t.dword\t$%08lX", val & 0xFFFFFFFF); - } - break; + case CF_LONG: + if (val < 0x100) { + AddCodeLine ("\tldx\t#$00"); + AddCodeLine ("\tstx\tsreg+1"); + AddCodeLine ("\tstx\tsreg"); + AddCodeLine ("\tlda\t#$%02X", (unsigned char) val); + } else if ((val & 0xFFFF00FF) == 0) { + AddCodeLine ("\tlda\t#$00"); + AddCodeLine ("\tsta\tsreg+1"); + AddCodeLine ("\tsta\tsreg"); + AddCodeLine ("\tldx\t#$%02X", (unsigned char) (val >> 8)); + } else if ((val & 0xFFFF0000) == 0 && FavourSize == 0) { + AddCodeLine ("\tlda\t#$00"); + AddCodeLine ("\tsta\tsreg+1"); + AddCodeLine ("\tsta\tsreg"); + AddCodeLine ("\tlda\t#$%02X", (unsigned char) val); + AddCodeLine ("\tldx\t#$%02X", (unsigned char) (val >> 8)); + } else if ((val & 0xFFFFFF00) == 0xFFFFFF00) { + AddCodeLine ("\tldx\t#$FF"); + AddCodeLine ("\tstx\tsreg+1"); + AddCodeLine ("\tstx\tsreg"); + if ((val & 0xFF) == 0xFF) { + AddCodeLine ("\ttxa"); + } else { + AddCodeLine ("\tlda\t#$%02X", (unsigned char) val); + } + } else if ((val & 0xFFFF00FF) == 0xFFFF00FF) { + AddCodeLine ("\tlda\t#$FF"); + AddCodeLine ("\tsta\tsreg+1"); + AddCodeLine ("\tsta\tsreg"); + AddCodeLine ("\tldx\t#$%02X", (unsigned char) (val >> 8)); + } else { + /* Call a subroutine that will load following value */ + AddCodeLine ("\tjsr\tldeax"); + AddCodeLine ("\t.dword\t$%08lX", val & 0xFFFFFFFF); + } + break; - default: - typeerror (flags); - break; + default: + typeerror (flags); + break; - } + } } else { @@ -1084,34 +1084,79 @@ void g_putstatic (unsigned flags, unsigned long label, unsigned offs) -void g_putlocal (unsigned flags, int offs) +void g_putlocal (unsigned Flags, int Offs, long Val) /* Put data into local object. */ { - offs -= oursp; - CheckLocalOffs (offs); - switch (flags & CF_TYPE) { + Offs -= oursp; + CheckLocalOffs (Offs); + switch (Flags & CF_TYPE) { case CF_CHAR: - if (CPU == CPU_65C02 && offs == 0) { - AddCodeLine ("\tsta\t(sp)"); - } else { - ldyconst (offs); - AddCodeLine ("\tsta\t(sp),y"); + if (Flags & CF_CONST) { + AddCodeLine ("\tlda\t#$%02X", (unsigned char) Val); } + if (CPU == CPU_65C02 && Offs == 0) { + AddCodeLine ("\tsta\t(sp)"); + } else { + ldyconst (Offs); + AddCodeLine ("\tsta\t(sp),y"); + } break; case CF_INT: - if (offs) { - ldyconst (offs); - AddCodeLine ("\tjsr\tstaxysp"); - } else { - AddCodeLine ("\tjsr\tstax0sp"); - } + if (Flags & CF_CONST) { + ldyconst (Offs+1); + AddCodeLine ("\tlda\t#$%02X", (unsigned char) (Val >> 8)); + AddCodeLine ("\tsta\t(sp),y"); + if ((Flags & CF_NOKEEP) == 0) { + /* Place high byte into X */ + AddCodeLine ("\ttax"); + } + if (CPU == CPU_65C02 && Offs == 0) { + AddCodeLine ("\tlda\t#$%02X", (unsigned char) Val); + AddCodeLine ("\tsta\t(sp)"); + } else { + if ((Val & 0xFF) == Offs+1) { + /* The value we need is already in Y */ + AddCodeLine ("\ttya"); + AddCodeLine ("\tdey"); + } else { + AddCodeLine ("\tdey"); + AddCodeLine ("\tlda\t#$%02X", (unsigned char) Val); + } + AddCodeLine ("\tsta\t(sp),y"); + } + } else { + if ((Flags & CF_NOKEEP) == 0 || FavourSize) { + if (Offs) { + ldyconst (Offs); + AddCodeLine ("\tjsr\tstaxysp"); + } else { + AddCodeLine ("\tjsr\tstax0sp"); + } + } else { + if (CPU == CPU_65C02 && Offs == 0) { + AddCodeLine ("\tsta\t(sp)"); + ldyconst (1); + AddCodeLine ("\ttxa"); + AddCodeLine ("\tsta\t(sp),y"); + } else { + ldyconst (Offs); + AddCodeLine ("\tsta\t(sp),y"); + AddCodeLine ("\tiny"); + AddCodeLine ("\ttxa"); + AddCodeLine ("\tsta\t(sp),y"); + } + } + } break; case CF_LONG: - if (offs) { - ldyconst (offs); + if (Flags & CF_CONST) { + g_getimmed (Flags, Val, 0); + } + if (Offs) { + ldyconst (Offs); AddCodeLine ("\tjsr\tsteaxysp"); } else { AddCodeLine ("\tjsr\tsteax0sp"); @@ -1119,7 +1164,7 @@ void g_putlocal (unsigned flags, int offs) break; default: - typeerror (flags); + typeerror (Flags); } } @@ -2461,44 +2506,44 @@ void g_swap (unsigned flags) -void g_call (unsigned flags, char* lbl, unsigned argsize) +void g_call (unsigned Flags, const char* Label, unsigned ArgSize) /* Call the specified subroutine name */ { - if ((flags & CF_FIXARGC) == 0) { - /* Pass arg count */ - ldyconst (argsize); + if ((Flags & CF_FIXARGC) == 0) { + /* Pass the argument count */ + ldyconst (ArgSize); } - AddCodeLine ("\tjsr\t_%s", lbl); - oursp += argsize; /* callee pops args */ + AddCodeLine ("\tjsr\t_%s", Label); + oursp += ArgSize; /* callee pops args */ } -void g_callind (unsigned flags, unsigned argsize) +void g_callind (unsigned Flags, unsigned ArgSize) /* Call subroutine with address in AX */ { - if ((flags & CF_FIXARGC) == 0) { + if ((Flags & CF_FIXARGC) == 0) { /* Pass arg count */ - ldyconst (argsize); + ldyconst (ArgSize); } AddCodeLine ("\tjsr\tcallax"); /* do the call */ - oursp += argsize; /* callee pops args */ + oursp += ArgSize; /* callee pops args */ } -void g_jump (unsigned label) +void g_jump (unsigned Label) /* Jump to specified internal label number */ { - AddCodeLine ("\tjmp\tL%04X", label); + AddCodeLine ("\tjmp\tL%04X", Label); } -void g_switch (unsigned flags) -/* Output switch statement preample */ +void g_switch (unsigned Flags) +/* Output switch statement preamble */ { - switch (flags & CF_TYPE) { + switch (Flags & CF_TYPE) { case CF_CHAR: case CF_INT: @@ -2510,7 +2555,7 @@ void g_switch (unsigned flags) break; default: - typeerror (flags); + typeerror (Flags); } } diff --git a/src/cc65/codegen.h b/src/cc65/codegen.h index 94b19c1c9..be2a5742f 100644 --- a/src/cc65/codegen.h +++ b/src/cc65/codegen.h @@ -50,12 +50,14 @@ */ #define CF_NONE 0x0000 /* No special flags */ -#define CF_TYPE 0x000F /* Mask for operand type */ +#define CF_TYPE 0x0007 /* Mask for operand type */ #define CF_CHAR 0x0003 /* Operation on characters */ #define CF_INT 0x0001 /* Operation on ints */ #define CF_PTR CF_INT /* Alias for readability */ #define CF_LONG 0x0000 /* Operation on longs */ +#define CF_NOKEEP 0x0008 /* Value may get destroyed when storing */ + #define CF_UNSIGNED 0x0010 /* Value is unsigned */ #define CF_CONST 0x0020 /* Constant value available */ #define CF_CONSTADDR 0x0040 /* Constant address value available */ @@ -273,7 +275,7 @@ void g_leavariadic (int Offs); void g_putstatic (unsigned flags, unsigned long label, unsigned offs); /* Store the primary register into the specified static memory cell */ -void g_putlocal (unsigned flags, int offs); +void g_putlocal (unsigned Flags, int Offs, long Val); /* Put data into local object. */ void g_putind (unsigned flags, unsigned offs); @@ -370,10 +372,18 @@ void g_cmp (unsigned flags, unsigned long val); void g_test (unsigned flags); void g_push (unsigned flags, unsigned long val); void g_swap (unsigned flags); -void g_call (unsigned flags, char *lbl, unsigned argsize); -void g_callind (unsigned flags, unsigned argsize); -void g_jump (unsigned label); -void g_switch (unsigned flags); + +void g_call (unsigned Flags, const char* Label, unsigned ArgSize); +/* Call the specified subroutine name */ + +void g_callind (unsigned Flags, unsigned ArgSize); +/* Call subroutine with address in AX */ + +void g_jump (unsigned Label); +/* Jump to specified internal label number */ + +void g_switch (unsigned Flags); +/* Output switch statement preamble */ void g_case (unsigned flags, unsigned label, unsigned long val); /* Create table code for one case selector */ diff --git a/src/cc65/datatype.c b/src/cc65/datatype.c index 6e0ac1d85..e50f56ffb 100644 --- a/src/cc65/datatype.c +++ b/src/cc65/datatype.c @@ -173,7 +173,7 @@ type* GetImplicitFuncType (void) type* T = TypeAlloc (1 + DECODE_SIZE + 2); /* Prepare the function descriptor */ - F->Flags = FD_IMPLICIT | FD_EMPTY | FD_ELLIPSIS; + F->Flags = FD_IMPLICIT | FD_EMPTY | FD_VARIADIC; F->SymTab = &EmptySymTab; F->TagTab = &EmptySymTab; @@ -476,7 +476,7 @@ unsigned TypeOf (const type* T) case T_FUNC: F = (FuncDesc*) DecodePtr (T+1); - return (F->Flags & FD_ELLIPSIS)? 0 : CF_FIXARGC; + return (F->Flags & FD_VARIADIC)? 0 : CF_FIXARGC; case T_STRUCT: case T_UNION: @@ -654,7 +654,7 @@ int IsVariadicFunc (const type* T) FuncDesc* F; CHECK (IsTypeFunc (T)); F = (FuncDesc*) DecodePtr (T+1); - return (F->Flags & FD_ELLIPSIS) != 0; + return (F->Flags & FD_VARIADIC) != 0; } diff --git a/src/cc65/declare.c b/src/cc65/declare.c index c5bf09777..b37d9088b 100644 --- a/src/cc65/declare.c +++ b/src/cc65/declare.c @@ -626,7 +626,7 @@ static void ParseAnsiParamList (FuncDesc* F) /* Allow an ellipsis as last parameter */ if (curtok == TOK_ELLIPSIS) { NextToken (); - F->Flags |= FD_ELLIPSIS; + F->Flags |= FD_VARIADIC; break; } @@ -708,14 +708,14 @@ static FuncDesc* ParseFuncDecl (void) /* Check for several special parameter lists */ if (curtok == TOK_RPAREN) { /* Parameter list is empty */ - F->Flags |= (FD_EMPTY | FD_ELLIPSIS); + F->Flags |= (FD_EMPTY | FD_VARIADIC); } else if (curtok == TOK_VOID && nxttok == TOK_RPAREN) { /* Parameter list declared as void */ NextToken (); F->Flags |= FD_VOID_PARAM; } else if (curtok == TOK_IDENT && (nxttok == TOK_COMMA || nxttok == TOK_RPAREN)) { /* Old style (K&R) function. Assume variable param list. */ - F->Flags |= (FD_OLDSTYLE | FD_ELLIPSIS); + F->Flags |= (FD_OLDSTYLE | FD_VARIADIC); } /* Parse params */ @@ -730,7 +730,7 @@ static FuncDesc* ParseFuncDecl (void) /* Assign offsets. If the function has a variable parameter list, * there's one additional byte (the arg size). */ - Offs = (F->Flags & FD_ELLIPSIS)? 1 : 0; + Offs = (F->Flags & FD_VARIADIC)? 1 : 0; Sym = GetSymTab()->SymTail; while (Sym) { unsigned Size = SizeOf (Sym->Type); diff --git a/src/cc65/expr.c b/src/cc65/expr.c index 11c43b973..0cd605efc 100644 --- a/src/cc65/expr.c +++ b/src/cc65/expr.c @@ -510,54 +510,70 @@ void exprhs (unsigned flags, int k, struct expent *lval) } -static void callfunction (struct expent* lval) -/* Perform a function call. Called from hie11, this routine will - * either call the named function, or if the supplied ptr is zero, - * will call the contents of P. + +static unsigned FunctionParamList (FuncDesc* Func) +/* Parse a function parameter list and pass the parameters to the called + * function. Depending on several criteria this may be done by just pushing + * each parameter separately, or creating the parameter frame once and then + * storing into this frame. + * The function returns the size of the parameters pushed. */ { - struct expent lval2; - FuncDesc* Func; /* Function descriptor */ - int Ellipsis; /* True if we have an open param list */ - SymEntry* Param; /* Current formal parameter */ - unsigned ParamCount; /* Actual parameter count */ - unsigned ParamSize; /* Number of parameter bytes */ - unsigned Flags; - unsigned CFlags; - CodeMark Mark; - - - /* Get a pointer to the function descriptor from the type string */ - Func = GetFuncDesc (lval->e_tptr); - - /* Initialize vars to keep gcc silent */ - Param = 0; - Mark = 0; + struct expent lval; - /* Check if this is a function pointer. If so, save it. If not, check for - * special known library functions that may be inlined. + /* Initialize variables */ + SymEntry* Param = 0; /* Keep gcc silent */ + unsigned ParamSize = 0; /* Size of parameters pushed */ + unsigned ParamCount = 0; /* Number of parameters pushed */ + unsigned FrameSize = 0; /* Size of parameter frame */ + unsigned FrameParams = 0; /* Number of params in frame */ + int FrameOffs = 0; /* Offset into parameter frame */ + int Ellipsis = 0; /* Function is variadic */ + + /* As an optimization, we may allocate the complete parameter frame at + * once instead of pushing each parameter as it comes. We may do that, + * if... + * + * - optimizations that increase code size are enabled (allocating the + * stack frame at once gives usually larger code). + * - we have more than one parameter to push (don't count the last param + * for __fastcall__ functions). */ - if (lval->e_flags & E_MEXPR) { - /* Function pointer is in primary register, save it */ - Mark = GetCodePos (); - g_save (CF_PTR); - } else if (InlineStdFuncs && IsStdFunc ((const char*) lval->e_name)) { - /* Inline this function */ - HandleStdFunc (lval); - return; + if (Optimize && !FavourSize) { + + /* Calculate the number and size of the parameters */ + FrameParams = Func->ParamCount; + FrameSize = Func->ParamSize; + if (FrameParams > 0 && (Func->Flags & FD_FASTCALL) != 0) { + /* Last parameter is not pushed */ + const SymEntry* LastParam = Func->SymTab->SymTail; + FrameSize -= SizeOf (LastParam->Type); + --FrameParams; + } + + /* Do we have more than one parameter in the frame? */ + if (FrameParams > 1) { + /* Okeydokey, setup the frame */ + FrameOffs = oursp; + g_space (FrameSize); + oursp -= FrameSize; + } else { + /* Don't use a preallocated frame */ + FrameSize = 0; + } } /* Parse the actual parameter list */ - ParamSize = 0; - ParamCount = 0; - Ellipsis = 0; while (curtok != TOK_RPAREN) { + unsigned CFlags; + unsigned Flags; + /* Add a hint for the optimizer */ AddCodeHint ("param:start"); - /* Count arguments */ - ++ParamCount; + /* Count arguments */ + ++ParamCount; /* Fetch the pointer to the next argument, check for too many args */ if (ParamCount <= Func->ParamCount) { @@ -579,7 +595,7 @@ static void callfunction (struct expent* lval) } } else if (!Ellipsis) { /* Too many arguments. Do we have an open param list? */ - if ((Func->Flags & FD_ELLIPSIS) == 0) { + if ((Func->Flags & FD_VARIADIC) == 0) { /* End of param list reached, no ellipsis */ Error ("Too many arguments in function call"); } @@ -596,8 +612,8 @@ static void callfunction (struct expent* lval) if (!Ellipsis && SizeOf (Param->Type) == 1) { CFlags = CF_FORCECHAR; } - Flags = 0; - if (evalexpr (CFlags, hie1, &lval2) == 0) { + Flags = CF_NONE; + if (evalexpr (CFlags, hie1, &lval) == 0) { /* A constant value */ Flags |= CF_CONST; } @@ -607,14 +623,14 @@ static void callfunction (struct expent* lval) */ if (!Ellipsis) { /* Promote the argument if needed */ - assignadjust (Param->Type, &lval2); + assignadjust (Param->Type, &lval); /* If we have a prototype, chars may be pushed as chars */ Flags |= CF_FORCECHAR; } /* Use the type of the argument for the push */ - Flags |= TypeOf (lval2.e_tptr); + Flags |= TypeOf (lval.e_tptr); /* If this is a fastcall function, don't push the last argument */ if (ParamCount == Func->ParamCount && (Func->Flags & FD_FASTCALL) != 0) { @@ -623,12 +639,24 @@ static void callfunction (struct expent* lval) * the primary. */ if (Flags & CF_CONST) { - exprhs (CF_FORCECHAR, 0, &lval2); + exprhs (CF_FORCECHAR, 0, &lval); } } else { - /* Push the argument, count the argument size */ - g_push (Flags, lval2.e_const); - ParamSize += sizeofarg (Flags); + unsigned ArgSize = sizeofarg (Flags); + if (FrameSize > 0) { + /* We have the space already allocated, store in the frame */ + CHECK (FrameSize >= ArgSize); + FrameSize -= ArgSize; + FrameOffs -= ArgSize; + /* Store */ + g_putlocal (Flags | CF_NOKEEP, FrameOffs, lval.e_const); + } else { + /* Push the argument */ + g_push (Flags, lval.e_const); + } + + /* Calculate total parameter size */ + ParamSize += ArgSize; } /* Add an optimizer hint */ @@ -641,14 +669,52 @@ static void callfunction (struct expent* lval) NextToken (); } - /* We need the closing bracket here */ - ConsumeRParen (); - /* Check if we had enough parameters */ if (ParamCount < Func->ParamCount) { Error ("Too few arguments in function call"); } + /* Return the size of all parameters pushed onto the stack */ + return ParamSize; +} + + + +static void CallFunction (struct expent* lval) +/* Perform a function call. Called from hie11, this routine will + * either call the named function, or the function pointer in a/x. + */ +{ + FuncDesc* Func; /* Function descriptor */ + unsigned ParamSize; /* Number of parameter bytes */ + CodeMark Mark; + + + /* Get a pointer to the function descriptor from the type string */ + Func = GetFuncDesc (lval->e_tptr); + + /* Initialize vars to keep gcc silent */ + Mark = 0; + + /* Check if this is a function pointer. If so, save it. If not, check for + * special known library functions that may be inlined. + */ + if (lval->e_flags & E_MEXPR) { + /* Function pointer is in primary register, save it */ + Mark = GetCodePos (); + g_save (CF_PTR); + } else if (InlineStdFuncs && IsStdFunc ((const char*) lval->e_name)) { + /* Inline this function */ + HandleStdFunc (lval); + return; + } + + /* Parse the parameter list */ + ParamSize = FunctionParamList (Func); + + /* We need the closing bracket here */ + ConsumeRParen (); + /* */ if (lval->e_flags & E_MEXPR) { /* Function called via pointer: Restore it and call function */ @@ -660,7 +726,7 @@ static void callfunction (struct expent* lval) } g_callind (TypeOf (lval->e_tptr), ParamSize); } else { - g_call (TypeOf (lval->e_tptr), (char*) lval->e_name, ParamSize); + g_call (TypeOf (lval->e_tptr), (const char*) lval->e_name, ParamSize); } } @@ -1205,7 +1271,7 @@ static int hie11 (struct expent *lval) ++lval->e_tptr; /* Skip T_PTR */ lval->e_flags |= E_MEXPR; } - callfunction (lval); + CallFunction (lval); lval->e_flags = E_MEXPR; lval->e_tptr += DECODE_SIZE + 1; /* Set to result */ } else { @@ -1255,7 +1321,7 @@ static void store (struct expent* lval) g_putstatic (flags, lval->e_name, lval->e_const); } else if (f & E_MLOCAL) { - g_putlocal (flags, lval->e_const); + g_putlocal (flags, lval->e_const, 0); } else if (f == E_MEOFFS) { g_putind (flags, lval->e_const); } else if (f != E_MREG) { diff --git a/src/cc65/funcdesc.h b/src/cc65/funcdesc.h index c18eb546c..eb62d3d48 100644 --- a/src/cc65/funcdesc.h +++ b/src/cc65/funcdesc.h @@ -48,7 +48,7 @@ #define FD_IMPLICIT 0x0001U /* Implicitly declared function */ #define FD_EMPTY 0x0002U /* Function with empty param list */ #define FD_VOID_PARAM 0x0004U /* Function with a void param list */ -#define FD_ELLIPSIS 0x0008U /* Function with variable param list */ +#define FD_VARIADIC 0x0008U /* Function with variable param list */ #define FD_FASTCALL 0x0010U /* __fastcall__ function */ #define FD_OLDSTYLE 0x0020U /* Old style (K&R) function */ #define FD_UNNAMED_PARAMS 0x0040U /* Function has unnamed params */ diff --git a/src/cc65/function.c b/src/cc65/function.c index 8b4e92c74..d9efc9a77 100644 --- a/src/cc65/function.c +++ b/src/cc65/function.c @@ -151,7 +151,7 @@ int HasVoidReturn (const Function* F) int IsVariadic (const Function* F) /* Return true if this is a variadic function */ { - return (F->Desc->Flags & FD_ELLIPSIS) != 0; + return (F->Desc->Flags & FD_VARIADIC) != 0; } @@ -231,8 +231,8 @@ void NewFunc (SymEntry* Func) * The latter is different depending on the type of the function (variadic * or not). */ - AddConstSym ("__fixargs__", type_uint, SC_DEF | SC_CONST, D->ParamSize); - if (D->Flags & FD_ELLIPSIS) { + 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); @@ -263,8 +263,8 @@ void NewFunc (SymEntry* Func) unsigned Flags; /* Fastcall functions may never have an ellipsis or the compiler is buggy */ - CHECK ((D->Flags & FD_ELLIPSIS) == 0); - + CHECK ((D->Flags & FD_VARIADIC) == 0); + /* Get a pointer to the last parameter entry */ LastParam = D->SymTab->SymTail; diff --git a/src/cc65/parser.c b/src/cc65/parser.c index b86cafd9c..42f732477 100644 --- a/src/cc65/parser.c +++ b/src/cc65/parser.c @@ -589,7 +589,7 @@ static ExprNode* DoFunctionCall (ExprNode* Left) } } else if (!Ellipsis) { /* Too many arguments. Do we have an open param list? */ - if ((Func->Flags & FD_ELLIPSIS) == 0) { + if ((Func->Flags & FD_VARIADIC) == 0) { /* End of param list reached, no ellipsis */ Error ("Too many function arguments"); }