|
83
|
1 //===-- BinaryHolder.h - Utility class for accessing binaries -------------===//
|
|
|
2 //
|
|
|
3 // The LLVM Compiler Infrastructure
|
|
|
4 //
|
|
|
5 // This file is distributed under the University of Illinois Open Source
|
|
|
6 // License. See LICENSE.TXT for details.
|
|
|
7 //
|
|
|
8 //===----------------------------------------------------------------------===//
|
|
|
9 //
|
|
|
10 // This program is a utility that aims to be a dropin replacement for
|
|
|
11 // Darwin's dsymutil.
|
|
|
12 //
|
|
|
13 //===----------------------------------------------------------------------===//
|
|
|
14 #ifndef LLVM_TOOLS_DSYMUTIL_BINARYHOLDER_H
|
|
|
15 #define LLVM_TOOLS_DSYMUTIL_BINARYHOLDER_H
|
|
|
16
|
|
|
17 #include "llvm/Object/Archive.h"
|
|
|
18 #include "llvm/Object/Error.h"
|
|
|
19 #include "llvm/Object/ObjectFile.h"
|
|
|
20 #include "llvm/Support/Errc.h"
|
|
|
21 #include "llvm/Support/ErrorOr.h"
|
|
|
22
|
|
|
23 namespace llvm {
|
|
|
24 namespace dsymutil {
|
|
|
25
|
|
|
26 /// \brief The BinaryHolder class is responsible for creating and
|
|
|
27 /// owning ObjectFile objects and their underlying MemoryBuffer. This
|
|
|
28 /// is different from a simple OwningBinary in that it handles
|
|
|
29 /// accessing to archive members.
|
|
|
30 ///
|
|
|
31 /// As an optimization, this class will reuse an already mapped and
|
|
|
32 /// parsed Archive object if 2 successive requests target the same
|
|
|
33 /// archive file (Which is always the case in debug maps).
|
|
|
34 /// Currently it only owns one memory buffer at any given time,
|
|
|
35 /// meaning that a mapping request will invalidate the previous memory
|
|
|
36 /// mapping.
|
|
|
37 class BinaryHolder {
|
|
|
38 std::unique_ptr<object::Archive> CurrentArchive;
|
|
|
39 std::unique_ptr<MemoryBuffer> CurrentMemoryBuffer;
|
|
|
40 std::unique_ptr<object::ObjectFile> CurrentObjectFile;
|
|
|
41 bool Verbose;
|
|
|
42
|
|
|
43 /// \brief Get the MemoryBufferRef for the file specification in \p
|
|
|
44 /// Filename from the current archive.
|
|
|
45 ///
|
|
|
46 /// This function performs no system calls, it just looks up a
|
|
|
47 /// potential match for the given \p Filename in the currently
|
|
|
48 /// mapped archive if there is one.
|
|
|
49 ErrorOr<MemoryBufferRef> GetArchiveMemberBuffer(StringRef Filename);
|
|
|
50
|
|
|
51 /// \brief Interpret Filename as an archive member specification,
|
|
|
52 /// map the corresponding archive to memory and return the
|
|
|
53 /// MemoryBufferRef corresponding to the described member.
|
|
|
54 ErrorOr<MemoryBufferRef> MapArchiveAndGetMemberBuffer(StringRef Filename);
|
|
|
55
|
|
|
56 /// \brief Return the MemoryBufferRef that holds the memory
|
|
|
57 /// mapping for the given \p Filename. This function will try to
|
|
|
58 /// parse archive member specifications of the form
|
|
|
59 /// /path/to/archive.a(member.o).
|
|
|
60 ///
|
|
|
61 /// The returned MemoryBufferRef points to a buffer owned by this
|
|
|
62 /// object. The buffer is valid until the next call to
|
|
|
63 /// GetMemoryBufferForFile() on this object.
|
|
|
64 ErrorOr<MemoryBufferRef> GetMemoryBufferForFile(StringRef Filename);
|
|
|
65
|
|
|
66 public:
|
|
|
67 BinaryHolder(bool Verbose) : Verbose(Verbose) {}
|
|
|
68
|
|
|
69 /// \brief Get the ObjectFile designated by the \p Filename. This
|
|
|
70 /// might be an archive member specification of the form
|
|
|
71 /// /path/to/archive.a(member.o).
|
|
|
72 ///
|
|
|
73 /// Calling this function invalidates the previous mapping owned by
|
|
|
74 /// the BinaryHolder.
|
|
|
75 ErrorOr<const object::ObjectFile &> GetObjectFile(StringRef Filename);
|
|
|
76
|
|
|
77 /// \brief Wraps GetObjectFile() to return a derived ObjectFile type.
|
|
|
78 template <typename ObjectFileType>
|
|
|
79 ErrorOr<const ObjectFileType &> GetFileAs(StringRef Filename) {
|
|
|
80 auto ErrOrObjFile = GetObjectFile(Filename);
|
|
|
81 if (auto Err = ErrOrObjFile.getError())
|
|
|
82 return Err;
|
|
|
83 if (const auto *Derived = dyn_cast<ObjectFileType>(CurrentObjectFile.get()))
|
|
|
84 return *Derived;
|
|
|
85 return make_error_code(object::object_error::invalid_file_type);
|
|
|
86 }
|
|
|
87
|
|
|
88 /// \brief Access the currently owned ObjectFile. As successfull
|
|
|
89 /// call to GetObjectFile() or GetFileAs() must have been performed
|
|
|
90 /// before calling this.
|
|
|
91 const object::ObjectFile &Get() {
|
|
|
92 assert(CurrentObjectFile);
|
|
|
93 return *CurrentObjectFile;
|
|
|
94 }
|
|
|
95
|
|
|
96 /// \brief Access to a derived version of the currently owned
|
|
|
97 /// ObjectFile. The conversion must be known to be valid.
|
|
|
98 template <typename ObjectFileType> const ObjectFileType &GetAs() {
|
|
|
99 return cast<ObjectFileType>(*CurrentObjectFile);
|
|
|
100 }
|
|
|
101 };
|
|
|
102 }
|
|
|
103 }
|
|
|
104 #endif
|
