namespace llvm {
+class AddrLabelMap;
class BasicBlock;
class BlockAddress;
class Constant;
// function. This is used to calculate the size of the BB section.
MCSymbol *CurrentSectionBeginSym = nullptr;
+ /// This map keeps track of which symbol is being used for the specified basic
+ /// block's address of label.
+ std::unique_ptr<AddrLabelMap> AddrLabelSymbols;
+
// The garbage collection metadata printer table.
void *GCMetadataPrinters = nullptr; // Really a DenseMap.
// given basic block.
MCSymbol *getMBBExceptionSym(const MachineBasicBlock &MBB);
+ /// Return the symbol to be used for the specified basic block when its
+ /// address is taken. This cannot be its normal LBB label because the block
+ /// may be accessed outside its containing function.
+ MCSymbol *getAddrLabelSymbol(const BasicBlock *BB) {
+ return getAddrLabelSymbolToEmit(BB).front();
+ }
+
+ /// Return the symbol to be used for the specified basic block when its
+ /// address is taken. If other blocks were RAUW'd to this one, we may have
+ /// to emit them as well, return the whole set.
+ ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB);
+
+ /// If the specified function has had any references to address-taken blocks
+ /// generated, but the block got deleted, return the symbol now so we can
+ /// emit it. This prevents emitting a reference to a symbol that has no
+ /// definition.
+ void takeDeletedSymbolsForFunction(const Function *F,
+ std::vector<MCSymbol *> &Result);
+
/// Return information about object file lowering.
const TargetLoweringObjectFile &getObjFileLowering() const;
class BasicBlock;
class Function;
class LLVMTargetMachine;
-class MMIAddrLabelMap;
class MachineFunction;
class Module;
class MCSymbol;
/// \}
- /// This map keeps track of which symbol is being used for the specified
- /// basic block's address of label.
- MMIAddrLabelMap *AddrLabelSymbols;
-
// TODO: Ideally, what we'd like is to have a switch that allows emitting
// synchronous (precise at call-sites only) CFA into .eh_frame. However,
// even under this switch, we'd like .debug_frame to be precise when using
void setUsesMSVCFloatingPoint(bool b) { UsesMSVCFloatingPoint = b; }
- /// Return the symbol to be used for the specified basic block when its
- /// address is taken. This cannot be its normal LBB label because the block
- /// may be accessed outside its containing function.
- MCSymbol *getAddrLabelSymbol(const BasicBlock *BB) {
- return getAddrLabelSymbolToEmit(BB).front();
- }
-
- /// Return the symbol to be used for the specified basic block when its
- /// address is taken. If other blocks were RAUW'd to this one, we may have
- /// to emit them as well, return the whole set.
- ArrayRef<MCSymbol *> getAddrLabelSymbolToEmit(const BasicBlock *BB);
-
- /// If the specified function has had any references to address-taken blocks
- /// generated, but the block got deleted, return the symbol now so we can
- /// emit it. This prevents emitting a reference to a symbol that has no
- /// definition.
- void takeDeletedSymbolsForFunction(const Function *F,
- std::vector<MCSymbol*> &Result);
-
/// \name Exception Handling
/// \{
return *(gcp_map_type*)P;
}
+namespace {
+class AddrLabelMapCallbackPtr final : CallbackVH {
+ AddrLabelMap *Map = nullptr;
+
+public:
+ AddrLabelMapCallbackPtr() = default;
+ AddrLabelMapCallbackPtr(Value *V) : CallbackVH(V) {}
+
+ void setPtr(BasicBlock *BB) {
+ ValueHandleBase::operator=(BB);
+ }
+
+ void setMap(AddrLabelMap *map) { Map = map; }
+
+ void deleted() override;
+ void allUsesReplacedWith(Value *V2) override;
+};
+} // namespace
+
+class llvm::AddrLabelMap {
+ 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<AddrLabelMapCallbackPtr> 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:
+ AddrLabelMap(MCContext &context) : Context(context) {}
+
+ ~AddrLabelMap() {
+ 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);
+};
+
+ArrayRef<MCSymbol *> AddrLabelMap::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 AddrLabelMap::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);
+}
+
+//===- Address of Block Management ----------------------------------------===//
+
+ArrayRef<MCSymbol *>
+AsmPrinter::getAddrLabelSymbolToEmit(const BasicBlock *BB) {
+ // Lazily create AddrLabelSymbols.
+ if (!AddrLabelSymbols)
+ AddrLabelSymbols = std::make_unique<AddrLabelMap>(OutContext);
+ return AddrLabelSymbols->getAddrLabelSymbolToEmit(
+ const_cast<BasicBlock *>(BB));
+}
+
+void AsmPrinter::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);
+}
+
+void AddrLabelMap::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 AddrLabelMap::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 AddrLabelMapCallbackPtr::deleted() {
+ Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr()));
+}
+
+void AddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) {
+ Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2));
+}
+
/// getGVAlignment - Return the alignment to use for the specified global
/// value. This rounds up to the preferred alignment if possible and legal.
Align AsmPrinter::getGVAlignment(const GlobalObject *GV, const DataLayout &DL,
HasSplitStack = false;
HasNoSplitStack = false;
+ AddrLabelSymbols = nullptr;
+
// Initialize TargetLoweringObjectFile.
const_cast<TargetLoweringObjectFile&>(getObjFileLowering())
.Initialize(OutContext, TM);
// references to the dangling symbols. Emit them at the start of the function
// so that we don't get references to undefined symbols.
std::vector<MCSymbol*> DeadBlockSyms;
- MMI->takeDeletedSymbolsForFunction(&F, DeadBlockSyms);
+ takeDeletedSymbolsForFunction(&F, DeadBlockSyms);
for (MCSymbol *DeadBlockSym : DeadBlockSyms) {
OutStreamer->AddComment("Address taken block that was later removed");
OutStreamer->emitLabel(DeadBlockSym);
emitEndOfAsmFile(M);
MMI = nullptr;
+ AddrLabelSymbols = nullptr;
OutStreamer->Finish();
OutStreamer->reset();
}
MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BlockAddress *BA) const {
- return MMI->getAddrLabelSymbol(BA->getBasicBlock());
+ return const_cast<AsmPrinter *>(this)->getAddrLabelSymbol(
+ BA->getBasicBlock());
}
MCSymbol *AsmPrinter::GetBlockAddressSymbol(const BasicBlock *BB) const {
- return MMI->getAddrLabelSymbol(BB);
+ return const_cast<AsmPrinter *>(this)->getAddrLabelSymbol(BB);
}
/// GetCPISymbol - Return the symbol for the specified constant pool entry.
// MBBs can have their address taken as part of CodeGen without having
// their corresponding BB's address taken in IR
if (BB && BB->hasAddressTaken())
- for (MCSymbol *Sym : MMI->getAddrLabelSymbolToEmit(BB))
+ for (MCSymbol *Sym : getAddrLabelSymbolToEmit(BB))
OutStreamer->emitLabel(Sym);
}
#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"
// 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.
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() { 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
/// \{
projects / platform / upstream / llvm.git / commitdiff