#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/StandardPasses.h"
#include "llvm/Support/SystemUtils.h"
+#include "llvm/System/Host.h"
#include "llvm/System/Signals.h"
#include "llvm/Target/SubtargetFeature.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Target/TargetAsmInfo.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
-#include "llvm/Target/TargetMachineRegistry.h"
+#include "llvm/Target/TargetRegistry.h"
#include "llvm/Target/TargetSelect.h"
#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/Scalar.h"
_linker("LinkTimeOptimizer", "ld-temp.o", _context), _target(NULL),
_emitDwarfDebugInfo(false), _scopeRestrictionsDone(false),
_codeModel(LTO_CODEGEN_PIC_MODEL_DYNAMIC),
- _nativeObjectFile(NULL), _gccPath(NULL), _assemblerPath(NULL)
+ _nativeObjectFile(NULL), _assemblerPath(NULL)
{
- InitializeAllTargets();
- InitializeAllAsmPrinters();
-
+ InitializeAllTargets();
+ InitializeAllAsmPrinters();
}
LTOCodeGenerator::~LTOCodeGenerator()
return true;
}
-void LTOCodeGenerator::setGccPath(const char* path)
-{
- if ( _gccPath )
- delete _gccPath;
- _gccPath = new sys::Path(path);
-}
-
void LTOCodeGenerator::setAssemblerPath(const char* path)
{
if ( _assemblerPath )
if ( _assemblerPath ) {
tool = *_assemblerPath;
needsCompilerOptions = false;
- }
- else if ( _gccPath ) {
- tool = *_gccPath;
} else {
// find compiler driver
tool = sys::Program::FindProgramByName("gcc");
bool LTOCodeGenerator::determineTarget(std::string& errMsg)
{
if ( _target == NULL ) {
+ std::string Triple = _linker.getModule()->getTargetTriple();
+ if (Triple.empty())
+ Triple = sys::getHostTriple();
+
// create target machine from info for merged modules
- Module* mergedModule = _linker.getModule();
- const Target *march =
- TargetRegistry::getClosestStaticTargetForModule(*mergedModule,
- errMsg);
+ const Target *march = TargetRegistry::lookupTarget(Triple, errMsg);
if ( march == NULL )
return true;
}
// construct LTModule, hand over ownership of module and target
- std::string FeatureStr =
- getFeatureString(_linker.getModule()->getTargetTriple().c_str());
- _target = march->createTargetMachine(*mergedModule, FeatureStr.c_str());
+ std::string FeatureStr = getFeatureString(Triple.c_str());
+ _target = march->createTargetMachine(Triple, FeatureStr);
}
return false;
}
e = mergedModule->end(); f != e; ++f) {
if ( !f->isDeclaration()
&& _mustPreserveSymbols.count(mangler.getMangledName(f)) )
- mustPreserveList.push_back(::strdup(f->getName().c_str()));
+ mustPreserveList.push_back(::strdup(f->getNameStr().c_str()));
}
for (Module::global_iterator v = mergedModule->global_begin(),
e = mergedModule->global_end(); v != e; ++v) {
if ( !v->isDeclaration()
&& _mustPreserveSymbols.count(mangler.getMangledName(v)) )
- mustPreserveList.push_back(::strdup(v->getName().c_str()));
+ mustPreserveList.push_back(::strdup(v->getNameStr().c_str()));
}
passes.add(createInternalizePass(mustPreserveList));
}
bool LTOCodeGenerator::generateAssemblyCode(formatted_raw_ostream& out,
std::string& errMsg)
{
- if ( this->determineTarget(errMsg) )
+ if ( this->determineTarget(errMsg) )
return true;
// mark which symbols can not be internalized
codeGenPasses->run(*it);
codeGenPasses->doFinalization();
+
+ out.flush();
+
return false; // success
}