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

1039 lines
33 KiB
C
Raw Blame History

#include "compiler/IroCSE.h"
#include "compiler/IroDump.h"
#include "compiler/IroFlowgraph.h"
#include "compiler/IroLinearForm.h"
#include "compiler/IroMalloc.h"
#include "compiler/IroPointerAnalysis.h"
#include "compiler/IroSubable.h"
#include "compiler/IROUseDef.h"
#include "compiler/IroUtil.h"
#include "compiler/IroVars.h"
#include "compiler/CError.h"
#include "compiler/CExpr.h"
#include "compiler/CInt64.h"
#include "compiler/CParser.h"
#include "compiler/CompilerTools.h"
#include "compiler/objects.h"
BitVector *IRO_Depends;
Boolean IRO_NotSubable;
Boolean IRO_IsVolatile;
Boolean IRO_CouldError;
IROExpr *IRO_FirstExpr;
IROExpr *IRO_LastExpr;
SInt32 IRO_NumExprs;
static Boolean HasVectorOperand;
// forward decls
static void IRO_DependsOnForDataFlow(IROLinear *linear, Boolean flag);
static void GetDependsOfIndirect(IROLinear *nd) {
IROListNode *resultList;
IROListNode *next;
IROListNode *list;
IROListNode *scan;
IROLinear *scannd;
Object *obj;
VarRecord *var;
int index;
Boolean result;
Boolean foundObjRef;
result = 0;
if (nd && copts.opt_pointer_analysis && nd->pointsToFunction && FunctionName) {
resultList = NULL;
PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, nd, &resultList);
if ((list = resultList)) {
for (scan = list; scan; scan = scan->nextList) {
if (!scan->list.head || !scan->list.tail) {
result = 1;
break;
}
foundObjRef = 0;
for (scannd = scan->list.head; scannd != scan->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
foundObjRef = 1;
break;
}
}
if (!foundObjRef) {
result = 1;
break;
}
}
if (!result) {
while (list) {
for (scannd = list->list.head; scannd != list->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
obj = scannd->u.node->data.objref;
CError_ASSERT(119, obj != NULL);
var = IRO_FindVar(obj, 1, 1);
CError_ASSERT(121, var != NULL);
index = var->index;
CError_ASSERT(123, index != 0);
if (is_volatile_object(obj)) {
IRO_IsVolatile = 1;
IRO_NotSubable = 1;
}
Bv_SetBit(index, IRO_Depends);
}
}
list = list->nextList;
}
}
while (resultList) {
next = resultList->nextList;
IRO_free(resultList);
resultList = next;
}
} else {
result = 1;
}
} else {
result = 1;
}
if (result) {
nd = nd->u.monadic;
if (nd->type == IROLinearOp1Arg && nd->nodetype == EBITFIELD)
nd = nd->u.monadic;
if (nd->type == IROLinearOp2Arg && nd->nodetype == EADD) {
IRO_BaseTerms = 0;
IRO_VarTerms = 0;
IRO_DecomposeAddressExpression_Cheap(nd);
if (IRO_BaseTerms != 1) {
IRO_CouldError = 1;
Bv_SetBit(0, IRO_Depends);
Bv_Or(IRO_FuncKills, IRO_Depends);
}
if (IRO_VarTerms)
IRO_CouldError = 1;
} else {
IRO_CouldError = 1;
Bv_SetBit(0, IRO_Depends);
Bv_Or(IRO_FuncKills, IRO_Depends);
}
}
}
static void GetDependsOfFunctionCallForDataFlow(IROLinear *nd) {
IROLinear *innernd;
IROListNode *resultList;
IROListNode *next;
IROListNode *list;
IROListNode *scan;
IROLinear *scannd;
Object *obj;
VarRecord *var;
int index;
Boolean result;
Boolean foundObjRef;
ObjectList *olist;
ObjectList *depsList;
result = 0;
innernd = nd->u.funccall.linear8;
if (innernd && copts.opt_pointer_analysis && innernd->pointsToFunction && FunctionName) {
resultList = NULL;
PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, innernd, &resultList);
if ((list = resultList)) {
for (scan = list; scan; scan = scan->nextList) {
if (!scan->list.head || !scan->list.tail) {
result = 1;
break;
}
foundObjRef = 0;
for (scannd = scan->list.head; scannd != scan->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
foundObjRef = 1;
obj = scannd->u.node->data.objref;
CError_ASSERT(234, obj != NULL);
depsList = NULL;
PointerAnalysis_GetFunctionDependencies(obj, nd, &depsList);
for (olist = depsList; olist; olist = olist->next) {
if (!olist->object) {
result = 1;
break;
}
}
while (depsList) {
olist = depsList->next;
IRO_free(depsList);
depsList = olist;
}
if (result)
break;
}
}
if (!foundObjRef)
result = 1;
if (result)
break;
}
if (!result) {
for (list = resultList; list; list = list->nextList) {
for (scannd = list->list.head; scannd != list->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
obj = scannd->u.node->data.objref;
depsList = NULL;
PointerAnalysis_GetFunctionDependencies(obj, nd, &depsList);
for (olist = depsList; olist; olist = olist->next) {
var = IRO_FindVar(olist->object, 1, 1);
CError_ASSERT(285, var != NULL);
index = var->index;
CError_ASSERT(287, index != 0);
if (is_volatile_object(olist->object)) {
IRO_IsVolatile = 1;
IRO_NotSubable = 1;
}
Bv_SetBit(index, IRO_Depends);
}
while (depsList) {
olist = depsList->next;
IRO_free(depsList);
depsList = olist;
}
}
}
}
}
while (resultList) {
next = resultList->nextList;
IRO_free(resultList);
resultList = next;
}
} else {
result = 1;
}
} else {
result = 1;
}
if (result) {
IRO_DependsOnForDataFlow(nd->u.funccall.linear8, 0);
Bv_Or(IRO_FuncKills, IRO_Depends);
for (index = nd->u.funccall.argCount - 1; index >= 0; index--)
IRO_DependsOnForDataFlow(nd->u.funccall.args[index], 0);
}
}
static void IRO_DependsOn(IROLinear *linear, Boolean flag) {
VarRecord *var;
IROLinear *inner;
if (linear->rtype && CParser_IsVolatile(linear->rtype, linear->nodeflags & ENODE_FLAG_QUALS)) {
IRO_IsVolatile = 1;
IRO_NotSubable = 1;
}
if (!IRO_NotSubable) {
switch (linear->type) {
case IROLinearOperand:
if (flag && linear->u.node->type == EOBJREF) {
if ((var = IRO_FindVar(linear->u.node->data.objref, 0, 1))) {
if (is_volatile_object(var->object)) {
IRO_IsVolatile = 1;
IRO_NotSubable = 1;
}
Bv_SetBit(var->index, IRO_Depends);
} else {
IRO_NotSubable = 1;
}
}
break;
case IROLinearOp1Arg:
if (IRO_IsAssignOp[linear->nodetype]) {
IRO_NotSubable = 1;
} else {
inner = linear->u.monadic;
if (linear->nodetype == EINDIRECT) {
if (inner->type == IROLinearOp1Arg && inner->nodetype == EBITFIELD)
inner = inner->u.monadic;
if (inner->type != IROLinearOperand || inner->u.node->type != EOBJREF)
GetDependsOfIndirect(linear);
}
IRO_DependsOn(inner, linear->nodetype == EINDIRECT);
}
break;
case IROLinearOp2Arg:
if (IRO_IsAssignOp[linear->nodetype]) {
IRO_NotSubable = 1;
} else {
if (linear->nodetype == EDIV || linear->nodetype == EMODULO) {
if (IRO_IsIntConstant(linear->u.diadic.right)) {
if (CInt64_Equal(linear->u.diadic.right->u.node->data.intval, cint64_zero))
IRO_CouldError = 1;
} else {
IRO_CouldError = 1;
}
}
IRO_DependsOn(linear->u.diadic.left, flag);
IRO_DependsOn(linear->u.diadic.right, flag);
}
break;
case IROLinearOp3Arg:
if (IRO_IsAssignOp[linear->nodetype]) {
IRO_NotSubable = 1;
} else {
IRO_DependsOn(linear->u.args3.a, flag);
IRO_DependsOn(linear->u.args3.b, flag);
IRO_DependsOn(linear->u.args3.c, flag);
}
break;
case IROLinearFunccall:
IRO_NotSubable = 1;
break;
default:
CError_FATAL(479);
}
}
}
static void IRO_DependsOnForDataFlow(IROLinear *linear, Boolean flag) {
VarRecord *var;
IROLinear *inner;
if (linear->rtype && CParser_IsVolatile(linear->rtype, linear->nodeflags & ENODE_FLAG_QUALS)) {
IRO_IsVolatile = 1;
IRO_NotSubable = 1;
}
switch (linear->type) {
case IROLinearOperand:
if (flag && linear->u.node->type == EOBJREF) {
if ((var = IRO_FindVar(linear->u.node->data.objref, 0, 1))) {
if (is_volatile_object(var->object)) {
IRO_IsVolatile = 1;
IRO_NotSubable = 1;
}
Bv_SetBit(var->index, IRO_Depends);
} else {
IRO_NotSubable = 1;
}
}
break;
case IROLinearOp1Arg:
if (IRO_IsAssignOp[linear->nodetype])
IRO_NotSubable = 1;
inner = linear->u.monadic;
if (linear->nodetype == EINDIRECT) {
if (inner->type == IROLinearOp1Arg && inner->nodetype == EBITFIELD)
inner = inner->u.monadic;
if (inner->type != IROLinearOperand || inner->u.node->type != EOBJREF)
GetDependsOfIndirect(linear);
}
IRO_DependsOnForDataFlow(inner, linear->nodetype == EINDIRECT);
break;
case IROLinearOp2Arg:
if (IRO_IsAssignOp[linear->nodetype])
IRO_NotSubable = 1;
if (linear->nodetype == EDIV || linear->nodetype == EMODULO) {
if (IRO_IsIntConstant(linear->u.diadic.right)) {
if (CInt64_Equal(linear->u.diadic.right->u.node->data.intval, cint64_zero))
IRO_CouldError = 1;
} else {
IRO_CouldError = 1;
}
}
IRO_DependsOnForDataFlow(linear->u.diadic.left, flag);
IRO_DependsOnForDataFlow(linear->u.diadic.right, flag);
break;
case IROLinearOp3Arg:
if (IRO_IsAssignOp[linear->nodetype])
IRO_NotSubable = 1;
IRO_DependsOnForDataFlow(linear->u.args3.a, flag);
IRO_DependsOnForDataFlow(linear->u.args3.b, flag);
IRO_DependsOnForDataFlow(linear->u.args3.c, flag);
break;
case IROLinearFunccall:
IRO_NotSubable = 1;
GetDependsOfFunctionCallForDataFlow(linear);
break;
default:
CError_FATAL(650);
}
}
void IRO_FindDepends_NoAlloc(IROLinear *linear) {
Bv_Clear(IRO_Depends);
IRO_CouldError = 0;
IRO_NotSubable = 0;
IRO_IsVolatile = 0;
IRO_DependsOnForDataFlow(linear, 0);
}
void IRO_FindDepends(IROLinear *linear) {
Bv_AllocVector(&IRO_Depends, IRO_NumVars + 1);
IRO_CouldError = 0;
IRO_NotSubable = 0;
IRO_DependsOn(linear, 0);
}
static void VecAct(IROLinear *linear, Boolean isFirst) {
if (!isFirst && (linear->flags & IROLF_VecOpBase))
HasVectorOperand = 1;
}
static Boolean IRO_DoesNotHaveVectorOperand(IROLinear *linear) {
HasVectorOperand = 0;
IRO_WalkTree(linear, VecAct);
return HasVectorOperand == 0;
}
static void IRO_AddExpression(IROLinear *linear, IRONode *node, Boolean flag) {
IROExpr *expr;
if ((linear->flags & IROLF_Reffed) && IRO_IsSubableExpression(linear) && IRO_DoesNotHaveVectorOperand(linear)) {
expr = oalloc(sizeof(IROExpr));
expr->x0 = 0;
expr->index = ++IRO_NumExprs;
expr->linear = linear;
expr->x8 = NULL;
expr->node = node;
IRO_FindDepends(linear);
expr->depends = IRO_Depends;
expr->notSubable = IRO_NotSubable;
expr->couldError = IRO_CouldError;
expr->next = NULL;
expr->x14 = NULL;
if (IRO_FirstExpr)
IRO_LastExpr->next = expr;
else
IRO_FirstExpr = expr;
IRO_LastExpr = expr;
linear->expr = expr;
}
}
void IRO_FindExpressions(BitVector *bv, Boolean flag) {
IROLinear *nd;
IRONode *fnode;
IRO_FirstExpr = IRO_LastExpr = NULL;
IRO_NumExprs = 0;
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
if (!bv || Bv_IsBitSet(fnode->index, bv)) {
for (nd = fnode->first; nd; nd = nd->next) {
nd->expr = NULL;
IRO_AddExpression(nd, fnode, flag);
if (nd == fnode->last)
break;
}
} else {
for (nd = fnode->first; nd; nd = nd->next) {
nd->expr = NULL;
if (nd == fnode->last)
break;
}
}
}
IRO_CheckForUserBreak();
}
void IRO_RemoveExpr(IROExpr *expr) {
IROExpr *prev;
IROExpr *scan;
scan = IRO_FirstExpr;
prev = NULL;
while (scan != expr) {
prev = scan;
scan = scan->next;
CError_ASSERT(809, scan);
}
expr->linear->expr = NULL;
if (prev)
prev->next = expr->next;
else
IRO_FirstExpr = expr->next;
}
static void GetExprKillsByIndirectAssignment(IROLinear *linear) {
IROLinear *inner;
IROListNode *resultList;
IROListNode *next;
IROListNode *list;
IROListNode *scan;
IROLinear *scannd;
Object *obj;
VarRecord *var;
int index;
Boolean result;
Boolean foundObjRef;
IROExpr *expr;
result = 0;
if (linear->type == IROLinearOp2Arg)
linear = linear->u.diadic.left;
else
linear = linear->u.monadic;
if (
linear &&
linear->type == IROLinearOp1Arg &&
linear->nodetype == EINDIRECT &&
(inner = linear->u.monadic) &&
copts.opt_pointer_analysis &&
inner->pointsToFunction &&
FunctionName
) {
resultList = NULL;
PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, inner, &resultList);
if ((list = resultList)) {
for (scan = list; scan; scan = scan->nextList) {
if (!scan->list.head || !scan->list.tail) {
result = 1;
break;
}
foundObjRef = 0;
for (scannd = scan->list.head; scannd != scan->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
foundObjRef = 1;
break;
}
}
if (!foundObjRef) {
result = 1;
break;
}
}
if (!result) {
while (list) {
for (scannd = list->list.head; scannd != list->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
obj = scannd->u.node->data.objref;
CError_ASSERT(893, obj != NULL);
var = IRO_FindVar(obj, 1, 1);
CError_ASSERT(895, var != NULL);
index = var->index;
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
if (Bv_IsBitSet(index, expr->depends))
Bv_SetBit(expr->index, IRO_ExprKills);
}
}
}
list = list->nextList;
}
}
while (resultList) {
next = resultList->nextList;
IRO_free(resultList);
resultList = next;
}
} else {
result = 1;
}
} else {
result = 1;
}
if (result) {
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
if (Bv_BitsInCommon(expr->depends, IRO_FuncKills))
Bv_SetBit(expr->index, IRO_ExprKills);
}
}
}
static void GetExprKillsByFunctionCall(IROLinear *funccall) {
IROLinear *innernd;
IROListNode *resultList;
IROListNode *next;
IROListNode *list;
IROListNode *scan;
IROLinear *scannd;
Object *obj;
VarRecord *var;
int index;
Boolean result;
Boolean foundObjRef;
ObjectList *olist;
ObjectList *depsList;
IROExpr *expr;
result = 0;
innernd = funccall->u.funccall.linear8;
if (innernd && copts.opt_pointer_analysis && innernd->pointsToFunction && FunctionName) {
resultList = NULL;
PointerAnalysis_LookupLinearNodePointerExpr(FunctionName, innernd, &resultList);
if ((list = resultList)) {
for (scan = list; scan; scan = scan->nextList) {
if (!scan->list.head || !scan->list.tail) {
result = 1;
break;
}
foundObjRef = 0;
for (scannd = scan->list.head; scannd != scan->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
foundObjRef = 1;
obj = scannd->u.node->data.objref;
CError_ASSERT(991, obj != NULL);
depsList = NULL;
PointerAnalysis_GetFunctionKills(obj, funccall, &depsList);
for (olist = depsList; olist; olist = olist->next) {
if (!olist->object) {
result = 1;
break;
}
}
while (depsList) {
olist = depsList->next;
IRO_free(depsList);
depsList = olist;
}
if (result)
break;
}
}
if (!foundObjRef)
result = 1;
if (result)
break;
}
if (!result) {
for (list = resultList; list; list = list->nextList) {
for (scannd = list->list.head; scannd != list->list.tail->next; scannd = scannd->next) {
if (scannd->type == IROLinearOperand && scannd->u.node->type == EOBJREF) {
obj = scannd->u.node->data.objref;
depsList = NULL;
PointerAnalysis_GetFunctionKills(obj, funccall, &depsList);
for (olist = depsList; olist; olist = olist->next) {
var = IRO_FindVar(olist->object, 1, 1);
CError_ASSERT(1042, var != NULL);
index = var->index;
CError_ASSERT(1044, index != 0);
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
if (Bv_IsBitSet(index, expr->depends))
Bv_SetBit(expr->index, IRO_ExprKills);
}
}
while (depsList) {
olist = depsList->next;
IRO_free(depsList);
depsList = olist;
}
}
}
}
}
while (resultList) {
next = resultList->nextList;
IRO_free(resultList);
resultList = next;
}
} else {
result = 1;
}
} else {
result = 1;
}
if (result) {
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
if (Bv_BitsInCommon(expr->depends, IRO_FuncKills))
Bv_SetBit(expr->index, IRO_ExprKills);
}
}
}
static void IRO_GetExprKills(IROLinear *linear) {
Bv_Clear(IRO_ExprKills);
switch (linear->type) {
case IROLinearOp1Arg:
case IROLinearOp2Arg:
if (IRO_IsAssignOp[linear->nodetype]) {
VarRecord *var;
int index;
var = IRO_FindAssigned(linear);
index = 0;
if (var)
index = var->index;
if (!index) {
GetExprKillsByIndirectAssignment(linear);
} else {
IROExpr *expr;
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
if (Bv_IsBitSet(index, expr->depends))
Bv_SetBit(expr->index, IRO_ExprKills);
}
}
}
break;
case IROLinearAsm: {
IROExpr *expr;
IRO_GetKills(linear);
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
if (Bv_BitsInCommon(expr->depends, IRO_VarKills))
Bv_SetBit(expr->index, IRO_ExprKills);
}
break;
}
case IROLinearFunccall:
GetExprKillsByFunctionCall(linear);
break;
}
}
void IRO_ComputeAvail(void) {
IRONode *node;
IROLinear *linear;
SInt32 counter;
BitVector *bv;
Boolean flag;
counter = 0;
node = IRO_FirstNode;
Bv_AllocVector(&IRO_VarKills, IRO_NumVars + 1);
Bv_AllocVector(&IRO_ExprKills, IRO_NumExprs + 1);
while (node) {
Bv_AllocVector(&node->x16, IRO_NumExprs);
if (node->numpred)
Bv_Set(node->x16);
Bv_AllocVector(&node->x22, IRO_NumExprs);
Bv_AllocVector(&node->x1E, IRO_NumExprs);
Bv_AllocVector(&node->x1A, IRO_NumExprs);
for (linear = node->first; linear; linear = linear->next) {
if (linear->expr)
Bv_SetBit(linear->expr->index, node->x1E);
IRO_GetExprKills(linear);
Bv_Or(IRO_ExprKills, node->x22);
Bv_Minus(IRO_ExprKills, node->x1E);
if (linear == node->last)
break;
if (counter > 250) {
IRO_CheckForUserBreak();
counter = 0;
} else {
counter++;
}
}
Bv_Copy(node->x16, node->x1A);
Bv_Minus(node->x22, node->x1A);
Bv_Or(node->x1E, node->x1A);
node = node->nextnode;
}
IRO_CheckForUserBreak();
Bv_AllocVector(&bv, IRO_NumExprs);
do {
flag = 0;
for (node = IRO_FirstNode; node; node = node->nextnode) {
if (!node->numpred) {
Bv_Clear(bv);
} else {
UInt16 i;
Bv_Set(bv);
for (i = 0; i < node->numpred; i++)
Bv_And(IRO_NodeTable[node->pred[i]]->x1A, bv);
}
if (!Bv_Compare(bv, node->x16)) {
flag = 1;
Bv_Copy(bv, node->x16);
}
Bv_Copy(node->x16, node->x1A);
Bv_Minus(node->x22, node->x1A);
Bv_Or(node->x1E, node->x1A);
}
IRO_CheckForUserBreak();
} while (flag);
}
static void IRO_MakeReplacementEmbedded(IROExpr *expr) {
IROLinear *opnd;
IROLinear *ind;
IROLinear *ass;
IRO_GetTemp(expr);
opnd = IRO_NewLinear(IROLinearOperand);
opnd->u.node = create_objectrefnode(expr->x8);
opnd->rtype = opnd->u.node->data.objref->type;
opnd->index = ++IRO_NumLinear;
opnd->flags |= IROLF_Reffed | IROLF_Assigned | IROLF_Ind;
ind = IRO_NewLinear(IROLinearOp1Arg);
ind->nodetype = EINDIRECT;
ind->rtype = expr->linear->rtype;
ind->u.monadic = opnd;
ind->index = ++IRO_NumLinear;
ind->flags |= IROLF_Reffed | IROLF_Assigned;
ass = IRO_NewLinear(IROLinearOp2Arg);
ass->nodetype = EASS;
ass->u.diadic.left = ind;
ass->u.diadic.right = expr->linear;
ass->rtype = expr->linear->rtype;
ass->index = ++IRO_NumLinear;
opnd->next = ind;
ind->next = ass;
IRO_ReplaceReferenceWithNode(expr->linear, ass);
IRO_PasteAfter(opnd, ass, expr->linear);
}
static void IRO_ActUnmarkSubExpressions(IROLinear *linear, Boolean isFirst) {
if (isFirst)
linear->flags &= ~IROLF_8;
}
static void CheckCommonSub(IROLinear *linear) {
IROExpr *expr;
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
if (expr->linear != linear && !expr->x14) {
if (Bv_IsBitSet(expr->index, IRO_Avail) && !expr->notSubable && IRO_ExprsSame(linear, expr->linear)) {
IRO_WalkTree(linear, IRO_ActUnmarkSubExpressions);
linear->flags |= IROLF_8;
linear->expr->x14 = expr;
break;
}
}
}
}
static void MoveCommonSub(IROExpr *expr) {
SInt32 best;
SInt32 sz1;
SInt32 sz2;
SInt32 i1;
SInt32 i2;
IROLinear *scan;
IROLinear *array1[64];
IROLinear *array2[64];
IROExpr *scanexpr;
sz1 = 0;
scan = expr->linear;
do {
scan = IRO_LocateFather(scan);
if (scan) {
if (sz1 == 64)
return;
array1[sz1++] = scan;
}
} while (scan);
best = -1;
for (scanexpr = IRO_FirstExpr; scanexpr; scanexpr = scanexpr->next) {
if (scanexpr->x14 == expr) {
sz2 = 0;
scan = scanexpr->linear;
do {
scan = IRO_LocateFather(scan);
if (scan) {
if (sz2 == 64)
return;
array2[sz2++] = scan;
}
} while (scan);
i1 = sz1;
i2 = sz2;
while (i1 && i2 && array1[sz1 - 1] == array2[sz2 - 1]) {
i1--;
i2--;
}
if (i1 != sz1 && i1 > best)
best = i1;
}
}
if (best < 0) {
IRO_MakeReplacementEmbedded(expr);
} else {
IROLinear *start;
IROLinear *comma;
IRO_Dump("Moving common sub from node %d to %d\n", expr->linear->index, array1[best]->index);
start = IRO_FindStart(array1[best]);
IRO_GetTemp(expr);
IRO_ReplaceReference(expr->linear, expr->x8, expr->linear);
IRO_MoveExpression(expr, start);
comma = IRO_NewLinear(IROLinearOp2Arg);
comma->nodetype = ECOMMA;
comma->rtype = array1[best]->rtype;
comma->u.diadic.left = IRO_AssignToTemp(expr);
comma->u.diadic.right = array1[best];
comma->stmt = array1[best]->stmt;
IRO_ReplaceReferenceWithNode(array1[best], comma);
IRO_PasteAfter(comma, comma, array1[best]);
}
}
static void ReplaceCommonSub(IROLinear *linear) {
IROExpr *expr = linear->expr->x14;
if (!expr->x8) {
MoveCommonSub(expr);
if (!expr->x8)
return;
}
IRO_Dump("Replacing common sub at %d with %d\n", linear->index, expr->linear->index);
IRO_ReplaceReference(linear, expr->x8, linear);
IRO_RemoveExpr(linear->expr);
IRO_NopOut(linear);
}
void IRO_CommonSubs(void) {
IRONode *node;
IROLinear *linear;
SInt32 counter;
counter = 0;
for (node = IRO_FirstNode; node; node = node->nextnode) {
IRO_Avail = node->x16;
linear = node->first;
while (1) {
if (!linear)
break;
if (linear->expr && !linear->expr->notSubable)
CheckCommonSub(linear);
if (linear->expr)
Bv_SetBit(linear->expr->index, IRO_Avail);
IRO_GetExprKills(linear);
Bv_Minus(IRO_ExprKills, IRO_Avail);
if (linear == node->last)
break;
if (counter > 250) {
IRO_CheckForUserBreak();
counter = 0;
} else {
counter++;
}
linear = linear->next;
}
}
for (node = IRO_FirstNode; node; node = node->nextnode) {
for (linear = node->first; linear; linear = linear->next) {
if (linear->expr && (linear->flags & IROLF_8) && !IRO_HasSideEffect(linear))
ReplaceCommonSub(linear);
if (linear == node->last)
break;
if (counter > 250) {
IRO_CheckForUserBreak();
counter = 0;
} else {
counter++;
}
}
}
IRO_CheckForUserBreak();
}
static Boolean CountThisSubableOperandUse(IROUse *use) {
return use->x1C != 0;
}
static int GetSubableOperandUseCount(VarRecord *var) {
int count = 0;
IROUse *use;
if (var->uses) {
for (use = var->uses; use; use = use->varnext) {
if (CountThisSubableOperandUse(use))
count++;
}
}
return count;
}
static void IRO_MakeTopLevelExprForSubableOperand(IROLinear *linear) {
IROLinear *copy = IRO_NewLinear(IROLinearOperand);
memcpy(copy, linear, sizeof(IROLinear));
copy->index = ++IRO_NumLinear;
if (IRO_FirstLinear && IRO_FirstLinear->type == IROLinearNop)
IRO_PasteAfter(copy, copy, IRO_FirstLinear);
else
IRO_Paste(copy, copy, IRO_FirstLinear);
}
void IRO_GenerateTopLevelExprsForSubableOperands(void) {
IROLinear *nd;
IRONode *fnode;
VarRecord *var;
BitVector *bv;
Bv_AllocVector(&bv, IRO_NumVars + 1);
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
for (nd = fnode->first; nd; nd = nd->next) {
nd->expr = NULL;
if ((nd->flags & IROLF_Reffed) && IRO_IsSubableExpression(nd) && IRO_DoesNotHaveVectorOperand(nd)) {
if (nd->type == IROLinearOperand && nd->u.node && nd->u.node->type == EOBJREF) {
if ((var = IRO_FindVar(nd->u.node->data.objref, 0, 1))) {
if (!Bv_IsBitSet(var->index, bv)) {
IRO_MakeTopLevelExprForSubableOperand(nd);
Bv_SetBit(var->index, bv);
}
}
}
}
if (nd == fnode->last)
break;
}
}
}
Reference in New Issue View Git Blame Copy Permalink