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/IroLinearForm.c

1798 lines
58 KiB
C
Raw Blame History

#include "compiler/IroLinearForm.h"
#include "compiler/IroDump.h"
#include "compiler/IroFlowgraph.h"
#include "compiler/IroUtil.h"
#include "compiler/IroVars.h"
#include "compiler/CError.h"
#include "compiler/CExpr.h"
#include "compiler/CFunc.h"
#include "compiler/CInt64.h"
#include "compiler/CParser.h"
#include "compiler/CompilerTools.h"
#include "compiler/InlineAsm.h"
#include "compiler/InlineAsmPPC.h"
#include "compiler/types.h"
typedef struct NullCheckListNode {
SInt32 precompid;
Object *tempobj;
struct NullCheckListNode *next;
} NullCheckListNode;
IROLinear *IRO_FirstLinear;
IROLinear *IRO_LastLinear;
UInt32 IRO_NumLinear;
Statement *CurStat;
static NullCheckListNode *NullCheckList;
static Statement *CurrStmt;
static Statement *PrevStmt;
static void LinkLinear(IROLinear *linear) {
linear->index = IRO_NumLinear++;
if (IRO_FirstLinear)
IRO_LastLinear->next = linear;
else
IRO_FirstLinear = linear;
IRO_LastLinear = linear;
}
IROLinear *IRO_NewLinear(IROLinearType type) {
IROLinear *linear = oalloc(sizeof(IROLinear));
memset(linear, 0, sizeof(IROLinear));
linear->stmt = CurStat;
linear->nodetype = EPOSTINC;
linear->next = NULL;
linear->type = type;
linear->rtype = NULL;
linear->flags = 0;
linear->nodeflags = 0;
linear->expr = NULL;
linear->x16 = 0;
return linear;
}
static void MarkAssigned(IROLinear *linear, Boolean flag) {
IROLinear *inner;
IROAddrRecord *rec;
if (IS_LINEAR_MONADIC(linear, EINDIRECT) && IS_LINEAR_MONADIC(linear->u.monadic, EBITFIELD)) {
linear->flags |= IROLF_Assigned;
inner = linear->u.monadic->u.monadic;
if (inner->type == IROLinearOperand) {
inner->flags |= IROLF_Assigned;
if (flag) {
linear->flags |= IROLF_Used;
inner->flags |= IROLF_Used;
}
}
if (IS_LINEAR_DIADIC(inner, EADD)) {
if (IS_LINEAR_ENODE(inner->u.diadic.left, EOBJREF)) {
if (IS_LINEAR_ENODE(inner->u.diadic.right, EINTCONST))
inner->u.diadic.left->flags |= IROLF_Assigned;
if (flag) {
linear->flags |= IROLF_Used;
inner->u.diadic.left->flags |= IROLF_Used;
}
}
rec = IRO_InitAddrRecordPointer(inner);
IRO_DecomposeAddressExpression(inner, rec);
if (rec->numObjRefs == 1 && IS_LINEAR_ENODE(inner->u.diadic.left, EOBJREF)) {
rec->objRefs->element->flags |= IROLF_Assigned;
if (flag) {
linear->flags |= IROLF_Used;
rec->objRefs->element->flags |= IROLF_Used;
}
}
}
}
if (IS_LINEAR_MONADIC(linear, EINDIRECT)) {
linear->flags |= IROLF_Assigned;
if (linear->u.monadic->type == IROLinearOperand) {
linear->u.monadic->flags |= IROLF_Assigned;
if (flag) {
linear->flags |= IROLF_Used;
linear->u.monadic->flags |= IROLF_Used;
}
}
}
if (IS_LINEAR_MONADIC(linear, EINDIRECT)) {
linear->flags |= IROLF_Assigned;
inner = linear->u.monadic;
if (IS_LINEAR_DIADIC(inner, EADD)) {
if (IS_LINEAR_ENODE(inner->u.diadic.left, EOBJREF)) {
if (IS_LINEAR_ENODE(inner->u.diadic.right, EINTCONST))
inner->u.diadic.left->flags |= IROLF_Assigned;
if (flag) {
linear->flags |= IROLF_Used;
inner->u.diadic.left->flags |= IROLF_Used;
}
}
rec = IRO_InitAddrRecordPointer(inner);
IRO_DecomposeAddressExpression(inner, rec);
if (rec->numObjRefs == 1 && IS_LINEAR_ENODE(inner->u.diadic.left, EOBJREF)) {
rec->objRefs->element->flags |= IROLF_Assigned;
if (flag) {
linear->flags |= IROLF_Used;
rec->objRefs->element->flags |= IROLF_Used;
}
}
}
}
}
static void MarkSubscript(IROLinear *linear) {
linear->flags |= IROLF_Subs;
if (IS_LINEAR_DIADIC(linear, EADD)) {
if (IRO_IsAddressMultiply(linear->u.diadic.left) || IS_LINEAR_MONADIC(linear->u.diadic.left, EINDIRECT))
linear->u.diadic.left->flags |= IROLF_Subs;
if (IRO_IsAddressMultiply(linear->u.diadic.right) || IS_LINEAR_MONADIC(linear->u.diadic.right, EINDIRECT))
linear->u.diadic.right->flags |= IROLF_Subs;
if (IS_LINEAR_DIADIC(linear->u.diadic.left, EADD))
MarkSubscript(linear->u.diadic.left);
if (IS_LINEAR_DIADIC(linear->u.diadic.right, EADD))
MarkSubscript(linear->u.diadic.right);
}
}
static void MarkArgs(IROLinear *linear) {
int i;
linear->flags |= IROLF_4000;
switch (linear->type) {
case IROLinearEnd:
break;
case IROLinearOp1Arg:
case IROLinearBeginCatch:
case IROLinearEndCatch:
case IROLinearEndCatchDtor:
MarkArgs(linear->u.monadic);
break;
case IROLinearOp2Arg:
MarkArgs(linear->u.diadic.left);
MarkArgs(linear->u.diadic.right);
break;
case IROLinearIf:
case IROLinearIfNot:
MarkArgs(linear->u.label.x4);
break;
case IROLinearReturn:
if (linear->u.monadic)
MarkArgs(linear->u.monadic);
break;
case IROLinearSwitch:
MarkArgs(linear->u.swtch.x4);
break;
case IROLinearOp3Arg:
MarkArgs(linear->u.args3.a);
MarkArgs(linear->u.args3.b);
MarkArgs(linear->u.args3.c);
break;
case IROLinearFunccall:
MarkArgs(linear->u.funccall.linear8);
for (i = 0; i < linear->u.funccall.argCount; i++)
MarkArgs(linear->u.funccall.args[i]);
break;
}
}
// assumed name, position
static inline void MarkSubExpr(IROLinear *linear) {
int i;
switch (linear->type) {
case IROLinearNop:
case IROLinearOperand:
case IROLinearGoto:
case IROLinearLabel:
case IROLinearEntry:
case IROLinearExit:
case IROLinearAsm:
case IROLinearEnd:
break;
case IROLinearOp1Arg:
case IROLinearBeginCatch:
case IROLinearEndCatch:
case IROLinearEndCatchDtor:
linear->u.monadic->flags |= IROLF_Reffed;
break;
case IROLinearOp2Arg:
linear->u.diadic.left->flags |= IROLF_Reffed;
linear->u.diadic.right->flags |= IROLF_Reffed;
break;
case IROLinearIf:
case IROLinearIfNot:
linear->u.label.x4->flags |= IROLF_Reffed;
break;
case IROLinearReturn:
if (linear->u.monadic)
linear->u.monadic->flags |= IROLF_Reffed;
break;
case IROLinearSwitch:
linear->u.swtch.x4->flags |= IROLF_Reffed;
break;
case IROLinearOp3Arg:
linear->u.args3.a->flags |= IROLF_Reffed;
linear->u.args3.b->flags |= IROLF_Reffed;
linear->u.args3.c->flags |= IROLF_Reffed;
break;
case IROLinearFunccall:
linear->u.funccall.linear8->flags |= IROLF_Reffed;
for (i = 0; i < linear->u.funccall.argCount; i++)
linear->u.funccall.args[i]->flags |= IROLF_Reffed;
break;
default:
CError_FATAL(368);
}
}
static void MarkSubs1(IROLinear *linear) {
IROAddrRecord *rec;
if (IS_LINEAR_MONADIC(linear, EBITFIELD)) {
linear = linear->u.monadic;
if (IS_LINEAR_ENODE(linear, EOBJREF))
linear->flags |= IROLF_Ind;
}
if (IS_LINEAR_DIADIC(linear, EADD)) {
if (IS_LINEAR_ENODE(linear->u.diadic.left, EOBJREF) && IS_LINEAR_ENODE(linear->u.diadic.right, EINTCONST))
linear->u.diadic.left->flags |= IROLF_Ind;
rec = IRO_InitAddrRecordPointer(linear);
IRO_DecomposeAddressExpression(linear, rec);
if (rec->numObjRefs == 1 && IS_LINEAR_ENODE(linear->u.diadic.left, EOBJREF))
rec->objRefs->element->flags |= IROLF_Ind;
}
}
static void MakeLeftChildAsAssignment(ENode *enode) {
Statement *stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = enode->data.diadic.left;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void AssignCommaRToTemp(ENode *enode, Boolean flag) {
Statement *stmt;
if (!IS_TYPE_VOID(enode->rtype) && !flag) {
Object *obj = create_temp_object(enode->rtype);
ENode *indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(obj);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
CError_FATAL(548);
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = enode->data.diadic.right;
stmt->expr->rtype = enode->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
enode->type = EINDIRECT;
enode->data.monadic = create_objectrefnode(obj);
CError_ASSERT(580, !IS_TYPE_VOID(enode->rtype));
} else {
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = enode->data.diadic.right;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
enode->type = EINTCONST;
enode->data.intval = cint64_zero;
}
}
static void AssignDangerousArgumentToTemp(ENode *enode) {
Statement *stmt;
Object *obj;
ENode *indnode;
ENode *rightnode;
obj = create_temp_object(enode->rtype);
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(obj);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
CError_FATAL(627);
rightnode = IRO_NewENode(enode->type);
memcpy(rightnode, enode, sizeof(ENode));
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = rightnode;
stmt->expr->rtype = enode->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
enode->type = EINDIRECT;
enode->data.monadic = create_objectrefnode(obj);
}
static void CreateTempAssignmentToZero(ENode *enode, Object **objptr) {
Statement *stmt;
ENode *indnode;
ENode *rightnode;
*objptr = create_temp_object(enode->rtype);
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
CError_FATAL(678);
rightnode = IRO_NewENode(EINTCONST);
rightnode->data.intval = cint64_zero;
rightnode->rtype = enode->rtype;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = rightnode;
stmt->expr->rtype = enode->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void CreateTempAssignmentToOne(ENode *enode, Object **objptr) {
Statement *stmt;
ENode *indnode;
ENode *rightnode;
*objptr = create_temp_object(enode->rtype);
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
CError_FATAL(720);
rightnode = IRO_NewENode(EINTCONST);
rightnode->data.intval = cint64_one;
rightnode->rtype = enode->rtype;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = rightnode;
stmt->expr->rtype = enode->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateCondExpression(ENode *enode, CLabel **label) {
Statement *stmt;
*label = IRO_NewLabel();
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_IFNGOTO;
stmt->expr = enode->data.cond.cond;
stmt->label = *label;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateGoToStmt(ENode *enode, CLabel **label) {
Statement *stmt;
*label = IRO_NewLabel();
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_GOTO;
stmt->label = *label;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void PutTempOnNullCheckList(ENode *expr, Object *obj) {
NullCheckListNode *n = lalloc(sizeof(NullCheckListNode));
n->precompid = expr->data.nullcheck.precompid;
n->tempobj = obj;
n->next = NULL;
if (NullCheckList) {
n->next = NullCheckList;
NullCheckList = n;
} else {
NullCheckList = n;
}
}
static Object *GetTempFromtheList(ENode *expr) {
NullCheckListNode *n;
for (n = NullCheckList; n; n = n->next) {
if (n->precompid == expr->data.precompid)
break;
}
CError_ASSERT(839, n);
return n->tempobj;
}
static void GenerateNullcheckExprTempAssignment(ENode *enode, Object **objptr) {
Statement *stmt;
ENode *indnode;
if (!IS_TYPE_VOID(enode->rtype))
*objptr = create_temp_object(enode->rtype);
else
*objptr = create_temp_object(enode->data.nullcheck.nullcheckexpr->rtype);
PutTempOnNullCheckList(enode, *objptr);
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
indnode->rtype = enode->data.nullcheck.nullcheckexpr->rtype;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = enode->data.nullcheck.nullcheckexpr;
if (!IS_TYPE_VOID(enode->rtype))
stmt->expr->rtype = enode->rtype;
else
stmt->expr->rtype = enode->data.nullcheck.nullcheckexpr->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateExpr1TempAssignment(ENode *enode, Object **objptr) {
Statement *stmt;
ENode *indnode;
if (!IS_TYPE_VOID(enode->rtype)) {
*objptr = create_temp_object(enode->rtype);
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
indnode->rtype = enode->rtype;
CError_ASSERT(905, !IS_TYPE_VOID(enode->rtype));
}
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
if (!IS_TYPE_VOID(enode->rtype)) {
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = enode->data.cond.expr1;
stmt->expr->rtype = enode->rtype;
} else {
stmt->expr = enode->data.cond.expr1;
}
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateExpr2TempAssignment(ENode *enode, Object **objptr) {
Statement *stmt;
ENode *indnode;
if (!IS_TYPE_VOID(enode->rtype)) {
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
indnode->rtype = enode->rtype;
CError_ASSERT(953, !IS_TYPE_VOID(enode->rtype));
}
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
if (!IS_TYPE_VOID(enode->rtype)) {
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = enode->data.cond.expr2;
stmt->expr->rtype = enode->rtype;
} else {
stmt->expr = enode->data.cond.expr2;
}
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateForceLoadTempAssignment(ENode *enode, Object **objptr) {
Statement *stmt;
ENode *indnode;
if (!IS_TYPE_VOID(enode->rtype)) {
*objptr = create_temp_object(enode->rtype);
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
indnode->rtype = enode->rtype;
CError_ASSERT(1003, !IS_TYPE_VOID(enode->rtype));
}
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
if (!IS_TYPE_VOID(enode->rtype)) {
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = enode->data.monadic;
stmt->expr->rtype = enode->rtype;
} else {
stmt->expr = enode->data.monadic;
}
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateLabel(CLabel **labelptr) {
Statement *stmt;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_LABEL;
stmt->label = *labelptr;
stmt->label->stmt = stmt;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateIfNotTemp(ENode *enode, Object **objptr, CLabel **labelptr) {
Statement *stmt;
ENode *indnode;
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
indnode->rtype = enode->data.monadic->rtype;
*labelptr = IRO_NewLabel();
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_IFNGOTO;
stmt->expr = indnode;
stmt->label = *labelptr;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void GenerateNullcheckCondExpr(ENode *enode, Object **objptr) {
Statement *stmt;
ENode *indnode;
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
indnode->rtype = enode->data.nullcheck.nullcheckexpr->rtype;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = enode->data.nullcheck.condexpr;
if (!IS_TYPE_VOID(enode->rtype))
stmt->expr->rtype = enode->rtype;
else
stmt->expr->rtype = enode->data.nullcheck.nullcheckexpr->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void TransformLogicalAndLHS(ENode *enode, Object **objptr, CLabel **labelptr) {
Statement *stmt;
*labelptr = IRO_NewLabel();
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_IFNGOTO;
stmt->expr = enode->data.diadic.left;
stmt->label = *labelptr;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void TransformLogicalAndRHS(ENode *enode, Object **objptr, CLabel **labelptr) {
Statement *stmt;
ENode *indnode;
ENode *rightnode;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_IFNGOTO;
stmt->expr = enode->data.diadic.right;
stmt->label = *labelptr;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
CError_FATAL(1225);
rightnode = IRO_NewENode(EINTCONST);
rightnode->data.intval = cint64_one;
rightnode->rtype = enode->rtype;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = rightnode;
stmt->expr->rtype = enode->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_LABEL;
stmt->label = *labelptr;
stmt->label->stmt = stmt;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
enode->type = EINDIRECT;
enode->data.monadic = create_objectrefnode(*objptr);
CError_ASSERT(1276, !IS_TYPE_VOID(enode->rtype));
}
static void TransformLogicalOrLHS(ENode *enode, Object **objptr, CLabel **labelptr) {
Statement *stmt;
*labelptr = IRO_NewLabel();
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_IFGOTO;
stmt->expr = enode->data.diadic.left;
stmt->label = *labelptr;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
}
static void TransformLogicalOrRHS(ENode *enode, Object **objptr, CLabel **labelptr) {
Statement *stmt;
ENode *indnode;
ENode *rightnode;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_IFGOTO;
stmt->expr = enode->data.diadic.right;
stmt->label = *labelptr;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
indnode = IRO_NewENode(EINDIRECT);
indnode->data.monadic = create_objectrefnode(*objptr);
if (!IS_TYPE_VOID(enode->rtype))
indnode->rtype = enode->rtype;
else
CError_FATAL(1354);
rightnode = IRO_NewENode(EINTCONST);
rightnode->data.intval = cint64_zero;
rightnode->rtype = enode->rtype;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_EXPRESSION;
stmt->expr = IRO_NewENode(EASS);
stmt->expr->data.diadic.left = indnode;
stmt->expr->data.diadic.right = rightnode;
stmt->expr->rtype = enode->rtype;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = ST_LABEL;
stmt->label = *labelptr;
stmt->label->stmt = stmt;
stmt->dobjstack = CurrStmt->dobjstack;
stmt->sourceoffset = CurrStmt->sourceoffset;
stmt->sourcefilepath = CurrStmt->sourcefilepath;
stmt->value = CurrStmt->value;
stmt->flags = CurrStmt->flags;
if (PrevStmt) {
stmt->next = PrevStmt->next;
PrevStmt->next = stmt;
} else {
stmt->next = NULL;
}
PrevStmt = stmt;
enode->type = EINDIRECT;
enode->data.monadic = create_objectrefnode(*objptr);
CError_ASSERT(1405, !IS_TYPE_VOID(enode->rtype));
}
static void LinearizeExpr1(ENode *a, ENode *b, Boolean flag, Boolean flag2) {
switch (a->type) {
ENODE_CASE_MONADIC:
LinearizeExpr1(a->data.monadic, a, 0, 0);
if (a->type == EFORCELOAD) {
Object *obj;
GenerateForceLoadTempAssignment(a, &obj);
a->type = EINDIRECT;
a->data.monadic = create_objectrefnode(obj);
CError_ASSERT(1428, !IS_TYPE_VOID(a->rtype));
}
break;
ENODE_CASE_DIADIC_1:
case ECOMMA:
case EPMODULO:
case EROTL:
case EROTR:
case EBTST:
if (a->type == ECOMMA) {
LinearizeExpr1(a->data.diadic.left, a, 1, 0);
MakeLeftChildAsAssignment(a);
LinearizeExpr1(a->data.diadic.right, a, 0, 0);
AssignCommaRToTemp(a, flag);
} else if (a->data.diadic.right->cost >= a->data.diadic.left->cost) {
LinearizeExpr1(a->data.diadic.right, a, 0, 0);
LinearizeExpr1(a->data.diadic.left, a, 0, 0);
} else {
LinearizeExpr1(a->data.diadic.left, a, 0, 0);
LinearizeExpr1(a->data.diadic.right, a, 0, 0);
}
break;
ENODE_CASE_ASSIGN:
LinearizeExpr1(a->data.diadic.right, a, 0, 0);
LinearizeExpr1(a->data.diadic.left, a, 0, 0);
break;
case ELAND:
case ELOR:
if (a->type == ELAND) {
CLabel *label;
Object *obj;
CreateTempAssignmentToZero(a, &obj);
LinearizeExpr1(a->data.diadic.left, a, 0, 0);
TransformLogicalAndLHS(a, &obj, &label);
LinearizeExpr1(a->data.diadic.right, a, 0, 0);
TransformLogicalAndRHS(a, &obj, &label);
} else if (a->type == ELOR) {
CLabel *label;
Object *obj;
CreateTempAssignmentToOne(a, &obj);
LinearizeExpr1(a->data.diadic.left, a, 0, 0);
TransformLogicalOrLHS(a, &obj, &label);
LinearizeExpr1(a->data.diadic.right, a, 0, 0);
TransformLogicalOrRHS(a, &obj, &label);
}
break;
case ECOND: {
CLabel *label1, *label2;
Object *obj;
LinearizeExpr1(a->data.cond.cond, a, 0, 0);
GenerateCondExpression(a, &label1);
LinearizeExpr1(a->data.cond.expr1, a, 0, 0);
GenerateExpr1TempAssignment(a, &obj);
GenerateGoToStmt(a, &label2);
GenerateLabel(&label1);
LinearizeExpr1(a->data.cond.expr2, a, 0, 0);
GenerateExpr2TempAssignment(a, &obj);
GenerateLabel(&label2);
if (!IS_TYPE_VOID(a->rtype)) {
a->type = EINDIRECT;
a->data.monadic = create_objectrefnode(obj);
CError_ASSERT(1596, !IS_TYPE_VOID(a->rtype));
} else {
a->type = EINTCONST;
a->data.intval = cint64_zero;
}
break;
}
case EPRECOMP: {
Object *temp = GetTempFromtheList(a);
a->type = EINDIRECT;
a->data.monadic = create_objectrefnode(temp);
CError_ASSERT(1614, !IS_TYPE_VOID(a->rtype));
break;
}
case ENULLCHECK: {
CLabel *label;
Object *obj;
LinearizeExpr1(a->data.nullcheck.nullcheckexpr, a, 0, 0);
GenerateNullcheckExprTempAssignment(a, &obj);
GenerateIfNotTemp(a, &obj, &label);
LinearizeExpr1(a->data.nullcheck.condexpr, a, 0, 0);
GenerateNullcheckCondExpr(a, &obj);
GenerateLabel(&label);
if (!IS_TYPE_VOID(a->rtype)) {
a->type = EINDIRECT;
a->data.monadic = create_objectrefnode(obj);
CError_ASSERT(1639, !IS_TYPE_VOID(a->rtype));
} else {
a->type = EINTCONST;
a->data.intval = cint64_zero;
}
break;
}
case EFUNCCALL:
case EFUNCCALLP: {
SInt32 count;
SInt32 i;
ENodeList *list;
ENode **arr;
SInt16 *arr2;
IRO_IsLeafFunction = 0;
list = a->data.funccall.args;
count = 0;
while (list) {
list = list->next;
count++;
}
if (count) {
arr = oalloc(sizeof(ENode *) * count);
list = a->data.funccall.args;
count = 0;
while (list) {
arr[count] = list->node;
list = list->next;
count++;
}
arr2 = oalloc(sizeof(SInt16) * count);
for (i = 0; i < count; i++)
arr2[i] = count - i - 1;
for (i = 0; i < count; i++)
LinearizeExpr1(arr[arr2[i]], a, 0, 0);
}
LinearizeExpr1(a->data.funccall.funcref, a, 0, 0);
break;
}
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJREF:
case ESETCONST:
case EVECTOR128CONST:
break;
default:
CError_FATAL(1723);
}
}
static IROLinear *LinearizeExpr(ENode *enode) {
IROLinear *linear = NULL;
switch (enode->type) {
ENODE_CASE_MONADIC:
linear = IRO_NewLinear(IROLinearOp1Arg);
linear->u.monadic = LinearizeExpr(enode->data.monadic);
linear->nodetype = enode->type;
linear->rtype = enode->rtype;
linear->nodeflags = enode->flags;
if (IRO_IsAssignOp[linear->nodetype])
MarkAssigned(linear->u.monadic, 1);
if (linear->nodetype == EINDIRECT) {
MarkSubs1(linear->u.monadic);
linear->u.monadic->flags |= IROLF_Immind | IROLF_Ind;
if (IS_LINEAR_DIADIC(linear->u.monadic, EADD))
MarkSubscript(linear->u.monadic);
}
break;
ENODE_CASE_DIADIC_1:
case ECOMMA:
case EPMODULO:
case EROTL:
case EROTR:
case EBTST:
linear = IRO_NewLinear(IROLinearOp2Arg);
linear->nodeflags = enode->flags;
if (!ENODE_IS(enode, ECOMMA) && enode->data.diadic.right->cost >= enode->data.diadic.left->cost) {
linear->u.diadic.right = LinearizeExpr(enode->data.diadic.right);
linear->u.diadic.left = LinearizeExpr(enode->data.diadic.left);
linear->flags |= IROLF_8000;
} else {
linear->u.diadic.left = LinearizeExpr(enode->data.diadic.left);
linear->u.diadic.right = LinearizeExpr(enode->data.diadic.right);
}
linear->nodetype = enode->type;
linear->rtype = enode->rtype;
if (IRO_IsAssignOp[linear->nodetype])
MarkAssigned(linear->u.diadic.left, IRO_IsModifyOp[linear->nodetype]);
break;
ENODE_CASE_ASSIGN:
linear = IRO_NewLinear(IROLinearOp2Arg);
linear->nodeflags = enode->flags;
linear->u.diadic.right = LinearizeExpr(enode->data.diadic.right);
linear->u.diadic.left = LinearizeExpr(enode->data.diadic.left);
linear->flags |= IROLF_8000;
linear->nodetype = enode->type;
linear->rtype = enode->rtype;
MarkAssigned(linear->u.diadic.left, IRO_IsModifyOp[linear->nodetype]);
break;
case EINTCONST:
case EFLOATCONST:
case ESTRINGCONST:
case EOBJREF:
case EVECTOR128CONST:
linear = IRO_NewLinear(IROLinearOperand);
linear->nodeflags = enode->flags;
linear->u.node = enode;
linear->rtype = enode->rtype;
break;
case EFUNCCALL:
case EFUNCCALLP: {
SInt32 count;
SInt32 i;
ENodeList *list;
ENode **arr;
SInt16 *arr2;
linear = IRO_NewLinear(IROLinearFunccall);
linear->nodeflags = enode->flags;
linear->u.funccall.ispascal = enode->type == EFUNCCALLP;
list = enode->data.funccall.args;
count = 0;
while (list) {
list = list->next;
count++;
}
arr = NULL;
if (count) {
arr = oalloc(sizeof(ENode *) * count);
list = enode->data.funccall.args;
count = 0;
while (list) {
arr[count] = list->node;
list = list->next;
count++;
}
arr2 = oalloc(sizeof(SInt16) * count);
for (i = 0; i < count; i++)
arr2[i] = count - i - 1;
for (i = 0; i < count; i++) {
arr[arr2[i]] = (ENode *) LinearizeExpr(arr[arr2[i]]);
MarkArgs((IROLinear *) arr[arr2[i]]);
}
}
linear->u.funccall.argCount = count;
linear->u.funccall.args = (IROLinear **) arr;
linear->u.funccall.linear8 = LinearizeExpr(enode->data.funccall.funcref);
linear->u.funccall.functype = enode->data.funccall.functype;
linear->rtype = enode->rtype;
break;
}
default:
CError_FATAL(1943);
}
if (linear)
LinkLinear(linear);
return linear;
}
void IRO_PreLinearize(Statement *stmt) {
IRO_FirstLinear = IRO_LastLinear = NULL;
IRO_NumLinear = 0;
CurrStmt = PrevStmt = NULL;
while (stmt) {
CurStat = stmt;
CurrStmt = stmt;
NullCheckList = NULL;
switch (stmt->type) {
case ST_NOP:
case ST_LABEL:
case ST_GOTO:
break;
case ST_OVF:
CError_FATAL(1989);
case ST_EXPRESSION:
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_SWITCH:
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_IFGOTO:
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_IFNGOTO:
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_RETURN:
if (stmt->expr)
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_BEGINCATCH:
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_ENDCATCH:
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_ENDCATCHDTOR:
LinearizeExpr1(stmt->expr, NULL, 0, 0);
break;
case ST_EXIT:
case ST_ENTRY:
case ST_ASM:
break;
default:
CError_FATAL(2038);
}
PrevStmt = stmt;
stmt = stmt->next;
}
IRO_CheckForUserBreak();
}
static void MarkAllSubExprs(IROLinear *linear) {
IROLinear *scan;
int i;
for (scan = linear; scan; scan = scan->next)
scan->flags &= ~IROLF_Reffed;
for (scan = linear; scan; scan = scan->next)
MarkSubExpr(scan);
}
void IRO_Linearize(Statement *stmt) {
IROLinear *linear;
IRO_FirstLinear = IRO_LastLinear = NULL;
IRO_NumLinear = 0;
while (stmt) {
CurStat = stmt;
linear = NULL;
switch (stmt->type) {
case ST_NOP:
linear = IRO_NewLinear(IROLinearNop);
break;
case ST_LABEL:
linear = IRO_NewLinear(IROLinearLabel);
linear->u.label.label = stmt->label;
linear->flags |= IROLF_1;
break;
case ST_GOTO:
linear = IRO_NewLinear(IROLinearGoto);
linear->u.label.label = stmt->label;
break;
case ST_EXPRESSION:
LinearizeExpr(stmt->expr);
break;
case ST_SWITCH:
linear = IRO_NewLinear(IROLinearSwitch);
linear->u.swtch.x4 = LinearizeExpr(stmt->expr);
linear->u.swtch.info = (SwitchInfo *) stmt->label;
break;
case ST_IFGOTO:
linear = IRO_NewLinear(IROLinearIf);
linear->u.label.x4 = LinearizeExpr(stmt->expr);
linear->u.label.label = stmt->label;
break;
case ST_IFNGOTO:
linear = IRO_NewLinear(IROLinearIfNot);
linear->u.label.x4 = LinearizeExpr(stmt->expr);
linear->u.label.label = stmt->label;
break;
case ST_RETURN:
IRO_FunctionHasReturn = 1;
linear = IRO_NewLinear(IROLinearReturn);
if (stmt->expr)
linear->u.monadic = LinearizeExpr(stmt->expr);
else
linear->u.monadic = NULL;
break;
case ST_OVF:
CError_FATAL(2143);
break;
case ST_EXIT:
linear = IRO_NewLinear(IROLinearExit);
linear->u.label.label = stmt->label;
break;
case ST_ENTRY:
linear = IRO_NewLinear(IROLinearEntry);
linear->u.label.label = stmt->label;
linear->flags |= IROLF_1;
break;
case ST_BEGINCATCH:
linear = IRO_NewLinear(IROLinearBeginCatch);
linear->u.ctch.linear = LinearizeExpr(stmt->expr);
linear->u.ctch.x4 = 0;
linear->u.ctch.x8 = 0;
break;
case ST_ENDCATCH:
linear = IRO_NewLinear(IROLinearEndCatch);
linear->u.monadic = LinearizeExpr(stmt->expr);
break;
case ST_ENDCATCHDTOR:
linear = IRO_NewLinear(IROLinearEndCatchDtor);
linear->u.monadic = LinearizeExpr(stmt->expr);
break;
case ST_ASM:
linear = IRO_NewLinear(IROLinearAsm);
linear->u.asm_stmt = stmt;
if (copts.optimizewithasm) {
IAEffects effects;
CodeGen_GetAsmEffects(stmt, &effects);
if (effects.x0 || effects.x3)
DisableDueToAsm = 1;
} else {
DisableDueToAsm = 1;
}
break;
default:
CError_FATAL(2194);
}
if (linear)
LinkLinear(linear);
stmt = stmt->next;
}
linear = IRO_NewLinear(IROLinearEnd);
linear->flags |= IROLF_1;
LinkLinear(linear);
MarkAllSubExprs(IRO_FirstLinear);
IRO_CheckForUserBreak();
}
static Statement *NewStatement(IROLinear *linear, StatementType sttype) {
Statement *stmt = lalloc(sizeof(Statement));
memset(stmt, 0, sizeof(Statement));
stmt->type = sttype;
stmt->value = 1;
if (linear->stmt) {
stmt->dobjstack = linear->stmt->dobjstack;
stmt->sourceoffset = linear->stmt->sourceoffset;
stmt->sourcefilepath = linear->stmt->sourcefilepath;
stmt->value = linear->stmt->value;
stmt->flags = linear->stmt->flags;
} else {
stmt->sourceoffset = -1;
stmt->sourcefilepath = NULL;
}
return stmt;
}
ENode *IRO_NewENode(ENodeType nodetype) {
ENode *enode = lalloc(sizeof(ENode));
memset(enode, 0, sizeof(ENode));
enode->type = nodetype;
return enode;
}
static ENode *BuildExpr(IROLinear *linear) {
ENode *enode;
switch (linear->type) {
case IROLinearOperand:
enode = IRO_NewENode(linear->u.node->type);
enode->flags = linear->nodeflags;
*enode = *linear->u.node;
break;
case IROLinearOp1Arg:
enode = IRO_NewENode(linear->nodetype);
enode->flags = linear->nodeflags;
enode->data.monadic = BuildExpr(linear->u.monadic);
enode->rtype = linear->rtype;
enode->cost = enode->data.monadic->cost;
if (!enode->cost)
enode->cost = 1;
break;
case IROLinearOp2Arg:
enode = IRO_NewENode(linear->nodetype);
enode->flags = linear->nodeflags;
enode->data.diadic.left = BuildExpr(linear->u.diadic.left);
enode->data.diadic.right = BuildExpr(linear->u.diadic.right);
enode->cost = enode->data.diadic.left->cost;
if (enode->data.diadic.right->cost > enode->cost)
enode->cost = enode->data.diadic.right->cost;
else if (enode->data.diadic.right->cost == enode->cost)
enode->cost += 1;
if (ENODE_IS4(enode, ESHL, ESHR, EDIV, EMODULO))
enode->cost += 2;
if (enode->cost > 200)
enode->cost = 200;
enode->rtype = linear->rtype;
break;
case IROLinearOp3Arg:
enode = IRO_NewENode(linear->nodetype);
enode->flags = linear->nodeflags;
enode->data.cond.cond = BuildExpr(linear->u.args3.a);
enode->data.cond.expr1 = BuildExpr(linear->u.args3.b);
enode->data.cond.expr2 = BuildExpr(linear->u.args3.c);
enode->rtype = linear->rtype;
enode->cost = enode->data.cond.cond->cost;
if (enode->data.cond.expr1->cost > enode->cost)
enode->cost = enode->data.cond.expr1->cost;
if (enode->data.cond.expr2->cost > enode->cost)
enode->cost = enode->data.cond.expr2->cost;
enode->cost += 1;
if (enode->cost > 200)
enode->cost = 200;
break;
case IROLinearFunccall: {
int i;
enode = IRO_NewENode(linear->u.funccall.ispascal ? EFUNCCALLP : EFUNCCALL);
enode->flags = linear->nodeflags;
enode->data.funccall.funcref = BuildExpr(linear->u.funccall.linear8);
enode->data.funccall.functype = linear->u.funccall.functype;
enode->data.funccall.args = NULL;
enode->cost = 200;
for (i = linear->u.funccall.argCount - 1; i >= 0; i--) {
ENodeList *list = lalloc(sizeof(ENodeList));
list->node = BuildExpr(linear->u.funccall.args[i]);
list->next = enode->data.funccall.args;
enode->data.funccall.args = list;
}
enode->rtype = linear->rtype;
break;
}
default:
IRO_Dump("Oh, oh, bad expression type in BuildExpr at: %d\n", linear->index);
CError_FATAL(2390);
}
enode->pointsTo = linear->pointsToFunction;
return enode;
}
Statement *IRO_Delinearize(IRONode *node, IROLinear *linear) {
IROLinear *scanlin;
Statement *firstStmt;
Statement *lastStmt;
IRONode *scan;
Statement *stmt;
IRONode mynode;
firstStmt = lastStmt = NULL;
if (node) {
scan = node;
MarkAllSubExprs(IRO_FirstLinear);
} else {
memset(&mynode, 0, sizeof(IRONode));
mynode.first = linear;
scan = &mynode;
MarkAllSubExprs(linear);
}
while (scan) {
for (scanlin = scan->first; scanlin; scanlin = scanlin->next) {
stmt = NULL;
if (!(scanlin->flags & IROLF_Reffed)) {
switch (scanlin->type) {
case IROLinearNop:
if (scan == node)
stmt = NewStatement(scanlin, ST_NOP);
else
stmt = NULL;
break;
case IROLinearOperand:
case IROLinearOp1Arg:
case IROLinearOp2Arg:
case IROLinearOp3Arg:
case IROLinearFunccall:
stmt = NewStatement(scanlin, ST_EXPRESSION);
stmt->expr = BuildExpr(scanlin);
break;
case IROLinearGoto:
stmt = NewStatement(scanlin, ST_GOTO);
stmt->label = scanlin->u.label.label;
break;
case IROLinearExit:
stmt = NewStatement(scanlin, ST_EXIT);
stmt->label = scanlin->u.label.label;
break;
case IROLinearIf:
case IROLinearIfNot:
stmt = NewStatement(scanlin, (scanlin->type == IROLinearIf) ? ST_IFGOTO : ST_IFNGOTO);
stmt->label = scanlin->u.label.label;
stmt->expr = BuildExpr(scanlin->u.label.x4);
break;
case IROLinearReturn:
stmt = NewStatement(scanlin, ST_RETURN);
if (scanlin->u.monadic)
stmt->expr = BuildExpr(scanlin->u.monadic);
break;
case IROLinearLabel:
stmt = NewStatement(scanlin, ST_LABEL);
stmt->label = scanlin->u.label.label;
stmt->label->stmt = stmt;
break;
case IROLinearEntry:
stmt = NewStatement(scanlin, ST_ENTRY);
stmt->label = scanlin->u.label.label;
stmt->label->stmt = stmt;
break;
case IROLinearSwitch:
stmt = NewStatement(scanlin, ST_SWITCH);
stmt->expr = BuildExpr(scanlin->u.swtch.x4);
stmt->label = (CLabel *) scanlin->u.swtch.info;
break;
case IROLinearBeginCatch:
stmt = NewStatement(scanlin, ST_BEGINCATCH);
stmt->expr = BuildExpr(scanlin->u.ctch.linear);
break;
case IROLinearEndCatch:
stmt = NewStatement(scanlin, ST_ENDCATCH);
stmt->expr = BuildExpr(scanlin->u.monadic);
break;
case IROLinearEndCatchDtor:
stmt = NewStatement(scanlin, ST_ENDCATCHDTOR);
stmt->expr = BuildExpr(scanlin->u.monadic);
break;
case IROLinearAsm:
stmt = scanlin->u.asm_stmt;
break;
case IROLinearEnd:
stmt = NULL;
break;
default:
CError_FATAL(2685);
}
if (stmt) {
if (LoopOptimizerRun) {
SInt32 i;
SInt32 value = 1;
for (i = 0; i < scan->loopdepth; i++) {
value = (value < 4096) ? (value * 8) : (value + 1);
}
stmt->value = value;
}
if (firstStmt)
lastStmt->next = stmt;
else
firstStmt = stmt;
lastStmt = stmt;
}
}
if (scanlin == scan->last)
break;
}
scan = scan->nextnode;
}
return firstStmt;
}
void IRO_RenumberInts(void) {
IROLinear *linear = IRO_FirstLinear;
IRO_NumLinear = 0;
while (linear) {
linear->index = IRO_NumLinear++;
linear = linear->next;
}
}
static void TravExprToUpdateFlags(IROLinear *linear) {
int i;
linear->flags &= ~(IROLF_Assigned | IROLF_8 | IROLF_Used | IROLF_Ind | IROLF_Subs | IROLF_LoopInvariant | IROLF_Ris | IROLF_Immind | IROLF_CouldError);
switch (linear->type) {
case IROLinearNop:
case IROLinearOperand:
break;
case IROLinearOp1Arg:
TravExprToUpdateFlags(linear->u.monadic);
if (IRO_IsAssignOp[linear->nodetype])
MarkAssigned(linear->u.monadic, 1);
if (linear->nodetype == EINDIRECT) {
MarkSubs1(linear->u.monadic);
linear->u.monadic->flags |= IROLF_Immind | IROLF_Ind;
if (IS_LINEAR_DIADIC(linear->u.monadic, EADD))
MarkSubscript(linear->u.monadic);
}
break;
case IROLinearOp2Arg:
TravExprToUpdateFlags(linear->u.diadic.left);
TravExprToUpdateFlags(linear->u.diadic.right);
if (IRO_IsAssignOp[linear->nodetype])
MarkAssigned(linear->u.diadic.left, IRO_IsModifyOp[linear->nodetype]);
break;
case IROLinearOp3Arg:
TravExprToUpdateFlags(linear->u.args3.a);
TravExprToUpdateFlags(linear->u.args3.b);
TravExprToUpdateFlags(linear->u.args3.c);
break;
case IROLinearFunccall:
TravExprToUpdateFlags(linear->u.funccall.linear8);
for (i = linear->u.funccall.argCount - 1; i >= 0; i--)
TravExprToUpdateFlags(linear->u.funccall.args[i]);
break;
default:
IRO_Dump("Oh, oh, bad expression type in TravExprToUpdateFlags at: %d\n", linear->index);
CError_FATAL(2853);
}
}
void IRO_UpdateFlagsOnInts(void) {
IROLinear *linear;
IRONode *node;
MarkAllSubExprs(IRO_FirstLinear);
for (node = IRO_FirstNode; node; node = node->nextnode) {
for (linear = node->first; linear; linear = linear->next) {
if (!(linear->flags & IROLF_Reffed)) {
switch (linear->type) {
case IROLinearOperand:
case IROLinearOp1Arg:
case IROLinearOp2Arg:
case IROLinearOp3Arg:
case IROLinearFunccall:
TravExprToUpdateFlags(linear);
break;
case IROLinearIf:
case IROLinearIfNot:
TravExprToUpdateFlags(linear->u.label.x4);
break;
case IROLinearReturn:
if (linear->u.monadic)
TravExprToUpdateFlags(linear->u.monadic);
break;
case IROLinearSwitch:
TravExprToUpdateFlags(linear->u.swtch.x4);
break;
case IROLinearBeginCatch:
TravExprToUpdateFlags(linear->u.ctch.linear);
break;
case IROLinearEndCatch:
TravExprToUpdateFlags(linear->u.monadic);
break;
case IROLinearEndCatchDtor:
TravExprToUpdateFlags(linear->u.monadic);
break;
case IROLinearNop:
case IROLinearGoto:
case IROLinearLabel:
case IROLinearEntry:
case IROLinearExit:
case IROLinearAsm:
case IROLinearEnd:
break;
default:
CError_FATAL(2931);
}
}
if (linear == node->last)
break;
}
}
}
void IRO_SaveLinearIR(IROLinearIRSave *save) {
save->firstLinear = IRO_FirstLinear;
save->lastLinear = IRO_LastLinear;
save->numLinear = IRO_NumLinear;
save->curStat = CurStat;
save->disableDueToAsm = DisableDueToAsm;
save->isLeafFunction = IRO_IsLeafFunction;
save->functionHasReturn = IRO_FunctionHasReturn;
save->nullCheckList = NullCheckList;
save->currStmt = CurrStmt;
save->prevStmt = PrevStmt;
}
void IRO_RestoreLinearIR(IROLinearIRSave *save) {
IRO_FirstLinear = save->firstLinear;
IRO_LastLinear = save->lastLinear;
IRO_NumLinear = save->numLinear;
CurStat = save->curStat;
DisableDueToAsm = save->disableDueToAsm;
IRO_IsLeafFunction = save->isLeafFunction;
IRO_FunctionHasReturn = save->functionHasReturn;
NullCheckList = save->nullCheckList;
CurrStmt = save->currStmt;
PrevStmt = save->prevStmt;
}
Reference in New Issue View Git Blame Copy Permalink