Import prebuilt clang toolchain for linux.
diff --git a/linux-x64/clang/include/llvm/ObjectYAML/DWARFYAML.h b/linux-x64/clang/include/llvm/ObjectYAML/DWARFYAML.h
new file mode 100644
index 0000000..2162f0f
--- /dev/null
+++ b/linux-x64/clang/include/llvm/ObjectYAML/DWARFYAML.h
@@ -0,0 +1,309 @@
+//===- DWARFYAML.h - DWARF YAMLIO implementation ----------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// \brief This file declares classes for handling the YAML representation
+/// of DWARF Debug Info.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECTYAML_DWARFYAML_H
+#define LLVM_OBJECTYAML_DWARFYAML_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/Dwarf.h"
+#include "llvm/Support/YAMLTraits.h"
+#include <cstdint>
+#include <vector>
+
+namespace llvm {
+namespace DWARFYAML {
+
+struct InitialLength {
+ uint32_t TotalLength;
+ uint64_t TotalLength64;
+
+ bool isDWARF64() const { return TotalLength == UINT32_MAX; }
+
+ uint64_t getLength() const {
+ return isDWARF64() ? TotalLength64 : TotalLength;
+ }
+
+ void setLength(uint64_t Len) {
+ if (Len >= (uint64_t)UINT32_MAX) {
+ TotalLength64 = Len;
+ TotalLength = UINT32_MAX;
+ } else {
+ TotalLength = Len;
+ }
+ }
+};
+
+struct AttributeAbbrev {
+ llvm::dwarf::Attribute Attribute;
+ llvm::dwarf::Form Form;
+ llvm::yaml::Hex64 Value; // Some DWARF5 attributes have values
+};
+
+struct Abbrev {
+ llvm::yaml::Hex32 Code;
+ llvm::dwarf::Tag Tag;
+ llvm::dwarf::Constants Children;
+ std::vector<AttributeAbbrev> Attributes;
+};
+
+struct ARangeDescriptor {
+ llvm::yaml::Hex64 Address;
+ uint64_t Length;
+};
+
+struct ARange {
+ InitialLength Length;
+ uint16_t Version;
+ uint32_t CuOffset;
+ uint8_t AddrSize;
+ uint8_t SegSize;
+ std::vector<ARangeDescriptor> Descriptors;
+};
+
+struct PubEntry {
+ llvm::yaml::Hex32 DieOffset;
+ llvm::yaml::Hex8 Descriptor;
+ StringRef Name;
+};
+
+struct PubSection {
+ InitialLength Length;
+ uint16_t Version;
+ uint32_t UnitOffset;
+ uint32_t UnitSize;
+ bool IsGNUStyle = false;
+ std::vector<PubEntry> Entries;
+};
+
+struct FormValue {
+ llvm::yaml::Hex64 Value;
+ StringRef CStr;
+ std::vector<llvm::yaml::Hex8> BlockData;
+};
+
+struct Entry {
+ llvm::yaml::Hex32 AbbrCode;
+ std::vector<FormValue> Values;
+};
+
+struct Unit {
+ InitialLength Length;
+ uint16_t Version;
+ llvm::dwarf::UnitType Type; // Added in DWARF 5
+ uint32_t AbbrOffset;
+ uint8_t AddrSize;
+ std::vector<Entry> Entries;
+};
+
+struct File {
+ StringRef Name;
+ uint64_t DirIdx;
+ uint64_t ModTime;
+ uint64_t Length;
+};
+
+struct LineTableOpcode {
+ dwarf::LineNumberOps Opcode;
+ uint64_t ExtLen;
+ dwarf::LineNumberExtendedOps SubOpcode;
+ uint64_t Data;
+ int64_t SData;
+ File FileEntry;
+ std::vector<llvm::yaml::Hex8> UnknownOpcodeData;
+ std::vector<llvm::yaml::Hex64> StandardOpcodeData;
+};
+
+struct LineTable {
+ InitialLength Length;
+ uint16_t Version;
+ uint64_t PrologueLength;
+ uint8_t MinInstLength;
+ uint8_t MaxOpsPerInst;
+ uint8_t DefaultIsStmt;
+ uint8_t LineBase;
+ uint8_t LineRange;
+ uint8_t OpcodeBase;
+ std::vector<uint8_t> StandardOpcodeLengths;
+ std::vector<StringRef> IncludeDirs;
+ std::vector<File> Files;
+ std::vector<LineTableOpcode> Opcodes;
+};
+
+struct Data {
+ bool IsLittleEndian;
+ std::vector<Abbrev> AbbrevDecls;
+ std::vector<StringRef> DebugStrings;
+ std::vector<ARange> ARanges;
+ PubSection PubNames;
+ PubSection PubTypes;
+
+ PubSection GNUPubNames;
+ PubSection GNUPubTypes;
+
+ std::vector<Unit> CompileUnits;
+
+ std::vector<LineTable> DebugLines;
+
+ bool isEmpty() const;
+};
+
+} // end namespace DWARFYAML
+} // end namespace llvm
+
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex64)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::yaml::Hex8)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::AttributeAbbrev)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Abbrev)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARangeDescriptor)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::ARange)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::PubEntry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Unit)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::FormValue)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::Entry)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::File)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTable)
+LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DWARFYAML::LineTableOpcode)
+
+namespace llvm {
+namespace yaml {
+
+template <> struct MappingTraits<DWARFYAML::Data> {
+ static void mapping(IO &IO, DWARFYAML::Data &DWARF);
+};
+
+template <> struct MappingTraits<DWARFYAML::Abbrev> {
+ static void mapping(IO &IO, DWARFYAML::Abbrev &Abbrev);
+};
+
+template <> struct MappingTraits<DWARFYAML::AttributeAbbrev> {
+ static void mapping(IO &IO, DWARFYAML::AttributeAbbrev &AttAbbrev);
+};
+
+template <> struct MappingTraits<DWARFYAML::ARangeDescriptor> {
+ static void mapping(IO &IO, DWARFYAML::ARangeDescriptor &Descriptor);
+};
+
+template <> struct MappingTraits<DWARFYAML::ARange> {
+ static void mapping(IO &IO, DWARFYAML::ARange &Range);
+};
+
+template <> struct MappingTraits<DWARFYAML::PubEntry> {
+ static void mapping(IO &IO, DWARFYAML::PubEntry &Entry);
+};
+
+template <> struct MappingTraits<DWARFYAML::PubSection> {
+ static void mapping(IO &IO, DWARFYAML::PubSection &Section);
+};
+
+template <> struct MappingTraits<DWARFYAML::Unit> {
+ static void mapping(IO &IO, DWARFYAML::Unit &Unit);
+};
+
+template <> struct MappingTraits<DWARFYAML::Entry> {
+ static void mapping(IO &IO, DWARFYAML::Entry &Entry);
+};
+
+template <> struct MappingTraits<DWARFYAML::FormValue> {
+ static void mapping(IO &IO, DWARFYAML::FormValue &FormValue);
+};
+
+template <> struct MappingTraits<DWARFYAML::File> {
+ static void mapping(IO &IO, DWARFYAML::File &File);
+};
+
+template <> struct MappingTraits<DWARFYAML::LineTableOpcode> {
+ static void mapping(IO &IO, DWARFYAML::LineTableOpcode &LineTableOpcode);
+};
+
+template <> struct MappingTraits<DWARFYAML::LineTable> {
+ static void mapping(IO &IO, DWARFYAML::LineTable &LineTable);
+};
+
+template <> struct MappingTraits<DWARFYAML::InitialLength> {
+ static void mapping(IO &IO, DWARFYAML::InitialLength &DWARF);
+};
+
+#define HANDLE_DW_TAG(unused, name, unused2, unused3) \
+ io.enumCase(value, "DW_TAG_" #name, dwarf::DW_TAG_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::Tag> {
+ static void enumeration(IO &io, dwarf::Tag &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+ io.enumFallback<Hex16>(value);
+ }
+};
+
+#define HANDLE_DW_LNS(unused, name) \
+ io.enumCase(value, "DW_LNS_" #name, dwarf::DW_LNS_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::LineNumberOps> {
+ static void enumeration(IO &io, dwarf::LineNumberOps &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+ io.enumFallback<Hex8>(value);
+ }
+};
+
+#define HANDLE_DW_LNE(unused, name) \
+ io.enumCase(value, "DW_LNE_" #name, dwarf::DW_LNE_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::LineNumberExtendedOps> {
+ static void enumeration(IO &io, dwarf::LineNumberExtendedOps &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+ io.enumFallback<Hex16>(value);
+ }
+};
+
+#define HANDLE_DW_AT(unused, name, unused2, unused3) \
+ io.enumCase(value, "DW_AT_" #name, dwarf::DW_AT_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::Attribute> {
+ static void enumeration(IO &io, dwarf::Attribute &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+ io.enumFallback<Hex16>(value);
+ }
+};
+
+#define HANDLE_DW_FORM(unused, name, unused2, unused3) \
+ io.enumCase(value, "DW_FORM_" #name, dwarf::DW_FORM_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::Form> {
+ static void enumeration(IO &io, dwarf::Form &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+ io.enumFallback<Hex16>(value);
+ }
+};
+
+#define HANDLE_DW_UT(unused, name) \
+ io.enumCase(value, "DW_UT_" #name, dwarf::DW_UT_##name);
+
+template <> struct ScalarEnumerationTraits<dwarf::UnitType> {
+ static void enumeration(IO &io, dwarf::UnitType &value) {
+#include "llvm/BinaryFormat/Dwarf.def"
+ io.enumFallback<Hex8>(value);
+ }
+};
+
+template <> struct ScalarEnumerationTraits<dwarf::Constants> {
+ static void enumeration(IO &io, dwarf::Constants &value) {
+ io.enumCase(value, "DW_CHILDREN_no", dwarf::DW_CHILDREN_no);
+ io.enumCase(value, "DW_CHILDREN_yes", dwarf::DW_CHILDREN_yes);
+ io.enumFallback<Hex16>(value);
+ }
+};
+
+} // end namespace yaml
+} // end namespace llvm
+
+#endif // LLVM_OBJECTYAML_DWARFYAML_H