void compileAndRunModule(AST_Module* m, BoxedModule* bm) {
Timer _t("for compileModule()");
ScopingAnalysis* scoping = runScopingAnalysis(m);
SourceInfo* si = new SourceInfo(bm, scoping);
si->cfg = computeCFG(AST_TYPE::Module, m->body);
si->ast = m;
si->liveness = computeLivenessInfo(si->cfg);
si->phis = computeRequiredPhis(NULL, si->cfg, si->liveness, si->scoping->getScopeInfoForNode(si->ast));
CLFunction* cl_f = new CLFunction(si);
EffortLevel::EffortLevel effort = initialEffort();
CompiledFunction* cf
= compileFunction(cl_f, new FunctionSignature(VOID, &si->getArgNames(), 0, false, false), effort, NULL);
assert(cf->clfunc->versions.size());
_t.end();
if (cf->is_interpreted)
interpretFunction(cf->func, 0, NULL, NULL, NULL, NULL);
else
((void (*)())cf->code)();
}
void compileAndRunModule(AST_Module* m, BoxedModule* bm) {
CompiledFunction* cf;
{ // scope for limiting the locked region:
LOCK_REGION(codegen_rwlock.asWrite());
Timer _t("for compileModule()");
bm->future_flags = getFutureFlags(m, bm->fn.c_str());
ScopingAnalysis* scoping = runScopingAnalysis(m);
SourceInfo* si = new SourceInfo(bm, scoping, m, m->body);
si->cfg = computeCFG(si, m->body);
si->liveness = computeLivenessInfo(si->cfg);
si->phis = computeRequiredPhis(si->arg_names, si->cfg, si->liveness, si->getScopeInfo());
CLFunction* cl_f = new CLFunction(0, 0, false, false, si);
EffortLevel::EffortLevel effort = initialEffort();
cf = compileFunction(cl_f, new FunctionSpecialization(VOID), effort, NULL);
assert(cf->clfunc->versions.size());
}
if (cf->is_interpreted)
interpretFunction(cf->func, 0, NULL, NULL, NULL, NULL, NULL, NULL);
else
((void (*)())cf->code)();
}
CompiledFunction* compileModule(AST_Module *m, BoxedModule *bm) {
Timer _t("for compileModule()");
ScopingAnalysis *scoping = runScopingAnalysis(m);
SourceInfo *si = new SourceInfo(bm, scoping);
si->cfg = computeCFG(AST_TYPE::Module, m->body);
si->ast = m;
si->liveness = computeLivenessInfo(si->cfg);
si->phis = computeRequiredPhis(NULL, si->cfg, si->liveness, si->scoping->getScopeInfoForNode(si->ast));
CLFunction *cl_f = new CLFunction(si);
EffortLevel::EffortLevel effort = initialEffort();
CompiledFunction *cf = _doCompile(cl_f, new FunctionSignature(VOID, false), effort, NULL);
assert(cf->clfunc->versions.size());
return cf;
}
// Compiles a new version of the function with the given signature and adds it to the list;
// should only be called after checking to see if the other versions would work.
CompiledFunction* compileFunction(CLFunction* f, FunctionSignature* sig, EffortLevel::EffortLevel effort,
const OSREntryDescriptor* entry) {
Timer _t("for compileFunction()");
assert(sig);
ASSERT(f->versions.size() < 20, "%ld", f->versions.size());
SourceInfo* source = f->source;
assert(source);
std::string name = source->getName();
const std::vector<AST_expr*>& arg_names = source->getArgNames();
AST_arguments* args = source->getArgsAST();
if (args) {
// args object can be NULL if this is a module scope
assert(!args->vararg.size());
assert(!args->kwarg.size());
assert(!args->defaults.size());
}
if (VERBOSITY("irgen") >= 1) {
std::string s;
llvm::raw_string_ostream ss(s);
ss << "\033[34;1mJIT'ing " << name << " with signature (";
for (int i = 0; i < sig->arg_types.size(); i++) {
if (i > 0)
ss << ", ";
ss << sig->arg_types[i]->debugName();
// sig->arg_types[i]->llvmType()->print(ss);
}
ss << ") -> ";
ss << sig->rtn_type->debugName();
// sig->rtn_type->llvmType()->print(ss);
ss << " at effort level " << effort;
if (entry != NULL) {
ss << "\nDoing OSR-entry partial compile, starting with backedge to block " << entry->backedge->target->idx
<< '\n';
}
ss << "\033[0m";
printf("%s\n", ss.str().c_str());
}
// Do the analysis now if we had deferred it earlier:
if (source->cfg == NULL) {
assert(source->ast);
source->cfg = computeCFG(source->ast->type, source->getBody());
source->liveness = computeLivenessInfo(source->cfg);
source->phis = computeRequiredPhis(args, source->cfg, source->liveness,
source->scoping->getScopeInfoForNode(source->ast));
}
CompiledFunction* cf = doCompile(source, entry, effort, sig, arg_names, name);
compileIR(cf, effort);
f->addVersion(cf);
assert(f->versions.size());
long us = _t.end();
static StatCounter us_compiling("us_compiling");
us_compiling.log(us);
static StatCounter num_compiles("num_compiles");
num_compiles.log();
switch (effort) {
case EffortLevel::INTERPRETED: {
static StatCounter us_compiling("us_compiling_0_interpreted");
us_compiling.log(us);
static StatCounter num_compiles("num_compiles_0_interpreted");
num_compiles.log();
break;
}
case EffortLevel::MINIMAL: {
static StatCounter us_compiling("us_compiling_1_minimal");
us_compiling.log(us);
static StatCounter num_compiles("num_compiles_1_minimal");
num_compiles.log();
break;
}
case EffortLevel::MODERATE: {
static StatCounter us_compiling("us_compiling_2_moderate");
us_compiling.log(us);
static StatCounter num_compiles("num_compiles_2_moderate");
num_compiles.log();
break;
}
case EffortLevel::MAXIMAL: {
static StatCounter us_compiling("us_compiling_3_maximal");
us_compiling.log(us);
static StatCounter num_compiles("num_compiles_3_maximal");
num_compiles.log();
break;
}
}
return cf;
}
