================
@@ -82,76 +116,79 @@ class OffloadBinary : public Binary {
LLVM_ABI static Expected<std::unique_ptr<OffloadBinary>>
create(MemoryBufferRef);
- /// Serialize the contents of \p File to a binary buffer to be read later.
- LLVM_ABI static SmallString<0> write(const OffloadingImage &);
+ /// Serialize the contents of \p OffloadingData to a binary buffer to be read
+ /// later.
+ LLVM_ABI static SmallString<0>
+ write(ArrayRef<OffloadingImage> OffloadingData);
static uint64_t getAlignment() { return 8; }
- ImageKind getImageKind() const { return TheEntry->TheImageKind; }
- OffloadKind getOffloadKind() const { return TheEntry->TheOffloadKind; }
+ ImageKind getOnlyImageKind() const {
+ assert(getEntriesCount() == 1 && "Expected exactly one entry.");
+ return Entries[0].first->TheImageKind;
+ }
+
+ OffloadKind getOffloadKind() const { return
Entries[0].first->TheOffloadKind; }
uint32_t getVersion() const { return TheHeader->Version; }
- uint32_t getFlags() const { return TheEntry->Flags; }
+ uint32_t getFlags() const { return Entries[0].first->Flags; }
uint64_t getSize() const { return TheHeader->Size; }
+ uint64_t getEntriesCount() const { return TheHeader->EntriesCount; }
StringRef getTriple() const { return getString("triple"); }
StringRef getArch() const { return getString("arch"); }
StringRef getImage() const {
- return StringRef(&Buffer[TheEntry->ImageOffset], TheEntry->ImageSize);
+ return StringRef(&Buffer[Entries[0].first->ImageOffset],
Entries[0].first->ImageSize);
}
- // Iterator over all the key and value pairs in the binary.
- string_iterator_range strings() const { return StringData; }
+ // Iterator access to all entries in the binary
+ entry_iterator_range entries() const {
+ return make_range(Entries.begin(), Entries.end());
+ }
+ entry_iterator entries_begin() const { return Entries.begin(); }
+ entry_iterator entries_end() const { return Entries.end(); }
- StringRef getString(StringRef Key) const { return StringData.lookup(Key); }
+ // Access specific entry by index.
+ const std::pair<const Entry *, StringMap> &getEntry(size_t Index) const {
+ assert(Index < Entries.size() && "Entry index out of bounds");
+ return Entries[Index];
+ }
- static bool classof(const Binary *V) { return V->isOffloadFile(); }
+ // Iterator over all the key and value pairs in the binary.
+ string_iterator_range strings() const { return Entries[0].second; }
- struct Header {
- uint8_t Magic[4] = {0x10, 0xFF, 0x10, 0xAD}; // 0x10FF10AD magic bytes.
- uint32_t Version = OffloadBinary::Version; // Version identifier.
- uint64_t Size; // Size in bytes of this entire binary.
- uint64_t EntryOffset; // Offset of the metadata entry in bytes.
- uint64_t EntrySize; // Size of the metadata entry in bytes.
- };
+ StringRef getString(StringRef Key) const { return
Entries[0].second.lookup(Key); }
- struct Entry {
- ImageKind TheImageKind; // The kind of the image stored.
- OffloadKind TheOffloadKind; // The producer of this image.
- uint32_t Flags; // Additional flags associated with the image.
- uint64_t StringOffset; // Offset in bytes to the string map.
- uint64_t NumStrings; // Number of entries in the string map.
- uint64_t ImageOffset; // Offset in bytes of the actual binary image.
- uint64_t ImageSize; // Size in bytes of the binary image.
- };
-
- struct StringEntry {
- uint64_t KeyOffset;
- uint64_t ValueOffset;
- };
+ static bool classof(const Binary *V) { return V->isOffloadFile(); }
private:
OffloadBinary(MemoryBufferRef Source, const Header *TheHeader,
- const Entry *TheEntry)
+ const Entry *EntriesBegin)
: Binary(Binary::ID_Offload, Source), Buffer(Source.getBufferStart()),
- TheHeader(TheHeader), TheEntry(TheEntry) {
- const StringEntry *StringMapBegin =
- reinterpret_cast<const StringEntry *>(&Buffer[TheEntry->StringOffset]);
- for (uint64_t I = 0, E = TheEntry->NumStrings; I != E; ++I) {
- StringRef Key = &Buffer[StringMapBegin[I].KeyOffset];
- StringData[Key] = &Buffer[StringMapBegin[I].ValueOffset];
+ TheHeader(TheHeader) {
+ for (uint64_t EI = 0, EE = TheHeader->EntriesCount; EI != EE; ++EI) {
+ const Entry *TheEntry = &EntriesBegin[EI];
+ const StringEntry *StringMapBegin = reinterpret_cast<const StringEntry
*>(
+ &Buffer[TheEntry->StringOffset]);
+ StringMap Strings;
+ for (uint64_t SI = 0, SE = TheEntry->NumStrings; SI != SE; ++SI) {
+ StringRef Key = &Buffer[StringMapBegin[SI].KeyOffset];
+ StringRef Value = StringRef(
+ &Buffer[StringMapBegin[SI].ValueOffset],
StringMapBegin[SI].ValueSize);
+ Strings.insert({Key, Value});
+ }
+ Entries.push_back(std::make_pair(TheEntry, std::move(Strings)));
}
}
OffloadBinary(const OffloadBinary &Other) = delete;
- /// Map from keys to offsets in the binary.
- MapVector<StringRef, StringRef> StringData;
+ /// Location of the metadata entries within the binary mapped to
+ /// the key-value string data.
+ SmallVector<std::pair<const Entry *, StringMap>, 1> Entries;
----------------
jhuber6 wrote:
Can't decide if this should be two vectors that take the same index
https://github.com/llvm/llvm-project/pull/169425
_______________________________________________
cfe-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
