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