llvm/test/TableGen/dag-functional.td

   1 // RUN: llvm-tblgen %s | FileCheck %s
   2 // XFAIL: vg_leak
   3
   4 // CHECK: --- Defs ---
   5
   6 // CHECK: def A0 {
   7 // CHECK:   dag ret = (ops);
   8 // CHECK: }
   9
  10 // CHECK: def A1 {
  11 // CHECK:   dag ret = (ops ?:$a, 1:$b, 2);
  12 // CHECK: }
  13
  14 // CHECK: def A2 {
  15 // CHECK:   dag ret = (ops (ops ?:$name):$a, (ops 1):$b, (ops "foo"):$c);
  16 // CHECK: }
  17
  18 // CHECK: def A3 {
  19 // CHECK:   dag ret = (ops NodeA0:$a, NodeB0:$b);
  20 // CHECK: }
  21
  22 // CHECK: def A4 {
  23 // CHECK:   dag ret = (ops NodeA0, NodeB0);
  24 // CHECK: }
  25
  26 // CHECK: def B0 {
  27 // CHECK:   dag ret = (ops);
  28 // CHECK: }
  29
  30 // CHECK: def B1 {
  31 // CHECK:   dag ret = (ops 1:$a, 2:$b);
  32 // CHECK: }
  33
  34 // CHECK: def C0 {
  35 // CHECK:   dag ret1 = (ops ?:$a, ?:$b);
  36 // CHECK:   dag ret2 = (ops 1, 2);
  37 // CHECK: }
  38
  39 // CHECK: def D {
  40 // CHECK:   dag d1 = (ops 1, ?:$name1, 2, 3);
  41 // CHECK: }
  42
  43 // CHECK: def E0 {
  44 // CHECK:   dag ret = (ops 1, 2);
  45 // CHECK: }
  46
  47 class Ops;
  48
  49 def ops : Ops;
  50
  51 class Node<int val, string name> {
  52   int Val = val;
  53   string Name = name;
  54 }
  55
  56 class Aint<list<int> nodes, list<string> names> {
  57   dag ret = !dag(ops, nodes, names);
  58 }
  59
  60 class Adag<list<dag> nodes, list<string> names> {
  61   dag ret = !dag(ops, nodes, names);
  62 }
  63
  64 class NodeBase;
  65
  66 class NodeA<int val> : NodeBase {
  67   int x = val;
  68 }
  69
  70 class NodeB<int val> : NodeBase {
  71   int y = val;
  72 }
  73
  74 class Anode<list<NodeBase> nodes, list<string> names> {
  75   dag ret = !dag(ops, nodes, names);
  76 }
  77
  78 class B<list<Node> nodes> {
  79   dag ret = !foldl((ops), nodes, lhs, rhs, !con(lhs, !dag(ops, [rhs.Val], [rhs.Name])));
  80 }
  81
  82 def A0 : Aint<[], []>;
  83 def A1 : Aint<[?, 1, 2], ["a", "b", ?]>;
  84
  85 def A2 : Adag<[(ops $name), (ops 1), (ops "foo")], ["a", "b", "c"]>;
  86
  87 def NodeA0 : NodeA<0>;
  88 def NodeB0 : NodeB<0>;
  89
  90 def A3 : Anode<[NodeA0, NodeB0], ["a", "b"]>;
  91
  92 def A4 {
  93   // Like A3, but with a literal list directly in the !dag.
  94   dag ret = !dag(ops, [NodeA0, NodeB0], ?);
  95 }
  96
  97 def B0 : B<[]>;
  98 def B1 : B<[Node<1, "a">, Node<2, "b">]>;
  99
 100 class C<list<int> nodes, list<string> names> {
 101   dag ret1 = !dag(ops, ?, names);
 102   dag ret2 = !dag(ops, nodes, ?);
 103 }
 104
 105 def C0 : C<[1, 2], ["a", "b"]>;
 106
 107 def D {
 108   dag d1 = !con((ops 1), (ops $name1), (ops), (ops 2, 3));
 109 }
 110
 111 class E<Ops op> {
 112   // Allow concatenation of DAG nodes with operators from template arguments.
 113   dag ret = !con((op 1), (op 2));
 114 }
 115
 116 def E0 : E<ops>;