void* Compiler::generate_function(bool indy) {
if(!mci_) {
if(!function_) return NULL;
if(indy) ctx_->llvm_state()->shared().gc_independent(ctx_->llvm_state());
if(ctx_->llvm_state()->jit_dump_code() & cSimple) {
llvm::outs() << "[[[ LLVM Simple IR ]]]\n";
llvm::outs() << *function_ << "\n";
}
std::vector<BasicBlock*> to_remove;
bool Broken = false;
for(Function::iterator I = function_->begin(),
E = function_->end();
I != E;
++I)
{
if(I->empty()) {
BasicBlock& bb = *I;
// No one jumps to it....
if(llvm::pred_begin(&bb) == llvm::pred_end(&bb)) {
to_remove.push_back(&bb);
} else {
llvm::outs() << "Basic Block is empty and used!\n";
}
} else if(!I->back().isTerminator()) {
llvm::errs() << "Basic Block does not have terminator!\n";
llvm::errs() << *I << "\n";
llvm::errs() << "\n";
Broken = true;
}
}
for(std::vector<BasicBlock*>::iterator i = to_remove.begin();
i != to_remove.end();
++i) {
(*i)->eraseFromParent();
}
if(Broken or llvm::verifyFunction(*function_, PrintMessageAction)) {
llvm::outs() << "ERROR: complication error detected.\n";
llvm::outs() << "ERROR: Please report the above message and the\n";
llvm::outs() << " code below to http://github.com/rubinius/rubinius/issues\n";
llvm::outs() << *function_ << "\n";
function_ = NULL;
if(indy) ctx_->llvm_state()->shared().gc_dependent(ctx_->llvm_state());
return NULL;
}
ctx_->passes()->run(*function_);
if(ctx_->llvm_state()->jit_dump_code() & cOptimized) {
llvm::outs() << "[[[ LLVM Optimized IR: ]]]\n";
llvm::outs() << *function_ << "\n";
}
mci_ = new llvm::MachineCodeInfo();
ctx_->engine()->runJITOnFunction(function_, mci_);
ctx_->llvm_state()->add_code_bytes(mci_->size());
// If we're not in JIT debug mode, delete the body IR, now that we're
// done with it.
// This saves us 100M+ of memory in a full spec run.
if(!ctx_->llvm_state()->debug_p()) {
function_->dropAllReferences();
}
if(indy) ctx_->llvm_state()->shared().gc_dependent(ctx_->llvm_state());
// Inject the RuntimeData objects used into the original CompiledCode
// Do this way after we've validated the IR so things are consistent.
void* native_function = ctx_->native_function();
ctx_->runtime_data_holder()->set_function(native_function,
mci_->address(), mci_->size());
// info.method()->set_jit_data(ctx.runtime_data_holder());
ctx_->llvm_state()->shared().om->add_code_resource(ctx_->runtime_data_holder());
}
return mci_->address();
}
Function* Decompiler::decompileFunction(unsigned Address) {
// Check that Address is inside the current section.
// TODO: Find a better way to do this check. What we really care about is
// avoiding reads to library calls and areas of memory we can't "see".
const object::SectionRef Sect = Dis->getCurrentSection();
uint64_t SectStart, SectEnd;
Sect.getAddress(SectStart);
Sect.getSize(SectEnd);
SectEnd += SectStart;
if (Address < SectStart || Address > SectEnd) {
errs() << "Address out of bounds for section (is this a library call?): "
<< format("%1" PRIx64, Address) << "\n";
return NULL;
}
MachineFunction *MF = Dis->disassemble(Address);
// Get Function Name
// TODO: Determine Function Type
FunctionType *FType = FunctionType::get(Type::getPrimitiveType(*Context,
Type::VoidTyID), false);
Function *F =
cast<Function>(Mod->getOrInsertFunction(MF->getName(), FType));
if (!F->empty()) {
return F;
}
// Create a basic block to hold entry point (alloca) information
BasicBlock *entry = getOrCreateBasicBlock("entry", F);
// For each basic block
MachineFunction::iterator BI = MF->begin(), BE = MF->end();
while (BI != BE) {
// Add branch from "entry"
if (BI == MF->begin()) {
entry->getInstList().push_back(
BranchInst::Create(getOrCreateBasicBlock(BI->getName(), F)));
} else {
getOrCreateBasicBlock(BI->getName(), F);
}
++BI;
}
BI = MF->begin();
while (BI != BE) {
if (decompileBasicBlock(BI, F) == NULL) {
printError("Unable to decompile basic block!");
}
++BI;
}
// During Decompilation, did any "in-between" basic blocks get created?
// Nothing ever splits the entry block, so we skip it.
for (Function::iterator I = ++F->begin(), E = F->end(); I != E; ++I) {
if (!(I->empty())) {
continue;
}
// Right now, the only way to get the right offset is to parse its name
// it sucks, but it works.
StringRef Name = I->getName();
if (Name == "end" || Name == "entry") continue; // these can be empty
size_t Off = F->getName().size() + 1;
size_t Size = Name.size() - Off;
StringRef BBAddrStr = Name.substr(Off, Size);
unsigned long long BBAddr;
getAsUnsignedInteger(BBAddrStr, 10, BBAddr);
BBAddr += Address;
DEBUG(errs() << "Split Target: " << Name << "\t Address: "
<< BBAddr << "\n");
// split Block at AddrStr
Function::iterator SB; // Split basic block
BasicBlock::iterator SI, SE; // Split instruction
// Note the ++, nothing ever splits the entry block.
for (SB = ++F->begin(); SB != E; ++SB) {
DEBUG(outs() << "SB: " << SB->getName()
<< "\tRange: " << Dis->getDebugOffset(SB->begin()->getDebugLoc())
<< " " << Dis->getDebugOffset(SB->getTerminator()->getDebugLoc())
<< "\n");
if (SB->empty() || BBAddr < getBasicBlockAddress(SB)
|| BBAddr > Dis->getDebugOffset(SB->getTerminator()->getDebugLoc())) {
continue;
}
// Reorder instructions based on Debug Location
sortBasicBlock(SB);
DEBUG(errs() << "Found Split Block: " << SB->getName() << "\n");
// Find iterator to split on.
for (SI = SB->begin(), SE = SB->end(); SI != SE; ++SI) {
// outs() << "SI: " << SI->getDebugLoc().getLine() << "\n";
if (Dis->getDebugOffset(SI->getDebugLoc()) == BBAddr) break;
if (Dis->getDebugOffset(SI->getDebugLoc()) > BBAddr) {
errs() << "Could not find address inside basic block!\n"
<< "SI: " << Dis->getDebugOffset(SI->getDebugLoc()) << "\n"
<< "BBAddr: " << BBAddr << "\n";
break;
}
}
break;
}
if (!SB || SI == SE || SB == E) {
errs() << "Decompiler: Failed to find instruction offset in function!\n";
continue;
}
// outs() << SB->getName() << " " << SI->getName() << "\n";
// outs() << "Creating Block...";
splitBasicBlockIntoBlock(SB, SI, I);
}
// Clean up unnecessary stores and loads
FunctionPassManager FPM(Mod);
// FPM.add(createPromoteMemoryToRegisterPass()); // See Scalar.h for more.
FPM.add(createTypeRecoveryPass());
FPM.run(*F);
return F;
}
void LLVMCompiler::compile(LLVMState* ls, VMMethod* vmm, bool is_block) {
if(ls->config().jit_inline_debug) {
if(is_block) {
VMMethod* parent = vmm->parent();
assert(parent);
llvm::errs() << "JIT: compiling block in "
<< ls->symbol_cstr(parent->original->scope()->module()->name())
<< "#"
<< ls->symbol_cstr(vmm->original->name())
<< " near "
<< ls->symbol_cstr(vmm->original->file()) << ":"
<< vmm->original->start_line() << "\n";
} else {
llvm::errs() << "JIT: compiling "
<< ls->symbol_cstr(vmm->original->scope()->module()->name())
<< "#"
<< ls->symbol_cstr(vmm->original->name()) << "\n";
}
}
JITMethodInfo info(vmm);
info.is_block = is_block;
LLVMWorkHorse work(ls, info);
if(is_block) {
work.setup_block();
} else {
work.setup();
}
llvm::Function* func = info.function();
if(!work.generate_body()) {
function_ = NULL;
// This is too noisy to report
// llvm::outs() << "not supported yet.\n";
return;
}
if(ls->jit_dump_code() & cSimple) {
llvm::outs() << "[[[ LLVM Simple IR ]]]\n";
llvm::outs() << *func << "\n";
}
std::vector<BasicBlock*> to_remove;
bool Broken = false;
for(Function::iterator I = func->begin(), E = func->end(); I != E; ++I) {
if(I->empty()) {
BasicBlock& bb = *I;
// No one jumps to it....
if(llvm::pred_begin(&bb) == llvm::pred_end(&bb)) {
to_remove.push_back(&bb);
} else {
llvm::outs() << "Basic Block is empty and used!\n";
}
} else if(!I->back().isTerminator()) {
llvm::errs() << "Basic Block does not have terminator!\n";
llvm::errs() << *I << "\n";
llvm::errs() << "\n";
Broken = true;
}
}
for(std::vector<BasicBlock*>::iterator i = to_remove.begin();
i != to_remove.end();
i++) {
(*i)->eraseFromParent();
}
if(Broken or llvm::verifyFunction(*func, PrintMessageAction)) {
llvm::outs() << "ERROR: complication error detected.\n";
llvm::outs() << "ERROR: Please report the above message and the\n";
llvm::outs() << " code below to http://github.com/evanphx/rubinius/issues\n";
llvm::outs() << *func << "\n";
function_ = NULL;
return;
}
ls->passes()->run(*func);
if(ls->jit_dump_code() & cOptimized) {
llvm::outs() << "[[[ LLVM Optimized IR: "
<< ls->symbol_cstr(vmm->original->name()) << " ]]]\n";
llvm::outs() << *func << "\n";
}
function_ = func;
}
void Compiler::compile_builder(jit::Context& ctx, LLVMState* ls, JITMethodInfo& info,
jit::Builder& work)
{
llvm::Function* func = info.function();
if(!work.generate_body()) {
function_ = NULL;
// This is too noisy to report
// llvm::outs() << "not supported yet.\n";
return;
}
// Hook up the return pad and return phi.
work.generate_hard_return();
if(ls->jit_dump_code() & cSimple) {
llvm::outs() << "[[[ LLVM Simple IR ]]]\n";
llvm::outs() << *func << "\n";
}
std::vector<BasicBlock*> to_remove;
bool Broken = false;
for(Function::iterator I = func->begin(), E = func->end(); I != E; ++I) {
if(I->empty()) {
BasicBlock& bb = *I;
// No one jumps to it....
if(llvm::pred_begin(&bb) == llvm::pred_end(&bb)) {
to_remove.push_back(&bb);
} else {
llvm::outs() << "Basic Block is empty and used!\n";
}
} else if(!I->back().isTerminator()) {
llvm::errs() << "Basic Block does not have terminator!\n";
llvm::errs() << *I << "\n";
llvm::errs() << "\n";
Broken = true;
}
}
for(std::vector<BasicBlock*>::iterator i = to_remove.begin();
i != to_remove.end();
++i) {
(*i)->eraseFromParent();
}
if(Broken or llvm::verifyFunction(*func, PrintMessageAction)) {
llvm::outs() << "ERROR: complication error detected.\n";
llvm::outs() << "ERROR: Please report the above message and the\n";
llvm::outs() << " code below to http://github.com/rubinius/rubinius/issues\n";
llvm::outs() << *func << "\n";
function_ = NULL;
return;
}
ls->passes()->run(*func);
if(ls->jit_dump_code() & cOptimized) {
llvm::outs() << "[[[ LLVM Optimized IR: "
<< ls->symbol_cstr(info.method()->name()) << " ]]]\n";
llvm::outs() << *func << "\n";
}
function_ = func;
generate_function(ls);
// Inject the RuntimeData objects used into the original CompiledMethod
// Do this way after we've validated the IR so things are consistent.
ctx.runtime_data_holder()->set_function(func, mci_->address(), mci_->size());
info.method()->set_jit_data(ctx.runtime_data_holder());
ls->shared().om->add_code_resource(ctx.runtime_data_holder());
}
