Mercurial > hg > CbC > CbC_llvm

comparison tools/dsymutil/BinaryHolder.h @ 83:60c9769439b8 LLVM3.7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM 3.7
author Tatsuki IHA <e125716@ie.u-ryukyu.ac.jp>
date Wed, 18 Feb 2015 14:55:36 +0900
parents
children afa8332a0e37
comparison
equal deleted inserted replaced
78:af83660cff7b 83:60c9769439b8
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