1 //===- Core/File.h - A Container of Atoms ---------------------------------===//
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLD_CORE_FILE_H
11 #define LLD_CORE_FILE_H
13 #include "lld/Core/AbsoluteAtom.h"
14 #include "lld/Core/DefinedAtom.h"
15 #include "lld/Core/SharedLibraryAtom.h"
16 #include "lld/Core/UndefinedAtom.h"
17 #include "llvm/ADT/Optional.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/Twine.h"
20 #include "llvm/Support/ErrorHandling.h"
30 /// Every Atom is owned by some File. A common scenario is for a single
31 /// object file (.o) to be parsed by some reader and produce a single
32 /// File object that represents the content of that object file.
34 /// To iterate through the Atoms in a File there are four methods that
35 /// return collections. For instance to iterate through all the DefinedAtoms
36 /// in a File object use:
37 /// for (const DefinedAtoms *atom : file->defined()) {
40 /// The Atom objects in a File are owned by the File object. The Atom objects
41 /// are destroyed when the File object is destroyed.
46 /// \brief Kinds of files that are supported.
48 kindErrorObject, ///< a error object file (.o)
49 kindNormalizedObject, ///< a normalized file (.o)
50 kindMachObject, ///< a MachO object file (.o)
51 kindCEntryObject, ///< a file for CEntries
52 kindHeaderObject, ///< a file for file headers
53 kindEntryObject, ///< a file for the entry
54 kindUndefinedSymsObject, ///< a file for undefined symbols
55 kindStubHelperObject, ///< a file for stub helpers
56 kindResolverMergedObject, ///< the resolver merged file.
57 kindSectCreateObject, ///< a sect create object file (.o)
58 kindSharedLibrary, ///< shared library (.so)
59 kindArchiveLibrary ///< archive (.a)
62 /// \brief Returns file kind. Need for dyn_cast<> on File objects.
67 /// This returns the path to the file which was used to create this object
68 /// (e.g. "/tmp/foo.o"). If the file is a member of an archive file, the
69 /// returned string includes the archive file name.
70 StringRef path() const {
71 if (_archivePath.empty())
73 if (_archiveMemberPath.empty())
74 _archiveMemberPath = (_archivePath + "(" + _path + ")").str();
75 return _archiveMemberPath;
78 /// Returns the path of the archive file name if this file is instantiated
79 /// from an archive file. Otherwise returns the empty string.
80 StringRef archivePath() const { return _archivePath; }
81 void setArchivePath(StringRef path) { _archivePath = path; }
83 /// Returns the path name of this file. It doesn't include archive file name.
84 StringRef memberPath() const { return _path; }
86 /// Returns the command line order of the file.
87 uint64_t ordinal() const {
88 assert(_ordinal != UINT64_MAX);
92 /// Returns true/false depending on whether an ordinal has been set.
93 bool hasOrdinal() const { return (_ordinal != UINT64_MAX); }
95 /// Sets the command line order of the file.
96 void setOrdinal(uint64_t ordinal) const { _ordinal = ordinal; }
98 /// Returns the ordinal for the next atom to be defined in this file.
99 uint64_t getNextAtomOrdinalAndIncrement() const {
100 return _nextAtomOrdinal++;
103 /// For allocating any objects owned by this File.
104 llvm::BumpPtrAllocator &allocator() const {
108 /// The type of atom mutable container.
109 template <typename T> using AtomVector = std::vector<OwningAtomPtr<T>>;
111 /// The range type for the atoms.
112 template <typename T> class AtomRange {
114 AtomRange(AtomVector<T> &v) : _v(v) {}
115 AtomRange(const AtomVector<T> &v) : _v(const_cast<AtomVector<T> &>(v)) {}
117 typedef std::pointer_to_unary_function<const OwningAtomPtr<T>&,
118 const T*> ConstDerefFn;
120 typedef std::pointer_to_unary_function<OwningAtomPtr<T>&, T*> DerefFn;
122 typedef llvm::mapped_iterator<typename AtomVector<T>::const_iterator,
123 ConstDerefFn> ConstItTy;
124 typedef llvm::mapped_iterator<typename AtomVector<T>::iterator,
127 static const T* DerefConst(const OwningAtomPtr<T> &p) {
131 static T* Deref(OwningAtomPtr<T> &p) {
135 ConstItTy begin() const {
136 return ConstItTy(_v.begin(), ConstDerefFn(DerefConst));
138 ConstItTy end() const {
139 return ConstItTy(_v.end(), ConstDerefFn(DerefConst));
143 return ItTy(_v.begin(), DerefFn(Deref));
146 return ItTy(_v.end(), DerefFn(Deref));
149 llvm::iterator_range<typename AtomVector<T>::iterator> owning_ptrs() {
150 return llvm::make_range(_v.begin(), _v.end());
153 llvm::iterator_range<typename AtomVector<T>::iterator> owning_ptrs() const {
154 return llvm::make_range(_v.begin(), _v.end());
161 size_t size() const {
165 const OwningAtomPtr<T> &operator[](size_t idx) const {
169 OwningAtomPtr<T> &operator[](size_t idx) {
177 /// \brief Must be implemented to return the AtomVector object for
178 /// all DefinedAtoms in this File.
179 virtual const AtomRange<DefinedAtom> defined() const = 0;
181 /// \brief Must be implemented to return the AtomVector object for
182 /// all UndefinedAtomw in this File.
183 virtual const AtomRange<UndefinedAtom> undefined() const = 0;
185 /// \brief Must be implemented to return the AtomVector object for
186 /// all SharedLibraryAtoms in this File.
187 virtual const AtomRange<SharedLibraryAtom> sharedLibrary() const = 0;
189 /// \brief Must be implemented to return the AtomVector object for
190 /// all AbsoluteAtoms in this File.
191 virtual const AtomRange<AbsoluteAtom> absolute() const = 0;
193 /// Drop all of the atoms owned by this file. This will result in all of
194 /// the atoms running their destructors.
195 /// This is required because atoms may be allocated on a BumpPtrAllocator
196 /// of a different file. We need to destruct all atoms before any files.
197 virtual void clearAtoms() = 0;
199 /// \brief If a file is parsed using a different method than doParse(),
200 /// one must use this method to set the last error status, so that
201 /// doParse will not be called twice. Only YAML reader uses this
202 /// (because YAML reader does not read blobs but structured data).
203 void setLastError(std::error_code err) { _lastError = err; }
205 std::error_code parse();
207 // Usually each file owns a std::unique_ptr<MemoryBuffer>.
208 // However, there's one special case. If a file is an archive file,
209 // the archive file and its children all shares the same memory buffer.
210 // This method is used by the ArchiveFile to give its children
211 // co-ownership of the buffer.
212 void setSharedMemoryBuffer(std::shared_ptr<MemoryBuffer> mb) {
213 _sharedMemoryBuffer = mb;
217 /// \brief only subclasses of File can be instantiated
218 File(StringRef p, Kind kind)
219 : _path(p), _kind(kind), _ordinal(UINT64_MAX),
220 _nextAtomOrdinal(0) {}
222 /// \brief Subclasses should override this method to parse the
223 /// memory buffer passed to this file's constructor.
224 virtual std::error_code doParse() { return std::error_code(); }
226 static AtomVector<DefinedAtom> _noDefinedAtoms;
227 static AtomVector<UndefinedAtom> _noUndefinedAtoms;
228 static AtomVector<SharedLibraryAtom> _noSharedLibraryAtoms;
229 static AtomVector<AbsoluteAtom> _noAbsoluteAtoms;
230 mutable llvm::BumpPtrAllocator _allocator;
234 std::string _archivePath;
235 mutable std::string _archiveMemberPath;
237 mutable uint64_t _ordinal;
238 mutable uint64_t _nextAtomOrdinal;
239 std::shared_ptr<MemoryBuffer> _sharedMemoryBuffer;
240 llvm::Optional<std::error_code> _lastError;
241 std::mutex _parseMutex;
244 /// An ErrorFile represents a file that doesn't exist.
245 /// If you try to parse a file which doesn't exist, an instance of this
246 /// class will be returned. That's parse method always returns an error.
247 /// This is useful to delay erroring on non-existent files, so that we
248 /// can do unit testing a driver using non-existing file paths.
249 class ErrorFile : public File {
251 ErrorFile(StringRef path, std::error_code ec)
252 : File(path, kindErrorObject), _ec(ec) {}
254 std::error_code doParse() override { return _ec; }
256 const AtomRange<DefinedAtom> defined() const override {
257 llvm_unreachable("internal error");
259 const AtomRange<UndefinedAtom> undefined() const override {
260 llvm_unreachable("internal error");
262 const AtomRange<SharedLibraryAtom> sharedLibrary() const override {
263 llvm_unreachable("internal error");
265 const AtomRange<AbsoluteAtom> absolute() const override {
266 llvm_unreachable("internal error");
269 void clearAtoms() override {
276 } // end namespace lld