1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
//===-- BinaryHolder.h - Utility class for accessing binaries -------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This program is a utility that aims to be a dropin replacement for
// Darwin's dsymutil.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_TOOLS_DSYMUTIL_BINARYHOLDER_H
#define LLVM_TOOLS_DSYMUTIL_BINARYHOLDER_H
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/Triple.h"
#include "llvm/Object/Archive.h"
#include "llvm/Object/Error.h"
#include "llvm/Object/MachOUniversal.h"
#include "llvm/Object/ObjectFile.h"
#include "llvm/Support/Chrono.h"
#include "llvm/Support/Errc.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/VirtualFileSystem.h"
#include <mutex>
namespace llvm {
namespace dsymutil {
/// The BinaryHolder class is responsible for creating and owning
/// ObjectFiles and their underlying MemoryBuffers. It differs from a simple
/// OwningBinary in that it handles accessing and caching of archives and its
/// members.
class BinaryHolder {
public:
using TimestampTy = sys::TimePoint<std::chrono::seconds>;
BinaryHolder(IntrusiveRefCntPtr<vfs::FileSystem> VFS, bool Verbose = false)
: VFS(VFS), Verbose(Verbose) {}
// Forward declarations for friend declaration.
class ObjectEntry;
class ArchiveEntry;
/// Base class shared by cached entries, representing objects and archives.
class EntryBase {
protected:
std::unique_ptr<MemoryBuffer> MemBuffer;
std::unique_ptr<object::MachOUniversalBinary> FatBinary;
std::string FatBinaryName;
};
/// Cached entry holding one or more (in case of a fat binary) object files.
class ObjectEntry : public EntryBase {
public:
/// Load the given object binary in memory.
Error load(IntrusiveRefCntPtr<vfs::FileSystem> VFS, StringRef Filename,
TimestampTy Timestamp, bool Verbose = false);
/// Access all owned ObjectFiles.
std::vector<const object::ObjectFile *> getObjects() const;
/// Access to a derived version of all the currently owned ObjectFiles. The
/// conversion might be invalid, in which case an Error is returned.
template <typename ObjectFileType>
Expected<std::vector<const ObjectFileType *>> getObjectsAs() const {
std::vector<const ObjectFileType *> Result;
Result.reserve(Objects.size());
for (auto &Object : Objects) {
const auto *Derived = dyn_cast<ObjectFileType>(Object.get());
if (!Derived)
return errorCodeToError(object::object_error::invalid_file_type);
Result.push_back(Derived);
}
return Result;
}
/// Access the owned ObjectFile with architecture \p T.
Expected<const object::ObjectFile &> getObject(const Triple &T) const;
/// Access to a derived version of the currently owned ObjectFile with
/// architecture \p T. The conversion must be known to be valid.
template <typename ObjectFileType>
Expected<const ObjectFileType &> getObjectAs(const Triple &T) const {
auto Object = getObject(T);
if (!Object)
return Object.takeError();
return cast<ObjectFileType>(*Object);
}
private:
std::vector<std::unique_ptr<object::ObjectFile>> Objects;
friend ArchiveEntry;
};
/// Cached entry holding one or more (in the of a fat binary) archive files.
class ArchiveEntry : public EntryBase {
public:
struct KeyTy {
std::string Filename;
TimestampTy Timestamp;
KeyTy() : Filename(), Timestamp() {}
KeyTy(StringRef Filename, TimestampTy Timestamp)
: Filename(Filename.str()), Timestamp(Timestamp) {}
};
/// Load the given object binary in memory.
Error load(IntrusiveRefCntPtr<vfs::FileSystem> VFS, StringRef Filename,
TimestampTy Timestamp, bool Verbose = false);
Expected<const ObjectEntry &> getObjectEntry(StringRef Filename,
TimestampTy Timestamp,
bool Verbose = false);
private:
std::vector<std::unique_ptr<object::Archive>> Archives;
DenseMap<KeyTy, ObjectEntry> MemberCache;
std::mutex MemberCacheMutex;
};
Expected<const ObjectEntry &>
getObjectEntry(StringRef Filename, TimestampTy Timestamp = TimestampTy());
void clear();
private:
/// Cache of static archives. Objects that are part of a static archive are
/// stored under this object, rather than in the map below.
StringMap<ArchiveEntry> ArchiveCache;
std::mutex ArchiveCacheMutex;
/// Object entries for objects that are not in a static archive.
StringMap<ObjectEntry> ObjectCache;
std::mutex ObjectCacheMutex;
/// Virtual File System instance.
IntrusiveRefCntPtr<vfs::FileSystem> VFS;
bool Verbose;
};
} // namespace dsymutil
template <> struct DenseMapInfo<dsymutil::BinaryHolder::ArchiveEntry::KeyTy> {
static inline dsymutil::BinaryHolder::ArchiveEntry::KeyTy getEmptyKey() {
return dsymutil::BinaryHolder::ArchiveEntry::KeyTy();
}
static inline dsymutil::BinaryHolder::ArchiveEntry::KeyTy getTombstoneKey() {
return dsymutil::BinaryHolder::ArchiveEntry::KeyTy("/", {});
}
static unsigned
getHashValue(const dsymutil::BinaryHolder::ArchiveEntry::KeyTy &K) {
return hash_combine(DenseMapInfo<StringRef>::getHashValue(K.Filename),
DenseMapInfo<unsigned>::getHashValue(
K.Timestamp.time_since_epoch().count()));
}
static bool isEqual(const dsymutil::BinaryHolder::ArchiveEntry::KeyTy &LHS,
const dsymutil::BinaryHolder::ArchiveEntry::KeyTy &RHS) {
return LHS.Filename == RHS.Filename && LHS.Timestamp == RHS.Timestamp;
}
};
} // namespace llvm
#endif
|
