mirror of https://git.wuffs.org/MWCC
2325 lines
84 KiB
C
2325 lines
84 KiB
C
#include "compiler/IroLoop.h"
|
|
#include "compiler/IroCSE.h"
|
|
#include "compiler/IroDump.h"
|
|
#include "compiler/IroFlowgraph.h"
|
|
#include "compiler/IroLinearForm.h"
|
|
#include "compiler/IroPropagate.h"
|
|
#include "compiler/IroSubable.h"
|
|
#include "compiler/IroUtil.h"
|
|
#include "compiler/IroVars.h"
|
|
#include "compiler/CFunc.h"
|
|
#include "compiler/CInt64.h"
|
|
#include "compiler/CMachine.h"
|
|
#include "compiler/objects.h"
|
|
#include "compiler/types.h"
|
|
|
|
IRONode *LoopNode;
|
|
Boolean ConditionalHeaderAtBottom;
|
|
IROLoopInd *FirstInd;
|
|
BitVector *InLoop;
|
|
IROList IRO_InitLList;
|
|
BitVector *InLoop_Exits;
|
|
BitVector *InLoop_Tails;
|
|
UInt32 LoopExitNumber;
|
|
UInt32 LoopTailNum;
|
|
IRONode *LoopExitSuccessor;
|
|
IRONode *LoopTail;
|
|
IROLoopMemRef *IRO_LoopMemRefFirst;
|
|
IROLoopMemRef *IRO_LoopMemRefCurrent;
|
|
static IROExpr *RisList;
|
|
static BitVector *AllKills;
|
|
static Boolean KnownBounds;
|
|
static SInt32 Times;
|
|
static IROLinear *PredInt;
|
|
static IROElmList *FirstAddendLinear;
|
|
static IROElmList *LastAddendLinear;
|
|
static int NoSubableSubs;
|
|
|
|
// forward decls
|
|
static void MyHandleLoop_Vector(IRONode *fnode);
|
|
static void MyHandleLoop_Motion(IRONode *fnode);
|
|
static void CheckAllLoopAddresses(IRONode *fnode, BitVector *bv, Boolean *resultFlag);
|
|
static void MakeLoopEntry(IROLinear *nd, IROAddrRecord *rec, Boolean mustreach1, Boolean flag2);
|
|
static void MoveInvarianceInAddressExpr(void);
|
|
static IROLinear *RearrangeInvarianceInAddressExpr(IROLinear *nd, IROList *list);
|
|
static UInt32 IsAssignmentReductionCandidate(IROLinear *nd);
|
|
|
|
void FindMustReach(void) {
|
|
IRONode *fnode;
|
|
IRONode *fnode2;
|
|
IRONode *pred;
|
|
int i;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
fnode->mustreach = 0;
|
|
if (Bv_IsBitSet(fnode->index, InLoop)) {
|
|
fnode->mustreach = 1;
|
|
|
|
for (i = 0; i < LoopNode->numpred; i++) {
|
|
pred = IRO_NodeTable[LoopNode->pred[i]];
|
|
if (Bv_IsBitSet(pred->index, InLoop) && !Bv_IsBitSet(fnode->index, pred->dom)) {
|
|
fnode->mustreach = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (fnode2 = IRO_FirstNode; fnode2; fnode2 = fnode2->nextnode) {
|
|
if (Bv_IsBitSet(fnode2->index, InLoop)) {
|
|
for (i = 0; i < fnode2->numsucc; i++) {
|
|
if (!Bv_IsBitSet(fnode2->succ[i], InLoop) && !Bv_IsBitSet(fnode->index, fnode2->dom)) {
|
|
fnode->mustreach = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!fnode->mustreach)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void FindMustReach1(IRONode *checkfnode) {
|
|
IRONode *fnode;
|
|
IRONode *fnode2;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
if (Bv_IsBitSet(fnode->index, InLoop)) {
|
|
fnode->mustreach1 = 1;
|
|
for (fnode2 = IRO_FirstNode; fnode2; fnode2 = fnode2->nextnode) {
|
|
if (Bv_IsBitSet(fnode2->index, InLoop)) {
|
|
if (Bv_IsBitSet(fnode2->index, InLoop_Tails) && !Bv_IsBitSet(fnode->index, fnode2->dom))
|
|
fnode->mustreach1 = 0;
|
|
|
|
if (Bv_IsBitSet(fnode2->index, InLoop_Exits) && fnode2 != checkfnode && !Bv_IsBitSet(fnode->index, fnode2->dom))
|
|
fnode->mustreach1 = 0;
|
|
|
|
if (!fnode->mustreach1)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void IRO_FindLoopTailsAndExits(IRONode *fnode) {
|
|
IRONode *scan;
|
|
IRONode *succ;
|
|
int i;
|
|
|
|
for (scan = IRO_FirstNode; scan; scan = scan->nextnode) {
|
|
if (Bv_IsBitSet(scan->index, InLoop)) {
|
|
for (i = 0; i < scan->numsucc; i++) {
|
|
succ = IRO_NodeTable[scan->succ[i]];
|
|
if (succ == fnode) {
|
|
Bv_SetBit(scan->index, InLoop_Tails);
|
|
LoopTail = scan;
|
|
LoopTailNum++;
|
|
}
|
|
if (!Bv_IsBitSet(succ->index, InLoop)) {
|
|
LoopExitNumber++;
|
|
LoopExitSuccessor = succ;
|
|
Bv_SetBit(scan->index, InLoop_Exits);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
IRO_Dump("IRO_FindLoopTailsAndExits:For header %d, Loop exits and loop tails are \n", fnode->index);
|
|
IRO_DumpBits("Loop Exits: ", InLoop_Exits);
|
|
IRO_DumpBits("Loop Tails: ", InLoop_Tails);
|
|
IRO_Dump("LoopExitNum=%d: \n", LoopExitNumber);
|
|
if (LoopExitSuccessor)
|
|
IRO_Dump("LoopExitSuccessor node =%d: \n", LoopExitSuccessor->index);
|
|
}
|
|
|
|
static int IsSafeTypcon(IROLinear *nd) {
|
|
Type *srcType;
|
|
Type *destType;
|
|
SInt32 srcSize;
|
|
SInt32 destSize;
|
|
Boolean srcUnsigned;
|
|
Boolean destUnsigned;
|
|
|
|
srcType = nd->u.monadic->rtype;
|
|
destType = nd->rtype;
|
|
if (!IS_TYPE_INT(srcType) || !IS_TYPE_INT(destType))
|
|
return 0;
|
|
|
|
srcSize = srcType->size;
|
|
destSize = destType->size;
|
|
srcUnsigned = IRO_IsUnsignedType(srcType);
|
|
destUnsigned = IRO_IsUnsignedType(destType);
|
|
|
|
if (srcUnsigned == destUnsigned && destSize >= srcSize)
|
|
return 1;
|
|
if (srcUnsigned == 1 && destUnsigned == 0 && destSize > srcSize)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
static int Reducable(IROLinear *nd, IROLinear **resultNd1, IROLinear **resultNd2, VarRecord **resultVar) {
|
|
IROLinear *indirect;
|
|
IROLinear *left;
|
|
IROLinear *right;
|
|
Boolean leftInvariant;
|
|
Boolean rightInvariant;
|
|
Boolean leftTypcon;
|
|
Boolean rightTypcon;
|
|
Object *obj;
|
|
ENode *enode;
|
|
IROLoopInd *ind;
|
|
CInt64 val64;
|
|
SInt32 val;
|
|
SInt32 div;
|
|
|
|
leftInvariant = 0;
|
|
rightInvariant = 0;
|
|
leftTypcon = 0;
|
|
rightTypcon = 0;
|
|
|
|
if (nd->type == IROLinearOp2Arg && nd->nodetype == EADD && (IS_TYPE_INT(nd->rtype) || IS_TYPE_POINTER_ONLY(nd->rtype))) {
|
|
left = nd->u.diadic.left;
|
|
right = nd->u.diadic.right;
|
|
if (left->type == IROLinearOp1Arg && left->nodetype == ETYPCON) {
|
|
leftTypcon = 1;
|
|
leftInvariant = (left->flags & IROLF_LoopInvariant) != 0;
|
|
left = left->u.monadic;
|
|
}
|
|
if (right->type == IROLinearOp1Arg && right->nodetype == ETYPCON) {
|
|
rightTypcon = 1;
|
|
rightInvariant = (right->flags & IROLF_LoopInvariant) != 0;
|
|
right = right->u.monadic;
|
|
}
|
|
|
|
if (((left->flags & IROLF_LoopInvariant) || leftInvariant) && IRO_IsVariable(right)) {
|
|
if (leftInvariant || ((!(obj = IRO_IsVariable(left)) || !IRO_IsRegable(obj)) && !IRO_IsConstant(left))) {
|
|
if (
|
|
left->type == IROLinearOp2Arg &&
|
|
left->nodetype == EADD &&
|
|
(obj = IRO_IsVariable(left->u.diadic.left)) &&
|
|
IRO_IsRegable(obj) &&
|
|
IRO_IsConstant(left->u.diadic.right)
|
|
)
|
|
return 0;
|
|
|
|
if (rightTypcon) {
|
|
if (!IsSafeTypcon(nd->u.diadic.right))
|
|
return 0;
|
|
*resultNd2 = nd->u.diadic.right;
|
|
} else {
|
|
*resultNd2 = right;
|
|
}
|
|
|
|
indirect = right;
|
|
*resultNd1 = IRO_NewLinear(IROLinearOperand);
|
|
|
|
enode = IRO_NewENode(EINTCONST);
|
|
enode->data.intval = cint64_one;
|
|
enode->rtype = nd->u.diadic.right->rtype;
|
|
(*resultNd1)->rtype = nd->u.diadic.right->rtype;
|
|
(*resultNd1)->u.node = enode;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else if (
|
|
((left->flags & IROLF_LoopInvariant) || leftInvariant) &&
|
|
right->type == IROLinearOp2Arg &&
|
|
!rightTypcon &&
|
|
(right->nodetype == EMUL || right->nodetype == ESHL)
|
|
) {
|
|
if (IRO_IsConstant(right->u.diadic.right)) {
|
|
if (right->nodetype == ESHL) {
|
|
right->nodetype = EMUL;
|
|
right->u.diadic.right->u.node->data.intval = CInt64_Shl(cint64_one, right->u.diadic.right->u.node->data.intval);
|
|
}
|
|
if (right->u.diadic.left->type == IROLinearOp1Arg) {
|
|
if (IRO_IsVariable(right->u.diadic.left)) {
|
|
*resultNd2 = right->u.diadic.left;
|
|
indirect = right->u.diadic.left;
|
|
*resultNd1 = right->u.diadic.right;
|
|
} else if (right->u.diadic.left->nodetype == ETYPCON && IRO_IsVariable(right->u.diadic.left->u.monadic)) {
|
|
if (!IsSafeTypcon(right->u.diadic.left))
|
|
return 0;
|
|
*resultNd2 = right->u.diadic.left;
|
|
indirect = right->u.diadic.left->u.monadic;
|
|
*resultNd1 = right->u.diadic.right;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else if (
|
|
((right->flags & IROLF_LoopInvariant) || rightInvariant) &&
|
|
left->type == IROLinearOp2Arg &&
|
|
!leftTypcon &&
|
|
(left->nodetype == EMUL || left->nodetype == ESHL)
|
|
) {
|
|
if (IRO_IsConstant(left->u.diadic.right)) {
|
|
if (left->nodetype == ESHL) {
|
|
left->nodetype = EMUL;
|
|
left->u.diadic.right->u.node->data.intval = CInt64_Shl(cint64_one, left->u.diadic.right->u.node->data.intval);
|
|
}
|
|
if (left->u.diadic.left->type == IROLinearOp1Arg) {
|
|
if (IRO_IsVariable(left->u.diadic.left)) {
|
|
*resultNd2 = left->u.diadic.left;
|
|
indirect = left->u.diadic.left;
|
|
*resultNd1 = left->u.diadic.right;
|
|
} else if (left->u.diadic.left->nodetype == ETYPCON && IRO_IsVariable(left->u.diadic.left->u.monadic)) {
|
|
if (!IsSafeTypcon(left->u.diadic.left))
|
|
return 0;
|
|
*resultNd2 = left->u.diadic.left;
|
|
indirect = left->u.diadic.left->u.monadic;
|
|
*resultNd1 = left->u.diadic.right;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else if (
|
|
((right->flags & IROLF_LoopInvariant) || rightInvariant) &&
|
|
IRO_IsVariable(left)
|
|
) {
|
|
if (rightInvariant || ((!(obj = IRO_IsVariable(right)) || !IRO_IsRegable(obj)) && !IRO_IsConstant(right))) {
|
|
if (
|
|
right->type == IROLinearOp2Arg &&
|
|
right->nodetype == EADD &&
|
|
(obj = IRO_IsVariable(right->u.diadic.left)) &&
|
|
IRO_IsRegable(obj) &&
|
|
IRO_IsConstant(right->u.diadic.right)
|
|
)
|
|
return 0;
|
|
|
|
if (leftTypcon) {
|
|
if (!IsSafeTypcon(nd->u.diadic.left))
|
|
return 0;
|
|
*resultNd2 = nd->u.diadic.left;
|
|
} else {
|
|
*resultNd2 = left;
|
|
}
|
|
|
|
indirect = left;
|
|
*resultNd1 = IRO_NewLinear(IROLinearOperand);
|
|
|
|
enode = IRO_NewENode(EINTCONST);
|
|
enode->data.intval = cint64_one;
|
|
enode->rtype = nd->u.diadic.left->rtype;
|
|
(*resultNd1)->rtype = nd->u.diadic.left->rtype;
|
|
(*resultNd1)->u.node = enode;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else if (nd->type == IROLinearOp2Arg && (nd->nodetype == EMUL || nd->nodetype == ESHL) && nd->rtype->size <= 4 && (IS_TYPE_INT(nd->rtype) || IS_TYPE_POINTER_ONLY(nd->rtype))) {
|
|
left = nd->u.diadic.left;
|
|
right = nd->u.diadic.right;
|
|
|
|
if (IRO_IsConstant(right) && IRO_IsVariable(left)) {
|
|
*resultNd2 = left;
|
|
indirect = left;
|
|
*resultNd1 = right;
|
|
} else if (IRO_IsConstant(nd->u.diadic.right) && left->type == IROLinearOp1Arg && left->nodetype == ETYPCON &&
|
|
IRO_IsVariable(left->u.monadic)) {
|
|
if (!IsSafeTypcon(left))
|
|
return 0;
|
|
*resultNd2 = left;
|
|
indirect = left->u.monadic;
|
|
*resultNd1 = right;
|
|
} else {
|
|
if (nd->type == IROLinearOp2Arg && nd->nodetype == ESHL)
|
|
return 0;
|
|
|
|
if (nd->u.diadic.right->flags & IROLF_LoopInvariant) {
|
|
if (IRO_IsVariable(left)) {
|
|
*resultNd2 = left;
|
|
indirect = left;
|
|
*resultNd1 = right;
|
|
} else if (left->type == IROLinearOp1Arg && left->nodetype == ETYPCON && IRO_IsVariable(left->u.monadic)) {
|
|
if (!IsSafeTypcon(left))
|
|
return 0;
|
|
*resultNd2 = left;
|
|
indirect = left->u.monadic;
|
|
*resultNd1 = right;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else if (nd->u.diadic.left->flags & IROLF_LoopInvariant) {
|
|
if (IRO_IsVariable(right)) {
|
|
*resultNd2 = right;
|
|
indirect = right;
|
|
*resultNd1 = left;
|
|
} else if (right->type == IROLinearOp1Arg && right->nodetype == ETYPCON && IRO_IsVariable(right->u.monadic) && nd->type == IROLinearOp2Arg && nd->nodetype == EMUL) {
|
|
if (!IsSafeTypcon(right))
|
|
return 0;
|
|
*resultNd2 = right;
|
|
indirect = right->u.monadic;
|
|
*resultNd1 = left;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
} else if (nd->type == IROLinearOp2Arg && (nd->nodetype == EDIV || nd->nodetype == ESHR) && nd->rtype->size <= 4 && IS_TYPE_INT(nd->rtype)) {
|
|
if (IRO_IsVariable(nd->u.diadic.left) && IRO_IsConstant(nd->u.diadic.right)) {
|
|
val64 = nd->u.diadic.right->u.node->data.intval;
|
|
if (nd->type == IROLinearOp2Arg && nd->nodetype == ESHR) {
|
|
CInt64_GetULong(&val64);
|
|
if (CInt64_GetULong(&val64) > 32 || CTool_EndianReadWord32(&val64.hi))
|
|
return 0;
|
|
val64 = CInt64_Shl(cint64_one, val64);
|
|
}
|
|
*resultNd2 = nd->u.diadic.left;
|
|
indirect = nd->u.diadic.left;
|
|
} else {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
if (
|
|
nd->type == IROLinearOp2Arg &&
|
|
nd->nodetype == ESHL &&
|
|
(
|
|
!IRO_IsConstant(*resultNd1) ||
|
|
(SInt32) CInt64_GetULong(&(*resultNd1)->u.node->data.intval) < 0 ||
|
|
(SInt32) CInt64_GetULong(&(*resultNd1)->u.node->data.intval) > 32 ||
|
|
CTool_EndianReadWord32(&(*resultNd1)->u.node->data.intval.hi)
|
|
)
|
|
)
|
|
return 0;
|
|
|
|
CError_ASSERT(802, indirect->u.monadic->u.node != NULL);
|
|
*resultVar = IRO_FindVar(indirect->u.monadic->u.node->data.objref, 0, 1);
|
|
if (!*resultVar || (*resultVar)->xA != 2)
|
|
return 0;
|
|
|
|
if (copts.ANSI_strict || copts.opt_strength_reduction_strict) {
|
|
Type *type = (*resultVar)->object->type;
|
|
if (IRO_IsUnsignedType(type) && type->size < stunsignedlong.size)
|
|
return 0;
|
|
}
|
|
|
|
if (nd->type == IROLinearOp2Arg && (nd->nodetype == ESHR || nd->nodetype == EDIV)) {
|
|
ind = FirstInd;
|
|
while (ind && ind->var != *resultVar)
|
|
ind = ind->next;
|
|
|
|
CError_ASSERT(845, ind != NULL);
|
|
|
|
if (ind->addNode == NULL) {
|
|
if (ind->addConst < (val = CInt64_GetULong(&val64)))
|
|
return 0;
|
|
if ((div = ind->addConst / val) <= 0)
|
|
return 0;
|
|
|
|
*resultNd1 = IRO_NewLinear(IROLinearOperand);
|
|
enode = IRO_NewENode(EINTCONST);
|
|
CInt64_SetULong(&enode->data.intval, div);
|
|
enode->rtype = nd->u.diadic.left->rtype;
|
|
(*resultNd1)->rtype = nd->u.diadic.left->rtype;
|
|
(*resultNd1)->u.node = enode;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void IRO_RemoveExpr_Action(IROLinear *linear, Boolean isFirst) {
|
|
if (isFirst && linear->expr)
|
|
IRO_RemoveExpr(linear->expr);
|
|
}
|
|
|
|
static void IRO_ActUnmarkRISCandidate(IROLinear *linear, Boolean isFirst) {
|
|
if (isFirst && linear->expr)
|
|
linear->flags &= ~IROLF_Ris;
|
|
}
|
|
|
|
static IROExpr *CreateRIS(IROExpr *expr, IROLinear *nd1, IROLinear *nd2, IROLoopInd *induction, int unk) {
|
|
Object *tempObj;
|
|
Type *type;
|
|
Boolean flag23;
|
|
Object *tempObj2;
|
|
IROLinear *firstnode;
|
|
IROLinear *fourthnode;
|
|
IROLinear *fifthnode;
|
|
IROLinear *secondnode;
|
|
IROLinear *thirdnode;
|
|
IROLinear *tmp;
|
|
ENode *enode;
|
|
IROList list1;
|
|
IROList list2;
|
|
|
|
flag23 = 0;
|
|
type = expr->linear->rtype;
|
|
tempObj = create_temp_object(type);
|
|
IRO_FindVar(tempObj, 1, 1);
|
|
IRO_InitList(&list1);
|
|
|
|
if (IS_LINEAR_DIADIC(expr->linear, EADD)) {
|
|
firstnode = IRO_DuplicateExpr(expr->linear, &list1);
|
|
} else if (IS_LINEAR_DIADIC_2(expr->linear, EDIV, ESHR)) {
|
|
firstnode = IRO_DuplicateExpr(expr->linear, &list1);
|
|
} else {
|
|
firstnode = IRO_NewLinear(IROLinearOp2Arg);
|
|
firstnode->index = ++IRO_NumLinear;
|
|
firstnode->rtype = type;
|
|
firstnode->nodetype = EMUL;
|
|
firstnode->u.diadic.left = IRO_DuplicateExpr(nd1, &list1);
|
|
if (unk)
|
|
firstnode->u.diadic.right = IRO_DuplicateExpr(nd1, &list1);
|
|
else
|
|
firstnode->u.diadic.right = IRO_DuplicateExpr(nd2, &list1);
|
|
IRO_AddToList(firstnode, &list1);
|
|
}
|
|
|
|
secondnode = IRO_NewLinear(IROLinearOp2Arg);
|
|
secondnode->index = ++IRO_NumLinear;
|
|
secondnode->rtype = type;
|
|
secondnode->nodetype = EASS;
|
|
secondnode->u.diadic.left = IRO_TempReference(tempObj, &list1);
|
|
secondnode->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
|
|
secondnode->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
|
|
secondnode->u.diadic.right = firstnode;
|
|
IRO_AddToList(secondnode, &list1);
|
|
IRO_Paste(list1.head, list1.tail, PredInt);
|
|
if (
|
|
!IS_LINEAR_DIADIC_2(expr->linear, EDIV, ESHR) &&
|
|
induction->addConst != 1 &&
|
|
(induction->addNode || !IRO_IsConstant(nd2))
|
|
) {
|
|
flag23 = 1;
|
|
IRO_InitList(&list1);
|
|
thirdnode = IRO_NewLinear(IROLinearOp2Arg);
|
|
thirdnode->index = ++IRO_NumLinear;
|
|
thirdnode->rtype = nd2->rtype;
|
|
thirdnode->nodetype = EMUL;
|
|
|
|
if (!induction->addNode) {
|
|
thirdnode->u.diadic.left = IRO_DuplicateExpr(nd2, &list1);
|
|
thirdnode->u.diadic.right = IRO_NewLinear(IROLinearOperand);
|
|
thirdnode->u.diadic.right->index = ++IRO_NumLinear;
|
|
enode = IRO_NewENode(EINTCONST);
|
|
enode->rtype = nd2->rtype;
|
|
thirdnode->u.diadic.right->rtype = nd2->rtype;
|
|
CInt64_SetLong(&enode->data.intval, induction->addConst);
|
|
thirdnode->u.diadic.right->u.node = enode;
|
|
IRO_AddToList(thirdnode->u.diadic.right, &list1);
|
|
} else {
|
|
thirdnode->u.diadic.left = IRO_DuplicateExpr(nd2, &list1);
|
|
thirdnode->u.diadic.right = IRO_DuplicateExpr(induction->addNode, &list1);
|
|
if (nd2->rtype != induction->addNode->rtype) {
|
|
tmp = IRO_NewLinear(IROLinearOp1Arg);
|
|
tmp->nodetype = ETYPCON;
|
|
tmp->index = ++IRO_NumLinear;
|
|
tmp->rtype = nd2->rtype;
|
|
tmp->u.monadic = thirdnode->u.diadic.right;
|
|
IRO_AddToList(tmp, &list1);
|
|
thirdnode->u.diadic.right = tmp;
|
|
}
|
|
}
|
|
IRO_AddToList(thirdnode, &list1);
|
|
|
|
tempObj2 = create_temp_object(nd2->rtype);
|
|
|
|
fourthnode = IRO_NewLinear(IROLinearOp2Arg);
|
|
fourthnode->index = ++IRO_NumLinear;
|
|
fourthnode->rtype = nd2->rtype;
|
|
fourthnode->nodetype = EASS;
|
|
fourthnode->u.diadic.left = IRO_TempReference(tempObj2, &list1);
|
|
fourthnode->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
|
|
fourthnode->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
|
|
fourthnode->u.diadic.right = thirdnode;
|
|
IRO_AddToList(fourthnode, &list1);
|
|
IRO_Paste(list1.head, list1.tail, PredInt);
|
|
}
|
|
|
|
IRO_InitList(&list2);
|
|
fifthnode = IRO_NewLinear(IROLinearOp2Arg);
|
|
fifthnode->index = ++IRO_NumLinear;
|
|
fifthnode->rtype = type;
|
|
if (induction->nd->type == IROLinearOp2Arg) {
|
|
if (induction->nd->nodetype == EASS && IS_LINEAR_DIADIC(induction->nd->u.diadic.right, EADD))
|
|
fifthnode->nodetype = EADDASS;
|
|
else if (induction->nd->nodetype == EASS && IS_LINEAR_DIADIC(induction->nd->u.diadic.right, ESUB))
|
|
fifthnode->nodetype = ESUBASS;
|
|
else
|
|
fifthnode->nodetype = induction->nd->nodetype;
|
|
} else {
|
|
if (induction->nd->nodetype == EPREINC || induction->nd->nodetype == EPOSTINC)
|
|
fifthnode->nodetype = EADDASS;
|
|
else
|
|
fifthnode->nodetype = ESUBASS;
|
|
}
|
|
|
|
fifthnode->u.diadic.left = IRO_TempReference(tempObj, &list2);
|
|
fifthnode->u.diadic.left->flags |= IROLF_Ind | IROLF_Used | IROLF_Assigned;
|
|
fifthnode->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Used | IROLF_Assigned;
|
|
if (!unk) {
|
|
if (!flag23) {
|
|
if (induction->addConst == 1 || IS_LINEAR_DIADIC_2(expr->linear, EDIV, ESHR)) {
|
|
fifthnode->u.diadic.right = IRO_DuplicateExpr(nd2, &list2);
|
|
} else {
|
|
fifthnode->u.diadic.right = IRO_NewLinear(IROLinearOperand);
|
|
fifthnode->u.diadic.right->index = ++IRO_NumLinear;
|
|
enode = IRO_NewENode(EINTCONST);
|
|
enode->rtype = nd2->rtype;
|
|
fifthnode->u.diadic.right->rtype = nd2->rtype;
|
|
CInt64_SetLong(&enode->data.intval, induction->addConst * CInt64_GetULong(&nd2->u.node->data.intval));
|
|
fifthnode->u.diadic.right->u.node = enode;
|
|
IRO_AddToList(fifthnode->u.diadic.right, &list2);
|
|
}
|
|
} else {
|
|
fifthnode->u.diadic.right = IRO_TempReference(tempObj2, &list2);
|
|
fifthnode->u.diadic.right->flags |= IROLF_Used;
|
|
}
|
|
}
|
|
|
|
fifthnode->index = ++IRO_NumLinear;
|
|
IRO_AddToList(fifthnode, &list2);
|
|
IRO_Paste(list2.head, list2.tail, IRO_FindStart(induction->nd));
|
|
IRO_WalkTree(expr->linear, IRO_RemoveExpr_Action);
|
|
expr->x8 = tempObj;
|
|
expr->next = RisList;
|
|
RisList = expr;
|
|
return expr;
|
|
}
|
|
|
|
static IRONode *CreatePreHeader(IRONode *fnode1, IRONode *fnode2) {
|
|
IROLinear *labelnode;
|
|
IRONode *newfnode;
|
|
IRONode *iter;
|
|
CLabel *oldlabel;
|
|
CLabel *newlabel;
|
|
SwitchInfo *swinfo;
|
|
SwitchCase *swcase;
|
|
|
|
newfnode = oalloc(sizeof(IRONode));
|
|
memset(newfnode, 0, sizeof(IRONode));
|
|
newfnode->index = IRO_NumNodes;
|
|
IRO_NumNodes++;
|
|
|
|
labelnode = IRO_NewLinear(IROLinearLabel);
|
|
labelnode->index = IRO_NumLinear++;
|
|
labelnode->next = NULL;
|
|
labelnode->u.label.label = IRO_NewLabel();
|
|
labelnode->flags |= IROLF_1;
|
|
labelnode->u.label.label->stmt = (Statement *) newfnode;
|
|
newfnode->first = labelnode;
|
|
newfnode->last = labelnode;
|
|
|
|
if (fnode2) {
|
|
fnode2->last->next = labelnode;
|
|
labelnode->next = IRO_NewLinear(IROLinearNop);
|
|
labelnode->next->next = fnode1->first;
|
|
fnode2->nextnode = newfnode;
|
|
newfnode->nextnode = fnode1;
|
|
} else {
|
|
CError_ASSERT(1254, fnode1->first->type == IROLinearLabel);
|
|
labelnode->next = IRO_NewLinear(IROLinearGoto);
|
|
labelnode->next->u.label.label = fnode1->first->u.label.label;
|
|
IRO_LastNode->last->next = labelnode;
|
|
IRO_LastNode->nextnode = newfnode;
|
|
IRO_LastNode = newfnode;
|
|
IRO_LastLinear = labelnode->next;
|
|
}
|
|
|
|
newfnode->last = labelnode->next;
|
|
|
|
IRO_NodeTable = oalloc(sizeof(IRONode *) * IRO_NumNodes);
|
|
memset(IRO_NodeTable, 0, sizeof(IRONode *) * IRO_NumNodes);
|
|
for (iter = IRO_FirstNode; iter; iter = iter->nextnode)
|
|
IRO_NodeTable[iter->index] = iter;
|
|
|
|
if (fnode1->first->type == IROLinearLabel) {
|
|
oldlabel = fnode1->first->u.label.label;
|
|
newlabel = newfnode->first->u.label.label;
|
|
for (iter = IRO_FirstNode; iter; iter = iter->nextnode) {
|
|
if (!Bv_IsBitSet(iter->index, InLoop) && iter != newfnode) {
|
|
switch (iter->last->type) {
|
|
case IROLinearGoto:
|
|
if (iter->last->u.label.label == oldlabel)
|
|
iter->last->u.label.label = newlabel;
|
|
break;
|
|
case IROLinearIf:
|
|
case IROLinearIfNot:
|
|
if (iter->last->u.label.label == oldlabel)
|
|
iter->last->u.label.label = newlabel;
|
|
break;
|
|
case IROLinearSwitch:
|
|
swinfo = iter->last->u.swtch.info;
|
|
for (swcase = swinfo->cases; swcase; swcase = swcase->next) {
|
|
if (swcase->label == oldlabel)
|
|
swcase->label = newlabel;
|
|
}
|
|
if (swinfo->defaultlabel == oldlabel)
|
|
swinfo->defaultlabel = newlabel;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
IRO_ComputeSuccPred();
|
|
IRO_ComputeDom();
|
|
return newfnode;
|
|
}
|
|
|
|
static IRONode *CreateNewLoopExitSuccessor(IRONode *fnode1) {
|
|
IROLinear *labelnode;
|
|
IRONode *fnode2;
|
|
IRONode *newfnode;
|
|
Boolean flag;
|
|
IRONode *iter;
|
|
CLabel *oldlabel;
|
|
CLabel *newlabel;
|
|
SwitchInfo *swinfo;
|
|
SwitchCase *swcase;
|
|
UInt16 i;
|
|
|
|
CError_ASSERT(1355, fnode1 != NULL && LoopExitNumber == 1);
|
|
|
|
fnode2 = NULL;
|
|
flag = 0;
|
|
|
|
for (i = 0; i < fnode1->numpred; i++) {
|
|
iter = IRO_NodeTable[fnode1->pred[i]];
|
|
if (Bv_IsBitSet(iter->index, InLoop_Exits)) {
|
|
CError_ASSERT(1366, fnode2 == NULL);
|
|
fnode2 = iter;
|
|
if (!flag) {
|
|
if (
|
|
!iter->last ||
|
|
!fnode1->first ||
|
|
fnode1->first->type != IROLinearLabel ||
|
|
(
|
|
(iter->last->type == IROLinearIf || iter->last->type == IROLinearIfNot) &&
|
|
iter->last->u.label.label != fnode1->first->u.label.label
|
|
))
|
|
flag = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
CError_ASSERT(1382, fnode2 != NULL);
|
|
|
|
newfnode = oalloc(sizeof(IRONode));
|
|
memset(newfnode, 0, sizeof(IRONode));
|
|
newfnode->index = IRO_NumNodes;
|
|
IRO_NumNodes++;
|
|
|
|
labelnode = IRO_NewLinear(IROLinearLabel);
|
|
labelnode->index = IRO_NumLinear++;
|
|
labelnode->next = NULL;
|
|
labelnode->u.label.label = IRO_NewLabel();
|
|
labelnode->flags |= IROLF_1;
|
|
labelnode->u.label.label->stmt = (Statement *) newfnode;
|
|
newfnode->first = labelnode;
|
|
newfnode->last = labelnode;
|
|
|
|
if (flag) {
|
|
fnode2->last->next = labelnode;
|
|
labelnode->next = IRO_NewLinear(IROLinearNop);
|
|
labelnode->next->next = fnode1->first;
|
|
fnode2->nextnode = newfnode;
|
|
newfnode->nextnode = fnode1;
|
|
} else {
|
|
CError_ASSERT(1422, fnode1->first->type == IROLinearLabel);
|
|
labelnode->next = IRO_NewLinear(IROLinearGoto);
|
|
labelnode->next->u.label.label = fnode1->first->u.label.label;
|
|
IRO_LastNode->last->next = labelnode;
|
|
IRO_LastNode->nextnode = newfnode;
|
|
IRO_LastNode = newfnode;
|
|
IRO_LastLinear = labelnode->next;
|
|
}
|
|
|
|
newfnode->last = labelnode->next;
|
|
|
|
IRO_NodeTable = oalloc(sizeof(IRONode *) * IRO_NumNodes);
|
|
memset(IRO_NodeTable, 0, sizeof(IRONode *) * IRO_NumNodes);
|
|
for (iter = IRO_FirstNode; iter; iter = iter->nextnode)
|
|
IRO_NodeTable[iter->index] = iter;
|
|
|
|
if (fnode1->first->type == IROLinearLabel) {
|
|
oldlabel = fnode1->first->u.label.label;
|
|
newlabel = newfnode->first->u.label.label;
|
|
switch (fnode2->last->type) {
|
|
case IROLinearGoto:
|
|
if (fnode2->last->u.label.label == oldlabel)
|
|
fnode2->last->u.label.label = newlabel;
|
|
break;
|
|
case IROLinearIf:
|
|
case IROLinearIfNot:
|
|
if (fnode2->last->u.label.label == oldlabel)
|
|
fnode2->last->u.label.label = newlabel;
|
|
break;
|
|
case IROLinearSwitch:
|
|
swinfo = fnode2->last->u.swtch.info;
|
|
for (swcase = swinfo->cases; swcase; swcase = swcase->next) {
|
|
if (swcase->label == oldlabel)
|
|
swcase->label = newlabel;
|
|
}
|
|
if (swinfo->defaultlabel == oldlabel)
|
|
swinfo->defaultlabel = newlabel;
|
|
break;
|
|
}
|
|
}
|
|
|
|
IRO_ComputeSuccPred();
|
|
IRO_ComputeDom();
|
|
return newfnode;
|
|
}
|
|
|
|
void AddPreds(IRONode *fnode) {
|
|
IRONode *pred;
|
|
int i;
|
|
|
|
for (i = 0; i < fnode->numpred; i++) {
|
|
pred = IRO_NodeTable[fnode->pred[i]];
|
|
if (!Bv_IsBitSet(pred->index, InLoop)) {
|
|
Bv_SetBit(pred->index, InLoop);
|
|
AddPreds(pred);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void RemoveNoopsFromExprList(void) {
|
|
IROExpr *expr;
|
|
IROExpr *prev;
|
|
|
|
expr = IRO_FirstExpr;
|
|
prev = NULL;
|
|
while (expr) {
|
|
if (expr->linear->type == IROLinearNop) {
|
|
if (prev)
|
|
prev->next = expr->next;
|
|
else
|
|
IRO_FirstExpr = expr->next;
|
|
expr = expr->next;
|
|
} else {
|
|
prev = expr;
|
|
expr = expr->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
void IncLoopDepth(void) {
|
|
IRONode *fnode;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
if (Bv_IsBitSet(fnode->index, InLoop))
|
|
fnode->loopdepth++;
|
|
}
|
|
}
|
|
|
|
void IRO_SetLoopDepth(void) {
|
|
IRONode *fnode;
|
|
IRONode *pred;
|
|
UInt16 i;
|
|
UInt16 flag;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode)
|
|
fnode->loopdepth = 0;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
flag = 0;
|
|
|
|
for (i = 0; i < fnode->numpred; i++) {
|
|
pred = IRO_NodeTable[fnode->pred[i]];
|
|
if (Bv_IsBitSet(fnode->index, pred->dom)) {
|
|
if (!flag) {
|
|
Bv_AllocVector(&InLoop, IRO_NumNodes + 1);
|
|
Bv_Clear(InLoop);
|
|
Bv_SetBit(fnode->index, InLoop);
|
|
}
|
|
flag = 1;
|
|
Bv_SetBit(pred->index, InLoop);
|
|
if (pred != fnode)
|
|
AddPreds(pred);
|
|
}
|
|
}
|
|
|
|
if (flag)
|
|
IncLoopDepth();
|
|
}
|
|
|
|
IRO_CheckForUserBreak();
|
|
}
|
|
|
|
static void InsertBranchAroundLoopPreheaders(void) {
|
|
IRONode *fnode;
|
|
CLabel *label;
|
|
IRONode *iter;
|
|
IROLinear *endnode;
|
|
IROLinear *labelnode;
|
|
|
|
if (IRO_EndNode && IRO_EndNode->last && IRO_EndNode->last->type == IROLinearEnd) {
|
|
label = IRO_NewLabel();
|
|
fnode = IRO_NewFlowGraphNode();
|
|
IRO_LastNode->nextnode = fnode;
|
|
label->stmt = (Statement *) fnode;
|
|
|
|
IRO_NodeTable = oalloc(sizeof(IRONode *) * IRO_NumNodes);
|
|
memset(IRO_NodeTable, 0, sizeof(IRONode *) * IRO_NumNodes);
|
|
for (iter = IRO_FirstNode; iter; iter = iter->nextnode)
|
|
IRO_NodeTable[iter->index] = iter;
|
|
|
|
labelnode = IRO_NewLinear(IROLinearLabel);
|
|
labelnode->index = ++IRO_NumLinear;
|
|
labelnode->u.label.label = label;
|
|
labelnode->flags |= IROLF_1;
|
|
fnode->first = labelnode;
|
|
IRO_LastLinear->next = labelnode;
|
|
|
|
endnode = IRO_NewLinear(IROLinearEnd);
|
|
memcpy(endnode, IRO_EndNode->last, sizeof(IROLinear));
|
|
endnode->index = ++IRO_NumLinear;
|
|
endnode->next = NULL;
|
|
fnode->last = endnode;
|
|
labelnode->next = endnode;
|
|
IRO_LastLinear = endnode;
|
|
|
|
IRO_EndNode->last->type = IROLinearGoto;
|
|
IRO_EndNode->last->u.label.label = label;
|
|
IRO_LastNode = fnode;
|
|
IRO_EndNode = fnode;
|
|
|
|
IRO_ComputeSuccPred();
|
|
IRO_ComputeDom();
|
|
}
|
|
}
|
|
|
|
void IRO_FindLoops(void) {
|
|
IRONode *fnode;
|
|
IRONode *pred;
|
|
UInt16 i;
|
|
UInt16 flag;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
flag = 0;
|
|
|
|
for (i = 0; i < fnode->numpred; i++) {
|
|
pred = IRO_NodeTable[fnode->pred[i]];
|
|
if (Bv_IsBitSet(fnode->index, pred->dom)) {
|
|
if (!flag) {
|
|
Bv_AllocVector(&InLoop, IRO_NumNodes + 1);
|
|
Bv_Clear(InLoop);
|
|
Bv_SetBit(fnode->index, InLoop);
|
|
}
|
|
flag = 1;
|
|
Bv_SetBit(pred->index, InLoop);
|
|
if (pred != fnode)
|
|
AddPreds(pred);
|
|
}
|
|
}
|
|
|
|
if (flag) {
|
|
IncLoopDepth();
|
|
IRO_Dump("IRO_FindLoops:Found loop with header %d\n", fnode->index);
|
|
IRO_DumpBits("Loop includes: ", InLoop);
|
|
MyHandleLoop_Motion(fnode);
|
|
IRO_UpdateFlagsOnInts();
|
|
MyHandleLoop_Vector(fnode);
|
|
RemoveNoopsFromExprList();
|
|
IRO_UpdateFlagsOnInts();
|
|
IRO_UpdateVars();
|
|
}
|
|
}
|
|
|
|
if (!IRO_FunctionHasReturn && IRO_EndNode != IRO_LastNode)
|
|
InsertBranchAroundLoopPreheaders();
|
|
}
|
|
|
|
static void CheckSubableSub(IROLinear *linear, Boolean isFirst) {
|
|
if (isFirst && IRO_IsSubableExpression(linear)) {
|
|
IRO_Dump("Subable Expression is %d\n", linear->index);
|
|
NoSubableSubs = 0;
|
|
}
|
|
}
|
|
|
|
static int NoSubableSubExprs(IROLinear *nd) {
|
|
NoSubableSubs = 1;
|
|
IRO_WalkTree(nd, CheckSubableSub);
|
|
return NoSubableSubs;
|
|
}
|
|
|
|
void ComputeLoopKills(void) {
|
|
IRONode *fnode;
|
|
IROLinear *nd;
|
|
|
|
Bv_AllocVector(&AllKills, IRO_NumVars + 1);
|
|
Bv_AllocVector(&IRO_VarKills, IRO_NumVars + 1);
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
|
|
Bv_AllocVector(&fnode->x16, IRO_NumVars + 1);
|
|
Bv_AllocVector(&fnode->x1E, IRO_NumVars + 1);
|
|
while (1) {
|
|
Bv_Clear(IRO_VarKills);
|
|
IRO_GetKills(nd);
|
|
Bv_Or(IRO_VarKills, AllKills);
|
|
if (nd == fnode->last)
|
|
break;
|
|
nd = nd->next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ComputeLoopInvariance(void) {
|
|
IRONode *fnode;
|
|
IROLinear *nd;
|
|
|
|
IRO_Depends = IRO_VarKills;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
|
|
nd->flags &= ~IROLF_LoopInvariant;
|
|
while (1) {
|
|
if ((nd->flags & IROLF_Reffed) && nd->type != IROLinearNop) {
|
|
IRO_FindDepends_NoAlloc(nd);
|
|
if (!IRO_IsVolatile && !Bv_BitsInCommon(IRO_Depends, AllKills))
|
|
nd->flags |= IROLF_LoopInvariant;
|
|
|
|
if (IRO_CouldError)
|
|
nd->flags |= IROLF_CouldError;
|
|
else
|
|
nd->flags &= ~IROLF_CouldError;
|
|
}
|
|
|
|
if (nd == fnode->last)
|
|
break;
|
|
nd = nd->next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ComputeLoopInduction(void) {
|
|
IRONode *fnode;
|
|
IROLinear *nd;
|
|
Boolean flag;
|
|
Object *obj;
|
|
Object *obj2;
|
|
Object *obj3;
|
|
VarRecord *var;
|
|
IROLinear *tmpnd;
|
|
IROLoopInd *ind;
|
|
Boolean isUnsigned;
|
|
|
|
Bv_AllocVector(&AllKills, IRO_NumVars + 1);
|
|
Bv_AllocVector(&IRO_VarKills, IRO_NumVars + 1);
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
|
|
while (1) {
|
|
Bv_Clear(IRO_VarKills);
|
|
IRO_GetKills(nd);
|
|
Bv_Or(IRO_VarKills, AllKills);
|
|
flag = 0;
|
|
if (
|
|
(
|
|
nd->type == IROLinearOp2Arg &&
|
|
nd->rtype->size <= 4 &&
|
|
(nd->nodetype == EADDASS || nd->nodetype == ESUBASS) &&
|
|
(obj = IRO_IsVariable(nd->u.diadic.left)) &&
|
|
obj->type->size == nd->rtype->size &&
|
|
IS_TYPE_INT(obj->type) &&
|
|
(
|
|
(IRO_IsIntConstant(nd->u.diadic.right) && CInt64_GetULong(&nd->u.diadic.right->u.node->data.intval))
|
|
||
|
|
(nd->u.diadic.right->flags & IROLF_LoopInvariant)
|
|
)
|
|
)
|
|
||
|
|
(
|
|
nd->type == IROLinearOp1Arg &&
|
|
nd->rtype->size <= 4 &&
|
|
(nd->nodetype == EPOSTINC || nd->nodetype == EPOSTDEC || nd->nodetype == EPREINC || nd->nodetype == EPREDEC) &&
|
|
(obj = IRO_IsVariable(nd->u.monadic)) &&
|
|
obj->type->size == nd->rtype->size &&
|
|
IS_TYPE_INT(obj->type)
|
|
)
|
|
)
|
|
{
|
|
flag = 1;
|
|
}
|
|
else if (
|
|
nd->type == IROLinearOp2Arg &&
|
|
nd->rtype->size <= 4 &&
|
|
nd->nodetype == EASS &&
|
|
(obj = IRO_IsVariable(nd->u.diadic.left)) &&
|
|
obj->type->size == nd->rtype->size &&
|
|
IS_TYPE_INT(obj->type) &&
|
|
nd->u.diadic.right->type == IROLinearOp2Arg &&
|
|
(nd->u.diadic.right->nodetype == EADD || nd->u.diadic.right->nodetype == ESUB)
|
|
)
|
|
{
|
|
if (nd->u.diadic.right->nodetype == EADD) {
|
|
obj2 = IRO_IsVariable(nd->u.diadic.right->u.diadic.left);
|
|
obj3 = IRO_IsVariable(nd->u.diadic.right->u.diadic.right);
|
|
if (obj2 == obj && obj3 != obj && (nd->u.diadic.right->u.diadic.right->flags & IROLF_LoopInvariant))
|
|
flag = 1;
|
|
|
|
if (obj3 == obj && obj2 != obj && (nd->u.diadic.right->u.diadic.left->flags & IROLF_LoopInvariant)) {
|
|
flag = 1;
|
|
tmpnd = nd->u.diadic.right->u.diadic.left;
|
|
nd->u.diadic.right->u.diadic.left = nd->u.diadic.right->u.diadic.right;
|
|
nd->u.diadic.right->u.diadic.right = tmpnd;
|
|
}
|
|
} else {
|
|
obj2 = IRO_IsVariable(nd->u.diadic.right->u.diadic.left);
|
|
obj3 = IRO_IsVariable(nd->u.diadic.right->u.diadic.right);
|
|
if (obj2 == obj && obj3 != obj && (nd->u.diadic.right->u.diadic.right->flags & IROLF_LoopInvariant))
|
|
flag = 1;
|
|
}
|
|
}
|
|
|
|
if (flag) {
|
|
if ((var = IRO_FindAssigned(nd))) {
|
|
if (var->xA == 2)
|
|
var->xA = 0;
|
|
else if (var->xA == 1)
|
|
var->xA = 2;
|
|
}
|
|
} else {
|
|
for (var = IRO_FirstVar; var; var = var->next) {
|
|
if (Bv_IsBitSet(var->index, IRO_VarKills))
|
|
var->xA = 0;
|
|
}
|
|
}
|
|
|
|
if (nd == fnode->last)
|
|
break;
|
|
nd = nd->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
IRO_DumpBits("Killed in loop: ", AllKills);
|
|
|
|
for (fnode = IRO_FirstNode, FirstInd = NULL; fnode; fnode = fnode->nextnode) {
|
|
if (Bv_IsBitSet(fnode->index, InLoop) && (nd = fnode->first)) {
|
|
while (1) {
|
|
if (
|
|
(
|
|
nd->type == IROLinearOp2Arg &&
|
|
(nd->nodetype == EADDASS || nd->nodetype == ESUBASS || nd->nodetype == EASS)
|
|
)
|
|
||
|
|
(
|
|
nd->type == IROLinearOp1Arg &&
|
|
(nd->nodetype == EPOSTINC || nd->nodetype == EPOSTDEC || nd->nodetype == EPREINC || nd->nodetype == EPREDEC)
|
|
)
|
|
) {
|
|
if ((var = IRO_FindAssigned(nd)) && var->xA == 2 && var->object->type->size <= 4) {
|
|
ind = oalloc(sizeof(IROLoopInd));
|
|
ind->fnode = fnode;
|
|
ind->var = var;
|
|
ind->nd = nd;
|
|
ind->next = FirstInd;
|
|
ind->addNode = NULL;
|
|
ind->addConst = 0;
|
|
ind->flags = 0;
|
|
|
|
if (nd->type == IROLinearOp2Arg) {
|
|
isUnsigned = IRO_IsUnsignedType(nd->rtype);
|
|
if (IRO_IsIntConstant(nd->u.diadic.right)) {
|
|
CInt64 val = nd->u.diadic.right->u.node->data.intval;
|
|
if (IS_LINEAR_DIADIC(nd, EADDASS) && CInt64_Less(val, cint64_zero)) {
|
|
nd->nodetype = ESUBASS;
|
|
nd->u.diadic.right->u.node->data.intval = CInt64_Neg(val);
|
|
}
|
|
if (isUnsigned) {
|
|
CInt64_ConvertUInt32(&nd->u.diadic.right->u.node->data.intval);
|
|
ind->addConst = CInt64_GetULong(&nd->u.diadic.right->u.node->data.intval);
|
|
} else {
|
|
CInt64_ConvertInt32(&nd->u.diadic.right->u.node->data.intval);
|
|
ind->addConst = CInt64_GetULong(&nd->u.diadic.right->u.node->data.intval);
|
|
}
|
|
ind->addNode = NULL;
|
|
} else if (nd->nodetype == EADDASS || nd->nodetype == ESUBASS) {
|
|
ind->addNode = nd->u.diadic.right;
|
|
} else if (nd->nodetype == EASS) {
|
|
ind->addNode = nd->u.diadic.right->u.diadic.right;
|
|
}
|
|
} else {
|
|
if (IS_TYPE_POINTER_ONLY(nd->rtype))
|
|
ind->addConst = TPTR_TARGET(nd->rtype)->size;
|
|
else
|
|
ind->addConst = 1;
|
|
ind->addNode = NULL;
|
|
}
|
|
|
|
FirstInd = ind;
|
|
|
|
if (IS_LINEAR_DIADIC_2(nd, EADDASS, ESUBASS)) {
|
|
if (nd->u.diadic.right->flags & IROLF_LoopInvariant)
|
|
IRO_Dump("Found induction variable the new way: %s\n", var->object->name->name);
|
|
else
|
|
IRO_Dump("Found induction variable the old way: %s\n", var->object->name->name);
|
|
} else if (nd->type == IROLinearOp2Arg && (nd->u.diadic.right->nodetype == EADD || nd->u.diadic.right->nodetype == ESUB)) {
|
|
IRO_Dump("Found induction variable the new way: %s\n", var->object->name->name);
|
|
} else {
|
|
IRO_Dump("Found induction variable the old way: %s\n", var->object->name->name);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nd == fnode->last)
|
|
break;
|
|
nd = nd->next;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static void IRO_ActUnmarkLoopInvariance(IROLinear *linear, Boolean isFirst) {
|
|
if (isFirst)
|
|
linear->flags &= ~IROLF_LoopInvariant;
|
|
}
|
|
|
|
static void UnmarkSubexpressionsOfInvariantExpressions(void) {
|
|
IROExpr *expr;
|
|
|
|
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
|
|
if (
|
|
Bv_IsBitSet(expr->node->index, InLoop) &&
|
|
!expr->notSubable &&
|
|
(!expr->couldError || expr->node->mustreach) &&
|
|
(expr->linear->flags & IROLF_LoopInvariant)
|
|
) {
|
|
IRO_WalkTree(expr->linear, IRO_ActUnmarkLoopInvariance);
|
|
expr->linear->flags |= IROLF_LoopInvariant;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MyHandleLoop_Vector(IRONode *fnode) {
|
|
IRONode *pred;
|
|
UInt16 i;
|
|
IROExpr *expr;
|
|
IROExpr *removedExprs;
|
|
IROExpr *exprnext;
|
|
IROLoopInd *induction;
|
|
IROExpr *exprinner;
|
|
Boolean flag24;
|
|
IRONode *v2;
|
|
IRONode *node22;
|
|
int flag21;
|
|
IRONode *iter;
|
|
IROExpr *searchris;
|
|
IROLinear *reduceNd1;
|
|
VarRecord *var;
|
|
IROLinear *reduceNd2;
|
|
|
|
IRO_FirstExpr = NULL;
|
|
LoopNode = fnode;
|
|
FindMustReach();
|
|
|
|
for (var = IRO_FirstVar; var; var = var->next)
|
|
var->xA = 1;
|
|
|
|
ComputeLoopKills();
|
|
ComputeLoopInvariance();
|
|
ComputeLoopInduction();
|
|
LoopNode = fnode;
|
|
ConditionalHeaderAtBottom = 0;
|
|
|
|
v2 = NULL;
|
|
flag21 = 0;
|
|
node22 = NULL;
|
|
for (i = 0; i < LoopNode->numpred; i++) {
|
|
pred = IRO_NodeTable[LoopNode->pred[i]];
|
|
if (!Bv_IsBitSet(pred->index, InLoop)) {
|
|
if (flag21)
|
|
node22 = NULL;
|
|
else
|
|
node22 = pred;
|
|
flag21 = 1;
|
|
if (pred->nextnode == fnode) {
|
|
CError_ASSERT(2880, v2 == NULL || pred == v2);
|
|
v2 = pred;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!flag21) {
|
|
IRO_Dump("No predecessor outside the loop\n");
|
|
return;
|
|
}
|
|
|
|
if (!node22 || node22->last->type != IROLinearGoto)
|
|
node22 = CreatePreHeader(fnode, v2);
|
|
PredInt = node22->last;
|
|
|
|
if (PredInt->type == IROLinearGoto && PredInt->u.label.label != LoopNode->first->u.label.label) {
|
|
if (!KnownBounds || !Times) {
|
|
for (iter = IRO_FirstNode; iter; iter = iter->nextnode)
|
|
iter->mustreach = 0;
|
|
} else {
|
|
PredInt->u.label.label = LoopNode->first->u.label.label;
|
|
IRO_ComputeSuccPred();
|
|
}
|
|
}
|
|
|
|
if (copts.opt_loop_invariants || copts.opt_strength_reduction) {
|
|
MoveInvarianceInAddressExpr();
|
|
IRO_DumpAfterPhase("MoveInvarianceInAddressExpr", 0);
|
|
IRO_FindExpressions(InLoop, 1);
|
|
IRO_DumpExprs();
|
|
}
|
|
|
|
if (copts.opt_loop_invariants)
|
|
UnmarkSubexpressionsOfInvariantExpressions();
|
|
|
|
if (!copts.optimize_for_size && copts.opt_strength_reduction) {
|
|
for (expr = IRO_FirstExpr; expr; expr = expr->next) {
|
|
if (
|
|
!(expr->x0 & 4) &&
|
|
Bv_IsBitSet(expr->node->index, InLoop) &&
|
|
!expr->notSubable &&
|
|
(!expr->couldError || expr->node->mustreach) &&
|
|
Reducable(expr->linear, &reduceNd1, &reduceNd2, &var)
|
|
) {
|
|
IRO_WalkTree(expr->linear, IRO_ActUnmarkRISCandidate);
|
|
expr->linear->flags |= IROLF_Ris;
|
|
expr->x1A = reduceNd1;
|
|
expr->x1E = var;
|
|
expr->x22 = reduceNd2;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!copts.optimize_for_size && copts.opt_strength_reduction) {
|
|
RisList = NULL;
|
|
for (expr = IRO_FirstExpr; expr; expr = exprnext) {
|
|
exprnext = expr->next;
|
|
if (!(expr->x0 & 4) && (expr->linear->flags & IROLF_Ris)) {
|
|
reduceNd1 = expr->x1A;
|
|
var = expr->x1E;
|
|
reduceNd2 = expr->x22;
|
|
|
|
induction = FirstInd;
|
|
while (induction && induction->var != var)
|
|
induction = induction->next;
|
|
CError_ASSERT(3529, induction != NULL);
|
|
|
|
IRO_FindDepends(reduceNd1);
|
|
if (!Bv_BitsInCommon(IRO_Depends, AllKills)) {
|
|
IRO_Dump("Found reduction in strength: %d\n", expr->linear->index);
|
|
if (IS_LINEAR_DIADIC(expr->linear, ESHL)) {
|
|
expr->linear->nodetype = EMUL;
|
|
CInt64_SetULong(&reduceNd1->u.node->data.intval, 1 << CInt64_GetULong(&reduceNd1->u.node->data.intval));
|
|
reduceNd1->u.node->rtype = expr->linear->rtype;
|
|
}
|
|
|
|
searchris = RisList;
|
|
while (1) {
|
|
if (!searchris)
|
|
break;
|
|
if (IRO_ExprsSame(expr->linear, searchris->linear))
|
|
break;
|
|
searchris = searchris->next;
|
|
}
|
|
|
|
if (searchris) {
|
|
IRO_Dump("Using existing RIS: %d\n", searchris->linear->index);
|
|
IRO_WalkTree(expr->linear, IRO_RemoveExpr_Action);
|
|
} else {
|
|
searchris = CreateRIS(expr, reduceNd2, reduceNd1, induction, 0);
|
|
}
|
|
IRO_ReplaceReference(expr->linear, searchris->x8, expr->linear);
|
|
IRO_ClipExpr(expr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
RisList = NULL;
|
|
|
|
expr = IRO_FirstExpr;
|
|
removedExprs = NULL;
|
|
if (copts.opt_loop_invariants) {
|
|
while (expr) {
|
|
exprnext = expr->next;
|
|
flag24 = 0;
|
|
|
|
if (
|
|
Bv_IsBitSet(expr->node->index, InLoop) &&
|
|
!expr->notSubable &&
|
|
(!expr->couldError || expr->node->mustreach) &&
|
|
(expr->linear->flags & IROLF_LoopInvariant) &&
|
|
!(expr->x0 & 4)
|
|
) {
|
|
IRO_Dump("Found loop invariant: %d\n", expr->linear->index);
|
|
|
|
for (exprinner = removedExprs; exprinner; exprinner = exprinner->next) {
|
|
if (IRO_ExprsSame(exprinner->linear, expr->linear)) {
|
|
IRO_ReplaceReference(expr->linear, exprinner->x8, expr->linear);
|
|
IRO_NopOut(expr->linear);
|
|
IRO_Dump("Using already removed expr: %d\n", exprinner->linear->index);
|
|
IRO_RemoveExpr(expr);
|
|
flag24 = 1;
|
|
}
|
|
}
|
|
|
|
if (!flag24 && !expr->x8) {
|
|
IRO_GetTemp(expr);
|
|
IRO_ReplaceReference(expr->linear, expr->x8, expr->linear);
|
|
IRO_MoveExpression(expr, PredInt);
|
|
IRO_AssignToTemp(expr);
|
|
IRO_RemoveExpr(expr);
|
|
expr->next = removedExprs;
|
|
removedExprs = expr;
|
|
}
|
|
}
|
|
|
|
expr = exprnext;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void MyHandleLoop_Motion(IRONode *fnode) {
|
|
IROLoopMemRef *memref;
|
|
IRONode *pred;
|
|
UInt16 i;
|
|
IRONode *v2;
|
|
IRONode *node21;
|
|
Object *tempobj;
|
|
int flag20;
|
|
IRONode *iter;
|
|
IROLinear *ass;
|
|
VarRecord *var;
|
|
Boolean checkflag;
|
|
IROLoop *loop;
|
|
IROList list;
|
|
IROElmList *refiter;
|
|
|
|
IRO_FirstExpr = NULL;
|
|
LoopNode = fnode;
|
|
FindMustReach();
|
|
|
|
for (var = IRO_FirstVar; var; var = var->next)
|
|
var->xA = 1;
|
|
|
|
ComputeLoopKills();
|
|
ComputeLoopInvariance();
|
|
ComputeLoopInduction();
|
|
LoopNode = fnode;
|
|
ConditionalHeaderAtBottom = 0;
|
|
|
|
v2 = NULL;
|
|
flag20 = 0;
|
|
node21 = NULL;
|
|
for (i = 0; i < LoopNode->numpred; i++) {
|
|
pred = IRO_NodeTable[LoopNode->pred[i]];
|
|
if (!Bv_IsBitSet(pred->index, InLoop)) {
|
|
if (flag20)
|
|
node21 = NULL;
|
|
else
|
|
node21 = pred;
|
|
flag20 = 1;
|
|
if (pred->nextnode == fnode) {
|
|
CError_ASSERT(3880, v2 == NULL || pred == v2);
|
|
v2 = pred;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!flag20) {
|
|
IRO_Dump("No predecessor outside the loop\n");
|
|
return;
|
|
}
|
|
|
|
if (!node21 || node21->last->type != IROLinearGoto)
|
|
node21 = CreatePreHeader(fnode, v2);
|
|
PredInt = node21->last;
|
|
|
|
if (PredInt->type == IROLinearGoto && PredInt->u.label.label != LoopNode->first->u.label.label) {
|
|
if (!KnownBounds || !Times) {
|
|
for (iter = IRO_FirstNode; iter; iter = iter->nextnode)
|
|
iter->mustreach = 0;
|
|
} else {
|
|
PredInt->u.label.label = LoopNode->first->u.label.label;
|
|
IRO_ComputeSuccPred();
|
|
}
|
|
}
|
|
|
|
if (copts.opt_loop_invariants || copts.opt_strength_reduction) {
|
|
MoveInvarianceInAddressExpr();
|
|
IRO_DumpAfterPhase("MoveInvarianceInAddressExpr", 0);
|
|
IRO_FindExpressions(InLoop, 0);
|
|
IRO_DumpExprs();
|
|
}
|
|
|
|
if (copts.opt_loop_invariants)
|
|
UnmarkSubexpressionsOfInvariantExpressions();
|
|
|
|
checkflag = 1;
|
|
Bv_AllocVector(&InLoop_Exits, IRO_NumNodes + 1);
|
|
Bv_AllocVector(&InLoop_Tails, IRO_NumNodes + 1);
|
|
LoopExitNumber = 0;
|
|
LoopExitSuccessor = NULL;
|
|
LoopTailNum = 0;
|
|
LoopTail = NULL;
|
|
IRO_FindLoopTailsAndExits(fnode);
|
|
FindMustReach1(fnode);
|
|
|
|
loop = NULL;
|
|
if (LoopTailNum == 1) {
|
|
if (fnode->last->type == IROLinearIf || fnode->last->type == IROLinearIfNot)
|
|
loop = ExtractLoopInfo(fnode);
|
|
else if (LoopTail->last->type == IROLinearIf || LoopTail->last->type == IROLinearIfNot)
|
|
loop = ExtractLoopInfo(LoopTail);
|
|
}
|
|
|
|
if (loop && !(loop->flags & LP_IFEXPR_NON_CANONICAL) && LoopExitNumber == 1) {
|
|
IRO_LoopMemRefFirst = NULL;
|
|
IRO_LoopMemRefCurrent = NULL;
|
|
CheckAllLoopAddresses(IRO_FirstNode, InLoop, &checkflag);
|
|
CheckAllLoopAddresses(IRO_FirstNode, InLoop, &checkflag);
|
|
if (checkflag) {
|
|
for (memref = IRO_LoopMemRefFirst; memref; memref = memref->next) {
|
|
if (memref->flags & LoopMemRef_10)
|
|
memref->flags |= LoopMemRef_8;
|
|
}
|
|
|
|
for (memref = IRO_LoopMemRefFirst; memref; memref = memref->next) {
|
|
IRO_Dump("Loop Motion Candidate:: Int= %d", memref->nd->index);
|
|
if (memref->flags & LoopMemRef_8)
|
|
IRO_Dump("<invalid>");
|
|
if (memref->flags & LoopMemRef_1)
|
|
IRO_Dump("<load>");
|
|
if (memref->flags & LoopMemRef_2)
|
|
IRO_Dump("<store>");
|
|
IRO_Dump("\n");
|
|
|
|
if (!(memref->flags & LoopMemRef_8)) {
|
|
tempobj = create_temp_object(memref->nd->rtype);
|
|
IRO_FindVar(tempobj, 1, 1);
|
|
if (IRO_FindVar(((IROLinear *) memref->rec->objRefs->element)->u.node->data.objref, 0, 1)) {
|
|
IRO_InitList(&list);
|
|
ass = IRO_NewLinear(IROLinearOp2Arg);
|
|
ass->index = ++IRO_NumLinear;
|
|
ass->rtype = memref->nd->rtype;
|
|
ass->nodetype = EASS;
|
|
ass->u.diadic.left = IRO_TempReference(tempobj, &list);
|
|
ass->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
|
|
ass->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
|
|
ass->u.diadic.right = IRO_DuplicateExpr(memref->nd, &list);
|
|
IRO_AddToList(ass, &list);
|
|
IRO_Paste(list.head, list.tail, PredInt);
|
|
} else {
|
|
CError_FATAL(4123);
|
|
}
|
|
|
|
if (LoopExitSuccessor->numpred != 1)
|
|
LoopExitSuccessor = CreateNewLoopExitSuccessor(LoopExitSuccessor);
|
|
|
|
IRO_InitList(&list);
|
|
ass = IRO_NewLinear(IROLinearOp2Arg);
|
|
ass->index = ++IRO_NumLinear;
|
|
ass->rtype = memref->nd->rtype;
|
|
ass->nodetype = EASS;
|
|
ass->u.diadic.left = IRO_DuplicateExpr(memref->nd, &list);
|
|
ass->u.diadic.left->flags |= IROLF_Ind | IROLF_Assigned;
|
|
ass->u.diadic.left->u.monadic->flags |= IROLF_Ind | IROLF_Assigned;
|
|
ass->u.diadic.right = IRO_TempReference(tempobj, &list);
|
|
IRO_AddToList(ass, &list);
|
|
|
|
if (LoopExitSuccessor->first->type == IROLinearLabel)
|
|
IRO_PasteAfter(list.head, list.tail, LoopExitSuccessor->first);
|
|
else
|
|
IRO_Paste(list.head, list.tail, LoopExitSuccessor->first);
|
|
|
|
for (refiter = memref->list; refiter; refiter = refiter->next) {
|
|
IRO_Dump("Loop Motion Candidate Reference at Int= %d\n", ((IROLinear *) refiter->element)->index);
|
|
IRO_InitList(&list);
|
|
IRO_TempReference(tempobj, &list);
|
|
IRO_Paste(list.head, list.tail, refiter->element);
|
|
IRO_LocateFather_Cut_And_Paste(refiter->element, list.tail);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
IRO_DumpAfterPhase("After Motion", 0);
|
|
}
|
|
|
|
static Boolean CheckLoopAddress(IROLinear *nd, Boolean mustreach1) {
|
|
IROLoopMemRef *memref;
|
|
IROAddrRecord *rec;
|
|
IROAddrRecord *otherrec;
|
|
IROLinear *inner;
|
|
IROElmList *list;
|
|
Boolean flag;
|
|
|
|
inner = nd->u.monadic;
|
|
rec = IRO_InitAddrRecordPointer(inner);
|
|
if (IS_LINEAR_ENODE(inner, EOBJREF)) {
|
|
rec->numObjRefs++;
|
|
IRO_AddElmToList(inner, &rec->objRefs);
|
|
} else if (IS_LINEAR_DIADIC(inner, EADD)) {
|
|
IRO_DecomposeAddressExpression(inner, rec);
|
|
} else {
|
|
return 0;
|
|
}
|
|
|
|
if (rec->numObjRefs != 1)
|
|
return 0;
|
|
|
|
flag = (nd->flags & IROLF_CouldError) || !(nd->flags & IROLF_Reffed);
|
|
if (!IRO_LoopMemRefFirst) {
|
|
MakeLoopEntry(nd, rec, mustreach1, flag);
|
|
} else {
|
|
for (memref = IRO_LoopMemRefFirst; memref; memref = memref->next) {
|
|
otherrec = memref->rec;
|
|
if (((IROLinear *) rec->objRefs->element)->u.node->data.objref == ((IROLinear *) otherrec->objRefs->element)->u.node->data.objref) {
|
|
if (IRO_ExprsSame(inner, otherrec->linear)) {
|
|
list = oalloc(sizeof(IROElmList));
|
|
list->element = nd;
|
|
list->next = NULL;
|
|
if (!memref->list) {
|
|
memref->list = list;
|
|
} else {
|
|
list->next = memref->list;
|
|
memref->list = list;
|
|
}
|
|
} else {
|
|
memref->flags |= LoopMemRef_8;
|
|
}
|
|
|
|
if (!mustreach1 && flag)
|
|
memref->flags |= LoopMemRef_8;
|
|
if (mustreach1 || flag)
|
|
memref->flags &= ~LoopMemRef_10;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!memref)
|
|
MakeLoopEntry(nd, rec, mustreach1, flag);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void CheckAllLoopAddresses(IRONode *fnode, BitVector *bv, Boolean *resultFlag) {
|
|
IROLinear *nd;
|
|
Boolean flag;
|
|
|
|
flag = *resultFlag;
|
|
while (fnode) {
|
|
if (Bv_IsBitSet(fnode->index, bv) && (nd = fnode->first)) {
|
|
while (flag) {
|
|
if (nd->type == IROLinearOp1Arg && nd->nodetype == EINDIRECT)
|
|
flag = CheckLoopAddress(nd, fnode->mustreach1);
|
|
else if (nd->type == IROLinearFunccall)
|
|
flag = 0;
|
|
|
|
if (nd == fnode->last)
|
|
break;
|
|
nd = nd->next;
|
|
}
|
|
|
|
if (!flag)
|
|
break;
|
|
}
|
|
fnode = fnode->nextnode;
|
|
}
|
|
*resultFlag = flag;
|
|
}
|
|
|
|
static void MakeLoopEntry(IROLinear *nd, IROAddrRecord *rec, Boolean mustreach1, Boolean flag2) {
|
|
IROElmList *list;
|
|
|
|
if (!IRO_IsRegable(((IROLinear *) rec->objRefs->element)->u.node->data.objref) &&
|
|
(nd->u.monadic->flags & IROLF_LoopInvariant) &&
|
|
!IRO_HasSideEffect(nd)) {
|
|
if (!IRO_LoopMemRefFirst) {
|
|
IRO_LoopMemRefCurrent = IRO_LoopMemRefFirst = oalloc(sizeof(IROLoopMemRef));
|
|
} else {
|
|
IRO_LoopMemRefCurrent->next = oalloc(sizeof(IROLoopMemRef));
|
|
IRO_LoopMemRefCurrent = IRO_LoopMemRefCurrent->next;
|
|
}
|
|
IRO_LoopMemRefCurrent->flags = LoopMemRef_10;
|
|
IRO_LoopMemRefCurrent->nd = nd;
|
|
IRO_LoopMemRefCurrent->rec = rec;
|
|
IRO_LoopMemRefCurrent->next = NULL;
|
|
IRO_LoopMemRefCurrent->list = NULL;
|
|
|
|
list = oalloc(sizeof(IROElmList));
|
|
list->element = nd;
|
|
list->next = NULL;
|
|
if (!IRO_LoopMemRefCurrent->list) {
|
|
IRO_LoopMemRefCurrent->list = list;
|
|
} else {
|
|
list->next = IRO_LoopMemRefCurrent->list;
|
|
IRO_LoopMemRefCurrent->list = list;
|
|
}
|
|
|
|
if (((IROLinear *) rec->objRefs->element)->flags & IROLF_Assigned) {
|
|
IRO_LoopMemRefCurrent->flags |= LoopMemRef_2;
|
|
if (((IROLinear *) rec->objRefs->element)->flags & IROLF_Used)
|
|
IRO_LoopMemRefCurrent->flags |= LoopMemRef_1;
|
|
} else {
|
|
IRO_LoopMemRefCurrent->flags |= LoopMemRef_1;
|
|
}
|
|
|
|
if (!mustreach1 && flag2)
|
|
IRO_LoopMemRefCurrent->flags |= LoopMemRef_8;
|
|
|
|
if (mustreach1 || flag2)
|
|
IRO_LoopMemRefCurrent->flags &= ~LoopMemRef_10;
|
|
}
|
|
}
|
|
|
|
void FindAssignmenttoInductionVar(IROLoop *loop, IRONode *fnode) {
|
|
IROLinear *nd;
|
|
UInt32 index;
|
|
|
|
if (!loop->induction) {
|
|
loop->nd14 = NULL;
|
|
} else {
|
|
index = loop->induction->var->index;
|
|
for (nd = fnode->first; nd; nd = nd->next) {
|
|
Bv_Clear(IRO_VarKills);
|
|
IRO_GetKills(nd);
|
|
if (Bv_IsBitSet(index, IRO_VarKills))
|
|
loop->nd14 = nd;
|
|
|
|
if (nd == fnode->last)
|
|
break;
|
|
}
|
|
|
|
if (loop->nd14 && loop->nd14->type != IROLinearOp2Arg)
|
|
loop->nd14 = NULL;
|
|
}
|
|
}
|
|
|
|
static void ComputeIntWeight(IROLoop *loop, IROLinear *Int) {
|
|
loop->sizeBySomeMeasurement++;
|
|
}
|
|
|
|
static IROLinear *IsTypconVar(IROLinear *nd) {
|
|
if (IS_LINEAR_MONADIC(nd, ETYPCON) && IRO_IsVariable(nd->u.monadic))
|
|
return nd->u.monadic;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
IROLoop *ExtractLoopInfo(IRONode *fnode) {
|
|
Boolean flag30;
|
|
Boolean flag29;
|
|
Boolean flag28;
|
|
UInt32 counter27;
|
|
IROLoopInd *ind23;
|
|
Object *obj;
|
|
IROLinear *nd21;
|
|
IRONode *scanfnode;
|
|
IROLinear *left19;
|
|
IROLinear *right18;
|
|
IROLinear *tmp18;
|
|
IROLinear *scannd;
|
|
IROLinear *tmp;
|
|
VarRecord *var;
|
|
IROLoopInd *scanind;
|
|
IROLinear *left;
|
|
IROLinear *right;
|
|
UInt32 counter2;
|
|
UInt32 i;
|
|
IROLoop *loop;
|
|
|
|
flag30 = 0;
|
|
flag29 = 0;
|
|
flag28 = 0;
|
|
counter27 = 0;
|
|
LoopNode = fnode;
|
|
|
|
loop = oalloc(sizeof(IROLoop));
|
|
loop->fnode = fnode;
|
|
nd21 = LoopNode->last->u.label.x4;
|
|
loop->nd18 = nd21;
|
|
loop->flags = 0;
|
|
loop->x8 = 0;
|
|
loop->nd14 = NULL;
|
|
loop->induction = NULL;
|
|
loop->index20 = -1;
|
|
loop->index24 = -1;
|
|
loop->sizeBySomeMeasurement = 0;
|
|
|
|
if (nd21->type == IROLinearOp2Arg && IS_TYPE_INT(nd21->rtype)) {
|
|
ind23 = NULL;
|
|
left19 = nd21->u.diadic.left;
|
|
right18 = nd21->u.diadic.right;
|
|
if (IRO_IsVariable(left19) || (left19 = IsTypconVar(left19))) {
|
|
if ((var = IRO_FindVar(left19->u.monadic->u.node->data.objref, 0, 1))) {
|
|
scanind = FirstInd;
|
|
while (scanind && scanind->var != var)
|
|
scanind = scanind->next;
|
|
if (scanind) {
|
|
ind23 = scanind;
|
|
loop->flags |= LoopFlags_1;
|
|
loop->induction = scanind;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IRO_IsVariable(right18) || (right18 = IsTypconVar(right18))) {
|
|
if ((var = IRO_FindVar(right18->u.monadic->u.node->data.objref, 0, 1))) {
|
|
scanind = FirstInd;
|
|
while (scanind && scanind->var != var)
|
|
scanind = scanind->next;
|
|
if (scanind) {
|
|
ind23 = scanind;
|
|
loop->flags &= ~LoopFlags_1;
|
|
loop->induction = scanind;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ind23 && ind23->addConst > 0) {
|
|
if (loop->flags & LoopFlags_1) {
|
|
if (
|
|
loop->nd18->type != IROLinearOp2Arg ||
|
|
!(loop->nd18->nodetype == ELESS || loop->nd18->nodetype == EGREATER || loop->nd18->nodetype == ELESSEQU || loop->nd18->nodetype == EGREATEREQU) ||
|
|
!loop->nd18->u.diadic.left ||
|
|
!loop->nd18->u.diadic.left->rtype ||
|
|
!IS_TYPE_INT(loop->nd18->u.diadic.left->rtype) ||
|
|
!loop->nd18->u.diadic.right ||
|
|
!loop->nd18->u.diadic.right->rtype ||
|
|
!IS_TYPE_INT(loop->nd18->u.diadic.right->rtype)
|
|
) {
|
|
loop->flags |= LP_IFEXPR_NON_CANONICAL;
|
|
return loop;
|
|
}
|
|
} else {
|
|
if (
|
|
loop->nd18->type == IROLinearOp2Arg &&
|
|
(loop->nd18->nodetype == EGREATER || loop->nd18->nodetype == EGREATEREQU) &&
|
|
(left = loop->nd18->u.diadic.left) &&
|
|
left->rtype &&
|
|
IS_TYPE_INT(left->rtype) &&
|
|
(right = loop->nd18->u.diadic.right) &&
|
|
right->rtype &&
|
|
IS_TYPE_INT(right->rtype)
|
|
) {
|
|
loop->nd18->u.diadic.left = right;
|
|
loop->nd18->u.diadic.right = left;
|
|
if (loop->nd18->nodetype == EGREATER)
|
|
loop->nd18->nodetype = ELESS;
|
|
else if (loop->nd18->nodetype == EGREATEREQU)
|
|
loop->nd18->nodetype = ELESSEQU;
|
|
loop->flags |= LoopFlags_1;
|
|
} else if (
|
|
loop->nd18->type == IROLinearOp2Arg &&
|
|
(loop->nd18->nodetype == ELESS || loop->nd18->nodetype == ELESSEQU) &&
|
|
(left = loop->nd18->u.diadic.left) &&
|
|
left->rtype &&
|
|
IS_TYPE_INT(left->rtype) &&
|
|
(right = loop->nd18->u.diadic.right) &&
|
|
right->rtype &&
|
|
IS_TYPE_INT(right->rtype)
|
|
) {
|
|
loop->nd18->u.diadic.left = right;
|
|
loop->nd18->u.diadic.right = left;
|
|
if (loop->nd18->nodetype == ELESS)
|
|
loop->nd18->nodetype = EGREATER;
|
|
else if (loop->nd18->nodetype == ELESSEQU)
|
|
loop->nd18->nodetype = EGREATEREQU;
|
|
loop->flags |= LoopFlags_1;
|
|
} else {
|
|
loop->flags |= LP_IFEXPR_NON_CANONICAL;
|
|
return loop;
|
|
}
|
|
}
|
|
} else {
|
|
loop->flags |= LP_INDUCTION_NOT_FOUND;
|
|
return loop;
|
|
}
|
|
} else if (nd21->type == IROLinearOp1Arg && IS_TYPE_INT(nd21->rtype)) {
|
|
if (nd21->nodetype == EPREINC || nd21->nodetype == EPOSTINC || nd21->nodetype == EPREDEC || nd21->nodetype == EPOSTDEC) {
|
|
if (IRO_IsVariable(nd21->u.monadic)) {
|
|
if ((var = IRO_FindVar(nd21->u.monadic->u.monadic->u.node->data.objref, 0, 1))) {
|
|
scanind = FirstInd;
|
|
while (scanind && scanind->var != var)
|
|
scanind = scanind->next;
|
|
if (scanind) {
|
|
ind23 = scanind;
|
|
loop->flags |= LoopFlags_10000;
|
|
loop->induction = scanind;
|
|
} else {
|
|
loop->flags |= LP_INDUCTION_NOT_FOUND;
|
|
return loop;
|
|
}
|
|
} else {
|
|
loop->flags |= LP_INDUCTION_NOT_FOUND;
|
|
return loop;
|
|
}
|
|
} else {
|
|
loop->flags |= LP_INDUCTION_NOT_FOUND;
|
|
return loop;
|
|
}
|
|
} else {
|
|
loop->flags |= LP_INDUCTION_NOT_FOUND;
|
|
return loop;
|
|
}
|
|
} else {
|
|
loop->flags |= LP_IFEXPR_NON_CANONICAL;
|
|
return loop;
|
|
}
|
|
|
|
counter2 = 0;
|
|
scanind = FirstInd;
|
|
while (scanind) {
|
|
scanind = scanind->next;
|
|
counter2++;
|
|
}
|
|
|
|
if (counter2 > 1)
|
|
loop->flags |= LP_HAS_MULTIPLE_INDUCTIONS;
|
|
|
|
if ((scanind = loop->induction)) {
|
|
nd21 = scanind->nd;
|
|
if (nd21->type == IROLinearOp2Arg) {
|
|
if (IS_LINEAR_DIADIC_2(loop->nd18, ELESS, ELESSEQU)) {
|
|
if (nd21->nodetype == EADDASS) {
|
|
if (scanind->addConst == 1)
|
|
loop->flags |= LP_LOOP_STEP_ISADD;
|
|
if (scanind->addConst > 0)
|
|
loop->flags |= LP_LOOP_STEP_ISPOS;
|
|
} else if (nd21->nodetype == EASS &&
|
|
IS_LINEAR_DIADIC(nd21->u.diadic.right, EADD) &&
|
|
IRO_IsIntConstant(tmp18 = nd21->u.diadic.right->u.diadic.right) &&
|
|
CTool_EndianReadWord32(&tmp18->u.node->data.intval.hi) == 0) {
|
|
if (CInt64_GetULong(&tmp18->u.node->data.intval) == 1)
|
|
loop->flags |= LP_LOOP_STEP_ISADD;
|
|
if (CInt64_GetULong(&tmp18->u.node->data.intval) > 0)
|
|
loop->flags |= LP_LOOP_STEP_ISPOS;
|
|
}
|
|
}
|
|
} else if (nd21->type == IROLinearOp1Arg) {
|
|
if (nd21->nodetype == EPREINC || nd21->nodetype == EPOSTINC) {
|
|
if (scanind->addConst == 1)
|
|
loop->flags |= LP_LOOP_STEP_ISADD;
|
|
if (scanind->addConst > 0)
|
|
loop->flags |= LP_LOOP_STEP_ISPOS;
|
|
}
|
|
if (nd21->nodetype == EPREDEC || nd21->nodetype == EPOSTDEC) {
|
|
if (scanind->addConst == 1)
|
|
loop->flags |= LoopFlags_2000;
|
|
if (scanind->addConst > 0)
|
|
loop->flags |= LP_LOOP_STEP_ISNEG;
|
|
}
|
|
}
|
|
loop->index24 = nd21->index;
|
|
loop->index20 = IRO_FindStart(nd21)->index;
|
|
}
|
|
|
|
if (ind23) {
|
|
tmp = IRO_FindStart(fnode->last->u.diadic.right);
|
|
loop->flags |= LoopFlags_200;
|
|
if (loop->flags & LoopFlags_10000) {
|
|
for (scannd = loop->fnode->first; scannd && scannd != tmp; scannd = scannd->next) {
|
|
if (scannd->type != IROLinearLabel && scannd->type != IROLinearNop)
|
|
loop->flags &= ~LoopFlags_200;
|
|
}
|
|
} else {
|
|
for (scannd = ind23->nd->next; scannd && scannd != tmp; scannd = scannd->next){
|
|
if (scannd->type != IROLinearLabel && scannd->type != IROLinearNop)
|
|
loop->flags &= ~LoopFlags_200;
|
|
}
|
|
for (scannd = loop->fnode->first; scannd && scannd != tmp; scannd = scannd->next){
|
|
if ((scannd->index < loop->index20 || scannd->index > loop->index24) && scannd->type != IROLinearLabel && scannd->type != IROLinearNop)
|
|
loop->flags &= ~LoopFlags_200;
|
|
}
|
|
}
|
|
}
|
|
|
|
for (scanfnode = IRO_FirstNode; scanfnode; scanfnode = scanfnode->nextnode) {
|
|
if (Bv_IsBitSet(scanfnode->index, InLoop) && scanfnode != fnode && (scannd = scanfnode->first)) {
|
|
while (1) {
|
|
if (scannd->type == IROLinearFunccall)
|
|
flag30 = 1;
|
|
if (scannd->type == IROLinearGoto)
|
|
flag28++;
|
|
if (flag28 >= 1)
|
|
flag29 = 1;
|
|
if (scannd->type == IROLinearIf || scannd->type == IROLinearIfNot || scannd->type == IROLinearSwitch || scannd->type == IROLinearReturn)
|
|
flag29 = 1;
|
|
|
|
if (scannd->type == IROLinearAsm)
|
|
loop->flags |= LP_LOOP_HAS_ASM;
|
|
|
|
if (!(scannd->flags & IROLF_Reffed) && scannd->type != IROLinearNop && scannd->type != IROLinearLabel) {
|
|
if (!IRO_IsAssignOp[scannd->nodetype]) {
|
|
loop->flags |= LoopFlags_8;
|
|
} else if (scannd->index < loop->index20 || scannd->index > loop->index24) {
|
|
counter27++;
|
|
if (IsAssignmentReductionCandidate(scannd) && counter27 == 1)
|
|
loop->flags |= LoopFlags_40000;
|
|
if (counter27 > 1)
|
|
loop->flags &= ~LoopFlags_40000;
|
|
}
|
|
}
|
|
|
|
if (scannd->index < loop->index20 || scannd->index > loop->index24) {
|
|
if (IS_LINEAR_ENODE(scannd, EOBJREF)) {
|
|
obj = scannd->u.node->data.objref;
|
|
if ((scannd->flags & IROLF_Ind) && obj && obj == loop->induction->var->object) {
|
|
if (!(scannd->flags & IROLF_Assigned) && (scannd->flags & IROLF_Used)) {
|
|
IRO_Dump("Induction Used in loop\n");
|
|
loop->flags |= LoopFlags_800;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IS_LINEAR_DIADIC(scannd, ESHR) &&
|
|
(obj = IRO_IsVariable(scannd->u.diadic.left)) &&
|
|
IRO_IsConstant(scannd->u.diadic.right)) {
|
|
for (scanind = FirstInd; scanind; scanind = scanind->next) {
|
|
if (scanind->var->object == obj) {
|
|
IRO_Dump("Induction has DIV: %s\n", obj->name->name);
|
|
scanind->flags |= LoopInd_HasDiv;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IS_LINEAR_DIADIC(scannd, EAND) &&
|
|
(obj = IRO_IsVariable(scannd->u.diadic.left)) &&
|
|
IRO_IsConstant(scannd->u.diadic.right)) {
|
|
for (scanind = FirstInd; scanind && obj; scanind = scanind->next) {
|
|
if (scanind->var->object == obj) {
|
|
IRO_Dump("Induction has MOD: %s\n", obj->name->name);
|
|
scanind->flags |= LoopInd_HasMod;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
ComputeIntWeight(loop, scannd);
|
|
if (scannd == scanfnode->last)
|
|
break;
|
|
scannd = scannd->next;
|
|
}
|
|
}
|
|
|
|
if (flag30)
|
|
loop->flags |= LP_LOOP_HAS_CALLS;
|
|
if (flag29)
|
|
loop->flags |= LP_LOOP_HAS_CNTRLFLOW;
|
|
|
|
for (i = 0; i < scanfnode->numsucc && scanfnode != fnode; i++) {
|
|
if (Bv_IsBitSet(scanfnode->index, InLoop) && !Bv_IsBitSet(scanfnode->succ[i], InLoop)) {
|
|
IRO_Dump("Node %d has an out of loop successor %d\n", scanfnode->index, scanfnode->succ[i]);
|
|
IRO_DumpBits("Loop includes: ", InLoop);
|
|
IRO_Dump("loop has multiple exits\n");
|
|
loop->flags |= LoopFlags_1000;
|
|
}
|
|
}
|
|
}
|
|
|
|
return loop;
|
|
}
|
|
|
|
CLabel *BuildLabel(IROList *list) {
|
|
IROLinear *nd;
|
|
|
|
nd = IRO_NewLinear(IROLinearLabel);
|
|
nd->index = IRO_NumLinear++;
|
|
nd->u.label.label = IRO_NewLabel();
|
|
nd->flags |= IROLF_1;
|
|
IRO_AddToList(nd, list);
|
|
return nd->u.label.label;
|
|
}
|
|
|
|
static void MoveInvarianceInAddressExpr(void) {
|
|
IRONode *fnode;
|
|
IROLinear *nd;
|
|
IROLinear *start;
|
|
IROList list;
|
|
|
|
IRO_FirstExpr = IRO_LastExpr = NULL;
|
|
IRO_NumExprs = 0;
|
|
|
|
for (fnode = IRO_FirstNode; fnode; fnode = fnode->nextnode) {
|
|
if (Bv_IsBitSet(fnode->index, InLoop)) {
|
|
for (nd = fnode->first; nd; nd = nd->next) {
|
|
if (nd->type == IROLinearOp1Arg &&
|
|
(nd->nodetype == EINDIRECT || nd->nodetype == EINDIRECT) &&
|
|
IS_LINEAR_DIADIC(nd->u.monadic, EADD)) {
|
|
RearrangeInvarianceInAddressExpr(nd->u.monadic, &list);
|
|
start = IRO_FindStart(nd->u.monadic);
|
|
IRO_LocateFather_Cut_And_Paste(nd->u.monadic, list.tail);
|
|
IRO_Paste(list.head, list.tail, start);
|
|
}
|
|
|
|
if (nd == fnode->last)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
IRO_UpdateFlagsOnInts();
|
|
}
|
|
|
|
static void AddAddendLinear(IROLinear *nd) {
|
|
IROElmList *list;
|
|
|
|
if (IS_LINEAR_DIADIC(nd, EADD)) {
|
|
AddAddendLinear(nd->u.diadic.left);
|
|
AddAddendLinear(nd->u.diadic.right);
|
|
} else {
|
|
list = oalloc(sizeof(IROElmList));
|
|
list->element = nd;
|
|
list->next = NULL;
|
|
if (FirstAddendLinear)
|
|
LastAddendLinear->next = list;
|
|
else
|
|
FirstAddendLinear = list;
|
|
LastAddendLinear = list;
|
|
}
|
|
}
|
|
|
|
static IROLinear *RearrangeInvarianceInAddressExpr(IROLinear *nd, IROList *list) {
|
|
IROLinear *result;
|
|
IROElmList *scanlist;
|
|
IROElmList *elist;
|
|
IROLinear *scannd;
|
|
|
|
IRO_InitList(list);
|
|
FirstAddendLinear = LastAddendLinear = NULL;
|
|
AddAddendLinear(nd->u.diadic.left);
|
|
AddAddendLinear(nd->u.diadic.right);
|
|
|
|
elist = NULL;
|
|
result = NULL;
|
|
for (scanlist = FirstAddendLinear; scanlist; scanlist = scanlist->next) {
|
|
scannd = scanlist->element;
|
|
if (!IRO_IsIntConstant(scannd) && (scannd->flags & IROLF_LoopInvariant)) {
|
|
if (result) {
|
|
IROLinear *tmp = IRO_NewLinear(IROLinearOp2Arg);
|
|
tmp->index = ++IRO_NumLinear;
|
|
tmp->nodetype = EADD;
|
|
tmp->u.diadic.left = result;
|
|
tmp->u.diadic.right = IRO_DuplicateExpr(scannd, list);
|
|
IRO_AddToList(tmp, list);
|
|
tmp->flags |= IROLF_LoopInvariant;
|
|
tmp->flags |= IROLF_Reffed;
|
|
tmp->rtype = result->rtype;
|
|
result = tmp;
|
|
} else {
|
|
result = IRO_DuplicateExpr(scannd, list);
|
|
}
|
|
|
|
if (elist)
|
|
elist->next = scanlist->next;
|
|
else
|
|
FirstAddendLinear = scanlist->next;
|
|
} else {
|
|
elist = scanlist;
|
|
}
|
|
}
|
|
|
|
for (scanlist = FirstAddendLinear, elist = NULL; scanlist; scanlist = scanlist->next) {
|
|
scannd = scanlist->element;
|
|
if (!IRO_IsIntConstant(scannd)) {
|
|
if (result) {
|
|
IROLinear *tmp = IRO_NewLinear(IROLinearOp2Arg);
|
|
tmp->index = ++IRO_NumLinear;
|
|
tmp->nodetype = EADD;
|
|
tmp->u.diadic.left = result;
|
|
tmp->u.diadic.right = IRO_DuplicateExpr(scannd, list);
|
|
IRO_AddToList(tmp, list);
|
|
tmp->flags |= IROLF_Reffed;
|
|
tmp->rtype = result->rtype;
|
|
result = tmp;
|
|
} else {
|
|
result = IRO_DuplicateExpr(scannd, list);
|
|
}
|
|
|
|
if (elist)
|
|
elist->next = scanlist->next;
|
|
else
|
|
FirstAddendLinear = scanlist->next;
|
|
} else {
|
|
elist = scanlist;
|
|
}
|
|
}
|
|
|
|
for (scanlist = FirstAddendLinear; scanlist; scanlist = scanlist->next) {
|
|
scannd = scanlist->element;
|
|
if (result) {
|
|
IROLinear *tmp = IRO_NewLinear(IROLinearOp2Arg);
|
|
tmp->index = ++IRO_NumLinear;
|
|
tmp->nodetype = EADD;
|
|
tmp->u.diadic.left = result;
|
|
tmp->u.diadic.right = scannd;
|
|
tmp->u.diadic.right = IRO_DuplicateExpr(scannd, list);
|
|
IRO_AddToList(tmp, list);
|
|
tmp->flags |= IROLF_Reffed;
|
|
tmp->rtype = result->rtype;
|
|
result = tmp;
|
|
} else {
|
|
result = IRO_DuplicateExpr(scannd, list);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
static IROLinear *FindAddendForReductionPattern(IROLinear *a, IROLinear *b, Boolean *resultFlag) {
|
|
IROLinear *left;
|
|
IROLinear *right;
|
|
IROLinear *node28;
|
|
Boolean subflag;
|
|
|
|
left = b->u.diadic.left;
|
|
right = b->u.diadic.right;
|
|
if (b->nodetype == EADD || b->nodetype == ESUB) {
|
|
node28 = left;
|
|
while (IS_LINEAR_MONADIC(node28, ETYPCON))
|
|
node28 = node28->u.monadic;
|
|
|
|
if (IS_LINEAR_MONADIC(node28, EINDIRECT) && (node28->u.monadic->flags & IROLF_LoopInvariant) && IRO_ExprsSame(a, node28)) {
|
|
*resultFlag = 1;
|
|
return left;
|
|
}
|
|
|
|
if (IS_LINEAR_DIADIC_2(node28, EADD, ESUB)) {
|
|
if ((node28 = FindAddendForReductionPattern(a, node28, &subflag))) {
|
|
*resultFlag = 1;
|
|
return node28;
|
|
}
|
|
}
|
|
}
|
|
|
|
*resultFlag = 0;
|
|
if (b->nodetype == EADD) {
|
|
node28 = right;
|
|
while (IS_LINEAR_MONADIC(node28, ETYPCON))
|
|
node28 = node28->u.monadic;
|
|
|
|
if (IS_LINEAR_MONADIC(node28, EINDIRECT) && (node28->u.monadic->flags & IROLF_LoopInvariant) && IRO_ExprsSame(a, node28)) {
|
|
return right;
|
|
}
|
|
|
|
if (IS_LINEAR_DIADIC_2(node28, EADD, ESUB)) {
|
|
if ((node28 = FindAddendForReductionPattern(a, node28, &subflag))) {
|
|
return node28;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void ReorderOperandsForReductionPattern(IROLinear *a, IROLinear *b) {
|
|
IROLinear *left;
|
|
IROLinear *right;
|
|
IROLinear *addend;
|
|
IROLinear *tmp;
|
|
Boolean flag;
|
|
|
|
left = b->u.diadic.left;
|
|
right = b->u.diadic.right;
|
|
|
|
if (b->nodetype == EADD && (addend = FindAddendForReductionPattern(a, b, &flag)) && addend != left) {
|
|
if (flag && IS_LINEAR_DIADIC_2(left, EADD, ESUB) && addend->rtype == right->rtype) {
|
|
tmp = left;
|
|
b->u.diadic.left = right;
|
|
left = right;
|
|
b->u.diadic.right = tmp;
|
|
right = tmp;
|
|
flag = 0;
|
|
}
|
|
|
|
if (!flag && IS_LINEAR_DIADIC_2(right, EADD, ESUB) && addend->rtype == left->rtype) {
|
|
if (IRO_LocateFather_Cut_And_Paste_Without_Nopping(addend, left))
|
|
b->u.diadic.left = addend;
|
|
}
|
|
}
|
|
}
|
|
|
|
static UInt32 IsAssignmentReductionCandidate(IROLinear *nd) {
|
|
IROLinear *left;
|
|
IROLinear *right;
|
|
IROLinear *tmp;
|
|
|
|
if (nd->type == IROLinearOp2Arg) {
|
|
if (nd->nodetype == EASS) {
|
|
left = nd->u.diadic.left;
|
|
right = nd->u.diadic.right;
|
|
if (IS_LINEAR_MONADIC(left, EINDIRECT) && (left->u.monadic->flags & IROLF_LoopInvariant)) {
|
|
if (IS_LINEAR_MONADIC(right, ETYPCON) &&
|
|
right->rtype->type == right->u.monadic->rtype->type &&
|
|
IS_TYPE_INT(right->rtype) &&
|
|
right->rtype->size < right->u.monadic->rtype->size)
|
|
right = right->u.monadic;
|
|
|
|
if (IS_LINEAR_DIADIC_2(right, EADD, ESUB)) {
|
|
ReorderOperandsForReductionPattern(left, right);
|
|
tmp = right->u.diadic.left;
|
|
if (IS_LINEAR_MONADIC(tmp, ETYPCON))
|
|
tmp = tmp->u.monadic;
|
|
if (IS_LINEAR_MONADIC(tmp, EINDIRECT) &&
|
|
(tmp->u.monadic->flags & IROLF_LoopInvariant) &&
|
|
IRO_ExprsSame(left, tmp) &&
|
|
right->u.diadic.right->type == IROLinearOp2Arg) {
|
|
if (right->u.diadic.right->nodetype == EADD)
|
|
return 1;
|
|
if (right->u.diadic.right->nodetype == ESUB)
|
|
return 1;
|
|
if (right->u.diadic.right->nodetype == EMUL)
|
|
return 1;
|
|
if (right->u.diadic.right->nodetype == EDIV)
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
} else if (nd->nodetype == EADDASS || nd->nodetype == ESUBASS) {
|
|
left = nd->u.diadic.left;
|
|
right = nd->u.diadic.right;
|
|
|
|
if (IS_LINEAR_MONADIC(right, ETYPCON) &&
|
|
right->rtype->type == right->u.monadic->rtype->type &&
|
|
IS_TYPE_INT(right->rtype) &&
|
|
right->rtype->size < right->u.monadic->rtype->size)
|
|
right = right->u.monadic;
|
|
|
|
if (IS_LINEAR_MONADIC(left, EINDIRECT) &&
|
|
(left->u.monadic->flags & IROLF_LoopInvariant) &&
|
|
right->type == IROLinearOp2Arg) {
|
|
if (right->nodetype == EADD)
|
|
return 1;
|
|
if (right->nodetype == ESUB)
|
|
return 1;
|
|
if (right->nodetype == EMUL)
|
|
return 1;
|
|
if (right->nodetype == EDIV)
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|