llvm/test/TableGen/defvar.td

   1 // RUN: llvm-tblgen %s | FileCheck %s
   2 // RUN: not llvm-tblgen -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s
   3 // RUN: not llvm-tblgen -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s
   4 // RUN: not llvm-tblgen -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s
   5 // RUN: not llvm-tblgen -DERROR4 %s 2>&1 | FileCheck --check-prefix=ERROR4 %s
   6 // RUN: not llvm-tblgen -DERROR5 %s 2>&1 | FileCheck --check-prefix=ERROR5 %s
   7
   8 #ifdef ERROR1
   9 // Refer to a variable we haven't defined *yet*, expecting an error.
  10 // ERROR1: [[@LINE+1]]:22: error: Variable not defined: 'myvar'
  11 def bad { dag x = (? myvar); }
  12 #endif
  13
  14 // Define a global variable.
  15 defvar myvar = "foo";
  16
  17 #ifdef ERROR2
  18 // Demonstrate an error when a global variable is redefined.
  19 // ERROR2: [[@LINE+1]]:8: error: def or global variable of this name already exists
  20 defvar myvar = "another value";
  21 #endif
  22
  23 multiclass Test<int x> {
  24   // Refer to a global variable, while inside a local scope like a multiclass.
  25   def _with_global_string { string s = myvar; }
  26
  27   // Define some variables local to this multiclass, and prove we can refer to
  28   // those too.
  29   defvar myvar = !add(x, 100);
  30   defvar myvar2 = "string of " # myvar;
  31   def _with_local_int { int i = myvar; string s = myvar2; }
  32
  33 #ifdef ERROR3
  34   // Demonstrate an error when a local variable is redefined.
  35   // ERROR3: [[@LINE+1]]:10: error: local variable of this name already exists
  36   defvar myvar = "another value";
  37 #endif
  38 }
  39
  40 // Instantiate the above multiclass, and expect all the right outputs.
  41
  42 // CHECK: def aaa_with_global_string {
  43 // CHECK-NEXT: string s = "foo";
  44 // CHECK: def aaa_with_local_int {
  45 // CHECK-NEXT: int i = 101;
  46 // CHECK-NEXT: string s = "string of 101";
  47 // CHECK: def bbb_with_global_string {
  48 // CHECK-NEXT: string s = "foo";
  49 // CHECK: def bbb_with_local_int {
  50 // CHECK-NEXT: int i = 102;
  51 // CHECK-NEXT: string s = "string of 102";
  52 defm aaa: Test<1>;
  53 defm bbb: Test<2>;
  54
  55 // Test that local variables can be defined inside a foreach block, and inside
  56 // an object body.
  57 //
  58 // The scopes nest (you can refer to variables in an outer block from an inner
  59 // one), and the variables go out of scope again at the end of the block (in
  60 // particular, you don't get a redefinition error the next time round the
  61 // loop).
  62
  63 // CHECK: def nest_f1_s3 {
  64 // CHECK-NEXT: int member = 113;
  65 // CHECK-NEXT: }
  66 // CHECK: def nest_f1_s4 {
  67 // CHECK-NEXT: int member = 114;
  68 // CHECK-NEXT: }
  69 // CHECK: def nest_f2_s3 {
  70 // CHECK-NEXT: int member = 123;
  71 // CHECK-NEXT: }
  72 // CHECK: def nest_f2_s4 {
  73 // CHECK-NEXT: int member = 124;
  74 // CHECK-NEXT: }
  75 foreach first = [ 1, 2 ] in {
  76   defvar firstStr = "f" # first;
  77   foreach second = [ 3, 4 ] in {
  78     defvar secondStr = "s" # second;
  79     def "nest_" # firstStr # "_" # secondStr {
  80       defvar defLocalVariable = !add(!mul(first, 10), second);
  81       int member = !add(100, defLocalVariable);
  82     }
  83   }
  84 }
  85 defvar firstStr = "now define this at the top level and still expect no error";
  86
  87 // Test that you can shadow an outer declaration with an inner one. Here, we
  88 // expect all the shadowOuter records (both above and below the inner foreach)
  89 // to get the value 1 from the outer definition of shadowedVariable, and the
  90 // shadowInner ones to get 2 from the inner definition.
  91
  92 // CHECK: def shadowInner11 {
  93 // CHECK-NEXT: int var = 2;
  94 // CHECK: def shadowInner12 {
  95 // CHECK-NEXT: int var = 2;
  96 // CHECK: def shadowInner21 {
  97 // CHECK-NEXT: int var = 2;
  98 // CHECK: def shadowInner22 {
  99 // CHECK-NEXT: int var = 2;
 100 // CHECK: def shadowInnerIf1 {
 101 // CHECK-NEXT: int var = 3;
 102 // CHECK: def shadowOuterAbove1 {
 103 // CHECK-NEXT: int var = 1;
 104 // CHECK: def shadowOuterAbove2 {
 105 // CHECK-NEXT: int var = 1;
 106 // CHECK: def shadowOuterBelowForeach1 {
 107 // CHECK-NEXT: int var = 1;
 108 // CHECK: def shadowOuterBelowForeach2 {
 109 // CHECK-NEXT: int var = 1;
 110 // CHECK: def shadowOuterBelowIf1 {
 111 // CHECK-NEXT: int var = 1;
 112 // CHECK: def shadowOuterBelowIf2 {
 113 // CHECK-NEXT: int var = 1;
 114
 115 foreach first = [ 1, 2 ] in {
 116   defvar shadowedVariable = 1;
 117   def shadowOuterAbove # first { int var = shadowedVariable; }
 118
 119   // The foreach statement opens a new scope, in which a new variable of the
 120   // same name can be defined without clashing with the outer one.
 121   foreach second = [ 1, 2 ] in {
 122     defvar shadowedVariable = 2;
 123     def shadowInner # first # second { int var = shadowedVariable; }
 124   }
 125
 126   // Now the outer variable is back in scope.
 127   def shadowOuterBelowForeach # first { int var = shadowedVariable; }
 128
 129   // An if statement also opens a new scope.
 130   if !eq(first, 1) then {
 131     defvar shadowedVariable = 3;
 132     def shadowInnerIf # first { int var = shadowedVariable; }
 133   }
 134
 135   // Now the outer variable is back in scope again.
 136   def shadowOuterBelowIf # first { int var = shadowedVariable; }
 137 }
 138
 139 class RedefinitionTest<int a, int b> {
 140   #ifdef ERROR4
 141   defvar value = !add(a, b);
 142   #endif
 143   // ERROR4: [[@LINE+1]]:7: error: local variable of this name already exists
 144   int value = !add(a, b);
 145   #ifdef ERROR5
 146   // ERROR5: [[@LINE+1]]:10: error: field of this name already exists
 147   defvar value = !add(a, b);
 148   #endif
 149 }
 150
 151 // These variables should be shadowed by class/multiclass template arguments.
 152 defvar a = 2333;
 153 defvar b = 2333;
 154 defvar c = 2333;
 155 class ShadowGlobalsTest<int a, int b, int c> {
 156   // Template arguments have higher priorities than global variables.
 157   int value = !add(a, b, c);
 158 }
 159
 160 class ShadowClassArgumentTest<int a, int b, int c> {
 161   // Local variable 'c' has higher priority than class template argument 'c'.
 162   defvar c = !add(c, c);
 163   int value = !add(a, b, c);
 164 }
 165
 166 multiclass ShadowMulticlassArgumentTest<int a, int b, int c> {
 167   // Local variable 'c' has higher priority than multiclass template argument 'c'.
 168   defvar c = !add(c, c);
 169   def "" {
 170     int value = !add(a, b, c);
 171   }
 172 }
 173
 174 // CHECK: def shadowTestOfClassArgument {
 175 // CHECK-NEXT: int value = 11;
 176 // CHECK: def shadowTestOfGlobals {
 177 // CHECK-NEXT: int value = 8;
 178 // CHECK: def shadowTestOfLoopIterator0 {
 179 // CHECK-NEXT: int value = 10;
 180 // CHECK: def shadowTestOfLoopIterator1 {
 181 // CHECK-NEXT: int value = 11;
 182 // CHECK: def shadowTestOfMulticlassArgument {
 183 // CHECK-NEXT: int value = 11;
 184 def shadowTestOfClassArgument: ShadowClassArgumentTest<2, 3, 3>;
 185 def shadowTestOfGlobals: ShadowGlobalsTest<2, 3, 3>;
 186 foreach i = 0...1 in {
 187   // Local variable 'i' has higher priority than loop iterator 'i'.
 188   def shadowTestOfLoopIterator # i {
 189     defvar i = !add(10, i);
 190     int value = i;
 191   }
 192 }
 193 defm shadowTestOfMulticlassArgument: ShadowMulticlassArgumentTest<2, 3, 3>;
 194
 195 // Test that a top-level let statement also makes a variable scope (on the
 196 // general principle of consistency, because it defines a braced sub-block).
 197
 198 let someVariable = "some value" in {
 199   defvar myvar = "override the definition from above and expect no error";
 200 }
 201 // CHECK: def topLevelLetTest {
 202 // CHECK-NEXT: string val = "foo";
 203 def topLevelLetTest { string val = myvar; }