reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74
   75
   76
   77
   78
   79
   80
   81
   82
   83
   84
   85
   86
   87
   88
   89
   90
   91
   92
   93
   94
   95
   96
   97
   98
   99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116

// RUN: llvm-tblgen %s | FileCheck %s
// XFAIL: vg_leak

// CHECK: --- Defs ---

// CHECK: def A0 {
// CHECK:   dag ret = (ops);
// CHECK: }

// CHECK: def A1 {
// CHECK:   dag ret = (ops ?:$a, 1:$b, 2);
// CHECK: }

// CHECK: def A2 {
// CHECK:   dag ret = (ops (ops ?:$name):$a, (ops 1):$b, (ops "foo"):$c);
// CHECK: }

// CHECK: def A3 {
// CHECK:   dag ret = (ops NodeA0:$a, NodeB0:$b);
// CHECK: }

// CHECK: def A4 {
// CHECK:   dag ret = (ops NodeA0, NodeB0);
// CHECK: }

// CHECK: def B0 {
// CHECK:   dag ret = (ops);
// CHECK: }

// CHECK: def B1 {
// CHECK:   dag ret = (ops 1:$a, 2:$b);
// CHECK: }

// CHECK: def C0 {
// CHECK:   dag ret1 = (ops ?:$a, ?:$b);
// CHECK:   dag ret2 = (ops 1, 2);
// CHECK: }

// CHECK: def D {
// CHECK:   dag d1 = (ops 1, ?:$name1, 2, 3);
// CHECK: }

// CHECK: def E0 {
// CHECK:   dag ret = (ops 1, 2);
// CHECK: }

class Ops;

def ops : Ops;

class Node<int val, string name> {
  int Val = val;
  string Name = name;
}

class Aint<list<int> nodes, list<string> names> {
  dag ret = !dag(ops, nodes, names);
}

class Adag<list<dag> nodes, list<string> names> {
  dag ret = !dag(ops, nodes, names);
}

class NodeBase;

class NodeA<int val> : NodeBase {
  int x = val;
}

class NodeB<int val> : NodeBase {
  int y = val;
}

class Anode<list<NodeBase> nodes, list<string> names> {
  dag ret = !dag(ops, nodes, names);
}

class B<list<Node> nodes> {
  dag ret = !foldl((ops), nodes, lhs, rhs, !con(lhs, !dag(ops, [rhs.Val], [rhs.Name])));
}

def A0 : Aint<[], []>;
def A1 : Aint<[?, 1, 2], ["a", "b", ?]>;

def A2 : Adag<[(ops $name), (ops 1), (ops "foo")], ["a", "b", "c"]>;

def NodeA0 : NodeA<0>;
def NodeB0 : NodeB<0>;

def A3 : Anode<[NodeA0, NodeB0], ["a", "b"]>;

def A4 {
  // Like A3, but with a literal list directly in the !dag.
  dag ret = !dag(ops, [NodeA0, NodeB0], ?);
}

def B0 : B<[]>;
def B1 : B<[Node<1, "a">, Node<2, "b">]>;

class C<list<int> nodes, list<string> names> {
  dag ret1 = !dag(ops, ?, names);
  dag ret2 = !dag(ops, nodes, ?);
}

def C0 : C<[1, 2], ["a", "b"]>;

def D {
  dag d1 = !con((ops 1), (ops $name1), (ops), (ops 2, 3));
}

class E<Ops op> {
  // Allow concatenation of DAG nodes with operators from template arguments.
  dag ret = !con((op 1), (op 2));
}

def E0 : E<ops>;