LLVM  14.0.0git
JSON.h
Go to the documentation of this file.
1 //===--- JSON.h - JSON values, parsing and serialization -------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===---------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// This file supports working with JSON data.
11 ///
12 /// It comprises:
13 ///
14 /// - classes which hold dynamically-typed parsed JSON structures
15 /// These are value types that can be composed, inspected, and modified.
16 /// See json::Value, and the related types json::Object and json::Array.
17 ///
18 /// - functions to parse JSON text into Values, and to serialize Values to text.
19 /// See parse(), operator<<, and format_provider.
20 ///
21 /// - a convention and helpers for mapping between json::Value and user-defined
22 /// types. See fromJSON(), ObjectMapper, and the class comment on Value.
23 ///
24 /// - an output API json::OStream which can emit JSON without materializing
25 /// all structures as json::Value.
26 ///
27 /// Typically, JSON data would be read from an external source, parsed into
28 /// a Value, and then converted into some native data structure before doing
29 /// real work on it. (And vice versa when writing).
30 ///
31 /// Other serialization mechanisms you may consider:
32 ///
33 /// - YAML is also text-based, and more human-readable than JSON. It's a more
34 /// complex format and data model, and YAML parsers aren't ubiquitous.
35 /// YAMLParser.h is a streaming parser suitable for parsing large documents
36 /// (including JSON, as YAML is a superset). It can be awkward to use
37 /// directly. YAML I/O (YAMLTraits.h) provides data mapping that is more
38 /// declarative than the toJSON/fromJSON conventions here.
39 ///
40 /// - LLVM bitstream is a space- and CPU- efficient binary format. Typically it
41 /// encodes LLVM IR ("bitcode"), but it can be a container for other data.
42 /// Low-level reader/writer libraries are in Bitstream/Bitstream*.h
43 ///
44 //===---------------------------------------------------------------------===//
45 
46 #ifndef LLVM_SUPPORT_JSON_H
47 #define LLVM_SUPPORT_JSON_H
48 
49 #include "llvm/ADT/DenseMap.h"
50 #include "llvm/ADT/SmallVector.h"
51 #include "llvm/ADT/StringRef.h"
52 #include "llvm/Support/Error.h"
55 #include <map>
56 
57 namespace llvm {
58 namespace json {
59 
60 // === String encodings ===
61 //
62 // JSON strings are character sequences (not byte sequences like std::string).
63 // We need to know the encoding, and for simplicity only support UTF-8.
64 //
65 // - When parsing, invalid UTF-8 is a syntax error like any other
66 //
67 // - When creating Values from strings, callers must ensure they are UTF-8.
68 // with asserts on, invalid UTF-8 will crash the program
69 // with asserts off, we'll substitute the replacement character (U+FFFD)
70 // Callers can use json::isUTF8() and json::fixUTF8() for validation.
71 //
72 // - When retrieving strings from Values (e.g. asString()), the result will
73 // always be valid UTF-8.
74 
75 /// Returns true if \p S is valid UTF-8, which is required for use as JSON.
76 /// If it returns false, \p Offset is set to a byte offset near the first error.
77 bool isUTF8(llvm::StringRef S, size_t *ErrOffset = nullptr);
78 /// Replaces invalid UTF-8 sequences in \p S with the replacement character
79 /// (U+FFFD). The returned string is valid UTF-8.
80 /// This is much slower than isUTF8, so test that first.
81 std::string fixUTF8(llvm::StringRef S);
82 
83 class Array;
84 class ObjectKey;
85 class Value;
86 template <typename T> Value toJSON(const llvm::Optional<T> &Opt);
87 
88 /// An Object is a JSON object, which maps strings to heterogenous JSON values.
89 /// It simulates DenseMap<ObjectKey, Value>. ObjectKey is a maybe-owned string.
90 class Object {
92  Storage M;
93 
94 public:
96  using mapped_type = Value;
100 
101  Object() = default;
102  // KV is a trivial key-value struct for list-initialization.
103  // (using std::pair forces extra copies).
104  struct KV;
105  explicit Object(std::initializer_list<KV> Properties);
106 
107  iterator begin() { return M.begin(); }
108  const_iterator begin() const { return M.begin(); }
109  iterator end() { return M.end(); }
110  const_iterator end() const { return M.end(); }
111 
112  bool empty() const { return M.empty(); }
113  size_t size() const { return M.size(); }
114 
115  void clear() { M.clear(); }
116  std::pair<iterator, bool> insert(KV E);
117  template <typename... Ts>
118  std::pair<iterator, bool> try_emplace(const ObjectKey &K, Ts &&... Args) {
119  return M.try_emplace(K, std::forward<Ts>(Args)...);
120  }
121  template <typename... Ts>
122  std::pair<iterator, bool> try_emplace(ObjectKey &&K, Ts &&... Args) {
123  return M.try_emplace(std::move(K), std::forward<Ts>(Args)...);
124  }
125  bool erase(StringRef K);
126  void erase(iterator I) { M.erase(I); }
127 
128  iterator find(StringRef K) { return M.find_as(K); }
129  const_iterator find(StringRef K) const { return M.find_as(K); }
130  // operator[] acts as if Value was default-constructible as null.
131  Value &operator[](const ObjectKey &K);
132  Value &operator[](ObjectKey &&K);
133  // Look up a property, returning nullptr if it doesn't exist.
134  Value *get(StringRef K);
135  const Value *get(StringRef K) const;
136  // Typed accessors return None/nullptr if
137  // - the property doesn't exist
138  // - or it has the wrong type
144  const json::Object *getObject(StringRef K) const;
146  const json::Array *getArray(StringRef K) const;
148 };
149 bool operator==(const Object &LHS, const Object &RHS);
150 inline bool operator!=(const Object &LHS, const Object &RHS) {
151  return !(LHS == RHS);
152 }
153 
154 /// An Array is a JSON array, which contains heterogeneous JSON values.
155 /// It simulates std::vector<Value>.
156 class Array {
157  std::vector<Value> V;
158 
159 public:
160  using value_type = Value;
161  using iterator = std::vector<Value>::iterator;
162  using const_iterator = std::vector<Value>::const_iterator;
163 
164  Array() = default;
165  explicit Array(std::initializer_list<Value> Elements);
166  template <typename Collection> explicit Array(const Collection &C) {
167  for (const auto &V : C)
168  emplace_back(V);
169  }
170 
171  Value &operator[](size_t I) { return V[I]; }
172  const Value &operator[](size_t I) const { return V[I]; }
173  Value &front() { return V.front(); }
174  const Value &front() const { return V.front(); }
175  Value &back() { return V.back(); }
176  const Value &back() const { return V.back(); }
177  Value *data() { return V.data(); }
178  const Value *data() const { return V.data(); }
179 
180  iterator begin() { return V.begin(); }
181  const_iterator begin() const { return V.begin(); }
182  iterator end() { return V.end(); }
183  const_iterator end() const { return V.end(); }
184 
185  bool empty() const { return V.empty(); }
186  size_t size() const { return V.size(); }
187  void reserve(size_t S) { V.reserve(S); }
188 
189  void clear() { V.clear(); }
190  void push_back(const Value &E) { V.push_back(E); }
191  void push_back(Value &&E) { V.push_back(std::move(E)); }
192  template <typename... Args> void emplace_back(Args &&... A) {
193  V.emplace_back(std::forward<Args>(A)...);
194  }
195  void pop_back() { V.pop_back(); }
196  // FIXME: insert() takes const_iterator since C++11, old libstdc++ disagrees.
197  iterator insert(iterator P, const Value &E) { return V.insert(P, E); }
199  return V.insert(P, std::move(E));
200  }
201  template <typename It> iterator insert(iterator P, It A, It Z) {
202  return V.insert(P, A, Z);
203  }
204  template <typename... Args> iterator emplace(const_iterator P, Args &&... A) {
205  return V.emplace(P, std::forward<Args>(A)...);
206  }
207 
208  friend bool operator==(const Array &L, const Array &R) { return L.V == R.V; }
209 };
210 inline bool operator!=(const Array &L, const Array &R) { return !(L == R); }
211 
212 /// A Value is an JSON value of unknown type.
213 /// They can be copied, but should generally be moved.
214 ///
215 /// === Composing values ===
216 ///
217 /// You can implicitly construct Values from:
218 /// - strings: std::string, SmallString, formatv, StringRef, char*
219 /// (char*, and StringRef are references, not copies!)
220 /// - numbers
221 /// - booleans
222 /// - null: nullptr
223 /// - arrays: {"foo", 42.0, false}
224 /// - serializable things: types with toJSON(const T&)->Value, found by ADL
225 ///
226 /// They can also be constructed from object/array helpers:
227 /// - json::Object is a type like map<ObjectKey, Value>
228 /// - json::Array is a type like vector<Value>
229 /// These can be list-initialized, or used to build up collections in a loop.
230 /// json::ary(Collection) converts all items in a collection to Values.
231 ///
232 /// === Inspecting values ===
233 ///
234 /// Each Value is one of the JSON kinds:
235 /// null (nullptr_t)
236 /// boolean (bool)
237 /// number (double, int64 or uint64)
238 /// string (StringRef)
239 /// array (json::Array)
240 /// object (json::Object)
241 ///
242 /// The kind can be queried directly, or implicitly via the typed accessors:
243 /// if (Optional<StringRef> S = E.getAsString()
244 /// assert(E.kind() == Value::String);
245 ///
246 /// Array and Object also have typed indexing accessors for easy traversal:
247 /// Expected<Value> E = parse(R"( {"options": {"font": "sans-serif"}} )");
248 /// if (Object* O = E->getAsObject())
249 /// if (Object* Opts = O->getObject("options"))
250 /// if (Optional<StringRef> Font = Opts->getString("font"))
251 /// assert(Opts->at("font").kind() == Value::String);
252 ///
253 /// === Converting JSON values to C++ types ===
254 ///
255 /// The convention is to have a deserializer function findable via ADL:
256 /// fromJSON(const json::Value&, T&, Path) -> bool
257 ///
258 /// The return value indicates overall success, and Path is used for precise
259 /// error reporting. (The Path::Root passed in at the top level fromJSON call
260 /// captures any nested error and can render it in context).
261 /// If conversion fails, fromJSON calls Path::report() and immediately returns.
262 /// This ensures that the first fatal error survives.
263 ///
264 /// Deserializers are provided for:
265 /// - bool
266 /// - int and int64_t
267 /// - double
268 /// - std::string
269 /// - vector<T>, where T is deserializable
270 /// - map<string, T>, where T is deserializable
271 /// - Optional<T>, where T is deserializable
272 /// ObjectMapper can help writing fromJSON() functions for object types.
273 ///
274 /// For conversion in the other direction, the serializer function is:
275 /// toJSON(const T&) -> json::Value
276 /// If this exists, then it also allows constructing Value from T, and can
277 /// be used to serialize vector<T>, map<string, T>, and Optional<T>.
278 ///
279 /// === Serialization ===
280 ///
281 /// Values can be serialized to JSON:
282 /// 1) raw_ostream << Value // Basic formatting.
283 /// 2) raw_ostream << formatv("{0}", Value) // Basic formatting.
284 /// 3) raw_ostream << formatv("{0:2}", Value) // Pretty-print with indent 2.
285 ///
286 /// And parsed:
287 /// Expected<Value> E = json::parse("[1, 2, null]");
288 /// assert(E && E->kind() == Value::Array);
289 class Value {
290 public:
291  enum Kind {
294  /// Number values can store both int64s and doubles at full precision,
295  /// depending on what they were constructed/parsed from.
300  };
301 
302  // It would be nice to have Value() be null. But that would make {} null too.
303  Value(const Value &M) { copyFrom(M); }
304  Value(Value &&M) { moveFrom(std::move(M)); }
305  Value(std::initializer_list<Value> Elements);
306  Value(json::Array &&Elements) : Type(T_Array) {
307  create<json::Array>(std::move(Elements));
308  }
309  template <typename Elt>
310  Value(const std::vector<Elt> &C) : Value(json::Array(C)) {}
311  Value(json::Object &&Properties) : Type(T_Object) {
312  create<json::Object>(std::move(Properties));
313  }
314  template <typename Elt>
315  Value(const std::map<std::string, Elt> &C) : Value(json::Object(C)) {}
316  // Strings: types with value semantics. Must be valid UTF-8.
317  Value(std::string V) : Type(T_String) {
318  if (LLVM_UNLIKELY(!isUTF8(V))) {
319  assert(false && "Invalid UTF-8 in value used as JSON");
320  V = fixUTF8(std::move(V));
321  }
322  create<std::string>(std::move(V));
323  }
325  : Value(std::string(V.begin(), V.end())) {}
326  Value(const llvm::formatv_object_base &V) : Value(V.str()) {}
327  // Strings: types with reference semantics. Must be valid UTF-8.
328  Value(StringRef V) : Type(T_StringRef) {
329  create<llvm::StringRef>(V);
330  if (LLVM_UNLIKELY(!isUTF8(V))) {
331  assert(false && "Invalid UTF-8 in value used as JSON");
332  *this = Value(fixUTF8(V));
333  }
334  }
335  Value(const char *V) : Value(StringRef(V)) {}
336  Value(std::nullptr_t) : Type(T_Null) {}
337  // Boolean (disallow implicit conversions).
338  // (The last template parameter is a dummy to keep templates distinct.)
339  template <typename T,
340  typename = std::enable_if_t<std::is_same<T, bool>::value>,
341  bool = false>
342  Value(T B) : Type(T_Boolean) {
343  create<bool>(B);
344  }
345 
346  // Unsigned 64-bit long integers.
347  template <typename T,
348  typename = std::enable_if_t<std::is_same<T, uint64_t>::value>,
349  bool = false, bool = false>
350  Value(T V) : Type(T_UINT64) {
351  create<uint64_t>(uint64_t{V});
352  }
353 
354  // Integers (except boolean and uint64_t).
355  // Must be non-narrowing convertible to int64_t.
356  template <typename T, typename = std::enable_if_t<std::is_integral<T>::value>,
357  typename = std::enable_if_t<!std::is_same<T, bool>::value>,
358  typename = std::enable_if_t<!std::is_same<T, uint64_t>::value>>
359  Value(T I) : Type(T_Integer) {
360  create<int64_t>(int64_t{I});
361  }
362  // Floating point. Must be non-narrowing convertible to double.
363  template <typename T,
364  typename = std::enable_if_t<std::is_floating_point<T>::value>,
365  double * = nullptr>
366  Value(T D) : Type(T_Double) {
367  create<double>(double{D});
368  }
369  // Serializable types: with a toJSON(const T&)->Value function, found by ADL.
370  template <typename T,
371  typename = std::enable_if_t<std::is_same<
372  Value, decltype(toJSON(*(const T *)nullptr))>::value>,
373  Value * = nullptr>
374  Value(const T &V) : Value(toJSON(V)) {}
375 
376  Value &operator=(const Value &M) {
377  destroy();
378  copyFrom(M);
379  return *this;
380  }
382  destroy();
383  moveFrom(std::move(M));
384  return *this;
385  }
386  ~Value() { destroy(); }
387 
388  Kind kind() const {
389  switch (Type) {
390  case T_Null:
391  return Null;
392  case T_Boolean:
393  return Boolean;
394  case T_Double:
395  case T_Integer:
396  case T_UINT64:
397  return Number;
398  case T_String:
399  case T_StringRef:
400  return String;
401  case T_Object:
402  return Object;
403  case T_Array:
404  return Array;
405  }
406  llvm_unreachable("Unknown kind");
407  }
408 
409  // Typed accessors return None/nullptr if the Value is not of this type.
411  if (LLVM_LIKELY(Type == T_Null))
412  return nullptr;
413  return llvm::None;
414  }
416  if (LLVM_LIKELY(Type == T_Boolean))
417  return as<bool>();
418  return llvm::None;
419  }
421  if (LLVM_LIKELY(Type == T_Double))
422  return as<double>();
423  if (LLVM_LIKELY(Type == T_Integer))
424  return as<int64_t>();
425  if (LLVM_LIKELY(Type == T_UINT64))
426  return as<uint64_t>();
427  return llvm::None;
428  }
429  // Succeeds if the Value is a Number, and exactly representable as int64_t.
431  if (LLVM_LIKELY(Type == T_Integer))
432  return as<int64_t>();
433  if (LLVM_LIKELY(Type == T_Double)) {
434  double D = as<double>();
435  if (LLVM_LIKELY(std::modf(D, &D) == 0.0 &&
436  D >= double(std::numeric_limits<int64_t>::min()) &&
437  D <= double(std::numeric_limits<int64_t>::max())))
438  return D;
439  }
440  return llvm::None;
441  }
443  if (Type == T_UINT64)
444  return as<uint64_t>();
445  else if (Type == T_Integer) {
446  int64_t N = as<int64_t>();
447  if (N >= 0)
448  return as<uint64_t>();
449  }
450  return llvm::None;
451  }
453  if (Type == T_String)
454  return llvm::StringRef(as<std::string>());
455  if (LLVM_LIKELY(Type == T_StringRef))
456  return as<llvm::StringRef>();
457  return llvm::None;
458  }
459  const json::Object *getAsObject() const {
460  return LLVM_LIKELY(Type == T_Object) ? &as<json::Object>() : nullptr;
461  }
463  return LLVM_LIKELY(Type == T_Object) ? &as<json::Object>() : nullptr;
464  }
465  const json::Array *getAsArray() const {
466  return LLVM_LIKELY(Type == T_Array) ? &as<json::Array>() : nullptr;
467  }
469  return LLVM_LIKELY(Type == T_Array) ? &as<json::Array>() : nullptr;
470  }
471 
472 private:
473  void destroy();
474  void copyFrom(const Value &M);
475  // We allow moving from *const* Values, by marking all members as mutable!
476  // This hack is needed to support initializer-list syntax efficiently.
477  // (std::initializer_list<T> is a container of const T).
478  void moveFrom(const Value &&M);
479  friend class Array;
480  friend class Object;
481 
482  template <typename T, typename... U> void create(U &&... V) {
483  new (reinterpret_cast<T *>(&Union)) T(std::forward<U>(V)...);
484  }
485  template <typename T> T &as() const {
486  // Using this two-step static_cast via void * instead of reinterpret_cast
487  // silences a -Wstrict-aliasing false positive from GCC6 and earlier.
488  void *Storage = static_cast<void *>(&Union);
489  return *static_cast<T *>(Storage);
490  }
491 
492  friend class OStream;
493 
494  enum ValueType : char16_t {
495  T_Null,
496  T_Boolean,
497  T_Double,
498  T_Integer,
499  T_UINT64,
500  T_StringRef,
501  T_String,
502  T_Object,
503  T_Array,
504  };
505  // All members mutable, see moveFrom().
506  mutable ValueType Type;
507  mutable llvm::AlignedCharArrayUnion<bool, double, int64_t, uint64_t,
508  llvm::StringRef, std::string, json::Array,
509  json::Object>
510  Union;
511  friend bool operator==(const Value &, const Value &);
512 };
513 
514 bool operator==(const Value &, const Value &);
515 inline bool operator!=(const Value &L, const Value &R) { return !(L == R); }
516 
517 /// ObjectKey is a used to capture keys in Object. Like Value but:
518 /// - only strings are allowed
519 /// - it's optimized for the string literal case (Owned == nullptr)
520 /// Like Value, strings must be UTF-8. See isUTF8 documentation for details.
521 class ObjectKey {
522 public:
523  ObjectKey(const char *S) : ObjectKey(StringRef(S)) {}
524  ObjectKey(std::string S) : Owned(new std::string(std::move(S))) {
525  if (LLVM_UNLIKELY(!isUTF8(*Owned))) {
526  assert(false && "Invalid UTF-8 in value used as JSON");
527  *Owned = fixUTF8(std::move(*Owned));
528  }
529  Data = *Owned;
530  }
532  if (LLVM_UNLIKELY(!isUTF8(Data))) {
533  assert(false && "Invalid UTF-8 in value used as JSON");
534  *this = ObjectKey(fixUTF8(S));
535  }
536  }
538  : ObjectKey(std::string(V.begin(), V.end())) {}
540 
541  ObjectKey(const ObjectKey &C) { *this = C; }
542  ObjectKey(ObjectKey &&C) : ObjectKey(static_cast<const ObjectKey &&>(C)) {}
544  if (C.Owned) {
545  Owned.reset(new std::string(*C.Owned));
546  Data = *Owned;
547  } else {
548  Data = C.Data;
549  }
550  return *this;
551  }
552  ObjectKey &operator=(ObjectKey &&) = default;
553 
554  operator llvm::StringRef() const { return Data; }
555  std::string str() const { return Data.str(); }
556 
557 private:
558  // FIXME: this is unneccesarily large (3 pointers). Pointer + length + owned
559  // could be 2 pointers at most.
560  std::unique_ptr<std::string> Owned;
561  llvm::StringRef Data;
562 };
563 
564 inline bool operator==(const ObjectKey &L, const ObjectKey &R) {
565  return llvm::StringRef(L) == llvm::StringRef(R);
566 }
567 inline bool operator!=(const ObjectKey &L, const ObjectKey &R) {
568  return !(L == R);
569 }
570 inline bool operator<(const ObjectKey &L, const ObjectKey &R) {
571  return StringRef(L) < StringRef(R);
572 }
573 
574 struct Object::KV {
577 };
578 
579 inline Object::Object(std::initializer_list<KV> Properties) {
580  for (const auto &P : Properties) {
581  auto R = try_emplace(P.K, nullptr);
582  if (R.second)
583  R.first->getSecond().moveFrom(std::move(P.V));
584  }
585 }
586 inline std::pair<Object::iterator, bool> Object::insert(KV E) {
587  return try_emplace(std::move(E.K), std::move(E.V));
588 }
589 inline bool Object::erase(StringRef K) {
590  return M.erase(ObjectKey(K));
591 }
592 
593 /// A "cursor" marking a position within a Value.
594 /// The Value is a tree, and this is the path from the root to the current node.
595 /// This is used to associate errors with particular subobjects.
596 class Path {
597 public:
598  class Root;
599 
600  /// Records that the value at the current path is invalid.
601  /// Message is e.g. "expected number" and becomes part of the final error.
602  /// This overwrites any previously written error message in the root.
603  void report(llvm::StringLiteral Message);
604 
605  /// The root may be treated as a Path.
606  Path(Root &R) : Parent(nullptr), Seg(&R) {}
607  /// Derives a path for an array element: this[Index]
608  Path index(unsigned Index) const { return Path(this, Segment(Index)); }
609  /// Derives a path for an object field: this.Field
610  Path field(StringRef Field) const { return Path(this, Segment(Field)); }
611 
612 private:
613  /// One element in a JSON path: an object field (.foo) or array index [27].
614  /// Exception: the root Path encodes a pointer to the Path::Root.
615  class Segment {
616  uintptr_t Pointer;
617  unsigned Offset;
618 
619  public:
620  Segment() = default;
621  Segment(Root *R) : Pointer(reinterpret_cast<uintptr_t>(R)) {}
622  Segment(llvm::StringRef Field)
623  : Pointer(reinterpret_cast<uintptr_t>(Field.data())),
624  Offset(static_cast<unsigned>(Field.size())) {}
625  Segment(unsigned Index) : Pointer(0), Offset(Index) {}
626 
627  bool isField() const { return Pointer != 0; }
628  StringRef field() const {
629  return StringRef(reinterpret_cast<const char *>(Pointer), Offset);
630  }
631  unsigned index() const { return Offset; }
632  Root *root() const { return reinterpret_cast<Root *>(Pointer); }
633  };
634 
635  const Path *Parent;
636  Segment Seg;
637 
638  Path(const Path *Parent, Segment S) : Parent(Parent), Seg(S) {}
639 };
640 
641 /// The root is the trivial Path to the root value.
642 /// It also stores the latest reported error and the path where it occurred.
643 class Path::Root {
644  llvm::StringRef Name;
645  llvm::StringLiteral ErrorMessage;
646  std::vector<Path::Segment> ErrorPath; // Only valid in error state. Reversed.
647 
648  friend void Path::report(llvm::StringLiteral Message);
649 
650 public:
651  Root(llvm::StringRef Name = "") : Name(Name), ErrorMessage("") {}
652  // No copy/move allowed as there are incoming pointers.
653  Root(Root &&) = delete;
654  Root &operator=(Root &&) = delete;
655  Root(const Root &) = delete;
656  Root &operator=(const Root &) = delete;
657 
658  /// Returns the last error reported, or else a generic error.
659  Error getError() const;
660  /// Print the root value with the error shown inline as a comment.
661  /// Unrelated parts of the value are elided for brevity, e.g.
662  /// {
663  /// "id": 42,
664  /// "name": /* expected string */ null,
665  /// "properties": { ... }
666  /// }
667  void printErrorContext(const Value &, llvm::raw_ostream &) const;
668 };
669 
670 // Standard deserializers are provided for primitive types.
671 // See comments on Value.
672 inline bool fromJSON(const Value &E, std::string &Out, Path P) {
673  if (auto S = E.getAsString()) {
674  Out = std::string(*S);
675  return true;
676  }
677  P.report("expected string");
678  return false;
679 }
680 inline bool fromJSON(const Value &E, int &Out, Path P) {
681  if (auto S = E.getAsInteger()) {
682  Out = *S;
683  return true;
684  }
685  P.report("expected integer");
686  return false;
687 }
688 inline bool fromJSON(const Value &E, int64_t &Out, Path P) {
689  if (auto S = E.getAsInteger()) {
690  Out = *S;
691  return true;
692  }
693  P.report("expected integer");
694  return false;
695 }
696 inline bool fromJSON(const Value &E, double &Out, Path P) {
697  if (auto S = E.getAsNumber()) {
698  Out = *S;
699  return true;
700  }
701  P.report("expected number");
702  return false;
703 }
704 inline bool fromJSON(const Value &E, bool &Out, Path P) {
705  if (auto S = E.getAsBoolean()) {
706  Out = *S;
707  return true;
708  }
709  P.report("expected boolean");
710  return false;
711 }
712 inline bool fromJSON(const Value &E, uint64_t &Out, Path P) {
713  if (auto S = E.getAsUINT64()) {
714  Out = *S;
715  return true;
716  }
717  P.report("expected uint64_t");
718  return false;
719 }
720 inline bool fromJSON(const Value &E, std::nullptr_t &Out, Path P) {
721  if (auto S = E.getAsNull()) {
722  Out = *S;
723  return true;
724  }
725  P.report("expected null");
726  return false;
727 }
728 template <typename T>
729 bool fromJSON(const Value &E, llvm::Optional<T> &Out, Path P) {
730  if (E.getAsNull()) {
731  Out = llvm::None;
732  return true;
733  }
734  T Result;
735  if (!fromJSON(E, Result, P))
736  return false;
737  Out = std::move(Result);
738  return true;
739 }
740 template <typename T>
741 bool fromJSON(const Value &E, std::vector<T> &Out, Path P) {
742  if (auto *A = E.getAsArray()) {
743  Out.clear();
744  Out.resize(A->size());
745  for (size_t I = 0; I < A->size(); ++I)
746  if (!fromJSON((*A)[I], Out[I], P.index(I)))
747  return false;
748  return true;
749  }
750  P.report("expected array");
751  return false;
752 }
753 template <typename T>
754 bool fromJSON(const Value &E, std::map<std::string, T> &Out, Path P) {
755  if (auto *O = E.getAsObject()) {
756  Out.clear();
757  for (const auto &KV : *O)
758  if (!fromJSON(KV.second, Out[std::string(llvm::StringRef(KV.first))],
759  P.field(KV.first)))
760  return false;
761  return true;
762  }
763  P.report("expected object");
764  return false;
765 }
766 
767 // Allow serialization of Optional<T> for supported T.
768 template <typename T> Value toJSON(const llvm::Optional<T> &Opt) {
769  return Opt ? Value(*Opt) : Value(nullptr);
770 }
771 
772 /// Helper for mapping JSON objects onto protocol structs.
773 ///
774 /// Example:
775 /// \code
776 /// bool fromJSON(const Value &E, MyStruct &R, Path P) {
777 /// ObjectMapper O(E, P);
778 /// // When returning false, error details were already reported.
779 /// return O && O.map("mandatory_field", R.MandatoryField) &&
780 /// O.mapOptional("optional_field", R.OptionalField);
781 /// }
782 /// \endcode
784 public:
785  /// If O is not an object, this mapper is invalid and an error is reported.
786  ObjectMapper(const Value &E, Path P) : O(E.getAsObject()), P(P) {
787  if (!O)
788  P.report("expected object");
789  }
790 
791  /// True if the expression is an object.
792  /// Must be checked before calling map().
793  operator bool() const { return O; }
794 
795  /// Maps a property to a field.
796  /// If the property is missing or invalid, reports an error.
797  template <typename T> bool map(StringLiteral Prop, T &Out) {
798  assert(*this && "Must check this is an object before calling map()");
799  if (const Value *E = O->get(Prop))
800  return fromJSON(*E, Out, P.field(Prop));
801  P.field(Prop).report("missing value");
802  return false;
803  }
804 
805  /// Maps a property to a field, if it exists.
806  /// If the property exists and is invalid, reports an error.
807  /// (Optional requires special handling, because missing keys are OK).
808  template <typename T> bool map(StringLiteral Prop, llvm::Optional<T> &Out) {
809  assert(*this && "Must check this is an object before calling map()");
810  if (const Value *E = O->get(Prop))
811  return fromJSON(*E, Out, P.field(Prop));
812  Out = llvm::None;
813  return true;
814  }
815 
816  /// Maps a property to a field, if it exists.
817  /// If the property exists and is invalid, reports an error.
818  /// If the property does not exist, Out is unchanged.
819  template <typename T> bool mapOptional(StringLiteral Prop, T &Out) {
820  assert(*this && "Must check this is an object before calling map()");
821  if (const Value *E = O->get(Prop))
822  return fromJSON(*E, Out, P.field(Prop));
823  return true;
824  }
825 
826 private:
827  const Object *O;
828  Path P;
829 };
830 
831 /// Parses the provided JSON source, or returns a ParseError.
832 /// The returned Value is self-contained and owns its strings (they do not refer
833 /// to the original source).
835 
836 class ParseError : public llvm::ErrorInfo<ParseError> {
837  const char *Msg;
838  unsigned Line, Column, Offset;
839 
840 public:
841  static char ID;
842  ParseError(const char *Msg, unsigned Line, unsigned Column, unsigned Offset)
843  : Msg(Msg), Line(Line), Column(Column), Offset(Offset) {}
844  void log(llvm::raw_ostream &OS) const override {
845  OS << llvm::formatv("[{0}:{1}, byte={2}]: {3}", Line, Column, Offset, Msg);
846  }
847  std::error_code convertToErrorCode() const override {
849  }
850 };
851 
852 /// Version of parse() that converts the parsed value to the type T.
853 /// RootName describes the root object and is used in error messages.
854 template <typename T>
855 Expected<T> parse(const llvm::StringRef &JSON, const char *RootName = "") {
856  auto V = parse(JSON);
857  if (!V)
858  return V.takeError();
859  Path::Root R(RootName);
860  T Result;
861  if (fromJSON(*V, Result, R))
862  return std::move(Result);
863  return R.getError();
864 }
865 
866 /// json::OStream allows writing well-formed JSON without materializing
867 /// all structures as json::Value ahead of time.
868 /// It's faster, lower-level, and less safe than OS << json::Value.
869 /// It also allows emitting more constructs, such as comments.
870 ///
871 /// Only one "top-level" object can be written to a stream.
872 /// Simplest usage involves passing lambdas (Blocks) to fill in containers:
873 ///
874 /// json::OStream J(OS);
875 /// J.array([&]{
876 /// for (const Event &E : Events)
877 /// J.object([&] {
878 /// J.attribute("timestamp", int64_t(E.Time));
879 /// J.attributeArray("participants", [&] {
880 /// for (const Participant &P : E.Participants)
881 /// J.value(P.toString());
882 /// });
883 /// });
884 /// });
885 ///
886 /// This would produce JSON like:
887 ///
888 /// [
889 /// {
890 /// "timestamp": 19287398741,
891 /// "participants": [
892 /// "King Kong",
893 /// "Miley Cyrus",
894 /// "Cleopatra"
895 /// ]
896 /// },
897 /// ...
898 /// ]
899 ///
900 /// The lower level begin/end methods (arrayBegin()) are more flexible but
901 /// care must be taken to pair them correctly:
902 ///
903 /// json::OStream J(OS);
904 // J.arrayBegin();
905 /// for (const Event &E : Events) {
906 /// J.objectBegin();
907 /// J.attribute("timestamp", int64_t(E.Time));
908 /// J.attributeBegin("participants");
909 /// for (const Participant &P : E.Participants)
910 /// J.value(P.toString());
911 /// J.attributeEnd();
912 /// J.objectEnd();
913 /// }
914 /// J.arrayEnd();
915 ///
916 /// If the call sequence isn't valid JSON, asserts will fire in debug mode.
917 /// This can be mismatched begin()/end() pairs, trying to emit attributes inside
918 /// an array, and so on.
919 /// With asserts disabled, this is undefined behavior.
920 class OStream {
921  public:
922  using Block = llvm::function_ref<void()>;
923  // If IndentSize is nonzero, output is pretty-printed.
924  explicit OStream(llvm::raw_ostream &OS, unsigned IndentSize = 0)
925  : OS(OS), IndentSize(IndentSize) {
926  Stack.emplace_back();
927  }
929  assert(Stack.size() == 1 && "Unmatched begin()/end()");
930  assert(Stack.back().Ctx == Singleton);
931  assert(Stack.back().HasValue && "Did not write top-level value");
932  }
933 
934  /// Flushes the underlying ostream. OStream does not buffer internally.
935  void flush() { OS.flush(); }
936 
937  // High level functions to output a value.
938  // Valid at top-level (exactly once), in an attribute value (exactly once),
939  // or in an array (any number of times).
940 
941  /// Emit a self-contained value (number, string, vector<string> etc).
942  void value(const Value &V);
943  /// Emit an array whose elements are emitted in the provided Block.
944  void array(Block Contents) {
945  arrayBegin();
946  Contents();
947  arrayEnd();
948  }
949  /// Emit an object whose elements are emitted in the provided Block.
950  void object(Block Contents) {
951  objectBegin();
952  Contents();
953  objectEnd();
954  }
955  /// Emit an externally-serialized value.
956  /// The caller must write exactly one valid JSON value to the provided stream.
957  /// No validation or formatting of this value occurs.
958  void rawValue(llvm::function_ref<void(raw_ostream &)> Contents) {
959  rawValueBegin();
960  Contents(OS);
961  rawValueEnd();
962  }
963  void rawValue(llvm::StringRef Contents) {
964  rawValue([&](raw_ostream &OS) { OS << Contents; });
965  }
966  /// Emit a JavaScript comment associated with the next printed value.
967  /// The string must be valid until the next attribute or value is emitted.
968  /// Comments are not part of standard JSON, and many parsers reject them!
969  void comment(llvm::StringRef);
970 
971  // High level functions to output object attributes.
972  // Valid only within an object (any number of times).
973 
974  /// Emit an attribute whose value is self-contained (number, vector<int> etc).
975  void attribute(llvm::StringRef Key, const Value& Contents) {
976  attributeImpl(Key, [&] { value(Contents); });
977  }
978  /// Emit an attribute whose value is an array with elements from the Block.
980  attributeImpl(Key, [&] { array(Contents); });
981  }
982  /// Emit an attribute whose value is an object with attributes from the Block.
984  attributeImpl(Key, [&] { object(Contents); });
985  }
986 
987  // Low-level begin/end functions to output arrays, objects, and attributes.
988  // Must be correctly paired. Allowed contexts are as above.
989 
990  void arrayBegin();
991  void arrayEnd();
992  void objectBegin();
993  void objectEnd();
995  void attributeEnd();
997  void rawValueEnd();
998 
999 private:
1000  void attributeImpl(llvm::StringRef Key, Block Contents) {
1002  Contents();
1003  attributeEnd();
1004  }
1005 
1006  void valueBegin();
1007  void flushComment();
1008  void newline();
1009 
1010  enum Context {
1011  Singleton, // Top level, or object attribute.
1012  Array,
1013  Object,
1014  RawValue, // External code writing a value to OS directly.
1015  };
1016  struct State {
1017  Context Ctx = Singleton;
1018  bool HasValue = false;
1019  };
1020  llvm::SmallVector<State, 16> Stack; // Never empty.
1021  llvm::StringRef PendingComment;
1022  llvm::raw_ostream &OS;
1023  unsigned IndentSize;
1024  unsigned Indent = 0;
1025 };
1026 
1027 /// Serializes this Value to JSON, writing it to the provided stream.
1028 /// The formatting is compact (no extra whitespace) and deterministic.
1029 /// For pretty-printing, use the formatv() format_provider below.
1031  OStream(OS).value(V);
1032  return OS;
1033 }
1034 } // namespace json
1035 
1036 /// Allow printing json::Value with formatv().
1037 /// The default style is basic/compact formatting, like operator<<.
1038 /// A format string like formatv("{0:2}", Value) pretty-prints with indent 2.
1039 template <> struct format_provider<llvm::json::Value> {
1040  static void format(const llvm::json::Value &, raw_ostream &, StringRef);
1041 };
1042 } // namespace llvm
1043 
1044 #endif
llvm::json::Object::Object
Object()=default
llvm::json::Object::erase
bool erase(StringRef K)
Definition: JSON.h:589
llvm::json::Array::operator[]
Value & operator[](size_t I)
Definition: JSON.h:171
llvm::json::OStream::comment
void comment(llvm::StringRef)
Emit a JavaScript comment associated with the next printed value.
Definition: JSON.cpp:791
llvm::json::OStream::attributeBegin
void attributeBegin(llvm::StringRef Key)
Definition: JSON.cpp:866
llvm::json::Path::Root
The root is the trivial Path to the root value.
Definition: JSON.h:643
as
compiles conv shl5 shl ret i32 or10 it would be better as
Definition: README.txt:615
llvm::json::Value
A Value is an JSON value of unknown type.
Definition: JSON.h:289
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::json::Value::Value
Value(std::nullptr_t)
Definition: JSON.h:336
llvm::json::Value::kind
Kind kind() const
Definition: JSON.h:388
llvm::json::Value::Value
Value(const char *V)
Definition: JSON.h:335
llvm::json::Value::Value
Value(T I)
Definition: JSON.h:359
llvm::json::OStream::~OStream
~OStream()
Definition: JSON.h:928
llvm::format_provider
Definition: FormatVariadicDetails.h:18
llvm::json::Value::Boolean
@ Boolean
Definition: JSON.h:293
llvm::json::Value::Object
friend class Object
Definition: JSON.h:480
llvm::json::Array::empty
bool empty() const
Definition: JSON.h:185
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::json::OStream::attributeEnd
void attributeEnd()
Definition: JSON.cpp:886
llvm::json::Array::emplace
iterator emplace(const_iterator P, Args &&... A)
Definition: JSON.h:204
llvm::json::Object::find
const_iterator find(StringRef K) const
Definition: JSON.h:129
llvm::json::Array::emplace_back
void emplace_back(Args &&... A)
Definition: JSON.h:192
double
into xmm2 addss xmm2 xmm1 xmm3 addss xmm3 movaps xmm0 unpcklps xmm0 ret seems silly when it could just be one addps Expand libm rounding functions main should enable SSE DAZ mode and other fast SSE modes Think about doing i64 math in SSE regs on x86 This testcase should have no SSE instructions in and only one load from a constant double
Definition: README-SSE.txt:85
llvm::SmallVector< State, 16 >
llvm::json::Value::Value
Value(T V)
Definition: JSON.h:350
Error.h
llvm::json::Value::operator==
friend bool operator==(const Value &, const Value &)
Definition: JSON.cpp:181
llvm::json::Value::getAsNull
llvm::Optional< std::nullptr_t > getAsNull() const
Definition: JSON.h:410
llvm::DenseMapBase::erase
bool erase(const KeyT &Val)
Definition: DenseMap.h:302
llvm::json::ObjectKey::ObjectKey
ObjectKey(const char *S)
Definition: JSON.h:523
llvm::DenseMapIterator
Definition: DenseMap.h:56
llvm::json::OStream::Block
llvm::function_ref< void()> Block
Definition: JSON.h:922
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
DenseMap.h
llvm::sys::path::end
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:236
llvm::sys::path::begin
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:227
llvm::json::Path::Root::printErrorContext
void printErrorContext(const Value &, llvm::raw_ostream &) const
Print the root value with the error shown inline as a comment.
Definition: JSON.cpp:307
llvm::json::OStream::attributeArray
void attributeArray(llvm::StringRef Key, Block Contents)
Emit an attribute whose value is an array with elements from the Block.
Definition: JSON.h:979
llvm::json::ObjectMapper::ObjectMapper
ObjectMapper(const Value &E, Path P)
If O is not an object, this mapper is invalid and an error is reported.
Definition: JSON.h:786
llvm::Optional
Definition: APInt.h:33
llvm::json::Value::Null
@ Null
Definition: JSON.h:292
T
#define T
Definition: Mips16ISelLowering.cpp:341
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:80
llvm::json::ObjectMapper::map
bool map(StringLiteral Prop, T &Out)
Maps a property to a field.
Definition: JSON.h:797
llvm::json::Object::erase
void erase(iterator I)
Definition: JSON.h:126
llvm::json::Value::getAsNumber
llvm::Optional< double > getAsNumber() const
Definition: JSON.h:420
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::json::Array::insert
iterator insert(iterator P, const Value &E)
Definition: JSON.h:197
RHS
Value * RHS
Definition: X86PartialReduction.cpp:74
llvm::json::ParseError::log
void log(llvm::raw_ostream &OS) const override
Print an error message to an output stream.
Definition: JSON.h:844
llvm::json::OStream::rawValue
void rawValue(llvm::StringRef Contents)
Definition: JSON.h:963
llvm::AlignedCharArrayUnion
A suitably aligned and sized character array member which can hold elements of any type.
Definition: AlignOf.h:27
llvm::codeview::PointerMode::Pointer
@ Pointer
llvm::json::Array::operator==
friend bool operator==(const Array &L, const Array &R)
Definition: JSON.h:208
llvm::json::Array::push_back
void push_back(const Value &E)
Definition: JSON.h:190
llvm::detail::DenseMapPair< ObjectKey, Value >
llvm::json::ObjectMapper::map
bool map(StringLiteral Prop, llvm::Optional< T > &Out)
Maps a property to a field, if it exists.
Definition: JSON.h:808
llvm::json::Path::report
void report(llvm::StringLiteral Message)
Records that the value at the current path is invalid.
Definition: JSON.cpp:207
llvm::json::Array::const_iterator
std::vector< Value >::const_iterator const_iterator
Definition: JSON.h:162
new
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM ID Predecessors according to mbb< bb27, 0x8b0a7c0 > Note ADDri is not a two address instruction its result reg1037 is an operand of the PHI node in bb76 and its operand reg1039 is the result of the PHI node We should treat it as a two address code and make sure the ADDri is scheduled after any node that reads reg1039 Use info(i.e. register scavenger) to assign it a free register to allow reuse the collector could move the objects and invalidate the derived pointer This is bad enough in the first but safe points can crop up unpredictably **array_addr i32 n y store obj * new
Definition: README.txt:125
llvm::RISCVFenceField::R
@ R
Definition: RISCVBaseInfo.h:207
Context
ManagedStatic< detail::RecordContext > Context
Definition: Record.cpp:96
llvm::json::Array::begin
iterator begin()
Definition: JSON.h:180
llvm::DenseMapBase< DenseMap< ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value > >, ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value > >::const_iterator
DenseMapIterator< ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value >, true > const_iterator
Definition: DenseMap.h:72
llvm::json::operator==
bool operator==(const Object &LHS, const Object &RHS)
Definition: JSON.cpp:83
LHS
Value * LHS
Definition: X86PartialReduction.cpp:73
llvm::formatv
auto formatv(const char *Fmt, Ts &&... Vals) -> formatv_object< decltype(std::make_tuple(detail::build_format_adapter(std::forward< Ts >(Vals))...))>
Definition: FormatVariadic.h:250
llvm::json::ParseError::ParseError
ParseError(const char *Msg, unsigned Line, unsigned Column, unsigned Offset)
Definition: JSON.h:842
llvm::StringLiteral
A wrapper around a string literal that serves as a proxy for constructing global tables of StringRefs...
Definition: StringRef.h:890
llvm::json::Object::begin
const_iterator begin() const
Definition: JSON.h:108
llvm::json::Object::getString
llvm::Optional< llvm::StringRef > getString(StringRef K) const
Definition: JSON.cpp:58
llvm::json::Value::Value
Value(const Value &M)
Definition: JSON.h:303
llvm::json::Array::back
const Value & back() const
Definition: JSON.h:176
llvm::json::Value::Value
Value(std::string V)
Definition: JSON.h:317
llvm::json::Value::Value
Value(const llvm::formatv_object_base &V)
Definition: JSON.h:326
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::json::OStream::object
void object(Block Contents)
Emit an object whose elements are emitted in the provided Block.
Definition: JSON.h:950
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::json::OStream::array
void array(Block Contents)
Emit an array whose elements are emitted in the provided Block.
Definition: JSON.h:944
llvm::json::Path::Root::Root
Root(llvm::StringRef Name="")
Definition: JSON.h:651
llvm::json::Object::KV::V
Value V
Definition: JSON.h:576
llvm::json::Object::getObject
const json::Object * getObject(StringRef K) const
Definition: JSON.cpp:63
llvm::json::Array::end
iterator end()
Definition: JSON.h:182
llvm::AMDGPU::PALMD::Key
Key
PAL metadata keys.
Definition: AMDGPUMetadata.h:481
llvm::json::ObjectMapper::mapOptional
bool mapOptional(StringLiteral Prop, T &Out)
Maps a property to a field, if it exists.
Definition: JSON.h:819
llvm::json::Array::insert
iterator insert(iterator P, Value &&E)
Definition: JSON.h:198
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::json::Value::operator=
Value & operator=(Value &&M)
Definition: JSON.h:381
llvm::json::Value::Number
@ Number
Number values can store both int64s and doubles at full precision, depending on what they were constr...
Definition: JSON.h:296
llvm::json::Value::Array
friend class Array
Definition: JSON.h:479
llvm::json::Array
An Array is a JSON array, which contains heterogeneous JSON values.
Definition: JSON.h:156
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::json::Value::Object
@ Object
Definition: JSON.h:299
llvm::raw_ostream::flush
void flush()
Definition: raw_ostream.h:186
llvm::json::Array::operator[]
const Value & operator[](size_t I) const
Definition: JSON.h:172
llvm::json::Value::Value
Value(json::Array &&Elements)
Definition: JSON.h:306
llvm::json::parse
llvm::Expected< Value > parse(llvm::StringRef JSON)
Parses the provided JSON source, or returns a ParseError.
Definition: JSON.cpp:670
llvm::json::Object::KV
Definition: JSON.h:574
llvm::json::Object::try_emplace
std::pair< iterator, bool > try_emplace(const ObjectKey &K, Ts &&... Args)
Definition: JSON.h:118
FormatVariadic.h
llvm::StringRef::str
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:244
llvm::None
const NoneType None
Definition: None.h:23
llvm::json::OStream::objectEnd
void objectEnd()
Definition: JSON.cpp:855
llvm::json::Array::size
size_t size() const
Definition: JSON.h:186
llvm::json::Value::Value
Value(T D)
Definition: JSON.h:366
llvm::json::Array::data
const Value * data() const
Definition: JSON.h:178
llvm::json::Object::getNumber
llvm::Optional< double > getNumber(StringRef K) const
Definition: JSON.cpp:48
llvm::json::ObjectKey::ObjectKey
ObjectKey(const llvm::formatv_object_base &V)
Definition: JSON.h:539
llvm::json::Value::Value
Value(StringRef V)
Definition: JSON.h:328
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:223
llvm::json::ObjectKey::ObjectKey
ObjectKey(std::string S)
Definition: JSON.h:524
llvm::json::Object::try_emplace
std::pair< iterator, bool > try_emplace(ObjectKey &&K, Ts &&... Args)
Definition: JSON.h:122
llvm::json::Object::find
iterator find(StringRef K)
Definition: JSON.h:128
llvm::json::Value::getAsArray
json::Array * getAsArray()
Definition: JSON.h:468
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:206
llvm::json::Array::insert
iterator insert(iterator P, It A, It Z)
Definition: JSON.h:201
llvm::json::Value::getAsArray
const json::Array * getAsArray() const
Definition: JSON.h:465
llvm::json::OStream::rawValueEnd
void rawValueEnd()
Definition: JSON.cpp:901
llvm::json::fromJSON
bool fromJSON(const Value &E, std::string &Out, Path P)
Definition: JSON.h:672
llvm::json::OStream
json::OStream allows writing well-formed JSON without materializing all structures as json::Value ahe...
Definition: JSON.h:920
llvm::json::Object::get
Value * get(StringRef K)
Definition: JSON.cpp:26
Index
uint32_t Index
Definition: ELFObjHandler.cpp:83
uint64_t
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
const
aarch64 promote const
Definition: AArch64PromoteConstant.cpp:232
llvm::DenseMapBase< DenseMap< ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value > >, ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value > >::value_type
llvm::detail::DenseMapPair< ObjectKey, Value > value_type
Definition: DenseMap.h:68
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::json::OStream::arrayBegin
void arrayBegin()
Definition: JSON.cpp:828
llvm::DenseMap< ObjectKey, Value, llvm::DenseMapInfo< StringRef > >
llvm::json::Object::operator[]
Value & operator[](const ObjectKey &K)
Definition: JSON.cpp:20
llvm::json::ParseError
Definition: JSON.h:836
llvm::json::Value::getAsInteger
llvm::Optional< int64_t > getAsInteger() const
Definition: JSON.h:430
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::json::Path::index
Path index(unsigned Index) const
Derives a path for an array element: this[Index].
Definition: JSON.h:608
llvm::json::operator!=
bool operator!=(const Object &LHS, const Object &RHS)
Definition: JSON.h:150
TemplateParamKind::Type
@ Type
llvm::AMDGPU::HSAMD::ValueType
ValueType
Value types.
Definition: AMDGPUMetadata.h:95
llvm::json::Array::data
Value * data()
Definition: JSON.h:177
llvm::json::Array::back
Value & back()
Definition: JSON.h:175
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1707
llvm::json::ObjectKey::ObjectKey
ObjectKey(llvm::StringRef S)
Definition: JSON.h:531
llvm::json::fixUTF8
std::string fixUTF8(llvm::StringRef S)
Replaces invalid UTF-8 sequences in S with the replacement character (U+FFFD).
Definition: JSON.cpp:695
llvm::json::Object::empty
bool empty() const
Definition: JSON.h:112
llvm::ErrorInfo
Base class for user error types.
Definition: Error.h:349
llvm::json::Array::Array
Array()=default
llvm::size
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
Definition: STLExtras.h:1630
llvm::json::ParseError::convertToErrorCode
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: JSON.h:847
llvm::json::Value::getAsBoolean
llvm::Optional< bool > getAsBoolean() const
Definition: JSON.h:415
llvm::json::Array::iterator
std::vector< Value >::iterator iterator
Definition: JSON.h:161
llvm::json::Array::pop_back
void pop_back()
Definition: JSON.h:195
llvm::json::Value::getAsUINT64
llvm::Optional< uint64_t > getAsUINT64() const
Definition: JSON.h:442
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
llvm::json::Object::size
size_t size() const
Definition: JSON.h:113
llvm::json::ObjectKey::ObjectKey
ObjectKey(const ObjectKey &C)
Definition: JSON.h:541
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::json::Object::getInteger
llvm::Optional< int64_t > getInteger(StringRef K) const
Definition: JSON.cpp:53
llvm::json::Object::end
iterator end()
Definition: JSON.h:109
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:134
llvm::json::Path::field
Path field(StringRef Field) const
Derives a path for an object field: this.Field.
Definition: JSON.h:610
llvm::json::Value::Value
Value(const llvm::SmallVectorImpl< char > &V)
Definition: JSON.h:324
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::json::Array::reserve
void reserve(size_t S)
Definition: JSON.h:187
llvm::json::Object::clear
void clear()
Definition: JSON.h:115
llvm::json::toJSON
Value toJSON(const llvm::Optional< T > &Opt)
Definition: JSON.h:768
llvm::json::ObjectKey::operator=
ObjectKey & operator=(const ObjectKey &C)
Definition: JSON.h:543
llvm::json::Object::end
const_iterator end() const
Definition: JSON.h:110
llvm::format
format_object< Ts... > format(const char *Fmt, const Ts &... Vals)
These are helper functions used to produce formatted output.
Definition: Format.h:124
llvm::json::ParseError::ID
static char ID
Definition: JSON.h:841
llvm::json::Value::~Value
~Value()
Definition: JSON.h:386
llvm::PointerUnion< const Value *, const PseudoSourceValue * >
llvm::json::Path::Root::getError
Error getError() const
Returns the last error reported, or else a generic error.
Definition: JSON.cpp:222
llvm::json::Value::Value
Value(T B)
Definition: JSON.h:342
std
Definition: BitVector.h:838
llvm::inconvertibleErrorCode
std::error_code inconvertibleErrorCode()
The value returned by this function can be returned from convertToErrorCode for Error values where no...
Definition: Error.cpp:77
llvm::json::Value::getAsObject
const json::Object * getAsObject() const
Definition: JSON.h:459
llvm::json::Value::Value
Value(const std::map< std::string, Elt > &C)
Definition: JSON.h:315
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
llvm::json::ObjectKey::str
std::string str() const
Definition: JSON.h:555
llvm::TargetStackID::Value
Value
Definition: TargetFrameLowering.h:27
llvm::json::OStream::value
void value(const Value &V)
Emit a self-contained value (number, string, vector<string> etc).
Definition: JSON.cpp:742
llvm::json::Object::getArray
const json::Array * getArray(StringRef K) const
Definition: JSON.cpp:73
llvm::HasValue
detail::ValueMatchesPoly< M > HasValue(M Matcher)
Definition: Error.h:221
llvm::json::operator<<
llvm::raw_ostream & operator<<(llvm::raw_ostream &OS, const Value &V)
Serializes this Value to JSON, writing it to the provided stream.
Definition: JSON.h:1030
llvm::json::Value::String
@ String
Definition: JSON.h:297
llvm::json::Path::Path
Path(Root &R)
The root may be treated as a Path.
Definition: JSON.h:606
llvm::json::ObjectKey::ObjectKey
ObjectKey(const llvm::SmallVectorImpl< char > &V)
Definition: JSON.h:537
llvm::DenseMapBase< DenseMap< ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value > >, ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value > >::iterator
DenseMapIterator< ObjectKey, Value, llvm::DenseMapInfo< StringRef >, llvm::detail::DenseMapPair< ObjectKey, Value > > iterator
Definition: DenseMap.h:70
SmallVector.h
llvm::json::Value::Array
@ Array
Definition: JSON.h:298
llvm::json::Value::Value
Value(Value &&M)
Definition: JSON.h:304
llvm::json::Value::Value
Value(const std::vector< Elt > &C)
Definition: JSON.h:310
N
#define N
P
#define P(N)
llvm::json::OStream::arrayEnd
void arrayEnd()
Definition: JSON.cpp:836
llvm::json::Value::getAsObject
json::Object * getAsObject()
Definition: JSON.h:462
llvm::max
Align max(MaybeAlign Lhs, Align Rhs)
Definition: Alignment.h:340
llvm::json::Array::end
const_iterator end() const
Definition: JSON.h:183
llvm::json::Array::front
const Value & front() const
Definition: JSON.h:174
LLVM_LIKELY
#define LLVM_LIKELY(EXPR)
Definition: Compiler.h:229
llvm::json::Array::Array
Array(const Collection &C)
Definition: JSON.h:166
llvm::SmallVectorImpl< char >
llvm::json::Value::Value
Value(json::Object &&Properties)
Definition: JSON.h:311
llvm::json::OStream::attributeObject
void attributeObject(llvm::StringRef Key, Block Contents)
Emit an attribute whose value is an object with attributes from the Block.
Definition: JSON.h:983
llvm::json::Value::Kind
Kind
Definition: JSON.h:291
llvm::json::Value::Value
Value(const T &V)
Definition: JSON.h:374
llvm::formatv_object_base
Definition: FormatVariadic.h:65
llvm::json::isUTF8
bool isUTF8(llvm::StringRef S, size_t *ErrOffset=nullptr)
Returns true if S is valid UTF-8, which is required for use as JSON.
Definition: JSON.cpp:681
llvm::OptimizedStructLayoutField
A field in a structure.
Definition: OptimizedStructLayout.h:45
llvm::json::ObjectKey
ObjectKey is a used to capture keys in Object.
Definition: JSON.h:521
llvm::json::ObjectKey::ObjectKey
ObjectKey(ObjectKey &&C)
Definition: JSON.h:542
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::json::OStream::attribute
void attribute(llvm::StringRef Key, const Value &Contents)
Emit an attribute whose value is self-contained (number, vector<int> etc).
Definition: JSON.h:975
LLVM_UNLIKELY
#define LLVM_UNLIKELY(EXPR)
Definition: Compiler.h:230
raw_ostream.h
llvm::json::Object
An Object is a JSON object, which maps strings to heterogenous JSON values.
Definition: JSON.h:90
llvm::json::Value::getAsString
llvm::Optional< llvm::StringRef > getAsString() const
Definition: JSON.h:452
llvm::json::Object::insert
std::pair< iterator, bool > insert(KV E)
Definition: JSON.h:586
llvm::json::Object::KV::K
ObjectKey K
Definition: JSON.h:575
llvm::json::OStream::rawValueBegin
raw_ostream & rawValueBegin()
Definition: JSON.cpp:894
llvm::json::Object::getBoolean
llvm::Optional< bool > getBoolean(StringRef K) const
Definition: JSON.cpp:43
llvm::json::Array::push_back
void push_back(Value &&E)
Definition: JSON.h:191
llvm::json::Array::clear
void clear()
Definition: JSON.h:189
llvm::json::OStream::objectBegin
void objectBegin()
Definition: JSON.cpp:847
llvm::json::Path
A "cursor" marking a position within a Value.
Definition: JSON.h:596
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::json::OStream::OStream
OStream(llvm::raw_ostream &OS, unsigned IndentSize=0)
Definition: JSON.h:924
llvm::json::OStream::flush
void flush()
Flushes the underlying ostream. OStream does not buffer internally.
Definition: JSON.h:935
llvm::json::Array::front
Value & front()
Definition: JSON.h:173
SpecialSubKind::string
@ string
llvm::json::Path::Root::operator=
Root & operator=(Root &&)=delete
llvm::json::ObjectMapper
Helper for mapping JSON objects onto protocol structs.
Definition: JSON.h:783
llvm::json::Object::begin
iterator begin()
Definition: JSON.h:107
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:917
llvm::json::Array::begin
const_iterator begin() const
Definition: JSON.h:181
llvm::json::OStream::rawValue
void rawValue(llvm::function_ref< void(raw_ostream &)> Contents)
Emit an externally-serialized value.
Definition: JSON.h:958
llvm::json::operator<
bool operator<(const ObjectKey &L, const ObjectKey &R)
Definition: JSON.h:570
llvm::json::Object::getNull
llvm::Optional< std::nullptr_t > getNull(StringRef K) const
Definition: JSON.cpp:38
llvm::json::Value::operator=
Value & operator=(const Value &M)
Definition: JSON.h:376