979c275097
The module currently stores the target triple as a string. This means that any code that wants to actually use the triple first has to instantiate a Triple, which is somewhat expensive. The change in #121652 caused a moderate compile-time regression due to this. While it would be easy enough to work around, I think that architecturally, it makes more sense to store the parsed Triple in the module, so that it can always be directly queried. For this change, I've opted not to add any magic conversions between std::string and Triple for backwards-compatibilty purses, and instead write out needed Triple()s or str()s explicitly. This is because I think a decent number of them should be changed to work on Triple as well, to avoid unnecessary conversions back and forth. The only interesting part in this patch is that the default triple is Triple("") instead of Triple() to preserve existing behavior. The former defaults to using the ELF object format instead of unknown object format. We should fix that as well.
147 lines
3.9 KiB
C++
147 lines
3.9 KiB
C++
//===----- JITTargetMachineBuilder.cpp - Build TargetMachines for JIT -----===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
|
|
|
|
#include "llvm/MC/TargetRegistry.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include "llvm/TargetParser/Host.h"
|
|
|
|
namespace llvm {
|
|
namespace orc {
|
|
|
|
JITTargetMachineBuilder::JITTargetMachineBuilder(Triple TT)
|
|
: TT(std::move(TT)) {
|
|
Options.EmulatedTLS = true;
|
|
Options.UseInitArray = true;
|
|
}
|
|
|
|
Expected<JITTargetMachineBuilder> JITTargetMachineBuilder::detectHost() {
|
|
JITTargetMachineBuilder TMBuilder((Triple(sys::getProcessTriple())));
|
|
|
|
// Retrieve host CPU name and sub-target features and add them to builder.
|
|
// Relocation model, code model and codegen opt level are kept to default
|
|
// values.
|
|
for (const auto &Feature : llvm::sys::getHostCPUFeatures())
|
|
TMBuilder.getFeatures().AddFeature(Feature.first(), Feature.second);
|
|
|
|
TMBuilder.setCPU(std::string(llvm::sys::getHostCPUName()));
|
|
|
|
return TMBuilder;
|
|
}
|
|
|
|
Expected<std::unique_ptr<TargetMachine>>
|
|
JITTargetMachineBuilder::createTargetMachine() {
|
|
|
|
std::string ErrMsg;
|
|
auto *TheTarget = TargetRegistry::lookupTarget(TT, ErrMsg);
|
|
if (!TheTarget)
|
|
return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
|
|
|
|
if (!TheTarget->hasJIT())
|
|
return make_error<StringError>("Target has no JIT support",
|
|
inconvertibleErrorCode());
|
|
|
|
auto *TM =
|
|
TheTarget->createTargetMachine(TT.getTriple(), CPU, Features.getString(),
|
|
Options, RM, CM, OptLevel, /*JIT*/ true);
|
|
if (!TM)
|
|
return make_error<StringError>("Could not allocate target machine",
|
|
inconvertibleErrorCode());
|
|
|
|
return std::unique_ptr<TargetMachine>(TM);
|
|
}
|
|
|
|
JITTargetMachineBuilder &JITTargetMachineBuilder::addFeatures(
|
|
const std::vector<std::string> &FeatureVec) {
|
|
for (const auto &F : FeatureVec)
|
|
Features.AddFeature(F);
|
|
return *this;
|
|
}
|
|
|
|
#ifndef NDEBUG
|
|
void JITTargetMachineBuilderPrinter::print(raw_ostream &OS) const {
|
|
OS << Indent << "{\n"
|
|
<< Indent << " Triple = \"" << JTMB.TT.str() << "\"\n"
|
|
<< Indent << " CPU = \"" << JTMB.CPU << "\"\n"
|
|
<< Indent << " Features = \"" << JTMB.Features.getString() << "\"\n"
|
|
<< Indent << " Options = <not-printable>\n"
|
|
<< Indent << " Relocation Model = ";
|
|
|
|
if (JTMB.RM) {
|
|
switch (*JTMB.RM) {
|
|
case Reloc::Static:
|
|
OS << "Static";
|
|
break;
|
|
case Reloc::PIC_:
|
|
OS << "PIC_";
|
|
break;
|
|
case Reloc::DynamicNoPIC:
|
|
OS << "DynamicNoPIC";
|
|
break;
|
|
case Reloc::ROPI:
|
|
OS << "ROPI";
|
|
break;
|
|
case Reloc::RWPI:
|
|
OS << "RWPI";
|
|
break;
|
|
case Reloc::ROPI_RWPI:
|
|
OS << "ROPI_RWPI";
|
|
break;
|
|
}
|
|
} else
|
|
OS << "unspecified (will use target default)";
|
|
|
|
OS << "\n"
|
|
<< Indent << " Code Model = ";
|
|
|
|
if (JTMB.CM) {
|
|
switch (*JTMB.CM) {
|
|
case CodeModel::Tiny:
|
|
OS << "Tiny";
|
|
break;
|
|
case CodeModel::Small:
|
|
OS << "Small";
|
|
break;
|
|
case CodeModel::Kernel:
|
|
OS << "Kernel";
|
|
break;
|
|
case CodeModel::Medium:
|
|
OS << "Medium";
|
|
break;
|
|
case CodeModel::Large:
|
|
OS << "Large";
|
|
break;
|
|
}
|
|
} else
|
|
OS << "unspecified (will use target default)";
|
|
|
|
OS << "\n"
|
|
<< Indent << " Optimization Level = ";
|
|
switch (JTMB.OptLevel) {
|
|
case CodeGenOptLevel::None:
|
|
OS << "None";
|
|
break;
|
|
case CodeGenOptLevel::Less:
|
|
OS << "Less";
|
|
break;
|
|
case CodeGenOptLevel::Default:
|
|
OS << "Default";
|
|
break;
|
|
case CodeGenOptLevel::Aggressive:
|
|
OS << "Aggressive";
|
|
break;
|
|
}
|
|
|
|
OS << "\n" << Indent << "}\n";
|
|
}
|
|
#endif // NDEBUG
|
|
|
|
} // End namespace orc.
|
|
} // End namespace llvm.
|