aboutsummaryrefslogtreecommitdiff
path: root/lib/BinaryFormat
diff options
context:
space:
mode:
Diffstat (limited to 'lib/BinaryFormat')
-rw-r--r--lib/BinaryFormat/AMDGPUMetadataVerifier.cpp160
-rw-r--r--lib/BinaryFormat/Dwarf.cpp13
-rw-r--r--lib/BinaryFormat/Magic.cpp21
-rw-r--r--lib/BinaryFormat/Minidump.cpp14
-rw-r--r--lib/BinaryFormat/MsgPackDocument.cpp245
-rw-r--r--lib/BinaryFormat/MsgPackDocumentYAML.cpp249
-rw-r--r--lib/BinaryFormat/MsgPackReader.cpp7
-rw-r--r--lib/BinaryFormat/MsgPackTypes.cpp303
-rw-r--r--lib/BinaryFormat/MsgPackWriter.cpp7
-rw-r--r--lib/BinaryFormat/Wasm.cpp29
10 files changed, 636 insertions, 412 deletions
diff --git a/lib/BinaryFormat/AMDGPUMetadataVerifier.cpp b/lib/BinaryFormat/AMDGPUMetadataVerifier.cpp
index b789f646b5f6..3f36dff9f55c 100644
--- a/lib/BinaryFormat/AMDGPUMetadataVerifier.cpp
+++ b/lib/BinaryFormat/AMDGPUMetadataVerifier.cpp
@@ -1,9 +1,8 @@
//===- AMDGPUMetadataVerifier.cpp - MsgPack Types ---------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
//
@@ -21,98 +20,92 @@ namespace HSAMD {
namespace V3 {
bool MetadataVerifier::verifyScalar(
- msgpack::Node &Node, msgpack::ScalarNode::ScalarKind SKind,
- function_ref<bool(msgpack::ScalarNode &)> verifyValue) {
- auto ScalarPtr = dyn_cast<msgpack::ScalarNode>(&Node);
- if (!ScalarPtr)
- return false;
- auto &Scalar = *ScalarPtr;
- // Do not output extraneous tags for types we know from the spec.
- Scalar.IgnoreTag = true;
- if (Scalar.getScalarKind() != SKind) {
+ msgpack::DocNode &Node, msgpack::Type SKind,
+ function_ref<bool(msgpack::DocNode &)> verifyValue) {
+ if (!Node.isScalar())
+ return false;
+ if (Node.getKind() != SKind) {
if (Strict)
return false;
// If we are not strict, we interpret string values as "implicitly typed"
// and attempt to coerce them to the expected type here.
- if (Scalar.getScalarKind() != msgpack::ScalarNode::SK_String)
+ if (Node.getKind() != msgpack::Type::String)
return false;
- std::string StringValue = Scalar.getString();
- Scalar.setScalarKind(SKind);
- if (Scalar.inputYAML(StringValue) != StringRef())
+ StringRef StringValue = Node.getString();
+ Node.fromString(StringValue);
+ if (Node.getKind() != SKind)
return false;
}
if (verifyValue)
- return verifyValue(Scalar);
+ return verifyValue(Node);
return true;
}
-bool MetadataVerifier::verifyInteger(msgpack::Node &Node) {
- if (!verifyScalar(Node, msgpack::ScalarNode::SK_UInt))
- if (!verifyScalar(Node, msgpack::ScalarNode::SK_Int))
+bool MetadataVerifier::verifyInteger(msgpack::DocNode &Node) {
+ if (!verifyScalar(Node, msgpack::Type::UInt))
+ if (!verifyScalar(Node, msgpack::Type::Int))
return false;
return true;
}
bool MetadataVerifier::verifyArray(
- msgpack::Node &Node, function_ref<bool(msgpack::Node &)> verifyNode,
+ msgpack::DocNode &Node, function_ref<bool(msgpack::DocNode &)> verifyNode,
Optional<size_t> Size) {
- auto ArrayPtr = dyn_cast<msgpack::ArrayNode>(&Node);
- if (!ArrayPtr)
+ if (!Node.isArray())
return false;
- auto &Array = *ArrayPtr;
+ auto &Array = Node.getArray();
if (Size && Array.size() != *Size)
return false;
for (auto &Item : Array)
- if (!verifyNode(*Item.get()))
+ if (!verifyNode(Item))
return false;
return true;
}
bool MetadataVerifier::verifyEntry(
- msgpack::MapNode &MapNode, StringRef Key, bool Required,
- function_ref<bool(msgpack::Node &)> verifyNode) {
+ msgpack::MapDocNode &MapNode, StringRef Key, bool Required,
+ function_ref<bool(msgpack::DocNode &)> verifyNode) {
auto Entry = MapNode.find(Key);
if (Entry == MapNode.end())
return !Required;
- return verifyNode(*Entry->second.get());
+ return verifyNode(Entry->second);
}
bool MetadataVerifier::verifyScalarEntry(
- msgpack::MapNode &MapNode, StringRef Key, bool Required,
- msgpack::ScalarNode::ScalarKind SKind,
- function_ref<bool(msgpack::ScalarNode &)> verifyValue) {
- return verifyEntry(MapNode, Key, Required, [=](msgpack::Node &Node) {
+ msgpack::MapDocNode &MapNode, StringRef Key, bool Required,
+ msgpack::Type SKind,
+ function_ref<bool(msgpack::DocNode &)> verifyValue) {
+ return verifyEntry(MapNode, Key, Required, [=](msgpack::DocNode &Node) {
return verifyScalar(Node, SKind, verifyValue);
});
}
-bool MetadataVerifier::verifyIntegerEntry(msgpack::MapNode &MapNode,
+bool MetadataVerifier::verifyIntegerEntry(msgpack::MapDocNode &MapNode,
StringRef Key, bool Required) {
- return verifyEntry(MapNode, Key, Required, [this](msgpack::Node &Node) {
+ return verifyEntry(MapNode, Key, Required, [this](msgpack::DocNode &Node) {
return verifyInteger(Node);
});
}
-bool MetadataVerifier::verifyKernelArgs(msgpack::Node &Node) {
- auto ArgsMapPtr = dyn_cast<msgpack::MapNode>(&Node);
- if (!ArgsMapPtr)
+bool MetadataVerifier::verifyKernelArgs(msgpack::DocNode &Node) {
+ if (!Node.isMap())
return false;
- auto &ArgsMap = *ArgsMapPtr;
+ auto &ArgsMap = Node.getMap();
if (!verifyScalarEntry(ArgsMap, ".name", false,
- msgpack::ScalarNode::SK_String))
+ msgpack::Type::String))
return false;
if (!verifyScalarEntry(ArgsMap, ".type_name", false,
- msgpack::ScalarNode::SK_String))
+ msgpack::Type::String))
return false;
if (!verifyIntegerEntry(ArgsMap, ".size", true))
return false;
if (!verifyIntegerEntry(ArgsMap, ".offset", true))
return false;
if (!verifyScalarEntry(ArgsMap, ".value_kind", true,
- msgpack::ScalarNode::SK_String,
- [](msgpack::ScalarNode &SNode) {
+ msgpack::Type::String,
+ [](msgpack::DocNode &SNode) {
return StringSwitch<bool>(SNode.getString())
.Case("by_value", true)
.Case("global_buffer", true)
@@ -128,12 +121,13 @@ bool MetadataVerifier::verifyKernelArgs(msgpack::Node &Node) {
.Case("hidden_printf_buffer", true)
.Case("hidden_default_queue", true)
.Case("hidden_completion_action", true)
+ .Case("hidden_multigrid_sync_arg", true)
.Default(false);
}))
return false;
if (!verifyScalarEntry(ArgsMap, ".value_type", true,
- msgpack::ScalarNode::SK_String,
- [](msgpack::ScalarNode &SNode) {
+ msgpack::Type::String,
+ [](msgpack::DocNode &SNode) {
return StringSwitch<bool>(SNode.getString())
.Case("struct", true)
.Case("i8", true)
@@ -153,8 +147,8 @@ bool MetadataVerifier::verifyKernelArgs(msgpack::Node &Node) {
if (!verifyIntegerEntry(ArgsMap, ".pointee_align", false))
return false;
if (!verifyScalarEntry(ArgsMap, ".address_space", false,
- msgpack::ScalarNode::SK_String,
- [](msgpack::ScalarNode &SNode) {
+ msgpack::Type::String,
+ [](msgpack::DocNode &SNode) {
return StringSwitch<bool>(SNode.getString())
.Case("private", true)
.Case("global", true)
@@ -166,8 +160,8 @@ bool MetadataVerifier::verifyKernelArgs(msgpack::Node &Node) {
}))
return false;
if (!verifyScalarEntry(ArgsMap, ".access", false,
- msgpack::ScalarNode::SK_String,
- [](msgpack::ScalarNode &SNode) {
+ msgpack::Type::String,
+ [](msgpack::DocNode &SNode) {
return StringSwitch<bool>(SNode.getString())
.Case("read_only", true)
.Case("write_only", true)
@@ -176,8 +170,8 @@ bool MetadataVerifier::verifyKernelArgs(msgpack::Node &Node) {
}))
return false;
if (!verifyScalarEntry(ArgsMap, ".actual_access", false,
- msgpack::ScalarNode::SK_String,
- [](msgpack::ScalarNode &SNode) {
+ msgpack::Type::String,
+ [](msgpack::DocNode &SNode) {
return StringSwitch<bool>(SNode.getString())
.Case("read_only", true)
.Case("write_only", true)
@@ -186,36 +180,35 @@ bool MetadataVerifier::verifyKernelArgs(msgpack::Node &Node) {
}))
return false;
if (!verifyScalarEntry(ArgsMap, ".is_const", false,
- msgpack::ScalarNode::SK_Boolean))
+ msgpack::Type::Boolean))
return false;
if (!verifyScalarEntry(ArgsMap, ".is_restrict", false,
- msgpack::ScalarNode::SK_Boolean))
+ msgpack::Type::Boolean))
return false;
if (!verifyScalarEntry(ArgsMap, ".is_volatile", false,
- msgpack::ScalarNode::SK_Boolean))
+ msgpack::Type::Boolean))
return false;
if (!verifyScalarEntry(ArgsMap, ".is_pipe", false,
- msgpack::ScalarNode::SK_Boolean))
+ msgpack::Type::Boolean))
return false;
return true;
}
-bool MetadataVerifier::verifyKernel(msgpack::Node &Node) {
- auto KernelMapPtr = dyn_cast<msgpack::MapNode>(&Node);
- if (!KernelMapPtr)
+bool MetadataVerifier::verifyKernel(msgpack::DocNode &Node) {
+ if (!Node.isMap())
return false;
- auto &KernelMap = *KernelMapPtr;
+ auto &KernelMap = Node.getMap();
if (!verifyScalarEntry(KernelMap, ".name", true,
- msgpack::ScalarNode::SK_String))
+ msgpack::Type::String))
return false;
if (!verifyScalarEntry(KernelMap, ".symbol", true,
- msgpack::ScalarNode::SK_String))
+ msgpack::Type::String))
return false;
if (!verifyScalarEntry(KernelMap, ".language", false,
- msgpack::ScalarNode::SK_String,
- [](msgpack::ScalarNode &SNode) {
+ msgpack::Type::String,
+ [](msgpack::DocNode &SNode) {
return StringSwitch<bool>(SNode.getString())
.Case("OpenCL C", true)
.Case("OpenCL C++", true)
@@ -227,41 +220,41 @@ bool MetadataVerifier::verifyKernel(msgpack::Node &Node) {
}))
return false;
if (!verifyEntry(
- KernelMap, ".language_version", false, [this](msgpack::Node &Node) {
+ KernelMap, ".language_version", false, [this](msgpack::DocNode &Node) {
return verifyArray(
Node,
- [this](msgpack::Node &Node) { return verifyInteger(Node); }, 2);
+ [this](msgpack::DocNode &Node) { return verifyInteger(Node); }, 2);
}))
return false;
- if (!verifyEntry(KernelMap, ".args", false, [this](msgpack::Node &Node) {
- return verifyArray(Node, [this](msgpack::Node &Node) {
+ if (!verifyEntry(KernelMap, ".args", false, [this](msgpack::DocNode &Node) {
+ return verifyArray(Node, [this](msgpack::DocNode &Node) {
return verifyKernelArgs(Node);
});
}))
return false;
if (!verifyEntry(KernelMap, ".reqd_workgroup_size", false,
- [this](msgpack::Node &Node) {
+ [this](msgpack::DocNode &Node) {
return verifyArray(Node,
- [this](msgpack::Node &Node) {
+ [this](msgpack::DocNode &Node) {
return verifyInteger(Node);
},
3);
}))
return false;
if (!verifyEntry(KernelMap, ".workgroup_size_hint", false,
- [this](msgpack::Node &Node) {
+ [this](msgpack::DocNode &Node) {
return verifyArray(Node,
- [this](msgpack::Node &Node) {
+ [this](msgpack::DocNode &Node) {
return verifyInteger(Node);
},
3);
}))
return false;
if (!verifyScalarEntry(KernelMap, ".vec_type_hint", false,
- msgpack::ScalarNode::SK_String))
+ msgpack::Type::String))
return false;
if (!verifyScalarEntry(KernelMap, ".device_enqueue_symbol", false,
- msgpack::ScalarNode::SK_String))
+ msgpack::Type::String))
return false;
if (!verifyIntegerEntry(KernelMap, ".kernarg_segment_size", true))
return false;
@@ -287,29 +280,28 @@ bool MetadataVerifier::verifyKernel(msgpack::Node &Node) {
return true;
}
-bool MetadataVerifier::verify(msgpack::Node &HSAMetadataRoot) {
- auto RootMapPtr = dyn_cast<msgpack::MapNode>(&HSAMetadataRoot);
- if (!RootMapPtr)
+bool MetadataVerifier::verify(msgpack::DocNode &HSAMetadataRoot) {
+ if (!HSAMetadataRoot.isMap())
return false;
- auto &RootMap = *RootMapPtr;
+ auto &RootMap = HSAMetadataRoot.getMap();
if (!verifyEntry(
- RootMap, "amdhsa.version", true, [this](msgpack::Node &Node) {
+ RootMap, "amdhsa.version", true, [this](msgpack::DocNode &Node) {
return verifyArray(
Node,
- [this](msgpack::Node &Node) { return verifyInteger(Node); }, 2);
+ [this](msgpack::DocNode &Node) { return verifyInteger(Node); }, 2);
}))
return false;
if (!verifyEntry(
- RootMap, "amdhsa.printf", false, [this](msgpack::Node &Node) {
- return verifyArray(Node, [this](msgpack::Node &Node) {
- return verifyScalar(Node, msgpack::ScalarNode::SK_String);
+ RootMap, "amdhsa.printf", false, [this](msgpack::DocNode &Node) {
+ return verifyArray(Node, [this](msgpack::DocNode &Node) {
+ return verifyScalar(Node, msgpack::Type::String);
});
}))
return false;
if (!verifyEntry(RootMap, "amdhsa.kernels", true,
- [this](msgpack::Node &Node) {
- return verifyArray(Node, [this](msgpack::Node &Node) {
+ [this](msgpack::DocNode &Node) {
+ return verifyArray(Node, [this](msgpack::DocNode &Node) {
return verifyKernel(Node);
});
}))
diff --git a/lib/BinaryFormat/Dwarf.cpp b/lib/BinaryFormat/Dwarf.cpp
index 46f8056774b7..eb6bd33ce583 100644
--- a/lib/BinaryFormat/Dwarf.cpp
+++ b/lib/BinaryFormat/Dwarf.cpp
@@ -1,9 +1,8 @@
//===-- llvm/BinaryFormat/Dwarf.cpp - Dwarf Framework ------------*- C++-*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
//
@@ -144,8 +143,12 @@ StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
case DW_OP_##NAME: \
return "DW_OP_" #NAME;
#include "llvm/BinaryFormat/Dwarf.def"
+ case DW_OP_LLVM_convert:
+ return "DW_OP_LLVM_convert";
case DW_OP_LLVM_fragment:
return "DW_OP_LLVM_fragment";
+ case DW_OP_LLVM_tag_offset:
+ return "DW_OP_LLVM_tag_offset";
}
}
@@ -154,7 +157,9 @@ unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
#define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
.Case("DW_OP_" #NAME, DW_OP_##NAME)
#include "llvm/BinaryFormat/Dwarf.def"
+ .Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
.Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
+ .Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset)
.Default(0);
}
diff --git a/lib/BinaryFormat/Magic.cpp b/lib/BinaryFormat/Magic.cpp
index 78efa6ec87be..7dfe23690a50 100644
--- a/lib/BinaryFormat/Magic.cpp
+++ b/lib/BinaryFormat/Magic.cpp
@@ -1,9 +1,8 @@
//===- llvm/BinaryFormat/Magic.cpp - File magic identification --*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
@@ -62,6 +61,15 @@ file_magic llvm::identify_magic(StringRef Magic) {
return file_magic::wasm_object;
break;
}
+
+ case 0x01:
+ // XCOFF format
+ if (startswith(Magic, "\x01\xDF"))
+ return file_magic::xcoff_object_32;
+ if (startswith(Magic, "\x01\xF7"))
+ return file_magic::xcoff_object_64;
+ break;
+
case 0xDE: // 0x0B17C0DE = BC wraper
if (startswith(Magic, "\xDE\xC0\x17\x0B"))
return file_magic::bitcode;
@@ -182,7 +190,8 @@ file_magic llvm::identify_magic(StringRef Magic) {
return file_magic::coff_object;
break;
- case 'M': // Possible MS-DOS stub on Windows PE file or MSF/PDB file.
+ case 'M': // Possible MS-DOS stub on Windows PE file, MSF/PDB file or a
+ // Minidump file.
if (startswith(Magic, "MZ") && Magic.size() >= 0x3c + 4) {
uint32_t off = read32le(Magic.data() + 0x3c);
// PE/COFF file, either EXE or DLL.
@@ -192,6 +201,8 @@ file_magic llvm::identify_magic(StringRef Magic) {
}
if (Magic.startswith("Microsoft C/C++ MSF 7.00\r\n"))
return file_magic::pdb;
+ if (startswith(Magic, "MDMP"))
+ return file_magic::minidump;
break;
case 0x64: // x86-64 or ARM64 Windows.
diff --git a/lib/BinaryFormat/Minidump.cpp b/lib/BinaryFormat/Minidump.cpp
new file mode 100644
index 000000000000..b618fb157012
--- /dev/null
+++ b/lib/BinaryFormat/Minidump.cpp
@@ -0,0 +1,14 @@
+//===-- Minidump.cpp - Minidump constants and structures ---------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/BinaryFormat/Minidump.h"
+
+using namespace llvm::minidump;
+
+constexpr uint32_t Header::MagicSignature;
+constexpr uint16_t Header::MagicVersion;
diff --git a/lib/BinaryFormat/MsgPackDocument.cpp b/lib/BinaryFormat/MsgPackDocument.cpp
new file mode 100644
index 000000000000..e12c54a37ad0
--- /dev/null
+++ b/lib/BinaryFormat/MsgPackDocument.cpp
@@ -0,0 +1,245 @@
+//===-- MsgPackDocument.cpp - MsgPack Document --------------------------*-===//
+//
+// 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 implements a class that exposes a simple in-memory representation
+/// of a document of MsgPack objects, that can be read from MsgPack, written to
+/// MsgPack, and inspected and modified in memory. This is intended to be a
+/// lighter-weight (in terms of memory allocations) replacement for
+/// MsgPackTypes.
+///
+//===----------------------------------------------------------------------===//
+
+#include "llvm/BinaryFormat/MsgPackDocument.h"
+#include "llvm/BinaryFormat/MsgPackWriter.h"
+
+using namespace llvm;
+using namespace msgpack;
+
+// Convert this DocNode into an empty array.
+void DocNode::convertToArray() { *this = getDocument()->getArrayNode(); }
+
+// Convert this DocNode into an empty map.
+void DocNode::convertToMap() { *this = getDocument()->getMapNode(); }
+
+/// Find the key in the MapDocNode.
+DocNode::MapTy::iterator MapDocNode::find(StringRef S) {
+ return find(getDocument()->getNode(S));
+}
+
+/// Member access for MapDocNode. The string data must remain valid for the
+/// lifetime of the Document.
+DocNode &MapDocNode::operator[](StringRef S) {
+ return (*this)[getDocument()->getNode(S)];
+}
+
+/// Member access for MapDocNode.
+DocNode &MapDocNode::operator[](DocNode Key) {
+ assert(!Key.isEmpty());
+ MapTy::value_type Entry(Key, DocNode());
+ auto ItAndInserted = Map->insert(Entry);
+ if (ItAndInserted.second) {
+ // Ensure a new element has its KindAndDoc initialized.
+ ItAndInserted.first->second = getDocument()->getNode();
+ }
+ return ItAndInserted.first->second;
+}
+
+/// Array element access. This extends the array if necessary.
+DocNode &ArrayDocNode::operator[](size_t Index) {
+ if (size() <= Index) {
+ // Ensure new elements have their KindAndDoc initialized.
+ Array->resize(Index + 1, getDocument()->getNode());
+ }
+ return (*Array)[Index];
+}
+
+// A level in the document reading stack.
+struct StackLevel {
+ DocNode Node;
+ size_t Length;
+ // Points to map entry when we have just processed a map key.
+ DocNode *MapEntry;
+};
+
+// Read a document from a binary msgpack blob.
+// The blob data must remain valid for the lifetime of this Document (because a
+// string object in the document contains a StringRef into the original blob).
+// If Multi, then this sets root to an array and adds top-level objects to it.
+// If !Multi, then it only reads a single top-level object, even if there are
+// more, and sets root to that.
+// Returns false if failed due to illegal format.
+bool Document::readFromBlob(StringRef Blob, bool Multi) {
+ msgpack::Reader MPReader(Blob);
+ SmallVector<StackLevel, 4> Stack;
+ if (Multi) {
+ // Create the array for multiple top-level objects.
+ Root = getArrayNode();
+ Stack.push_back(StackLevel({Root, (size_t)-1, nullptr}));
+ }
+ do {
+ // On to next element (or key if doing a map key next).
+ // Read the value.
+ Object Obj;
+ if (!MPReader.read(Obj)) {
+ if (Multi && Stack.size() == 1) {
+ // OK to finish here as we've just done a top-level element with Multi
+ break;
+ }
+ return false; // Finished too early
+ }
+ // Convert it into a DocNode.
+ DocNode Node;
+ switch (Obj.Kind) {
+ case Type::Nil:
+ Node = getNode();
+ break;
+ case Type::Int:
+ Node = getNode(Obj.Int);
+ break;
+ case Type::UInt:
+ Node = getNode(Obj.UInt);
+ break;
+ case Type::Boolean:
+ Node = getNode(Obj.Bool);
+ break;
+ case Type::Float:
+ Node = getNode(Obj.Float);
+ break;
+ case Type::String:
+ Node = getNode(Obj.Raw);
+ break;
+ case Type::Map:
+ Node = getMapNode();
+ break;
+ case Type::Array:
+ Node = getArrayNode();
+ break;
+ default:
+ return false; // Raw and Extension not supported
+ }
+
+ // Store it.
+ if (Stack.empty())
+ Root = Node;
+ else if (Stack.back().Node.getKind() == Type::Array) {
+ // Reading an array entry.
+ auto &Array = Stack.back().Node.getArray();
+ Array.push_back(Node);
+ } else {
+ auto &Map = Stack.back().Node.getMap();
+ if (!Stack.back().MapEntry) {
+ // Reading a map key.
+ Stack.back().MapEntry = &Map[Node];
+ } else {
+ // Reading the value for the map key read in the last iteration.
+ *Stack.back().MapEntry = Node;
+ Stack.back().MapEntry = nullptr;
+ }
+ }
+
+ // See if we're starting a new array or map.
+ switch (Node.getKind()) {
+ case msgpack::Type::Array:
+ case msgpack::Type::Map:
+ Stack.push_back(StackLevel({Node, Obj.Length, nullptr}));
+ break;
+ default:
+ break;
+ }
+
+ // Pop finished stack levels.
+ while (!Stack.empty()) {
+ if (Stack.back().Node.getKind() == msgpack::Type::Array) {
+ if (Stack.back().Node.getArray().size() != Stack.back().Length)
+ break;
+ } else {
+ if (Stack.back().MapEntry ||
+ Stack.back().Node.getMap().size() != Stack.back().Length)
+ break;
+ }
+ Stack.pop_back();
+ }
+ } while (!Stack.empty());
+ return true;
+}
+
+struct WriterStackLevel {
+ DocNode Node;
+ DocNode::MapTy::iterator MapIt;
+ DocNode::ArrayTy::iterator ArrayIt;
+ bool OnKey;
+};
+
+/// Write a MsgPack document to a binary MsgPack blob.
+void Document::writeToBlob(std::string &Blob) {
+ Blob.clear();
+ raw_string_ostream OS(Blob);
+ msgpack::Writer MPWriter(OS);
+ SmallVector<WriterStackLevel, 4> Stack;
+ DocNode Node = getRoot();
+ for (;;) {
+ switch (Node.getKind()) {
+ case Type::Array:
+ MPWriter.writeArraySize(Node.getArray().size());
+ Stack.push_back(
+ {Node, DocNode::MapTy::iterator(), Node.getArray().begin(), false});
+ break;
+ case Type::Map:
+ MPWriter.writeMapSize(Node.getMap().size());
+ Stack.push_back(
+ {Node, Node.getMap().begin(), DocNode::ArrayTy::iterator(), true});
+ break;
+ case Type::Nil:
+ MPWriter.writeNil();
+ break;
+ case Type::Boolean:
+ MPWriter.write(Node.getBool());
+ break;
+ case Type::Int:
+ MPWriter.write(Node.getInt());
+ break;
+ case Type::UInt:
+ MPWriter.write(Node.getUInt());
+ break;
+ case Type::String:
+ MPWriter.write(Node.getString());
+ break;
+ default:
+ llvm_unreachable("unhandled msgpack object kind");
+ }
+ // Pop finished stack levels.
+ while (!Stack.empty()) {
+ if (Stack.back().Node.getKind() == Type::Map) {
+ if (Stack.back().MapIt != Stack.back().Node.getMap().end())
+ break;
+ } else {
+ if (Stack.back().ArrayIt != Stack.back().Node.getArray().end())
+ break;
+ }
+ Stack.pop_back();
+ }
+ if (Stack.empty())
+ break;
+ // Get the next value.
+ if (Stack.back().Node.getKind() == Type::Map) {
+ if (Stack.back().OnKey) {
+ // Do the key of a key,value pair in a map.
+ Node = Stack.back().MapIt->first;
+ Stack.back().OnKey = false;
+ } else {
+ Node = Stack.back().MapIt->second;
+ ++Stack.back().MapIt;
+ Stack.back().OnKey = true;
+ }
+ } else {
+ Node = *Stack.back().ArrayIt;
+ ++Stack.back().ArrayIt;
+ }
+ }
+}
+
diff --git a/lib/BinaryFormat/MsgPackDocumentYAML.cpp b/lib/BinaryFormat/MsgPackDocumentYAML.cpp
new file mode 100644
index 000000000000..1d9c81ef8ebc
--- /dev/null
+++ b/lib/BinaryFormat/MsgPackDocumentYAML.cpp
@@ -0,0 +1,249 @@
+//===-- MsgPackDocumentYAML.cpp - MsgPack Document YAML interface -------*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+/// This file implements YAMLIO on a msgpack::Document.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/BinaryFormat/MsgPackDocument.h"
+#include "llvm/Support/YAMLTraits.h"
+
+using namespace llvm;
+using namespace msgpack;
+
+namespace {
+
+// Struct used to represent scalar node. (MapDocNode and ArrayDocNode already
+// exist in MsgPackDocument.h.)
+struct ScalarDocNode : DocNode {
+ ScalarDocNode(DocNode N) : DocNode(N) {}
+
+ /// Get the YAML tag for this ScalarDocNode. This normally returns ""; it only
+ /// returns something else if the result of toString would be ambiguous, e.g.
+ /// a string that parses as a number or boolean.
+ StringRef getYAMLTag() const;
+};
+
+} // namespace
+
+/// Convert this DocNode to a string, assuming it is scalar.
+std::string DocNode::toString() const {
+ std::string S;
+ raw_string_ostream OS(S);
+ switch (getKind()) {
+ case msgpack::Type::String:
+ OS << Raw;
+ break;
+ case msgpack::Type::Nil:
+ break;
+ case msgpack::Type::Boolean:
+ OS << (Bool ? "true" : "false");
+ break;
+ case msgpack::Type::Int:
+ OS << Int;
+ break;
+ case msgpack::Type::UInt:
+ if (getDocument()->getHexMode())
+ OS << format("%#llx", (unsigned long long)UInt);
+ else
+ OS << UInt;
+ break;
+ case msgpack::Type::Float:
+ OS << Float;
+ break;
+ default:
+ llvm_unreachable("not scalar");
+ break;
+ }
+ return OS.str();
+}
+
+/// Convert the StringRef and use it to set this DocNode (assuming scalar). If
+/// it is a string, copy the string into the Document's strings list so we do
+/// not rely on S having a lifetime beyond this call. Tag is "" or a YAML tag.
+StringRef DocNode::fromString(StringRef S, StringRef Tag) {
+ if (Tag == "tag:yaml.org,2002:str")
+ Tag = "";
+ if (Tag == "!int" || Tag == "") {
+ // Try unsigned int then signed int.
+ *this = getDocument()->getNode(uint64_t(0));
+ StringRef Err = yaml::ScalarTraits<uint64_t>::input(S, nullptr, getUInt());
+ if (Err != "") {
+ *this = getDocument()->getNode(int64_t(0));
+ Err = yaml::ScalarTraits<int64_t>::input(S, nullptr, getInt());
+ }
+ if (Err == "" || Tag != "")
+ return Err;
+ }
+ if (Tag == "!nil") {
+ *this = getDocument()->getNode();
+ return "";
+ }
+ if (Tag == "!bool" || Tag == "") {
+ *this = getDocument()->getNode(false);
+ StringRef Err = yaml::ScalarTraits<bool>::input(S, nullptr, getBool());
+ if (Err == "" || Tag != "")
+ return Err;
+ }
+ if (Tag == "!float" || Tag == "") {
+ *this = getDocument()->getNode(0.0);
+ StringRef Err = yaml::ScalarTraits<double>::input(S, nullptr, getFloat());
+ if (Err == "" || Tag != "")
+ return Err;
+ }
+ assert((Tag == "!str" || Tag == "") && "unsupported tag");
+ std::string V;
+ StringRef Err = yaml::ScalarTraits<std::string>::input(S, nullptr, V);
+ if (Err == "")
+ *this = getDocument()->getNode(V, /*Copy=*/true);
+ return Err;
+}
+
+/// Get the YAML tag for this ScalarDocNode. This normally returns ""; it only
+/// returns something else if the result of toString would be ambiguous, e.g.
+/// a string that parses as a number or boolean.
+StringRef ScalarDocNode::getYAMLTag() const {
+ if (getKind() == msgpack::Type::Nil)
+ return "!nil";
+ // Try converting both ways and see if we get the same kind. If not, we need
+ // a tag.
+ ScalarDocNode N = getDocument()->getNode();
+ N.fromString(toString(), "");
+ if (N.getKind() == getKind())
+ return "";
+ // Tolerate signedness of int changing, as tags do not differentiate between
+ // them anyway.
+ if (N.getKind() == msgpack::Type::UInt && getKind() == msgpack::Type::Int)
+ return "";
+ if (N.getKind() == msgpack::Type::Int && getKind() == msgpack::Type::UInt)
+ return "";
+ // We do need a tag.
+ switch (getKind()) {
+ case msgpack::Type::String:
+ return "!str";
+ case msgpack::Type::Int:
+ return "!int";
+ case msgpack::Type::UInt:
+ return "!int";
+ case msgpack::Type::Boolean:
+ return "!bool";
+ case msgpack::Type::Float:
+ return "!float";
+ default:
+ llvm_unreachable("unrecognized kind");
+ }
+}
+
+namespace llvm {
+namespace yaml {
+
+/// YAMLIO for DocNode
+template <> struct PolymorphicTraits<DocNode> {
+
+ static NodeKind getKind(const DocNode &N) {
+ switch (N.getKind()) {
+ case msgpack::Type::Map:
+ return NodeKind::Map;
+ case msgpack::Type::Array:
+ return NodeKind::Sequence;
+ default:
+ return NodeKind::Scalar;
+ }
+ }
+
+ static MapDocNode &getAsMap(DocNode &N) { return N.getMap(/*Convert=*/true); }
+
+ static ArrayDocNode &getAsSequence(DocNode &N) {
+ N.getArray(/*Convert=*/true);
+ return *static_cast<ArrayDocNode *>(&N);
+ }
+
+ static ScalarDocNode &getAsScalar(DocNode &N) {
+ return *static_cast<ScalarDocNode *>(&N);
+ }
+};
+
+/// YAMLIO for ScalarDocNode
+template <> struct TaggedScalarTraits<ScalarDocNode> {
+
+ static void output(const ScalarDocNode &S, void *Ctxt, raw_ostream &OS,
+ raw_ostream &TagOS) {
+ TagOS << S.getYAMLTag();
+ OS << S.toString();
+ }
+
+ static StringRef input(StringRef Str, StringRef Tag, void *Ctxt,
+ ScalarDocNode &S) {
+ return S.fromString(Str, Tag);
+ }
+
+ static QuotingType mustQuote(const ScalarDocNode &S, StringRef ScalarStr) {
+ switch (S.getKind()) {
+ case Type::Int:
+ return ScalarTraits<int64_t>::mustQuote(ScalarStr);
+ case Type::UInt:
+ return ScalarTraits<uint64_t>::mustQuote(ScalarStr);
+ case Type::Nil:
+ return ScalarTraits<StringRef>::mustQuote(ScalarStr);
+ case Type::Boolean:
+ return ScalarTraits<bool>::mustQuote(ScalarStr);
+ case Type::Float:
+ return ScalarTraits<double>::mustQuote(ScalarStr);
+ case Type::Binary:
+ case Type::String:
+ return ScalarTraits<std::string>::mustQuote(ScalarStr);
+ default:
+ llvm_unreachable("unrecognized ScalarKind");
+ }
+ }
+};
+
+/// YAMLIO for MapDocNode
+template <> struct CustomMappingTraits<MapDocNode> {
+
+ static void inputOne(IO &IO, StringRef Key, MapDocNode &M) {
+ ScalarDocNode KeyObj = M.getDocument()->getNode();
+ KeyObj.fromString(Key, "");
+ IO.mapRequired(Key.str().c_str(), M.getMap()[KeyObj]);
+ }
+
+ static void output(IO &IO, MapDocNode &M) {
+ for (auto I : M.getMap()) {
+ IO.mapRequired(I.first.toString().c_str(), I.second);
+ }
+ }
+};
+
+/// YAMLIO for ArrayNode
+template <> struct SequenceTraits<ArrayDocNode> {
+
+ static size_t size(IO &IO, ArrayDocNode &A) { return A.size(); }
+
+ static DocNode &element(IO &IO, ArrayDocNode &A, size_t Index) {
+ return A[Index];
+ }
+};
+
+} // namespace yaml
+} // namespace llvm
+
+/// Convert MsgPack Document to YAML text.
+void msgpack::Document::toYAML(raw_ostream &OS) {
+ yaml::Output Yout(OS);
+ Yout << getRoot();
+}
+
+/// Read YAML text into the MsgPack document. Returns false on failure.
+bool msgpack::Document::fromYAML(StringRef S) {
+ clear();
+ yaml::Input Yin(S);
+ Yin >> getRoot();
+ return !Yin.error();
+}
+
diff --git a/lib/BinaryFormat/MsgPackReader.cpp b/lib/BinaryFormat/MsgPackReader.cpp
index b510fdba9608..872a6e0e29f8 100644
--- a/lib/BinaryFormat/MsgPackReader.cpp
+++ b/lib/BinaryFormat/MsgPackReader.cpp
@@ -1,9 +1,8 @@
//===- MsgPackReader.cpp - Simple MsgPack reader ----------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
///
diff --git a/lib/BinaryFormat/MsgPackTypes.cpp b/lib/BinaryFormat/MsgPackTypes.cpp
deleted file mode 100644
index 4a8f70b10fb8..000000000000
--- a/lib/BinaryFormat/MsgPackTypes.cpp
+++ /dev/null
@@ -1,303 +0,0 @@
-//===- MsgPackTypes.cpp - MsgPack Types -------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-/// \file
-/// Implementation of types representing MessagePack "documents".
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/BinaryFormat/MsgPackTypes.h"
-#include "llvm/Support/Error.h"
-
-using namespace llvm;
-using namespace msgpack;
-
-namespace llvm {
-namespace msgpack {
-void ScalarNode::anchor() {}
-void ArrayNode::anchor() {}
-void MapNode::anchor() {}
-}
-}
-
-Expected<OptNodePtr> Node::readArray(Reader &MPReader, size_t Length) {
- auto A = std::make_shared<ArrayNode>();
- for (size_t I = 0; I < Length; ++I) {
- auto OptNodeOrErr = Node::read(MPReader);
- if (auto Err = OptNodeOrErr.takeError())
- return std::move(Err);
- if (!*OptNodeOrErr)
- return make_error<StringError>(
- "Insufficient array elements",
- std::make_error_code(std::errc::invalid_argument));
- A->push_back(std::move(**OptNodeOrErr));
- }
- return OptNodePtr(std::move(A));
-}
-
-Expected<OptNodePtr> Node::readMap(Reader &MPReader, size_t Length) {
- auto M = std::make_shared<MapNode>();
- for (size_t I = 0; I < Length; ++I) {
- auto OptKeyOrErr = Node::read(MPReader);
- if (auto Err = OptKeyOrErr.takeError())
- return std::move(Err);
- if (!*OptKeyOrErr)
- return make_error<StringError>(
- "Insufficient map elements",
- std::make_error_code(std::errc::invalid_argument));
- auto OptValOrErr = Node::read(MPReader);
- if (auto Err = OptValOrErr.takeError())
- return std::move(Err);
- if (!*OptValOrErr)
- return make_error<StringError>(
- "Insufficient map elements",
- std::make_error_code(std::errc::invalid_argument));
- auto *Key = dyn_cast<ScalarNode>((*OptKeyOrErr)->get());
- if (!Key)
- return make_error<StringError>(
- "Only string map keys are supported",
- std::make_error_code(std::errc::invalid_argument));
- if (Key->getScalarKind() != ScalarNode::SK_String)
- return make_error<StringError>(
- "Only string map keys are supported",
- std::make_error_code(std::errc::invalid_argument));
- M->try_emplace(Key->getString(), std::move(**OptValOrErr));
- }
- return OptNodePtr(std::move(M));
-}
-
-Expected<OptNodePtr> Node::read(Reader &MPReader) {
- Object Obj;
-
- auto ContinueOrErr = MPReader.read(Obj);
- if (auto Err = ContinueOrErr.takeError())
- return std::move(Err);
- if (!*ContinueOrErr)
- return None;
-
- switch (Obj.Kind) {
- case Type::Int:
- return OptNodePtr(std::make_shared<ScalarNode>(Obj.Int));
- case Type::UInt:
- return OptNodePtr(std::make_shared<ScalarNode>(Obj.UInt));
- case Type::Nil:
- return OptNodePtr(std::make_shared<ScalarNode>());
- case Type::Boolean:
- return OptNodePtr(std::make_shared<ScalarNode>(Obj.Bool));
- case Type::Float:
- return OptNodePtr(std::make_shared<ScalarNode>(Obj.Float));
- case Type::String:
- return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw));
- case Type::Binary:
- return OptNodePtr(std::make_shared<ScalarNode>(Obj.Raw));
- case Type::Array:
- return Node::readArray(MPReader, Obj.Length);
- case Type::Map:
- return Node::readMap(MPReader, Obj.Length);
- case Type::Extension:
- return make_error<StringError>(
- "Extension types are not supported",
- std::make_error_code(std::errc::invalid_argument));
- }
- llvm_unreachable("msgpack::Type not handled");
-}
-
-void ScalarNode::destroy() {
- switch (SKind) {
- case SK_String:
- case SK_Binary:
- StringValue.~basic_string();
- break;
- default:
- // POD types do not require destruction
- break;
- }
-}
-
-ScalarNode::ScalarNode(int64_t IntValue)
- : Node(NK_Scalar), SKind(SK_Int), IntValue(IntValue) {}
-
-ScalarNode::ScalarNode(int32_t IntValue)
- : ScalarNode(static_cast<int64_t>(IntValue)) {}
-
-ScalarNode::ScalarNode(uint64_t UIntValue)
- : Node(NK_Scalar), SKind(SK_UInt), UIntValue(UIntValue) {}
-
-ScalarNode::ScalarNode(uint32_t IntValue)
- : ScalarNode(static_cast<uint64_t>(IntValue)) {}
-
-ScalarNode::ScalarNode() : Node(NK_Scalar), SKind(SK_Nil) {}
-
-ScalarNode::ScalarNode(bool BoolValue)
- : Node(NK_Scalar), SKind(SK_Boolean), BoolValue(BoolValue) {}
-
-ScalarNode::ScalarNode(double FloatValue)
- : Node(NK_Scalar), SKind(SK_Float), BoolValue(FloatValue) {}
-
-ScalarNode::ScalarNode(StringRef StringValue)
- : Node(NK_Scalar), SKind(SK_String) {
- new (&this->StringValue) std::string(StringValue);
-}
-
-ScalarNode::ScalarNode(const char *StringValue)
- : ScalarNode(StringRef(StringValue)) {}
-
-ScalarNode::ScalarNode(std::string &&StringValue)
- : Node(NK_Scalar), SKind(SK_String) {
- new (&this->StringValue) std::string(StringValue);
-}
-
-ScalarNode::ScalarNode(MemoryBufferRef BinaryValue)
- : Node(NK_Scalar), SKind(SK_Binary) {
- new (&StringValue) std::string(BinaryValue.getBuffer());
-}
-
-ScalarNode::~ScalarNode() { destroy(); }
-
-ScalarNode &ScalarNode::operator=(ScalarNode &&RHS) {
- destroy();
- switch (SKind = RHS.SKind) {
- case SK_Int:
- IntValue = RHS.IntValue;
- break;
- case SK_UInt:
- UIntValue = RHS.UIntValue;
- break;
- case SK_Boolean:
- BoolValue = RHS.BoolValue;
- break;
- case SK_Float:
- FloatValue = RHS.FloatValue;
- break;
- case SK_String:
- case SK_Binary:
- new (&StringValue) std::string(std::move(RHS.StringValue));
- break;
- case SK_Nil:
- // pass
- break;
- }
- return *this;
-}
-
-StringRef ScalarNode::inputYAML(StringRef ScalarStr) {
- switch (SKind) {
- case SK_Int:
- return yaml::ScalarTraits<int64_t>::input(ScalarStr, nullptr, IntValue);
- case SK_UInt:
- return yaml::ScalarTraits<uint64_t>::input(ScalarStr, nullptr, UIntValue);
- case SK_Nil:
- return StringRef();
- case SK_Boolean:
- return yaml::ScalarTraits<bool>::input(ScalarStr, nullptr, BoolValue);
- case SK_Float:
- return yaml::ScalarTraits<double>::input(ScalarStr, nullptr, FloatValue);
- case SK_Binary:
- case SK_String:
- return yaml::ScalarTraits<std::string>::input(ScalarStr, nullptr,
- StringValue);
- }
- llvm_unreachable("unrecognized ScalarKind");
-}
-
-void ScalarNode::outputYAML(raw_ostream &OS) const {
- switch (SKind) {
- case SK_Int:
- yaml::ScalarTraits<int64_t>::output(IntValue, nullptr, OS);
- break;
- case SK_UInt:
- yaml::ScalarTraits<uint64_t>::output(UIntValue, nullptr, OS);
- break;
- case SK_Nil:
- yaml::ScalarTraits<StringRef>::output("", nullptr, OS);
- break;
- case SK_Boolean:
- yaml::ScalarTraits<bool>::output(BoolValue, nullptr, OS);
- break;
- case SK_Float:
- yaml::ScalarTraits<double>::output(FloatValue, nullptr, OS);
- break;
- case SK_Binary:
- case SK_String:
- yaml::ScalarTraits<std::string>::output(StringValue, nullptr, OS);
- break;
- }
-}
-
-yaml::QuotingType ScalarNode::mustQuoteYAML(StringRef ScalarStr) const {
- switch (SKind) {
- case SK_Int:
- return yaml::ScalarTraits<int64_t>::mustQuote(ScalarStr);
- case SK_UInt:
- return yaml::ScalarTraits<uint64_t>::mustQuote(ScalarStr);
- case SK_Nil:
- return yaml::ScalarTraits<StringRef>::mustQuote(ScalarStr);
- case SK_Boolean:
- return yaml::ScalarTraits<bool>::mustQuote(ScalarStr);
- case SK_Float:
- return yaml::ScalarTraits<double>::mustQuote(ScalarStr);
- case SK_Binary:
- case SK_String:
- return yaml::ScalarTraits<std::string>::mustQuote(ScalarStr);
- }
- llvm_unreachable("unrecognized ScalarKind");
-}
-
-const char *ScalarNode::IntTag = "!int";
-const char *ScalarNode::NilTag = "!nil";
-const char *ScalarNode::BooleanTag = "!bool";
-const char *ScalarNode::FloatTag = "!float";
-const char *ScalarNode::StringTag = "!str";
-const char *ScalarNode::BinaryTag = "!bin";
-
-StringRef ScalarNode::getYAMLTag() const {
- switch (SKind) {
- case SK_Int:
- return IntTag;
- case SK_UInt:
- return IntTag;
- case SK_Nil:
- return NilTag;
- case SK_Boolean:
- return BooleanTag;
- case SK_Float:
- return FloatTag;
- case SK_String:
- return StringTag;
- case SK_Binary:
- return BinaryTag;
- }
- llvm_unreachable("unrecognized ScalarKind");
-}
-
-void ScalarNode::write(Writer &MPWriter) {
- switch (SKind) {
- case SK_Int:
- MPWriter.write(IntValue);
- break;
- case SK_UInt:
- MPWriter.write(UIntValue);
- break;
- case SK_Nil:
- MPWriter.writeNil();
- break;
- case SK_Boolean:
- MPWriter.write(BoolValue);
- break;
- case SK_Float:
- MPWriter.write(FloatValue);
- break;
- case SK_String:
- MPWriter.write(StringValue);
- break;
- case SK_Binary:
- MPWriter.write(MemoryBufferRef(StringValue, ""));
- break;
- }
-}
diff --git a/lib/BinaryFormat/MsgPackWriter.cpp b/lib/BinaryFormat/MsgPackWriter.cpp
index d024bb0fcdb2..b4d70e8f78c1 100644
--- a/lib/BinaryFormat/MsgPackWriter.cpp
+++ b/lib/BinaryFormat/MsgPackWriter.cpp
@@ -1,9 +1,8 @@
//===- MsgPackWriter.cpp - Simple MsgPack writer ----------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
///
diff --git a/lib/BinaryFormat/Wasm.cpp b/lib/BinaryFormat/Wasm.cpp
index 94d40bf02a39..d46be481edb3 100644
--- a/lib/BinaryFormat/Wasm.cpp
+++ b/lib/BinaryFormat/Wasm.cpp
@@ -1,16 +1,15 @@
//===-- llvm/BinaryFormat/Wasm.cpp -------------------------------*- C++-*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// 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
//
//===----------------------------------------------------------------------===//
#include "llvm/BinaryFormat/Wasm.h"
-std::string llvm::wasm::toString(wasm::WasmSymbolType type) {
- switch (type) {
+std::string llvm::wasm::toString(wasm::WasmSymbolType Type) {
+ switch (Type) {
case wasm::WASM_SYMBOL_TYPE_FUNCTION:
return "WASM_SYMBOL_TYPE_FUNCTION";
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
@@ -25,8 +24,8 @@ std::string llvm::wasm::toString(wasm::WasmSymbolType type) {
llvm_unreachable("unknown symbol type");
}
-std::string llvm::wasm::relocTypetoString(uint32_t type) {
- switch (type) {
+std::string llvm::wasm::relocTypetoString(uint32_t Type) {
+ switch (Type) {
#define WASM_RELOC(NAME, VALUE) \
case VALUE: \
return #NAME;
@@ -36,3 +35,17 @@ std::string llvm::wasm::relocTypetoString(uint32_t type) {
llvm_unreachable("unknown reloc type");
}
}
+
+bool llvm::wasm::relocTypeHasAddend(uint32_t Type) {
+ switch (Type) {
+ case R_WASM_MEMORY_ADDR_LEB:
+ case R_WASM_MEMORY_ADDR_SLEB:
+ case R_WASM_MEMORY_ADDR_REL_SLEB:
+ case R_WASM_MEMORY_ADDR_I32:
+ case R_WASM_FUNCTION_OFFSET_I32:
+ case R_WASM_SECTION_OFFSET_I32:
+ return true;
+ default:
+ return false;
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-09 14:22:14 +0000