894 lines
30 KiB
C++
894 lines
30 KiB
C++
#include "JIT_Compiler.hh"
|
|
#include <unistd.h>
|
|
#include <sys/wait.h>
|
|
#include <fcntl.h>
|
|
#include <memory>
|
|
|
|
using namespace std;
|
|
|
|
#define FREE_ALLOCATED() \
|
|
free(buffer); \
|
|
free(p->y_u.jhc.jh->cmd); \
|
|
free(outputfilename); \
|
|
free(optoutputfilename); \
|
|
free(cmd1); \
|
|
free(cmd2);
|
|
|
|
#define ADD_PASS_ACCORDING_TO_KIND() \
|
|
switch (Kind) { \
|
|
case PT_BasicBlock: \
|
|
fprintf(stderr, "Oops -- basicblock printer\n"); \
|
|
exit(1); \
|
|
case PT_Region: \
|
|
Pass.add(new RegionPassPrinter(PI)); \
|
|
break; \
|
|
case PT_Loop: \
|
|
Pass.add(new LoopPassPrinter(PI)); \
|
|
break; \
|
|
case PT_Function: \
|
|
Pass.add(new FunctionPassPrinter(PI)); \
|
|
break; \
|
|
case PT_CallGraphSCC: \
|
|
Pass.add(new CallGraphSCCPassPrinter(PI)); \
|
|
break; \
|
|
default: \
|
|
Pass.add(new ModulePassPrinter(PI)); \
|
|
break; \
|
|
}
|
|
|
|
#define TREAT_CASE_FOR(PASS) \
|
|
PI = PassRegistry::getPassRegistry()->getPassInfo(PASS->getPassID()); \
|
|
Kind = PASS->getPassKind(); \
|
|
ADD_PASS_ACCORDING_TO_KIND();
|
|
|
|
#include "PassPrinters.hh"
|
|
|
|
void JIT_Compiler::analyze_module(llvm::Module* &M)
|
|
{
|
|
PassManager Pass; // 'Pass' stores analysis passes to be applied
|
|
TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple()));
|
|
|
|
const PassInfo *PI;
|
|
PassKind Kind;
|
|
|
|
Pass.add(TLI); // First, I add on 'Pass' the Target Info of Module
|
|
Pass.add(new DataLayoutPass(M)); // Second, I must add Target Data on 'Pass'
|
|
for (int i = 0; i < ExpEnv.analysis_struc.n; i++) {
|
|
/*
|
|
* 'ExpEnv.analysis_struc.act_an' contains sorted analysis passes *
|
|
* 'ExpEnv.analysis_struc.act_an' is filled by analysis predicates *
|
|
* What must I do? *
|
|
* 1. Pass over 'ExpEnv.analysis_struc.act_an' (by previous 'for') *
|
|
* 2. For each unity within 'ExpEnv.analysis_struc.act_an' *
|
|
* 2.1. Check its type *
|
|
* 2.2. Add analysis pass on 'Pass' accordingly the type checked *
|
|
*/
|
|
switch (ExpEnv.analysis_struc.act_an[i]) {
|
|
case e_createAAEvalPass:
|
|
TREAT_CASE_FOR(createAAEvalPass());
|
|
break;
|
|
case e_createBasicAliasAnalysisPass:
|
|
TREAT_CASE_FOR(createBasicAliasAnalysisPass());
|
|
break;
|
|
case e_createAliasAnalysisCounterPass:
|
|
TREAT_CASE_FOR(createAliasAnalysisCounterPass());
|
|
break;
|
|
case e_createGlobalsModRefPass:
|
|
TREAT_CASE_FOR(createGlobalsModRefPass());
|
|
break;
|
|
case e_createInstCountPass:
|
|
TREAT_CASE_FOR(createInstCountPass());
|
|
break;
|
|
case e_createIVUsersPass:
|
|
TREAT_CASE_FOR(createIVUsersPass());
|
|
break;
|
|
case e_createLazyValueInfoPass:
|
|
TREAT_CASE_FOR(createLazyValueInfoPass());
|
|
break;
|
|
//CHANGED FOR LLVM 3.5
|
|
case e_createLoopDependenceAnalysisPass:
|
|
TREAT_CASE_FOR(createDependenceAnalysisPass());
|
|
break;
|
|
case e_createLibCallAliasAnalysisPass:
|
|
TREAT_CASE_FOR(createLibCallAliasAnalysisPass(NULL));
|
|
break;
|
|
case e_createLintPass:
|
|
TREAT_CASE_FOR(createLintPass());
|
|
break;
|
|
case e_createMemDepPrinter:
|
|
TREAT_CASE_FOR(createMemDepPrinter());
|
|
break;
|
|
case e_createModuleDebugInfoPrinterPass:
|
|
TREAT_CASE_FOR(createModuleDebugInfoPrinterPass());
|
|
break;
|
|
case e_createNoAAPass:
|
|
TREAT_CASE_FOR(createNoAAPass());
|
|
break;
|
|
//NOT IN LLVM 3.5
|
|
//case e_createNoPathProfileInfoPass:
|
|
// TREAT_CASE_FOR(createNoPathProfileInfoPass());
|
|
// break;
|
|
//NOT IN LLVM 3.5
|
|
//case e_createNoProfileInfoPass:
|
|
// TREAT_CASE_FOR(createNoProfileInfoPass());
|
|
// break;
|
|
case e_createObjCARCAliasAnalysisPass:
|
|
TREAT_CASE_FOR(createObjCARCAliasAnalysisPass());
|
|
break;
|
|
//NOT IN LLVM 3.5
|
|
//case e_createProfileEstimatorPass:
|
|
// TREAT_CASE_FOR(createProfileEstimatorPass());
|
|
// break;
|
|
//CHANGED FOR LLVM 3.5
|
|
case e_createProfileLoaderPass:
|
|
TREAT_CASE_FOR(createSampleProfileLoaderPass());
|
|
break;
|
|
//NOT IN LLVM 3.5
|
|
//case e_createProfileVerifierPass:
|
|
// TREAT_CASE_FOR(createProfileVerifierPass());
|
|
// break;
|
|
case e_createRegionInfoPass:
|
|
TREAT_CASE_FOR(createRegionInfoPass());
|
|
break;
|
|
case e_createScalarEvolutionAliasAnalysisPass:
|
|
TREAT_CASE_FOR(createScalarEvolutionAliasAnalysisPass());
|
|
break;
|
|
case e_createTypeBasedAliasAnalysisPass:
|
|
TREAT_CASE_FOR(createTypeBasedAliasAnalysisPass());
|
|
break;
|
|
//CHANGED FOR LLVM 3.5
|
|
case e_createDbgInfoPrinterPass:
|
|
TREAT_CASE_FOR(createDebugInfoVerifierPass());
|
|
break;
|
|
case e_createCFGPrinterPass:
|
|
TREAT_CASE_FOR(createCFGPrinterPass());
|
|
break;
|
|
case e_createCFGOnlyPrinterPass:
|
|
TREAT_CASE_FOR(createCFGOnlyPrinterPass());
|
|
break;
|
|
case e_createDomPrinterPass:
|
|
TREAT_CASE_FOR(createDomPrinterPass());
|
|
break;
|
|
case e_createDomOnlyPrinterPass:
|
|
TREAT_CASE_FOR(createDomOnlyPrinterPass());
|
|
break;
|
|
case e_createPostDomPrinterPass:
|
|
TREAT_CASE_FOR(createPostDomPrinterPass());
|
|
break;
|
|
case e_createPostDomOnlyPrinterPass:
|
|
TREAT_CASE_FOR(createPostDomOnlyPrinterPass());
|
|
break;
|
|
case e_createRegionPrinterPass:
|
|
TREAT_CASE_FOR(createRegionPrinterPass());
|
|
break;
|
|
case e_createRegionOnlyPrinterPass:
|
|
TREAT_CASE_FOR(createRegionOnlyPrinterPass());
|
|
break;
|
|
//NOT IN LLVM 3.5
|
|
//case e_createPathProfileLoaderPass:
|
|
// TREAT_CASE_FOR(createPathProfileLoaderPass());
|
|
// break;
|
|
//NOT IN LLVM 3.5
|
|
//case e_createPathProfileVerifierPass:
|
|
// TREAT_CASE_FOR(createPathProfileVerifierPass());
|
|
// break;
|
|
default:;
|
|
}
|
|
}
|
|
|
|
/* if 'llvm::TimePassesIsEnabled' is 'true', llvm time passes are printed on 'shutdown_llvm()' (p_halt -- stdpreds.c) */
|
|
llvm::TimePassesIsEnabled = ExpEnv.analysis_struc.time_pass_enabled;
|
|
/* Use 'llvm::EnableStatistics()' so that llvm stats are printed on 'shutdown_llvm()' (p_halt -- stdpreds.c) */
|
|
if (ExpEnv.analysis_struc.stats_enabled) llvm::EnableStatistics();
|
|
|
|
/*
|
|
* Here, I configure resulting analysis output -- default: stderr *
|
|
* Use analysis_output_file/1 to change *
|
|
*/
|
|
if (strcmp(((char*)ExpEnv.analysis_struc.outfile), "STDERR")) { // print to file that is not stderr
|
|
int stderrcopy = dup(2); // stderr backup
|
|
if (strcmp(((char*)ExpEnv.analysis_struc.outfile), "STDOUT") == 0) { // print to stdout
|
|
dup2(1, 2); // 2 is stderr; 1 is stdout -- dup2(1,2) redirects stderr output to stdout
|
|
Pass.run(*M); // Run passes (results will be printed on stdout)
|
|
dup2(stderrcopy, 2); // Recovers stderr
|
|
}
|
|
else {
|
|
int Outputfile = open(((char*)ExpEnv.analysis_struc.outfile), O_CREAT | O_TRUNC | O_WRONLY, 0777);
|
|
// Openning Output file, whose name is on 'ExpEnv.analysis_struc.outfile'
|
|
if (Outputfile < 0) {
|
|
fprintf(stderr, "Error:: I can not write analysis passes's output on %s...\n", ((char*)ExpEnv.analysis_struc.outfile));
|
|
fprintf(stderr, " %s...\n", strerror(errno));
|
|
errno = 0;
|
|
exit(1);
|
|
}
|
|
dup2(Outputfile, 2); // 2 is stderr; Outputfile is any other file -- dup2(Outputfile,2) redirects stderr output to Outputfile
|
|
Pass.run(*M); // Run passes (results will be printed on Outputfile)
|
|
close(Outputfile);
|
|
dup2(stderrcopy, 2); // Recovers stderr
|
|
}
|
|
close(stderrcopy);
|
|
}
|
|
else // print to stderr
|
|
Pass.run(*M); // Run passes (results will be printed on stderr)
|
|
}
|
|
|
|
void JIT_Compiler::optimize_module(llvm::Module* &M)
|
|
{
|
|
if (ExpEnv.transform_struc.optlevel > -1) { /* Do I need to apply transform level? */
|
|
/* Yes, I do, so... */
|
|
|
|
/* Initializes PassManager for Function */
|
|
std::shared_ptr<FunctionPassManager> FPM;
|
|
FPM.reset(new FunctionPassManager(M));
|
|
FPM->add(new DataLayoutPass(M));
|
|
PassManagerBuilder Builder; // aid to 'FPM' and 'MPM'
|
|
|
|
/* Initializes PassManager for Function */
|
|
PassManager MPM;
|
|
TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple()));
|
|
MPM.add(TLI);
|
|
MPM.add(new DataLayoutPass(M));
|
|
|
|
/* Populates 'Builder' */
|
|
Builder.OptLevel = ExpEnv.transform_struc.optlevel;
|
|
Builder.DisableUnitAtATime = !ExpEnv.transform_struc.unit_at_time_enabled;
|
|
//NOT IN LLVM 3.5
|
|
//Builder.DisableSimplifyLibCalls = !ExpEnv.transform_struc.simplify_libcalls_enabled;
|
|
/* inline and unrool only be enabled if 'ExpEnv.transform_struc.optlevel' > 0 */
|
|
if (ExpEnv.transform_struc.optlevel) Builder.Inliner =
|
|
createFunctionInliningPass(ExpEnv.transform_struc.opt_args.inline_threshold);
|
|
Builder.DisableUnrollLoops = (ExpEnv.transform_struc.optlevel == 0);
|
|
/***/
|
|
/***/
|
|
|
|
/* Populates 'FPM' from 'Builder' */
|
|
Builder.populateFunctionPassManager(*FPM);
|
|
/* Populates 'MPM' from 'Builder' */
|
|
Builder.populateModulePassManager(MPM);
|
|
|
|
/*
|
|
* Enabling link-time optimizations -- default is no *
|
|
* Use 'link_time_opt/1', 'link_time_opt/3', 'enable_link_time_opt/0', or 'enable_link_time_opt/2' to change *
|
|
*/
|
|
if (ExpEnv.transform_struc.link_time_opt.enabled)
|
|
Builder.populateLTOPassManager(MPM,
|
|
(bool)ExpEnv.transform_struc.link_time_opt.internalize,
|
|
(bool)ExpEnv.transform_struc.link_time_opt.runinliner);
|
|
/***/
|
|
|
|
//set_regalloc_pass(MPM);
|
|
|
|
/* Pass over all functions within Module and run passes */
|
|
FPM->doInitialization();
|
|
for (Module::iterator F = M->begin(), E = M->end(); F != E; ++F)
|
|
FPM->run(*F);
|
|
FPM->doFinalization();
|
|
/***/
|
|
|
|
MPM.run(*M); // Run passes on module
|
|
}
|
|
else {
|
|
/* No, I need to apply transform passes accordingly transform predicates but transform_level/1 */
|
|
std::vector<GlobalValue*> GVvector; // 'createGVExtractionPass' argument
|
|
PassManager Pass; // 'Pass' stores transform passes to be applied
|
|
TargetLibraryInfo *TLI = new TargetLibraryInfo(Triple(M->getTargetTriple()));
|
|
Pass.add(TLI); // First, I add on 'Pass' the Target Info of Module
|
|
Pass.add(new DataLayoutPass(M)); // Second, I must add Target Data on 'Pass'
|
|
for (int i = 0; i < ExpEnv.transform_struc.n; i++) {
|
|
/*
|
|
* 'ExpEnv.transform_struc.act_tr' contains sorted transform passes *
|
|
* 'ExpEnv.transform_struc.act_tr' is filled by transform predicates *
|
|
* What must I do? *
|
|
* 1. Pass over 'ExpEnv.transform_struc.act_tr' (by previous 'for') *
|
|
* 2. For each unity within 'ExpEnv.analysis_struc.act_an', add transform pass on 'Pass' *
|
|
*/
|
|
switch (ExpEnv.transform_struc.act_tr[i]) {
|
|
case t_createAggressiveDCEPass:
|
|
Pass.add(createAggressiveDCEPass());
|
|
break;
|
|
case t_createArgumentPromotionPass:
|
|
Pass.add(createArgumentPromotionPass((Int)ExpEnv.transform_struc.opt_args.arg_promotion_max_elements));
|
|
break;
|
|
case t_createBBVectorizePass:
|
|
Pass.add(createBBVectorizePass());
|
|
break;
|
|
case t_createBlockExtractorPass:
|
|
Pass.add(createBlockExtractorPass());
|
|
break;
|
|
//NOT IN LLVM 3.5
|
|
//case t_createBlockPlacementPass:
|
|
// Pass.add(createBlockPlacementPass());
|
|
// break;
|
|
case t_createBreakCriticalEdgesPass:
|
|
Pass.add(createBreakCriticalEdgesPass());
|
|
break;
|
|
case t_createCFGSimplificationPass:
|
|
Pass.add(createCFGSimplificationPass());
|
|
break;
|
|
case t_createCodeGenPreparePass:
|
|
Pass.add(createCodeGenPreparePass());
|
|
break;
|
|
case t_createConstantMergePass:
|
|
Pass.add(createConstantMergePass());
|
|
break;
|
|
case t_createConstantPropagationPass:
|
|
Pass.add(createConstantPropagationPass());
|
|
break;
|
|
case t_createCorrelatedValuePropagationPass:
|
|
Pass.add(createCorrelatedValuePropagationPass());
|
|
break;
|
|
case t_createDeadArgEliminationPass:
|
|
Pass.add(createDeadArgEliminationPass());
|
|
break;
|
|
case t_createDeadArgHackingPass:
|
|
Pass.add(createDeadArgHackingPass());
|
|
break;
|
|
case t_createDeadCodeEliminationPass:
|
|
Pass.add(createDeadCodeEliminationPass());
|
|
break;
|
|
case t_createDeadInstEliminationPass:
|
|
Pass.add(createDeadInstEliminationPass());
|
|
break;
|
|
case t_createDeadStoreEliminationPass:
|
|
Pass.add(createDeadStoreEliminationPass());
|
|
break;
|
|
case t_createDemoteRegisterToMemoryPass:
|
|
Pass.add(createDemoteRegisterToMemoryPass());
|
|
break;
|
|
case t_createEarlyCSEPass:
|
|
Pass.add(createEarlyCSEPass());
|
|
break;
|
|
case t_createFunctionAttrsPass:
|
|
Pass.add(createFunctionAttrsPass());
|
|
break;
|
|
case t_createFunctionInliningPass:
|
|
Pass.add(createFunctionInliningPass(ExpEnv.transform_struc.opt_args.inline_threshold));
|
|
break;
|
|
case t_createGlobalDCEPass:
|
|
Pass.add(createGlobalDCEPass());
|
|
break;
|
|
case t_createGlobalOptimizerPass:
|
|
Pass.add(createGlobalOptimizerPass());
|
|
break;
|
|
case t_createGVExtractionPass:
|
|
Pass.add(createGVExtractionPass(GVvector));
|
|
break;
|
|
case t_createGVNPass:
|
|
Pass.add(createGVNPass());
|
|
break;
|
|
case t_createIndVarSimplifyPass:
|
|
Pass.add(createIndVarSimplifyPass());
|
|
break;
|
|
case t_createInstructionCombiningPass:
|
|
Pass.add(createInstructionCombiningPass());
|
|
break;
|
|
case t_createInstructionNamerPass:
|
|
Pass.add(createInstructionNamerPass());
|
|
break;
|
|
case t_createInstructionSimplifierPass:
|
|
Pass.add(createInstructionSimplifierPass());
|
|
break;
|
|
case t_createInternalizePass:
|
|
Pass.add(createInternalizePass());
|
|
break;
|
|
case t_createIPConstantPropagationPass:
|
|
Pass.add(createIPConstantPropagationPass());
|
|
break;
|
|
case t_createIPSCCPPass:
|
|
Pass.add(createIPSCCPPass());
|
|
break;
|
|
case t_createJumpThreadingPass:
|
|
Pass.add(createJumpThreadingPass());
|
|
break;
|
|
case t_createLCSSAPass:
|
|
Pass.add(createLCSSAPass());
|
|
break;
|
|
case t_createLICMPass:
|
|
Pass.add(createLICMPass());
|
|
break;
|
|
case t_createLoopDeletionPass:
|
|
Pass.add(createLoopDeletionPass());
|
|
break;
|
|
case t_createLoopExtractorPass:
|
|
Pass.add(createLoopExtractorPass());
|
|
break;
|
|
case t_createLoopIdiomPass:
|
|
Pass.add(createLoopIdiomPass());
|
|
break;
|
|
case t_createLoopInstSimplifyPass:
|
|
Pass.add(createLoopInstSimplifyPass());
|
|
break;
|
|
case t_createLoopRotatePass:
|
|
Pass.add(createLoopRotatePass());
|
|
break;
|
|
case t_createLoopSimplifyPass:
|
|
Pass.add(createLoopSimplifyPass());
|
|
break;
|
|
case t_createLoopStrengthReducePass:
|
|
Pass.add(createLoopStrengthReducePass());
|
|
break;
|
|
case t_createLoopUnrollPass:
|
|
Pass.add(createLoopUnrollPass((Int)ExpEnv.transform_struc.opt_args.loop_unroll_threshold));
|
|
break;
|
|
case t_createLoopUnswitchPass:
|
|
Pass.add(createLoopUnswitchPass((bool)ExpEnv.transform_struc.opt_args.loop_unswitch_optimize_for_size));
|
|
break;
|
|
case t_createLowerAtomicPass:
|
|
Pass.add(createLowerAtomicPass());
|
|
break;
|
|
case t_createLowerExpectIntrinsicPass:
|
|
Pass.add(createLowerExpectIntrinsicPass());
|
|
break;
|
|
case t_createLowerInvokePass:
|
|
Pass.add(createLowerInvokePass());
|
|
break;
|
|
case t_createLowerSwitchPass:
|
|
Pass.add(createLowerSwitchPass());
|
|
break;
|
|
case t_createMemCpyOptPass:
|
|
Pass.add(createMemCpyOptPass());
|
|
break;
|
|
case t_createMergeFunctionsPass:
|
|
Pass.add(createMergeFunctionsPass());
|
|
break;
|
|
case t_createObjCARCAPElimPass:
|
|
Pass.add(createObjCARCAPElimPass());
|
|
break;
|
|
case t_createObjCARCContractPass:
|
|
Pass.add(createObjCARCContractPass());
|
|
break;
|
|
case t_createObjCARCExpandPass:
|
|
Pass.add(createObjCARCExpandPass());
|
|
break;
|
|
case t_createObjCARCOptPass:
|
|
Pass.add(createObjCARCOptPass());
|
|
break;
|
|
case t_createPartialInliningPass:
|
|
Pass.add(createPartialInliningPass());
|
|
break;
|
|
case t_createPromoteMemoryToRegisterPass:
|
|
Pass.add(createPromoteMemoryToRegisterPass());
|
|
break;
|
|
case t_createPruneEHPass:
|
|
Pass.add(createPruneEHPass());
|
|
break;
|
|
case t_createReassociatePass:
|
|
Pass.add(createReassociatePass());
|
|
break;
|
|
case t_createScalarReplAggregatesPass:
|
|
Pass.add(createScalarReplAggregatesPass((Int)ExpEnv.transform_struc.opt_args.scalar_replace_aggregates_threshold));
|
|
break;
|
|
case t_createSCCPPass:
|
|
Pass.add(createSCCPPass());
|
|
break;
|
|
//NOT IN LLVM 3.5
|
|
//case t_createSimplifyLibCallsPass:
|
|
// Pass.add(createSimplifyLibCallsPass());
|
|
// break;
|
|
case t_createSingleLoopExtractorPass:
|
|
Pass.add(createSingleLoopExtractorPass());
|
|
break;
|
|
case t_createSinkingPass:
|
|
Pass.add(createSinkingPass());
|
|
break;
|
|
case t_createStripDeadDebugInfoPass:
|
|
Pass.add(createStripDeadDebugInfoPass());
|
|
break;
|
|
case t_createStripDeadPrototypesPass:
|
|
Pass.add(createStripDeadPrototypesPass());
|
|
break;
|
|
case t_createStripDebugDeclarePass:
|
|
Pass.add(createStripDebugDeclarePass());
|
|
break;
|
|
case t_createStripNonDebugSymbolsPass:
|
|
Pass.add(createStripNonDebugSymbolsPass());
|
|
break;
|
|
case t_createStripSymbolsPass:
|
|
Pass.add(createStripSymbolsPass((bool)ExpEnv.transform_struc.opt_args.strip_symbols_pass_type));
|
|
break;
|
|
case t_createTailCallEliminationPass:
|
|
Pass.add(createTailCallEliminationPass());
|
|
break;
|
|
default:;
|
|
}
|
|
}
|
|
//set_regalloc_pass(Pass);
|
|
Pass.run(*M); // Run passes
|
|
}
|
|
}
|
|
|
|
void JIT_Compiler::set_regalloc_pass(PassManager &PM) {
|
|
// 'ExpEnv.codegen_struc.struc_enginebuilder.regallocator' contains the active register allocator to be used
|
|
switch(ExpEnv.codegen_struc.struc_enginebuilder.regallocator) {
|
|
case REG_ALLOC_BASIC:
|
|
PM.add(createBasicRegisterAllocator());
|
|
break;
|
|
case REG_ALLOC_FAST:
|
|
PM.add(createFastRegisterAllocator());
|
|
break;
|
|
case REG_ALLOC_GREEDY:
|
|
PM.add(createGreedyRegisterAllocator());
|
|
break;
|
|
case REG_ALLOC_PBQP:
|
|
PM.add(createDefaultPBQPRegisterAllocator());
|
|
break;
|
|
}
|
|
}
|
|
|
|
void* JIT_Compiler::compile_all(LLVMContext* &Context, yamop* p)
|
|
{
|
|
/* Init llvm code generation, analysis and transform passes */
|
|
InitializeNativeTarget();
|
|
PassRegistry &Registry = *PassRegistry::getPassRegistry();
|
|
initializeCore(Registry);
|
|
initializeScalarOpts(Registry);
|
|
initializeVectorization(Registry);
|
|
initializeIPO(Registry);
|
|
initializeAnalysis(Registry);
|
|
initializeIPA(Registry);
|
|
initializeTransformUtils(Registry);
|
|
initializeInstCombine(Registry);
|
|
initializeInstrumentation(Registry);
|
|
initializeTarget(Registry);
|
|
sys::Process::PreventCoreFiles();
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wwrite-strings"
|
|
/* CLANG arguments */
|
|
char *clang_args[] =
|
|
{
|
|
"clang", "-fomit-frame-pointer", "-O0",
|
|
#if CUT_C
|
|
"-DCUT_C=1",
|
|
#endif
|
|
#if COROUTINING
|
|
"-DCOROUTINING=1",
|
|
#endif
|
|
#if RATIONAL_TREES
|
|
"-DRATIONAL_TREES=1",
|
|
#endif
|
|
#if DEBUG
|
|
"-DDEBUG=1",
|
|
#endif
|
|
#if DEPTH_LIMIT
|
|
"-DDEPTH_LIMIT=1",
|
|
#endif
|
|
#if YAP_DBG_PREDS
|
|
"-DYAP_DBG_PREDS=1",
|
|
#endif
|
|
#if YAP_STAT_PREDS
|
|
"-DYAP_STAT_PREDS=1",
|
|
#endif
|
|
#if TABLING
|
|
"-DTABLING=1",
|
|
#endif
|
|
#if _YAP_NOT_INSTALLED_
|
|
"-D_YAP_NOT_INSTALLED_=1",
|
|
#endif
|
|
#ifdef HAVE_CONFIG_H
|
|
"-DHAVE_CONFIG_H",
|
|
#endif
|
|
"-DYAP_JIT", "-D_NATIVE=1", "-I.", "-I./H", "-I./include", "-I./os", "-I./OPTYap", "-I./BEAM", "-I./MYDDAS", "-I./HPP", "-xc", "-c", "-", "-o", "-", "-emit-llvm", NULL
|
|
};
|
|
#pragma GCC diagnostic pop
|
|
|
|
std::string errStr;
|
|
error_code e;
|
|
|
|
/* Pipe to communicate 'echo' with 'clang' */
|
|
int pipe1[2];
|
|
int pid_echo, pid_clang ;
|
|
|
|
/* 'clang' out file */
|
|
char* outputfilename = (char*)malloc(33*sizeof(char));
|
|
sprintf(outputfilename, "%lx.bc", (CELL)p);
|
|
int Output = open(outputfilename, O_CREAT | O_RDWR, 0644);
|
|
|
|
/* Creating pipes */
|
|
if (pipe(pipe1)<0) {
|
|
perror(" ERROR!!\n ERROR") ;
|
|
exit(1);
|
|
}
|
|
|
|
/* Calls echo. */
|
|
pid_echo = fork() ;
|
|
if (pid_echo < 0) {
|
|
perror(" ERROR!!\n ERROR") ;
|
|
exit(1);
|
|
}
|
|
if (!pid_echo) {
|
|
/* Setting echo's output to 1st pipe */
|
|
dup2(pipe1[1], 1);
|
|
|
|
/* Closing pipes */
|
|
close(pipe1[0]);
|
|
close(pipe1[1]);
|
|
|
|
execlp("echo", "echo", p->y_u.jhc.jh->tcc.cmd, NULL);
|
|
}
|
|
else {
|
|
/* Calls clang. */
|
|
pid_clang = fork() ;
|
|
if (pid_clang < 0) {
|
|
perror(" ERROR!!\n ERROR") ;
|
|
exit(1);
|
|
}
|
|
if (!pid_clang) {
|
|
/* Setting clang's input from 1st pipe */
|
|
dup2(pipe1[0], 0) ;
|
|
|
|
/* Setting clang's output to Output */
|
|
dup2(Output, 1) ;
|
|
|
|
/* Closing pipes */
|
|
close(pipe1[0]);
|
|
close(pipe1[1]);
|
|
|
|
execvp(*clang_args, clang_args);
|
|
}
|
|
}
|
|
/* Closing pipes */
|
|
close(pipe1[0]);
|
|
close(pipe1[1]);
|
|
|
|
/* waiting for completion of processes */
|
|
int i;
|
|
int *status = NULL;
|
|
// 2 means two processes: 'echo' and 'clang'
|
|
for (i = 0; i < 2; i++) wait(status);
|
|
/***/
|
|
|
|
/*
|
|
* At this point, the compiled code (O0) is on 'Output' *
|
|
* I need to read it to main memory *
|
|
* for this, I'll use 'MemoryBuffer::getOpenFile' *
|
|
*/
|
|
lseek(Output, 0, SEEK_SET);
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> em = MemoryBuffer::getOpenFile(Output, outputfilename, -1);
|
|
e = em.getError();
|
|
if (e) {
|
|
errs() << "ERROR::Unable to MemoryBuffer from " << outputfilename << " -- " << e.message() << "\n";
|
|
exit(1);
|
|
}
|
|
|
|
/*
|
|
* At this point, the compiled code (O0) is on main memory *
|
|
* I need to read it to Module *
|
|
* for this, I'll use 'parseBitcodeFile' *
|
|
*/
|
|
Module *Mod = *parseBitcodeFile(em->get(), *Context);
|
|
|
|
/*
|
|
* verify module correctness *
|
|
* predicates: *
|
|
* enable_module_correctness/1 *
|
|
* verify_module_before/0 *
|
|
* verify_module_both/0 *
|
|
*/
|
|
if (ExpEnv.analysis_struc.pointtoverifymodule == BEFORE || ExpEnv.analysis_struc.pointtoverifymodule == BOTH) {
|
|
if (verifyModule(*Mod)) {
|
|
errs() << "ERROR:: Module not built correctly!\n";
|
|
exit(1);
|
|
}
|
|
}
|
|
/***/
|
|
|
|
#if YAP_DBG_PREDS
|
|
/* for debug... print module before optimizing it */
|
|
if (ExpEnv.debug_struc.pprint_llva.print_llva_before)
|
|
errs() << "Module before optimization::\n" << *Mod;
|
|
#endif
|
|
|
|
/* Analyze module -- analysis predicates */
|
|
analyze_module(Mod);
|
|
/* Optimize module -- transform predicates */
|
|
optimize_module(Mod);
|
|
|
|
/* Computing size of optimized module */
|
|
{
|
|
/* Open file 'tmp.bc' which will be filled by optimized Module */
|
|
std::shared_ptr<tool_output_file> Out;
|
|
std::string ErrorInfo;
|
|
Out.reset(new tool_output_file("tmp.bc", ErrorInfo, llvm::sys::fs::F_None));
|
|
if (!ErrorInfo.empty()) {
|
|
errs() << ErrorInfo << '\n';
|
|
exit(1);
|
|
}
|
|
/* 'createPrintModulePass(arg)' will print Module (now optimized) to on file represented by 'arg' */
|
|
PassManager Pass;
|
|
Pass.add(createPrintModulePass(Out->os()));
|
|
Pass.run(*Mod);
|
|
/* 'Out->keep()' will keep printed module to file and will close file */
|
|
Out->keep();
|
|
|
|
/* Open file 'tmp.bc' */
|
|
int Outtmp = open("tmp.bc", O_CREAT | O_RDWR, 0644);
|
|
#if YAP_STAT_PREDS
|
|
/* for statistics... compute file size and store value on 'NativeArea->area.native_size_bytes' */
|
|
NativeArea->area.native_size_bytes[p->y_u.jhc.jh->caa.naddress][NativeArea->area.nrecomp[p->y_u.jhc.jh->caa.naddress]-1] = lseek(Outtmp, 0, SEEK_END);
|
|
#endif
|
|
close(Outtmp);
|
|
remove("tmp.bc");
|
|
}
|
|
/***/
|
|
|
|
#if YAP_DBG_PREDS
|
|
/* for debug... print module after optimizing it */
|
|
if (ExpEnv.debug_struc.pprint_llva.print_llva_after)
|
|
errs() << "Module after optimization::\n" << *Mod;
|
|
#endif
|
|
|
|
/*
|
|
* verify module correctness *
|
|
* predicates: *
|
|
* enable_module_correctness/0 *
|
|
* enable_module_correctness/1 *
|
|
* verify_module_after/0 *
|
|
* verify_module_both/0 *
|
|
*/
|
|
if (ExpEnv.analysis_struc.pointtoverifymodule == AFTER || ExpEnv.analysis_struc.pointtoverifymodule == BOTH) {
|
|
if (verifyModule(*Mod)) {
|
|
errs() << "ERROR:: Module not built correctly!\n";
|
|
exit(1);
|
|
}
|
|
}
|
|
/***/
|
|
|
|
// materializeAllPermanently -- Make sure all GlobalValues in this Module are fully read
|
|
error_code materialize_error = Mod->materializeAllPermanently();
|
|
if (materialize_error.value() != 0) {
|
|
errs() <<"Error:: bitcode didn't read correctly. -- " << materialize_error.message() << "\n";
|
|
exit(1);
|
|
}
|
|
|
|
/* Creating EngineBuilder -- called 'builder' */
|
|
Function *EntryFn;
|
|
EngineBuilder builder(Mod);
|
|
builder.setErrorStr(&errStr);
|
|
builder.setJITMemoryManager(JITMemoryManager::CreateDefaultMemManager());
|
|
builder.setEngineKind(EngineKind::JIT);
|
|
// codegen predicate 'engine_opt_level/1'
|
|
switch(ExpEnv.codegen_struc.struc_enginebuilder.engineoptlevel) {
|
|
case 0:
|
|
builder.setOptLevel(CodeGenOpt::None);
|
|
break;
|
|
case 1:
|
|
builder.setOptLevel(CodeGenOpt::Less);
|
|
break;
|
|
case 2:
|
|
builder.setOptLevel(CodeGenOpt::Default);
|
|
break;
|
|
case 3:
|
|
builder.setOptLevel(CodeGenOpt::Aggressive);
|
|
break;
|
|
}
|
|
// codegen predicate 'relocmodel/1'
|
|
switch(ExpEnv.codegen_struc.struc_enginebuilder.relocmodel) {
|
|
case 0:
|
|
builder.setRelocationModel(Reloc::Default);
|
|
break;
|
|
case 1:
|
|
builder.setRelocationModel(Reloc::Static);
|
|
break;
|
|
case 2:
|
|
builder.setRelocationModel(Reloc::PIC_);
|
|
break;
|
|
case 3:
|
|
builder.setRelocationModel(Reloc::DynamicNoPIC);
|
|
break;
|
|
}
|
|
// codegen predicate 'codemodel/1'
|
|
switch(ExpEnv.codegen_struc.struc_enginebuilder.codemodel) {
|
|
case 0:
|
|
builder.setCodeModel(CodeModel::Default);
|
|
break;
|
|
case 1:
|
|
builder.setCodeModel(CodeModel::JITDefault);
|
|
break;
|
|
case 2:
|
|
builder.setCodeModel(CodeModel::Small);
|
|
break;
|
|
case 3:
|
|
builder.setCodeModel(CodeModel::Kernel);
|
|
break;
|
|
case 4:
|
|
builder.setCodeModel(CodeModel::Medium);
|
|
break;
|
|
case 5:
|
|
builder.setCodeModel(CodeModel::Large);
|
|
break;
|
|
}
|
|
// codegen predicates 'enable_mcjit/0' or 'disable_mcjit/0'
|
|
builder.setUseMCJIT((bool)ExpEnv.codegen_struc.struc_enginebuilder.usemcjit);
|
|
llvm::TargetOptions Options;
|
|
{
|
|
/* codegen predicates 'enable_framepointer_elimination/0' or 'disable_framepointer_elimination/0' */
|
|
Options.NoFramePointerElim = (bool)ExpEnv.codegen_struc.struc_targetopt.noframepointerelim;
|
|
//NOT IN LLVM 3.5
|
|
//Options.NoFramePointerElimNonLeaf = (bool)ExpEnv.codegen_struc.struc_targetopt.noframepointerelim;
|
|
/***/
|
|
// codegen predicates 'less_precise_fp_mad_option/0' or 'more_precise_fp_mad_option/0'
|
|
Options.LessPreciseFPMADOption = (bool)ExpEnv.codegen_struc.struc_targetopt.lessprecisefpmadoption;
|
|
// codegen predicates 'no_excess_fp_precision/0' or 'excess_fp_precision/0'
|
|
//NOT IN LLVM 3.5
|
|
//Options.NoExcessFPPrecision = (bool)ExpEnv.codegen_struc.struc_targetopt.noexcessfpprecision;
|
|
// codegen predicates 'unsafe_fp_math/0' or 'safe_fp_math/0'
|
|
Options.UnsafeFPMath = (bool)ExpEnv.codegen_struc.struc_targetopt.unsafefpmath;
|
|
// codegen predicates 'rounding_mode_dynamically_changed/0' or 'rounding_mode_not_changed/0'
|
|
Options.HonorSignDependentRoundingFPMathOption =
|
|
(bool)ExpEnv.codegen_struc.struc_targetopt.honorsigndependentroundingfpmathoption;
|
|
// codegen predicates 'no_use_soft_float/0' or 'use_soft_float/0'
|
|
Options.UseSoftFloat = (bool)ExpEnv.codegen_struc.struc_targetopt.usesoftfloat;
|
|
// codegen predicates 'enable_jit_exception_handling/0' or 'disable_jit_exception_handling/0'
|
|
//NOT IN LLVM 3.5
|
|
//Options.JITExceptionHandling = (bool)ExpEnv.codegen_struc.struc_targetopt.jitexceptionhandling;
|
|
// codegen predicates 'enable_jit_emit_debug_info/0' or 'disable_jit_emit_debug_info/0'
|
|
Options.JITEmitDebugInfo = (bool)ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfo;
|
|
// codegen predicates 'enable_jit_emit_debug_info_to_disk/0' or 'disable_jit_emit_debug_info_to_disk/0'
|
|
Options.JITEmitDebugInfoToDisk = (bool)ExpEnv.codegen_struc.struc_targetopt.jitemitdebuginfotodisk;
|
|
// codegen predicates 'guaranteed_tail_call_opt/0' or 'no_guaranteed_tail_call_opt/0'
|
|
Options.GuaranteedTailCallOpt = (bool)ExpEnv.codegen_struc.struc_targetopt.guaranteedtailcallopt;
|
|
// codegen predicates 'enable_tail_calls/0' or 'disable_tail_calls/0'
|
|
Options.DisableTailCalls = (bool)ExpEnv.codegen_struc.struc_targetopt.disabletailcalls;
|
|
// codegen predicates 'enable_fast_isel/0' or 'disable_fast_isel/0'
|
|
Options.EnableFastISel = (bool)ExpEnv.codegen_struc.struc_targetopt.fastisel;
|
|
}
|
|
// codegen predicates 'fp_abitype/1' or 'default_fp_abitype/0'
|
|
switch(ExpEnv.codegen_struc.struc_targetopt.floatabitype) {
|
|
case 0:
|
|
Options.FloatABIType = FloatABI::Default;
|
|
break;
|
|
case 1:
|
|
Options.FloatABIType = FloatABI::Soft;
|
|
break;
|
|
case 2:
|
|
Options.FloatABIType = FloatABI::Hard;
|
|
break;
|
|
}
|
|
builder.setTargetOptions(Options);
|
|
/***/
|
|
|
|
/* Creating ExecutionEngine from EngineBuilder (builder) */
|
|
ExecutionEngine *EE = builder.create();
|
|
if (!EE) {
|
|
if (!errStr.empty())
|
|
errs() << "Error creating Execution Engine: " << errStr << "\n";
|
|
else
|
|
errs() << "Unknown error creating Execution Engine!\n";
|
|
exit(1);
|
|
}
|
|
/***/
|
|
|
|
// 'clause' is our function -- getting it from Module
|
|
EntryFn = Mod->getFunction("clause");
|
|
if (!EntryFn) {
|
|
/*
|
|
* Theoretically, every Module is correct, but *
|
|
* for some reason, llvm can not compile some of them *
|
|
*/
|
|
close(Output);
|
|
remove(outputfilename);
|
|
free(p->y_u.jhc.jh->tcc.cmd);
|
|
free(outputfilename);
|
|
return NULL;
|
|
}
|
|
|
|
/* Here, we know that Module was be successfully compiled, so... */
|
|
// 1. execute all of the static constructors or destructors for program
|
|
EE->runStaticConstructorsDestructors(false);
|
|
global++;
|
|
|
|
close(Output);
|
|
remove(outputfilename);
|
|
free(p->y_u.jhc.jh->tcc.cmd);
|
|
free(outputfilename);
|
|
// 2. get native pointer from 'clause' (our function within Module) and return it
|
|
return EE->getPointerToFunction(EntryFn);
|
|
}
|
|
|
|
void* JIT_Compiler::compile(yamop* p) {
|
|
/* LLVMContext must be declared here, otherwise LLVM will crash on x86_64 machines */
|
|
LLVMContext *Context = new LLVMContext();
|
|
return compile_all(Context, p);
|
|
}
|