test/TableGen/JSON.td

// RUN: llvm-tblgen -dump-json %s | %python %S/JSON-check.py %s

// CHECK: data['!tablegen_json_version'] == 1

// CHECK: all(data[s]['!name'] == s for s in data if not s.startswith("!"))

class Base {}
class Intermediate : Base {}
class Derived : Intermediate {}

def D : Intermediate {}
// CHECK: 'D' in data['!instanceof']['Base']
// CHECK: 'D' in data['!instanceof']['Intermediate']
// CHECK: 'D' not in data['!instanceof']['Derived']
// CHECK: 'Base' in data['D']['!superclasses']
// CHECK: 'Intermediate' in data['D']['!superclasses']
// CHECK: 'Derived' not in data['D']['!superclasses']

def ExampleDagOp;

def FieldKeywordTest {
    int a;
    field int b;
    // CHECK: 'a' not in data['FieldKeywordTest']['!fields']
    // CHECK: 'b' in data['FieldKeywordTest']['!fields']
}

class Variables {
    int i;
    string s;
    bit b;
    bits<8> bs;
    code c;
    list<int> li;
    Base base;
    dag d;
}
def VarNull : Variables {
    // A variable not filled in at all has its value set to JSON
    // 'null', which translates to Python None
    // CHECK: data['VarNull']['i'] is None
}
def VarPrim : Variables {
    // Test initializers that map to primitive JSON types

    int i = 3;
    // CHECK: data['VarPrim']['i'] == 3

    // Integer literals should be emitted in the JSON at full 64-bit
    // precision, for the benefit of JSON readers that preserve that
    // much information. Python's is one such.
    int enormous_pos = 9123456789123456789;
    int enormous_neg = -9123456789123456789;
    // CHECK: data['VarPrim']['enormous_pos'] == 9123456789123456789
    // CHECK: data['VarPrim']['enormous_neg'] == -9123456789123456789

    string s = "hello, world";
    // CHECK: data['VarPrim']['s'] == 'hello, world'

    bit b = 0;
    // CHECK: data['VarPrim']['b'] == 0

    // bits<> arrays are stored in logical order (array[i] is the same
    // bit identified in .td files as bs{i}), which means the _visual_
    // order of the list (in default rendering) is reversed.
    bits<8> bs = { 0,0,0,1,0,1,1,1 };
    // CHECK: data['VarPrim']['bs'] == [ 1,1,1,0,1,0,0,0 ]

    code c = [{ \"  }];
    // CHECK: data['VarPrim']['c'] == r' \"  '

    list<int> li = [ 1, 2, 3, 4 ];
    // CHECK: data['VarPrim']['li'] == [ 1, 2, 3, 4 ]
}
def VarObj : Variables {
    // Test initializers that map to JSON objects containing a 'kind'
    // discriminator

    Base base = D;
    // CHECK: data['VarObj']['base']['kind'] == 'def'
    // CHECK: data['VarObj']['base']['def'] == 'D'
    // CHECK: data['VarObj']['base']['printable'] == 'D'

    dag d = (ExampleDagOp 22, "hello":$foo);
    // CHECK: data['VarObj']['d']['kind'] == 'dag'
    // CHECK: data['VarObj']['d']['operator']['kind'] == 'def'
    // CHECK: data['VarObj']['d']['operator']['def'] == 'ExampleDagOp'
    // CHECK: data['VarObj']['d']['operator']['printable'] == 'ExampleDagOp'
    // CHECK: data['VarObj']['d']['args'] == [[22, None], ["hello", "foo"]]
    // CHECK: data['VarObj']['d']['printable'] == '(ExampleDagOp 22, "hello":$foo)'

    int undef_int;
    field int ref_int = undef_int;
    // CHECK: data['VarObj']['ref_int']['kind'] == 'var'
    // CHECK: data['VarObj']['ref_int']['var'] == 'undef_int'
    // CHECK: data['VarObj']['ref_int']['printable'] == 'undef_int'

    bits<2> undef_bits;
    bits<4> ref_bits;
    let ref_bits{3-2} = 0b10;
    let ref_bits{1-0} = undef_bits{1-0};
    // CHECK: data['VarObj']['ref_bits'][3] == 1
    // CHECK: data['VarObj']['ref_bits'][2] == 0
    // CHECK: data['VarObj']['ref_bits'][1]['kind'] == 'varbit'
    // CHECK: data['VarObj']['ref_bits'][1]['var'] == 'undef_bits'
    // CHECK: data['VarObj']['ref_bits'][1]['index'] == 1
    // CHECK: data['VarObj']['ref_bits'][1]['printable'] == 'undef_bits{1}'
    // CHECK: data['VarObj']['ref_bits'][0]['kind'] == 'varbit'
    // CHECK: data['VarObj']['ref_bits'][0]['var'] == 'undef_bits'
    // CHECK: data['VarObj']['ref_bits'][0]['index'] == 0
    // CHECK: data['VarObj']['ref_bits'][0]['printable'] == 'undef_bits{0}'

    field int complex_ref_int = !add(undef_int, 2);
    // CHECK: data['VarObj']['complex_ref_int']['kind'] == 'complex'
    // CHECK: data['VarObj']['complex_ref_int']['printable'] == '!add(undef_int, 2)'
}

// Test the !anonymous member. This is tricky because when a def is
// anonymous, almost by definition, the test can't reliably predict
// the name it will be stored under! So we have to search all the defs
// in the JSON output looking for the one that has the test integer
// field set to the right value.

def Named { int AnonTestField = 1; }
// CHECK: data['Named']['AnonTestField'] == 1
// CHECK: data['Named']['!anonymous'] is False

def { int AnonTestField = 2; }
// CHECK: next(rec for rec in data.values() if isinstance(rec, dict) and rec.get('AnonTestField') == 2)['!anonymous'] is True

multiclass AnonTestMulticlass<int base> {
    def _plus_one { int AnonTestField = !add(base,1); }
    def { int AnonTestField = !add(base,2); }
}

defm NamedDefm : AnonTestMulticlass<10>;
// CHECK: data['NamedDefm_plus_one']['!anonymous'] is False
// CHECK: data['NamedDefm_plus_one']['AnonTestField'] == 11
// CHECK: next(rec for rec in data.values() if isinstance(rec, dict) and rec.get('AnonTestField') == 12)['!anonymous'] is True

// D47431 clarifies that a named def inside a multiclass gives a
// *non*-anonymous output record, even if the defm that instantiates
// that multiclass is anonymous.
defm : AnonTestMulticlass<20>;
// CHECK: next(rec for rec in data.values() if isinstance(rec, dict) and rec.get('AnonTestField') == 21)['!anonymous'] is False
// CHECK: next(rec for rec in data.values() if isinstance(rec, dict) and rec.get('AnonTestField') == 22)['!anonymous'] is True