ExecutionEngine * JIT_to_ExecutionEngine (Module * m) {
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
InitializeNativeTargetAsmParser();
PassRegistry * Registry = PassRegistry::getPassRegistry();
initializeCore(*Registry);
initializeCodeGen(*Registry);
initializeLowerIntrinsicsPass(*Registry);
std::string errMessage;
EngineBuilder builder{std::unique_ptr<Module>(m)};
builder.setErrorStr(&errMessage);
builder.setMCPU(sys::getHostCPUName());
TargetOptions opts = InitTargetOptionsFromCodeGenFlags();
builder.setTargetOptions(opts);
CodeGenOpt::Level optLevel = CodeGenOpt::Level::None;
switch (OptLevel) {
case '0': optLevel = CodeGenOpt::None; break;
case '1': optLevel = CodeGenOpt::Less; break;
case '2': optLevel = CodeGenOpt::Default; break;
case '3': optLevel = CodeGenOpt::Aggressive; break;
default: errs() << OptLevel << " is an invalid optimization level.\n";
}
builder.setOptLevel(optLevel);
if ((strncmp(lGetSystemISA(), "avx2", 4) == 0)) {
std::vector<std::string> attrs;
attrs.push_back("avx2");
builder.setMAttrs(attrs);
}
// builder.selectTarget();
if (LLVM_UNLIKELY(DumpGeneratedIR)) {
if (IROutputFilename.empty()) {
m->dump();
} else {
std::error_code error;
llvm::raw_fd_ostream out(IROutputFilename, error, sys::fs::OpenFlags::F_None);
m->print(out, nullptr);
}
}
ExecutionEngine * engine = builder.create();
ICGrepObjectCache * cache = nullptr;
if (engine == nullptr) {
throw std::runtime_error("Could not create ExecutionEngine: " + errMessage);
}
if (EnableObjectCache) {
if (ObjectCacheDir.empty())
// Default is $HOME/.cache/icgrep
cache = new ICGrepObjectCache();
else
cache = new ICGrepObjectCache(ObjectCacheDir);
engine->setObjectCache(cache);
}
return engine;
}
/** ------------------------------------------------------------------------------------------------------------- *
* @brief hoistWhileLoopInvariants
** ------------------------------------------------------------------------------------------------------------- */
void CodeMotionPass::hoistLoopInvariants(While * loop) {
flat_set<const PabloAST *> loopVariants;
for (Next * variant : loop->getVariants()) {
loopVariants.insert(variant);
loopVariants.insert(variant->getInitial());
}
Statement * outerNode = loop->getPrevNode();
Statement * stmt = loop->getBody()->front();
while (stmt) {
if (isa<If>(stmt)) {
for (Assign * def : cast<If>(stmt)->getDefined()) {
loopVariants.insert(def);
}
} else if (isa<While>(stmt)) {
for (Next * var : cast<While>(stmt)->getVariants()) {
loopVariants.insert(var);
}
} else {
bool invariant = true;
for (unsigned i = 0; i != stmt->getNumOperands(); ++i) {
if (loopVariants.count(stmt->getOperand(i)) != 0) {
invariant = false;
break;
}
}
if (LLVM_UNLIKELY(invariant)) {
Statement * next = stmt->getNextNode();
stmt->insertAfter(outerNode);
outerNode = stmt;
stmt = next;
} else {
loopVariants.insert(stmt);
stmt = stmt->getNextNode();
}
}
}
}
HexState operator() (const char*& Ptr, llvm::raw_ostream& Stream,
bool ForceHex) {
// Block allocate the next chunk
if (!(m_Buf.size() % kBufSize))
m_Buf.reserve(m_Buf.size() + kBufSize);
HexState State = kText;
const char* const Start = Ptr;
char32_t Char;
if (m_Utf8) {
Char = utf8::next(Ptr);
if (Ptr > m_End) {
// Invalid/bad encoding: dump the remaining as hex
Ptr = Start;
while (Ptr < m_End)
Stream << "\\x" << llvm::format_hex_no_prefix(uint8_t(*Ptr++), 2);
m_HexRun = true;
return kHex;
}
} else
Char = (*Ptr++ & 0xff);
// Assume more often than not -regular- strings are printed
if (LLVM_UNLIKELY(!isPrintable(Char, m_Loc))) {
m_HexRun = false;
if (LLVM_UNLIKELY(ForceHex || !std::isspace(wchar_t(Char), m_Loc))) {
if (Char > 0xffff)
Stream << "\\U" << llvm::format_hex_no_prefix(uint32_t(Char), 8);
else if (Char > 0xff)
Stream << "\\u" << llvm::format_hex_no_prefix(uint16_t(Char), 4);
else if (Char) {
Stream << "\\x" << llvm::format_hex_no_prefix(uint8_t(Char), 2);
m_HexRun = true;
return kHex;
} else
Stream << "\\0";
return kText;
}
switch (Char) {
case '\b': Stream << "\\b"; return kEsc;
// \r isn't so great on Unix, what about Windows?
case '\r': Stream << "\\r"; return kEsc;
default: break;
}
State = kEsc;
}
if (m_HexRun) {
// If the last print was a hex code, and this is now a char that could
// be interpreted as a continuation of that hex-sequence, close out
// the string and use concatenation. {'\xea', 'B'} -> "\xea" "B"
m_HexRun = false;
if (std::isxdigit(wchar_t(Char), m_Loc))
Stream << "\" \"";
}
if (m_Utf8)
Stream << llvm::StringRef(Start, Ptr-Start);
else
Stream << char(Char);
return State;
}