uint8_t *TR::PPCHelperCallSnippet::emitSnippetBody()
{
uint8_t *buffer = cg()->getBinaryBufferCursor();
uint8_t *gtrmpln, *trmpln;
getSnippetLabel()->setCodeLocation(buffer);
return genHelperCall(buffer);
}
void TR::X86DataSnippet::print(TR::FILE* pOutFile, TR_Debug* debug)
{
if (pOutFile == NULL)
return;
uint8_t *bufferPos = getSnippetLabel()->getCodeLocation();
debug->printSnippetLabel(pOutFile, getSnippetLabel(), bufferPos, debug->getName(this));
debug->printPrefix(pOutFile, NULL, bufferPos, getDataSize());
const char* toString;
switch (getDataSize())
{
case 8:
toString = dqString();
break;
case 4:
toString = ddString();
break;
case 2:
toString = dwString();
break;
default:
toString = dbString();
break;
}
trfprintf(pOutFile, "%s \t%s", toString, hexPrefixString());
for (int i=getDataSize()-1; i >= 0; i--)
{
trfprintf(pOutFile, "%02x", bufferPos[i]);
}
trfprintf(pOutFile,"%s\t%s ", hexSuffixString(), commentString());
printValue(pOutFile, debug);
}
uint8_t *
TR::S390WarmToColdTrampolineSnippet::emitSnippetBody()
{
uint8_t * cursor = cg()->getBinaryBufferCursor();
getSnippetLabel()->setCodeLocation(cursor);
if (getIsUsed())
{
cg()->addRelocation(new (cg()->trHeapMemory()) TR::LabelRelative32BitRelocation(cursor, getTargetLabel()));
// BRCL 0xf, <target>
*(int16_t *) cursor = 0xC0F4;
cursor += sizeof(int16_t);
// BRCL - Add Relocation the data constants to this LARL.
*(int32_t *) cursor = 0xDEADBEEF;
cursor += sizeof(int32_t);
}
return cursor;
}
uint8_t *TR::X86DataSnippet::emitSnippetBody()
{
uint8_t *cursor = cg()->getBinaryBufferCursor();
// align to 16 bytes
if (getDataSize() % 16 == 0)
{
cursor = (uint8_t*)(((intptrj_t)(cursor + 15)) & ((-1)<<4));
}
getSnippetLabel()->setCodeLocation(cursor);
memcpy(cursor, getRawData(), getDataSize());
addMetaDataForCodeAddress(cursor);
cursor += getDataSize();
return cursor;
}
uint8_t *TR::PPCArrayCopyCallSnippet::emitSnippetBody()
{
TR::Node *node = getNode();
TR_ASSERT(node->getOpCodeValue() == TR::arraycopy &&
node->getChild(2)->getOpCode().isLoadConst(), "only valid for arraycopies with a constant length\n");
uint8_t *buffer = cg()->getBinaryBufferCursor();
getSnippetLabel()->setCodeLocation(buffer);
TR::RealRegister *lengthReg = cg()->machine()->getRealRegister(_lengthRegNum);
TR::Node *lengthNode = node->getChild(2);
int64_t byteLen = (lengthNode->getType().isInt32() ?
lengthNode->getInt() : lengthNode->getLongInt());
TR::InstOpCode opcode;
// li lengthReg, #byteLen
opcode.setOpCodeValue(TR::InstOpCode::li);
buffer = opcode.copyBinaryToBuffer(buffer);
lengthReg->setRegisterFieldRT((uint32_t *)buffer);
TR_ASSERT(byteLen <= UPPER_IMMED,"byteLen too big to encode\n");
*(int32_t *)buffer |= byteLen;
buffer += 4;
return TR::PPCHelperCallSnippet::genHelperCall(buffer);
}
uint8_t *TR::X86FPConversionSnippet::emitSnippetBody()
{
uint8_t *buffer = cg()->getBinaryBufferCursor();
getSnippetLabel()->setCodeLocation(buffer);
return genRestartJump(genFPConversion(buffer));
}
uint8_t *
TR::S390HelperCallSnippet::emitSnippetBody()
{
uint8_t * cursor = cg()->getBinaryBufferCursor();
getSnippetLabel()->setCodeLocation(cursor);
TR::Node * callNode = getNode();
TR::SymbolReference * helperSymRef = getHelperSymRef();
bool jitInduceOSR = helperSymRef == cg()->symRefTab()->element(TR_induceOSRAtCurrentPC);
if (jitInduceOSR)
{
// Flush in-register arguments back to the stack for interpreter
cursor = TR::S390CallSnippet::S390flushArgumentsToStack(cursor, callNode, getSizeOfArguments(), cg());
}
uint32_t rEP = (uint32_t) cg()->getEntryPointRegister() - 1;
//load vm thread into gpr13
cursor = generateLoadVMThreadInstruction(cg(), cursor);
// Generate RIOFF if RI is supported.
cursor = generateRuntimeInstrumentationOnOffInstruction(cg(), cursor, TR::InstOpCode::RIOFF);
if ( // Methods that require
alwaysExcept()) // R14 to point to snippet:
{
// For trace method entry/exit, we need to set up R14 to point to the
// beginning of the data segment. We will use BRASL to automatically
// set R14 correctly.
// For methods that lead to exceptions, and never return to the
// main code, we set up R14, so that if GC occurs, the stackwalker
// will see R14 is pointing to this snippet, and pick up the correct
// stack map.
*(int16_t *) cursor = 0xC0E5; // BRASL R14, <Helper Addr>
cursor += sizeof(int16_t);
}
else // Otherwise:
{
// We're not sure if the helper will return. So, we need to provide
// the return addr of the main line code, so that when helper call
// completes, it can jump back properly.
// Load Return Address into R14.
intptrj_t returnAddr = (intptrj_t)getReStartLabel()->getCodeLocation(); // LARL R14, <Return Addr>
*(int16_t *) cursor = 0xC0E0;
cursor += sizeof(int16_t);
*(int32_t *) cursor = (int32_t)((returnAddr - (intptrj_t)(cursor - 2)) / 2);
cursor += sizeof(int32_t);
*(int16_t *) cursor = 0xC0F4; // BRCL <Helper Addr>
cursor += sizeof(int16_t);
}
// Calculate the relative offset to get to helper method.
// If MCC is not supported, everything should be reachable.
// If MCC is supported, we will look up the appropriate trampoline, if
// necessary.
intptrj_t destAddr = (intptrj_t)(helperSymRef->getSymbol()->castToMethodSymbol()->getMethodAddress());
#if defined(TR_TARGET_64BIT)
#if defined(J9ZOS390)
if (cg()->comp()->getOption(TR_EnableRMODE64))
#endif
{
if (NEEDS_TRAMPOLINE(destAddr, cursor, cg()))
{
destAddr = cg()->fe()->indexedTrampolineLookup(helperSymRef->getReferenceNumber(), (void *)cursor);
this->setUsedTrampoline(true);
// We clobber rEP if we take a trampoline. Update our register map if necessary.
if (gcMap().getStackMap() != NULL)
{
gcMap().getStackMap()->maskRegisters(~(0x1 << (rEP)));
}
}
}
#endif
TR_ASSERT(CHECK_32BIT_TRAMPOLINE_RANGE(destAddr, cursor), "Helper Call is not reachable.");
this->setSnippetDestAddr(destAddr);
*(int32_t *) cursor = (int32_t)((destAddr - (intptrj_t)(cursor - 2)) / 2);
AOTcgDiag1(cg()->comp(), "add TR_HelperAddress cursor=%x\n", cursor);
cg()->addProjectSpecializedRelocation(cursor, (uint8_t*) helperSymRef, NULL, TR_HelperAddress,
__FILE__, __LINE__, getNode());
cursor += sizeof(int32_t);
gcMap().registerStackMap(cursor, cg());
return cursor;
}