[TableGen] Add a general-purpose JSON backend.

[simon_tatham]

Summary

The aim of this backend is to output everything TableGen knows about
the record set, similarly to the default -print-records backend. But
where -print-records produces output in TableGen's input syntax
(convenient for humans to read), this backend produces it as
structured JSON data, which is convenient for loading into standard
scripting languages such as Python, in order to extract information
from the data set in an automated way.

The output data contains a JSON representation of the variable
definitions in output 'def' records, and a few pieces of metadata such
as which of those definitions are tagged with the 'field' prefix and
which defs are derived from which classes. It doesn't dump out
absolutely every piece of knowledge it _could_ produce, such as type
information and complicated arithmetic operator nodes in abstract
superclasses; the main aim is to allow consumers of this JSON dump to
essentially act as new backends, and backends don't generally need to
depend on that kind of data.

The new backend is implemented as an EmitJSON() function similar to
all of llvm-tblgen's other EmitFoo functions, except that it lives in
lib/TableGen instead of utils/TableGen on the basis that I'm expecting
to add it to clang-tblgen too in a future patch.

To test it, I've written a Python script that loads the JSON output
and tests properties of it based on comments in the .td source - more
or less like FileCheck, except that the CHECK: lines have Python
expressions after them instead of textual pattern matches.

[labath]

utils/TableGen/JSONEmitter.cpp

1

You should take a look at <D45753>, which is about to add a JSON library to llvm. It would be a shame to add two of them in the same week. :)

[simon_tatham]

utils/TableGen/JSONEmitter.cpp

1

Ha! You're right, I hadn't noticed that. I'll replace my ad-hockery with calls to that code with great pleasure as soon as it lands – even without looking I'm sure it will be better than the 'only just enough' code I have here. Thanks for pointing it out!

[simon_tatham]

@nhaehnle : while this change is blocked on that one, do you have any opinions on my design questions? Particularly the one about whether I ought to move most of the code into some sort of getAsJSONObject method in the various classes in Record.h / Record.cpp, because if I'm going to do that then I should do it before making any other detailed changes :-)

[nhaehnle]

Consider what to do about integer values that don't fit exactly into a 'double'. This code will simply emit them as decimal integer literals, which JSON parsers are within their rights to round to the nearest double precision float, losing data. Some JSON readers (e.g. Python json.load) will deliver accurate integer values anyway, but it might be better not to rely on that, and instead output very large integers in some other form, such as a JSON object containing an identifying type field and two doubles whose sum is the desired integer, or a string representation of the integer, or both.

Well. The one thing I do have a strong opinion on is that the representation of very large integers should not be different from the representation of small integers, because consumers would almost certainly get that wrong. So that leaves two options: string representations, or sending JavaScript to the hell it deserves and going with integers.

Consider adding the new -dump-json option to clang-tblgen as well as llvm-tblgen. (As I understand it they wouldn't do anything differently, but it seems asymmetric not to have both of them support it. They both have -print-records, after all.)

Sure, that seems like a good idea.

Consider providing a cut-down version, enabled by another option such as '-dump-simple-json', in which all the complicated parametric expression nodes like !add and !foreach and !foldl are simply not emitted, and replaced by some kind of small object indicating that a complex expression was elided. The motivation is that I expect a lot of uses for this system would only be interested in the output fields that consist of final well-defined values of primitive type, so constructing the complicated parts is a waste of both TableGen's time and the consumer's. But I'm not sure where the line should be drawn - DAG arguments might well still need to be output in full, for example, and type information might be omittable. There may be no one good answer.

I believe there is a good answer :)

Take a look at TGParser.cpp, checkConcrete. All valid final and needed records should pass that check. There are unfortunately still some exceptions, although it'd be nice if we could get rid of those actually.

So I would argue that you should only bother emitting what fits this definition of "concrete", i.e. don't have a "complex" JSON option at all. If you do encounter something that doesn't fit the definition of concrete, just output a JSON object { "kind": "complex", "code": <getAsString()> } in its place.

On a related note, I'm not convinced you really want to print out class definitions. The benefit of printing class definitions with -print-records is that it can help you understand what's going on while you're writing class definitions, but the existing TableGen backends really don't care about class definitions. Since the idea here is to basically allow writing TableGen backends in a scripting language like Python, providing the class definitions is unlikely to be useful. It doesn't hurt, but I don't think it's a good motivation for building all this infrastructure for printing ! operations, for example.

Decide where all this code should live. It might be better to move a lot of it into Record.cpp in the form of getAsJSONObject() methods or something like that. That would remove the risk of forgetting to update the JSON back end if a new node type is introduced - anyone forgetting to implement that method in any new subclass of Init or RecTy would be reminded by a compile error.

I'd rather keep it separate for orthogonality. Adding a new fundamental concrete data type is a rare enough occurence, and the worst that would happen with my suggestion above is that you get an unexpected "complex" object, which is not too difficult to track down.

[simon_tatham]

Well. The one thing I do have a strong opinion on is that the representation of very large integers should not be different from the representation of small integers, because consumers would almost certainly get that wrong.

A good point – now you put it that way, I suddenly agree strongly!

So that leaves two options: string representations, or sending JavaScript to the hell it deserves and going with integers.

Well, since my personal use cases all involve Python, and Python copes fine with arbitrary integers, I'm happy with the latter if you are :-) And I'd definitely prefer not to have to put a decode-from-string operation in every single consumer of this JSON output.

I suppose a cl::opt<bool> to switch to a more cumbersome representation of integers could always be added later, if anyone turns out to really need one.

Take a look at TGParser.cpp, checkConcrete. All valid final and needed records should pass that check. There are unfortunately still some exceptions, although it'd be nice if we could get rid of those actually.

Ah! Yes, that seems nice. And if I'm not dumping the class definitions, then perhaps it's not worth dumping the details of all the types either, for the same reason (a 'back end' consuming this format will already know what type to expect from any field it cares about), in which case I can simplify the output representation a great deal by removing the extra level of dereference where you have to suffix ['value'] all the time.

I agree that none of my own use cases will care about any of the things that this redesign throws away – and it makes the output JSON a great deal smaller and simpler. Thanks for the suggestions!

[simon_tatham]

OK, here's my second draft. Changes since last time:

• thrown out the ad-hoc JSON emitter in favour of the new JSON library in D45753 (also requires the integer-handling followup patch D46209)
• moved the new source file into lib/TableGen where clang-tblgen will be able to get at it more easily (but I haven't actually added it to clang-tblgen yet)
• removed all the type and abstract class information, leaving only the concrete records and a couple of pieces of metadata that I know backends do actually want (list of field keywords, list of superclasses, list of instances of each class). Exotic subclasses of Init are now rendered as kind="complex" with only a printable representation.
• flattened the JSON structure by several layers to make it more convenient to consume
• added documentation of the format.

I think from my perspective this is no longer an unfinished draft; I'd be happy to commit it in this state, subject to code review approval and its dependencies landing.

[nhaehnle]

Thanks, this already looks very good. I do have some suggestions though.

docs/TableGen/BackEnds.rst

516–518 ↗

(On Diff #144564)

This is a minor point, but I suspect it would be slightly more convenient for consumers if this were instead represented as [[arg, name], [arg, name], ...]. So the example below would have args be [[22, null], ["hello", "foo"]]. What do you think?

lib/TableGen/JSONBackend.cpp

46–49 ↗

(On Diff #144564)

C-style comments are rather uncommon in LLVM; best to be consistent and use C++-style comments here (and below).

93 ↗

(On Diff #144564)

I think this should be "var" instead of "variable", for consistency.

172–179 ↗

(On Diff #144564)

I think it would be slightly nicer to merge this into the loop above, to avoid iterating over the same data twice.

test/TableGen/JSON-check.py

50

Cool, I didn't know this was possible.

[simon_tatham]

docs/TableGen/BackEnds.rst

516–518 ↗

(On Diff #144564)

That's actually more like how I had it in the first version of the patch, and I had second thoughts and changed it to this :-) so I'm already on the fence and could easily be persuaded to change it back again.

My thought was that some use cases wouldn't care about the name at all (e.g. an entire backend might use dag-typed data for some purpose that never gives a name to any argument), and those users would find it more convenient if they could get the actual arguments by just saying node['args'][n] instead of having to say node['args'][n][0] (in your version) or node['args'][n]['value'] (as I originally had it). So I moved the names out into a separate array that you'd only have to look at if you cared about names at all.

On the other hand, I can certainly see the counterargument – if you do care about names, it's nicer to have a single array to iterate over. I'm happy to change it to your style.

lib/TableGen/JSONBackend.cpp

93 ↗

(On Diff #144564)

Another thing I was trying to do (but forgot to actually mention anywhere) was to arrange for all the field names that depend on "kind" not to be the same as each other, as a means of error detection – it would stop a user accidentally mistaking a var for a varbit, by absentmindedly retrieving node['var'] and forgetting there was another field to look at too. But that's quite a marginal consideration in the first place, and also I admit this particular choice of two different names was terrible :-) so yes, I'm happy to change over to being consistent.

test/TableGen/JSON-check.py

50

You mean passing a string to sys.exit? That was new to me as well quite recently. It's one of those functions where as a C programmer I automatically assumed I already knew how its API would work, so it took me years to find a reason to read its docs!

[simon_tatham]

Updated with all those review comments.

[nhaehnle]

Great, LGTM!

docs/TableGen/BackEnds.rst

516–518 ↗

(On Diff #144564)

Yeah, I admit it was really a minor thing. Thanks for changing it though!

[simon_tatham]

Thanks for the review!

Of course, having got to this point, I can't actually commit it until D45753 is ready. And I'm about to be on holiday for several weeks, so if that happens soon then I probably won't notice for a while. But I won't actually forget about this patch, I promise :-)

[simon_tatham]

@nhaehnle, following up discussion about NAME in D47430 (and hopefully posted in the right place this time):

I was going to change this patch so that it uses !name instead of NAME for the key inside each JSON def object that gives the def's own name. (Mostly the reason I think it's useful to have such a key at all is so that client code that's consuming the JSON can pass those dictionaries to its own subfunctions without having to pass the name alongside it, so it makes sense to me to use a key that indicates that it's a JSON-specific convenience.)

But it's just struck me that there might also be a use case for knowing whether the record is anonymous or not, in the sense of whether its name is something that was deliberately specified in the TableGen input or whether it was some anonymous_123 value made up by tblgen itself.

I was thinking of adding a boolean field !anonymous, or alternatively perhaps having !key and !name (where !key is always the key under which this record is stored in the JSON root object, and !name is either the same as !key or null). Any particular preference, before I make the changes? Or is the entire idea not worth bothering with?

(Also, I noticed in passing that the IsAnonymous field isn't set reliably: the records defined by an anonymous defm have it false rather than true. That looks easy to fix, and I could fold that into this change or make it a separate one.)

[nhaehnle]

There are arguments both for !key + !name and for !name + !anonymous, although thinking about it for a minute or two I weakly prefer !name + !anonymous because it matches the representation in C++. It makes it easier for people to move between JSON and C++.

P.S.: No worries about the confusion with the other review :)

[nhaehnle]

And by the way, I do agree with your rationale for why !name is very useful to have in JSON. The C++ backends can (and do) use Record::getName() for the same functionality.

[simon_tatham]

Renamed the NAME attribute to !name in line with D47430.

Added the !anonymous attribute, a set of tests for it, and a fix in TGParser.cpp to set it correctly for anonymous defms.

[simon_tatham]

OK, !name + !anonymous it is. (That was how I'd drafted it too, so I think we had the same mild preference.)

I'm afraid this patch now has a very tiny conflict with D47430, in that we've both added braces to the same if statement in TGParser::ParseDefm.

[simon_tatham]

Rebase to current trunk, and revert change to 'anonymous' handling.

In line with the discussion in D47431, I've removed my previous tweak
in TGParser.cpp that sets the !anonymous flag if any part of a def's
final name was derived from an anonymous def or defm. Now the
!anonymous field in the JSON output is consistent with the existing
behavior of the isAnonymous() query function.

[simon_tatham]

@nhaehnle , are you still happy for me to commit this, now that its dependencies have landed and I've tweaked its handing of !anonymous?

[simon_tatham]

Nearly forgot to mention the new option in the tblgen man page!

[simon_tatham]

Actually, on second thoughts, I'm going to assume it was overcautious to ask for a re-approval, since this version of the patch introduces no new controversy and in fact removes the only previous tweak in the Tablegen core (in that I'm not trying to change the semantics of anonymous any more). So I'll commit this as is, based on the previous review approval.

[stella.stamenova]

The test json.td fails on Windows when there's a space in the path to python. python should be specified in the test file as '%python' or "%python" rather than just '%python. I can submit a fix for review if you're not able. Thanks!

[simon_tatham]

Oops, sorry about that :-(

(I admit I didn't consider the possibility of spacey filenames at all, but now I have, it's a mild surprise to me that %python doesn't expand to an already correctly-quoted string.)

The fix sounds easy, but if you have a setup where you can actually check it works, there might be less chance of a typo if you do it rather than me...

include/llvm/TableGen/Record.h

public:
   static bool classof(const Init *I) {
     return I->getKind() >= IK_FirstOpInit &&
            I->getKind() <= IK_LastOpInit;
   }
 
   // Clone - Clone this operator, replacing arguments with the new list
   virtual OpInit *clone(ArrayRef<Init *> Operands) const = 0;
 
+  virtual std::string getOperatorName() const = 0;
   virtual unsigned getNumOperands() const = 0;
   virtual Init *getOperand(unsigned i) const = 0;
 
   Init *getBit(unsigned Bit) const override;
 };
 
 /// !op (X) - Transform an init.
 ///
public:
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
   Init *Fold(Record *CurRec, bool IsFinal = false) const;
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
+  std::string getOperatorName() const override;
 };
 
 /// !op (X, Y) - Combine two inits.
 class BinOpInit : public OpInit, public FoldingSetNode {
 public:
   enum BinaryOp : uint8_t { ADD, AND, OR, SHL, SRA, SRL, LISTCONCAT,
                             STRCONCAT, CONCAT, EQ, NE, LE, LT, GE, GT };
 
public:
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
   Init *Fold(Record *CurRec) const;
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
+  std::string getOperatorName() const override;
 };
 
 /// !op (X, Y, Z) - Combine two inits.
 class TernOpInit : public OpInit, public FoldingSetNode {
 public:
   enum TernaryOp : uint8_t { SUBST, FOREACH, IF, DAG };
 
 private:
public:
 
   bool isComplete() const override {
     return LHS->isComplete() && MHS->isComplete() && RHS->isComplete();
   }
 
   Init *resolveReferences(Resolver &R) const override;
 
   std::string getAsString() const override;
+  std::string getOperatorName() const override;
 };
 
 /// !foldl (a, b, expr, start, lst) - Fold over a list.
 class FoldOpInit : public TypedInit, public FoldingSetNode {
 private:
   Init *Start;
   Init *List;
   Init *A;
public:
   void Profile(FoldingSetNodeID &ID) const;
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
   Init *Fold(Record *CurRec) const;
 
   bool isComplete() const override { return false; }
 
+  Init *getStart() const { return Start; }
+  Init *getList() const { return List; }
+  Init *getA() const { return A; }
+  Init *getB() const { return B; }
+  Init *getExpr() const { return Expr; }
+
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override;
 
   std::string getAsString() const override;
 };
 
 /// !isa<type>(expr) - Dynamically determine the type of an expression.
public:
   static IsAOpInit *get(RecTy *CheckType, Init *Expr);
 
   void Profile(FoldingSetNodeID &ID) const;
 
   // Fold - If possible, fold this to a simpler init.  Return this if not
   // possible to fold.
   Init *Fold() const;
 
+  RecTy *getCheckType() const { return CheckType; }
+  Init *getExpr() const { return Expr; }
+
   bool isComplete() const override { return false; }
 
   Init *resolveReferences(Resolver &R) const override;
 
   Init *getBit(unsigned Bit) const override;
 
   std::string getAsString() const override;
 };
public:
 
   void Profile(FoldingSetNodeID &ID) const;
 
   Init *resolveReferences(Resolver &R) const override;
   Init *Fold() const;
 
   std::string getAsString() const override;
 
+  Record *getClass() const { return Class; }
+
   Init *getArg(unsigned i) const {
     assert(i < NumArgs && "Argument index out of range!");
     return getTrailingObjects<Init *>()[i];
   }
 
   using const_iterator = Init *const *;
 
   const_iterator args_begin() const { return getTrailingObjects<Init *>(); }

lib/TableGen/Record.cpp

Init *UnOpInit::resolveReferences(Resolver &R) const {
 
   if (LHS != lhs || (R.isFinal() && getOpcode() == CAST))
     return (UnOpInit::get(getOpcode(), lhs, getType()))
         ->Fold(R.getCurrentRecord(), R.isFinal());
   return const_cast<UnOpInit *>(this);
 }
 
 std::string UnOpInit::getAsString() const {
-  std::string Result;
+  std::string OpSuffix;
   switch (getOpcode()) {
-  case CAST: Result = "!cast<" + getType()->getAsString() + ">"; break;
-  case HEAD: Result = "!head"; break;
-  case TAIL: Result = "!tail"; break;
-  case SIZE: Result = "!size"; break;
-  case EMPTY: Result = "!empty"; break;
+  case CAST: OpSuffix += "<" + getType()->getAsString() + ">"; break;
+  default: break;
+  }
+  return getOperatorName() + OpSuffix + "(" + LHS->getAsString() + ")";
+}
+
+std::string UnOpInit::getOperatorName() const {
+  switch (getOpcode()) {
+  case CAST: return "!cast";
+  case HEAD: return "!head";
+  case TAIL: return "!tail";
+  case SIZE: return "!size";
+  case EMPTY: return "!empty";
+  default: llvm_unreachable("bad unop opcode");
   }
-  return Result + "(" + LHS->getAsString() + ")";
 }
 
 static void
 ProfileBinOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *RHS,
                  RecTy *Type) {
   ID.AddInteger(Opcode);
   ID.AddPointer(LHS);
   ID.AddPointer(RHS);
Init *BinOpInit::resolveReferences(Resolver &R) const {
 
   if (LHS != lhs || RHS != rhs)
     return (BinOpInit::get(getOpcode(), lhs, rhs, getType()))
         ->Fold(R.getCurrentRecord());
   return const_cast<BinOpInit *>(this);
 }
 
 std::string BinOpInit::getAsString() const {
-  std::string Result;
+  return getOperatorName() + "(" + LHS->getAsString() + ", " +
+         RHS->getAsString() + ")";
+}
+
+std::string BinOpInit::getOperatorName() const {
   switch (getOpcode()) {
-  case CONCAT: Result = "!con"; break;
-  case ADD: Result = "!add"; break;
-  case AND: Result = "!and"; break;
-  case OR: Result = "!or"; break;
-  case SHL: Result = "!shl"; break;
-  case SRA: Result = "!sra"; break;
-  case SRL: Result = "!srl"; break;
-  case EQ: Result = "!eq"; break;
-  case NE: Result = "!ne"; break;
-  case LE: Result = "!le"; break;
-  case LT: Result = "!lt"; break;
-  case GE: Result = "!ge"; break;
-  case GT: Result = "!gt"; break;
-  case LISTCONCAT: Result = "!listconcat"; break;
-  case STRCONCAT: Result = "!strconcat"; break;
+  case CONCAT: return "!con";
+  case ADD: return "!add";
+  case AND: return "!and";
+  case OR: return "!or";
+  case SHL: return "!shl";
+  case SRA: return "!sra";
+  case SRL: return "!srl";
+  case EQ: return "!eq";
+  case NE: return "!ne";
+  case LE: return "!le";
+  case LT: return "!lt";
+  case GE: return "!ge";
+  case GT: return "!gt";
+  case LISTCONCAT: return "!listconcat";
+  case STRCONCAT: return "!strconcat";
+  default: llvm_unreachable("bad binop opcode");
   }
-  return Result + "(" + LHS->getAsString() + ", " + RHS->getAsString() + ")";
 }
 
 static void
 ProfileTernOpInit(FoldingSetNodeID &ID, unsigned Opcode, Init *LHS, Init *MHS,
                   Init *RHS, RecTy *Type) {
   ID.AddInteger(Opcode);
   ID.AddPointer(LHS);
   ID.AddPointer(MHS);
Init *TernOpInit::resolveReferences(Resolver &R) const {
 
   if (LHS != lhs || MHS != mhs || RHS != rhs)
     return (TernOpInit::get(getOpcode(), lhs, mhs, rhs, getType()))
         ->Fold(R.getCurrentRecord());
   return const_cast<TernOpInit *>(this);
 }
 
 std::string TernOpInit::getAsString() const {
-  std::string Result;
+  return getOperatorName() + "(" + LHS->getAsString() + ", " +
+         MHS->getAsString() + ", " + RHS->getAsString() + ")";
+}
+
+std::string TernOpInit::getOperatorName() const {
   switch (getOpcode()) {
-  case SUBST: Result = "!subst"; break;
-  case FOREACH: Result = "!foreach"; break;
-  case IF: Result = "!if"; break;
-  case DAG: Result = "!dag"; break;
+  case SUBST: return "!subst";
+  case FOREACH: return "!foreach";
+  case IF: return "!if";
+  case DAG: return "!dag";
+  default: llvm_unreachable("bad ternop opcode");
   }
-  return Result + "(" + LHS->getAsString() + ", " + MHS->getAsString() + ", " +
-         RHS->getAsString() + ")";
 }
 
 static void ProfileFoldOpInit(FoldingSetNodeID &ID, Init *A, Init *B,
                               Init *Start, Init *List, Init *Expr,
                               RecTy *Type) {
   ID.AddPointer(Start);
   ID.AddPointer(List);
   ID.AddPointer(A);

test/TableGen/JSON-check.py

+#!/usr/bin/env python
+
+import sys
+import subprocess
+import traceback
+import json
+
+data = json.load(sys.stdin)
+testfile = sys.argv[1]
+
+prefix = "CHECK: "
+
+fails = 0
+passes = 0
+with open(testfile) as testfh:
+    lineno = 0
+    for line in iter(testfh.readline, ""):
+        lineno += 1
+        line = line.rstrip("\r\n")
+        try:
+            prefix_pos = line.index(prefix)
+        except ValueError:
+            continue
+        check_expr = line[prefix_pos + len(prefix):]
+
+        try:
+            exception = None
+            result = eval(check_expr, {"data":data})
+        except Exception:
+            result = False
+            exception = traceback.format_exc().splitlines()[-1]
+
+        if exception is not None:
+            sys.stderr.write(
+                "{file}:{line:d}: check threw exception: {expr}\n"
+                "{file}:{line:d}: exception was: {exception}\n".format(
+                    file=testfile, line=lineno,
+                    expr=check_expr, exception=exception))
+            fails += 1
+        elif not result:
+            sys.stderr.write(
+                "{file}:{line:d}: check returned False: {expr}\n".format(
+                    file=testfile, line=lineno, expr=check_expr))
+            fails += 1
+        else:
+            passes += 1
+
+if fails != 0:
+    sys.exit("{} checks failed".format(fails))
+else:
+    sys.stdout.write("{} checks passed\n".format(passes))

test/TableGen/JSON.td

+// RUN: llvm-tblgen -dump-json %s | %python %S/JSON-check.py %s
+
+class Base {}
+class Intermediate : Base {}
+class Derived : Intermediate {}
+
+// CHECK: 'Base' in data['classes']['Intermediate']['superclasses']
+// CHECK: 'Intermediate' in data['classes']['Base']['subclasses']
+
+// CHECK: 'Intermediate' in data['classes']['Derived']['superclasses']
+// CHECK: 'Derived' in data['classes']['Intermediate']['subclasses']
+
+// CHECK: 'Derived' in data['classes']['Base']['subclasses']
+// CHECK: 'Base' in data['classes']['Derived']['superclasses']
+
+def D : Intermediate {}
+// CHECK: 'D' in data['classes']['Base']['instances']
+// CHECK: 'D' in data['classes']['Intermediate']['instances']
+// CHECK: 'D' not in data['classes']['Derived']['instances']
+
+class Foo {}
+
+class Templated<int i> {}
+
+def Op;
+
+class Variables {
+    int i;
+    // CHECK: data['classes']['Variables']['values']['i']['type']['kind'] == 'int'
+    // CHECK: data['classes']['Variables']['values']['i']['type']['printable'] == 'int'
+
+    string s;
+    // CHECK: data['classes']['Variables']['values']['s']['type']['kind'] == 'string'
+    // CHECK: data['classes']['Variables']['values']['s']['type']['printable'] == 'string'
+
+    bit b;
+    // CHECK: data['classes']['Variables']['values']['b']['type']['kind'] == 'bit'
+    // CHECK: data['classes']['Variables']['values']['b']['type']['printable'] == 'bit'
+
+    bits<8> bs;
+    // CHECK: data['classes']['Variables']['values']['bs']['type']['kind'] == 'bits'
+    // CHECK: data['classes']['Variables']['values']['bs']['type']['size'] == 8
+    // CHECK: data['classes']['Variables']['values']['bs']['type']['printable'] == 'bits<8>'
+
+    code c;
+    // CHECK: data['classes']['Variables']['values']['c']['type']['kind'] == 'code'
+    // CHECK: data['classes']['Variables']['values']['c']['type']['printable'] == 'code'
+
+    list<int> li;
+    // CHECK: data['classes']['Variables']['values']['li']['type']['kind'] == 'list'
+    // CHECK: data['classes']['Variables']['values']['li']['type']['element']['kind'] == 'int'
+    // CHECK: data['classes']['Variables']['values']['li']['type']['printable'] == 'list<int>'
+
+    Base base;
+    // CHECK: data['classes']['Variables']['values']['base']['type']['kind'] == 'record'
+    // CHECK: data['classes']['Variables']['values']['base']['type']['classes'] == ['Base']
+    // CHECK: data['classes']['Variables']['values']['base']['type']['printable'] == 'Base'
+
+    dag d;
+    // CHECK: data['classes']['Variables']['values']['d']['type']['kind'] == 'dag'
+    // CHECK: data['classes']['Variables']['values']['d']['type']['printable'] == 'dag'
+}
+def VarNull : Variables {
+    // A variable not filled in at all has its value set to JSON
+    // 'null', which translates to Python None
+    // CHECK: data['defs']['VarNull']['values']['i']['value'] is None
+    // CHECK: data['defs']['VarNull']['values']['i']['printable'] == '?'
+
+    // But it still comes with its type information from whatever
+    // class it inherits the variable, so you can check what _kind_ of
+    // value you haven't got.
+    // CHECK: data['defs']['VarNull']['values']['i']['type']['kind'] == 'int'
+}
+def VarPrim : Variables {
+    // Test initializers that map to primitive JSON types
+
+    int i = 3;
+    // CHECK: data['defs']['VarPrim']['values']['i']['value'] == 3
+    // CHECK: data['defs']['VarPrim']['values']['i']['printable'] == '3'
+
+    string s = "hello, world";
+    // CHECK: data['defs']['VarPrim']['values']['s']['value'] == 'hello, world'
+    // CHECK: data['defs']['VarPrim']['values']['s']['printable'] == '"hello, world"'
+
+    bit b = 0;
+    // CHECK: data['defs']['VarPrim']['values']['b']['value'] == 0
+    // CHECK: data['defs']['VarPrim']['values']['b']['printable'] == "0"
+
+    bits<8> bs = { 0,0,0,1,0,1,1,1 };
+    // CHECK: data['defs']['VarPrim']['values']['bs']['value'] == [ 0,0,0,1,0,1,1,1 ]
+    // CHECK: data['defs']['VarPrim']['values']['bs']['printable'] == '{ 0, 0, 0, 1, 0, 1, 1, 1 }'
+
+    code c = [{ \"  }];
+    // CHECK: data['defs']['VarPrim']['values']['c']['value'] == r' \"  '
+    // CHECK: data['defs']['VarPrim']['values']['c']['printable'] == r'[{ \"  }]'
+
+    list<int> li = [ 1, 2, 3, 4 ];
+    // CHECK: data['defs']['VarPrim']['values']['li']['value'] == [ 1, 2, 3, 4 ]
+    // CHECK: data['defs']['VarPrim']['values']['li']['printable'] == '[1, 2, 3, 4]'
+}
+def VarObj : Variables {
+    // Test initializers that map to JSON objects containing a 'kind'
+    // discriminator
+
+    Base base = D;
+    // CHECK: data['defs']['VarObj']['values']['base']['value']['kind'] == 'def'
+    // CHECK: data['defs']['VarObj']['values']['base']['value']['name'] == 'D'
+    // CHECK: data['defs']['VarObj']['values']['base']['printable'] == 'D'
+
+    dag d = (Op 22, 44:$foo);
+    // CHECK: data['defs']['VarObj']['values']['d']['value']['kind'] == 'dag'
+    // CHECK: data['defs']['VarObj']['values']['d']['value']['operator']['kind'] == 'def'
+    // CHECK: data['defs']['VarObj']['values']['d']['value']['operator']['name'] == 'Op'
+    // CHECK: data['defs']['VarObj']['values']['d']['value']['args'][0]['arg'] == 22
+    // CHECK: data['defs']['VarObj']['values']['d']['value']['args'][0]['name'] == None
+    // CHECK: data['defs']['VarObj']['values']['d']['value']['args'][1]['arg'] == 44
+    // CHECK: data['defs']['VarObj']['values']['d']['value']['args'][1]['name'] == 'foo'
+    // CHECK: data['defs']['VarObj']['values']['d']['printable'] == '(Op 22, 44:$foo)'
+}
+class VarObjC {
+    int i1;
+    int i2 = i1;
+    // CHECK: data['classes']['VarObjC']['values']['i2']['value']['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['i2']['value']['var'] == 'i1'
+    // CHECK: data['classes']['VarObjC']['values']['i2']['printable'] == 'i1'
+
+    bits<8> bs;
+    dag d = (Op bs{7-3});
+    // CHECK: all(arg['kind'] == 'bitindex' for arg in data['classes']['VarObjC']['values']['d']['value']['args'][0]['arg'])
+    // CHECK: all(arg['operand']['kind'] == 'var' for arg in data['classes']['VarObjC']['values']['d']['value']['args'][0]['arg'])
+    // CHECK: all(arg['bitnum'] == 7-i for i,arg in enumerate(data['classes']['VarObjC']['values']['d']['value']['args'][0]['arg']))
+    // CHECK: data['classes']['VarObjC']['values']['d']['printable'] == '(Op { bs{7}, bs{6}, bs{5}, bs{4}, bs{3} })'
+
+    Variables vs;
+    int vsi = vs.i;
+    // CHECK: data['classes']['VarObjC']['values']['vsi']['value']['kind'] == 'field'
+    // CHECK: data['classes']['VarObjC']['values']['vsi']['value']['record']['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['vsi']['value']['record']['var'] == 'vs'
+    // CHECK: data['classes']['VarObjC']['values']['vsi']['value']['field'] == 'i'
+    // CHECK: data['classes']['VarObjC']['values']['vsi']['printable'] == 'vs.i'
+
+    int vsi1 = !add(1, vsi);
+    // CHECK: data['classes']['VarObjC']['values']['vsi1']['value']['kind'] == '!add'
+    // CHECK: data['classes']['VarObjC']['values']['vsi1']['value']['args'][0] == 1
+    // CHECK: data['classes']['VarObjC']['values']['vsi1']['value']['args'][1]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['vsi1']['value']['args'][1]['var'] == 'vsi'
+    // CHECK: data['classes']['VarObjC']['values']['vsi1']['printable'] == '!add(1, vsi)'
+
+    int vsi2 = vs.li[2];
+    // CHECK: data['classes']['VarObjC']['values']['vsi2']['value']['kind'] == 'listindex'
+    // CHECK: data['classes']['VarObjC']['values']['vsi2']['value']['operand']['kind'] == 'field'
+    // CHECK: data['classes']['VarObjC']['values']['vsi2']['value']['index'] == 2
+    // CHECK: data['classes']['VarObjC']['values']['vsi2']['printable'] == 'vs.li[2]'
+
+    list<Base> bases;
+    list<int> isas = !foreach(base, bases, !isa<Derived>(base));
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['kind'] == '!foreach'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][0] == 'base'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][1]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][1]['var'] == 'bases'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][2]['kind'] == '!isa'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][2]['type']['kind'] == 'record'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][2]['type']['classes'] == ['Derived']
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][2]['args'][0]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['value']['args'][2]['args'][0]['var'] == 'base'
+    // CHECK: data['classes']['VarObjC']['values']['isas']['printable'] == '!foreach("base", bases, !isa<Derived>(base))'
+
+    list<int> summands;
+    int sum = !foldl(1, summands, x, y, !add(x,y));
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['kind'] == '!foldl'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][0] == 1
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][1]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][1]['var'] == 'summands'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][2] == 'x'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][3] == 'y'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][4]['kind'] == '!add'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][4]['args'][0]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][4]['args'][0]['var'] == 'x'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][4]['args'][1]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['value']['args'][4]['args'][1]['var'] == 'y'
+    // CHECK: data['classes']['VarObjC']['values']['sum']['printable'] == '!foldl(1, summands, x, y, !add(x, y))'
+}
+class VarObjCT<int i> {
+    Templated t = Templated<i>;
+    // CHECK: data['classes']['VarObjCT']['values']['t']['value']['kind'] == 'vardef'
+    // CHECK: data['classes']['VarObjCT']['values']['t']['value']['class'] == 'Templated'
+    // CHECK: data['classes']['VarObjCT']['values']['t']['value']['args'][0]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjCT']['values']['t']['value']['args'][0]['var'] == 'VarObjCT:i'
+    // CHECK: data['classes']['VarObjCT']['values']['t']['printable'] == 'Templated<VarObjCT:i>'
+
+    bit b = !cast<bit>(i);
+    // CHECK: data['classes']['VarObjCT']['values']['b']['value']['kind'] == '!cast'
+    // CHECK: data['classes']['VarObjCT']['values']['b']['value']['type']['kind'] == 'bit'
+    // CHECK: data['classes']['VarObjCT']['values']['b']['value']['args'][0]['kind'] == 'var'
+    // CHECK: data['classes']['VarObjCT']['values']['b']['value']['args'][0]['var'] == 'VarObjCT:i'
+    // CHECK: data['classes']['VarObjCT']['values']['b']['printable'] == '!cast<bit>(VarObjCT:i)'
+}
+
+class FieldKeywordTest {
+    int a;
+    field int b;
+    // CHECK: data['classes']['FieldKeywordTest']['values']['a']['field'] is False
+    // CHECK: data['classes']['FieldKeywordTest']['values']['b']['field'] is True
+}
+
+class TemplateArgsTest<int i, int j = 3> {}
+// CHECK: data['classes']['TemplateArgsTest']['template_args_order'] == ['TemplateArgsTest:i', 'TemplateArgsTest:j']
+// CHECK: data['classes']['TemplateArgsTest']['template_args']['TemplateArgsTest:i']['type']['kind'] == 'int'
+// CHECK: data['classes']['TemplateArgsTest']['template_args']['TemplateArgsTest:i']['value'] is None
+// CHECK: data['classes']['TemplateArgsTest']['template_args']['TemplateArgsTest:j']['type']['kind'] == 'int'
+// CHECK: data['classes']['TemplateArgsTest']['template_args']['TemplateArgsTest:j']['value'] == 3

utils/TableGen/CMakeLists.txt

add_tablegen(llvm-tblgen LLVM
   DisassemblerEmitter.cpp
   FastISelEmitter.cpp
   FixedLenDecoderEmitter.cpp
   GlobalISelEmitter.cpp
   InfoByHwMode.cpp
   InstrInfoEmitter.cpp
   InstrDocsEmitter.cpp
   IntrinsicEmitter.cpp
+  JSONEmitter.cpp
   OptParserEmitter.cpp
   PseudoLoweringEmitter.cpp
   RISCVCompressInstEmitter.cpp
   RegisterBankEmitter.cpp
   RegisterInfoEmitter.cpp
   SDNodeProperties.cpp
   SearchableTableEmitter.cpp
   SubtargetEmitter.cpp

utils/TableGen/JSONEmitter.cpp

+//===- RegisterBankEmitter.cpp - Generate a Register Bank Desc. -*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This TableGen back end generates a machine-readable representation
+// of all the classes and records defined by the input, in JSON format.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/BitVector.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/TableGen/Error.h"
+#include "llvm/TableGen/Record.h"
+#include "llvm/TableGen/TableGenBackend.h"
+
+#define DEBUG_TYPE "json-emitter"
+
+using namespace llvm;
+
+namespace {
+
+class JSONValue {
+public:
+  virtual ~JSONValue() = default;
+  virtual void write(raw_ostream &OS) const = 0;
+};
+
+using PVal = std::shared_ptr<const JSONValue>;
+
+class JSONNull : public JSONValue {
+public:
+  void write(raw_ostream &OS) const override { OS << "null"; }
+  JSONNull() = default;
+};
+
+class JSONBool : public JSONValue {
+  bool val;
+
+public:
+  void write(raw_ostream &OS) const override { OS << (val ? "true" : "false"); }
+  JSONBool(bool val_) : val(val_) {}
+};
+
+class JSONInteger : public JSONValue {
+  int64_t val;
+
+public:
+  void write(raw_ostream &OS) const override { OS << val; }
+  JSONInteger(int64_t val_) : val(val_) {}
+};
+
+class JSONString : public JSONValue {
+  std::string val;
+
+public:
+  void write(raw_ostream &OS) const override {
+    OS << '"';
+    for (char c : val) {
+      // Restrict to simple ASCII, avoiding Unicode pain
+      assert((unsigned char)c < 0x80);
+      switch (c) {
+      case '\n':
+        OS << "\\n";
+        break;
+      case '\r':
+        OS << "\\r";
+        break;
+      case '\t':
+        OS << "\\t";
+        break;
+      case '\f':
+        OS << "\\f";
+        break;
+      case '\b':
+        OS << "\\b";
+        break;
+      case '\\':
+      case '"':
+        OS << '\\' << c;
+        break;
+      default:
+        if (c < 0x20) {
+          static const char hex[] = "0123456789abcdef";
+          OS << "\\u00" << hex[c >> 4] << hex[c & 0xF];
+        } else {
+          OS << c;
+        }
+      }
+    }
+    OS << '"';
+  }
+  JSONString(const std::string &val_) : val(val_) {}
+};
+
+class JSONArray : public JSONValue {
+  std::vector<PVal> values;
+
+public:
+  void write(raw_ostream &OS) const override {
+    OS << '[';
+    const char *sep = "";
+    for (PVal v : values) {
+      OS << sep;
+      v->write(OS);
+      sep = ",";
+    }
+    OS << ']';
+  }
+  JSONArray() = default;
+  void push_back(PVal v) { values.push_back(v); }
+};
+
+class JSONObject : public JSONValue {
+  std::map<std::string, PVal> values;
+  std::vector<std::string> value_order;
+
+public:
+  void write(raw_ostream &OS) const override {
+    OS << '{';
+    const char *sep = "";
+    for (const auto &key : value_order) {
+      auto it = values.find(key);
+      assert(it != values.end());
+
+      OS << sep;
+      JSONString(key).write(OS);
+      OS << ':';
+      it->second->write(OS);
+      sep = ",";
+    }
+    OS << '}';
+  }
+  JSONObject() = default;
+  void insert(std::string key, PVal value) {
+    assert(values.find(key) == values.end());
+    values[key] = value;
+    value_order.push_back(key);
+  }
+};
+
+static inline std::shared_ptr<JSONObject> mkobj() {
+  return std::make_shared<JSONObject>();
+}
+static inline std::shared_ptr<JSONArray> mkarray() {
+  return std::make_shared<JSONArray>();
+}
+static inline std::shared_ptr<JSONString> mkstring(const std::string &s) {
+  return std::make_shared<JSONString>(s);
+}
+static inline std::shared_ptr<JSONInteger> mkint(int64_t i) {
+  return std::make_shared<JSONInteger>(i);
+}
+
+class JSONEmitter {
+private:
+  RecordKeeper &Records;
+  PVal True, False, Null;
+
+  PVal translate(const RecTy &T);
+  PVal translate(const Init &I);
+  PVal translate(const RecordVal &V);
+  std::shared_ptr<JSONObject> translate(const Record &R);
+
+public:
+  JSONEmitter(RecordKeeper &R);
+
+  void run(raw_ostream &OS);
+};
+
+} // end anonymous namespace
+
+JSONEmitter::JSONEmitter(RecordKeeper &R)
+    : Records(R), True(std::make_shared<JSONBool>(true)),
+      False(std::make_shared<JSONBool>(false)),
+      Null(std::make_shared<JSONNull>()) {}
+
+PVal JSONEmitter::translate(const RecTy &T) {
+  auto toret = mkobj();
+
+  toret->insert("printable", mkstring(T.getAsString()));
+
+  std::string kind;
+  switch (T.getRecTyKind()) {
+  case RecTy::BitRecTyKind:
+    kind = "bit";
+    break;
+  case RecTy::BitsRecTyKind:
+    kind = "bits";
+    break;
+  case RecTy::CodeRecTyKind:
+    kind = "code";
+    break;
+  case RecTy::IntRecTyKind:
+    kind = "int";
+    break;
+  case RecTy::StringRecTyKind:
+    kind = "string";
+    break;
+  case RecTy::ListRecTyKind:
+    kind = "list";
+    break;
+  case RecTy::DagRecTyKind:
+    kind = "dag";
+    break;
+  case RecTy::RecordRecTyKind:
+    kind = "record";
+    break;
+  default:
+    llvm_unreachable("Bad RecTyKind");
+  }
+  toret->insert("kind", mkstring(kind));
+
+  if (auto *BRT = dyn_cast<BitsRecTy>(&T))
+    toret->insert("size", mkint(BRT->getNumBits()));
+  if (auto *LRT = dyn_cast<ListRecTy>(&T))
+    toret->insert("element", translate(*LRT->getElementType()));
+  if (auto *RRT = dyn_cast<RecordRecTy>(&T)) {
+    auto classes = mkarray();
+    toret->insert("classes", classes);
+    for (Record *R : RRT->getClasses())
+      classes->push_back(mkstring(R->getNameInitAsString()));
+  }
+
+  return toret;
+}
+
+PVal JSONEmitter::translate(const Init &I) {
+  if (dyn_cast<UnsetInit>(&I)) {
+    return Null;
+  } else if (auto *Bit = dyn_cast<BitInit>(&I)) {
+    return mkint(Bit->getValue() ? 1 : 0);
+  } else if (auto *Bits = dyn_cast<BitsInit>(&I)) {
+    auto array = mkarray();
+    for (unsigned i = Bits->getNumBits(); i-- > 0;)
+      array->push_back(translate(*Bits->getBit(i)));
+    return array;
+  } else if (auto *Int = dyn_cast<IntInit>(&I)) {
+    return mkint(Int->getValue());
+  } else if (auto *Str = dyn_cast<StringInit>(&I)) {
+    return mkstring(Str->getValue());
+  } else if (auto *Code = dyn_cast<CodeInit>(&I)) {
+    return mkstring(Code->getValue());
+  } else if (auto *Def = dyn_cast<DefInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("def"));
+    obj->insert("name", mkstring(Def->getDef()->getName()));
+    return obj;
+  } else if (auto *Var = dyn_cast<VarInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("var"));
+    obj->insert("var", translate(*Var->getNameInit()));
+    return obj;
+  } else if (auto *Field = dyn_cast<FieldInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("field"));
+    obj->insert("record", translate(*Field->getRecord()));
+    obj->insert("field",
+                mkstring(Field->getFieldName()->getAsUnquotedString()));
+    return obj;
+  } else if (auto *VarBit = dyn_cast<VarBitInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("bitindex"));
+    obj->insert("operand", translate(*VarBit->getBitVar()));
+    obj->insert("bitnum", mkint(VarBit->getBitNum()));
+    return obj;
+  } else if (auto *VarDef = dyn_cast<VarDefInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("vardef"));
+    obj->insert("class", mkstring(VarDef->getClass()->getNameInitAsString()));
+    auto args = mkarray();
+    obj->insert("args", args);
+    for (auto arg : VarDef->args())
+      args->push_back(translate(*arg));
+    return obj;
+  } else if (auto *Dag = dyn_cast<DagInit>(&I)) {
+    auto node = mkobj();
+    node->insert("kind", mkstring("dag"));
+    node->insert("operator", translate(*Dag->getOperator()));
+    if (auto name = Dag->getName())
+      node->insert("name", mkstring(name->getAsUnquotedString()));
+    auto args = mkarray();
+    node->insert("args", args);
+    for (unsigned i = 0, limit = Dag->getNumArgs(); i < limit; ++i) {
+      auto arg = mkobj();
+      args->push_back(arg);
+      arg->insert("arg", translate(*Dag->getArg(i)));
+      if (auto argname = Dag->getArgName(i))
+        arg->insert("name", mkstring(argname->getAsUnquotedString()));
+      else
+        arg->insert("name", Null);
+    }
+    return node;
+  } else if (auto *Op = dyn_cast<OpInit>(&I)) {
+    auto node = mkobj();
+    node->insert("kind", mkstring(Op->getOperatorName()));
+    auto args = mkarray();
+    node->insert("args", args);
+    for (unsigned i = 0, limit = Op->getNumOperands(); i < limit; ++i)
+      args->push_back(translate(*Op->getOperand(i)));
+
+    if (auto *UnOp = dyn_cast<UnOpInit>(Op)) {
+      if (UnOp->getOpcode() == UnOpInit::CAST) {
+        node->insert("type", translate(*UnOp->getType()));
+      }
+    }
+
+    return node;
+  } else if (auto *List = dyn_cast<ListInit>(&I)) {
+    auto array = mkarray();
+    for (auto val : *List)
+      array->push_back(translate(*val));
+    return array;
+  } else if (auto *Fold = dyn_cast<FoldOpInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("!foldl"));
+    auto args = mkarray();
+    obj->insert("args", args);
+    args->push_back(translate(*Fold->getStart()));
+    args->push_back(translate(*Fold->getList()));
+    args->push_back(translate(*Fold->getA()));
+    args->push_back(translate(*Fold->getB()));
+    args->push_back(translate(*Fold->getExpr()));
+    return obj;
+  } else if (auto *IsA = dyn_cast<IsAOpInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("!isa"));
+    obj->insert("type", translate(*IsA->getCheckType()));
+    auto args = mkarray();
+    obj->insert("args", args);
+    args->push_back(translate(*IsA->getExpr()));
+    return obj;
+  } else if (auto *VLE = dyn_cast<VarListElementInit>(&I)) {
+    auto obj = mkobj();
+    obj->insert("kind", mkstring("listindex"));
+    obj->insert("operand", translate(*VLE->getVariable()));
+    obj->insert("index", mkint(VLE->getElementNum()));
+    return obj;
+  }
+
+  llvm_unreachable("Bad type in translate(Init)");
+}
+
+PVal JSONEmitter::translate(const RecordVal &V) {
+  auto toret = mkobj();
+  toret->insert("type", translate(*V.getType()));
+  if (auto val = V.getValue()) {
+    toret->insert("printable", mkstring(val->getAsString()));
+    toret->insert("value", translate(*val));
+  }
+  toret->insert("field", V.getPrefix() ? True : False);
+  return toret;
+}
+
+std::shared_ptr<JSONObject> JSONEmitter::translate(const Record &R) {
+  auto toret = mkobj();
+
+  {
+    auto sc = mkarray();
+    toret->insert("superclasses", sc);
+    for (const auto &SuperPair : R.getSuperClasses())
+      sc->push_back(mkstring(SuperPair.first->getNameInitAsString()));
+  }
+
+  {
+    auto ta_list = mkarray();
+    auto ta_dict = mkobj();
+    toret->insert("template_args_order", ta_list);
+    toret->insert("template_args", ta_dict);
+    for (const auto TA : R.getTemplateArgs()) {
+      const RecordVal *RV = R.getValue(TA);
+      assert(RV && "Template argument record not found??");
+      std::string name = RV->getNameInitAsString();
+      ta_list->push_back(mkstring(name));
+      ta_dict->insert(name, translate(*RV));
+    }
+  }
+
+  {
+    auto vals = mkobj();
+    toret->insert("values", vals);
+    for (const RecordVal &Val : R.getValues())
+      if (!R.isTemplateArg(Val.getNameInit()))
+        vals->insert(Val.getNameInitAsString(), translate(Val));
+  }
+
+  return toret;
+}
+
+void JSONEmitter::run(raw_ostream &OS) {
+  auto root = mkobj();
+
+  std::map<std::string, std::shared_ptr<JSONArray>> class_subclass_lists;
+  std::map<std::string, std::shared_ptr<JSONArray>> class_instance_lists;
+
+  auto classes = mkobj();
+  root->insert("classes", classes);
+  for (const auto &C : Records.getClasses()) {
+    auto &Name = C.second->getNameInitAsString();
+    auto &Class = *C.second;
+
+    auto Translated = translate(Class);
+    classes->insert(Name, Translated);
+
+    auto subclasses = mkarray();
+    Translated->insert("subclasses", subclasses);
+    class_subclass_lists[Name] = subclasses;
+
+    auto instances = mkarray();
+    Translated->insert("instances", instances);
+    class_instance_lists[Name] = instances;
+  }
+
+  for (const auto &C : Records.getClasses()) {
+    auto &Name = C.second->getNameInitAsString();
+    auto &Class = *C.second;
+    for (const auto &SuperPair : Class.getSuperClasses()) {
+      auto SuperName = SuperPair.first->getNameInitAsString();
+      auto it = class_subclass_lists.find(SuperName);
+      if (it != class_subclass_lists.end())
+        it->second->push_back(mkstring(Name));
+    }
+  }
+
+  auto defs = mkobj();
+  root->insert("defs", defs);
+  for (const auto &D : Records.getDefs()) {
+    auto &Name = D.second->getNameInitAsString();
+    auto &Def = *D.second;
+
+    auto Translated = translate(Def);
+    defs->insert(Name, Translated);
+
+    for (const auto &SuperPair : Def.getSuperClasses()) {
+      auto SuperName = SuperPair.first->getNameInitAsString();
+      auto it = class_instance_lists.find(SuperName);
+      if (it != class_instance_lists.end())
+        it->second->push_back(mkstring(Name));
+    }
+  }
+
+  root->write(OS);
+}
+
+namespace llvm {
+
+void EmitJSON(RecordKeeper &RK, raw_ostream &OS) { JSONEmitter(RK).run(OS); }
+
+} // end namespace llvm

utils/TableGen/TableGen.cpp

 #include "llvm/TableGen/Main.h"
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/SetTheory.h"
 
 using namespace llvm;
 
 enum ActionType {
   PrintRecords,
+  DumpJSON,
   GenEmitter,
   GenRegisterInfo,
   GenInstrInfo,
   GenInstrDocs,
   GenAsmWriter,
   GenAsmMatcher,
   GenDisassembler,
   GenPseudoLowering,
enum ActionType {
   GenRegisterBank,
 };
 
 namespace {
   cl::opt<ActionType>
   Action(cl::desc("Action to perform:"),
          cl::values(clEnumValN(PrintRecords, "print-records",
                                "Print all records to stdout (default)"),
+                    clEnumValN(DumpJSON, "dump-json",
+                               "Dump all records as machine-readable JSON"),
                     clEnumValN(GenEmitter, "gen-emitter",
                                "Generate machine code emitter"),
                     clEnumValN(GenRegisterInfo, "gen-register-info",
                                "Generate registers and register classes info"),
                     clEnumValN(GenInstrInfo, "gen-instr-info",
                                "Generate instruction descriptions"),
                     clEnumValN(GenInstrDocs, "gen-instr-docs",
                                "Generate instruction documentation"),
namespace {
   Class("class", cl::desc("Print Enum list for this class"),
         cl::value_desc("class name"), cl::cat(PrintEnumsCat));
 
 bool LLVMTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   switch (Action) {
   case PrintRecords:
     OS << Records;           // No argument, dump all contents
     break;
+  case DumpJSON:
+    EmitJSON(Records, OS);
+    break;
   case GenEmitter:
     EmitCodeEmitter(Records, OS);
     break;
   case GenRegisterInfo:
     EmitRegisterInfo(Records, OS);
     break;
   case GenInstrInfo:
     EmitInstrInfo(Records, OS);

utils/TableGen/TableGenBackends.h

 void EmitCTags(RecordKeeper &RK, raw_ostream &OS);
 void EmitAttributes(RecordKeeper &RK, raw_ostream &OS);
 void EmitSearchableTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitGlobalISel(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86EVEX2VEXTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitX86FoldTables(RecordKeeper &RK, raw_ostream &OS);
 void EmitRegisterBank(RecordKeeper &RK, raw_ostream &OS);
 
+void EmitJSON(RecordKeeper &RK, raw_ostream &OS);
+
 } // End llvm namespace
 
 #endif