const char* NodeGen::splitCondBranch( MergeNode* targetNode,
bool isBackwards,
PReg* targetPR,
SExpr* testExpr,
BranchBCTargetStack* targetStack,
SExprStack* exprStack,
PRegBList* exprStackPRs,
SplitSig* s ) {
// try to split a conditional branch bc to avoid materializing
// the boolean
// local splitting only for now
assert(targetPR->isConstPReg(),
"cond branch must be testing for constant");
oop targetOop = ((ConstPReg*)targetPR)->constant;
if (!testExpr->isMergeSExpr())
return "testExpr not MergeSExpr";
if (!((MergeSExpr*)testExpr)->isSplittable())
return "textExpr not splittable";
SExprBList* exprs = ((MergeSExpr*)testExpr)->exprs;
assert(testExpr->node(), "splittable implies node()");
Node* preceedingMerge = testExpr->node();
if (current != preceedingMerge)
return "not local"; // local only for now
if ( preceedingMerge->nPredecessors() != exprs->length() )
return "would have to iterate over predecessors";
fint i;
for ( i = 0;
i < exprs->length();
++i) {
SExpr* e = exprs->nth(i);
Node* n = e->node();
if ( !preceedingMerge->isPredecessor(n) )
return "merge not immediately after expr node";
if ( !e->isConstantSExpr() )
return "merge contains non-constant expression";
}
MergeNode* mergeForBranching = new MergeNode("for branching");
MergeNode* mergeForFallingThrough = new MergeNode("for falling through");
mergeForBranching ->setScope(currentScope());
mergeForFallingThrough->setScope(currentScope());
for ( i = 0;
i < exprs->length();
++i) {
SExpr* e = exprs->nth(i);
Node* n = e->node();
MergeNode* mn = e->constant() == targetOop
? mergeForBranching
: mergeForFallingThrough;
mn->setPrev(n);
n->moveNext(preceedingMerge, mn);
}
while (preceedingMerge->nPredecessors())
preceedingMerge->removePrev(preceedingMerge->prev(0));
current = mergeForBranching;
branchCode( targetNode,
isBackwards,
NULL,
NULL,
targetStack,
exprStack,
exprStackPRs,
s);
append(mergeForFallingThrough);
return NULL;
}
SExpr* SCodeScope::inlineMerge(SendInfo* info, MergeNode*& merge) {
// inline the send by type-casing; return uninlined cases in others list
// If merge has no predecessors, return NULL for merge ref.
SExpr* res = NULL;
assert(info->rcvr->isMergeSExpr(), "must be a merge");
MergeSExpr* r = (MergeSExpr*)info->rcvr;
stringOop sel = info->sel;
merge = NULL;
if (r->isSplittable() && shouldSplit(info)) {
return splitMerge(info, merge);
}
fint ncases = r->exprs->length();
if (ncases > SICTypeCaseLimit) {
info->needRealSend = true;
if (PrintInlining) {
lprintf("%*s*not type-casing %s (%ld > SICTypeCaseLimit)\n",
(void*)depth, "", selector_string(sel), (void*)ncases);
}
return res;
}
assert( merge == NULL, "I assume merge is out param only");
merge = new MergeNode("inlineMerge merge");
if (SICDebug) {
char* s = NEW_RESOURCE_ARRAY(char, 200);
sprintf(s, "begin type-case of %s (ends at node N%ld)",
sel->copy_null_terminated(), long(merge->id()));
theNodeGen->comment(s);
}
if (PrintInlining) {
lprintf("%*s*type-casing %s\n", (void*)depth, "", selector_string(sel));
}
// build list of cases to inline
// (add only immediate maps at first, collect others in ...2 lists
SSelfScopeBList* slist = new SSelfScopeBList(ncases);
SSelfScopeBList* slist2 = new SSelfScopeBList(ncases);
SExprBList* elist = new SExprBList(ncases);
SExprBList* elist2 = new SExprBList(ncases);
SExprBList* others = new SExprBList(ncases);
OopBList* mlist = new OopBList(ncases);
OopBList* mlist2 = new OopBList(ncases);
bool needMapLoad = false;
fint i;
for (i = 0; i < ncases; i++) {
SExpr* nth = r->exprs->nth(i);
assert(!nth->isConstantSExpr() || nth->next == NULL ||
nth->constant() == nth->next->constant(),
"shouldn't happen: merged consts - convert to map");
SSelfScope* s;
if (!nth->hasMap() || (s = tryLookup(info, nth)) == NULL) {
// cannot inline
others->append(nth);
info->needRealSend = true;
continue;
}
// can inline this case
// Notice that for immediates, instead of putting the constants in the mlist,
// we put the maps. No point in optimizing just for 17. -- dmu 6/05
Map* map = nth->map();
if (map == Memory->smi_map || map == Memory->float_map) {
slist ->append(s); // immediate maps go first
// Bug fix: instead of nth->shallowCopy, must generalize to any
// with same map, not just the same constant, because other ints (for example)
// will pass the type test, too. -- dmu 6/05
elist ->append(new MapSExpr(map->enclosing_mapOop(), r->preg(), NULL));
mlist ->append(map->enclosing_mapOop());
continue;
}
// can inline but not immediate map
slist2->append(s); // append later
elist2->append(nth->shallowCopy(r->preg(), NULL)); // use preg of merge
if (nth->isConstantSExpr()) {
mlist2->append(nth->constant());
}
else {
needMapLoad = true; // will need to load map of testee
mlist2->append(map->enclosing_mapOop());
}
}
mlist->appendList(mlist2);
elist->appendList(elist2);
slist->appendList(slist2);
// now do the type test and inline the individual cases
if (slist->length() > 0) {
memoizeBlocks(sel);
Node* typeCase =
theNodeGen->append(new TypeTestNode(r->preg(), mlist, needMapLoad,
info->needRealSend));
Node* fallThrough = typeCase->append(new NopNode);
for (i = 0; i < slist->length(); i++) {
theNodeGen->current = typeCase->append(i + 1, new NopNode);
SExpr* e = doInline(slist->nth(i), elist->nth(i), theNodeGen->current, merge);
if (!e->isNoResultSExpr()) {
theNodeGen->append(new NopNode);
e = e->shallowCopy(info->resReg, theNodeGen->current);
res = res ? res->mergeWith(e, merge) : e;
}
theNodeGen->branch(merge);
}
theNodeGen->current = fallThrough;
}
if (res && res->isMergeSExpr())
res->setNode(merge, info->resReg);
assert( info->needRealSend && others->length() ||
!info->needRealSend && !others->length(), "inconsistent");
// NB: *must* use uncommon branch if marked unlikely because
// future type tests won't test for unknown
if (others->isEmpty()) {
// typecase cannot fail
theNodeGen->deadEnd();
}
else if ( others->length() == 1
&& others->first()->isUnknownSExpr()
&& ((UnknownSExpr*)others->first())->isUnlikely()) {
// generate an uncommon branch for the unknown case, not a send
theNodeGen->uncommonBranch(currentExprStack(0), info->restartPrim);
info->needRealSend = false;
if (PrintInlining)
lprintf("%*s*making %s uncommon (2)\n", (void*)depth,"",selector_string(sel));
}
return res;
}
