encounter
/
MWCC
mirror of https://git.wuffs.org/MWCC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
MWCC/compiler_and_linker/unsorted/CInline.c

4207 lines
134 KiB
C
Raw Normal View History

honk
2022-11-07 03:06:21 +00:00
#include "compiler/CInline.h"
dump lots more code
2022-12-29 12:32:55 +00:00
#include "compiler/CABI.h"
#include "compiler/CClass.h"
#include "compiler/CError.h"
#include "compiler/CException.h"
#include "compiler/CExpr.h"
honk
2022-11-07 03:06:21 +00:00
#include "compiler/CFunc.h"
dump lots more code
2022-12-29 12:32:55 +00:00
#include "compiler/CInit.h"
#include "compiler/CInt64.h"
#include "compiler/CMachine.h"
#include "compiler/CMangler.h"
#include "compiler/COptimizer.h"
#include "compiler/CParser.h"
#include "compiler/CPrepTokenizer.h"
#include "compiler/CTemplateNew.h"
#include "compiler/CodeGen.h"
#include "compiler/CompilerTools.h"
#include "compiler/Exceptions.h"
#include "compiler/InlineAsm.h"
#include "compiler/ObjGenMachO.h"
#include "compiler/Switch.h"
#include "compiler/enode.h"
#include "compiler/objects.h"
#include "compiler/scopes.h"
#include "compiler/templates.h"
#ifdef __MWERKS__
#pragma options align=mac68k
#endif
typedef struct IDTrans {
struct IDTrans *next;
SInt32 from;
SInt32 to;
} IDTrans;
typedef struct LabelTrans {
struct LabelTrans *next;
CLabel **labelptr;
short id;
} LabelTrans;
typedef struct UIDTemp {
struct UIDTemp *next;
Object *object;
SInt32 uid;
} UIDTemp;
typedef struct CI_Export {
struct CI_Export *next;
Object *object;
CI_FuncData *funcdata;
Boolean xC;
} CI_Export;
typedef struct AObject {
Object *object;
ENode *expr1;
ENode *expr2;
} AObject;
typedef struct CI_StmtLink {
struct CI_StmtLink *next;
Statement *stmt;
CI_Statement *ciStmt;
} CI_StmtLink;
#ifdef __MWERKS__
#pragma options align=reset
#endif
honk
2022-11-07 03:06:21 +00:00
static CInlineCopyMode enode_copymode;
static Boolean enode_globalcopy;
dump lots more code
2022-12-29 12:32:55 +00:00
static IDTrans *enode_idtrans;
static Object **local_dobjects;
static AObject *local_aobjects;
honk
2022-11-07 03:06:21 +00:00
static CI_Var *loc_args;
static CI_Var *loc_vars;
static Boolean inline_expanded;
static Boolean any_inline_expanded;
static short cinline_level;
dump lots more code
2022-12-29 12:32:55 +00:00
static LabelTrans *cinline_label_trans;
honk
2022-11-07 03:06:21 +00:00
static Statement *cinline_first_stmt;
dump lots more code
2022-12-29 12:32:55 +00:00
static ENode *cinline_stmtlevelexpr[16];
honk
2022-11-07 03:06:21 +00:00
static short cinline_stmtlevelexprs;
static Boolean cinline_unconditionalpart;
static Boolean cinline_serialize_stmt;
dump lots more code
2022-12-29 12:32:55 +00:00
static CI_Export *cinline_exportlist; // type?
honk
2022-11-07 03:06:21 +00:00
static CI_Action *cinline_actionlist;
CI_Action *cinline_tactionlist;
static ObjectList *cinline_freflist;
static Boolean cinline_gendeps;
static Statement *cinline_serial_stmt;
static Statement *cinline_cur_serial_stmt;
dump lots more code
2022-12-29 12:32:55 +00:00
static UIDTemp *cinline_uid_temps;
honk
2022-11-07 03:06:21 +00:00
static Boolean cinline_has_sideeffect;
static SInt32 inline_max_size;
static Boolean recursive_inline;
static Object *expanding_function;
static Boolean cinline_funccallfound;
dump lots more code
2022-12-29 12:32:55 +00:00
// forward decls
static ENode *CInline_FoldConst(ENode *expr);
static ENode *CInline_CopyNodes(ENode *node);
static SInt32 CInline_EstimateSizeOfFunc(CI_FuncData *funcdata, SInt32 size, SInt32 level);
static ENode *CInline_SerializeExpr(ENode *expr);
static void CInline_AddFRefList_InlineFunc(CI_FuncData *data);
void CInline_Init(void) {
cinline_exportlist = NULL;
cinline_actionlist = NULL;
cinline_tactionlist = NULL;
cinline_gendeps = 0;
}
static ENode *CInline_MakeNotNot(ENode *expr) {
expr = CInline_FoldConst(expr);
if (!ENODE_IS(expr, EINTCONST)) {
expr = makemonadicnode(expr, ELOGNOT);
expr->rtype = CParser_GetBoolType();
expr = makemonadicnode(expr, ELOGNOT);
} else {
expr->data.intval = CInt64_Not(CInt64_Not(expr->data.intval));
}
return expr;
}
static ENode *CInline_FoldConst(ENode *expr) {
ENode *inner;
ENode *right;
ENode *left;
ENodeList *list;
switch (expr->type) {
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJREF:
case EPRECOMP:
case ETEMP:
case ELABEL:
case EOBJLIST:
case EINSTRUCTION:
case EVECTOR128CONST:
return expr;
case EMONMIN:
case EBINNOT:
case ELOGNOT:
expr->data.monadic = CInline_FoldConst(expr->data.monadic);
inner = expr->data.monadic;
switch (inner->type) {
case EINTCONST:
if (!ENODE_IS(expr, ELOGNOT)) {
inner->data.intval = CMach_CalcIntMonadic(
expr->rtype, CParser_GetOperator(expr->type), inner->data.intval);
} else {
inner->data.intval = CInt64_Not(inner->data.intval);
}
inner->rtype = expr->rtype;
return inner;
case EFLOATCONST:
if (ENODE_IS(expr, ELOGNOT)) {
inner->type = EINTCONST;
CInt64_SetLong(&inner->data.intval, CMach_FloatIsZero(inner->data.floatval));
} else {
inner->data.floatval = CMach_CalcFloatMonadic(
expr->rtype, CParser_GetOperator(expr->type), inner->data.floatval);
}
inner->rtype = expr->rtype;
return inner;
}
return expr;
case ETYPCON:
expr->data.monadic = CInline_FoldConst(expr->data.monadic);
switch (expr->data.monadic->type) {
case EINTCONST:
switch (expr->rtype->type) {
case TYPEFLOAT:
expr->type = EFLOATCONST;
expr->data.floatval = CMach_CalcFloatConvertFromInt(
expr->data.monadic->rtype, expr->data.monadic->data.intval);
return expr;
case TYPEINT:
expr->type = EINTCONST;
expr->data.intval = CExpr_IntConstConvert(
expr->rtype, expr->data.monadic->rtype, expr->data.monadic->data.intval);
break;
}
break;
case EFLOATCONST:
switch (expr->rtype->type) {
case TYPEFLOAT:
expr->type = EFLOATCONST;
expr->data.floatval = CMach_CalcFloatConvert(
expr->rtype, expr->data.monadic->data.floatval);
return expr;
case TYPEINT:
expr->type = EINTCONST;
expr->data.intval = CMach_CalcIntConvertFromFloat(
expr->rtype, expr->data.monadic->data.floatval);
return expr;
}
break;
}
return expr;
case EPOSTINC:
case EPOSTDEC:
expr->data.monadic = CInline_FoldConst(expr->data.monadic);
switch (expr->data.monadic->type) {
case EINTCONST:
case EFLOATCONST:
expr->data.monadic->rtype = expr->rtype;
return expr->data.monadic;
}
return expr;
case EPREINC:
case EPREDEC:
case EINDIRECT:
case EFORCELOAD:
case EBITFIELD:
expr->data.monadic = CInline_FoldConst(expr->data.monadic);
return expr;
case EMUL:
case EDIV:
case EMODULO:
case EADD:
case ESUB:
case ESHL:
case ESHR:
case EAND:
case EXOR:
case EOR:
expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
if ((left = expr->data.diadic.left)->type == (right = expr->data.diadic.right)->type) {
switch (left->type) {
case EINTCONST:
left->data.intval = CMach_CalcIntDiadic(
expr->rtype,
expr->data.diadic.left->data.intval,
CParser_GetOperator(expr->type),
right->data.intval);
left->rtype = expr->rtype;
return left;
case EFLOATCONST:
left->data.floatval = CMach_CalcFloatDiadic(
expr->rtype,
expr->data.diadic.left->data.floatval,
CParser_GetOperator(expr->type),
right->data.floatval);
left->rtype = expr->rtype;
return left;
}
}
return expr;
case ELESS:
case EGREATER:
case ELESSEQU:
case EGREATEREQU:
case EEQU:
case ENOTEQU:
expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
if ((left = expr->data.diadic.left)->type == (right = expr->data.diadic.right)->type) {
switch (left->type) {
case EINTCONST:
left->data.intval = CMach_CalcIntDiadic(
left->rtype,
expr->data.diadic.left->data.intval,
CParser_GetOperator(expr->type),
right->data.intval);
left->rtype = expr->rtype;
return left;
case EFLOATCONST:
CInt64_SetLong(&left->data.intval, CMach_CalcFloatDiadicBool(
left->rtype,
expr->data.diadic.left->data.floatval,
CParser_GetOperator(expr->type),
right->data.floatval
));
left->type = EINTCONST;
left->rtype = expr->rtype;
return left;
}
}
return expr;
case ELAND:
expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
if (iszero(expr->data.diadic.left))
return expr->data.diadic.left;
if (isnotzero(expr->data.diadic.left))
return CInline_MakeNotNot(expr->data.diadic.right);
expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
if (isnotzero(expr->data.diadic.right))
return CInline_MakeNotNot(expr->data.diadic.left);
return expr;
case ELOR:
expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
if (iszero(expr->data.diadic.left))
return CInline_MakeNotNot(expr->data.diadic.right);
if (isnotzero(expr->data.diadic.left))
return CInline_MakeNotNot(expr->data.diadic.left);
expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
if (iszero(expr->data.diadic.right))
return CInline_MakeNotNot(expr->data.diadic.left);
return expr;
case EASS:
case EMULASS:
case EDIVASS:
case EMODASS:
case EADDASS:
case ESUBASS:
case ESHLASS:
case ESHRASS:
case EANDASS:
case EXORASS:
case EORASS:
case ECOMMA:
case EROTL:
case EROTR:
expr->data.diadic.left = CInline_FoldConst(expr->data.diadic.left);
expr->data.diadic.right = CInline_FoldConst(expr->data.diadic.right);
return expr;
case ECOND:
expr->data.cond.cond = CInline_FoldConst(expr->data.cond.cond);
if (isnotzero(expr->data.cond.cond))
return CInline_FoldConst(expr->data.cond.expr1);
if (iszero(expr->data.cond.cond))
return CInline_FoldConst(expr->data.cond.expr2);
expr->data.cond.expr1 = CInline_FoldConst(expr->data.cond.expr1);
expr->data.cond.expr2 = CInline_FoldConst(expr->data.cond.expr2);
return expr;
case EMFPOINTER:
expr->data.mfpointer.accessnode = CInline_FoldConst(expr->data.mfpointer.accessnode);
expr->data.mfpointer.mfpointer = CInline_FoldConst(expr->data.mfpointer.mfpointer);
return expr;
case EFUNCCALL:
case EFUNCCALLP:
expr->data.funccall.funcref = CInline_FoldConst(expr->data.funccall.funcref);
for (list = expr->data.funccall.args; list; list = list->next)
list->node = CInline_FoldConst(list->node);
return expr;
case ENULLCHECK:
expr->data.nullcheck.nullcheckexpr = CInline_FoldConst(expr->data.nullcheck.nullcheckexpr);
expr->data.nullcheck.condexpr = CInline_FoldConst(expr->data.nullcheck.condexpr);
return expr;
case EMEMBER:
if (expr->data.emember->expr)
expr->data.emember->expr = CInline_FoldConst(expr->data.emember->expr);
return expr;
default:
CError_FATAL(421);
return expr;
}
}
// unknown name
get it to compile with clang
2023-01-11 23:26:04 +00:00
CW_INLINE SInt32 CInline_GetLocalID2(Object *object) {
dump lots more code
2022-12-29 12:32:55 +00:00
ObjectList *list;
SInt32 counter;
for (list = locals, counter = 0; list; list = list->next) {
if (list->object->datatype == DLOCAL) {
if (list->object == object)
return counter;
counter++;
}
}
return -1;
}
SInt32 CInline_GetLocalID(Object *object) {
ObjectList *list;
SInt32 counter;
if (object) {
for (list = arguments, counter = 0; list; list = list->next, counter++) {
if (list->object == object) {
loc_args[counter].xD = 1;
loc_args[counter].xE = 0;
return counter - 0x7FFFFFFF;
}
}
counter = CInline_GetLocalID2(object);
CError_ASSERT(465, counter >= 0);
loc_vars[counter].xD = 1;
return counter + 1;
}
return 0;
}
static Boolean CInline_IsTrivialExpression(ENode *expr) {
while (1) {
switch (expr->type) {
case EINTCONST:
case EFLOATCONST:
case EOBJREF:
case EARGOBJ:
case ELOCOBJ:
case EOBJLIST:
case EVECTOR128CONST:
return 0;
case ESTRINGCONST:
return copts.dont_reuse_strings;
case EMEMBER:
if (expr->data.emember->expr)
return CInline_IsTrivialExpression(expr->data.emember->expr);
return 0;
case EINDIRECT:
if (ENODE_IS(expr->data.monadic, EOBJREF)) {
if (expr->data.monadic->data.objref->datatype == DLOCAL &&
!(expr->data.monadic->data.objref->flags & OBJECT_FLAGS_2))
return 0;
if (is_const_object(expr->data.monadic->data.objref))
return 0;
return 1;
}
return 1;
case EPOSTINC:
case EPOSTDEC:
case EPREINC:
case EPREDEC:
case EFORCELOAD:
case EASS:
case EMULASS:
case EDIVASS:
case EMODASS:
case EADDASS:
case ESUBASS:
case ESHLASS:
case ESHRASS:
case EANDASS:
case EXORASS:
case EORASS:
case EFUNCCALL:
case EFUNCCALLP:
case EMFPOINTER:
case ENULLCHECK:
case EPRECOMP:
case ETEMP:
case ELABEL:
case EINSTRUCTION:
return 1;
case EMONMIN:
case EBINNOT:
case ELOGNOT:
case ETYPCON:
case EBITFIELD:
expr = expr->data.monadic;
continue;
case EMUL:
case EDIV:
case EMODULO:
case EADD:
case ESUB:
case ESHL:
case ESHR:
case ELESS:
case EGREATER:
case ELESSEQU:
case EGREATEREQU:
case EEQU:
case ENOTEQU:
case EAND:
case EXOR:
case EOR:
case ELAND:
case ELOR:
case ECOMMA:
case EROTL:
case EROTR:
if (CInline_IsTrivialExpression(expr->data.diadic.left))
return 1;
expr = expr->data.diadic.right;
continue;
case ECOND:
if (CInline_IsTrivialExpression(expr->data.cond.cond))
return 1;
if (CInline_IsTrivialExpression(expr->data.cond.expr1))
return 1;
expr = expr->data.cond.expr2;
continue;
default:
CError_FATAL(582);
}
}
}
Boolean CInline_ExpressionHasSideEffect(ENode *expr) {
while (1) {
switch (expr->type) {
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJREF:
case EPRECOMP:
case ETEMP:
case EARGOBJ:
case ELOCOBJ:
case ELABEL:
case EOBJLIST:
case EVECTOR128CONST:
return 0;
case EPOSTINC:
case EPOSTDEC:
case EPREINC:
case EPREDEC:
case EASS:
case EMULASS:
case EDIVASS:
case EMODASS:
case EADDASS:
case ESUBASS:
case ESHLASS:
case ESHRASS:
case EANDASS:
case EXORASS:
case EORASS:
case EFUNCCALL:
case EFUNCCALLP:
case EINSTRUCTION:
return 1;
case EINDIRECT:
case EMONMIN:
case EBINNOT:
case ELOGNOT:
case EFORCELOAD:
case ETYPCON:
case EBITFIELD:
expr = expr->data.monadic;
continue;
case EMUL:
case EDIV:
case EMODULO:
case EADD:
case ESUB:
case ESHL:
case ESHR:
case ELESS:
case EGREATER:
case ELESSEQU:
case EGREATEREQU:
case EEQU:
case ENOTEQU:
case EAND:
case EXOR:
case EOR:
case ELAND:
case ELOR:
case ECOMMA:
case EROTL:
case EROTR:
if (CInline_ExpressionHasSideEffect(expr->data.diadic.left))
return 1;
expr = expr->data.diadic.right;
continue;
case EMEMBER:
if (expr->data.emember->expr)
return CInline_ExpressionHasSideEffect(expr->data.emember->expr);
return 0;
case EMFPOINTER:
if (CInline_ExpressionHasSideEffect(expr->data.mfpointer.accessnode))
return 1;
expr = expr->data.mfpointer.mfpointer;
continue;
case ENULLCHECK:
if (CInline_ExpressionHasSideEffect(expr->data.nullcheck.nullcheckexpr))
return 1;
expr = expr->data.nullcheck.condexpr;
continue;
case ECOND:
if (CInline_ExpressionHasSideEffect(expr->data.cond.cond))
return 1;
if (CInline_ExpressionHasSideEffect(expr->data.cond.expr1))
return 1;
expr = expr->data.cond.expr2;
continue;
default:
CError_FATAL(689);
}
}
}
static ENode *CInline_CopyExpressionSave(ENode *expr) {
CInlineCopyMode save_copymode;
Boolean save_globalcopy;
IDTrans *save_idtrans;
save_globalcopy = enode_globalcopy;
enode_globalcopy = 1;
save_copymode = enode_copymode;
enode_copymode = CopyMode4;
save_idtrans = enode_idtrans;
enode_idtrans = NULL;
expr = CInline_CopyNodes(expr);
enode_globalcopy = save_globalcopy;
enode_copymode = save_copymode;
enode_idtrans = save_idtrans;
return expr;
}
static SInt32 CInline_TranslateID(SInt32 id) {
IDTrans *trans;
for (trans = enode_idtrans; trans; trans = trans->next) {
if (trans->from == id)
return trans->to;
}
trans = lalloc(sizeof(IDTrans));
trans->next = enode_idtrans;
enode_idtrans = trans;
trans->from = id;
trans->to = CParser_GetUniqueID();
return trans->to;
}
static short CInline_GetLabelStatementNumber(HashNameNode *name) {
Statement *stmt;
short i;
for (stmt = cinline_first_stmt, i = 0; stmt; stmt = stmt->next, i++) {
if (stmt->type == ST_LABEL && stmt->label->uniquename == name)
return i;
}
CError_FATAL(742);
return 0;
}
static ENodeList *CInline_CopyNodeList(ENodeList *list) {
ENodeList *copy;
ENodeList *first;
ENodeList *last;
first = NULL;
while (list) {
if (enode_globalcopy)
copy = galloc(sizeof(ENodeList));
else
copy = lalloc(sizeof(ENodeList));
copy->node = CInline_CopyNodes(list->node);
copy->next = NULL;
if (first) {
last->next = copy;
last = copy;
} else {
first = last = copy;
}
list = list->next;
}
return first;
}
static EMemberInfo *CInline_CopyEMemberInfo(EMemberInfo *mi) {
EMemberInfo *copy;
if (enode_globalcopy)
copy = galloc(sizeof(EMemberInfo));
else
copy = lalloc(sizeof(EMemberInfo));
*copy = *mi;
if (copy->path)
copy->path = CClass_GetPathCopy(copy->path, enode_globalcopy);
if (copy->expr)
copy->expr = CInline_CopyNodes(copy->expr);
return copy;
}
static ENode *CInline_CopyNodes(ENode *node) {
ENode *copy;
if (enode_globalcopy)
copy = galloc(sizeof(ENode));
else
copy = lalloc(sizeof(ENode));
while (1) {
*copy = *node;
switch (copy->type) {
case ETEMPLDEP:
switch (copy->data.templdep.subtype) {
case TDE_PARAM:
case TDE_SIZEOF:
case TDE_ALIGNOF:
case TDE_QUALNAME:
case TDE_OBJ:
break;
case TDE_CAST:
copy->data.templdep.u.cast.args = CInline_CopyNodeList(copy->data.templdep.u.cast.args);
break;
case TDE_SOURCEREF:
copy->data.templdep.u.sourceref.expr = CInline_CopyNodes(copy->data.templdep.u.sourceref.expr);
break;
case TDE_ADDRESS_OF:
copy->data.templdep.u.monadic = CInline_CopyNodes(copy->data.templdep.u.monadic);
break;
default:
CError_FATAL(840);
}
break;
case ETEMP:
if (enode_copymode == CopyMode3 && copy->data.temp.uniqueid)
copy->data.temp.uniqueid = CInline_TranslateID(copy->data.temp.uniqueid);
break;
case ELABEL:
switch (enode_copymode) {
case CopyMode2:
copy->data.precompid = CInline_GetLabelStatementNumber(copy->data.label->uniquename);
return copy;
case CopyMode3:
case CopyMode4: {
LabelTrans *trans = lalloc(sizeof(LabelTrans));
trans->next = cinline_label_trans;
cinline_label_trans = trans;
trans->id = copy->data.precompid;
trans->labelptr = &copy->data.label;
return copy;
}
}
break;
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJLIST:
case EINSTRUCTION:
case EVECTOR128CONST:
break;
case EPOSTINC:
case EPOSTDEC:
case EPREINC:
case EPREDEC:
case EMONMIN:
case EBINNOT:
case ELOGNOT:
case EFORCELOAD:
case ETYPCON:
case EBITFIELD:
copy->data.monadic = CInline_CopyNodes(copy->data.monadic);
break;
ENODE_CASE_DIADIC_ALL:
copy->data.diadic.left = CInline_CopyNodes(copy->data.diadic.left);
copy->data.diadic.right = CInline_CopyNodes(copy->data.diadic.right);
break;
case ECOND:
copy->data.cond.cond = CInline_CopyNodes(copy->data.cond.cond);
copy->data.cond.expr1 = CInline_CopyNodes(copy->data.cond.expr1);
copy->data.cond.expr2 = CInline_CopyNodes(copy->data.cond.expr2);
break;
case EMFPOINTER:
copy->data.mfpointer.accessnode = CInline_CopyNodes(copy->data.mfpointer.accessnode);
copy->data.mfpointer.mfpointer = CInline_CopyNodes(copy->data.mfpointer.mfpointer);
break;
case EFUNCCALL:
case EFUNCCALLP:
copy->data.funccall.funcref = CInline_CopyNodes(copy->data.funccall.funcref);
copy->data.funccall.args = CInline_CopyNodeList(copy->data.funccall.args);
break;
case ENULLCHECK:
copy->data.nullcheck.precompid = CInline_TranslateID(copy->data.nullcheck.precompid);
copy->data.nullcheck.nullcheckexpr = CInline_CopyNodes(copy->data.nullcheck.nullcheckexpr);
copy->data.nullcheck.condexpr = CInline_CopyNodes(copy->data.nullcheck.condexpr);
break;
case EPRECOMP:
copy->data.precompid = CInline_TranslateID(copy->data.precompid);
break;
case EINDIRECT:
if (
enode_copymode == CopyMode4 &&
ENODE_IS(copy->data.monadic, EARGOBJ) &&
local_aobjects[copy->data.monadic->data.longval].object == NULL
)
{
CError_ASSERT(910, local_aobjects[copy->data.monadic->data.longval].expr1);
copy = CInline_CopyExpressionSave(local_aobjects[copy->data.monadic->data.longval].expr1);
if (copy->rtype != node->rtype) {
if (IS_TYPE_INT(copy->rtype) && IS_TYPE_INT(node->rtype))
copy = makemonadicnode(copy, ETYPCON);
copy->rtype = node->rtype;
}
return copy;
}
copy->data.monadic = CInline_CopyNodes(copy->data.monadic);
break;
case EOBJREF:
if (enode_copymode == CopyMode2) {
ObjectList *list;
int i;
if (node->data.objref->datatype == DALIAS) {
CExpr_AliasTransform(node);
continue;
}
if (node->data.objref->datatype == DDATA)
return copy;
for (list = arguments, i = 0; list; list = list->next, i++) {
if (list->object == copy->data.objref) {
copy->type = EARGOBJ;
copy->data.longval = i;
return copy;
}
}
i = CInline_GetLocalID2(copy->data.objref);
if (i >= 0) {
copy->type = ELOCOBJ;
copy->data.longval = i;
return copy;
}
if (node->data.objref->datatype == DLOCAL)
CError_FATAL(949);
}
break;
case EARGOBJ:
switch (enode_copymode) {
case CopyMode4:
CError_ASSERT(957, local_aobjects[copy->data.longval].object);
copy->type = EOBJREF;
copy->data.objref = local_aobjects[copy->data.longval].object;
return copy;
case CopyMode3: {
ObjectList *list;
int i;
for (list = arguments, i = 0; list; list = list->next, i++) {
if (i == copy->data.longval) {
copy->type = EOBJREF;
copy->data.objref = list->object;
CError_ASSERT(966, copy->data.objref);
return copy;
}
}
}
default:
CError_FATAL(971);
}
case ELOCOBJ:
switch (enode_copymode) {
case CopyMode4:
copy->type = EOBJREF;
copy->data.objref = local_dobjects[copy->data.longval];
return copy;
case CopyMode3: {
ObjectList *list;
int i;
for (list = locals, i = 0; list; list = list->next, i++) {
if (i == copy->data.longval) {
copy->type = EOBJREF;
copy->data.objref = list->object;
CError_ASSERT(986, copy->data.objref);
return copy;
}
}
}
default:
CError_FATAL(991);
}
break;
case ENEWEXCEPTION:
case ENEWEXCEPTIONARRAY:
copy->data.newexception.initexpr = CInline_CopyNodes(copy->data.newexception.initexpr);
copy->data.newexception.tryexpr = CInline_CopyNodes(copy->data.newexception.tryexpr);
break;
case EINITTRYCATCH:
copy->data.itc.initexpr = CInline_CopyNodes(copy->data.itc.initexpr);
copy->data.itc.tryexpr = CInline_CopyNodes(copy->data.itc.tryexpr);
copy->data.itc.catchexpr = CInline_CopyNodes(copy->data.itc.catchexpr);
copy->data.itc.result = CInline_CopyNodes(copy->data.itc.result);
break;
case EMEMBER:
copy->data.emember = CInline_CopyEMemberInfo(copy->data.emember);
break;
default:
CError_FATAL(1015);
}
return copy;
}
}
static void CInline_CheckUsage(ENode *expr, Boolean flag) {
ENodeList *list;
ENode *inner;
while (1) {
switch (expr->type) {
case EARGOBJ:
loc_args[expr->data.longval].xD = 1;
loc_args[expr->data.longval].xE = 0;
return;
case ELOCOBJ:
loc_vars[expr->data.longval].xD = 1;
return;
case EINDIRECT:
if (ENODE_IS((inner = expr->data.monadic), EARGOBJ)) {
loc_args[inner->data.longval].xD = 1;
if (flag)
loc_args[inner->data.longval].xE = 0;
return;
}
expr = expr->data.monadic;
flag = 0;
continue;
case EMONMIN:
case EBINNOT:
case ELOGNOT:
case EFORCELOAD:
case ETYPCON:
case EBITFIELD:
expr = expr->data.monadic;
flag = 0;
continue;
case EPOSTINC:
case EPOSTDEC:
case EPREINC:
case EPREDEC:
expr = expr->data.monadic;
flag = 1;
continue;
case EASS:
case EMULASS:
case EDIVASS:
case EMODASS:
case EADDASS:
case ESUBASS:
case ESHLASS:
case ESHRASS:
case EANDASS:
case EXORASS:
case EORASS:
CInline_CheckUsage(expr->data.diadic.left, 1);
expr = expr->data.diadic.right;
flag = 0;
continue;
case EMUL:
case EDIV:
case EMODULO:
case EADD:
case ESUB:
case ESHL:
case ESHR:
case ELESS:
case EGREATER:
case ELESSEQU:
case EGREATEREQU:
case EEQU:
case ENOTEQU:
case EAND:
case EXOR:
case EOR:
case ELAND:
case ELOR:
case ECOMMA:
case EROTL:
case EROTR:
CInline_CheckUsage(expr->data.diadic.left, 0);
expr = expr->data.diadic.right;
flag = 0;
continue;
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJREF:
case EPRECOMP:
case ETEMP:
case ELABEL:
case EOBJLIST:
case EVECTOR128CONST:
return;
case EMEMBER:
if (expr->data.emember->expr)
CInline_CheckUsage(expr->data.emember->expr, 0);
return;
case EFUNCCALL:
case EFUNCCALLP:
CInline_CheckUsage(expr->data.funccall.funcref, 0);
for (list = expr->data.funccall.args; list; list = list->next)
CInline_CheckUsage(list->node, 0);
return;
case ENULLCHECK:
CInline_CheckUsage(expr->data.nullcheck.nullcheckexpr, 0);
expr = expr->data.nullcheck.condexpr;
flag = 0;
continue;
case EMFPOINTER:
CInline_CheckUsage(expr->data.mfpointer.accessnode, 0);
expr = expr->data.mfpointer.mfpointer;
flag = 0;
continue;
case ECOND:
CInline_CheckUsage(expr->data.cond.cond, 0);
CInline_CheckUsage(expr->data.cond.expr1, 0);
expr = expr->data.cond.expr2;
flag = 0;
continue;
case EINSTRUCTION:
return;
default:
CError_FATAL(1146);
}
}
}
ENode *CInline_CopyExpression(ENode *expr, CInlineCopyMode mode) {
enode_copymode = mode;
switch (mode) {
case CopyMode0:
case CopyMode4:
enode_idtrans = NULL;
enode_globalcopy = 0;
expr = CInline_CopyNodes(expr);
break;
case CopyMode3:
enode_globalcopy = 0;
expr = CInline_CopyNodes(expr);
break;
case CopyMode1:
enode_idtrans = NULL;
enode_globalcopy = 1;
expr = CInline_CopyNodes(expr);
break;
case CopyMode2:
enode_idtrans = NULL;
enode_globalcopy = 1;
expr = CInline_CopyNodes(expr);
CInline_CheckUsage(expr, 0);
break;
}
return expr;
}
static UInt8 CInline_GetObjectSFlags(Object *object) {
UInt8 flags;
switch (object->sclass) {
case 0:
flags = CI_SFLAGS_NoClass;
break;
case TK_REGISTER:
flags = CI_SFLAGS_Register;
break;
case TK_AUTO:
flags = CI_SFLAGS_Auto;
break;
default:
CError_FATAL(1204);
}
if (object->flags & OBJECT_FLAGS_2)
flags |= CI_SFLAGS_HasObjectFlag2;
return flags;
}
static void CInline_SetObjectSFlags(Object *object, UInt8 sflags) {
if (sflags & CI_SFLAGS_HasObjectFlag2) {
object->flags |= OBJECT_FLAGS_2;
sflags &= ~CI_SFLAGS_HasObjectFlag2;
}
switch (sflags) {
case CI_SFLAGS_NoClass:
object->sclass = 0;
break;
case CI_SFLAGS_Register:
object->sclass = TK_REGISTER;
break;
case CI_SFLAGS_Auto:
object->sclass = TK_AUTO;
break;
default:
CError_FATAL(1229);
}
}
static Object *CInline_NewLocalObject(Type *type, short qual, UInt8 sflags, int unk) {
Object *object = CParser_NewLocalDataObject(NULL, 1);
object->name = CParser_GetUniqueName();
object->type = type;
object->qual = qual;
CInline_SetObjectSFlags(object, sflags);
CFunc_SetupLocalVarInfo(object);
return object;
}
static ENode *CInline_FuncArgConvert(ENode *expr) {
ENode *copy;
switch (expr->type) {
case EOBJREF:
copy = lalloc(sizeof(ENode));
*copy = *expr;
return copy;
case ETEMP:
CError_FATAL(1272);
}
return NULL;
}
static ENode *CInline_RefArgTransform(ENode *expr, Boolean flag) {
ENodeList *arg;
while (ENODE_IS(expr, ECOMMA))
expr = expr->data.diadic.right;
switch (expr->type) {
case EOBJREF:
case ETEMP:
if (flag)
return CInline_FuncArgConvert(expr);
break;
case EFUNCCALL:
if (IS_TYPE_POINTER_ONLY(expr->rtype) && IS_TYPE_CLASS(TPTR_TARGET(expr->rtype))) {
if (
ENODE_IS(expr->data.funccall.funcref, EOBJREF) &&
CClass_IsConstructor(expr->data.funccall.funcref->data.objref) &&
expr->data.funccall.args
)
return CInline_FuncArgConvert(expr->data.funccall.args->node);
if (
TPTR_TARGET(expr->rtype) == expr->data.funccall.functype->functype &&
CMach_GetFunctionResultClass(expr->data.funccall.functype) == 1 &&
(arg = expr->data.funccall.args)
)
{
switch (CABI_GetStructResultArgumentIndex(expr->data.funccall.functype)) {
case 0:
break;
case 1:
if ((arg = arg->next))
break;
CError_FATAL(1313);
default:
CError_FATAL(1314);
}
return CInline_FuncArgConvert(arg->node);
}
}
break;
}
return NULL;
}
static ENode *CInline_SetupArgsExpression(Object *object, CI_FuncData *data, ENodeList *list) {
ENode *commaNodes;
CI_Var *var;
ENodeList *scan;
ENode *expr;
SInt32 i;
Boolean is_oldstyle;
is_oldstyle = 0;
if (TYPE_FUNC(object->type)->args == &oldstyle)
is_oldstyle = 1;
local_dobjects = lalloc(sizeof(Object *) * data->numlocals);
local_aobjects = lalloc(sizeof(AObject) * data->numarguments);
for (i = 0, var = data->locals; i < data->numlocals; i++, var++) {
if (var->xD) {
object = CInline_NewLocalObject(var->type, var->qual, var->sflags, 0);
local_dobjects[i] = object;
if (!var->xE)
object->flags |= OBJECT_FLAGS_2;
} else {
local_dobjects[i] = NULL;
}
}
for (i = 0, var = data->arguments, scan = list; i < data->numarguments; i++, var++) {
local_aobjects[i].expr2 = NULL;
if (!var->xD) {
local_aobjects[i].object = NULL;
local_aobjects[i].expr1 = NULL;
} else if (
scan &&
var->xE &&
!CInline_IsTrivialExpression(scan->node) &&
(!is_oldstyle || scan->node->rtype->size == var->type->size)
)
{
local_aobjects[i].object = NULL;
local_aobjects[i].expr1 = scan->node;
} else if (
scan &&
var->xE &&
IS_TYPE_REFERENCE(var->type) &&
(expr = CInline_RefArgTransform(scan->node, 1))
)
{
local_aobjects[i].object = NULL;
local_aobjects[i].expr1 = expr;
local_aobjects[i].expr2 = scan->node;
} else {
local_aobjects[i].object = CInline_NewLocalObject(var->type, var->qual, var->sflags, 0);
local_aobjects[i].expr1 = NULL;
}
if (scan)
scan = scan->next;
}
commaNodes = NULL;
for (i = 0, scan = list; scan; scan = scan->next, i++) {
if (i >= data->numarguments) {
if (!commaNodes)
commaNodes = scan->node;
else
commaNodes = makecommaexpression(scan->node, commaNodes);
} else if (!local_aobjects[i].object || local_aobjects[i].expr2) {
if (local_aobjects[i].expr2) {
if (!commaNodes)
commaNodes = local_aobjects[i].expr2;
else
commaNodes = makecommaexpression(local_aobjects[i].expr2, commaNodes);
} else if (!local_aobjects[i].expr1 && CInline_IsTrivialExpression(scan->node)) {
commaNodes = !commaNodes ? scan->node : makecommaexpression(scan->node, commaNodes);
CError_ASSERT(1470, !ENODE_IS(scan->node, EPRECOMP));
}
} else {
if (is_oldstyle && scan->node->rtype->size != local_aobjects[i].object->type->size) {
scan->node = makemonadicnode(scan->node, ETYPCON);
scan->node->rtype = local_aobjects[i].object->type;
}
expr = makediadicnode(create_objectnode2(local_aobjects[i].object), scan->node, EASS);
if (!commaNodes)
commaNodes = expr;
else
commaNodes = makecommaexpression(expr, commaNodes);
}
}
return commaNodes;
}
static void CInline_ReturnCheckCB(ENode *expr) {
cinline_has_sideeffect = 1;
}
static ENode *CInline_ReturnCheck(ENode *expr) {
ENode *copy;
if (ENODE_IS(expr, EFORCELOAD))
return expr;
cinline_has_sideeffect = 0;
CExpr_SearchExprTree(expr, CInline_ReturnCheckCB, 3, EINDIRECT, EFUNCCALL, EFUNCCALLP);
if (!cinline_has_sideeffect)
return expr;
copy = lalloc(sizeof(ENode));
*copy = *expr;
copy->type = EFORCELOAD;
copy->data.monadic = expr;
return copy;
}
static ENode *CInline_ReturnMemResult(Object *object) {
int index = CABI_GetStructResultArgumentIndex(TYPE_FUNC(object->type));
if (local_aobjects[index].object == NULL)
return CInline_CopyExpressionSave(local_aobjects[index].expr1);
else
return create_objectnode(local_aobjects[index].object);
}
static ENode *CInline_InlineFunctionExpression(ENode *expr) {
Object *object;
CI_FuncData *funcdata;
short i;
Boolean flag26;
ENode *argsExpr;
object = expr->data.funccall.funcref->data.objref;
if (object->datatype == DALIAS)
object = object->u.alias.object;
funcdata = object->u.func.u.ifuncdata;
if (!funcdata)
return expr;
if (funcdata->can_inline < CI_CanInline6) {
if (funcdata->can_inline == CI_CanInline3) {
if (cinline_unconditionalpart && cinline_stmtlevelexprs < 16)
cinline_stmtlevelexpr[cinline_stmtlevelexprs++] = expr;
cinline_serialize_stmt = 1;
}
return expr;
}
flag26 = CMach_GetFunctionResultClass(TYPE_FUNC(object->type)) == 1;
argsExpr = CInline_SetupArgsExpression(object, funcdata, expr->data.funccall.args);
for (i = 0; i < funcdata->numstatements; i++) {
switch (funcdata->statements[i].type) {
case ST_RETURN:
if (funcdata->statements[i].u.expr) {
ENode *copy = CInline_CopyExpression(funcdata->statements[i].u.expr, CopyMode4);
if (flag26) {
if (argsExpr)
argsExpr = makecommaexpression(argsExpr, copy);
else
argsExpr = copy;
argsExpr = makecommaexpression(argsExpr, CInline_ReturnMemResult(object));
} else {
if (argsExpr)
argsExpr = makecommaexpression(argsExpr, CInline_ReturnCheck(copy));
else
argsExpr = CInline_ReturnCheck(copy);
}
}
break;
case ST_EXPRESSION:
if (argsExpr)
argsExpr = makecommaexpression(argsExpr, CInline_CopyExpression(funcdata->statements[i].u.expr, CopyMode4));
else
argsExpr = CInline_CopyExpression(funcdata->statements[i].u.expr, CopyMode4);
break;
default:
CError_FATAL(1632);
}
}
if (!argsExpr)
argsExpr = nullnode();
if (!IS_TYPE_VOID(expr->rtype))
argsExpr->rtype = expr->rtype;
inline_expanded = 1;
return CInline_FoldConst(argsExpr);
}
static Boolean CInline_CanExpand(ENode *expr) {
TypeFunc *tfunc;
Object *object;
object = expr->data.objref;
tfunc = TYPE_FUNC(object->type);
if (
IS_TYPE_FUNC(tfunc) &&
((object->qual & Q_INLINE) || (tfunc->flags & FUNC_FLAGS_800)) &&
(object->datatype == DFUNC || (object->datatype == DVFUNC && (expr->flags & ENODE_FLAG_80)))
)
return 1;
return 0;
}
static SInt32 CInline_EstimateSizeOfExpr(ENode *expr, SInt32 size, SInt32 level) {
ENodeList *list;
switch (expr->type) {
ENODE_CASE_MONADIC:
size = CInline_EstimateSizeOfExpr(expr->data.monadic, size, level) + 1;
break;
ENODE_CASE_DIADIC_ALL:
size = CInline_EstimateSizeOfExpr(expr->data.diadic.left, size, level);
if (size <= inline_max_size)
size = CInline_EstimateSizeOfExpr(expr->data.diadic.right, size, level) + 1;
break;
case EFUNCCALL:
case EFUNCCALLP:
if (
ENODE_IS(expr->data.funccall.funcref, EOBJREF) &&
expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata &&
CInline_CanExpand(expr->data.funccall.funcref)
)
{
recursive_inline |= expr->data.funccall.funcref->data.objref == expanding_function;
if (level == 0) {
if (!recursive_inline)
size = inline_max_size + 1;
} else {
size = CInline_EstimateSizeOfFunc(expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata, size, level - 1);
}
} else {
size++;
}
for (list = expr->data.funccall.args; list; list = list->next) {
if (size > inline_max_size)
break;
size = CInline_EstimateSizeOfExpr(list->node, size, level);
}
break;
case ECOND:
size = CInline_EstimateSizeOfExpr(expr->data.cond.cond, size, level);
if (size <= inline_max_size)
size = CInline_EstimateSizeOfExpr(expr->data.cond.expr1, size, level) + 1;
if (size <= inline_max_size)
size = CInline_EstimateSizeOfExpr(expr->data.cond.expr2, size, level) + 1;
break;
case ENULLCHECK:
size = CInline_EstimateSizeOfExpr(expr->data.nullcheck.nullcheckexpr, size, level);
if (size <= inline_max_size)
size = CInline_EstimateSizeOfExpr(expr->data.nullcheck.condexpr, size, level) + 1;
break;
case EMFPOINTER:
size = CInline_EstimateSizeOfExpr(expr->data.mfpointer.accessnode, size, level);
if (size <= inline_max_size)
size = CInline_EstimateSizeOfExpr(expr->data.mfpointer.mfpointer, size, level) + 1;
break;
case EMEMBER:
if (expr->data.emember->expr)
size = CInline_EstimateSizeOfExpr(expr->data.emember->expr, size, level) + 1;
break;
default:
size++;
}
return size;
}
static SInt32 CInline_EstimateSizeOfFunc(CI_FuncData *funcdata, SInt32 size, SInt32 level) {
CI_Statement *stmt;
SInt32 i;
size += funcdata->numstatements;
if (size > inline_max_size)
return size;
for (i = 0, stmt = funcdata->statements; i < funcdata->numstatements; i++, stmt++) {
switch (stmt->type) {
case ST_NOP:
case ST_LABEL:
case ST_GOTO:
case ST_ASM:
break;
case ST_EXPRESSION:
case ST_IFGOTO:
case ST_IFNGOTO:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_GOTOEXPR:
size = CInline_EstimateSizeOfExpr(stmt->u.expr, size, level);
break;
case ST_SWITCH:
size = CInline_EstimateSizeOfExpr(stmt->u.switchdata->expr, size, level);
break;
case ST_RETURN:
if (stmt->u.expr)
size = CInline_EstimateSizeOfExpr(stmt->u.expr, size, level);
break;
default:
CError_FATAL(1840);
}
if (size > inline_max_size)
break;
}
return size;
}
static SInt32 EstimateExpandedSizeOfExpr(ENode *expr, SInt32 level) {
ENodeList *list;
SInt32 size;
size = 0;
switch (expr->type) {
ENODE_CASE_MONADIC:
size = EstimateExpandedSizeOfExpr(expr->data.monadic, level) + 1;
break;
ENODE_CASE_DIADIC_ALL:
size = EstimateExpandedSizeOfExpr(expr->data.diadic.left, level) + 1;
size += EstimateExpandedSizeOfExpr(expr->data.diadic.right, level);
break;
case EFUNCCALL:
case EFUNCCALLP:
if (
ENODE_IS(expr->data.funccall.funcref, EOBJREF) &&
expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata &&
CInline_CanExpand(expr->data.funccall.funcref)
)
{
if (level) {
SInt32 est = CInline_EstimateSizeOfFunc(expr->data.funccall.funcref->data.objref->u.func.u.ifuncdata, size, level - 1);
if (est > inline_max_size)
size++;
else
size += est;
} else {
size++;
}
} else {
size++;
}
for (list = expr->data.funccall.args; list; list = list->next)
size += EstimateExpandedSizeOfExpr(list->node, level);
break;
case ECOND:
size = EstimateExpandedSizeOfExpr(expr->data.cond.cond, level) + 1;
size += EstimateExpandedSizeOfExpr(expr->data.cond.expr1, level);
size += EstimateExpandedSizeOfExpr(expr->data.cond.expr2, level);
break;
case ENULLCHECK:
size = EstimateExpandedSizeOfExpr(expr->data.nullcheck.nullcheckexpr, level) + 1;
size += EstimateExpandedSizeOfExpr(expr->data.nullcheck.condexpr, level);
break;
case EMFPOINTER:
size = EstimateExpandedSizeOfExpr(expr->data.mfpointer.accessnode, level) + 1;
size += EstimateExpandedSizeOfExpr(expr->data.mfpointer.mfpointer, level);
break;
case EMEMBER:
if (expr->data.emember->expr)
size = EstimateExpandedSizeOfExpr(expr->data.emember->expr, level);
break;
default:
size++;
}
return size;
}
static SInt32 EstimateExpandedSizeOfFunction(Statement *stmt) {
SInt32 size;
SInt32 level;
level = copts.inlinelevel;
if (!level)
level = 8;
size = 0;
while (stmt) {
switch (stmt->type) {
case ST_NOP:
break;
case ST_EXPRESSION:
case ST_SWITCH:
case ST_IFGOTO:
case ST_IFNGOTO:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_GOTOEXPR:
size++;
size += EstimateExpandedSizeOfExpr(stmt->expr, level);
break;
case ST_RETURN:
size++;
if (stmt->expr)
size = EstimateExpandedSizeOfExpr(stmt->expr, level);
break;
case ST_LABEL:
case ST_GOTO:
case ST_ASM:
size++;
break;
default:
CError_FATAL(2015);
}
stmt = stmt->next;
}
return size;
}
static Boolean CInline_InlineFunctionCheck(ENode *expr) {
Object *object;
SInt32 level;
CI_FuncData *funcdata;
object = expr->data.objref;
if (object->datatype == DALIAS)
object = object->u.alias.object;
if (
IS_TYPE_FUNC(object->type) &&
((object->qual & Q_INLINE) || (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_800)) &&
(object->datatype == DFUNC || (object->datatype == DVFUNC && (expr->flags & ENODE_FLAG_80)))
)
{
if (copts.always_inline)
return 1;
if (copts.inline_bottom_up) {
if (!object->u.func.u.ifuncdata)
return 0;
level = (copts.inlinelevel == 0) ? (7 - cinline_level) : (copts.inlinelevel - cinline_level - 1);
if ((object->qual & Q_INLINE) && level == 0)
return 1;
if (CInline_EstimateSizeOfFunc(object->u.func.u.ifuncdata, 0, level) > inline_max_size)
return 0;
} else if (cinline_level > 0 && copts.inlinelevel == 0) {
funcdata = object->u.func.u.ifuncdata;
if (!funcdata)
return 0;
if (funcdata->numstatements > 10)
return 0;
if (cinline_level > 1 && funcdata->numstatements > 7)
return 0;
if (cinline_level > 2 && funcdata->numstatements > 3)
return 0;
}
return 1;
} else {
return 0;
}
return 0;
}
static ENode *CInline_ExpandExpression(ENode *expr) {
ENodeList *list;
Boolean save;
switch (expr->type) {
case EPOSTINC:
case EPOSTDEC:
case EPREINC:
case EPREDEC:
case EINDIRECT:
case EMONMIN:
case EBINNOT:
case ELOGNOT:
case ETYPCON:
case EBITFIELD:
expr->data.monadic = CInline_ExpandExpression(expr->data.monadic);
break;
case EFORCELOAD:
expr->data.monadic = CInline_ExpandExpression(expr->data.monadic);
if (ENODE_IS(expr->data.monadic, EFORCELOAD))
expr->data.monadic = expr->data.monadic->data.monadic;
break;
case EMUL:
case EDIV:
case EMODULO:
case EADD:
case ESUB:
case ESHL:
case ESHR:
case ELESS:
case EGREATER:
case ELESSEQU:
case EGREATEREQU:
case EEQU:
case ENOTEQU:
case EAND:
case EXOR:
case EOR:
case EASS:
case EMULASS:
case EDIVASS:
case EMODASS:
case EADDASS:
case ESUBASS:
case ESHLASS:
case ESHRASS:
case EANDASS:
case EXORASS:
case EORASS:
case EPMODULO:
case EROTL:
case EROTR:
expr->data.diadic.left = CInline_ExpandExpression(expr->data.diadic.left);
expr->data.diadic.right = CInline_ExpandExpression(expr->data.diadic.right);
break;
case ELAND:
case ELOR:
case ECOMMA:
expr->data.diadic.left = CInline_ExpandExpression(expr->data.diadic.left);
save = cinline_unconditionalpart;
cinline_unconditionalpart = 0;
expr->data.diadic.right = CInline_ExpandExpression(expr->data.diadic.right);
cinline_unconditionalpart = save;
break;
case EFUNCCALL:
case EFUNCCALLP:
expr->data.funccall.funcref = CInline_ExpandExpression(expr->data.funccall.funcref);
for (list = expr->data.funccall.args; list; list = list->next)
list->node = CInline_ExpandExpression(list->node);
if (ENODE_IS(expr->data.funccall.funcref, EOBJREF) && CInline_InlineFunctionCheck(expr->data.funccall.funcref))
expr = CInline_InlineFunctionExpression(expr);
break;
case ENULLCHECK:
expr->data.nullcheck.nullcheckexpr = CInline_ExpandExpression(expr->data.nullcheck.nullcheckexpr);
save = cinline_unconditionalpart;
cinline_unconditionalpart = 0;
expr->data.nullcheck.condexpr = CInline_ExpandExpression(expr->data.nullcheck.condexpr);
cinline_unconditionalpart = save;
break;
case EMFPOINTER:
expr->data.mfpointer.accessnode = CInline_ExpandExpression(expr->data.mfpointer.accessnode);
expr->data.mfpointer.mfpointer = CInline_ExpandExpression(expr->data.mfpointer.mfpointer);
break;
case ECOND:
expr->data.cond.cond = CInline_ExpandExpression(expr->data.cond.cond);
save = cinline_unconditionalpart;
cinline_unconditionalpart = 0;
expr->data.cond.expr1 = CInline_ExpandExpression(expr->data.cond.expr1);
expr->data.cond.expr2 = CInline_ExpandExpression(expr->data.cond.expr2);
cinline_unconditionalpart = save;
break;
case EMEMBER:
if (expr->data.emember->expr)
expr = CInline_ExpandExpression(expr->data.emember->expr);
else
expr = nullnode();
break;
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJREF:
case EPRECOMP:
case ELABEL:
case EOBJLIST:
case EINSTRUCTION:
case EVECTOR128CONST:
break;
default:
CError_FATAL(2235);
}
return expr;
}
static Statement *CInline_NewStatement(StatementType sttype) {
Statement *stmt = lalloc(sizeof(Statement));
memclrw(stmt, sizeof(Statement));
stmt->type = sttype;
if (cinline_serial_stmt)
cinline_cur_serial_stmt->next = stmt;
else
cinline_serial_stmt = stmt;
cinline_cur_serial_stmt = stmt;
return stmt;
}
static ENode *CInline_LoadToTemp(ENode *expr, Object **objectptr) {
Object *object;
object = *objectptr;
if (!object) {
switch (expr->rtype->type) {
case TYPEVOID:
return expr;
case TYPEINT:
case TYPEFLOAT:
case TYPEENUM:
case TYPESTRUCT:
case TYPECLASS:
case TYPEMEMBERPOINTER:
case TYPEPOINTER:
object = create_temp_object(expr->rtype);
*objectptr = object;
break;
default:
CError_FATAL(2288);
}
}
return makediadicnode(create_objectnode(object), expr, EASS);
}
static ENode *CInline_SerializeEFORCELOAD(ENode *expr) {
Statement *stmt;
Object *temp = NULL;
while (ENODE_IS(expr->data.monadic, EFORCELOAD)) {
expr->data.monadic = expr->data.monadic->data.monadic;
}
expr->data.monadic = CInline_SerializeExpr(expr->data.monadic);
stmt = CInline_NewStatement(ST_EXPRESSION);
stmt->expr = CInline_LoadToTemp(expr->data.monadic, &temp);
return create_objectnode(temp);
}
static ENode *CInline_SerializeECOMMA(ENode *expr) {
Statement *stmt;
expr->data.diadic.left = CInline_SerializeExpr(expr->data.diadic.left);
stmt = CInline_NewStatement(ST_EXPRESSION);
stmt->expr = expr->data.diadic.left;
return CInline_SerializeExpr(expr->data.diadic.right);
}
static ENode *CInline_SerializeELOR(ENode *expr) {
ENode *n;
Statement *stmt;
CLabel *label;
Object *temp = NULL;
label = newlabel();
n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.left), ELOGNOT);
n->rtype = expr->rtype;
n = makemonadicnode(n, ELOGNOT);
n = CInline_LoadToTemp(n, &temp);
stmt = CInline_NewStatement(ST_IFGOTO);
stmt->expr = n;
stmt->label = label;
n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.right), ELOGNOT);
n->rtype = expr->rtype;
n = makemonadicnode(n, ELOGNOT);
n = CInline_LoadToTemp(n, &temp);
stmt = CInline_NewStatement(ST_EXPRESSION);
stmt->expr = n;
stmt = CInline_NewStatement(ST_LABEL);
stmt->label = label;
label->stmt = stmt;
return create_objectnode(temp);
}
static ENode *CInline_SerializeELAND(ENode *expr) {
ENode *n;
Statement *stmt;
CLabel *label;
Object *temp = NULL;
label = newlabel();
n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.left), ELOGNOT);
n->rtype = expr->rtype;
n = makemonadicnode(n, ELOGNOT);
n = CInline_LoadToTemp(n, &temp);
stmt = CInline_NewStatement(ST_IFNGOTO);
stmt->expr = n;
stmt->label = label;
n = makemonadicnode(CInline_SerializeExpr(expr->data.diadic.right), ELOGNOT);
n->rtype = expr->rtype;
n = makemonadicnode(n, ELOGNOT);
n = CInline_LoadToTemp(n, &temp);
stmt = CInline_NewStatement(ST_EXPRESSION);
stmt->expr = n;
stmt = CInline_NewStatement(ST_LABEL);
stmt->label = label;
label->stmt = stmt;
return create_objectnode(temp);
}
static ENode *CInline_SerializeEPRECOMP(ENode *expr) {
UIDTemp *uidtemp;
uidtemp = cinline_uid_temps;
while (1) {
if (!uidtemp)
CError_FATAL(2449);
if (uidtemp->uid == expr->data.precompid)
return create_objectnode(uidtemp->object);
uidtemp = uidtemp->next;
}
}
static ENode *CInline_SerializeENULLCHECK(ENode *expr) {
Statement *stmt;
CLabel *label;
ENode *n;
Object *temp = NULL;
UIDTemp uidtemp;
label = newlabel();
n = CInline_SerializeExpr(expr->data.nullcheck.nullcheckexpr);
stmt = CInline_NewStatement(ST_IFNGOTO);
stmt->expr = CInline_LoadToTemp(n, &temp);
stmt->label = label;
uidtemp.next = cinline_uid_temps;
uidtemp.object = temp;
uidtemp.uid = expr->data.nullcheck.precompid;
cinline_uid_temps = &uidtemp;
n = CInline_SerializeExpr(expr->data.nullcheck.condexpr);
stmt = CInline_NewStatement(ST_EXPRESSION);
stmt->expr = CInline_LoadToTemp(n, &temp);
cinline_uid_temps = uidtemp.next;
stmt = CInline_NewStatement(ST_LABEL);
stmt->label = label;
label->stmt = stmt;
return create_objectnode(temp);
}
static ENode *CInline_SerializeECOND(ENode *expr) {
Statement *stmt;
CLabel *label1;
CLabel *label2;
ENode *n;
Object *temp = NULL;
label1 = newlabel();
label2 = newlabel();
n = CInline_SerializeExpr(expr->data.cond.cond);
stmt = CInline_NewStatement(ST_IFNGOTO);
stmt->expr = n;
stmt->label = label1;
n = CInline_SerializeExpr(expr->data.cond.expr1);
n = CInline_LoadToTemp(n, &temp);
stmt = CInline_NewStatement(ST_EXPRESSION);
stmt->expr = n;
stmt = CInline_NewStatement(ST_GOTO);
stmt->label = label2;
stmt = CInline_NewStatement(ST_LABEL);
stmt->label = label1;
label1->stmt = stmt;
n = CInline_SerializeExpr(expr->data.cond.expr2);
n = CInline_LoadToTemp(n, &temp);
stmt = CInline_NewStatement(ST_EXPRESSION);
stmt->expr = n;
stmt = CInline_NewStatement(ST_LABEL);
stmt->label = label2;
label2->stmt = stmt;
if (!temp) {
n = nullnode();
n->rtype = &stvoid;
return n;
}
return create_objectnode(temp);
}
static ENode *CInline_SerializeExpr(ENode *expr) {
ENodeList *list;
switch (expr->type) {
case EFORCELOAD:
return CInline_SerializeEFORCELOAD(expr);
case ECOMMA:
return CInline_SerializeECOMMA(expr);
case ELAND:
return CInline_SerializeELAND(expr);
case ELOR:
return CInline_SerializeELOR(expr);
case EPRECOMP:
return CInline_SerializeEPRECOMP(expr);
case ENULLCHECK:
return CInline_SerializeENULLCHECK(expr);
case ECOND:
return CInline_SerializeECOND(expr);
case EINITTRYCATCH:
expr->data.itc.initexpr = CInline_SerializeExpr(expr->data.itc.initexpr);
expr->data.itc.tryexpr = CInline_SerializeExpr(expr->data.itc.tryexpr);
expr->data.itc.catchexpr = CInline_SerializeExpr(expr->data.itc.catchexpr);
expr->data.itc.result = CInline_SerializeExpr(expr->data.itc.result);
return expr;
case EPOSTINC:
case EPOSTDEC:
case EPREINC:
case EPREDEC:
case EINDIRECT:
case EMONMIN:
case EBINNOT:
case ELOGNOT:
case ETYPCON:
case EBITFIELD:
expr->data.monadic = CInline_SerializeExpr(expr->data.monadic);
return expr;
case EMUL:
case EDIV:
case EMODULO:
case EADD:
case ESUB:
case ESHL:
case ESHR:
case ELESS:
case EGREATER:
case ELESSEQU:
case EGREATEREQU:
case EEQU:
case ENOTEQU:
case EAND:
case EXOR:
case EOR:
case EASS:
case EMULASS:
case EDIVASS:
case EMODASS:
case EADDASS:
case ESUBASS:
case ESHLASS:
case ESHRASS:
case EANDASS:
case EXORASS:
case EORASS:
case EPMODULO:
case EROTL:
case EROTR:
expr->data.diadic.left = CInline_SerializeExpr(expr->data.diadic.left);
expr->data.diadic.right = CInline_SerializeExpr(expr->data.diadic.right);
return expr;
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJREF:
case ELABEL:
case EOBJLIST:
case EINSTRUCTION:
case EVECTOR128CONST:
return expr;
case EFUNCCALL:
case EFUNCCALLP:
expr->data.funccall.funcref = CInline_SerializeExpr(expr->data.funccall.funcref);
for (list = expr->data.funccall.args; list; list = list->next)
list->node = CInline_SerializeExpr(list->node);
return expr;
case EMFPOINTER:
// bug???
expr->data.mfpointer.accessnode = CInline_SerializeExpr(expr->data.mfpointer.accessnode);
expr->data.mfpointer.accessnode = CInline_SerializeExpr(expr->data.mfpointer.mfpointer);
return expr;
case EMEMBER:
if (expr->data.emember->expr)
return CInline_SerializeExpr(expr->data.emember->expr);
return expr;
default:
CError_FATAL(2684);
return expr;
}
}
void CInline_SerializeStatement(Statement *stmt) {
Statement *scan;
Statement *copy;
cinline_serial_stmt = NULL;
cinline_uid_temps = NULL;
stmt->expr = CInline_SerializeExpr(stmt->expr);
if (cinline_serial_stmt) {
for (scan = cinline_serial_stmt; scan; scan = scan->next) {
scan->value = stmt->value;
scan->dobjstack = stmt->dobjstack;
scan->sourceoffset = stmt->sourceoffset;
scan->sourcefilepath = stmt->sourcefilepath;
}
copy = CInline_NewStatement(ST_EXPRESSION);
*copy = *stmt;
*stmt = *cinline_serial_stmt;
}
}
static void CInline_UnpackSwitch(Statement *stmt, CI_Statement *packstmt, CLabel **labels) {
SwitchInfo *info;
SwitchCase *swcase;
short i;
info = lalloc(sizeof(SwitchInfo));
stmt->label = (CLabel *) info;
CError_ASSERT(2730, info->defaultlabel = labels[packstmt->u.switchdata->defaultlabelID]);
info->x8 = packstmt->u.switchdata->unkSwitch8;
for (i = 0; i < packstmt->u.switchdata->numcases; i++) {
if (i == 0) {
swcase = lalloc(sizeof(SwitchCase));
info->cases = swcase;
} else {
swcase->next = lalloc(sizeof(SwitchCase));
swcase = swcase->next;
}
swcase->next = NULL;
swcase->min = packstmt->u.switchdata->cases[i].min;
swcase->max = packstmt->u.switchdata->cases[i].max;
CError_ASSERT(2740, swcase->label = labels[packstmt->u.switchdata->cases[i].labelID]);
}
}
Object *CInline_GetLocalObj(SInt32 id, Boolean flag) {
ObjectList *list;
if (id) {
if (id & 0x80000000) {
id = (id & 0x7FFFFFFF) - 1;
if (flag) {
CError_ASSERT(2761, local_aobjects[id].object);
return local_aobjects[id].object;
}
for (list = arguments; list; list = list->next, id--) {
if (id == 0)
return list->object;
}
CError_FATAL(2765);
} else {
id--;
if (flag) {
CError_ASSERT(2772, local_dobjects[id]);
return local_dobjects[id];
}
for (list = locals; list; list = list->next, id--) {
if (id == 0)
return list->object;
}
CError_FATAL(2776);
}
}
return NULL;
}
static ExceptionAction *CInline_UnpackActions(CI_Statement *packstmt, Boolean flag) {
ExceptionAction *packexc;
ExceptionAction *last;
ExceptionAction *exc;
packexc = packstmt->dobjstack;
last = NULL;
while (packexc) {
exc = galloc(sizeof(ExceptionAction));
exc->prev = last;
last = exc;
exc->type = packexc->type;
switch (packexc->type) {
case EAT_DESTROYLOCAL:
exc->data.destroy_local.local = CInline_GetLocalObj((SInt32) packexc->data.destroy_local.local, flag);
exc->data.destroy_local.dtor = packexc->data.destroy_local.dtor;
break;
case EAT_DESTROYLOCALCOND:
exc->data.destroy_local_cond.local = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_cond.local, flag);
exc->data.destroy_local_cond.dtor = packexc->data.destroy_local_cond.dtor;
exc->data.destroy_local_cond.cond = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_cond.cond, flag);
break;
case EAT_DESTROYLOCALOFFSET:
exc->data.destroy_local_offset.local = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_offset.local, flag);
exc->data.destroy_local_offset.dtor = packexc->data.destroy_local_offset.dtor;
exc->data.destroy_local_offset.offset = packexc->data.destroy_local_offset.offset;
break;
case EAT_DESTROYLOCALPOINTER:
exc->data.destroy_local_pointer.pointer = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_pointer.pointer, flag);
exc->data.destroy_local_pointer.dtor = packexc->data.destroy_local_pointer.dtor;
break;
case EAT_DESTROYLOCALARRAY:
exc->data.destroy_local_array.localarray = CInline_GetLocalObj((SInt32) packexc->data.destroy_local_array.localarray, flag);
exc->data.destroy_local_array.dtor = packexc->data.destroy_local_array.dtor;
exc->data.destroy_local_array.elements = packexc->data.destroy_local_array.elements;
exc->data.destroy_local_array.element_size = packexc->data.destroy_local_array.element_size;
break;
case EAT_DESTROYPARTIALARRAY:
exc->data.destroy_partial_array.arraypointer = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.arraypointer, flag);
exc->data.destroy_partial_array.arraycounter = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.arraycounter, flag);
exc->data.destroy_partial_array.dtor = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.dtor, flag);
exc->data.destroy_partial_array.element_size = CInline_GetLocalObj((SInt32) packexc->data.destroy_partial_array.element_size, flag);
break;
case EAT_DESTROYMEMBER:
case EAT_DESTROYBASE:
exc->data.destroy_member.objectptr = CInline_GetLocalObj((SInt32) packexc->data.destroy_member.objectptr, flag);
exc->data.destroy_member.dtor = packexc->data.destroy_member.dtor;
exc->data.destroy_member.offset = packexc->data.destroy_member.offset;
break;
case EAT_DESTROYMEMBERCOND:
exc->data.destroy_member_cond.objectptr = CInline_GetLocalObj((SInt32) packexc->data.destroy_member_cond.objectptr, flag);
exc->data.destroy_member_cond.cond = CInline_GetLocalObj((SInt32) packexc->data.destroy_member_cond.cond, flag);
exc->data.destroy_member_cond.dtor = packexc->data.destroy_member_cond.dtor;
exc->data.destroy_member_cond.offset = packexc->data.destroy_member_cond.offset;
break;
case EAT_DESTROYMEMBERARRAY:
exc->data.destroy_member_array.objectptr = CInline_GetLocalObj((SInt32) packexc->data.destroy_member_array.objectptr, flag);
exc->data.destroy_member_array.dtor = packexc->data.destroy_member_array.dtor;
exc->data.destroy_member_array.offset = packexc->data.destroy_member_array.offset;
exc->data.destroy_member_array.elements = packexc->data.destroy_member_array.elements;
exc->data.destroy_member_array.element_size = packexc->data.destroy_member_array.element_size;
break;
case EAT_DELETEPOINTER:
case EAT_DELETELOCALPOINTER:
exc->data.delete_pointer.pointerobject = CInline_GetLocalObj((SInt32) packexc->data.delete_pointer.pointerobject, flag);
exc->data.delete_pointer.deletefunc = packexc->data.delete_pointer.deletefunc;
break;
case EAT_DELETEPOINTERCOND:
exc->data.delete_pointer_cond.pointerobject = CInline_GetLocalObj((SInt32) packexc->data.delete_pointer_cond.pointerobject, flag);
exc->data.delete_pointer_cond.deletefunc = packexc->data.delete_pointer_cond.deletefunc;
exc->data.delete_pointer_cond.cond = CInline_GetLocalObj((SInt32) packexc->data.delete_pointer_cond.cond, flag);
break;
case EAT_CATCHBLOCK: {
LabelTrans *trans;
exc->data.catch_block.catch_object = CInline_GetLocalObj((SInt32) packexc->data.catch_block.catch_object, flag);
exc->data.catch_block.catch_info_object = CInline_GetLocalObj((SInt32) packexc->data.catch_block.catch_info_object, flag);
trans = lalloc(sizeof(LabelTrans));
trans->next = cinline_label_trans;
cinline_label_trans = trans;
trans->id = (SInt32) packexc->data.catch_block.catch_label;
trans->labelptr = &exc->data.catch_block.catch_label;
exc->data.catch_block.catch_typeid = packexc->data.catch_block.catch_typeid;
exc->data.catch_block.catch_type = packexc->data.catch_block.catch_type;
exc->data.catch_block.catch_qual = packexc->data.catch_block.catch_qual;
break;
}
case EAT_ACTIVECATCHBLOCK:
exc->data.active_catch_block.catch_info_object = CInline_GetLocalObj((SInt32) packexc->data.active_catch_block.catch_info_object, flag);
break;
case EAT_SPECIFICATION: {
LabelTrans *trans;
exc->data.specification.unexp_ids = packexc->data.specification.unexp_ids;
exc->data.specification.unexp_id = packexc->data.specification.unexp_id;
trans = lalloc(sizeof(LabelTrans));
trans->next = cinline_label_trans;
cinline_label_trans = trans;
trans->id = (SInt32) packexc->data.specification.unexp_label;
trans->labelptr = &exc->data.specification.unexp_label;
exc->data.specification.unexp_info_object = CInline_GetLocalObj((SInt32) packexc->data.specification.unexp_info_object, flag);
break;
}
case EAT_TERMINATE:
break;
default:
CError_FATAL(2904);
}
packexc = packexc->prev;
}
return last;
}
static Statement *CInline_ExpandStatements(Object *funcobj, Statement *stmt, CI_FuncData *funcdata, ENode *funccall, CLabel *label, Object *resultobj, Boolean flag) {
CLabel **labels;
CI_Statement *packstmt;
short i;
CI_StmtLink *stmtLinks;
CI_StmtLink *link;
ENode *setupArgs;
Boolean is_result_class_1;
Statement origStmt;
origStmt = *stmt;
is_result_class_1 = CMach_GetFunctionResultClass(TYPE_FUNC(funcobj->type)) == 1;
if ((setupArgs = CInline_SetupArgsExpression(funcobj, funcdata, funccall->data.funccall.args))) {
stmt->type = ST_EXPRESSION;
stmt->expr = CInline_FoldConst(setupArgs);
} else {
stmt->type = ST_NOP;
}
stmtLinks = NULL;
cinline_label_trans = NULL;
labels = lalloc(sizeof(CLabel *) * funcdata->numstatements);
memclrw(labels, sizeof(CLabel *) * funcdata->numstatements);
for (i = 0, packstmt = funcdata->statements; i < funcdata->numstatements; i++, packstmt++) {
stmt->next = lalloc(sizeof(Statement));
stmt = stmt->next;
*stmt = origStmt;
stmt->type = packstmt->type;
stmt->flags = packstmt->flags;
stmt->value += packstmt->value;
if (packstmt->dobjstack) {
ExceptionAction *unpacked = CInline_UnpackActions(packstmt, 1);
if (stmt->dobjstack) {
ExceptionAction *scan = unpacked;
while (scan->prev)
scan = scan->prev;
scan->prev = stmt->dobjstack;
}
stmt->dobjstack = unpacked;
}
switch (stmt->type) {
case ST_NOP:
break;
case ST_EXPRESSION:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_GOTOEXPR:
stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.expr, CopyMode4));
break;
case ST_RETURN:
if (packstmt->u.expr) {
stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.expr, CopyMode4));
if (is_result_class_1)
stmt->expr = makecommaexpression(stmt->expr, CInline_ReturnMemResult(funcobj));
if (resultobj) {
stmt->type = ST_EXPRESSION;
stmt->expr = makediadicnode(create_objectnode2(resultobj), stmt->expr, EASS);
} else {
stmt->type = origStmt.type;
if (stmt->type == ST_EXPRESSION && !CInline_ExpressionHasSideEffect(stmt->expr))
stmt->type = ST_NOP;
}
if (label) {
stmt->next = lalloc(sizeof(Statement));
stmt = stmt->next;
*stmt = origStmt;
stmt->type = ST_GOTO;
stmt->label = label;
}
} else {
if (label) {
stmt->type = ST_GOTO;
stmt->label = label;
} else {
stmt->type = ST_NOP;
}
}
break;
case ST_LABEL:
labels[i] = stmt->label = newlabel();
stmt->label->stmt = stmt;
break;
case ST_IFGOTO:
case ST_IFNGOTO:
stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.ifgoto.expr, CopyMode4));
case ST_GOTO:
link = lalloc(sizeof(CI_StmtLink));
link->next = stmtLinks;
stmtLinks = link;
link->stmt = stmt;
link->ciStmt = packstmt;
break;
case ST_SWITCH:
stmt->expr = CInline_FoldConst(CInline_CopyExpression(packstmt->u.switchdata->expr, CopyMode4));
case ST_ASM:
link = lalloc(sizeof(CI_StmtLink));
link->next = stmtLinks;
stmtLinks = link;
link->stmt = stmt;
link->ciStmt = packstmt;
break;
default:
CError_FATAL(3040);
}
}
if (label) {
stmt->next = lalloc(sizeof(Statement));
stmt = stmt->next;
*stmt = origStmt;
stmt->type = ST_LABEL;
stmt->label = label;
label->stmt = stmt;
if (flag) {
stmt->next = lalloc(sizeof(Statement));
stmt = stmt->next;
*stmt = origStmt;
}
}
while (stmtLinks) {
Statement *linkstmt = stmtLinks->stmt;
packstmt = stmtLinks->ciStmt;
switch (linkstmt->type) {
case ST_GOTO:
CError_ASSERT(3060, linkstmt->label = labels[packstmt->u.statementnum]);
break;
case ST_IFGOTO:
case ST_IFNGOTO:
CError_ASSERT(3065, linkstmt->label = labels[packstmt->u.ifgoto.statementnum]);
break;
case ST_SWITCH:
CInline_UnpackSwitch(linkstmt, packstmt, labels);
break;
case ST_ASM:
InlineAsm_UnpackAsmStatement(linkstmt, labels, 1, packstmt->u.asmdata.data, packstmt->u.asmdata.size);
break;
default:
CError_FATAL(3076);
}
stmtLinks = stmtLinks->next;
}
while (cinline_label_trans) {
CError_ASSERT(3083, *cinline_label_trans->labelptr = labels[cinline_label_trans->id]);
cinline_label_trans = cinline_label_trans->next;
}
return stmt;
}
static Statement *CInline_InlineFunctionStatement(Statement *stmt, Boolean *changed) {
Object *object;
CI_FuncData *funcdata;
CLabel *label;
*changed = 0;
object = stmt->expr->data.funccall.funcref->data.objref;
if (object->datatype == DALIAS)
object = object->u.alias.object;
funcdata = object->u.func.u.ifuncdata;
if (!funcdata || funcdata->can_inline < CI_CanInline3)
return stmt;
if (stmt->type != ST_EXPRESSION) {
short i;
for (i = 0; i < (funcdata->numstatements - 1); i++) {
if (funcdata->statements[i].type == ST_RETURN)
return stmt;
}
if (funcdata->statements[funcdata->numstatements - 1].type != ST_RETURN)
return stmt;
label = NULL;
} else {
label = newlabel();
}
*changed = 1;
fix lots more issues, add endian conversions to ObjGenMachO, add 64-bit kludge to Switch.c
2023-01-13 01:36:56 +00:00
return CInline_ExpandStatements(object, stmt, funcdata, stmt->expr, label, NULL, 0);
dump lots more code
2022-12-29 12:32:55 +00:00
}
static Statement *CInline_ExtractInlineFunction(Statement *stmt) {
ENode *expr;
CI_FuncData *funcdata;
short i;
Object *funcObject;
Object *resultObject;
for (i = 0; i < cinline_stmtlevelexprs; i++) {
expr = cinline_stmtlevelexpr[i];
funcObject = expr->data.funccall.funcref->data.objref;
if (funcObject->datatype == DALIAS)
funcObject = funcObject->u.alias.object;
if ((funcdata = funcObject->u.func.u.ifuncdata)) {
TypeFunc *tfunc = TYPE_FUNC(funcObject->type);
CError_ASSERT(3141, IS_TYPE_FUNC(tfunc));
if (!IS_TYPE_VOID(tfunc->functype)) {
if (CMach_GetFunctionResultClass(TYPE_FUNC(funcObject->type)) == 1)
resultObject = CInline_NewLocalObject(CDecl_NewPointerType(tfunc->functype), 0, 0, 0);
else
resultObject = CInline_NewLocalObject(tfunc->functype, 0, 0, 0);
} else {
resultObject = NULL;
}
stmt = CInline_ExpandStatements(funcObject, stmt, funcdata, expr, newlabel(), resultObject, 1);
if (resultObject)
*expr = *create_objectnode2(resultObject);
else
*expr = *nullnode();
}
}
return stmt;
}
static Statement *CInline_ExpandStatement(Statement *stmt) {
Boolean changed;
do {
changed = 0;
if (
stmt->type == ST_EXPRESSION &&
ENODE_IS(stmt->expr, EINDIRECT) &&
!CParser_IsVolatile(stmt->expr->rtype, ENODE_QUALS(stmt->expr))
)
{
stmt->expr = stmt->expr->data.monadic;
changed = 1;
if (ENODE_IS2(stmt->expr, EOBJREF, EBITFIELD))
stmt->expr = nullnode();
}
if (ENODE_IS(stmt->expr, ECOMMA)) {
Statement *newStmt = lalloc(sizeof(Statement));
*newStmt = *stmt;
stmt->next = newStmt;
stmt->type = ST_EXPRESSION;
stmt->expr = stmt->expr->data.diadic.left;
newStmt->expr = newStmt->expr->data.diadic.right;
changed = 1;
}
} while (changed);
if (
ENODE_IS2(stmt->expr, EFUNCCALL, EFUNCCALLP) &&
ENODE_IS(stmt->expr->data.funccall.funcref, EOBJREF) &&
CInline_InlineFunctionCheck(stmt->expr->data.funccall.funcref)
)
{
stmt = CInline_InlineFunctionStatement(stmt, &changed);
if (changed) {
any_inline_expanded = 1;
return stmt;
}
}
inline_expanded = 0;
cinline_unconditionalpart = 1;
cinline_serialize_stmt = 0;
cinline_stmtlevelexprs = 0;
stmt->expr = CInline_ExpandExpression(stmt->expr);
if (cinline_serialize_stmt) {
cinline_unconditionalpart = 1;
cinline_serialize_stmt = 0;
cinline_stmtlevelexprs = 0;
CInline_SerializeStatement(stmt);
stmt->expr = CInline_ExpandExpression(stmt->expr);
}
if (inline_expanded) {
stmt->expr = CInline_FoldConst(stmt->expr);
any_inline_expanded = 1;
}
if (cinline_stmtlevelexprs) {
stmt = CInline_ExtractInlineFunction(stmt);
any_inline_expanded = 1;
}
return stmt;
}
static void CInline_ForceReverseSearch(ENode *) {
cinline_funccallfound = 1;
}
static ENode *CInline_ForceReverseEvaluation(ENode *expr) {
ENode *commanodes;
ENodeList *list;
int counter;
ENode *ass;
ENode *inner;
ENode *copy;
list = expr->data.funccall.args;
counter = 0;
commanodes = NULL;
while (list) {
cinline_funccallfound = 0;
inner = list->node;
CExpr_SearchExprTree(inner, CInline_ForceReverseSearch, 2, EFUNCCALL, EFUNCCALLP);
if (cinline_funccallfound && ++counter > 0) {
inner = create_objectrefnode(create_temp_object(inner->rtype));
copy = lalloc(sizeof(ENode));
*copy = *inner;
copy = makemonadicnode(copy, EINDIRECT);
copy->rtype = TPTR_TARGET(copy->rtype);
inner = makemonadicnode(inner, EINDIRECT);
inner->rtype = TPTR_TARGET(inner->rtype);
ass = makediadicnode(inner, copy, EASS);
list->node = copy;
if (commanodes)
commanodes = makediadicnode(ass, commanodes, ECOMMA);
else
commanodes = ass;
}
list = list->next;
}
if (commanodes) {
commanodes = makediadicnode(commanodes, expr, ECOMMA);
commanodes->rtype = expr->rtype;
return commanodes;
}
return expr;
}
static void CInline_ExportCheck(ENode *expr) {
while (1) {
switch (expr->type) {
case EOBJREF:
CInline_ObjectAddrRef(expr->data.objref);
if (expr->data.objref->datatype == DALIAS) {
CExpr_AliasTransform(expr);
continue;
}
return;
ENODE_CASE_MONADIC:
expr = expr->data.monadic;
continue;
ENODE_CASE_DIADIC_ALL:
CInline_ExportCheck(expr->data.diadic.left);
expr = expr->data.diadic.right;
continue;
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EPRECOMP:
case EINSTRUCTION:
case EVECTOR128CONST:
return;
case ELABEL:
if (expr->data.label->stmt)
expr->data.label->stmt->flags |= StmtFlag_1;
return;
case EFUNCCALL:
case EFUNCCALLP: {
ENodeList *list;
TypeClass *tclass;
SInt32 index;
for (list = expr->data.funccall.args; list; list = list->next)
CInline_ExportCheck(list->node);
expr = expr->data.funccall.funcref;
if (
copts.warn_notinlined &&
!copts.dont_inline &&
ENODE_IS(expr, EOBJREF) &&
(expr->data.objref->qual & Q_INLINE) &&
expr->data.objref->datatype != DINLINEFUNC &&
!CParser_IsVirtualFunction(expr->data.objref, &tclass, &index)
)
CError_Warning(CErrorStr342, expr->data.objref);
continue;
}
case ENULLCHECK:
CInline_ExportCheck(expr->data.nullcheck.nullcheckexpr);
expr = expr->data.nullcheck.condexpr;
continue;
case EMFPOINTER:
*expr = *nullnode();
continue;
case ECOND:
CInline_ExportCheck(expr->data.cond.cond);
CInline_ExportCheck(expr->data.cond.expr1);
expr = expr->data.cond.expr2;
continue;
case EMEMBER:
if (expr->data.emember->expr) {
*expr = *expr->data.emember->expr;
continue;
}
case EOBJLIST:
*expr = *nullnode();
continue;
default:
CError_FATAL(3372);
}
}
}
static void CInline_Expand(Statement *stmt) {
Statement *scan;
if (!copts.dont_inline && copts.inlinelevel >= 0) {
if (copts.inline_bottom_up) {
inline_max_size = copts.inline_max_size;
while (inline_max_size > 1 && EstimateExpandedSizeOfFunction(stmt) > copts.inline_max_total_size)
inline_max_size >>= 1;
}
cinline_level = 0;
while (1) {
any_inline_expanded = 0;
for (scan = stmt; scan; scan = scan->next) {
switch (scan->type) {
case ST_NOP:
case ST_LABEL:
case ST_GOTO:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_ASM:
break;
case ST_RETURN:
if (!scan->expr)
break;
case ST_EXPRESSION:
case ST_SWITCH:
case ST_IFGOTO:
case ST_IFNGOTO:
case ST_GOTOEXPR:
scan = CInline_ExpandStatement(scan);
break;
default:
CError_FATAL(3438);
}
}
if (!copts.inline_bottom_up && !any_inline_expanded)
break;
if (!copts.always_inline || copts.inline_bottom_up) {
if (copts.inlinelevel == 0) {
if (copts.inline_bottom_up) {
if ((cinline_level + 1) >= 8)
break;
} else {
if (cinline_level >= 3)
break;
}
} else {
if ((cinline_level + 1) >= copts.inlinelevel)
break;
}
}
if (CWDisplayLines(cparamblkptr->context, lines) != cwNoErr)
CError_UserBreak();
cinline_level++;
}
}
while (stmt) {
if (stmt->dobjstack)
CExcept_CheckStackRefs(stmt->dobjstack);
switch (stmt->type) {
case ST_NOP:
case ST_LABEL:
case ST_GOTO:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_ASM:
break;
case ST_RETURN:
if (!stmt->expr)
break;
case ST_EXPRESSION:
case ST_SWITCH:
case ST_IFGOTO:
case ST_IFNGOTO:
case ST_GOTOEXPR:
CInline_ExportCheck(stmt->expr);
break;
default:
CError_FATAL(3501);
}
stmt = stmt->next;
}
}
SInt16 CInline_GetStatementNumber(Statement *first, Statement *stmt) {
SInt16 number = 0;
while (first) {
if (first == stmt)
return number;
first = first->next;
number++;
}
CError_FATAL(3517);
return 0;
}
static CI_Switch *CInline_PackSwitch(Statement *start, Statement *stmt) {
SwitchInfo *info;
SwitchCase *swcase;
short numcases;
CI_Switch *packed;
info = (SwitchInfo *) stmt->label;
swcase = info->cases;
numcases = 0;
while (swcase) {
swcase = swcase->next;
numcases++;
}
packed = galloc(sizeof(CI_Switch) + numcases * sizeof(CI_SwitchCase));
packed->expr = CInline_CopyExpression(stmt->expr, CopyMode2);
packed->defaultlabelID = CInline_GetStatementNumber(start, info->defaultlabel->stmt);
packed->unkSwitch8 = info->x8;
packed->numcases = numcases;
for (swcase = info->cases, numcases = 0; swcase; swcase = swcase->next, numcases++) {
packed->cases[numcases].labelID = CInline_GetStatementNumber(start, swcase->label->stmt);
packed->cases[numcases].min = swcase->min;
packed->cases[numcases].max = swcase->max;
}
return packed;
}
static UInt8 CInline_CanInline(Object *object, Statement *stmt) {
UInt8 resultClass;
FuncArg *arg;
UInt8 result;
resultClass = CMach_GetFunctionResultClass(TYPE_FUNC(object->type));
if (
resultClass &&
(resultClass != 1 || (IS_TYPE_CLASS(TYPE_FUNC(object->type)->functype) && CClass_Destructor(TYPE_CLASS(TYPE_FUNC(object->type)->functype))))
)
return CI_CanInline0;
for (arg = TYPE_FUNC(object->type)->args; arg; arg = arg->next) {
if (arg == &elipsis)
return CI_CanInline0;
if (arg == &oldstyle)
break;
if (IS_TYPE_CLASS(arg->type) && CClass_Destructor(TYPE_CLASS(arg->type)))
return CI_CanInline0;
}
result = CI_CanInline6;
while (stmt) {
if (stmt->dobjstack)
return CI_CanInline3;
switch (stmt->type) {
case ST_EXPRESSION:
break;
case ST_RETURN:
if (stmt->next || (stmt->expr == NULL && TYPE_FUNC(object->type)->functype != &stvoid))
result = CI_CanInline3;
break;
default:
result = CI_CanInline3;
}
stmt = stmt->next;
}
return result;
}
static ExceptionAction *CInline_PackActions(Statement *start, Statement *stmt) {
ExceptionAction *exc;
ExceptionAction *last;
ExceptionAction *packexc;
exc = stmt->dobjstack;
last = NULL;
while (exc) {
packexc = galloc(sizeof(ExceptionAction));
packexc->prev = last;
last = packexc;
packexc->type = exc->type;
switch (exc->type) {
case EAT_DESTROYLOCAL:
packexc->data.destroy_local.local = (void *) CInline_GetLocalID(exc->data.destroy_local.local);
packexc->data.destroy_local.dtor = exc->data.destroy_local.dtor;
break;
case EAT_DESTROYLOCALCOND:
packexc->data.destroy_local_cond.local = (void *) CInline_GetLocalID(exc->data.destroy_local_cond.local);
packexc->data.destroy_local_cond.dtor = exc->data.destroy_local_cond.dtor;
packexc->data.destroy_local_cond.cond = (void *) CInline_GetLocalID(exc->data.destroy_local_cond.cond);
break;
case EAT_DESTROYLOCALOFFSET:
packexc->data.destroy_local_offset.local = (void *) CInline_GetLocalID(exc->data.destroy_local_offset.local);
packexc->data.destroy_local_offset.dtor = exc->data.destroy_local_offset.dtor;
packexc->data.destroy_local_offset.offset = exc->data.destroy_local_offset.offset;
break;
case EAT_DESTROYLOCALPOINTER:
packexc->data.destroy_local_pointer.pointer = (void *) CInline_GetLocalID(exc->data.destroy_local_pointer.pointer);
packexc->data.destroy_local_pointer.dtor = exc->data.destroy_local_pointer.dtor;
break;
case EAT_DESTROYLOCALARRAY:
packexc->data.destroy_local_array.localarray = (void *) CInline_GetLocalID(exc->data.destroy_local_array.localarray);
packexc->data.destroy_local_array.dtor = exc->data.destroy_local_array.dtor;
packexc->data.destroy_local_array.elements = exc->data.destroy_local_array.elements;
packexc->data.destroy_local_array.element_size = exc->data.destroy_local_array.element_size;
break;
case EAT_DESTROYPARTIALARRAY:
packexc->data.destroy_partial_array.arraypointer = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.arraypointer);
packexc->data.destroy_partial_array.arraycounter = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.arraycounter);
packexc->data.destroy_partial_array.dtor = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.dtor);
packexc->data.destroy_partial_array.element_size = (void *) CInline_GetLocalID(exc->data.destroy_partial_array.element_size);
break;
case EAT_DESTROYMEMBER:
case EAT_DESTROYBASE:
packexc->data.destroy_member.objectptr = (void *) CInline_GetLocalID(exc->data.destroy_member.objectptr);
packexc->data.destroy_member.dtor = exc->data.destroy_member.dtor;
packexc->data.destroy_member.offset = exc->data.destroy_member.offset;
break;
case EAT_DESTROYMEMBERCOND:
packexc->data.destroy_member_cond.objectptr = (void *) CInline_GetLocalID(exc->data.destroy_member_cond.objectptr);
packexc->data.destroy_member_cond.cond = (void *) CInline_GetLocalID(exc->data.destroy_member_cond.cond);
packexc->data.destroy_member_cond.dtor = exc->data.destroy_member_cond.dtor;
packexc->data.destroy_member_cond.offset = exc->data.destroy_member_cond.offset;
break;
case EAT_DESTROYMEMBERARRAY:
packexc->data.destroy_member_array.objectptr = (void *) CInline_GetLocalID(exc->data.destroy_member_array.objectptr);
packexc->data.destroy_member_array.dtor = exc->data.destroy_member_array.dtor;
packexc->data.destroy_member_array.offset = exc->data.destroy_member_array.offset;
packexc->data.destroy_member_array.elements = exc->data.destroy_member_array.elements;
packexc->data.destroy_member_array.element_size = exc->data.destroy_member_array.element_size;
break;
case EAT_DELETEPOINTER:
case EAT_DELETELOCALPOINTER:
packexc->data.delete_pointer.pointerobject = (void *) CInline_GetLocalID(exc->data.delete_pointer.pointerobject);
packexc->data.delete_pointer.deletefunc = exc->data.delete_pointer.deletefunc;
break;
case EAT_DELETEPOINTERCOND:
packexc->data.delete_pointer_cond.pointerobject = (void *) CInline_GetLocalID(exc->data.delete_pointer_cond.pointerobject);
packexc->data.delete_pointer_cond.deletefunc = exc->data.delete_pointer_cond.deletefunc;
packexc->data.delete_pointer_cond.cond = (void *) CInline_GetLocalID(exc->data.delete_pointer_cond.cond);
break;
case EAT_CATCHBLOCK:
packexc->data.catch_block.catch_object = (void *) CInline_GetLocalID(exc->data.catch_block.catch_object);
packexc->data.catch_block.catch_info_object = (void *) CInline_GetLocalID(exc->data.catch_block.catch_info_object);
packexc->data.catch_block.catch_label = (void *) CInline_GetStatementNumber(start->next, exc->data.catch_block.catch_label->stmt);
packexc->data.catch_block.catch_typeid = exc->data.catch_block.catch_typeid;
packexc->data.catch_block.catch_type = exc->data.catch_block.catch_type;
packexc->data.catch_block.catch_qual = exc->data.catch_block.catch_qual;
break;
case EAT_ACTIVECATCHBLOCK:
packexc->data.active_catch_block.catch_info_object = (void *) CInline_GetLocalID(exc->data.active_catch_block.catch_info_object);
packexc->data.active_catch_block.call_dtor = exc->data.active_catch_block.call_dtor;
break;
case EAT_SPECIFICATION:
packexc->data.specification.unexp_ids = exc->data.specification.unexp_ids;
packexc->data.specification.unexp_id = exc->data.specification.unexp_id;
packexc->data.specification.unexp_label = (void *) CInline_GetStatementNumber(start->next, exc->data.specification.unexp_label->stmt);
packexc->data.specification.unexp_info_object = (void *) CInline_GetLocalID(exc->data.specification.unexp_info_object);
break;
case EAT_TERMINATE:
break;
default:
CError_FATAL(3720);
}
exc = exc->prev;
}
return last;
}
void CInline_PackIFunctionData(CI_FuncData *funcdata, Statement *stmt, Object *object) {
ObjectList *list;
CI_Var *var;
Statement *scan;
CI_Statement *packstmt;
int i;
cinline_first_stmt = stmt->next;
memclrw(funcdata, sizeof(CI_FuncData));
funcdata->can_inline = CInline_CanInline(object, stmt->next);
if (copts.isGeneratingDebugInfo) {
funcdata->fileoffset = cparser_fileoffset;
funcdata->fileoffset.is_inline = 1;
funcdata->symdecloffset = symdecloffset;
funcdata->functionbodyoffset = functionbodyoffset;
funcdata->functionbodypath = functionbodypath;
funcdata->symdeclend = symdeclend;
}
list = arguments;
i = 0;
while (list) {
list = list->next;
i++;
}
if ((funcdata->numarguments = i) > 0) {
loc_args = funcdata->arguments = galloc(sizeof(CI_Var) * i);
memclrw(funcdata->arguments, sizeof(CI_Var) * i);
for (list = arguments, var = funcdata->arguments; list; list = list->next, var++) {
var->name = list->object->name;
var->type = list->object->type;
var->qual = list->object->qual;
var->sflags = CInline_GetObjectSFlags(list->object);
var->xD = 0;
var->xE = 1;
}
}
list = locals;
i = 0;
while (list) {
if (list->object->datatype == DLOCAL)
i++;
list = list->next;
}
if ((funcdata->numlocals = i) > 0) {
loc_vars = funcdata->locals = galloc(sizeof(CI_Var) * i);
memclrw(funcdata->locals, sizeof(CI_Var) * i);
for (list = locals, var = funcdata->locals; list; list = list->next) {
if (list->object->datatype == DLOCAL) {
var->name = list->object->name;
var->type = list->object->type;
var->qual = list->object->qual;
var->sflags = CInline_GetObjectSFlags(list->object);
var->xD = 0;
var->xE = 0;
var++;
}
}
}
scan = stmt->next;
i = 0;
while (scan) {
scan = scan->next;
i++;
}
funcdata->numstatements = i;
funcdata->statements = galloc(sizeof(CI_Statement) * i);
for (scan = stmt->next, packstmt = funcdata->statements; scan; scan = scan->next, packstmt++) {
packstmt->type = scan->type;
packstmt->flags = scan->flags;
packstmt->value = scan->value;
packstmt->dobjstack = CInline_PackActions(stmt, scan);
packstmt->sourceoffset = scan->sourceoffset;
packstmt->sourcefilepath = scan->sourcefilepath;
switch (scan->type) {
case ST_NOP:
case ST_LABEL:
break;
case ST_EXPRESSION:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_GOTOEXPR:
packstmt->u.expr = CInline_CopyExpression(scan->expr, CopyMode2);
break;
case ST_RETURN:
if (scan->expr)
packstmt->u.expr = CInline_CopyExpression(scan->expr, CopyMode2);
else
packstmt->u.expr = NULL;
break;
case ST_GOTO:
packstmt->u.statementnum = CInline_GetStatementNumber(stmt->next, scan->label->stmt);
break;
case ST_IFGOTO:
case ST_IFNGOTO:
packstmt->u.ifgoto.expr = CInline_CopyExpression(scan->expr, CopyMode2);
packstmt->u.ifgoto.statementnum = CInline_GetStatementNumber(stmt->next, scan->label->stmt);
break;
case ST_SWITCH:
packstmt->u.switchdata = CInline_PackSwitch(stmt->next, scan);
break;
case ST_ASM:
InlineAsm_PackAsmStatement(scan, stmt->next, &packstmt->u.asmdata.data, &packstmt->u.asmdata.size);
break;
default:
CError_FATAL(3862);
}
}
}
void CInline_UnpackIFunctionData(Object *object, CI_FuncData *funcdata, Statement *firstStmt) {
CLabel **labels;
CI_Var *var;
ObjectList *last;
Statement *stmt;
CI_Statement *packstmt;
int i;
cparser_fileoffset = funcdata->fileoffset;
symdecloffset = funcdata->symdecloffset;
functionbodyoffset = funcdata->functionbodyoffset;
functionbodypath = funcdata->functionbodypath;
symdeclend = funcdata->symdeclend;
for (i = 0, var = funcdata->arguments; i < funcdata->numarguments; i++, var++) {
if (i == 0) {
last = lalloc(sizeof(ObjectList));
arguments = last;
} else {
last->next = lalloc(sizeof(ObjectList));
last = last->next;
}
object = galloc(sizeof(Object));
memclrw(object, sizeof(Object));
last->object = object;
last->next = NULL;
object->otype = OT_OBJECT;
object->access = ACCESSPUBLIC;
object->datatype = DLOCAL;
object->name = var->name;
object->type = var->type;
object->qual = var->qual;
CInline_SetObjectSFlags(object, var->sflags);
CFunc_SetupLocalVarInfo(object);
if (funcdata->fileoffset.file) {
object->u.var.info->deftoken.tokenfile = funcdata->fileoffset.file;
object->u.var.info->deftoken.tokenoffset = funcdata->functionbodyoffset;
}
}
for (i = 0, var = funcdata->locals; i < funcdata->numlocals; i++, var++) {
if (i == 0) {
last = lalloc(sizeof(ObjectList));
locals = last;
} else {
last->next = lalloc(sizeof(ObjectList));
last = last->next;
}
object = galloc(sizeof(Object));
memclrw(object, sizeof(Object));
last->object = object;
last->next = NULL;
object->otype = OT_OBJECT;
object->access = ACCESSPUBLIC;
object->datatype = DLOCAL;
object->name = var->name;
object->type = var->type;
object->qual = var->qual;
CInline_SetObjectSFlags(object, var->sflags);
CFunc_SetupLocalVarInfo(object);
if (funcdata->fileoffset.file) {
object->u.var.info->deftoken.tokenfile = funcdata->fileoffset.file;
object->u.var.info->deftoken.tokenoffset = funcdata->functionbodyoffset;
}
}
enode_idtrans = NULL;
cinline_label_trans = NULL;
labels = lalloc(sizeof(CLabel *) * funcdata->numstatements);
memclrw(labels, sizeof(CLabel *) * funcdata->numstatements);
for (i = 0, stmt = firstStmt, packstmt = funcdata->statements; i < funcdata->numstatements; i++, packstmt++) {
stmt->next = lalloc(sizeof(Statement));
stmt = stmt->next;
stmt->type = packstmt->type;
stmt->flags = packstmt->flags;
stmt->value = packstmt->value;
stmt->sourceoffset = packstmt->sourceoffset;
stmt->sourcefilepath = packstmt->sourcefilepath;
stmt->dobjstack = CInline_UnpackActions(packstmt, 0);
stmt->next = NULL;
switch (stmt->type) {
case ST_NOP:
case ST_GOTO:
case ST_ASM:
break;
case ST_EXPRESSION:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_GOTOEXPR:
stmt->expr = CInline_CopyExpression(packstmt->u.expr, CopyMode3);
break;
case ST_RETURN:
if (packstmt->u.expr)
stmt->expr = CInline_CopyExpression(packstmt->u.expr, CopyMode3);
else
stmt->expr = NULL;
break;
case ST_LABEL:
labels[i] = stmt->label = newlabel();
stmt->label->stmt = stmt;
break;
case ST_IFGOTO:
case ST_IFNGOTO:
stmt->expr = CInline_CopyExpression(packstmt->u.ifgoto.expr, CopyMode3);
break;
case ST_SWITCH:
stmt->expr = CInline_CopyExpression(packstmt->u.switchdata->expr, CopyMode3);
break;
default:
CError_FATAL(4017);
}
}
for (stmt = firstStmt->next, packstmt = funcdata->statements; stmt; stmt = stmt->next, packstmt++) {
switch (stmt->type) {
case ST_GOTO:
CError_ASSERT(4024, stmt->label = labels[packstmt->u.statementnum]);
break;
case ST_IFGOTO:
case ST_IFNGOTO:
CError_ASSERT(4029, stmt->label = labels[packstmt->u.ifgoto.statementnum]);
break;
case ST_SWITCH:
CInline_UnpackSwitch(stmt, packstmt, labels);
break;
case ST_ASM:
InlineAsm_UnpackAsmStatement(stmt, labels, 0, packstmt->u.asmdata.data, packstmt->u.asmdata.size);
break;
}
}
cinline_first_stmt = firstStmt->next;
while (cinline_label_trans) {
CError_ASSERT(4045, *cinline_label_trans->labelptr = labels[cinline_label_trans->id]);
cinline_label_trans = cinline_label_trans->next;
}
}
static void CInline_GenIFunctionCode(Object *object, CI_FuncData *func, UInt8 unk) {
Boolean saveDebugInfo;
CScopeSave saveScope;
Statement firstStmt;
if (cparamblkptr->isPrecompiling != 1 && func) {
ObjGen_SetupSym();
CScope_SetFunctionScope(object, &saveScope);
CFunc_FuncGenSetup(&firstStmt, object);
CInline_UnpackIFunctionData(object, func, &firstStmt);
saveDebugInfo = copts.isGeneratingDebugInfo;
if (copts.nosyminline || (!symdecloffset && !symdeclend))
copts.isGeneratingDebugInfo = 0;
expanding_function = object;
recursive_inline = 0;
CInline_Expand(&firstStmt);
if (!anyerrors) {
if (copts.isGeneratingDebugInfo)
CPrep_SetSourceFile(&cparser_fileoffset);
CodeGen_Generator(&firstStmt, object, unk, 0);
}
CScope_RestoreScope(&saveScope);
copts.isGeneratingDebugInfo = saveDebugInfo;
}
}
void CInline_AddDefaultFunctionAction(Object *object) {
CI_Action *action;
for (action = cinline_actionlist; action; action = action->next) {
if (action->obj == object)
return;
}
action = galloc(sizeof(CI_Action));
memclrw(action, sizeof(CI_Action));
action->actiontype = CI_ActionDefaultFunc;
action->obj = object;
action->next = cinline_actionlist;
cinline_actionlist = action;
}
getting closer
2023-01-11 22:29:53 +00:00
void CInline_AddInlineFunctionAction(Object *object, TypeClass *tclass, FileOffsetInfo *fileoffset, TokenStream *stream, Boolean flag) {
dump lots more code
2022-12-29 12:32:55 +00:00
CI_Action *action;
for (action = flag ? cinline_tactionlist : cinline_actionlist; action; action = action->next) {
if (action->obj == object)
return;
}
CError_ASSERT(4132, IS_TYPE_FUNC(object->type));
TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_800000;
action = galloc(sizeof(CI_Action));
memclrw(action, sizeof(CI_Action));
action->actiontype = CI_ActionInlineFunc;
action->obj = object;
action->u.inlinefunc.tclass = tclass;
action->u.inlinefunc.fileoffset = *fileoffset;
action->u.inlinefunc.stream = *stream;
if (flag) {
action->next = cinline_tactionlist;
cinline_tactionlist = action;
TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_200000;
} else {
action->next = cinline_actionlist;
cinline_actionlist = action;
}
}
void CInline_AddMemberFunctionAction(Object *object, TemplClass *templ, TemplClassInst *inst, TemplateMember *tmemb) {
CI_Action *action;
for (action = cinline_tactionlist; action; action = action->next) {
if (action->obj == object)
return;
}
action = galloc(sizeof(CI_Action));
memclrw(action, sizeof(CI_Action));
action->actiontype = CI_ActionMemberFunc;
action->obj = object;
action->u.memberfunc.templ = templ;
action->u.memberfunc.inst = inst;
action->u.memberfunc.tmemb = tmemb;
action->next = cinline_tactionlist;
cinline_tactionlist = action;
TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_200000;
}
void CInline_AddTemplateFunctionAction(Object *object, TemplateFunction *func, TemplFuncInstance *inst) {
CI_Action *action;
for (action = cinline_tactionlist; action; action = action->next) {
if (action->obj == object)
return;
}
action = galloc(sizeof(CI_Action));
memclrw(action, sizeof(CI_Action));
action->actiontype = CI_ActionTemplateFunc;
action->obj = object;
action->u.templatefunc.func = func;
action->u.templatefunc.inst = inst;
action->next = cinline_tactionlist;
cinline_tactionlist = action;
TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_200000;
}
static void CInline_AddFRefList_Object(Object *object) {
ObjectList *list;
if (
!(object->datatype == DFUNC || object->datatype == DVFUNC) ||
(object->flags & OBJECT_FLAGS_4) ||
IS_TEMPL_FUNC(object->type)
)
return;
for (list = cinline_freflist; list; list = list->next) {
if (list->object == object)
return;
}
list = lalloc(sizeof(ObjectList));
list->object = object;
list->next = cinline_freflist;
cinline_freflist = list;
if ((object->qual & Q_INLINE) && object->u.func.u.ifuncdata)
CInline_AddFRefList_InlineFunc(object->u.func.u.ifuncdata);
}
static void CInline_AddFRefList_ExAction(ExceptionAction *exc) {
while (exc) {
switch (exc->type) {
case EAT_DESTROYLOCAL:
CInline_AddFRefList_Object(exc->data.destroy_local.dtor);
break;
case EAT_DESTROYLOCALCOND:
CInline_AddFRefList_Object(exc->data.destroy_local_cond.dtor);
break;
case EAT_DESTROYLOCALOFFSET:
CInline_AddFRefList_Object(exc->data.destroy_local_offset.dtor);
break;
case EAT_DESTROYLOCALPOINTER:
CInline_AddFRefList_Object(exc->data.destroy_local_pointer.dtor);
break;
case EAT_DESTROYLOCALARRAY:
CInline_AddFRefList_Object(exc->data.destroy_local_array.dtor);
break;
case EAT_DESTROYPARTIALARRAY:
CInline_AddFRefList_Object(exc->data.destroy_partial_array.dtor);
break;
case EAT_DESTROYMEMBER:
case EAT_DESTROYBASE:
CInline_AddFRefList_Object(exc->data.destroy_member.dtor);
break;
case EAT_DESTROYMEMBERCOND:
CInline_AddFRefList_Object(exc->data.destroy_member_cond.dtor);
break;
case EAT_DESTROYMEMBERARRAY:
CInline_AddFRefList_Object(exc->data.destroy_member_array.dtor);
break;
case EAT_DELETEPOINTER:
case EAT_DELETELOCALPOINTER:
CInline_AddFRefList_Object(exc->data.delete_pointer.deletefunc);
break;
case EAT_DELETEPOINTERCOND:
CInline_AddFRefList_Object(exc->data.delete_pointer_cond.deletefunc);
break;
case EAT_CATCHBLOCK:
case EAT_ACTIVECATCHBLOCK:
case EAT_SPECIFICATION:
case EAT_TERMINATE:
break;
default:
CError_FATAL(4307);
}
exc = exc->prev;
}
}
static void CInline_AddFRefList_ExprCB(ENode *expr) {
CInline_AddFRefList_Object(expr->data.objref);
}
static void CInline_AddFRefList_Expr(ENode *expr) {
CExpr_SearchExprTree(expr, CInline_AddFRefList_ExprCB, 1, EOBJREF);
}
static void CInline_AddFRefList_Statement(Statement *stmt) {
while (stmt) {
if (stmt->dobjstack)
CInline_AddFRefList_ExAction(stmt->dobjstack);
switch (stmt->type) {
case ST_NOP:
case ST_LABEL:
case ST_GOTO:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_ASM:
break;
case ST_RETURN:
if (!stmt->expr)
break;
case ST_EXPRESSION:
case ST_SWITCH:
case ST_IFGOTO:
case ST_IFNGOTO:
case ST_GOTOEXPR:
CInline_AddFRefList_Expr(stmt->expr);
break;
default:
CError_FATAL(4368);
}
stmt = stmt->next;
}
}
static void CInline_AddFRefList_InlineFunc(CI_FuncData *data) {
short i;
CI_Statement *stmt;
ExceptionAction *exc;
for (i = 0; i < data->numstatements; i++) {
stmt = data->statements + i;
switch (stmt->type) {
case ST_NOP:
case ST_LABEL:
case ST_GOTO:
case ST_ASM:
break;
case ST_EXPRESSION:
case ST_BEGINCATCH:
case ST_ENDCATCH:
case ST_ENDCATCHDTOR:
case ST_GOTOEXPR:
CInline_AddFRefList_Expr(stmt->u.expr);
break;
case ST_RETURN:
if (stmt->u.expr)
CInline_AddFRefList_Expr(stmt->u.expr);
break;
case ST_IFGOTO:
case ST_IFNGOTO:
CInline_AddFRefList_Expr(stmt->u.ifgoto.expr);
break;
case ST_SWITCH:
CInline_AddFRefList_Expr(stmt->u.switchdata->expr);
break;
default:
CError_FATAL(4420);
}
for (exc = data->statements[i].dobjstack; exc; exc = exc->prev) {
switch (exc->type) {
case EAT_DESTROYLOCAL:
CInline_AddFRefList_Object(exc->data.destroy_local.dtor);
break;
case EAT_DESTROYLOCALCOND:
CInline_AddFRefList_Object(exc->data.destroy_local_cond.dtor);
break;
case EAT_DESTROYLOCALOFFSET:
CInline_AddFRefList_Object(exc->data.destroy_local_offset.dtor);
break;
case EAT_DESTROYLOCALPOINTER:
CInline_AddFRefList_Object(exc->data.destroy_local_pointer.dtor);
break;
case EAT_DESTROYLOCALARRAY:
CInline_AddFRefList_Object(exc->data.destroy_local_array.dtor);
break;
case EAT_DESTROYPARTIALARRAY:
break;
case EAT_DESTROYMEMBER:
case EAT_DESTROYBASE:
CInline_AddFRefList_Object(exc->data.destroy_member.dtor);
break;
case EAT_DESTROYMEMBERCOND:
CInline_AddFRefList_Object(exc->data.destroy_member_cond.dtor);
break;
case EAT_DESTROYMEMBERARRAY:
CInline_AddFRefList_Object(exc->data.destroy_member_array.dtor);
break;
case EAT_DELETEPOINTER:
case EAT_DELETELOCALPOINTER:
CInline_AddFRefList_Object(exc->data.delete_pointer.deletefunc);
break;
case EAT_DELETEPOINTERCOND:
CInline_AddFRefList_Object(exc->data.delete_pointer_cond.deletefunc);
break;
case EAT_CATCHBLOCK:
case EAT_ACTIVECATCHBLOCK:
case EAT_SPECIFICATION:
case EAT_TERMINATE:
break;
default:
CError_FATAL(4470);
}
}
}
}
static void CInline_GenerateTemplateInline(Object *object) {
CI_Action **ptr;
CI_Action *action;
ptr = &cinline_tactionlist;
while ((action = *ptr)) {
if (object == action->obj) {
*ptr = action->next;
action->next = cinline_actionlist;
cinline_actionlist = action;
TYPE_FUNC(object->type)->flags &= ~FUNC_FLAGS_200000;
return;
}
ptr = &action->next;
}
CError_FATAL(4499);
}
void CInline_ObjectAddrRef(Object *object) {
CI_FuncData *funcdata;
object->flags |= OBJECT_FLAGS_2;
switch (object->datatype) {
case DFUNC:
case DVFUNC:
if (
(object->qual & Q_INLINE) &&
(funcdata = object->u.func.u.ifuncdata) &&
!(object->flags & OBJECT_FLAGS_4) &&
!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100000)
)
{
CI_Export *export = galloc(sizeof(CI_Export));
export->object = object;
export->funcdata = funcdata;
export->xC = 0;
export->next = cinline_exportlist;
cinline_exportlist = export;
object->flags |= OBJECT_FLAGS_4;
return;
}
else if (
(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100) &&
!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_2)
)
{
CInline_AddDefaultFunctionAction(object);
return;
}
else if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_200000)
{
CInline_GenerateTemplateInline(object);
return;
}
return;
case DALIAS:
CInline_ObjectAddrRef(object->u.alias.object);
return;
case DDATA:
if (object->qual & Q_10000)
CInit_ExportConst(object);
if (object->flags & OBJECT_FLAGS_8) {
object->flags &= ~OBJECT_FLAGS_8;
CParser_CallBackAction(object);
}
return;
}
}
static Boolean CInline_CheckDependencies(ObjectList *list) {
Object *object;
Boolean result;
result = 0;
while (list) {
object = list->object;
if (
(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100) &&
!(TYPE_FUNC(object->type)->flags & FUNC_FLAGS_2)
)
{
CInline_AddDefaultFunctionAction(object);
result = 1;
}
else if (
(object->qual & Q_400000) &&
CTempl_InlineFunctionCheck(object)
)
{
result = 1;
}
else {
CI_Action *action;
for (action = cinline_actionlist; action; action = action->next) {
if (object == action->obj) {
result = 1;
break;
}
}
if (TYPE_FUNC(object->type)->flags & FUNC_FLAGS_200000) {
CInline_GenerateTemplateInline(object);
result = 1;
}
}
list = list->next;
}
return result;
}
static Boolean CInline_IsSmallFunction(Object *object, Statement *stmt) {
SInt32 statementCount;
ObjectList *list;
SInt32 localSize;
statementCount = 0;
while (stmt) {
if (stmt->type != ST_NOP && stmt->type != ST_LABEL)
statementCount++;
if (statementCount > 15)
return 0;
stmt = stmt->next;
}
for (list = locals, localSize = 0; list; list = list->next)
localSize += list->object->type->size;
if (localSize > 1024)
return 0;
return 1;
}
static Boolean CInline_NoFPLocals(void) {
ObjectList *list;
for (list = locals; list; list = list->next) {
if (IS_TYPE_FLOAT(list->object->type))
return 0;
}
return 1;
}
void CInline_GenFunc(Statement *stmt, Object *object, UInt8 unk) {
CI_FuncData *funcdata;
CI_Export *export;
Boolean flag24;
Boolean flag30;
TYPE_FUNC(object->type)->flags |= OBJECT_FLAGS_2;
flag24 = 0;
flag30 = 0;
if (!(object->qual & Q_INLINE)) {
if (
copts.autoinline &&
!copts.dont_inline &&
CInline_CanInline(object, stmt->next) &&
CInline_IsSmallFunction(object, stmt->next)
)
{
flag24 = 1;
flag30 = 1;
TYPE_FUNC(object->type)->flags |= FUNC_FLAGS_800;
}
} else {
flag30 = 1;
}
if (flag30) {
COpt_SimpleOptimizer(object, stmt);
funcdata = galloc(sizeof(CI_FuncData));
CInline_PackIFunctionData(funcdata, stmt, object);
object->u.func.u.ifuncdata = funcdata;
if (!flag24 && !(object->flags & OBJECT_FLAGS_2)) {
if (cinline_gendeps) {
cinline_freflist = NULL;
CInline_AddFRefList_Statement(stmt);
CInline_CheckDependencies(cinline_freflist);
}
return;
}
}
object->flags |= OBJECT_FLAGS_4;
cinline_freflist = NULL;
CInline_AddFRefList_Statement(stmt);
if (CInline_CheckDependencies(cinline_freflist) || copts.defer_codegen) {
if (!flag30) {
funcdata = galloc(sizeof(CI_FuncData));
CInline_PackIFunctionData(funcdata, stmt, object);
} else {
funcdata = object->u.func.u.ifuncdata;
}
export = galloc(sizeof(CI_Export));
export->object = object;
export->funcdata = funcdata;
export->xC = unk;
export->next = cinline_exportlist;
cinline_exportlist = export;
return;
}
expanding_function = object;
recursive_inline = 0;
CInline_Expand(stmt);
if (copts.isGeneratingDebugInfo)
CPrep_SetSourceFile(&cparser_fileoffset);
if (!anyerrors)
CodeGen_Generator(stmt, object, unk, 0);
}
static void CInline_GenerateDefaultFunc(Object *object) {
TypeClass *tclass;
CError_ASSERT(4770, TYPE_FUNC(object->type)->flags & FUNC_FLAGS_100);
CError_ASSERT(4771, TYPE_FUNC(object->type)->flags & FUNC_FLAGS_METHOD);
tclass = TYPE_METHOD(object->type)->theclass;
if (object == CClass_DefaultConstructor(tclass)) {
if (object->u.func.defargdata)
CABI_MakeDefaultArgConstructor(tclass, object);
else
CABI_MakeDefaultConstructor(tclass, object);
} else if (object == CClass_CopyConstructor(tclass)) {
CABI_MakeDefaultCopyConstructor(tclass, object);
} else if (object == CClass_AssignmentOperator(tclass)) {
CABI_MakeDefaultAssignmentOperator(tclass, object);
} else if (object == CClass_Destructor(tclass)) {
CABI_MakeDefaultDestructor(tclass, object);
} else {
CError_FATAL(4805);
}
}
static TemplClassInst *CInline_FindNestedTemplInst(TypeClass *tclass) {
NameSpace *nspace;
while (tclass) {
if ((tclass->flags & CLASS_FLAGS_800))
return TEMPL_CLASS_INST(tclass);
if (!copts.template_patch)
break;
nspace = tclass->nspace->parent;
tclass = NULL;
while (nspace) {
if (nspace->theclass) {
tclass = nspace->theclass;
break;
}
nspace = nspace->parent;
}
}
return NULL;
}
static void CInline_GenerateInlineFunc(CI_Action *action) {
Object *object;
TemplClassInst *inst;
DeclInfo di;
SInt32 streamState;
object = action->obj;
CPrep_StreamInsert(&action->u.inlinefunc.stream, &streamState);
cparser_fileoffset = action->u.inlinefunc.fileoffset;
symdecloffset = cparser_fileoffset.tokenline;
switch ((tk = lex())) {
case ':':
case '{':
case TK_TRY:
break;
default:
CError_FATAL(4860);
}
symdecltoken = *CPrep_CurStreamElement();
TYPE_FUNC(object->type)->flags &= ~FUNC_FLAGS_2;
if (IS_TYPE_METHOD(object->type) && (inst = CInline_FindNestedTemplInst(TYPE_METHOD(object->type)->theclass))) {
CTempl_ParseInstanceScopeFunction(object, inst, NULL);
} else {
memclrw(&di, sizeof(di));
if (action->u.inlinefunc.tclass) {
if ((inst = CInline_FindNestedTemplInst(action->u.inlinefunc.tclass))) {
CTempl_ParseInstanceScopeFunction(object, inst, action->u.inlinefunc.tclass);
} else {
CFunc_ParseFuncDef(object, &di, action->u.inlinefunc.tclass, 0, 0, NULL);
}
} else {
CFunc_ParseFuncDef(object, &di, NULL, 0, 0, NULL);
}
}
CPrep_StreamRemove(&action->u.inlinefunc.stream, &streamState);
}
Boolean CInline_CanFreeLHeap(void) {
CI_Action *action;
if (!anyerrors) {
for (action = cinline_actionlist; action; action = action->next) {
if (action->actiontype == CI_ActionInlineFunc)
return 0;
}
}
return 1;
}
Boolean CInline_GenerateDeferredFuncs(void) {
CI_Action *action;
CI_Export *export;
if (!anyerrors) {
if ((action = cinline_actionlist)) {
cinline_actionlist = action->next;
cinline_gendeps = 1;
switch (action->actiontype) {
case CI_ActionDefaultFunc:
CInline_GenerateDefaultFunc(action->obj);
break;
case CI_ActionInlineFunc:
if (!(action->obj->flags & OBJECT_FLAGS_4))
CInline_GenerateInlineFunc(action);
break;
case CI_ActionMemberFunc:
if (!(TYPE_FUNC(action->obj->type)->flags & FUNC_FLAGS_2))
CTempl_InstantiateMember(
action->u.memberfunc.templ, action->u.memberfunc.inst,
action->u.memberfunc.tmemb, action->obj, 0);
break;
case CI_ActionTemplateFunc:
if (!(TYPE_FUNC(action->obj->type)->flags & FUNC_FLAGS_2) && !action->u.templatefunc.inst->is_specialized)
CTempl_GenFuncInstance(action->u.templatefunc.func, action->u.templatefunc.inst, 0);
break;
default:
CError_FATAL(5001);
}
cinline_gendeps = 0;
return 1;
} else {
if ((export = cinline_exportlist) && !copts.defer_codegen) {
cinline_exportlist = export->next;
CInline_GenIFunctionCode(export->object, export->funcdata, export->xC);
return 1;
}
}
}
return 0;
}
static InitExpr *CInline_InitTemplateData(InitExpr *init) {
Statement *stmt;
CLabel *label;
Object *object;
Object *data;
object = init->object;
data = CParser_NewCompilerDefDataObject();
data->type = TYPE(&stsignedchar);
data->name = CParser_NameConcat("__init__", CMangler_GetLinkName(object)->name);
data->qual = Q_OVERLOAD;
CInit_DeclareData(data, NULL, NULL, data->type->size);
stmt = CFunc_AppendStatement(ST_IFGOTO);
stmt->expr = create_objectnode(data);
label = newlabel();
stmt->label = label;
do {
stmt = CFunc_AppendStatement(ST_EXPRESSION);
stmt->expr = CInline_CopyExpression(init->expr, CopyMode0);
init = init->next;
} while (init && init->object == object);
stmt = CFunc_AppendStatement(ST_EXPRESSION);
stmt->expr = makediadicnode(create_objectnode(data), intconstnode(TYPE(&stsignedchar), 1), EASS);
stmt = CFunc_AppendStatement(ST_LABEL);
stmt->label = label;
label->stmt = stmt;
return init;
}
void CInline_Finish(void) {
NameSpace *nspace;
Boolean saveDebugInfo;
Statement firstStmt;
Statement *stmt;
InitExpr *init;
Boolean doMore;
if (!init_expressions || anyerrors)
return;
cinline_freflist = NULL;
for (init = init_expressions; init; init = init->next)
CInline_AddFRefList_Expr(init->expr);
CInline_CheckDependencies(cinline_freflist);
do {
doMore = CInline_GenerateDeferredFuncs();
} while (doMore);
nspace = CFunc_FuncGenSetup(&firstStmt, NULL);
saveDebugInfo = copts.isGeneratingDebugInfo;
copts.isGeneratingDebugInfo = 0;
init = init_expressions;
while (init) {
if (init->object->nspace->theclass && (init->object->nspace->theclass->flags & CLASS_FLAGS_800)) {
init = CInline_InitTemplateData(init);
} else {
stmt = CFunc_AppendStatement(ST_EXPRESSION);
stmt->expr = CInline_CopyExpression(init->expr, CopyMode0);
init = init->next;
}
}
CFunc_CodeCleanup(&firstStmt);
expanding_function = NULL;
recursive_inline = 0;
CInline_Expand(&firstStmt);
if (!anyerrors) {
if (copts.isGeneratingDebugInfo)
CPrep_SetSourceFile(&cparser_fileoffset);
CodeGen_Generator(&firstStmt, NULL, 0, 1);
}
cscope_current = nspace->parent;
copts.isGeneratingDebugInfo = saveDebugInfo;
}