bool checkMethodSignature(TR::ValuePropagation *vp, TR::SymbolReference *symRef, const char *sig)
{
TR::Symbol *symbol = symRef->getSymbol();
if (!symbol->isResolvedMethod())
return false;
TR::ResolvedMethodSymbol *method = symbol->castToResolvedMethodSymbol();
if (!method) return false;
if (strncmp(method->getResolvedMethod()->signature(vp->trMemory()), sig, strlen(sig)) == 0)
return true;
return false;
}
static int cacheStringAppend(TR::ValuePropagation *vp,TR::Node *node)
{
return 0;
if (!vp->lastTimeThrough())
return 0;
TR::TreeTop *tt = vp->_curTree;
TR::TreeTop *newTree = tt;
TR::TreeTop *startTree = 0;
TR::TreeTop *exitTree = vp->_curBlock->getExit();
TR::Node *newBuffer;
if(node->getNumChildren() >= 1)
newBuffer = node->getFirstChild();
else
return 0;
enum {MAX_STRINGS = 2};
int initWithString = 0;
bool initWithInteger = false;
TR::TreeTop *appendTree[MAX_STRINGS+1];
TR::Node *appendedString[MAX_STRINGS+1];
char pattern[MAX_STRINGS+1];
int stringCount = 0;
bool useStringBuffer=false;
TR::SymbolReference *valueOfSymRef[MAX_STRINGS+1];
bool success = false;
char *sigBuffer="java/lang/StringBuffer.<init>(";
char *sigBuilder = "java/lang/StringBuilder.<init>(";
char *sigInit = "java/lang/String.<init>(";
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (checkMethodSignature(vp,node->getSymbolReference(), sigInit))
{
TR::Symbol *symbol =node->getSymbolReference()->getSymbol();
TR_ResolvedMethod *m = symbol->castToResolvedMethodSymbol()->getResolvedMethod();
if (strncmp(m->signatureChars(), "(Ljava/lang/String;Ljava/lang/String;)V", m->signatureLength())==0)
{
vp->_cachedStringPeepHolesVcalls.add(new (vp->comp()->trStackMemory()) TR::ValuePropagation::VPTreeTopPair(tt,tt->getPrevRealTreeTop()));
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
if (checkMethodSignature(vp,node->getSymbolReference(), sigBuffer))
{
useStringBuffer=true;
success = true;
}
else if (checkMethodSignature(vp,node->getSymbolReference(), sigBuilder))
{
success = true;
useStringBuffer=false;
}
else
{
return 0;
}
if (success)
{
TR::Symbol *symbol =node->getSymbolReference()->getSymbol();
TR_ResolvedMethod *m = symbol->castToResolvedMethodSymbol()->getResolvedMethod();
if (strncmp(m->signatureChars(), "()V", m->signatureLength())==0)
{
// Diagnostics
}else
{
return 0;
}
}
else // <init> not found (could be unresolved)
{
return 0;
}
// now search for StringBuffer.append calls that are chained to one another
TR::TreeTop *lastAppendTree = 0; // updated when we find an append
TR::Node *child = newBuffer;
while (1)
{
startTree = tt->getNextRealTreeTop();
appendedString[stringCount] = 0;
int visitCount = 0;
if (useStringBuffer)
tt = searchForStringAppend(vp,"java/lang/StringBuffer.append(",
startTree, exitTree, TR::acall, child, visitCount,
appendedString + stringCount);
else
tt = searchForStringAppend(vp,"java/lang/StringBuilder.append(",
startTree, exitTree, TR::acall, child, visitCount,
appendedString + stringCount);
if (appendedString[stringCount]) // we found it
{
appendTree[stringCount] = tt;
// we could exit here if too many appends are chained
if (stringCount >= MAX_STRINGS)
return 0;
// see which type of append we have
TR::Symbol *symbol = tt->getNode()->getFirstChild()->getSymbolReference()->getSymbol();
TR_ASSERT(symbol->isResolvedMethod(), "assertion failure");
TR::ResolvedMethodSymbol *method = symbol->castToResolvedMethodSymbol();
TR_ASSERT(method, "assertion failure");
TR_ResolvedMethod *m = method->getResolvedMethod();
if (strncmp(m->signatureChars(), "(Ljava/lang/String;)", 20)==0)
{
pattern[stringCount] = 'S';
valueOfSymRef[stringCount] = 0; // don't need conversion to string
}
else // appending something that needs conversion using valueOf
{
TR::SymbolReference *symRefForValueOf = 0;
// In the following we can vp->compare only (C) because we know that
// StringBuffer.append returns a StringBuffer.
//s
char *sigBuffer = m->signatureChars();
TR_ASSERT(m->signatureLength() >= 3, "The minimum signature length should be 3 for ()V");
}
stringCount++;
}
else // the chain of appends is broken
{
appendTree[stringCount] = 0;
pattern[stringCount] = 0; // string terminator
break;
}
lastAppendTree = tt;
child = tt->getNode()->getFirstChild(); // the first node is a NULLCHK and its child is the call
} // end while
if (stringCount < 2)
return 0; // cannot apply StringPeepholes
if (stringCount > MAX_STRINGS)
return 0;
if (stringCount == 3)
return 0; // same as above
TR_ASSERT(lastAppendTree, "If stringCount <=2 then we must have found an append");
// now look for the toString call
TR::TreeTop *toStringTree = 0;
//visitCount = vp->comp()->incVisitCount();
int visitCount=0;
tt = searchForToStringCall(vp,lastAppendTree->getNextRealTreeTop(), exitTree,
lastAppendTree->getNode()->getFirstChild(),
visitCount, &toStringTree, useStringBuffer);
if (!toStringTree)
return 0;
vp->_cachedStringBufferVcalls.add(new (vp->comp()->trStackMemory()) TR::ValuePropagation::VPStringCached(appendTree[0],appendTree[1],appendedString[0],appendedString[1],newTree,toStringTree));
}
