llvm/test/TableGen/self-reference.td

   1 // RUN: llvm-tblgen %s | FileCheck %s
   2 // XFAIL: vg_leak
   3
   4 // CHECK: --- Defs ---
   5
   6 // CHECK: def A0 {
   7 // CHECK:   dag a = (ops A0);
   8 // CHECK: }
   9
  10 // CHECK: def B0 {
  11 // CHECK:   dag a = (ops);
  12 // CHECK:   A b = B0;
  13 // CHECK: }
  14
  15 // CHECK: def C0 {
  16 // CHECK:   dag q = (ops C0);
  17 // CHECK: }
  18
  19 // CHECK: def D0 {
  20 // CHECK:   D d = D0;
  21 // CHECK: }
  22
  23 // CHECK: def E0 {
  24 // CHECK:   E e = E0;
  25 // CHECK: }
  26
  27 // CHECK: def F0 {
  28 // CHECK:   Fa as_a = F0;
  29 // CHECK:   Fb as_b = F0;
  30 // CHECK: }
  31 // CHECK: def F0x {
  32 // CHECK:   Fc as_c = F0;
  33 // CHECK: }
  34
  35 // CHECK: def anonymous_0 {
  36 // CHECK:   G g = anonymous_0;
  37 // CHECK: }
  38 // CHECK: def anonymous_1 {
  39 // CHECK:   G g = anonymous_1;
  40 // CHECK: }
  41 // CHECK: def anonymous_2 {
  42 // CHECK:   G g = anonymous_2;
  43 // CHECK: }
  44 // CHECK: def anonymous_5 {
  45 // CHECK:   G g = anonymous_5;
  46 // CHECK: }
  47
  48 def ops;
  49
  50 class A<dag d> {
  51   dag a = d;
  52 }
  53
  54 // This type of self-reference is used in various places defining register
  55 // classes.
  56 def A0 : A<(ops A0)>;
  57
  58 class B<string self> {
  59   A b = !cast<A>(self);
  60 }
  61
  62 // A stronger form of this type of self-reference is used at least in the
  63 // SystemZ backend to define a record which is a ComplexPattern and an Operand
  64 // at the same time.
  65 def B0 : A<(ops)>, B<"B0">;
  66
  67 // Casting C0 to C by name here is tricky, because it happens while (or rather:
  68 // before) adding C as a superclass. However, SystemZ uses this pattern.
  69 class C<string self> {
  70   dag q = (ops !cast<C>(self));
  71 }
  72
  73 def C0 : C<"C0">;
  74
  75 // Explore some unused corner cases.
  76 //
  77 // A self-reference within a class may seem icky, but it unavoidably falls out
  78 // orthogonally of having forward class declarations and late resolve of self
  79 // references.
  80 class D<string self> {
  81   D d = !cast<D>(self);
  82 }
  83
  84 def D0 : D<"D0">;
  85
  86 class E<E x> {
  87   E e = x;
  88 }
  89
  90 // Putting the !cast directly in the def should work as well: we shouldn't
  91 // depend on implementation details of when exactly the record is looked up.
  92 //
  93 // Note the difference between !cast<E>("E0") and plain E0: the latter wouldn't
  94 // work here because E0 does not yet have E as a superclass while the template
  95 // arguments are being parsed.
  96 def E0 : E<!cast<E>("E0")>;
  97
  98 // Ensure that records end up with the correct type even when direct self-
  99 // references are involved.
 100 class Fa;
 101 class Fb<Fa x> {
 102   Fa as_a = x;
 103 }
 104 class Fc<Fb x> {
 105   Fb as_b = x;
 106 }
 107
 108 def F0 : Fa, Fb<F0>, Fc<F0>;
 109 def F0x {
 110   Fc as_c = F0;
 111 }
 112
 113 // anonymous record self-reference in foreach and multiclass
 114 class G {
 115   G g = !cast<G>(NAME);
 116 }
 117
 118 foreach _ = [1, 2] in
 119   def : G;
 120
 121 multiclass H {
 122   def : G;
 123 }
 124
 125 defm : H;
 126 defm : H;