Function* Create(const STREAMOUT_COMPILE_STATE& state)
{
static std::size_t soNum = 0;
std::stringstream fnName("SOShader", std::ios_base::in | std::ios_base::out | std::ios_base::ate);
fnName << soNum++;
// SO function signature
// typedef void(__cdecl *PFN_SO_FUNC)(SWR_STREAMOUT_CONTEXT*)
std::vector<Type*> args{
PointerType::get(Gen_SWR_STREAMOUT_CONTEXT(JM()), 0), // SWR_STREAMOUT_CONTEXT*
};
FunctionType* fTy = FunctionType::get(IRB()->getVoidTy(), args, false);
Function* soFunc = Function::Create(fTy, GlobalValue::ExternalLinkage, fnName.str(), JM()->mpCurrentModule);
// create return basic block
BasicBlock* entry = BasicBlock::Create(JM()->mContext, "entry", soFunc);
BasicBlock* returnBB = BasicBlock::Create(JM()->mContext, "return", soFunc);
IRB()->SetInsertPoint(entry);
// arguments
auto argitr = soFunc->getArgumentList().begin();
Value* pSoCtx = &*argitr++;
pSoCtx->setName("pSoCtx");
const STREAMOUT_STREAM& streamState = state.stream;
buildStream(state, streamState, pSoCtx, returnBB, soFunc);
BR(returnBB);
IRB()->SetInsertPoint(returnBB);
RET_VOID();
JitManager::DumpToFile(soFunc, "SoFunc");
::FunctionPassManager passes(JM()->mpCurrentModule);
passes.add(createBreakCriticalEdgesPass());
passes.add(createCFGSimplificationPass());
passes.add(createEarlyCSEPass());
passes.add(createPromoteMemoryToRegisterPass());
passes.add(createCFGSimplificationPass());
passes.add(createEarlyCSEPass());
passes.add(createInstructionCombiningPass());
passes.add(createInstructionSimplifierPass());
passes.add(createConstantPropagationPass());
passes.add(createSCCPPass());
passes.add(createAggressiveDCEPass());
passes.run(*soFunc);
JitManager::DumpToFile(soFunc, "SoFunc_optimized");
return soFunc;
}
void ModelGeneratorContext::initFunctionPassManager()
{
if (options & ModelGenerator::OPTIMIZE)
{
functionPassManager = new FunctionPassManager(module);
// Set up the optimizer pipeline. Start with registering info about how the
// target lays out data structures.
// we only support LLVM >= 3.1
#if (LLVM_VERSION_MAJOR == 3) && (LLVM_VERSION_MINOR == 1)
functionPassManager->add(new TargetData(*executionEngine->getTargetData()));
#else
functionPassManager->add(new DataLayout(*executionEngine->getDataLayout()));
#endif
// Provide basic AliasAnalysis support for GVN.
functionPassManager->add(createBasicAliasAnalysisPass());
if (options & ModelGenerator::OPTIMIZE_INSTRUCTION_SIMPLIFIER)
{
Log(Logger::LOG_INFORMATION) << "using OPTIMIZE_INSTRUCTION_SIMPLIFIER";
functionPassManager->add(createInstructionSimplifierPass());
}
if (options & ModelGenerator::OPTIMIZE_INSTRUCTION_COMBINING)
{
Log(Logger::LOG_INFORMATION) << "using OPTIMIZE_INSTRUCTION_COMBINING";
functionPassManager->add(createInstructionCombiningPass());
}
if(options & ModelGenerator::OPTIMIZE_GVN)
{
Log(Logger::LOG_INFORMATION) << "using GVN optimization";
functionPassManager->add(createGVNPass());
}
if (options & ModelGenerator::OPTIMIZE_CFG_SIMPLIFICATION)
{
Log(Logger::LOG_INFORMATION) << "using OPTIMIZE_CFG_SIMPLIFICATION";
functionPassManager->add(createCFGSimplificationPass());
}
if (options & ModelGenerator::OPTIMIZE_DEAD_INST_ELIMINATION)
{
Log(Logger::LOG_INFORMATION) << "using OPTIMIZE_DEAD_INST_ELIMINATION";
functionPassManager->add(createDeadInstEliminationPass());
}
if (options & ModelGenerator::OPTIMIZE_DEAD_CODE_ELIMINATION)
{
Log(Logger::LOG_INFORMATION) << "using OPTIMIZE_DEAD_CODE_ELIMINATION";
functionPassManager->add(createDeadCodeEliminationPass());
}
functionPassManager->doInitialization();
}
}
bool JITOptimizations::runOnFunction(Function& F) {
this->LI = &getAnalysis<LoopInfo>();
bool changed = false;
FPM = new FunctionPassManager(F.getParent());
// if the user input something we use those passes
std::vector<const PassInfo *> &customPasses = JPD->getPassList();
if (customPasses.size() > 0) {
for (int i=0; i<customPasses.size();i++) {
const PassInfo *pass = customPasses[i];
FPM->add(pass->createPass());
}
} else {
// Optimization ordering:
// - ADCE
// - inline
// - DSE <---- THIS causes seg faults when running on sqlite3
// test in llvm test-suite
// - Instruction Combining
// ---- IF LOOPS ----
// - LICM
// - Loop Simplify
// - Loop Strength Reduction
// ------------------
// - SCCP
// - Simplify CFG
// - SROA
FPM->add(createAggressiveDCEPass());
if (JPD->getThresholdT2() != 0)
FPM->add(createDynamicInlinerPass(JPD));
FPM->add(createInstructionCombiningPass());
// --- Loop optimizations --- //
if (LI->begin() != LI->end()) {
FPM->add(createLICMPass());
FPM->add(createLoopSimplifyPass());
FPM->add(createLoopStrengthReducePass());
}
// -------------------------- //
FPM->add(createSCCPPass());
FPM->add(createCFGSimplificationPass());
FPM->add(createSROAPass(false));
}
changed = changed | FPM->doInitialization();
changed = changed | FPM->run(F);
changed = changed | FPM->doFinalization();
delete FPM;
return changed;
}
bool SimpleTargetMachine::
addPassesToEmitWholeFile(PassManager & PM,
formatted_raw_ostream & o,
CodeGenFileType FileType,
CodeGenOpt::Level OptLevel,
bool DisableVerify) {
PM.add(createGCLoweringPass());
PM.add(createLowerInvokePass());
PM.add(createCFGSimplificationPass()); // clean up after lower invoke.
PM.add(new SimpleBackendNameAllUsedStructsAndMergeFunctions());
PM.add(new SimpleWriter(o));
pinavm::addGCInfoDeleter(PM);
return false;
}}
/// Optimize - Perform link time optimizations. This will run the scalar
/// optimizations, any loaded plugin-optimization modules, and then the
/// inter-procedural optimizations if applicable.
void Optimize(Module *M) {
// Instantiate the pass manager to organize the passes.
PassManager Passes;
// If we're verifying, start off with a verification pass.
if (VerifyEach)
Passes.add(createVerifierPass());
// Add an appropriate TargetData instance for this module...
addPass(Passes, new TargetData(M));
if (!DisableOptimizations)
PassManagerBuilder().populateLTOPassManager(Passes, !DisableInternalize,
!DisableInline);
// If the -s or -S command line options were specified, strip the symbols out
// of the resulting program to make it smaller. -s and -S are GNU ld options
// that we are supporting; they alias -strip-all and -strip-debug.
if (Strip || StripDebug)
addPass(Passes, createStripSymbolsPass(StripDebug && !Strip));
// Create a new optimization pass for each one specified on the command line
std::auto_ptr<TargetMachine> target;
for (unsigned i = 0; i < OptimizationList.size(); ++i) {
const PassInfo *Opt = OptimizationList[i];
if (Opt->getNormalCtor())
addPass(Passes, Opt->getNormalCtor()());
else
errs() << "llvm-ld: cannot create pass: "******"\n";
}
// The user's passes may leave cruft around. Clean up after them them but
// only if we haven't got DisableOptimizations set
if (!DisableOptimizations) {
addPass(Passes, createInstructionCombiningPass());
addPass(Passes, createCFGSimplificationPass());
addPass(Passes, createAggressiveDCEPass());
addPass(Passes, createGlobalDCEPass());
}
// Make sure everything is still good.
if (!DontVerify)
Passes.add(createVerifierPass());
// Run our queue of passes all at once now, efficiently.
Passes.run(*M);
}
main_func_type jit_engine::compile(const ast::Program &prog) {
llvm::LLVMContext &c=llvm::getGlobalContext();
llvm::Module *m=new llvm::Module("brainfuck", c);
brainfuck::codegen(*m, prog);
//m->dump();
std::string ErrStr;
ExecutionEngine *TheExecutionEngine = EngineBuilder(m).setErrorStr(&ErrStr).create();
if (!TheExecutionEngine) {
fprintf(stderr, "Could not create ExecutionEngine: %s\n", ErrStr.c_str());
exit(1);
}
Function *f_main=m->getFunction("main");
// Optimize, target dependant
if(optimization_level_>0)
{
FunctionPassManager OurFPM(m);
// Set up the optimizer pipeline. Start with registering info about how the
// target lays out data structures.
OurFPM.add(new TargetData(*TheExecutionEngine->getTargetData()));
// Provide basic AliasAnalysis support for GVN.
OurFPM.add(createBasicAliasAnalysisPass());
// Do simple "peephole" optimizations and bit-twiddling optzns.
OurFPM.add(createInstructionCombiningPass());
// Reassociate expressions.
OurFPM.add(createReassociatePass());
// Eliminate Common SubExpressions.
OurFPM.add(createGVNPass());
// Simplify the control flow graph (deleting unreachable blocks, etc).
OurFPM.add(createCFGSimplificationPass());
//OurFPM.add(createLoopSimplifyPass());
//OurFPM.add(createBlockPlacementPass());
//OurFPM.add(createConstantPropagationPass());
OurFPM.doInitialization();
OurFPM.run(*f_main);
}
//m->dump();
void *rp=TheExecutionEngine->getPointerToFunction(f_main);
main_func_type fp=reinterpret_cast<main_func_type>(rp);
return fp;
}
VALUE
llvm_pass_manager_run(VALUE self, VALUE module) {
PassManager *pm = (PassManager*) DATA_PTR(self);
Module *m = LLVM_MODULE(module);
pm->add(new TargetData(m));
pm->add(createVerifierPass());
pm->add(createLowerSetJmpPass());
pm->add(createRaiseAllocationsPass());
pm->add(createCFGSimplificationPass());
pm->add(createPromoteMemoryToRegisterPass());
pm->add(createGlobalOptimizerPass());
pm->add(createGlobalDCEPass());
pm->add(createFunctionInliningPass());
pm->run(*m);
return Qtrue;
}
// =============================================================================
// runOnModule
//
//
//
// =============================================================================
bool TwetoPassImpl::runOnModule(Module & M)
{
MSG("\n============== Tweto Pass =============\n");
this->llvmMod = &M;
LinkExternalBitcode(this->llvmMod, ExternalBitCodePath);
// Retrieve the method that does all the vtable calculations
// in order to call the actual 'write' method (see replaceCallsInProcess)
this->writeFun =
this->llvmMod->getFunction("tweto_call_write_method");
if (!this->writeFun) {
std::cerr << "tweto_call_write_method is missing,";
std::cerr << "pass aborded!" << std::endl;
return false;
}
// Retrieve the base write method in order to get the types
// of the 'this' pointer, the address and the data
// (should be always mangled like this, so if the Basic-protocol's includes
// are correctly imported, no error will be throw)
this->basicWriteFun = this->llvmMod->getFunction(wFunName);
if (!this->basicWriteFun) {
std::cerr << "basic's write method is missing,";
std::cerr << "pass aborded!" << std::endl;
return false;
}
writeFun->dump();
// Initialize function passes
DataLayout *target = new DataLayout(this->llvmMod);
DataLayoutPass *dlpass = new DataLayoutPass(*target);
funPassManager = new FunctionPassManager(this->llvmMod);
funPassManager->add(dlpass);
funPassManager->add(createIndVarSimplifyPass());
funPassManager->add(createLoopUnrollPass());
funPassManager->add(createInstructionCombiningPass());
funPassManager->add(createReassociatePass());
funPassManager->add(createGVNPass());
funPassManager->add(createCFGSimplificationPass());
funPassManager->add(createConstantPropagationPass());
// Modules
std::vector < sc_core::sc_module * >modules =
sc_core::sc_get_curr_simcontext()->get_module_registry()->
m_module_vec;
std::vector < sc_core::sc_module * >::iterator modIt;
for (modIt = modules.begin(); modIt < modules.end(); ++modIt) {
sc_core::sc_module * initiatorMod = *modIt;
std::string moduleName =
(std::string) initiatorMod->name();
// Optimize this module
optimize(initiatorMod);
}
// Check if the module is corrupt
verifyModule(*this->llvmMod);
std::ostringstream oss;
oss << callOptCounter;
MSG("\n Pass report - " + oss.str() + "/" + "?");
MSG(" - opt/total\n");
MSG("===========================================\n\n");
// TODO : handle false case
return true;
}
static void addOptimizationPasses(T *PM)
{
#ifdef JL_DEBUG_BUILD
PM->add(createVerifierPass());
#endif
#ifdef __has_feature
# if __has_feature(address_sanitizer)
# if defined(LLVM37) && !defined(LLVM38)
// LLVM 3.7 BUG: ASAN pass doesn't properly initialize its dependencies
initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry());
# endif
PM->add(createAddressSanitizerFunctionPass());
# endif
# if __has_feature(memory_sanitizer)
PM->add(llvm::createMemorySanitizerPass(true));
# endif
#endif
if (jl_options.opt_level <= 1) {
return;
}
#ifdef LLVM37
PM->add(createTargetTransformInfoWrapperPass(jl_TargetMachine->getTargetIRAnalysis()));
#else
jl_TargetMachine->addAnalysisPasses(*PM);
#endif
#ifdef LLVM38
PM->add(createTypeBasedAAWrapperPass());
#else
PM->add(createTypeBasedAliasAnalysisPass());
#endif
if (jl_options.opt_level >= 3) {
#ifdef LLVM38
PM->add(createBasicAAWrapperPass());
#else
PM->add(createBasicAliasAnalysisPass());
#endif
}
// list of passes from vmkit
PM->add(createCFGSimplificationPass()); // Clean up disgusting code
PM->add(createPromoteMemoryToRegisterPass());// Kill useless allocas
#ifndef INSTCOMBINE_BUG
PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
#endif
PM->add(createSROAPass()); // Break up aggregate allocas
#ifndef INSTCOMBINE_BUG
PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
#endif
PM->add(createJumpThreadingPass()); // Thread jumps.
// NOTE: CFG simp passes after this point seem to hurt native codegen.
// See issue #6112. Should be re-evaluated when we switch to MCJIT.
//PM->add(createCFGSimplificationPass()); // Merge & remove BBs
#ifndef INSTCOMBINE_BUG
PM->add(createInstructionCombiningPass()); // Combine silly seq's
#endif
//PM->add(createCFGSimplificationPass()); // Merge & remove BBs
PM->add(createReassociatePass()); // Reassociate expressions
// this has the potential to make some things a bit slower
//PM->add(createBBVectorizePass());
PM->add(createEarlyCSEPass()); //// ****
PM->add(createLoopIdiomPass()); //// ****
PM->add(createLoopRotatePass()); // Rotate loops.
// LoopRotate strips metadata from terminator, so run LowerSIMD afterwards
PM->add(createLowerSimdLoopPass()); // Annotate loop marked with "simdloop" as LLVM parallel loop
PM->add(createLICMPass()); // Hoist loop invariants
PM->add(createLoopUnswitchPass()); // Unswitch loops.
// Subsequent passes not stripping metadata from terminator
#ifndef INSTCOMBINE_BUG
PM->add(createInstructionCombiningPass());
#endif
PM->add(createIndVarSimplifyPass()); // Canonicalize indvars
PM->add(createLoopDeletionPass()); // Delete dead loops
#if defined(LLVM35)
PM->add(createSimpleLoopUnrollPass()); // Unroll small loops
#else
PM->add(createLoopUnrollPass()); // Unroll small loops
#endif
#if !defined(LLVM35) && !defined(INSTCOMBINE_BUG)
PM->add(createLoopVectorizePass()); // Vectorize loops
#endif
//PM->add(createLoopStrengthReducePass()); // (jwb added)
#ifndef INSTCOMBINE_BUG
PM->add(createInstructionCombiningPass()); // Clean up after the unroller
#endif
PM->add(createGVNPass()); // Remove redundancies
//PM->add(createMemCpyOptPass()); // Remove memcpy / form memset
PM->add(createSCCPPass()); // Constant prop with SCCP
// Run instcombine after redundancy elimination to exploit opportunities
// opened up by them.
PM->add(createSinkingPass()); ////////////// ****
PM->add(createInstructionSimplifierPass());///////// ****
#ifndef INSTCOMBINE_BUG
PM->add(createInstructionCombiningPass());
#endif
PM->add(createJumpThreadingPass()); // Thread jumps
PM->add(createDeadStoreEliminationPass()); // Delete dead stores
#if !defined(INSTCOMBINE_BUG)
if (jl_options.opt_level >= 3) {
#ifdef LLVM39
initializeDemandedBitsPass(*PassRegistry::getPassRegistry());
#endif
PM->add(createSLPVectorizerPass()); // Vectorize straight-line code
}
#endif
PM->add(createAggressiveDCEPass()); // Delete dead instructions
#if !defined(INSTCOMBINE_BUG)
if (jl_options.opt_level >= 3)
PM->add(createInstructionCombiningPass()); // Clean up after SLP loop vectorizer
#endif
#if defined(LLVM35)
PM->add(createLoopVectorizePass()); // Vectorize loops
PM->add(createInstructionCombiningPass()); // Clean up after loop vectorizer
#endif
//PM->add(createCFGSimplificationPass()); // Merge & remove BBs
}
void CouchRunner::runIR( CouchWorkingMemory *wm ){
/*
Module *theM;
theM = ParseBitcodeFile( MemoryBuffer::getFile("out.bc"),
getGlobalContext(),
&error );
*/
// Loads intermediate representation source
std::string error;
SMDiagnostic Err;
std::auto_ptr<Module> theM(ParseAssemblyFile( fSourceFile, Err, getGlobalContext() ));
std::cout << "KBVM v1.0 (experimental)\nIntermediate Representation Interpreter\n";
std::cout << "Parsing " << fSourceFile << "\n";
// Verifies module
try{
std::string VerifErr;
if (verifyModule( *theM.get(), ReturnStatusAction, &VerifErr)) {
errs() << fSourceFile
<< ": assembly parsed, but does not verify as correct!\n";
errs() << VerifErr;
return;
}
}
catch(...){
std::cerr << "Verification of module failed!\n";
return;
}
// Prepares to execute
S_wm = wm;
IRBuilder<> theBuilder( getGlobalContext() );
// Create the JIT.
S_TheExecutionEngine = ExecutionEngine::create(theM.get());
//ExistingModuleProvider OurModuleProvider( M );
FunctionPassManager OurFPM( theM.get() );
// Set up the optimizer pipeline.
// Start with registering info about how the
// target lays out data structures.
OurFPM.add(new TargetData(*S_TheExecutionEngine->getTargetData()));
// Promote allocas to registers.
OurFPM.add(createPromoteMemoryToRegisterPass());
// Do simple "peephole" optimizations and bit-twiddling optzns.
OurFPM.add(createInstructionCombiningPass());
// Reassociate expressions.
OurFPM.add(createReassociatePass());
// Eliminate Common SubExpressions.
OurFPM.add(createGVNPass());
// Simplify the control flow graph (deleting unreachable blocks, etc).
OurFPM.add(createCFGSimplificationPass());
// Set the global so the code gen can use this.
S_TheFPM = &OurFPM;
// Inital setup of the agenda
unsigned int i;
CouchRunner::S_Agenda->reset();
// Initial setup of the working memory
S_TheFPM->run( *theM->getFunction("ag_forward") );
std::string sign, val;
Function *FFwrd = S_TheExecutionEngine->FindFunctionNamed( "ag_forward" );
void *FFwrdPtr = S_TheExecutionEngine->getPointerToFunction(FFwrd);
void (*FFwrdP)(const char*) = (void (*)( const char*))FFwrdPtr;
DOMElement *elt;
DOMNodeList *domSuggests =
fDom->getElementsByTagName( XMLString::transcode("suggest") );
for( i = 0; i < domSuggests->getLength(); i++ ){
CouchRunner::S_Agenda->push( std::string(XMLString::transcode( ((DOMText *)(domSuggests->item(i)->getFirstChild()))->getData() )), S_wm );
}
DOMNodeList *domVolunteers =
fDom->getElementsByTagName( XMLString::transcode("volunteer") );
for( i = 0; i < domVolunteers->getLength(); i++ ){
elt = (DOMElement *)(domVolunteers->item(i));
sign = std::string( XMLString::transcode( ((DOMText *)(elt->getElementsByTagName(XMLString::transcode("var"))->item(0)->getFirstChild()))->getData() ) );
val = std::string( XMLString::transcode( ((DOMText *)(elt->getElementsByTagName(XMLString::transcode("const"))->item(0)->getFirstChild()))->getData() ) );
// TODO: update with type information
if( std::string("true") == val ){
S_wm->set( sign.c_str(), (int)1 );
}
else if( std::string("false") == val ){
S_wm->set( sign.c_str(), (int)0 );
}
else if( isalpha( *(val.c_str()) ) ){
S_wm->set( sign.c_str(), val.c_str() );
}
else{
double d = strtod( val.c_str(), NULL );
S_wm->set( sign.c_str(), d );
}
// Update agenda as if forwarded from execution
FFwrdP( sign.c_str() );
}
std::cout << "Session Started\n" << *S_wm << *CouchRunner::S_Agenda;
{
// Creates the `entry' function that sets up the Agenda, which
// also serves as continuation for the postponed calls
std::vector<Value *> args;
Function *Main;
while( !CouchRunner::S_Agenda->empty() ){
// Erase previous entry function if present
if( NULL != (Main = theM->getFunction("entry")) ){
Main->eraseFromParent();
}
// Creates code block
Main = cast<Function>(
theM->getOrInsertFunction( "entry",
Type::getInt32Ty(getGlobalContext()),
(Type *)0)
);
BasicBlock *EB = BasicBlock::Create(getGlobalContext(),
"EntryBlock", Main);
theBuilder.SetInsertPoint(EB);
// Loops through the current agenda
Value *res = NULL, *call;
std::string hypo;
// Copies agenda to current Agenda
while( !CouchRunner::S_Agenda->empty() ){
hypo = CouchRunner::S_Agenda->pop();
if( WorkingMemory::WM_UNKNOWN == S_wm->knownp( hypo.c_str() ) ){
call = theBuilder.CreateCall(theM->getFunction( hypo ),
args.begin(),
args.end(), "suggest");
res =
theBuilder.CreateIntCast( call,
Type::getInt32Ty(getGlobalContext()),
false, "cast_tmp" );
}
}
theBuilder.CreateRet( res == NULL ?
ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 2) :
res );
// Check it
S_TheFPM->run( *Main );
// Run it
Function *F = S_TheExecutionEngine->FindFunctionNamed( "entry" );
void *FPtr = S_TheExecutionEngine->getPointerToFunction(F);
typedef int (*PFN)();
PFN FP = reinterpret_cast<PFN>( FPtr );
// int (*FP)() = (int (*)())FPtr;
printf( "Result = %d\n", FP() );
std::cout << *S_wm << std::endl;
std::cout << *CouchRunner::S_Agenda << std::endl;
}
S_wm = NULL;
}
}
Context::Context(LLVMState* ls)
: ls_(ls)
, root_info_(0)
, inlined_block_(false)
, inline_depth_(0)
, rds_(new jit::RuntimeDataHolder)
, function_(0)
, state_(0)
, out_args_(0)
, counter_(0)
{
VoidTy = Type::getVoidTy(ctx_);
Int1Ty = Type::getInt1Ty(ctx_);
Int8Ty = Type::getInt8Ty(ctx_);
Int16Ty = Type::getInt16Ty(ctx_);
Int32Ty = Type::getInt32Ty(ctx_);
Int64Ty = Type::getInt64Ty(ctx_);
#ifdef IS_X8664
IntPtrTy = Int64Ty;
#else
IntPtrTy = Int32Ty;
#endif
VoidPtrTy = llvm::PointerType::getUnqual(Int8Ty);
FloatTy = Type::getFloatTy(ctx_);
DoubleTy = Type::getDoubleTy(ctx_);
Int8PtrTy = llvm::PointerType::getUnqual(Int8Ty);
Zero = llvm::ConstantInt::get(Int32Ty, 0);
One = llvm::ConstantInt::get(Int32Ty, 1);
module_ = new llvm::Module("rubinius", ctx_);
autogen_types::makeLLVMModuleContents(module_);
llvm::EngineBuilder factory(module_);
factory.setAllocateGVsWithCode(false);
memory_ = new jit::RubiniusRequestJITMemoryManager(ls->memory());
factory.setJITMemoryManager(memory_);
#if RBX_LLVM_API_VER > 300
llvm::TargetOptions opts;
opts.NoFramePointerElim = true;
opts.NoFramePointerElimNonLeaf = true;
factory.setTargetOptions(opts);
#endif
engine_ = factory.create();
if(ls_->jit_event_listener()) {
engine_->RegisterJITEventListener(ls_->jit_event_listener());
}
builder_ = new llvm::PassManagerBuilder();
builder_->OptLevel = 2;
passes_ = new llvm::FunctionPassManager(module_);
#if RBX_LLVM_API_VER >= 302
module_->setDataLayout(engine_->getDataLayout()->getStringRepresentation());
passes_->add(new llvm::DataLayout(*engine_->getDataLayout()));
#else
module_->setDataLayout(engine_->getTargetData()->getStringRepresentation());
passes_->add(new llvm::TargetData(*engine_->getTargetData()));
#endif
builder_->populateFunctionPassManager(*passes_);
// Eliminate unnecessary alloca.
passes_->add(createPromoteMemoryToRegisterPass());
// Do simple "peephole" optimizations and bit-twiddling optzns.
passes_->add(createInstructionCombiningPass());
// Reassociate expressions.
passes_->add(createReassociatePass());
// Eliminate Common SubExpressions.
passes_->add(createGVNPass());
passes_->add(createDeadStoreEliminationPass());
passes_->add(createInstructionCombiningPass());
// Simplify the control flow graph (deleting unreachable blocks, etc).
passes_->add(createCFGSimplificationPass());
passes_->add(create_rubinius_alias_analysis());
passes_->add(createGVNPass());
// passes_->add(createCFGSimplificationPass());
passes_->add(createDeadStoreEliminationPass());
// passes_->add(createVerifierPass());
passes_->add(createScalarReplAggregatesPass());
passes_->add(create_overflow_folding_pass());
passes_->add(create_guard_eliminator_pass());
passes_->add(createCFGSimplificationPass());
passes_->add(createInstructionCombiningPass());
passes_->add(createScalarReplAggregatesPass());
passes_->add(createDeadStoreEliminationPass());
passes_->add(createCFGSimplificationPass());
passes_->add(createInstructionCombiningPass());
passes_->doInitialization();
ObjTy = ptr_type("Object");
profiling_ = new GlobalVariable(
*module_, Int1Ty, false,
GlobalVariable::ExternalLinkage,
0, "profiling_flag");
metadata_id_ = ctx_.getMDKindID("rbx-classid");
}
bool CompiledCondition::compile(){
InitializeNativeTarget();
// Assume we're on main thread...
LLVMContext &context = getGlobalContext();
// Initialize module
Module* module = new Module("Compiled function", context);
// Create exection engine
ExecutionEngine* engine = EngineBuilder(module).create();
/********** Generate code **********/
//Get a type for representing an integer pointer
//Maybe this should be unsigned integer pointer type...
PointerType* integerPointerType = PointerType::get(IntegerType::get(module->getContext(), 32), 0);
//Create function type, for our function, int*, int* -> bool
vector<const Type*> paramType;
paramType.push_back(integerPointerType);
paramType.push_back(integerPointerType);
FunctionType* functionType = FunctionType::get(IntegerType::get(module->getContext(), 8), paramType, false);
//Declare new function
Function* function = Function::Create(functionType, GlobalValue::ExternalLinkage, "evaluate", module);
//Use C calling convention
function->setCallingConv(CallingConv::C); //TODO: Read documentation and reconsider this
//Get arguments from function
Function::arg_iterator args = function->arg_begin();
Value* marking = args++;
Value* valuation = args++;
marking->setName("marking");
valuation->setName("valuation");
//Create function block
BasicBlock* functionBlock = BasicBlock::Create(module->getContext(), "functionBlock", function, 0);
//Generate code
CodeGenerationContext codeGenContext(marking, valuation, functionBlock, context);
Value* result = _cond->codegen(codeGenContext);
//Zero extend the result, e.g. make it a 8 bit bool
CastInst* retval = new ZExtInst(result, IntegerType::get(module->getContext(), 8), "retval", functionBlock);
//Create a return instruction
ReturnInst::Create(module->getContext(), retval, functionBlock);
/********** Optimize and Compile **********/
// Create function pass manager, to optimize query
FunctionPassManager optimizer(module);
optimizer.add(new TargetData(*engine->getTargetData()));
optimizer.add(createBasicAliasAnalysisPass());
optimizer.add(createInstructionCombiningPass());
optimizer.add(createReassociatePass());
optimizer.add(createGVNPass());
optimizer.add(createCFGSimplificationPass());
optimizer.doInitialization();
// Verify function, errors written to stderr
if(verifyFunction(*function))
return false;
// Optimize function
optimizer.run(*function);
// Compile the function
_nativeFunction = (bool(*)(const MarkVal*, const VarVal*))engine->getPointerToFunction(function);
return _nativeFunction != NULL;
}
/// adopted from: llvm-2.9/include/llvm/Support/StandardPasses.h
void optimizeFunction(Function* f, const bool disableLICM, const bool disableLoopRotate) {
assert (f);
assert (f->getParent());
Module* mod = f->getParent();
TargetData* targetData = new TargetData(mod);
const unsigned OptimizationLevel = 3;
const bool OptimizeSize = false;
const bool UnitAtATime = true;
const bool UnrollLoops = true;
const bool SimplifyLibCalls = true;
const bool HaveExceptions = false;
Pass* InliningPass = createFunctionInliningPass(275);
//PassManager Passes;
FunctionPassManager Passes(mod);
Passes.add(targetData);
//
// custom
//
Passes.add(createScalarReplAggregatesPass(-1, false));
//
// createStandardFunctionPasses
//
Passes.add(createCFGSimplificationPass());
Passes.add(createPromoteMemoryToRegisterPass());
Passes.add(createInstructionCombiningPass());
// Add TypeBasedAliasAnalysis before BasicAliasAnalysis so that
// BasicAliasAnalysis wins if they disagree. This is intended to help
// support "obvious" type-punning idioms.
Passes.add(createTypeBasedAliasAnalysisPass());
Passes.add(createBasicAliasAnalysisPass());
// Start of function pass.
// Break up aggregate allocas, using SSAUpdater.
Passes.add(createScalarReplAggregatesPass(-1, false));
Passes.add(createEarlyCSEPass()); // Catch trivial redundancies
if (SimplifyLibCalls)
Passes.add(createSimplifyLibCallsPass()); // Library Call Optimizations
Passes.add(createJumpThreadingPass()); // Thread jumps.
Passes.add(createCorrelatedValuePropagationPass()); // Propagate conditionals
Passes.add(createCFGSimplificationPass()); // Merge & remove BBs
Passes.add(createInstructionCombiningPass()); // Combine silly seq's
Passes.add(createTailCallEliminationPass()); // Eliminate tail calls
Passes.add(createCFGSimplificationPass()); // Merge & remove BBs
Passes.add(createReassociatePass()); // Reassociate expressions
if (!disableLoopRotate) Passes.add(createLoopRotatePass()); // Rotate Loop // makes packetized Mandelbrot fail
if (!disableLICM) Passes.add(createLICMPass()); // Hoist loop invariants // makes scalar driver crash after optimization
//Passes.add(createLoopUnswitchPass(OptimizeSize || OptimizationLevel < 3)); // breaks DCT with UNIFORM_ANALYSIS=0
Passes.add(createInstructionCombiningPass());
Passes.add(createIndVarSimplifyPass()); // Canonicalize indvars
Passes.add(createLoopIdiomPass()); // Recognize idioms like memset.
Passes.add(createLoopDeletionPass()); // Delete dead loops
if (UnrollLoops)
Passes.add(createLoopUnrollPass()); // Unroll small loops
Passes.add(createInstructionCombiningPass()); // Clean up after the unroller
if (OptimizationLevel > 1)
Passes.add(createGVNPass()); // Remove redundancies
Passes.add(createMemCpyOptPass()); // Remove memcpy / form memset
Passes.add(createSCCPPass()); // Constant prop with SCCP
// Run instcombine after redundancy elimination to exploit opportunities
// opened up by them.
Passes.add(createInstructionCombiningPass());
Passes.add(createJumpThreadingPass()); // Thread jumps
Passes.add(createCorrelatedValuePropagationPass());
Passes.add(createDeadStoreEliminationPass()); // Delete dead stores
Passes.add(createAggressiveDCEPass()); // Delete dead instructions
Passes.add(createCFGSimplificationPass()); // Merge & remove BBs
WFVOPENCL_DEBUG( Passes.add(createVerifierPass()); );
/// initialize_module - perform setup of the LLVM code generation system.
void BrainFTraceRecorder::initialize_module() {
LLVMContext &Context = module->getContext();
// Initialize the code generator, and enable aggressive code generation.
InitializeNativeTarget();
EngineBuilder builder(module);
builder.setOptLevel(CodeGenOpt::Aggressive);
EE = builder.create();
// Create a FunctionPassManager to handle running optimization passes
// on our generated code. Setup a basic suite of optimizations for it.
FPM = new llvm::FunctionPassManager(module);
FPM->add(createInstructionCombiningPass());
FPM->add(createCFGSimplificationPass());
FPM->add(createScalarReplAggregatesPass());
FPM->add(createSimplifyLibCallsPass());
FPM->add(createInstructionCombiningPass());
FPM->add(createJumpThreadingPass());
FPM->add(createCFGSimplificationPass());
FPM->add(createInstructionCombiningPass());
FPM->add(createCFGSimplificationPass());
FPM->add(createReassociatePass());
FPM->add(createLoopRotatePass());
FPM->add(createLICMPass());
FPM->add(createLoopUnswitchPass(false));
FPM->add(createInstructionCombiningPass());
FPM->add(createIndVarSimplifyPass());
FPM->add(createLoopDeletionPass());
FPM->add(createLoopUnrollPass());
FPM->add(createInstructionCombiningPass());
FPM->add(createGVNPass());
FPM->add(createSCCPPass());
FPM->add(createInstructionCombiningPass());
FPM->add(createJumpThreadingPass());
FPM->add(createDeadStoreEliminationPass());
FPM->add(createAggressiveDCEPass());
FPM->add(createCFGSimplificationPass());
// Cache the LLVM type signature of an opcode function
int_type = sizeof(size_t) == 4 ?
IntegerType::getInt32Ty(Context) :
IntegerType::getInt64Ty(Context);
const Type *data_type =
PointerType::getUnqual(IntegerType::getInt8Ty(Context));
std::vector<const Type*> args;
args.push_back(int_type);
args.push_back(data_type);
op_type =
FunctionType::get(Type::getVoidTy(Context), args, false);
// Setup a global variable in the LLVM module to represent the bytecode
// array. Bind it to the actual bytecode array at JIT time.
const Type *bytecode_type = PointerType::getUnqual(op_type);
bytecode_array = cast<GlobalValue>(module->
getOrInsertGlobal("BytecodeArray", bytecode_type));
EE->addGlobalMapping(bytecode_array, BytecodeArray);
// Setup a similar mapping for the global mode flag.
const IntegerType *flag_type = IntegerType::get(Context, 8);
mode_flag =
cast<GlobalValue>(module->getOrInsertGlobal("mode", flag_type));
EE->addGlobalMapping(mode_flag, &mode);
// Setup a similar mapping for the global extension root flag.
ext_root =
cast<GlobalValue>(module->getOrInsertGlobal("ext_root", int_type));
EE->addGlobalMapping(ext_root, &extension_root);
// Setup a similar mapping for the global extension leaf flag.
ext_leaf =
cast<GlobalValue>(module->getOrInsertGlobal("ext_leaf", int_type));
EE->addGlobalMapping(ext_leaf, &extension_leaf);
// Cache LLVM declarations for putchar() and getchar().
const Type *int_type = sizeof(int) == 4 ? IntegerType::getInt32Ty(Context)
: IntegerType::getInt64Ty(Context);
putchar_func =
module->getOrInsertFunction("putchar", int_type, int_type, NULL);
getchar_func = module->getOrInsertFunction("getchar", int_type, NULL);
}
static void createOptimizationPasses() {
// Create and set up the per-function pass manager.
// FIXME: Move the code generator to be function-at-a-time.
PerFunctionPasses =
new FunctionPassManager(new ExistingModuleProvider(TheModule));
PerFunctionPasses->add(new TargetData(*TheTarget->getTargetData()));
// In -O0 if checking is disabled, we don't even have per-function passes.
bool HasPerFunctionPasses = false;
#ifdef ENABLE_CHECKING
PerFunctionPasses->add(createVerifierPass());
HasPerFunctionPasses = true;
#endif
if (optimize > 0 && !DisableLLVMOptimizations) {
HasPerFunctionPasses = true;
PerFunctionPasses->add(createCFGSimplificationPass());
if (optimize == 1)
PerFunctionPasses->add(createPromoteMemoryToRegisterPass());
else
PerFunctionPasses->add(createScalarReplAggregatesPass());
PerFunctionPasses->add(createInstructionCombiningPass());
// PerFunctionPasses->add(createCFGSimplificationPass());
}
// FIXME: AT -O0/O1, we should stream out functions at a time.
PerModulePasses = new PassManager();
PerModulePasses->add(new TargetData(*TheTarget->getTargetData()));
bool HasPerModulePasses = false;
if (optimize > 0 && !DisableLLVMOptimizations) {
HasPerModulePasses = true;
PassManager *PM = PerModulePasses;
if (flag_unit_at_a_time)
PM->add(createRaiseAllocationsPass()); // call %malloc -> malloc inst
PM->add(createCFGSimplificationPass()); // Clean up disgusting code
PM->add(createPromoteMemoryToRegisterPass()); // Kill useless allocas
if (flag_unit_at_a_time) {
PM->add(createGlobalOptimizerPass()); // Optimize out global vars
PM->add(createGlobalDCEPass()); // Remove unused fns and globs
PM->add(createIPConstantPropagationPass()); // IP Constant Propagation
PM->add(createDeadArgEliminationPass()); // Dead argument elimination
}
PM->add(createInstructionCombiningPass()); // Clean up after IPCP & DAE
// DISABLE PREDSIMPLIFY UNTIL PR967 is fixed.
//PM->add(createPredicateSimplifierPass()); // Canonicalize registers
PM->add(createCFGSimplificationPass()); // Clean up after IPCP & DAE
if (flag_unit_at_a_time)
PM->add(createPruneEHPass()); // Remove dead EH info
if (optimize > 1) {
if (flag_inline_trees > 1) // respect -fno-inline-functions
PM->add(createFunctionInliningPass()); // Inline small functions
if (flag_unit_at_a_time && !lang_hooks.flag_no_builtin())
PM->add(createSimplifyLibCallsPass()); // Library Call Optimizations
if (optimize > 2)
PM->add(createArgumentPromotionPass()); // Scalarize uninlined fn args
}
PM->add(createTailDuplicationPass()); // Simplify cfg by copying code
PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
PM->add(createCFGSimplificationPass()); // Merge & remove BBs
PM->add(createScalarReplAggregatesPass()); // Break up aggregate allocas
PM->add(createInstructionCombiningPass()); // Combine silly seq's
PM->add(createCondPropagationPass()); // Propagate conditionals
PM->add(createTailCallEliminationPass()); // Eliminate tail calls
PM->add(createCFGSimplificationPass()); // Merge & remove BBs
PM->add(createReassociatePass()); // Reassociate expressions
PM->add(createLoopRotatePass()); // Rotate Loop
PM->add(createLICMPass()); // Hoist loop invariants
PM->add(createLoopUnswitchPass(optimize_size ? true : false));
PM->add(createInstructionCombiningPass()); // Clean up after LICM/reassoc
PM->add(createIndVarSimplifyPass()); // Canonicalize indvars
if (flag_unroll_loops)
PM->add(createLoopUnrollPass()); // Unroll small loops
PM->add(createInstructionCombiningPass()); // Clean up after the unroller
PM->add(createLoadValueNumberingPass()); // GVN for load instructions
PM->add(createGCSEPass()); // Remove common subexprs
PM->add(createSCCPPass()); // Constant prop with SCCP
// Run instcombine after redundancy elimination to exploit opportunities
// opened up by them.
PM->add(createInstructionCombiningPass());
PM->add(createCondPropagationPass()); // Propagate conditionals
PM->add(createDeadStoreEliminationPass()); // Delete dead stores
PM->add(createAggressiveDCEPass()); // SSA based 'Aggressive DCE'
PM->add(createCFGSimplificationPass()); // Merge & remove BBs
if (optimize > 1 && flag_unit_at_a_time)
PM->add(createConstantMergePass()); // Merge dup global constants
PM->add(createStripDeadPrototypesPass()); // Get rid of dead prototypes
}
if (emit_llvm_bc) {
// Emit an LLVM .bc file to the output. This is used when passed
// -emit-llvm -c to the GCC driver.
PerModulePasses->add(CreateBitcodeWriterPass(*AsmOutStream));
// Disable emission of .ident into the output file... which is completely
// wrong for llvm/.bc emission cases.
flag_no_ident = 1;
HasPerModulePasses = true;
} else if (emit_llvm) {
// Emit an LLVM .ll file to the output. This is used when passed
// -emit-llvm -S to the GCC driver.
PerModulePasses->add(new PrintModulePass(AsmOutFile));
// Disable emission of .ident into the output file... which is completely
// wrong for llvm/.bc emission cases.
flag_no_ident = 1;
HasPerModulePasses = true;
} else {
FunctionPassManager *PM;
// If there are passes we have to run on the entire module, we do codegen
// as a separate "pass" after that happens.
// FIXME: This is disabled right now until bugs can be worked out. Reenable
// this for fast -O0 compiles!
if (HasPerModulePasses || 1) {
CodeGenPasses = PM =
new FunctionPassManager(new ExistingModuleProvider(TheModule));
PM->add(new TargetData(*TheTarget->getTargetData()));
} else {
// If there are no module-level passes that have to be run, we codegen as
// each function is parsed.
PM = PerFunctionPasses;
HasPerFunctionPasses = true;
}
// Normal mode, emit a .s file by running the code generator.
switch (TheTarget->addPassesToEmitFile(*PM, *AsmOutStream,
TargetMachine::AssemblyFile,
/*FAST*/optimize == 0)) {
default:
case FileModel::Error:
cerr << "Error interfacing to target machine!\n";
exit(1);
case FileModel::AsmFile:
break;
}
if (TheTarget->addPassesToEmitFileFinish(*PM, 0, /*Fast*/optimize == 0)) {
cerr << "Error interfacing to target machine!\n";
exit(1);
}
}
if (HasPerFunctionPasses) {
PerFunctionPasses->doInitialization();
} else {
delete PerFunctionPasses;
PerFunctionPasses = 0;
}
if (!HasPerModulePasses) {
delete PerModulePasses;
PerModulePasses = 0;
}
}
/// Optimize - Perform link time optimizations. This will run the scalar
/// optimizations, any loaded plugin-optimization modules, and then the
/// inter-procedural optimizations if applicable.
void Optimize(Module *M, const std::string &EntryPoint) {
// Instantiate the pass manager to organize the passes.
PassManager Passes;
// If we're verifying, start off with a verification pass.
if (VerifyEach)
Passes.add(createVerifierPass());
#if LLVM_VERSION_CODE <= LLVM_VERSION(3, 1)
// Add an appropriate TargetData instance for this module...
addPass(Passes, new TargetData(M));
#elif LLVM_VERSION_CODE < LLVM_VERSION(3, 5)
// Add an appropriate DataLayout instance for this module...
addPass(Passes, new DataLayout(M));
#else
// Add an appropriate DataLayout instance for this module...
addPass(Passes, new DataLayoutPass(M));
#endif
// DWD - Run the opt standard pass list as well.
AddStandardCompilePasses(Passes);
if (!DisableOptimizations) {
// Now that composite has been compiled, scan through the module, looking
// for a main function. If main is defined, mark all other functions
// internal.
if (!DisableInternalize) {
#if LLVM_VERSION_CODE >= LLVM_VERSION(3, 2)
ModulePass *pass = createInternalizePass(
std::vector<const char *>(1, EntryPoint.c_str()));
#else
ModulePass *pass = createInternalizePass(true);
#endif
addPass(Passes, pass);
}
// Propagate constants at call sites into the functions they call. This
// opens opportunities for globalopt (and inlining) by substituting function
// pointers passed as arguments to direct uses of functions.
addPass(Passes, createIPSCCPPass());
// Now that we internalized some globals, see if we can hack on them!
addPass(Passes, createGlobalOptimizerPass());
// Linking modules together can lead to duplicated global constants, only
// keep one copy of each constant...
addPass(Passes, createConstantMergePass());
// Remove unused arguments from functions...
addPass(Passes, createDeadArgEliminationPass());
// Reduce the code after globalopt and ipsccp. Both can open up significant
// simplification opportunities, and both can propagate functions through
// function pointers. When this happens, we often have to resolve varargs
// calls, etc, so let instcombine do this.
addPass(Passes, createInstructionCombiningPass());
if (!DisableInline)
addPass(Passes, createFunctionInliningPass()); // Inline small functions
addPass(Passes, createPruneEHPass()); // Remove dead EH info
addPass(Passes, createGlobalOptimizerPass()); // Optimize globals again.
addPass(Passes, createGlobalDCEPass()); // Remove dead functions
// If we didn't decide to inline a function, check to see if we can
// transform it to pass arguments by value instead of by reference.
addPass(Passes, createArgumentPromotionPass());
// The IPO passes may leave cruft around. Clean up after them.
addPass(Passes, createInstructionCombiningPass());
addPass(Passes, createJumpThreadingPass()); // Thread jumps.
addPass(Passes, createScalarReplAggregatesPass()); // Break up allocas
// Run a few AA driven optimizations here and now, to cleanup the code.
addPass(Passes, createFunctionAttrsPass()); // Add nocapture
addPass(Passes, createGlobalsModRefPass()); // IP alias analysis
addPass(Passes, createLICMPass()); // Hoist loop invariants
addPass(Passes, createGVNPass()); // Remove redundancies
addPass(Passes, createMemCpyOptPass()); // Remove dead memcpy's
addPass(Passes, createDeadStoreEliminationPass()); // Nuke dead stores
// Cleanup and simplify the code after the scalar optimizations.
addPass(Passes, createInstructionCombiningPass());
addPass(Passes, createJumpThreadingPass()); // Thread jumps.
addPass(Passes, createPromoteMemoryToRegisterPass()); // Cleanup jumpthread.
// Delete basic blocks, which optimization passes may have killed...
addPass(Passes, createCFGSimplificationPass());
// Now that we have optimized the program, discard unreachable functions...
addPass(Passes, createGlobalDCEPass());
}
// If the -s or -S command line options were specified, strip the symbols out
// of the resulting program to make it smaller. -s and -S are GNU ld options
// that we are supporting; they alias -strip-all and -strip-debug.
if (Strip || StripDebug)
addPass(Passes, createStripSymbolsPass(StripDebug && !Strip));
#if 0
// Create a new optimization pass for each one specified on the command line
std::auto_ptr<TargetMachine> target;
for (unsigned i = 0; i < OptimizationList.size(); ++i) {
const PassInfo *Opt = OptimizationList[i];
if (Opt->getNormalCtor())
addPass(Passes, Opt->getNormalCtor()());
else
llvm::errs() << "llvm-ld: cannot create pass: "******"\n";
}
#endif
// The user's passes may leave cruft around. Clean up after them them but
// only if we haven't got DisableOptimizations set
if (!DisableOptimizations) {
addPass(Passes, createInstructionCombiningPass());
addPass(Passes, createCFGSimplificationPass());
addPass(Passes, createAggressiveDCEPass());
addPass(Passes, createGlobalDCEPass());
}
// Make sure everything is still good.
if (!DontVerify)
Passes.add(createVerifierPass());
// Run our queue of passes all at once now, efficiently.
Passes.run(*M);
}
static void AddStandardCompilePasses(PassManager &PM) {
PM.add(createVerifierPass()); // Verify that input is correct
#if LLVM_VERSION_CODE < LLVM_VERSION(3, 0)
addPass(PM, createLowerSetJmpPass()); // Lower llvm.setjmp/.longjmp
#endif
// If the -strip-debug command line option was specified, do it.
if (StripDebug)
addPass(PM, createStripSymbolsPass(true));
if (DisableOptimizations) return;
addPass(PM, createCFGSimplificationPass()); // Clean up disgusting code
addPass(PM, createPromoteMemoryToRegisterPass());// Kill useless allocas
addPass(PM, createGlobalOptimizerPass()); // Optimize out global vars
addPass(PM, createGlobalDCEPass()); // Remove unused fns and globs
addPass(PM, createIPConstantPropagationPass());// IP Constant Propagation
addPass(PM, createDeadArgEliminationPass()); // Dead argument elimination
addPass(PM, createInstructionCombiningPass()); // Clean up after IPCP & DAE
addPass(PM, createCFGSimplificationPass()); // Clean up after IPCP & DAE
addPass(PM, createPruneEHPass()); // Remove dead EH info
addPass(PM, createFunctionAttrsPass()); // Deduce function attrs
if (!DisableInline)
addPass(PM, createFunctionInliningPass()); // Inline small functions
addPass(PM, createArgumentPromotionPass()); // Scalarize uninlined fn args
#if LLVM_VERSION_CODE < LLVM_VERSION(3, 4)
addPass(PM, createSimplifyLibCallsPass()); // Library Call Optimizations
#endif
addPass(PM, createInstructionCombiningPass()); // Cleanup for scalarrepl.
addPass(PM, createJumpThreadingPass()); // Thread jumps.
addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs
addPass(PM, createScalarReplAggregatesPass()); // Break up aggregate allocas
addPass(PM, createInstructionCombiningPass()); // Combine silly seq's
addPass(PM, createTailCallEliminationPass()); // Eliminate tail calls
addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs
addPass(PM, createReassociatePass()); // Reassociate expressions
addPass(PM, createLoopRotatePass());
addPass(PM, createLICMPass()); // Hoist loop invariants
addPass(PM, createLoopUnswitchPass()); // Unswitch loops.
// FIXME : Removing instcombine causes nestedloop regression.
addPass(PM, createInstructionCombiningPass());
addPass(PM, createIndVarSimplifyPass()); // Canonicalize indvars
addPass(PM, createLoopDeletionPass()); // Delete dead loops
addPass(PM, createLoopUnrollPass()); // Unroll small loops
addPass(PM, createInstructionCombiningPass()); // Clean up after the unroller
addPass(PM, createGVNPass()); // Remove redundancies
addPass(PM, createMemCpyOptPass()); // Remove memcpy / form memset
addPass(PM, createSCCPPass()); // Constant prop with SCCP
// Run instcombine after redundancy elimination to exploit opportunities
// opened up by them.
addPass(PM, createInstructionCombiningPass());
addPass(PM, createDeadStoreEliminationPass()); // Delete dead stores
addPass(PM, createAggressiveDCEPass()); // Delete dead instructions
addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs
addPass(PM, createStripDeadPrototypesPass()); // Get rid of dead prototypes
#if LLVM_VERSION_CODE < LLVM_VERSION(3, 0)
addPass(PM, createDeadTypeEliminationPass()); // Eliminate dead types
#endif
addPass(PM, createConstantMergePass()); // Merge dup global constants
}
Function * futamurize( const Function * orig_func, DenseMap<const Value*, Value*> &argmap, std::set<const unsigned char *> &constant_addresses_set )
{
LLVMContext &context = getGlobalContext();
// Make a copy of the function, removing constant arguments
Function * specialized_func = CloneFunction( orig_func, argmap );
specialized_func->setName( orig_func->getNameStr() + "_1" );
// add it to our module
LLVM_Module->getFunctionList().push_back( specialized_func );
printf("\nspecialized_func = %p <%s>\n", specialized_func, specialized_func->getName().data());
//~ specialized_func->dump();
// Optimize it
FunctionPassManager PM( LLVM_Module );
createStandardFunctionPasses( &PM, 3 );
PM.add(createScalarReplAggregatesPass()); // Break up aggregate allocas
PM.add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
PM.add(createJumpThreadingPass()); // Thread jumps.
PM.add(createCFGSimplificationPass()); // Merge & remove BBs
PM.add(createInstructionCombiningPass()); // Combine silly seq's
PM.add(createTailCallEliminationPass()); // Eliminate tail calls
PM.add(createCFGSimplificationPass()); // Merge & remove BBs
PM.add(createReassociatePass()); // Reassociate expressions
PM.add(createLoopRotatePass()); // Rotate Loop
PM.add(createLICMPass()); // Hoist loop invariants
PM.add(createLoopUnswitchPass( false ));
PM.add(createInstructionCombiningPass());
PM.add(createIndVarSimplifyPass()); // Canonicalize indvars
PM.add(createLoopDeletionPass()); // Delete dead loops
PM.add(createLoopUnroll2Pass()); // Unroll small loops
PM.add(createInstructionCombiningPass()); // Clean up after the unroller
PM.add(createGVNPass()); // Remove redundancies
PM.add(createMemCpyOptPass()); // Remove memcpy / form memset
PM.add(createSCCPPass()); // Constant prop with SCCP
PM.add(createPromoteMemoryToRegisterPass());
PM.add(createConstantPropagationPass());
PM.add(createDeadStoreEliminationPass());
PM.add(createAggressiveDCEPass());
PM.add(new MemoryDependenceAnalysis());
//~ PM.add(createAAEvalPass());
const PassInfo * pinfo = Pass::lookupPassInfo( "print-alias-sets" );
if( !pinfo ) { printf( "print-alias-sets not found\n" ); exit(-1); }
PM.add( pinfo->createPass() );
FunctionPassManager PM_Inline( LLVM_Module );
PM_Inline.add(createSingleFunctionInliningPass());
bool Changed = false;
int iterations = 2;
int inline_iterations = 6;
do
{
Changed = false;
// first do some optimizations
PM.doInitialization();
PM.run( *specialized_func );
PM.doFinalization();
// Load from Constant Memory detection
const TargetData *TD = LLVM_EE->getTargetData();
for (inst_iterator I = inst_begin(specialized_func), E = inst_end(specialized_func); I != E; ++I)
{
Instruction * inst = (Instruction *) &*I;
// get all Load instructions
LoadInst * load = dyn_cast<LoadInst>( inst );
if( !load ) continue;
if( load->isVolatile() ) continue;
if (load->use_empty()) continue; // Don't muck with dead instructions...
// get the address loaded by load instruction
Value *ptr_value = load->getPointerOperand();
// we're only interested in constant addresses
ConstantExpr * ptr_constant_expr = dyn_cast<ConstantExpr>( ptr_value );
if( !ptr_constant_expr ) continue;
ptr_constant_expr->dump();
// compute real address of constant pointer expression
Constant * ptr_constant = ConstantFoldConstantExpression( ptr_constant_expr, TD );
if( !ptr_constant ) continue;
ptr_constant->dump();
// convert to int constant
ConstantInt *int_constant = dyn_cast<ConstantInt>( ConstantExpr::getPtrToInt( ptr_constant, Type::getInt64Ty( context )));
if( !int_constant ) continue;
int_constant->dump();
// get data size
int data_length = TD->getTypeAllocSize( load->getType() );
ptr_value->getType()->dump();
// get real address (at last !)
const unsigned char * c_ptr = (const unsigned char *) int_constant->getLimitedValue();
printf( "%ld %d %d\n", c_ptr, constant_addresses_set.count( c_ptr ), data_length );
// check what's in this address
int isconst = 1;
for( int offset=0; offset<data_length; offset++ )
isconst &= constant_addresses_set.count( c_ptr + offset );
if( !isconst ) continue;
printf( "It is constant.\n" );
// make a LLVM const with the data
Constant *new_constant = NULL;
switch( data_length )
{
case 1: new_constant = ConstantInt::get( Type::getInt8Ty( context ), *(uint8_t*)c_ptr, false /* signed */ ); break;
case 2: new_constant = ConstantInt::get( Type::getInt16Ty( context ), *(uint16_t*)c_ptr, false /* signed */ ); break;
case 4: new_constant = ConstantInt::get( Type::getInt32Ty( context ), *(uint32_t*)c_ptr, false /* signed */ ); break;
case 8: new_constant = ConstantInt::get( Type::getInt64Ty( context ), *(uint64_t*)c_ptr, false /* signed */ ); break;
default:
{
StringRef const_data ( (const char *) c_ptr, data_length );
new_constant = ConstantArray::get( context, const_data, false /* dont add terminating null */ );
}
}
if( !new_constant ) continue;
new_constant->dump();
//~ // get the type that is loaded
const Type *Ty = load->getType();
// do we need a cast ?
if( load->getType() != new_constant->getType() )
{
new_constant = ConstantExpr::getBitCast( new_constant, Ty );
new_constant->dump();
}
// zap the load and replace with constant address
load->replaceAllUsesWith( new_constant );
printf( "\nREPLACED :...\n" );
load->dump();
new_constant->dump();
Changed = true;
}
if( Changed )
continue; // re-optimize and do another pass of constant load elimination
// if we can't do anything else, do an inlining pass
if( inline_iterations > 0 )
{
inline_iterations --;
PM_Inline.doInitialization();
Changed |= PM_Inline.run( *specialized_func );
PM_Inline.doFinalization();
//~ for( int i=0; i<3; i++ )
{
PM.doInitialization();
Changed |= PM.run( *specialized_func );
PM.doFinalization();
}
}
if( iterations>0 && !Changed )
iterations--;
} while( Changed || iterations>0 );
return specialized_func;
}
