mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 11:13:28 +01:00
9a21ccd3ad
Summary: The new rules are straightforward. The main rules to keep in mind are: 1. NAME is an implicit template argument of class and multiclass, and will be substituted by the name of the instantiating def/defm. 2. The name of a def/defm in a multiclass must contain a reference to NAME. If such a reference is not present, it is automatically prepended. And for some additional subtleties, consider these: 3. defm with no name generates a unique name but has no special behavior otherwise. 4. def with no name generates an anonymous record, whose name is unique but undefined. In particular, the name won't contain a reference to NAME. Keeping rules 1&2 in mind should allow a predictable behavior of name resolution that is simple to follow. The old "rules" were rather surprising: sometimes (but not always), NAME would correspond to the name of the toplevel defm. They were also plain bonkers when you pushed them to their limits, as the old version of the TableGen test case shows. Having NAME correspond to the name of the toplevel defm introduces "spooky action at a distance" and breaks composability: refactoring the upper layers of a hierarchy of nested multiclass instantiations can cause unexpected breakage by changing the value of NAME at a lower level of the hierarchy. The new rules don't suffer from this problem. Some existing .td files have to be adjusted because they ended up depending on the details of the old implementation. Change-Id: I694095231565b30f563e6fd0417b41ee01a12589 Reviewers: tra, simon_tatham, craig.topper, MartinO, arsenm, javed.absar Subscribers: wdng, llvm-commits Differential Revision: https://reviews.llvm.org/D47430 llvm-svn: 333900
84 lines
1.6 KiB
TableGen
84 lines
1.6 KiB
TableGen
// RUN: llvm-tblgen %s | FileCheck %s
|
|
// XFAIL: vg_leak
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Substitution of an int.
|
|
def X1;
|
|
|
|
class C1<int N> {
|
|
dag d = (X1 N);
|
|
}
|
|
|
|
def VAL1 : C1<13>;
|
|
|
|
// CHECK: def VAL1 {
|
|
// CHECK-NEXT: dag d = (X1 13)
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Substitution of a DAG.
|
|
def X2;
|
|
|
|
class yclass;
|
|
def Y2 : yclass;
|
|
|
|
class C2<yclass N> {
|
|
dag d = (X2 N);
|
|
dag e = (N X2);
|
|
}
|
|
|
|
def VAL2 : C2<Y2>;
|
|
|
|
// CHECK: def VAL2 {
|
|
// CHECK-NEXT: dag d = (X2 Y2)
|
|
// CHECK-NEXT: dag e = (Y2 X2)
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Complex dag operator (F.TheOp).
|
|
|
|
class operator;
|
|
def somedef1 : operator;
|
|
def somedef2 : operator;
|
|
|
|
class foo<operator a> {
|
|
operator TheOp = a;
|
|
}
|
|
|
|
class bar<foo F, operator a> {
|
|
dag Dag1 = (somedef1 1);
|
|
dag Dag2 = (a 2);
|
|
dag Dag3 = (F.TheOp 2);
|
|
}
|
|
|
|
def foo1 : foo<somedef1>;
|
|
def foo2 : foo<somedef2>;
|
|
|
|
def VAL3 : bar<foo1, somedef1>;
|
|
|
|
// CHECK: def VAL3 { // bar
|
|
// CHECK-NEXT: dag Dag1 = (somedef1 1);
|
|
// CHECK-NEXT: dag Dag2 = (somedef1 2);
|
|
// CHECK-NEXT: dag Dag3 = (somedef1 2);
|
|
// CHECK-NEXT: }
|
|
|
|
|
|
def VAL4 : bar<foo2, somedef2>;
|
|
// CHECK: def VAL4 {
|
|
// CHECK-NEXT: dag Dag1 = (somedef1 1);
|
|
// CHECK-NEXT: dag Dag2 = (somedef2 2);
|
|
// CHECK-NEXT: dag Dag3 = (somedef2 2);
|
|
// CHECK-NEXT: }
|
|
|
|
def VAL5 : bar<foo2, somedef2> {
|
|
// Named operands.
|
|
let Dag1 = (somedef1 1:$name1);
|
|
|
|
// Name, no node.
|
|
let Dag2 = (somedef2 $name2, $name3);
|
|
}
|
|
|
|
// CHECK: def VAL5 {
|
|
// CHECK-NEXT: dag Dag1 = (somedef1 1:$name1);
|
|
// CHECK-NEXT: dag Dag2 = (somedef2 ?:$name2, ?:$name3);
|