-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.
*/
-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 */
- oursp -= F->Reserved;
+ /* Correct the stack pointer */
+ oursp -= F->Reserved;
- /* Nothing more reserved */
- F->Reserved = 0;
+ /* Nothing more reserved */
+ F->Reserved = 0;
}
}
{
int HadReturn;
int IsVoidFunc;
+ SymEntry* LastParam;
/* Get the function descriptor from the function entry */
FuncDesc* D = Func->V.F.Func;
/* Reenter the lexical level */
ReenterFunctionLevel (D);
+ /* Before adding more symbols, remember the last parameter for later */
+ LastParam = D->SymTab->SymTail;
+
/* Declare two special functions symbols: __fixargs__ and __argsize__.
* 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_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 [] = { T_UCHAR | T_QUAL_CONST, 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);
}
/* 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 (LastParam->Type)) {
/* Pointer to function */
Flags = CF_PTR;
} else {
}
/* Generate function entry code if needed */
- g_enter (TypeOf (Func->Type), GetParamSize (CurrentFunc));
+ g_enter (TypeOf (Func->Type), F_GetParamSize (CurrentFunc));
/* Setup the stack */
oursp = 0;
/* If the function has a return type but no return statement, flag
* a warning
*/
- IsVoidFunc = HasVoidReturn (CurrentFunc);
+ IsVoidFunc = F_HasVoidReturn (CurrentFunc);
#if 0
/* Does not work reliably */
- if (!IsVoidFunc && !HadReturn) {
+ if (!F_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);