1 //===- Core/Atom.h - A node in linking graph --------------------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 #ifndef LLD_CORE_ATOM_H
10 #define LLD_CORE_ATOM_H
12 #include "lld/Common/LLVM.h"
13 #include "llvm/ADT/StringRef.h"
23 /// The linker has a Graph Theory model of linking. An object file is seen
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
26 /// content or a UndefinedAtom which is a placeholder and represents an
27 /// undefined symbol (extern declaration).
30 template<typename T> friend class OwningAtomPtr;
33 /// Whether this atom is defined or a proxy for an undefined symbol
35 definitionRegular, ///< Normal C/C++ function or global variable.
36 definitionAbsolute, ///< Asm-only (foo = 10). Not tied to any content.
37 definitionUndefined, ///< Only in .o files to model reference to undef.
38 definitionSharedLibrary ///< Only in shared libraries to model export.
41 /// The scope in which this atom is accessible to other atoms.
43 scopeTranslationUnit, ///< Accessible only to atoms in the same translation
44 /// unit (e.g. a C static).
45 scopeLinkageUnit, ///< Accessible to atoms being linked but not visible
46 /// to runtime loader (e.g. visibility=hidden).
47 scopeGlobal ///< Accessible to all atoms and visible to runtime
48 /// loader (e.g. visibility=default).
51 /// file - returns the File that produced/owns this Atom
52 virtual const File& file() const = 0;
54 /// name - The name of the atom. For a function atom, it is the (mangled)
55 /// name of the function.
56 virtual StringRef name() const = 0;
58 /// definition - Whether this atom is a definition or represents an undefined
60 Definition definition() const { return _definition; }
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) {}
68 /// The memory for Atom objects is always managed by the owning File
69 /// object. Therefore, no one but the owning File object should call
70 /// delete on an Atom. In fact, some File objects may bulk allocate
71 /// an array of Atoms, so they cannot be individually deleted by anyone.
72 virtual ~Atom() = default;
75 Definition _definition;
78 /// Class which owns an atom pointer and runs the atom destructor when the
79 /// owning pointer goes out of scope.
83 OwningAtomPtr(const OwningAtomPtr &) = delete;
84 void operator=(const OwningAtomPtr &) = delete;
87 OwningAtomPtr() = default;
88 OwningAtomPtr(T *atom) : atom(atom) { }
95 void runDestructor(Atom *atom) {
99 OwningAtomPtr(OwningAtomPtr &&ptr) : atom(ptr.atom) {
103 void operator=(OwningAtomPtr&& ptr) {
110 T *const &get() const {
128 } // end namespace lld
130 #endif // LLD_CORE_ATOM_H