/freebsd-12-stable/contrib/llvm-project/lld/include/lld/Core/ |
H A D | AbsoluteAtom.h | 1 //===- Core/AbsoluteAtom.h - An absolute Atom -----------------------------===// 12 #include "lld/Core/Atom.h" 18 class AbsoluteAtom : public Atom { 30 static bool classof(const Atom *a) { 37 AbsoluteAtom() : Atom(definitionAbsolute) {}
|
H A D | UndefinedAtom.h | 1 //===- Core/UndefinedAtom.h - An Undefined Atom ---------------------------===// 12 #include "lld/Core/Atom.h" 18 class UndefinedAtom : public Atom { 53 static bool classof(const Atom *a) { 60 UndefinedAtom() : Atom(definitionUndefined) {}
|
H A D | SharedLibraryAtom.h | 1 //===- Core/SharedLibraryAtom.h - A Shared Library Atom -------------------===// 12 #include "lld/Core/Atom.h" 18 class SharedLibraryAtom : public Atom { 38 static bool classof(const Atom *a) { 45 SharedLibraryAtom() : Atom(definitionSharedLibrary) {}
|
H A D | SymbolTable.h | 22 class Atom; 49 const Atom *findByName(StringRef sym); 55 const Atom *replacement(const Atom *); 58 bool isCoalescedAway(const Atom *); 61 typedef llvm::DenseMap<const Atom *, const Atom *> AtomToAtom; 73 typedef llvm::DenseMap<StringRef, const Atom *, 85 bool addByName(const Atom &);
|
H A D | Resolver.h | 1 //===- Core/Resolver.h - Resolves Atom References -------------------------===// 27 class Atom; 71 void markLive(const Atom *atom); 76 void addAtoms(llvm::MutableArrayRef<OwningAtomPtr<Atom>> atoms); 81 std::vector<OwningAtomPtr<Atom>> _atoms; 82 std::set<const Atom *> _deadStripRoots; 83 llvm::DenseSet<const Atom *> _liveAtoms; 84 llvm::DenseSet<const Atom *> _deadAtoms; 86 std::unordered_multimap<const Atom *, const Atom *> _reverseRe [all...] |
H A D | Atom.h | 1 //===- Core/Atom.h - A node in linking graph --------------------*- C++ -*-===// 24 /// as a set of Atoms with References to other Atoms. Each Atom is a node 25 /// and each Reference is an edge. An Atom can be a DefinedAtom which has 29 class Atom { class in namespace:lld 51 /// file - returns the File that produced/owns this Atom 62 static bool classof(const Atom *a) { return true; } 65 /// Atom is an abstract base class. Only subclasses can access constructor. 66 explicit Atom(Definition def) : _definition(def) {} function in class:lld::Atom 68 /// The memory for Atom objects is always managed by the owning File 70 /// delete on an Atom [all...] |
H A D | Reference.h | 1 //===- Core/References.h - A Reference to Another Atom ----------*- C++ -*-===// 16 class Atom; 20 /// as a set of Atoms with References to other Atoms. Each Atom is a node 24 /// the Atom, then the function Atom will have a Reference of: offsetInAtom=40, 80 /// If the reference is a fixup in the Atom, then this returns the 81 /// byte offset into the Atom's content to do the fix up. 85 virtual const Atom *target() const = 0; 89 virtual void setTarget(const Atom *) = 0;
|
H A D | DefinedAtom.h | 1 //===- Core/DefinedAtom.h - An Atom with content --------------------------===// 13 #include "lld/Core/Atom.h" 84 class DefinedAtom : public Atom { 214 /// returns a value for the order of this Atom within its file. 282 /// returns a reference to the raw (unrelocated) bytes of this Atom's 287 /// in an Atom. Concrete instances of DefinedAtom must implement 319 /// Returns an iterator to the beginning of this Atom's References. 322 /// Returns an iterator to the end of this Atom's References. 329 const Atom *target, Reference::Addend a) { 333 static bool classof(const Atom * [all...] |
H A D | Simple.h | 1 //===- lld/Core/Simple.h - Simple implementations of Atom and File --------===// 18 #include "lld/Core/Atom.h" 63 void addAtom(const Atom &atom) { 118 Reference::KindValue value, uint64_t off, const Atom *t, 128 const Atom *target() const override { 135 void setTarget(const Atom *newAtom) override { _target = newAtom; } 138 const Atom *_target; 203 const Atom *target, Reference::Addend a) override { 254 /// file - returns the File that produced/owns this Atom
|
/freebsd-12-stable/contrib/llvm-project/llvm/include/llvm/CodeGen/ |
H A D | AccelTable.h | 222 /// An Atom defines the form of the data in an Apple accelerator table. 225 struct Atom { struct in class:llvm::AppleAccelTableData 226 /// Atom Type. 231 constexpr Atom(uint16_t Type, uint16_t Form) : Type(Type), Form(Form) {} function in struct:llvm::AppleAccelTableData::Atom 239 // static constexpr Atom Atoms[]; 296 ArrayRef<AppleAccelTableData::Atom> Atoms); 327 static constexpr Atom Atoms[] = { 328 Atom(dwarf::DW_ATOM_die_offset, dwarf::DW_FORM_data4)}; 346 static constexpr Atom Atoms[] = { 347 Atom(dwar [all...] |
/freebsd-12-stable/contrib/llvm-project/lld/lib/ReaderWriter/MachO/ |
H A D | CompactUnwindPass.cpp | 35 const Atom *rangeStart; 36 const Atom *personalityFunction; 37 const Atom *lsdaLocation; 38 const Atom *ehFrame; 68 std::vector<const Atom *> &personalities, 147 void addPersonalityFunctions(std::vector<const Atom *> personalities) { 243 void addEhFrameReference(uint32_t offset, const Atom *dest, 249 void addImageReference(uint32_t offset, const Atom *dest, 255 void addImageReferenceIndirect(uint32_t offset, const Atom *dest) { 286 std::map<const Atom *, CompactUnwindEntr [all...] |
H A D | ArchHandler.h | 104 virtual const Atom *fdeTargetFunction(const DefinedAtom *fde); 124 const lld::Atom **, Reference::Addend *)> 130 const lld::Atom **)> FindAtomBySymbolIndex; 144 const lld::Atom **target, 160 const lld::Atom **target, 165 typedef std::function<uint32_t (const Atom &atom)> FindSymbolIndexForAtom; 169 typedef std::function<uint32_t (const Atom &atom)> FindSectionIndexForAtom; 173 typedef std::function<uint64_t (const Atom &atom)> FindAddressForAtom; 180 /// Copy raw content then apply all fixup References on an Atom.
|
H A D | StubsPass.cpp | 32 // Lazy Pointer Atom created by the stubs pass. 68 // NonLazyPointer (GOT) Atom created by the stubs pass. 105 // Stub Atom created by the stubs pass. 139 // Stub Helper Atom created by the stubs pass. 174 // Stub Helper Common Atom created by the stubs pass. 228 const Atom *target = ref->target(); 282 std::vector<const Atom *> targetsNeedingStubs; 286 [](const Atom * left, const Atom * right) { 292 for (const Atom *targe [all...] |
H A D | GOTPass.cpp | 14 /// Offsets Table). In the object file, the Atom containing this instruction 15 /// has a Reference whose target is an Atom named "foo" and the Reference 17 /// GOT entry. This is done be creating a GOT Atom to represent that pointer 18 /// sized data in this pass, and altering the Atom graph so the Reference now 19 /// points to the GOT Atom entry (corresponding to "foo") and changing the 49 // GOT Entry Atom created by the GOT pass. 108 const Atom *target = ref->target(); 139 bool shouldReplaceTargetWithGOTAtom(const Atom *target, bool canBypassGOT) { 156 const DefinedAtom *makeGOTEntry(const Atom *target) { 174 llvm::DenseMap<const Atom*, cons [all...] |
H A D | TLVPass.cpp | 25 // TLVP Entry Atom created by the TLV pass. 88 const Atom *target = ref->target(); 112 const DefinedAtom *makeTLVPEntry(const Atom *target) { 131 llvm::DenseMap<const Atom*, const TLVPEntryAtom*> _targetToTLVP;
|
H A D | DebugInfo.h | 12 #include "lld/Core/Atom.h" 65 Stab(const Atom* atom, uint8_t type, uint8_t other, uint16_t desc, 70 const class Atom* atom;
|
H A D | ShimPass.cpp | 56 const Atom *target = ref->target(); 118 llvm::DenseMap<const Atom*, const DefinedAtom*> _targetToShim;
|
H A D | MachONormalizedFileFromAtoms.cpp | 150 typedef llvm::DenseMap<const Atom*, uint64_t> AtomToAddress; 167 const Atom *targetOfLazyPointer(const DefinedAtom *lpAtom); 168 const Atom *targetOfStub(const DefinedAtom *stubAtom); 173 uint32_t sectionIndexForAtom(const Atom *atom); 177 typedef llvm::DenseMap<const Atom*, uint32_t> AtomToIndex; 178 struct AtomAndIndex { const Atom *atom; uint32_t index; SymbolScope scope; }; 202 std::vector<const Atom *> _machHeaderAliasAtoms; 657 auto addrForAtom = [&] (const Atom &atom) -> uint64_t { 663 auto sectionAddrForAtom = [&] (const Atom &atom) -> uint64_t { 767 for (const Atom *ato [all...] |
H A D | File.h | 39 void addDefinedAtom(StringRef name, Atom::Scope scope, 61 void addDefinedAtomInCustomSection(StringRef name, Atom::Scope scope, 86 void addZeroFillDefinedAtom(StringRef name, Atom::Scope scope, 126 void addTentativeDefAtom(StringRef name, Atom::Scope scope, uint64_t size, 167 const lld::Atom *findUndefAtom(StringRef name) { 266 typedef llvm::StringMap<const lld::Atom *> NameToAtom;
|
H A D | ArchHandler_x86.cpp | 95 const lld::Atom **target, 106 const lld::Atom **target, 161 static bool useExternalRelocationTo(const Atom &target); 258 const lld::Atom **target, 357 const lld::Atom **target, 364 const lld::Atom *fromTarget; 421 const Atom *target = ref->target(); 530 bool ArchHandler_x86::useExternalRelocationTo(const Atom &target) {
|
/freebsd-12-stable/contrib/llvm-project/lld/lib/Core/ |
H A D | Resolver.cpp | 1 //===- Core/Resolver.cpp - Resolves Atom References -----------------------===// 12 #include "lld/Core/Atom.h" 58 const Atom *atom = _symbolTable.findByName(undefName); 117 _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); 146 _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); 161 _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); 173 if (atom.get()->scope() != Atom::scopeTranslationUnit) 177 _atoms.push_back(OwningAtomPtr<Atom>(atom.release())); 298 for (const OwningAtomPtr<Atom> &atom : _atoms) { 311 const Atom *newTarge [all...] |
H A D | SymbolTable.cpp | 12 #include "lld/Core/Atom.h" 84 static NameCollisionResolution collide(Atom::Definition first, 85 Atom::Definition second) { 114 bool SymbolTable::addByName(const Atom &newAtom) { 117 const Atom *existing = findByName(name); 244 const Atom* existing = *pos; 250 const Atom *SymbolTable::findByName(StringRef sym) { 257 const Atom *SymbolTable::replacement(const Atom *atom) { 268 bool SymbolTable::isCoalescedAway(const Atom *ato [all...] |
/freebsd-12-stable/contrib/llvm-project/llvm/lib/DebugInfo/DWARF/ |
H A D | DWARFAcceleratorTable.cpp | 28 struct Atom { struct in namespace:__anon4686 32 static raw_ostream &operator<<(raw_ostream &OS, const Atom &A) { 40 static Atom formatAtom(unsigned Atom) { return {Atom}; } argument 96 for (auto Atom : getAtomsDesc()) { 97 DWARFFormValue FormValue(Atom.second); 98 switch (Atom.first) { 120 for (auto Atom : getAtomsDesc()) { 121 DWARFFormValue FormValue(Atom [all...] |
/freebsd-12-stable/contrib/llvm-project/llvm/lib/CodeGen/AsmPrinter/ |
H A D | AccelTable.cpp | 116 using Atom = AppleAccelTableData::Atom; 148 const SmallVector<Atom, 4> Atoms; 150 HeaderData(ArrayRef<Atom> AtomList, uint32_t Offset = 0) 169 ArrayRef<Atom> Atoms, const MCSymbol *SecBegin) 297 Asm->OutStreamer->AddComment("HeaderData Atom Count"); 300 for (const Atom &A : Atoms) { 546 ArrayRef<AppleAccelTableData::Atom> Atoms) { 617 constexpr AppleAccelTableData::Atom AppleAccelTableTypeData::Atoms[]; 618 constexpr AppleAccelTableData::Atom AppleAccelTableOffsetDat [all...] |
/freebsd-12-stable/contrib/llvm-project/lldb/source/Plugins/SymbolFile/DWARF/ |
H A D | HashedNameToDIE.h | 72 struct Atom { struct 78 typedef std::vector<Atom> AtomArray;
|