RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-11-29 22:50:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Move --march, --mcpu, and --mattr from JIT/TargetSelect.cpp to lli.cpp.

Browse Source 
llc.cpp also defined these flags, meaning that when I linked all of LLVM's
libraries into a single shared library, llc crashed on startup with duplicate
flag definitions.  This patch passes them through the EngineBuilder into
JIT::selectTarget().


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@95390 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jeffrey Yasskin 2010-02-05 16:19:36 +00:00
parent 63d58ebd09
commit 4688261c20
6 changed files with 93 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
include/llvm/ExecutionEngine/ExecutionEngine.h
View File

@ -19,6 +19,7 @@
#include <map>
#include <string>
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/ValueMap.h"
#include "llvm/Support/ValueHandle.h"
#include "llvm/System/Mutex.h"
@ -108,12 +109,16 @@ protected:
// To avoid having libexecutionengine depend on the JIT and interpreter
// libraries, the JIT and Interpreter set these functions to ctor pointers
// at startup time if they are linked in.
static ExecutionEngine *(*JITCtor)(Module *M,
std::string *ErrorStr,
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool GVsWithCode,
CodeModel::Model CMM);
static ExecutionEngine *(*JITCtor)(
Module *M,
std::string *ErrorStr,
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool GVsWithCode,
CodeModel::Model CMM,
StringRef MArch,
StringRef MCPU,
const SmallVectorImpl<std::string>& MAttrs);
static ExecutionEngine *(*InterpCtor)(Module *M,
std::string *ErrorStr);
@ -416,6 +421,9 @@ class EngineBuilder {
JITMemoryManager *JMM;
bool AllocateGVsWithCode;
CodeModel::Model CMModel;
std::string MArch;
std::string MCPU;
SmallVector<std::string, 4> MAttrs;
/// InitEngine - Does the common initialization of default options.
///
@ -484,6 +492,26 @@ class EngineBuilder {
return *this;
}
/// setMArch - Override the architecture set by the Module's triple.
EngineBuilder &setMArch(StringRef march) {
MArch.assign(march.begin(), march.end());
return *this;
}
/// setMCPU - Target a specific cpu type.
EngineBuilder &setMCPU(StringRef mcpu) {
MCPU.assign(mcpu.begin(), mcpu.end());
return *this;
}
/// setMAttrs - Set cpu-specific attributes.
template<typename StringSequence>
EngineBuilder &setMAttrs(const StringSequence &mattrs) {
MAttrs.clear();
MAttrs.append(mattrs.begin(), mattrs.end());
return *this;
}
ExecutionEngine *create();
};

19
lib/ExecutionEngine/ExecutionEngine.cpp
View File

@ -35,12 +35,16 @@ using namespace llvm;
STATISTIC(NumInitBytes, "Number of bytes of global vars initialized");
STATISTIC(NumGlobals , "Number of global vars initialized");
ExecutionEngine *(*ExecutionEngine::JITCtor)(Module *M,
std::string *ErrorStr,
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool GVsWithCode,
CodeModel::Model CMM) = 0;
ExecutionEngine *(*ExecutionEngine::JITCtor)(
Module *M,
std::string *ErrorStr,
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool GVsWithCode,
CodeModel::Model CMM,
StringRef MArch,
StringRef MCPU,
const SmallVectorImpl<std::string>& MAttrs) = 0;
ExecutionEngine *(*ExecutionEngine::InterpCtor)(Module *M,
std::string *ErrorStr) = 0;
ExecutionEngine::EERegisterFn ExecutionEngine::ExceptionTableRegister = 0;
@ -412,7 +416,8 @@ ExecutionEngine *EngineBuilder::create() {
if (ExecutionEngine::JITCtor) {
ExecutionEngine *EE =
ExecutionEngine::JITCtor(M, ErrorStr, JMM, OptLevel,
AllocateGVsWithCode, CMModel);
AllocateGVsWithCode, CMModel,
MArch, MCPU, MAttrs);
if (EE) return EE;
}
}

17
lib/ExecutionEngine/JIT/JIT.cpp
View File

@ -198,8 +198,14 @@ ExecutionEngine *ExecutionEngine::createJIT(Module *M,
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool GVsWithCode,
CodeModel::Model CMM) {
return JIT::createJIT(M, ErrorStr, JMM, OptLevel, GVsWithCode, CMM);
CodeModel::Model CMM) {
// Use the defaults for extra parameters. Users can use EngineBuilder to
// set them.
StringRef MArch = "";
StringRef MCPU = "";
SmallVector<std::string, 1> MAttrs;
return JIT::createJIT(M, ErrorStr, JMM, OptLevel, GVsWithCode, CMM,
MArch, MCPU, MAttrs);
}
ExecutionEngine *JIT::createJIT(Module *M,
@ -207,14 +213,17 @@ ExecutionEngine *JIT::createJIT(Module *M,
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool GVsWithCode,
CodeModel::Model CMM) {
CodeModel::Model CMM,
StringRef MArch,
StringRef MCPU,
const SmallVectorImpl<std::string>& MAttrs) {
// Make sure we can resolve symbols in the program as well. The zero arg
// to the function tells DynamicLibrary to load the program, not a library.
if (sys::DynamicLibrary::LoadLibraryPermanently(0, ErrorStr))
return 0;
// Pick a target either via -march or by guessing the native arch.
TargetMachine *TM = JIT::selectTarget(M, ErrorStr);
TargetMachine *TM = JIT::selectTarget(M, MArch, MCPU, MAttrs, ErrorStr);
if (!TM || (ErrorStr && ErrorStr->length() > 0)) return 0;
TM->setCodeModel(CMM);

13
lib/ExecutionEngine/JIT/JIT.h
View File

@ -70,7 +70,7 @@ public:
~JIT();
static void Register() {
JITCtor = create;
JITCtor = createJIT;
}
/// getJITInfo - Return the target JIT information structure.
@ -164,14 +164,21 @@ public:
/// selectTarget - Pick a target either via -march or by guessing the native
/// arch. Add any CPU features specified via -mcpu or -mattr.
static TargetMachine *selectTarget(Module *M, std::string *Err);
static TargetMachine *selectTarget(Module *M,
StringRef MArch,
StringRef MCPU,
const SmallVectorImpl<std::string>& MAttrs,
std::string *Err);
static ExecutionEngine *createJIT(Module *M,
std::string *ErrorStr,
JITMemoryManager *JMM,
CodeGenOpt::Level OptLevel,
bool GVsWithCode,
CodeModel::Model CMM);
CodeModel::Model CMM,
StringRef MArch,
StringRef MCPU,
const SmallVectorImpl<std::string>& MAttrs);
// Run the JIT on F and return information about the generated code
void runJITOnFunction(Function *F, MachineCodeInfo *MCI = 0);

22
lib/ExecutionEngine/JIT/TargetSelect.cpp
View File

@ -24,25 +24,13 @@
#include "llvm/Target/TargetRegistry.h"
using namespace llvm;
static cl::opt<std::string>
MArch("march",
cl::desc("Architecture to generate assembly for (see --version)"));
static cl::opt<std::string>
MCPU("mcpu",
cl::desc("Target a specific cpu type (-mcpu=help for details)"),
cl::value_desc("cpu-name"),
cl::init(""));
static cl::list<std::string>
MAttrs("mattr",
cl::CommaSeparated,
cl::desc("Target specific attributes (-mattr=help for details)"),
cl::value_desc("a1,+a2,-a3,..."));
/// selectTarget - Pick a target either via -march or by guessing the native
/// arch. Add any CPU features specified via -mcpu or -mattr.
TargetMachine *JIT::selectTarget(Module *Mod, std::string *ErrorStr) {
TargetMachine *JIT::selectTarget(Module *Mod,
StringRef MArch,
StringRef MCPU,
const SmallVectorImpl<std::string>& MAttrs,
std::string *ErrorStr) {
Triple TheTriple(Mod->getTargetTriple());
if (TheTriple.getTriple().empty())
TheTriple.setTriple(sys::getHostTriple());

19
tools/lli/lli.cpp
View File

@ -57,6 +57,22 @@ namespace {
cl::opt<std::string>
TargetTriple("mtriple", cl::desc("Override target triple for module"));
cl::opt<std::string>
MArch("march",
cl::desc("Architecture to generate assembly for (see --version)"));
cl::opt<std::string>
MCPU("mcpu",
cl::desc("Target a specific cpu type (-mcpu=help for details)"),
cl::value_desc("cpu-name"),
cl::init(""));
cl::list<std::string>
MAttrs("mattr",
cl::CommaSeparated,
cl::desc("Target specific attributes (-mattr=help for details)"),
cl::value_desc("a1,+a2,-a3,..."));
cl::opt<std::string>
EntryFunc("entry-function",
cl::desc("Specify the entry function (default = 'main') "
@ -131,6 +147,9 @@ int main(int argc, char **argv, char * const *envp) {
}
EngineBuilder builder(Mod);
builder.setMArch(MArch);
builder.setMCPU(MCPU);
builder.setMAttrs(MAttrs);
builder.setErrorStr(&ErrorMsg);
builder.setEngineKind(ForceInterpreter
? EngineKind::Interpreter