mirror of
https://github.com/llvm/llvm-project.git
synced 2025-05-13 06:56:07 +00:00
3659780d58
This is x86 specific, and adds statefulness to MachineModuleInfo. Instead of explicitly tracking this, infer if we need to declare the symbol based on the reference previously inserted. This produces a small change in the output due to the move from AsmPrinter::doFinalization to X86's emitEndOfAsmFile. This will now be moved relative to other end of file fields, which I'm assuming doesn't matter (e.g. the __morestack_addr declaration is now after the .note.GNU-split-stack part) This also produces another small change in code if the module happened to define/declare __morestack_addr, but I assume that's invalid and doesn't really matter.
434 lines
14 KiB
C++
434 lines
14 KiB
C++
//===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- C++ -*-===//
|
|
//
|
|
// 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/CodeGen/MachineModuleInfo.h"
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/TinyPtrVector.h"
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
#include "llvm/CodeGen/Passes.h"
|
|
#include "llvm/IR/BasicBlock.h"
|
|
#include "llvm/IR/Constants.h"
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
#include "llvm/IR/Module.h"
|
|
#include "llvm/IR/ValueHandle.h"
|
|
#include "llvm/InitializePasses.h"
|
|
#include "llvm/MC/MCContext.h"
|
|
#include "llvm/MC/MCSymbol.h"
|
|
#include "llvm/Pass.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Target/TargetLoweringObjectFile.h"
|
|
#include "llvm/Target/TargetMachine.h"
|
|
#include <algorithm>
|
|
#include <cassert>
|
|
#include <memory>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::dwarf;
|
|
|
|
static cl::opt<bool>
|
|
DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
|
|
cl::desc("Disable debug info printing"));
|
|
|
|
// Out of line virtual method.
|
|
MachineModuleInfoImpl::~MachineModuleInfoImpl() = default;
|
|
|
|
namespace llvm {
|
|
|
|
class MMIAddrLabelMapCallbackPtr final : CallbackVH {
|
|
MMIAddrLabelMap *Map = nullptr;
|
|
|
|
public:
|
|
MMIAddrLabelMapCallbackPtr() = default;
|
|
MMIAddrLabelMapCallbackPtr(Value *V) : CallbackVH(V) {}
|
|
|
|
void setPtr(BasicBlock *BB) {
|
|
ValueHandleBase::operator=(BB);
|
|
}
|
|
|
|
void setMap(MMIAddrLabelMap *map) { Map = map; }
|
|
|
|
void deleted() override;
|
|
void allUsesReplacedWith(Value *V2) override;
|
|
};
|
|
|
|
class MMIAddrLabelMap {
|
|
MCContext &Context;
|
|
struct AddrLabelSymEntry {
|
|
/// The symbols for the label.
|
|
TinyPtrVector<MCSymbol *> Symbols;
|
|
|
|
Function *Fn; // The containing function of the BasicBlock.
|
|
unsigned Index; // The index in BBCallbacks for the BasicBlock.
|
|
};
|
|
|
|
DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry> AddrLabelSymbols;
|
|
|
|
/// Callbacks for the BasicBlock's that we have entries for. We use this so
|
|
/// we get notified if a block is deleted or RAUWd.
|
|
std::vector<MMIAddrLabelMapCallbackPtr> BBCallbacks;
|
|
|
|
/// This is a per-function list of symbols whose corresponding BasicBlock got
|
|
/// deleted. These symbols need to be emitted at some point in the file, so
|
|
/// AsmPrinter emits them after the function body.
|
|
DenseMap<AssertingVH<Function>, std::vector<MCSymbol*>>
|
|
DeletedAddrLabelsNeedingEmission;
|
|
|
|
public:
|
|
MMIAddrLabelMap(MCContext &context) : Context(context) {}
|
|
|
|
~MMIAddrLabelMap() {
|
|
assert(DeletedAddrLabelsNeedingEmission.empty() &&
|
|
"Some labels for deleted blocks never got emitted");
|
|
}
|
|
|
|
ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(BasicBlock *BB);
|
|
|
|
void takeDeletedSymbolsForFunction(Function *F,
|
|
std::vector<MCSymbol*> &Result);
|
|
|
|
void UpdateForDeletedBlock(BasicBlock *BB);
|
|
void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New);
|
|
};
|
|
|
|
} // end namespace llvm
|
|
|
|
ArrayRef<MCSymbol *> MMIAddrLabelMap::getAddrLabelSymbolToEmit(BasicBlock *BB) {
|
|
assert(BB->hasAddressTaken() &&
|
|
"Shouldn't get label for block without address taken");
|
|
AddrLabelSymEntry &Entry = AddrLabelSymbols[BB];
|
|
|
|
// If we already had an entry for this block, just return it.
|
|
if (!Entry.Symbols.empty()) {
|
|
assert(BB->getParent() == Entry.Fn && "Parent changed");
|
|
return Entry.Symbols;
|
|
}
|
|
|
|
// Otherwise, this is a new entry, create a new symbol for it and add an
|
|
// entry to BBCallbacks so we can be notified if the BB is deleted or RAUWd.
|
|
BBCallbacks.emplace_back(BB);
|
|
BBCallbacks.back().setMap(this);
|
|
Entry.Index = BBCallbacks.size() - 1;
|
|
Entry.Fn = BB->getParent();
|
|
MCSymbol *Sym = BB->hasAddressTaken() ? Context.createNamedTempSymbol()
|
|
: Context.createTempSymbol();
|
|
Entry.Symbols.push_back(Sym);
|
|
return Entry.Symbols;
|
|
}
|
|
|
|
/// If we have any deleted symbols for F, return them.
|
|
void MMIAddrLabelMap::
|
|
takeDeletedSymbolsForFunction(Function *F, std::vector<MCSymbol*> &Result) {
|
|
DenseMap<AssertingVH<Function>, std::vector<MCSymbol*>>::iterator I =
|
|
DeletedAddrLabelsNeedingEmission.find(F);
|
|
|
|
// If there are no entries for the function, just return.
|
|
if (I == DeletedAddrLabelsNeedingEmission.end()) return;
|
|
|
|
// Otherwise, take the list.
|
|
std::swap(Result, I->second);
|
|
DeletedAddrLabelsNeedingEmission.erase(I);
|
|
}
|
|
|
|
void MMIAddrLabelMap::UpdateForDeletedBlock(BasicBlock *BB) {
|
|
// If the block got deleted, there is no need for the symbol. If the symbol
|
|
// was already emitted, we can just forget about it, otherwise we need to
|
|
// queue it up for later emission when the function is output.
|
|
AddrLabelSymEntry Entry = std::move(AddrLabelSymbols[BB]);
|
|
AddrLabelSymbols.erase(BB);
|
|
assert(!Entry.Symbols.empty() && "Didn't have a symbol, why a callback?");
|
|
BBCallbacks[Entry.Index] = nullptr; // Clear the callback.
|
|
|
|
#if !LLVM_MEMORY_SANITIZER_BUILD
|
|
// BasicBlock is destroyed already, so this access is UB detectable by msan.
|
|
assert((BB->getParent() == nullptr || BB->getParent() == Entry.Fn) &&
|
|
"Block/parent mismatch");
|
|
#endif
|
|
|
|
for (MCSymbol *Sym : Entry.Symbols) {
|
|
if (Sym->isDefined())
|
|
return;
|
|
|
|
// If the block is not yet defined, we need to emit it at the end of the
|
|
// function. Add the symbol to the DeletedAddrLabelsNeedingEmission list
|
|
// for the containing Function. Since the block is being deleted, its
|
|
// parent may already be removed, we have to get the function from 'Entry'.
|
|
DeletedAddrLabelsNeedingEmission[Entry.Fn].push_back(Sym);
|
|
}
|
|
}
|
|
|
|
void MMIAddrLabelMap::UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New) {
|
|
// Get the entry for the RAUW'd block and remove it from our map.
|
|
AddrLabelSymEntry OldEntry = std::move(AddrLabelSymbols[Old]);
|
|
AddrLabelSymbols.erase(Old);
|
|
assert(!OldEntry.Symbols.empty() && "Didn't have a symbol, why a callback?");
|
|
|
|
AddrLabelSymEntry &NewEntry = AddrLabelSymbols[New];
|
|
|
|
// If New is not address taken, just move our symbol over to it.
|
|
if (NewEntry.Symbols.empty()) {
|
|
BBCallbacks[OldEntry.Index].setPtr(New); // Update the callback.
|
|
NewEntry = std::move(OldEntry); // Set New's entry.
|
|
return;
|
|
}
|
|
|
|
BBCallbacks[OldEntry.Index] = nullptr; // Update the callback.
|
|
|
|
// Otherwise, we need to add the old symbols to the new block's set.
|
|
llvm::append_range(NewEntry.Symbols, OldEntry.Symbols);
|
|
}
|
|
|
|
void MMIAddrLabelMapCallbackPtr::deleted() {
|
|
Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr()));
|
|
}
|
|
|
|
void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
|
|
Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2));
|
|
}
|
|
|
|
void MachineModuleInfo::initialize() {
|
|
ObjFileMMI = nullptr;
|
|
CurCallSite = 0;
|
|
NextFnNum = 0;
|
|
UsesMSVCFloatingPoint = false;
|
|
AddrLabelSymbols = nullptr;
|
|
DbgInfoAvailable = false;
|
|
}
|
|
|
|
void MachineModuleInfo::finalize() {
|
|
Personalities.clear();
|
|
|
|
delete AddrLabelSymbols;
|
|
AddrLabelSymbols = nullptr;
|
|
|
|
Context.reset();
|
|
// We don't clear the ExternalContext.
|
|
|
|
delete ObjFileMMI;
|
|
ObjFileMMI = nullptr;
|
|
}
|
|
|
|
MachineModuleInfo::MachineModuleInfo(MachineModuleInfo &&MMI)
|
|
: TM(std::move(MMI.TM)),
|
|
Context(MMI.TM.getTargetTriple(), MMI.TM.getMCAsmInfo(),
|
|
MMI.TM.getMCRegisterInfo(), MMI.TM.getMCSubtargetInfo(), nullptr,
|
|
nullptr, false),
|
|
MachineFunctions(std::move(MMI.MachineFunctions)) {
|
|
Context.setObjectFileInfo(MMI.TM.getObjFileLowering());
|
|
ObjFileMMI = MMI.ObjFileMMI;
|
|
CurCallSite = MMI.CurCallSite;
|
|
UsesMSVCFloatingPoint = MMI.UsesMSVCFloatingPoint;
|
|
AddrLabelSymbols = MMI.AddrLabelSymbols;
|
|
ExternalContext = MMI.ExternalContext;
|
|
TheModule = MMI.TheModule;
|
|
}
|
|
|
|
MachineModuleInfo::MachineModuleInfo(const LLVMTargetMachine *TM)
|
|
: TM(*TM), Context(TM->getTargetTriple(), TM->getMCAsmInfo(),
|
|
TM->getMCRegisterInfo(), TM->getMCSubtargetInfo(),
|
|
nullptr, nullptr, false) {
|
|
Context.setObjectFileInfo(TM->getObjFileLowering());
|
|
initialize();
|
|
}
|
|
|
|
MachineModuleInfo::MachineModuleInfo(const LLVMTargetMachine *TM,
|
|
MCContext *ExtContext)
|
|
: TM(*TM), Context(TM->getTargetTriple(), TM->getMCAsmInfo(),
|
|
TM->getMCRegisterInfo(), TM->getMCSubtargetInfo(),
|
|
nullptr, nullptr, false),
|
|
ExternalContext(ExtContext) {
|
|
Context.setObjectFileInfo(TM->getObjFileLowering());
|
|
initialize();
|
|
}
|
|
|
|
MachineModuleInfo::~MachineModuleInfo() { finalize(); }
|
|
|
|
//===- Address of Block Management ----------------------------------------===//
|
|
|
|
ArrayRef<MCSymbol *>
|
|
MachineModuleInfo::getAddrLabelSymbolToEmit(const BasicBlock *BB) {
|
|
// Lazily create AddrLabelSymbols.
|
|
if (!AddrLabelSymbols)
|
|
AddrLabelSymbols = new MMIAddrLabelMap(getContext());
|
|
return AddrLabelSymbols->getAddrLabelSymbolToEmit(const_cast<BasicBlock*>(BB));
|
|
}
|
|
|
|
void MachineModuleInfo::
|
|
takeDeletedSymbolsForFunction(const Function *F,
|
|
std::vector<MCSymbol*> &Result) {
|
|
// If no blocks have had their addresses taken, we're done.
|
|
if (!AddrLabelSymbols) return;
|
|
return AddrLabelSymbols->
|
|
takeDeletedSymbolsForFunction(const_cast<Function*>(F), Result);
|
|
}
|
|
|
|
/// \name Exception Handling
|
|
/// \{
|
|
|
|
void MachineModuleInfo::addPersonality(const Function *Personality) {
|
|
if (!llvm::is_contained(Personalities, Personality))
|
|
Personalities.push_back(Personality);
|
|
}
|
|
|
|
/// \}
|
|
|
|
MachineFunction *
|
|
MachineModuleInfo::getMachineFunction(const Function &F) const {
|
|
auto I = MachineFunctions.find(&F);
|
|
return I != MachineFunctions.end() ? I->second.get() : nullptr;
|
|
}
|
|
|
|
MachineFunction &MachineModuleInfo::getOrCreateMachineFunction(Function &F) {
|
|
// Shortcut for the common case where a sequence of MachineFunctionPasses
|
|
// all query for the same Function.
|
|
if (LastRequest == &F)
|
|
return *LastResult;
|
|
|
|
auto I = MachineFunctions.insert(
|
|
std::make_pair(&F, std::unique_ptr<MachineFunction>()));
|
|
MachineFunction *MF;
|
|
if (I.second) {
|
|
// No pre-existing machine function, create a new one.
|
|
const TargetSubtargetInfo &STI = *TM.getSubtargetImpl(F);
|
|
MF = new MachineFunction(F, TM, STI, NextFnNum++, *this);
|
|
// Update the set entry.
|
|
I.first->second.reset(MF);
|
|
} else {
|
|
MF = I.first->second.get();
|
|
}
|
|
|
|
LastRequest = &F;
|
|
LastResult = MF;
|
|
return *MF;
|
|
}
|
|
|
|
void MachineModuleInfo::deleteMachineFunctionFor(Function &F) {
|
|
MachineFunctions.erase(&F);
|
|
LastRequest = nullptr;
|
|
LastResult = nullptr;
|
|
}
|
|
|
|
namespace {
|
|
|
|
/// This pass frees the MachineFunction object associated with a Function.
|
|
class FreeMachineFunction : public FunctionPass {
|
|
public:
|
|
static char ID;
|
|
|
|
FreeMachineFunction() : FunctionPass(ID) {}
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
AU.addRequired<MachineModuleInfoWrapperPass>();
|
|
AU.addPreserved<MachineModuleInfoWrapperPass>();
|
|
}
|
|
|
|
bool runOnFunction(Function &F) override {
|
|
MachineModuleInfo &MMI =
|
|
getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
|
|
MMI.deleteMachineFunctionFor(F);
|
|
return true;
|
|
}
|
|
|
|
StringRef getPassName() const override {
|
|
return "Free MachineFunction";
|
|
}
|
|
};
|
|
|
|
} // end anonymous namespace
|
|
|
|
char FreeMachineFunction::ID;
|
|
|
|
FunctionPass *llvm::createFreeMachineFunctionPass() {
|
|
return new FreeMachineFunction();
|
|
}
|
|
|
|
MachineModuleInfoWrapperPass::MachineModuleInfoWrapperPass(
|
|
const LLVMTargetMachine *TM)
|
|
: ImmutablePass(ID), MMI(TM) {
|
|
initializeMachineModuleInfoWrapperPassPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
MachineModuleInfoWrapperPass::MachineModuleInfoWrapperPass(
|
|
const LLVMTargetMachine *TM, MCContext *ExtContext)
|
|
: ImmutablePass(ID), MMI(TM, ExtContext) {
|
|
initializeMachineModuleInfoWrapperPassPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
// Handle the Pass registration stuff necessary to use DataLayout's.
|
|
INITIALIZE_PASS(MachineModuleInfoWrapperPass, "machinemoduleinfo",
|
|
"Machine Module Information", false, false)
|
|
char MachineModuleInfoWrapperPass::ID = 0;
|
|
|
|
static unsigned getLocCookie(const SMDiagnostic &SMD, const SourceMgr &SrcMgr,
|
|
std::vector<const MDNode *> &LocInfos) {
|
|
// Look up a LocInfo for the buffer this diagnostic is coming from.
|
|
unsigned BufNum = SrcMgr.FindBufferContainingLoc(SMD.getLoc());
|
|
const MDNode *LocInfo = nullptr;
|
|
if (BufNum > 0 && BufNum <= LocInfos.size())
|
|
LocInfo = LocInfos[BufNum - 1];
|
|
|
|
// If the inline asm had metadata associated with it, pull out a location
|
|
// cookie corresponding to which line the error occurred on.
|
|
unsigned LocCookie = 0;
|
|
if (LocInfo) {
|
|
unsigned ErrorLine = SMD.getLineNo() - 1;
|
|
if (ErrorLine >= LocInfo->getNumOperands())
|
|
ErrorLine = 0;
|
|
|
|
if (LocInfo->getNumOperands() != 0)
|
|
if (const ConstantInt *CI =
|
|
mdconst::dyn_extract<ConstantInt>(LocInfo->getOperand(ErrorLine)))
|
|
LocCookie = CI->getZExtValue();
|
|
}
|
|
|
|
return LocCookie;
|
|
}
|
|
|
|
bool MachineModuleInfoWrapperPass::doInitialization(Module &M) {
|
|
MMI.initialize();
|
|
MMI.TheModule = &M;
|
|
// FIXME: Do this for new pass manager.
|
|
LLVMContext &Ctx = M.getContext();
|
|
MMI.getContext().setDiagnosticHandler(
|
|
[&Ctx, &M](const SMDiagnostic &SMD, bool IsInlineAsm,
|
|
const SourceMgr &SrcMgr,
|
|
std::vector<const MDNode *> &LocInfos) {
|
|
unsigned LocCookie = 0;
|
|
if (IsInlineAsm)
|
|
LocCookie = getLocCookie(SMD, SrcMgr, LocInfos);
|
|
Ctx.diagnose(
|
|
DiagnosticInfoSrcMgr(SMD, M.getName(), IsInlineAsm, LocCookie));
|
|
});
|
|
MMI.DbgInfoAvailable = !DisableDebugInfoPrinting &&
|
|
!M.debug_compile_units().empty();
|
|
return false;
|
|
}
|
|
|
|
bool MachineModuleInfoWrapperPass::doFinalization(Module &M) {
|
|
MMI.finalize();
|
|
return false;
|
|
}
|
|
|
|
AnalysisKey MachineModuleAnalysis::Key;
|
|
|
|
MachineModuleInfo MachineModuleAnalysis::run(Module &M,
|
|
ModuleAnalysisManager &) {
|
|
MachineModuleInfo MMI(TM);
|
|
MMI.TheModule = &M;
|
|
MMI.DbgInfoAvailable = !DisableDebugInfoPrinting &&
|
|
!M.debug_compile_units().empty();
|
|
return MMI;
|
|
}
|