Update prebuilt Clang to r365631c1 from Android.
The version we had was segfaulting.
Bug: 132420445
Change-Id: Icb45a6fe0b4e2166f7895e669df1157cec9fb4e0
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h
index e194e59..68a0fc3 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/ELFYAML.h
@@ -52,6 +52,7 @@
// Just use 64, since it can hold 32-bit values too.
LLVM_YAML_STRONG_TYPEDEF(uint64_t, ELF_SHF)
LLVM_YAML_STRONG_TYPEDEF(uint16_t, ELF_SHN)
+LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STB)
LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STT)
LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STV)
LLVM_YAML_STRONG_TYPEDEF(uint8_t, ELF_STO)
@@ -74,6 +75,11 @@
ELF_EM Machine;
ELF_EF Flags;
llvm::yaml::Hex64 Entry;
+
+ Optional<llvm::yaml::Hex16> SHEntSize;
+ Optional<llvm::yaml::Hex16> SHOffset;
+ Optional<llvm::yaml::Hex16> SHNum;
+ Optional<llvm::yaml::Hex16> SHStrNdx;
};
struct SectionName {
@@ -86,25 +92,24 @@
llvm::yaml::Hex64 VAddr;
llvm::yaml::Hex64 PAddr;
Optional<llvm::yaml::Hex64> Align;
+ Optional<llvm::yaml::Hex64> FileSize;
+ Optional<llvm::yaml::Hex64> MemSize;
+ Optional<llvm::yaml::Hex64> Offset;
std::vector<SectionName> Sections;
};
struct Symbol {
StringRef Name;
+ Optional<uint32_t> NameIndex;
ELF_STT Type;
StringRef Section;
Optional<ELF_SHN> Index;
+ ELF_STB Binding;
llvm::yaml::Hex64 Value;
llvm::yaml::Hex64 Size;
uint8_t Other;
};
-struct LocalGlobalWeakSymbols {
- std::vector<Symbol> Local;
- std::vector<Symbol> Global;
- std::vector<Symbol> Weak;
-};
-
struct SectionOrType {
StringRef sectionNameOrType;
};
@@ -121,23 +126,31 @@
RawContent,
Relocation,
NoBits,
+ Verdef,
+ Verneed,
+ Symver,
MipsABIFlags
};
SectionKind Kind;
StringRef Name;
ELF_SHT Type;
- ELF_SHF Flags;
+ Optional<ELF_SHF> Flags;
llvm::yaml::Hex64 Address;
StringRef Link;
llvm::yaml::Hex64 AddressAlign;
Optional<llvm::yaml::Hex64> EntSize;
+ // This can be used to override the sh_offset field. It does not place the
+ // section data at the offset specified. Useful for creating invalid objects.
+ Optional<llvm::yaml::Hex64> ShOffset;
+
Section(SectionKind Kind) : Kind(Kind) {}
virtual ~Section();
};
struct DynamicSection : Section {
std::vector<DynamicEntry> Entries;
+ Optional<yaml::BinaryRef> Content;
DynamicSection() : Section(SectionKind::Dynamic) {}
@@ -147,8 +160,9 @@
};
struct RawContentSection : Section {
- yaml::BinaryRef Content;
- llvm::yaml::Hex64 Size;
+ Optional<yaml::BinaryRef> Content;
+ Optional<llvm::yaml::Hex64> Size;
+ Optional<llvm::yaml::Hex64> Info;
RawContentSection() : Section(SectionKind::RawContent) {}
@@ -167,6 +181,59 @@
}
};
+struct VernauxEntry {
+ uint32_t Hash;
+ uint16_t Flags;
+ uint16_t Other;
+ StringRef Name;
+};
+
+struct VerneedEntry {
+ uint16_t Version;
+ StringRef File;
+ std::vector<VernauxEntry> AuxV;
+};
+
+struct VerneedSection : Section {
+ std::vector<VerneedEntry> VerneedV;
+ llvm::yaml::Hex64 Info;
+
+ VerneedSection() : Section(SectionKind::Verneed) {}
+
+ static bool classof(const Section *S) {
+ return S->Kind == SectionKind::Verneed;
+ }
+};
+
+struct SymverSection : Section {
+ std::vector<uint16_t> Entries;
+
+ SymverSection() : Section(SectionKind::Symver) {}
+
+ static bool classof(const Section *S) {
+ return S->Kind == SectionKind::Symver;
+ }
+};
+
+struct VerdefEntry {
+ uint16_t Version;
+ uint16_t Flags;
+ uint16_t VersionNdx;
+ uint32_t Hash;
+ std::vector<StringRef> VerNames;
+};
+
+struct VerdefSection : Section {
+ std::vector<VerdefEntry> Entries;
+ llvm::yaml::Hex64 Info;
+
+ VerdefSection() : Section(SectionKind::Verdef) {}
+
+ static bool classof(const Section *S) {
+ return S->Kind == SectionKind::Verdef;
+ }
+};
+
struct Group : Section {
// Members of a group contain a flag and a list of section indices
// that are part of the group.
@@ -227,8 +294,8 @@
// cleaner and nicer if we read them from the YAML as a separate
// top-level key, which automatically ensures that invariants like there
// being a single SHT_SYMTAB section are upheld.
- LocalGlobalWeakSymbols Symbols;
- LocalGlobalWeakSymbols DynamicSymbols;
+ std::vector<Symbol> Symbols;
+ std::vector<Symbol> DynamicSymbols;
};
} // end namespace ELFYAML
@@ -238,6 +305,9 @@
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::ProgramHeader)
LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::ELFYAML::Section>)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Symbol)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerdefEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VernauxEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::VerneedEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::Relocation)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionOrType)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::ELFYAML::SectionName)
@@ -297,6 +367,10 @@
static void enumeration(IO &IO, ELFYAML::ELF_SHN &Value);
};
+template <> struct ScalarEnumerationTraits<ELFYAML::ELF_STB> {
+ static void enumeration(IO &IO, ELFYAML::ELF_STB &Value);
+};
+
template <>
struct ScalarEnumerationTraits<ELFYAML::ELF_STT> {
static void enumeration(IO &IO, ELFYAML::ELF_STT &Value);
@@ -372,15 +446,22 @@
static StringRef validate(IO &IO, ELFYAML::Symbol &Symbol);
};
-template <>
-struct MappingTraits<ELFYAML::LocalGlobalWeakSymbols> {
- static void mapping(IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols);
-};
-
template <> struct MappingTraits<ELFYAML::DynamicEntry> {
static void mapping(IO &IO, ELFYAML::DynamicEntry &Rel);
};
+template <> struct MappingTraits<ELFYAML::VerdefEntry> {
+ static void mapping(IO &IO, ELFYAML::VerdefEntry &E);
+};
+
+template <> struct MappingTraits<ELFYAML::VerneedEntry> {
+ static void mapping(IO &IO, ELFYAML::VerneedEntry &E);
+};
+
+template <> struct MappingTraits<ELFYAML::VernauxEntry> {
+ static void mapping(IO &IO, ELFYAML::VernauxEntry &E);
+};
+
template <> struct MappingTraits<ELFYAML::Relocation> {
static void mapping(IO &IO, ELFYAML::Relocation &Rel);
};
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/MinidumpYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/MinidumpYAML.h
new file mode 100644
index 0000000..39fdd62
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ObjectYAML/MinidumpYAML.h
@@ -0,0 +1,239 @@
+//===- MinidumpYAML.h - Minidump YAMLIO implementation ----------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECTYAML_MINIDUMPYAML_H
+#define LLVM_OBJECTYAML_MINIDUMPYAML_H
+
+#include "llvm/BinaryFormat/Minidump.h"
+#include "llvm/Object/Minidump.h"
+#include "llvm/ObjectYAML/YAML.h"
+#include "llvm/Support/YAMLTraits.h"
+
+namespace llvm {
+namespace MinidumpYAML {
+
+/// The base class for all minidump streams. The "Type" of the stream
+/// corresponds to the Stream Type field in the minidump file. The "Kind" field
+/// specifies how are we going to treat it. For highly specialized streams (e.g.
+/// SystemInfo), there is a 1:1 mapping between Types and Kinds, but in general
+/// one stream Kind can be used to represent multiple stream Types (e.g. any
+/// unrecognised stream Type will be handled via RawContentStream). The mapping
+/// from Types to Kinds is fixed and given by the static getKind function.
+struct Stream {
+ enum class StreamKind {
+ MemoryList,
+ ModuleList,
+ RawContent,
+ SystemInfo,
+ TextContent,
+ ThreadList,
+ };
+
+ Stream(StreamKind Kind, minidump::StreamType Type) : Kind(Kind), Type(Type) {}
+ virtual ~Stream(); // anchor
+
+ const StreamKind Kind;
+ const minidump::StreamType Type;
+
+ /// Get the stream Kind used for representing streams of a given Type.
+ static StreamKind getKind(minidump::StreamType Type);
+
+ /// Create an empty stream of the given Type.
+ static std::unique_ptr<Stream> create(minidump::StreamType Type);
+
+ /// Create a stream from the given stream directory entry.
+ static Expected<std::unique_ptr<Stream>>
+ create(const minidump::Directory &StreamDesc,
+ const object::MinidumpFile &File);
+};
+
+namespace detail {
+/// A stream representing a list of abstract entries in a minidump stream. Its
+/// instantiations can be used to represent the ModuleList stream and other
+/// streams with a similar structure.
+template <typename EntryT> struct ListStream : public Stream {
+ using entry_type = EntryT;
+
+ std::vector<entry_type> Entries;
+
+ explicit ListStream(std::vector<entry_type> Entries = {})
+ : Stream(EntryT::Kind, EntryT::Type), Entries(std::move(Entries)) {}
+
+ static bool classof(const Stream *S) { return S->Kind == EntryT::Kind; }
+};
+
+/// A structure containing all data belonging to a single minidump module.
+struct ParsedModule {
+ static constexpr Stream::StreamKind Kind = Stream::StreamKind::ModuleList;
+ static constexpr minidump::StreamType Type = minidump::StreamType::ModuleList;
+
+ minidump::Module Entry;
+ std::string Name;
+ yaml::BinaryRef CvRecord;
+ yaml::BinaryRef MiscRecord;
+};
+
+/// A structure containing all data belonging to a single minidump thread.
+struct ParsedThread {
+ static constexpr Stream::StreamKind Kind = Stream::StreamKind::ThreadList;
+ static constexpr minidump::StreamType Type = minidump::StreamType::ThreadList;
+
+ minidump::Thread Entry;
+ yaml::BinaryRef Stack;
+ yaml::BinaryRef Context;
+};
+
+/// A structure containing all data describing a single memory region.
+struct ParsedMemoryDescriptor {
+ static constexpr Stream::StreamKind Kind = Stream::StreamKind::MemoryList;
+ static constexpr minidump::StreamType Type = minidump::StreamType::MemoryList;
+
+ minidump::MemoryDescriptor Entry;
+ yaml::BinaryRef Content;
+};
+} // namespace detail
+
+using ModuleListStream = detail::ListStream<detail::ParsedModule>;
+using ThreadListStream = detail::ListStream<detail::ParsedThread>;
+using MemoryListStream = detail::ListStream<detail::ParsedMemoryDescriptor>;
+
+/// A minidump stream represented as a sequence of hex bytes. This is used as a
+/// fallback when no other stream kind is suitable.
+struct RawContentStream : public Stream {
+ yaml::BinaryRef Content;
+ yaml::Hex32 Size;
+
+ RawContentStream(minidump::StreamType Type, ArrayRef<uint8_t> Content = {})
+ : Stream(StreamKind::RawContent, Type), Content(Content),
+ Size(Content.size()) {}
+
+ static bool classof(const Stream *S) {
+ return S->Kind == StreamKind::RawContent;
+ }
+};
+
+/// SystemInfo minidump stream.
+struct SystemInfoStream : public Stream {
+ minidump::SystemInfo Info;
+ std::string CSDVersion;
+
+ explicit SystemInfoStream(const minidump::SystemInfo &Info,
+ std::string CSDVersion)
+ : Stream(StreamKind::SystemInfo, minidump::StreamType::SystemInfo),
+ Info(Info), CSDVersion(std::move(CSDVersion)) {}
+
+ SystemInfoStream()
+ : Stream(StreamKind::SystemInfo, minidump::StreamType::SystemInfo) {
+ memset(&Info, 0, sizeof(Info));
+ }
+
+ static bool classof(const Stream *S) {
+ return S->Kind == StreamKind::SystemInfo;
+ }
+};
+
+/// A StringRef, which is printed using YAML block notation.
+LLVM_YAML_STRONG_TYPEDEF(StringRef, BlockStringRef)
+
+/// A minidump stream containing textual data (typically, the contents of a
+/// /proc/<pid> file on linux).
+struct TextContentStream : public Stream {
+ BlockStringRef Text;
+
+ TextContentStream(minidump::StreamType Type, StringRef Text = {})
+ : Stream(StreamKind::TextContent, Type), Text(Text) {}
+
+ static bool classof(const Stream *S) {
+ return S->Kind == StreamKind::TextContent;
+ }
+};
+
+/// The top level structure representing a minidump object, consisting of a
+/// minidump header, and zero or more streams. To construct an Object from a
+/// minidump file, use the static create function. To serialize to/from yaml,
+/// use the appropriate streaming operator on a yaml stream.
+struct Object {
+ Object() = default;
+ Object(const Object &) = delete;
+ Object &operator=(const Object &) = delete;
+ Object(Object &&) = default;
+ Object &operator=(Object &&) = default;
+
+ Object(const minidump::Header &Header,
+ std::vector<std::unique_ptr<Stream>> Streams)
+ : Header(Header), Streams(std::move(Streams)) {}
+
+ /// The minidump header.
+ minidump::Header Header;
+
+ /// The list of streams in this minidump object.
+ std::vector<std::unique_ptr<Stream>> Streams;
+
+ static Expected<Object> create(const object::MinidumpFile &File);
+};
+
+/// Serialize the minidump file represented by Obj to OS in binary form.
+void writeAsBinary(Object &Obj, raw_ostream &OS);
+
+/// Serialize the yaml string as a minidump file to OS in binary form.
+Error writeAsBinary(StringRef Yaml, raw_ostream &OS);
+
+} // namespace MinidumpYAML
+
+namespace yaml {
+template <> struct BlockScalarTraits<MinidumpYAML::BlockStringRef> {
+ static void output(const MinidumpYAML::BlockStringRef &Text, void *,
+ raw_ostream &OS) {
+ OS << Text;
+ }
+
+ static StringRef input(StringRef Scalar, void *,
+ MinidumpYAML::BlockStringRef &Text) {
+ Text = Scalar;
+ return "";
+ }
+};
+
+template <> struct MappingTraits<std::unique_ptr<MinidumpYAML::Stream>> {
+ static void mapping(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
+ static StringRef validate(IO &IO, std::unique_ptr<MinidumpYAML::Stream> &S);
+};
+
+template <> struct MappingContextTraits<minidump::MemoryDescriptor, BinaryRef> {
+ static void mapping(IO &IO, minidump::MemoryDescriptor &Memory,
+ BinaryRef &Content);
+};
+
+} // namespace yaml
+
+} // namespace llvm
+
+LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::ProcessorArchitecture)
+LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::OSPlatform)
+LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::minidump::StreamType)
+
+LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::ArmInfo)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::OtherInfo)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::CPUInfo::X86Info)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::minidump::VSFixedFileInfo)
+
+LLVM_YAML_DECLARE_MAPPING_TRAITS(
+ llvm::MinidumpYAML::MemoryListStream::entry_type)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(
+ llvm::MinidumpYAML::ModuleListStream::entry_type)
+LLVM_YAML_DECLARE_MAPPING_TRAITS(
+ llvm::MinidumpYAML::ThreadListStream::entry_type)
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(std::unique_ptr<llvm::MinidumpYAML::Stream>)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::MemoryListStream::entry_type)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::ModuleListStream::entry_type)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::MinidumpYAML::ThreadListStream::entry_type)
+
+LLVM_YAML_DECLARE_MAPPING_TRAITS(llvm::MinidumpYAML::Object)
+
+#endif // LLVM_OBJECTYAML_MINIDUMPYAML_H
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h
index 56f5f39..0015fd3 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/ObjectYAML.h
@@ -12,6 +12,7 @@
#include "llvm/ObjectYAML/COFFYAML.h"
#include "llvm/ObjectYAML/ELFYAML.h"
#include "llvm/ObjectYAML/MachOYAML.h"
+#include "llvm/ObjectYAML/MinidumpYAML.h"
#include "llvm/ObjectYAML/WasmYAML.h"
#include "llvm/Support/YAMLTraits.h"
#include <memory>
@@ -26,6 +27,7 @@
std::unique_ptr<COFFYAML::Object> Coff;
std::unique_ptr<MachOYAML::Object> MachO;
std::unique_ptr<MachOYAML::UniversalBinary> FatMachO;
+ std::unique_ptr<MinidumpYAML::Object> Minidump;
std::unique_ptr<WasmYAML::Object> Wasm;
};
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h
index f5260bb..2411dc7 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/WasmYAML.h
@@ -38,6 +38,7 @@
LLVM_YAML_STRONG_TYPEDEF(uint32_t, SegmentFlags)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, LimitFlags)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, ComdatKind)
+LLVM_YAML_STRONG_TYPEDEF(uint32_t, FeaturePolicyPrefix)
struct FileHeader {
yaml::Hex32 Version;
@@ -111,8 +112,9 @@
};
struct DataSegment {
- uint32_t MemoryIndex;
uint32_t SectionOffset;
+ uint32_t InitFlags;
+ uint32_t MemoryIndex;
wasm::WasmInitExpr Offset;
yaml::BinaryRef Content;
};
@@ -127,6 +129,11 @@
std::string Version;
};
+struct FeatureEntry {
+ FeaturePolicyPrefix Prefix;
+ std::string Name;
+};
+
struct SegmentInfo {
uint32_t Index;
StringRef Name;
@@ -241,6 +248,17 @@
std::vector<ProducerEntry> SDKs;
};
+struct TargetFeaturesSection : CustomSection {
+ TargetFeaturesSection() : CustomSection("target_features") {}
+
+ static bool classof(const Section *S) {
+ auto C = dyn_cast<CustomSection>(S);
+ return C && C->Name == "target_features";
+ }
+
+ std::vector<FeatureEntry> Features;
+};
+
struct TypeSection : Section {
TypeSection() : Section(wasm::WASM_SEC_TYPE) {}
@@ -361,6 +379,16 @@
std::vector<DataSegment> Segments;
};
+struct DataCountSection : Section {
+ DataCountSection() : Section(wasm::WASM_SEC_DATACOUNT) {}
+
+ static bool classof(const Section *S) {
+ return S->Type == wasm::WASM_SEC_DATACOUNT;
+ }
+
+ uint32_t Count;
+};
+
struct Object {
FileHeader Header;
std::vector<std::unique_ptr<Section>> Sections;
@@ -384,6 +412,7 @@
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::Relocation)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::NameEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::ProducerEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::FeatureEntry)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SegmentInfo)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::SymbolInfo)
LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::WasmYAML::InitFunction)
@@ -466,6 +495,14 @@
static void mapping(IO &IO, WasmYAML::ProducerEntry &ProducerEntry);
};
+template <> struct ScalarEnumerationTraits<WasmYAML::FeaturePolicyPrefix> {
+ static void enumeration(IO &IO, WasmYAML::FeaturePolicyPrefix &Prefix);
+};
+
+template <> struct MappingTraits<WasmYAML::FeatureEntry> {
+ static void mapping(IO &IO, WasmYAML::FeatureEntry &FeatureEntry);
+};
+
template <> struct MappingTraits<WasmYAML::SegmentInfo> {
static void mapping(IO &IO, WasmYAML::SegmentInfo &SegmentInfo);
};
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/XCOFFYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/XCOFFYAML.h
new file mode 100644
index 0000000..f99004e
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ObjectYAML/XCOFFYAML.h
@@ -0,0 +1,71 @@
+//===----- XCOFFYAML.h - XCOFF YAMLIO implementation ------------*- C++ -*-===//
+//
+// 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 file declares classes for handling the YAML representation of XCOFF.
+//
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_OBJECTYAML_XCOFFYAML_H
+#define LLVM_OBJECTYAML_XCOFFYAML_H
+
+#include "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/ObjectYAML/YAML.h"
+#include <vector>
+
+namespace llvm {
+namespace XCOFFYAML {
+
+struct FileHeader {
+ llvm::yaml::Hex16 Magic;
+ uint16_t NumberOfSections;
+ int32_t TimeStamp;
+ llvm::yaml::Hex32 SymbolTableOffset; // File offset to symbol table.
+ int32_t NumberOfSymTableEntries;
+ uint16_t AuxHeaderSize;
+ llvm::yaml::Hex16 Flags;
+};
+
+struct Symbol {
+ StringRef SymbolName;
+ llvm::yaml::Hex32 Value; // Symbol value; storage class-dependent.
+ StringRef SectionName;
+ llvm::yaml::Hex16 Type;
+ XCOFF::StorageClass StorageClass;
+ uint8_t NumberOfAuxEntries; // Number of auxiliary entries
+};
+
+struct Object {
+ FileHeader Header;
+ std::vector<Symbol> Symbols;
+ Object();
+};
+} // namespace XCOFFYAML
+} // namespace llvm
+LLVM_YAML_IS_SEQUENCE_VECTOR(XCOFFYAML::Symbol)
+namespace llvm {
+namespace yaml {
+
+template <> struct ScalarEnumerationTraits<XCOFF::StorageClass> {
+ static void enumeration(IO &IO, XCOFF::StorageClass &Value);
+};
+
+template <> struct MappingTraits<XCOFFYAML::FileHeader> {
+ static void mapping(IO &IO, XCOFFYAML::FileHeader &H);
+};
+
+template <> struct MappingTraits<XCOFFYAML::Object> {
+ static void mapping(IO &IO, XCOFFYAML::Object &Obj);
+};
+
+template <> struct MappingTraits<XCOFFYAML::Symbol> {
+ static void mapping(IO &IO, XCOFFYAML::Symbol &S);
+};
+
+} // namespace yaml
+} // namespace llvm
+
+#endif // LLVM_OBJECTYAML_XCOFFYAML_H
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/YAML.h b/linux-x64/clang/include/llvm/ObjectYAML/YAML.h
index a14bfbc..3701410 100644
--- a/linux-x64/clang/include/llvm/ObjectYAML/YAML.h
+++ b/linux-x64/clang/include/llvm/ObjectYAML/YAML.h
@@ -73,8 +73,7 @@
public:
BinaryRef() = default;
BinaryRef(ArrayRef<uint8_t> Data) : Data(Data), DataIsHexString(false) {}
- BinaryRef(StringRef Data)
- : Data(reinterpret_cast<const uint8_t *>(Data.data()), Data.size()) {}
+ BinaryRef(StringRef Data) : Data(arrayRefFromStringRef(Data)) {}
/// The number of bytes that are represented by this BinaryRef.
/// This is the number of bytes that writeAsBinary() will write.