[llvm-exegesis][NFC] Remove extra `llvm::` qualifications.
Summary: Second patch: in the lib.
Reviewers: gchatelet
Subscribers: nemanjai, tschuett, MaskRay, mgrang, jsji, llvm-commits
Tags: #llvm
Differential Revision: https://reviews.llvm.org/D68692
llvm-svn: 374158
diff --git a/llvm/tools/llvm-exegesis/lib/Assembler.cpp b/llvm/tools/llvm-exegesis/lib/Assembler.cpp
index 229bf36..c19cac8 100644
--- a/llvm/tools/llvm-exegesis/lib/Assembler.cpp
+++ b/llvm/tools/llvm-exegesis/lib/Assembler.cpp
@@ -31,11 +31,9 @@
// Fills the given basic block with register setup code, and returns true if
// all registers could be setup correctly.
-static bool
-generateSnippetSetupCode(const ExegesisTarget &ET,
- const llvm::MCSubtargetInfo *const MSI,
- llvm::ArrayRef<RegisterValue> RegisterInitialValues,
- BasicBlockFiller &BBF) {
+static bool generateSnippetSetupCode(
+ const ExegesisTarget &ET, const MCSubtargetInfo *const MSI,
+ ArrayRef<RegisterValue> RegisterInitialValues, BasicBlockFiller &BBF) {
bool IsSnippetSetupComplete = true;
for (const RegisterValue &RV : RegisterInitialValues) {
// Load a constant in the register.
@@ -48,20 +46,20 @@
}
// Small utility function to add named passes.
-static bool addPass(llvm::PassManagerBase &PM, llvm::StringRef PassName,
- llvm::TargetPassConfig &TPC) {
- const llvm::PassRegistry *PR = llvm::PassRegistry::getPassRegistry();
- const llvm::PassInfo *PI = PR->getPassInfo(PassName);
+static bool addPass(PassManagerBase &PM, StringRef PassName,
+ TargetPassConfig &TPC) {
+ const PassRegistry *PR = PassRegistry::getPassRegistry();
+ const PassInfo *PI = PR->getPassInfo(PassName);
if (!PI) {
- llvm::errs() << " run-pass " << PassName << " is not registered.\n";
+ errs() << " run-pass " << PassName << " is not registered.\n";
return true;
}
if (!PI->getNormalCtor()) {
- llvm::errs() << " cannot create pass: " << PI->getPassName() << "\n";
+ errs() << " cannot create pass: " << PI->getPassName() << "\n";
return true;
}
- llvm::Pass *P = PI->getNormalCtor()();
+ Pass *P = PI->getNormalCtor()();
std::string Banner = std::string("After ") + std::string(P->getPassName());
PM.add(P);
TPC.printAndVerify(Banner);
@@ -69,42 +67,39 @@
return false;
}
-llvm::MachineFunction &
-createVoidVoidPtrMachineFunction(llvm::StringRef FunctionID,
- llvm::Module *Module,
- llvm::MachineModuleInfo *MMI) {
- llvm::Type *const ReturnType = llvm::Type::getInt32Ty(Module->getContext());
- llvm::Type *const MemParamType = llvm::PointerType::get(
- llvm::Type::getInt8Ty(Module->getContext()), 0 /*default address space*/);
- llvm::FunctionType *FunctionType =
- llvm::FunctionType::get(ReturnType, {MemParamType}, false);
- llvm::Function *const F = llvm::Function::Create(
- FunctionType, llvm::GlobalValue::InternalLinkage, FunctionID, Module);
+MachineFunction &createVoidVoidPtrMachineFunction(StringRef FunctionID,
+ Module *Module,
+ MachineModuleInfo *MMI) {
+ Type *const ReturnType = Type::getInt32Ty(Module->getContext());
+ Type *const MemParamType = PointerType::get(
+ Type::getInt8Ty(Module->getContext()), 0 /*default address space*/);
+ FunctionType *FunctionType =
+ FunctionType::get(ReturnType, {MemParamType}, false);
+ Function *const F = Function::Create(
+ FunctionType, GlobalValue::InternalLinkage, FunctionID, Module);
// Making sure we can create a MachineFunction out of this Function even if it
// contains no IR.
F->setIsMaterializable(true);
return MMI->getOrCreateMachineFunction(*F);
}
-BasicBlockFiller::BasicBlockFiller(llvm::MachineFunction &MF,
- llvm::MachineBasicBlock *MBB,
- const llvm::MCInstrInfo *MCII)
+BasicBlockFiller::BasicBlockFiller(MachineFunction &MF, MachineBasicBlock *MBB,
+ const MCInstrInfo *MCII)
: MF(MF), MBB(MBB), MCII(MCII) {}
-void BasicBlockFiller::addInstruction(const llvm::MCInst &Inst,
- const llvm::DebugLoc &DL) {
+void BasicBlockFiller::addInstruction(const MCInst &Inst, const DebugLoc &DL) {
const unsigned Opcode = Inst.getOpcode();
- const llvm::MCInstrDesc &MCID = MCII->get(Opcode);
- llvm::MachineInstrBuilder Builder = llvm::BuildMI(MBB, DL, MCID);
+ const MCInstrDesc &MCID = MCII->get(Opcode);
+ MachineInstrBuilder Builder = BuildMI(MBB, DL, MCID);
for (unsigned OpIndex = 0, E = Inst.getNumOperands(); OpIndex < E;
++OpIndex) {
- const llvm::MCOperand &Op = Inst.getOperand(OpIndex);
+ const MCOperand &Op = Inst.getOperand(OpIndex);
if (Op.isReg()) {
const bool IsDef = OpIndex < MCID.getNumDefs();
unsigned Flags = 0;
- const llvm::MCOperandInfo &OpInfo = MCID.operands().begin()[OpIndex];
+ const MCOperandInfo &OpInfo = MCID.operands().begin()[OpIndex];
if (IsDef && !OpInfo.isOptionalDef())
- Flags |= llvm::RegState::Define;
+ Flags |= RegState::Define;
Builder.addReg(Op.getReg(), Flags);
} else if (Op.isImm()) {
Builder.addImm(Op.getImm());
@@ -116,31 +111,31 @@
}
}
-void BasicBlockFiller::addInstructions(ArrayRef<llvm::MCInst> Insts,
- const llvm::DebugLoc &DL) {
+void BasicBlockFiller::addInstructions(ArrayRef<MCInst> Insts,
+ const DebugLoc &DL) {
for (const MCInst &Inst : Insts)
addInstruction(Inst, DL);
}
-void BasicBlockFiller::addReturn(const llvm::DebugLoc &DL) {
+void BasicBlockFiller::addReturn(const DebugLoc &DL) {
// Insert the return code.
- const llvm::TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
+ const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
if (TII->getReturnOpcode() < TII->getNumOpcodes()) {
- llvm::BuildMI(MBB, DL, TII->get(TII->getReturnOpcode()));
+ BuildMI(MBB, DL, TII->get(TII->getReturnOpcode()));
} else {
- llvm::MachineIRBuilder MIB(MF);
+ MachineIRBuilder MIB(MF);
MIB.setMBB(*MBB);
MF.getSubtarget().getCallLowering()->lowerReturn(MIB, nullptr, {});
}
}
-FunctionFiller::FunctionFiller(llvm::MachineFunction &MF,
+FunctionFiller::FunctionFiller(MachineFunction &MF,
std::vector<unsigned> RegistersSetUp)
: MF(MF), MCII(MF.getTarget().getMCInstrInfo()), Entry(addBasicBlock()),
RegistersSetUp(std::move(RegistersSetUp)) {}
BasicBlockFiller FunctionFiller::addBasicBlock() {
- llvm::MachineBasicBlock *MBB = MF.CreateMachineBasicBlock();
+ MachineBasicBlock *MBB = MF.CreateMachineBasicBlock();
MF.push_back(MBB);
return BasicBlockFiller(MF, MBB, MCII);
}
@@ -149,50 +144,45 @@
return RegistersSetUp;
}
-static std::unique_ptr<llvm::Module>
-createModule(const std::unique_ptr<llvm::LLVMContext> &Context,
- const llvm::DataLayout DL) {
- auto Module = std::make_unique<llvm::Module>(ModuleID, *Context);
- Module->setDataLayout(DL);
- return Module;
+static std::unique_ptr<Module>
+createModule(const std::unique_ptr<LLVMContext> &Context, const DataLayout DL) {
+ auto Mod = std::make_unique<Module>(ModuleID, *Context);
+ Mod->setDataLayout(DL);
+ return Mod;
}
-llvm::BitVector getFunctionReservedRegs(const llvm::TargetMachine &TM) {
- std::unique_ptr<llvm::LLVMContext> Context =
- std::make_unique<llvm::LLVMContext>();
- std::unique_ptr<llvm::Module> Module =
- createModule(Context, TM.createDataLayout());
+BitVector getFunctionReservedRegs(const TargetMachine &TM) {
+ std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
+ std::unique_ptr<Module> Module = createModule(Context, TM.createDataLayout());
// TODO: This only works for targets implementing LLVMTargetMachine.
const LLVMTargetMachine &LLVMTM = static_cast<const LLVMTargetMachine &>(TM);
- std::unique_ptr<llvm::MachineModuleInfoWrapperPass> MMIWP =
- std::make_unique<llvm::MachineModuleInfoWrapperPass>(&LLVMTM);
- llvm::MachineFunction &MF = createVoidVoidPtrMachineFunction(
+ std::unique_ptr<MachineModuleInfoWrapperPass> MMIWP =
+ std::make_unique<MachineModuleInfoWrapperPass>(&LLVMTM);
+ MachineFunction &MF = createVoidVoidPtrMachineFunction(
FunctionID, Module.get(), &MMIWP.get()->getMMI());
// Saving reserved registers for client.
return MF.getSubtarget().getRegisterInfo()->getReservedRegs(MF);
}
void assembleToStream(const ExegesisTarget &ET,
- std::unique_ptr<llvm::LLVMTargetMachine> TM,
- llvm::ArrayRef<unsigned> LiveIns,
- llvm::ArrayRef<RegisterValue> RegisterInitialValues,
- const FillFunction &Fill,
- llvm::raw_pwrite_stream &AsmStream) {
- std::unique_ptr<llvm::LLVMContext> Context =
- std::make_unique<llvm::LLVMContext>();
- std::unique_ptr<llvm::Module> Module =
+ std::unique_ptr<LLVMTargetMachine> TM,
+ ArrayRef<unsigned> LiveIns,
+ ArrayRef<RegisterValue> RegisterInitialValues,
+ const FillFunction &Fill, raw_pwrite_stream &AsmStream) {
+ std::unique_ptr<LLVMContext> Context = std::make_unique<LLVMContext>();
+ std::unique_ptr<Module> Module =
createModule(Context, TM->createDataLayout());
- std::unique_ptr<llvm::MachineModuleInfoWrapperPass> MMIWP =
- std::make_unique<llvm::MachineModuleInfoWrapperPass>(TM.get());
- llvm::MachineFunction &MF = createVoidVoidPtrMachineFunction(
+ std::unique_ptr<MachineModuleInfoWrapperPass> MMIWP =
+ std::make_unique<MachineModuleInfoWrapperPass>(TM.get());
+ MachineFunction &MF = createVoidVoidPtrMachineFunction(
FunctionID, Module.get(), &MMIWP.get()->getMMI());
// We need to instruct the passes that we're done with SSA and virtual
// registers.
auto &Properties = MF.getProperties();
- Properties.set(llvm::MachineFunctionProperties::Property::NoVRegs);
- Properties.reset(llvm::MachineFunctionProperties::Property::IsSSA);
- Properties.set(llvm::MachineFunctionProperties::Property::NoPHIs);
+ Properties.set(MachineFunctionProperties::Property::NoVRegs);
+ Properties.reset(MachineFunctionProperties::Property::IsSSA);
+ Properties.set(MachineFunctionProperties::Property::NoPHIs);
for (const unsigned Reg : LiveIns)
MF.getRegInfo().addLiveIn(Reg);
@@ -212,7 +202,7 @@
// If the snippet setup is not complete, we disable liveliness tracking. This
// means that we won't know what values are in the registers.
if (!IsSnippetSetupComplete)
- Properties.reset(llvm::MachineFunctionProperties::Property::TracksLiveness);
+ Properties.reset(MachineFunctionProperties::Property::TracksLiveness);
Fill(Sink);
@@ -221,13 +211,13 @@
MF.getRegInfo().freezeReservedRegs(MF);
// We create the pass manager, run the passes to populate AsmBuffer.
- llvm::MCContext &MCContext = MMIWP->getMMI().getContext();
- llvm::legacy::PassManager PM;
+ MCContext &MCContext = MMIWP->getMMI().getContext();
+ legacy::PassManager PM;
- llvm::TargetLibraryInfoImpl TLII(llvm::Triple(Module->getTargetTriple()));
- PM.add(new llvm::TargetLibraryInfoWrapperPass(TLII));
+ TargetLibraryInfoImpl TLII(Triple(Module->getTargetTriple()));
+ PM.add(new TargetLibraryInfoWrapperPass(TLII));
- llvm::TargetPassConfig *TPC = TM->createPassConfig(PM);
+ TargetPassConfig *TPC = TM->createPassConfig(PM);
PM.add(TPC);
PM.add(MMIWP.release());
TPC->printAndVerify("MachineFunctionGenerator::assemble");
@@ -239,50 +229,49 @@
// - prologepilog: saves and restore callee saved registers.
for (const char *PassName : {"machineverifier", "prologepilog"})
if (addPass(PM, PassName, *TPC))
- llvm::report_fatal_error("Unable to add a mandatory pass");
+ report_fatal_error("Unable to add a mandatory pass");
TPC->setInitialized();
// AsmPrinter is responsible for generating the assembly into AsmBuffer.
- if (TM->addAsmPrinter(PM, AsmStream, nullptr,
- llvm::TargetMachine::CGFT_ObjectFile, MCContext))
- llvm::report_fatal_error("Cannot add AsmPrinter passes");
+ if (TM->addAsmPrinter(PM, AsmStream, nullptr, TargetMachine::CGFT_ObjectFile,
+ MCContext))
+ report_fatal_error("Cannot add AsmPrinter passes");
PM.run(*Module); // Run all the passes
}
-llvm::object::OwningBinary<llvm::object::ObjectFile>
-getObjectFromBuffer(llvm::StringRef InputData) {
+object::OwningBinary<object::ObjectFile>
+getObjectFromBuffer(StringRef InputData) {
// Storing the generated assembly into a MemoryBuffer that owns the memory.
- std::unique_ptr<llvm::MemoryBuffer> Buffer =
- llvm::MemoryBuffer::getMemBufferCopy(InputData);
+ std::unique_ptr<MemoryBuffer> Buffer =
+ MemoryBuffer::getMemBufferCopy(InputData);
// Create the ObjectFile from the MemoryBuffer.
- std::unique_ptr<llvm::object::ObjectFile> Obj = llvm::cantFail(
- llvm::object::ObjectFile::createObjectFile(Buffer->getMemBufferRef()));
+ std::unique_ptr<object::ObjectFile> Obj =
+ cantFail(object::ObjectFile::createObjectFile(Buffer->getMemBufferRef()));
// Returning both the MemoryBuffer and the ObjectFile.
- return llvm::object::OwningBinary<llvm::object::ObjectFile>(
- std::move(Obj), std::move(Buffer));
+ return object::OwningBinary<object::ObjectFile>(std::move(Obj),
+ std::move(Buffer));
}
-llvm::object::OwningBinary<llvm::object::ObjectFile>
-getObjectFromFile(llvm::StringRef Filename) {
- return llvm::cantFail(llvm::object::ObjectFile::createObjectFile(Filename));
+object::OwningBinary<object::ObjectFile> getObjectFromFile(StringRef Filename) {
+ return cantFail(object::ObjectFile::createObjectFile(Filename));
}
namespace {
// Implementation of this class relies on the fact that a single object with a
// single function will be loaded into memory.
-class TrackingSectionMemoryManager : public llvm::SectionMemoryManager {
+class TrackingSectionMemoryManager : public SectionMemoryManager {
public:
explicit TrackingSectionMemoryManager(uintptr_t *CodeSize)
: CodeSize(CodeSize) {}
uint8_t *allocateCodeSection(uintptr_t Size, unsigned Alignment,
unsigned SectionID,
- llvm::StringRef SectionName) override {
+ StringRef SectionName) override {
*CodeSize = Size;
- return llvm::SectionMemoryManager::allocateCodeSection(
- Size, Alignment, SectionID, SectionName);
+ return SectionMemoryManager::allocateCodeSection(Size, Alignment, SectionID,
+ SectionName);
}
private:
@@ -292,9 +281,9 @@
} // namespace
ExecutableFunction::ExecutableFunction(
- std::unique_ptr<llvm::LLVMTargetMachine> TM,
- llvm::object::OwningBinary<llvm::object::ObjectFile> &&ObjectFileHolder)
- : Context(std::make_unique<llvm::LLVMContext>()) {
+ std::unique_ptr<LLVMTargetMachine> TM,
+ object::OwningBinary<object::ObjectFile> &&ObjectFileHolder)
+ : Context(std::make_unique<LLVMContext>()) {
assert(ObjectFileHolder.getBinary() && "cannot create object file");
// Initializing the execution engine.
// We need to use the JIT EngineKind to be able to add an object file.
@@ -302,24 +291,23 @@
uintptr_t CodeSize = 0;
std::string Error;
ExecEngine.reset(
- llvm::EngineBuilder(createModule(Context, TM->createDataLayout()))
+ EngineBuilder(createModule(Context, TM->createDataLayout()))
.setErrorStr(&Error)
.setMCPU(TM->getTargetCPU())
- .setEngineKind(llvm::EngineKind::JIT)
+ .setEngineKind(EngineKind::JIT)
.setMCJITMemoryManager(
std::make_unique<TrackingSectionMemoryManager>(&CodeSize))
.create(TM.release()));
if (!ExecEngine)
- llvm::report_fatal_error(Error);
+ report_fatal_error(Error);
// Adding the generated object file containing the assembled function.
// The ExecutionEngine makes sure the object file is copied into an
// executable page.
ExecEngine->addObjectFile(std::move(ObjectFileHolder));
// Fetching function bytes.
- FunctionBytes =
- llvm::StringRef(reinterpret_cast<const char *>(
- ExecEngine->getFunctionAddress(FunctionID)),
- CodeSize);
+ FunctionBytes = StringRef(reinterpret_cast<const char *>(
+ ExecEngine->getFunctionAddress(FunctionID)),
+ CodeSize);
}
} // namespace exegesis