Block* RLEGenericDecoder::getBlock(unsigned int blockPos_) {
if (!initialized) throw new CodingException("RLEGenericDecoder: Error, decoder not initialized with buffer");
RLETriple* triple=getTriple(blockPos_);
if (triple==NULL) return NULL;
block->setTriple(triple);
return block;
}
//read the begin to end line part of profile file and get their triples
void getTriples(int local_P, int genelen, int siglen, int profilenum, int linelen, int begin, int end, char *file, struct Profile_triple * triples)
{
int i;
//allocate the temp memory
short **profileSet = (short **)malloc(local_P*sizeof(short *));
for(i=0;i<local_P;i++)
profileSet[i] = (short *)malloc(genelen*sizeof(short));
short **tmp_profiles = (short **)malloc(profilenum*sizeof(short *));
for(i=0;i<profilenum;i++)
tmp_profiles[i] = (short *)malloc(genelen*sizeof(short));
//read file and get the proper data
ReadFile(file, linelen, begin, end, profilenum, genelen, tmp_profiles);
for(i=0; i<local_P; i++)
memcpy(profileSet[i],tmp_profiles[i+begin],genelen*sizeof(short));
//get the triple for every profile
for(i=0;i<local_P;i++)
triples[i] = getTriple(profileSet[i], genelen, siglen);
//free the temp memory
for(i=0;i<local_P;i++)
free(profileSet[i]);
free(profileSet);
for(i=0;i<profilenum;i++)
free(tmp_profiles[i]);
free(tmp_profiles);
}
llvm::TargetMachine *
getTargetMachine(llvm::Module *last_module)
{
llvm::Triple triple(last_module->getTargetTriple());
if (triple.getTriple().empty()) {
triple.setTriple(getTriple());
}
std::string Err;
const llvm::Target *target =
llvm::TargetRegistry::lookupTarget(triple.getTriple(), Err);
assert(target && "cannot auto-select target for module");
#if D_LLVM_VERSION_MINOR >= 2
llvm::TargetOptions target_options;
#endif
std::string Features;
target_sp =
#if D_LLVM_VERSION_MINOR <= 4
std::auto_ptr<llvm::TargetMachine>
#else
std::shared_ptr<llvm::TargetMachine>
#endif
(target->createTargetMachine(
triple.getTriple(), llvm::sys::getHostCPUName(),
Features
#if D_LLVM_VERSION_MINOR >= 2
, target_options
#endif
));
return target_sp.get();
}
Block* RLEDecoder::getBlock(unsigned int blockPos_) {
if (!initialized) throw new CodingException("RLEDecoder: Error, decoder not initialized with buffer");
RLETriple* triple = getTriple(blockPos_);
if (triple == NULL) return NULL;
if (block == NULL) {
block = new RLEBlock(triple, valSorted);
}
else {
block->setTriple(triple);
}
return block;
}
uint16_t ELFLinkingContext::getOutputMachine() const {
switch (getTriple().getArch()) {
case llvm::Triple::x86:
return llvm::ELF::EM_386;
case llvm::Triple::x86_64:
return llvm::ELF::EM_X86_64;
case llvm::Triple::hexagon:
return llvm::ELF::EM_HEXAGON;
case llvm::Triple::mipsel:
return llvm::ELF::EM_MIPS;
case llvm::Triple::ppc:
return llvm::ELF::EM_PPC;
default:
llvm_unreachable("Unhandled arch");
}
}
std::unique_ptr<DebugMap>
MachODebugMapParser::parseOneBinary(const MachOObjectFile &MainBinary,
StringRef BinaryPath) {
loadMainBinarySymbols(MainBinary);
ArrayRef<uint8_t> UUID = MainBinary.getUuid();
Result = make_unique<DebugMap>(getTriple(MainBinary), BinaryPath, UUID);
MainBinaryStrings = MainBinary.getStringTableData();
for (const SymbolRef &Symbol : MainBinary.symbols()) {
const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
if (MainBinary.is64Bit())
handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
else
handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
}
resetParserState();
return std::move(Result);
}
/// This main parsing routine tries to open the main binary and if
/// successful iterates over the STAB entries. The real parsing is
/// done in handleStabSymbolTableEntry.
ErrorOr<std::unique_ptr<DebugMap>> MachODebugMapParser::parse() {
auto MainBinOrError = MainBinaryHolder.GetFileAs<MachOObjectFile>(BinaryPath);
if (auto Error = MainBinOrError.getError())
return Error;
const MachOObjectFile &MainBinary = *MainBinOrError;
loadMainBinarySymbols();
Result = make_unique<DebugMap>(getTriple(MainBinary));
MainBinaryStrings = MainBinary.getStringTableData();
for (const SymbolRef &Symbol : MainBinary.symbols()) {
const DataRefImpl &DRI = Symbol.getRawDataRefImpl();
if (MainBinary.is64Bit())
handleStabDebugMapEntry(MainBinary.getSymbol64TableEntry(DRI));
else
handleStabDebugMapEntry(MainBinary.getSymbolTableEntry(DRI));
}
resetParserState();
return std::move(Result);
}
bool ELFLinkingContext::is64Bits() const { return getTriple().isArch64Bit(); }
bool Connect::
addSite( Vertex *vx, Node *nd, bool externalOK, bool splitOne, bool force)
{
int i, count;
Vertex *vtx;
Triple *trip, *tmp;
std::list< Triple * > tripleQueue;
hull.clear();
for( i = 2; i >= 0; --i )
{
trip = getTriple();
trip->from = vx->nodeAt(i);
trip->to = vx->nodeAt((i+1)%3);
trip->vtx = vx->vertices[i];
tripleQueue.push_back( trip );
}
vx->makeDeleted();
deleted.push_back( vx );
while( tripleQueue.size() > 0 )
{
trip = tripleQueue.back();
tripleQueue.pop_back();
vtx = trip->vtx;
if(vtx == (Vertex *)0)
{
hull.push_back( trip );
continue;
}
if( vtx->isDeleted() )
{
/*
If a vertex is deleted, we must have visited it during this loop.
Therefore, there must be a triple with reversed direction in the stack list.
We must remove both triples.
*/
tmp = tripleQueue.back();
if(tmp->from == trip->to && tmp->to == trip->from)
{
tripleQueue.pop_back();
}
else
{
tripleQueue.pop_front();
}
}
else
{
/*
Return status:
= 1 OK, destroyed
= 0 OK, not destroyed
= -1 NOT OK, external element destroyed
If retval = -1, abort the operation, clear buffers and indicate the same thing
for the upper level.
*/
int retval = vtx->isDestroyedBy(nd->x, nd->y, externalOK);
if(retval == 1)
{
vtx->makeDeleted();
deleted.push_back( vtx );
for(i = 0; i < 3; ++i) if(vtx->nodeAt(i) == trip->from) break;
tmp = getTriple();
tmp->from = vtx->nodeAt((i+1)%3);
tmp->to = vtx->nodeAt((i+2)%3);
tmp->vtx = vtx->vertices[(i+1)%3];
tripleQueue.push_back( tmp );
tmp = getTriple();
tmp->from = vtx->nodeAt(i);
tmp->to = vtx->nodeAt((i+1)%3);
tmp->vtx = vtx->vertices[i];
tripleQueue.push_back( tmp );
}
else if(retval == 0 || force)
{
hull.push_back( trip );
}
else
{
std::list< Vertex* >::iterator deletedIt;
for( deletedIt = deleted.begin(); deletedIt != deleted.end(); ++deletedIt )
{
(*deletedIt)->unDelete();
}
deleted.clear();
return false;
}
}
}
if (!externalOK && !splitOne && deleted.size() == 1)
return true;
// These parts should be separated!
count = hull.size();
getVertices( newVertices, count );
std::list<Triple *>::const_iterator hit;
for(hit = hull.begin(), i = 0; i < count; ++i, ++hit)
{
tmp = *hit;
newVertices[i]->reset( nd, tmp->from, tmp->to );
}
for(hit = hull.begin(), i = 0; i < count; ++i, ++hit)
{
tmp = *hit;
vtx = newVertices[i];
vtx->setVertices(newVertices[(i+count-1)%count],
tmp->vtx,
newVertices[(i+1)%count]);
if(tmp->vtx != (Vertex *)0)
{
if(tmp->vtx->nodeAt(0) == tmp->to)
tmp->vtx->replaceVertexWith(0, vtx);
else if(tmp->vtx->nodeAt(1) == tmp->to)
tmp->vtx->replaceVertexWith(1, vtx);
else if(tmp->vtx->nodeAt(2) == tmp->to)
tmp->vtx->replaceVertexWith(2, vtx);
}
}
root = newVertices.back();
return true;
}
int
Generator::run(std::vector<const char *> *file_paths,
std::vector<const char *> *bc_file_paths,
std::vector<const char *> *compile_lib_paths,
std::vector<const char *> *include_paths,
std::vector<const char *> *module_paths,
std::vector<const char *> *static_module_names,
std::vector<const char *> *cto_module_names,
const char *module_name,
int debug,
int produce,
int optlevel,
int remove_macros,
int no_common,
int no_dale_stdlib,
int static_mods_all,
int enable_cto,
std::vector<std::string> *shared_object_paths,
FILE *output_file)
{
if (!file_paths->size()) {
return 0;
}
NativeTypes nt;
TypeRegister tr;
llvm::ExecutionEngine *ee = NULL;
std::set<std::string> cto_modules;
for (std::vector<const char*>::iterator
b = cto_module_names->begin(),
e = cto_module_names->end();
b != e;
++b) {
cto_modules.insert(std::string(*b));
}
/* On OS X, SYSTEM_PROCESSOR is i386 even when the underlying
* processor is x86-64, hence the extra check here. */
bool is_x86_64 =
((!strcmp(SYSTEM_PROCESSOR, "x86_64"))
|| ((!strcmp(SYSTEM_PROCESSOR, "amd64")))
|| ((!strcmp(SYSTEM_NAME, "Darwin"))
&& (sizeof(char *) == 8)));
init_introspection_functions();
llvm::Module *last_module = NULL;
Module::Reader mr(module_paths, shared_object_paths, include_paths);
for (std::vector<const char*>::iterator b = compile_lib_paths->begin(),
e = compile_lib_paths->end();
b != e;
++b) {
mr.addDynamicLibrary((*b), false, false);
}
const char *libdrt_path = NULL;
if (!no_dale_stdlib) {
FILE *drt_file = NULL;
if ((drt_file = fopen(DALE_LIBRARY_PATH "/libdrt.so", "r"))) {
libdrt_path = DALE_LIBRARY_PATH "/libdrt.so";
} else if ((drt_file = fopen("./libdrt.so", "r"))) {
libdrt_path = "./libdrt.so";
} else {
error("unable to find libdrt.so");
}
mr.addDynamicLibrary(libdrt_path, false, false);
int res = fclose(drt_file);
if (res != 0) {
error("unable to close %s", libdrt_path, true);
}
}
if (!module_name && libdrt_path) {
shared_object_paths->push_back(libdrt_path);
}
Units units(&mr);
units.cto = enable_cto;
units.no_common = no_common;
units.no_dale_stdlib = no_dale_stdlib;
Context *ctx = NULL;
llvm::Module *mod = NULL;
llvm::Linker *linker = NULL;
ErrorReporter er("");
if (module_name) {
const char *last_slash = strrchr(module_name, '/');
std::string bare_module_name;
if (!last_slash) {
last_slash = module_name;
bare_module_name = std::string(last_slash);
} else {
bare_module_name = std::string(last_slash + 1);
}
if (bare_module_name.length() > 0) {
if (!isValidModuleName(&bare_module_name)) {
Error *e = new Error(
ErrorInst::InvalidModuleName, NULL,
bare_module_name.c_str()
);
er.addError(e);
return 0;
}
}
int diff = last_slash - module_name;
units.module_name = std::string(module_name);
units.module_name.replace(diff + 1, 0, "lib");
}
for (std::vector<const char*>::iterator b = file_paths->begin(),
e = file_paths->end();
b != e;
++b) {
const char *filename = *b;
assert(!units.size());
Unit *unit = new Unit(filename, &units, &er, &nt, &tr, NULL, is_x86_64);
units.push(unit);
ctx = unit->ctx;
mod = unit->module;
linker = unit->linker;
llvm::Triple triple(mod->getTargetTriple());
if (triple.getTriple().empty()) {
triple.setTriple(getTriple());
}
mod->setDataLayout((is_x86_64) ? x86_64_layout : x86_32_layout);
llvm::EngineBuilder eb = llvm::EngineBuilder(mod);
eb.setEngineKind(llvm::EngineKind::JIT);
ee = eb.create();
assert(ee);
ee->InstallLazyFunctionCreator(&lazyFunctionCreator);
unit->ee = ee;
unit->mp->ee = ee;
CommonDecl::addVarargsFunctions(unit);
if (!no_common) {
if (no_dale_stdlib) {
unit->addCommonDeclarations();
} else {
std::vector<const char*> import_forms;
mr.run(ctx, mod, nullNode(), "drt", &import_forms);
units.top()->mp->setPoolfree();
}
}
std::vector<Node*> nodes;
for (;;) {
int error_count = er.getErrorTypeCount(ErrorType::Error);
Node *top = units.top()->parser->getNextList();
if (top) {
nodes.push_back(top);
}
if (er.getErrorTypeCount(ErrorType::Error) > error_count) {
er.flush();
continue;
}
if (!top) {
er.flush();
break;
}
if (!top->is_token && !top->is_list) {
units.pop();
if (!units.empty()) {
Unit *unit = units.top();
ctx = unit->ctx;
mod = unit->module;
linker = unit->linker;
continue;
}
break;
}
FormTopLevelInstParse(&units, top);
er.flush();
}
if (remove_macros) {
ctx->eraseLLVMMacros();
}
if (dale::pool_free_fptr) {
ee->freeMachineCodeForFunction(dale::pool_free_fn);
}
if (last_module) {
linkModule(linker, last_module);
}
last_module = mod;
for (std::vector<Node *>::iterator b = nodes.begin(),
e = nodes.end();
b != e;
++b) {
delete (*b);
}
}
if (remove_macros) {
ctx->eraseLLVMMacros();
}
if (er.getErrorTypeCount(ErrorType::Error)) {
return 0;
}
if (bc_file_paths) {
for (std::vector<const char*>::iterator b = bc_file_paths->begin(),
e = bc_file_paths->end();
b != e;
++b) {
linkFile(linker, *b);
}
}
/* At optlevel 3, things go quite awry when making libraries, due
* to the argumentPromotionPass. So set it to 2, unless LTO has
* also been requested (optlevel == 4). */
bool lto = false;
if (optlevel == 3) {
optlevel = 2;
} else if (optlevel == 4) {
optlevel = 3;
lto = true;
}
llvm::TargetMachine *target_machine = getTargetMachine(last_module);
llvm::raw_fd_ostream ostream(fileno(output_file), false);
llvm::PassManager pass_manager;
addDataLayout(&pass_manager, mod);
pass_manager.add(llvm::createPostDomTree());
llvm::PassManagerBuilder pass_manager_builder;
pass_manager_builder.OptLevel = optlevel;
pass_manager_builder.DisableUnitAtATime = true;
if (optlevel > 0) {
if (lto) {
pass_manager_builder.DisableUnitAtATime = false;
}
pass_manager_builder.populateModulePassManager(pass_manager);
if (lto) {
pass_manager_builder.populateLTOPassManager(pass_manager, true, true);
}
}
if (units.module_name.size() > 0) {
Module::Writer mw(units.module_name, ctx, mod, &pass_manager,
&(mr.included_once_tags), &(mr.included_modules),
units.cto);
mw.run();
return 1;
}
std::map<std::string, llvm::Module*> *dtm_modules = &(mr.dtm_modules);
std::map<std::string, std::string> *dtm_nm_modules = &(mr.dtm_nm_modules);
bool reget_pointers = true;
std::map<std::string, llvm::Module *> static_dtm_modules;
if (static_mods_all || (static_module_names->size() > 0)) {
if (remove_macros) {
for (std::map<std::string, std::string>::iterator
b = dtm_nm_modules->begin(),
e = dtm_nm_modules->end();
b != e; ++b) {
static_dtm_modules.insert(
std::pair<std::string, llvm::Module*>(
b->first,
mr.loadModule(&(b->second))
)
);
}
} else {
static_dtm_modules = *dtm_modules;
}
reget_pointers = false;
}
if (static_mods_all) {
for (std::map<std::string, llvm::Module *>::iterator
b = static_dtm_modules.begin(),
e = static_dtm_modules.end();
b != e; ++b) {
if (cto_modules.find(b->first) == cto_modules.end()) {
linkModule(linker, b->second);
}
}
} else if (static_module_names->size() > 0) {
for (std::vector<const char *>::iterator b =
static_module_names->begin(), e =
static_module_names->end();
b != e; ++b) {
std::map<std::string, llvm::Module *>::iterator
found = static_dtm_modules.find(std::string(*b));
if (found != static_dtm_modules.end()) {
linkModule(linker, found->second);
}
}
reget_pointers = false;
}
if (reget_pointers) {
ctx->regetPointers(mod);
}
if (remove_macros) {
ctx->eraseLLVMMacrosAndCTOFunctions();
}
llvm::formatted_raw_ostream *ostream_formatted =
new llvm::formatted_raw_ostream(
ostream,
llvm::formatted_raw_ostream::DELETE_STREAM
);
if (produce == IR) {
addPrintModulePass(&pass_manager, &ostream);
} else if (produce == ASM) {
target_machine->setAsmVerbosityDefault(true);
llvm::CodeGenOpt::Level level = llvm::CodeGenOpt::Default;
bool res = target_machine->addPassesToEmitFile(
pass_manager, *ostream_formatted,
llvm::TargetMachine::CGFT_AssemblyFile,
level, NULL);
assert(!res && "unable to add passes to emit file");
_unused(res);
}
if (debug) {
mod->dump();
}
if (debug) {
llvm::verifyModule(*mod);
}
pass_manager.run(*mod);
if (produce == BitCode) {
llvm::WriteBitcodeToFile(mod, ostream);
}
ostream_formatted->flush();
ostream.flush();
return 1;
}
