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
   6 #ifdef ERROR1
   7 // Refer to a variable we haven't defined *yet*, expecting an error.
   8 // ERROR1: [[@LINE+1]]:22: error: Variable not defined: 'myvar'
   9 def bad { dag x = (? myvar); }
  10 #endif
  11
  12 // Define a global variable.
  13 defvar myvar = "foo";
  14
  15 #ifdef ERROR2
  16 // Demonstrate an error when a global variable is redefined.
  17 // ERROR2: [[@LINE+1]]:8: error: def or global variable of this name already exists
  18 defvar myvar = "another value";
  19 #endif
  20
  21 multiclass Test<int x> {
  22   // Refer to a global variable, while inside a local scope like a multiclass.
  23   def _with_global_string { string s = myvar; }
  24
  25   // Define some variables local to this multiclass, and prove we can refer to
  26   // those too.
  27   defvar myvar = !add(x, 100);
  28   defvar myvar2 = "string of " # myvar;
  29   def _with_local_int { int i = myvar; string s = myvar2; }
  30
  31 #ifdef ERROR3
  32   // Demonstrate an error when a local variable is redefined.
  33   // ERROR3: [[@LINE+1]]:10: error: local variable of this name already exists
  34   defvar myvar = "another value";
  35 #endif
  36 }
  37
  38 // Instantiate the above multiclass, and expect all the right outputs.
  39
  40 // CHECK: def aaa_with_global_string {
  41 // CHECK-NEXT: string s = "foo";
  42 // CHECK: def aaa_with_local_int {
  43 // CHECK-NEXT: int i = 101;
  44 // CHECK-NEXT: string s = "string of 101";
  45 // CHECK: def bbb_with_global_string {
  46 // CHECK-NEXT: string s = "foo";
  47 // CHECK: def bbb_with_local_int {
  48 // CHECK-NEXT: int i = 102;
  49 // CHECK-NEXT: string s = "string of 102";
  50 defm aaa: Test<1>;
  51 defm bbb: Test<2>;
  52
  53 // Test that local variables can be defined inside a foreach block, and inside
  54 // an object body.
  55 //
  56 // The scopes nest (you can refer to variables in an outer block from an inner
  57 // one), and the variables go out of scope again at the end of the block (in
  58 // particular, you don't get a redefinition error the next time round the
  59 // loop).
  60
  61 // CHECK: def nest_f1_s3 {
  62 // CHECK-NEXT: int member = 113;
  63 // CHECK-NEXT: }
  64 // CHECK: def nest_f1_s4 {
  65 // CHECK-NEXT: int member = 114;
  66 // CHECK-NEXT: }
  67 // CHECK: def nest_f2_s3 {
  68 // CHECK-NEXT: int member = 123;
  69 // CHECK-NEXT: }
  70 // CHECK: def nest_f2_s4 {
  71 // CHECK-NEXT: int member = 124;
  72 // CHECK-NEXT: }
  73 foreach first = [ 1, 2 ] in {
  74   defvar firstStr = "f" # first;
  75   foreach second = [ 3, 4 ] in {
  76     defvar secondStr = "s" # second;
  77     def "nest_" # firstStr # "_" # secondStr {
  78       defvar defLocalVariable = !add(!mul(first, 10), second);
  79       int member = !add(100, defLocalVariable);
  80     }
  81   }
  82 }
  83 defvar firstStr = "now define this at the top level and still expect no error";
  84
  85 // Test that you can shadow an outer declaration with an inner one. Here, we
  86 // expect all the shadowOuter records (both above and below the inner foreach)
  87 // to get the value 1 from the outer definition of shadowedVariable, and the
  88 // shadowInner ones to get 2 from the inner definition.
  89
  90 // CHECK: def shadowInner11 {
  91 // CHECK-NEXT: int var = 2;
  92 // CHECK: def shadowInner12 {
  93 // CHECK-NEXT: int var = 2;
  94 // CHECK: def shadowInner21 {
  95 // CHECK-NEXT: int var = 2;
  96 // CHECK: def shadowInner22 {
  97 // CHECK-NEXT: int var = 2;
  98 // CHECK: def shadowInnerIf1 {
  99 // CHECK-NEXT: int var = 3;
 100 // CHECK: def shadowOuterAbove1 {
 101 // CHECK-NEXT: int var = 1;
 102 // CHECK: def shadowOuterAbove2 {
 103 // CHECK-NEXT: int var = 1;
 104 // CHECK: def shadowOuterBelowForeach1 {
 105 // CHECK-NEXT: int var = 1;
 106 // CHECK: def shadowOuterBelowForeach2 {
 107 // CHECK-NEXT: int var = 1;
 108 // CHECK: def shadowOuterBelowIf1 {
 109 // CHECK-NEXT: int var = 1;
 110 // CHECK: def shadowOuterBelowIf2 {
 111 // CHECK-NEXT: int var = 1;
 112
 113 foreach first = [ 1, 2 ] in {
 114   defvar shadowedVariable = 1;
 115   def shadowOuterAbove # first { int var = shadowedVariable; }
 116
 117   // The foreach statement opens a new scope, in which a new variable of the
 118   // same name can be defined without clashing with the outer one.
 119   foreach second = [ 1, 2 ] in {
 120     defvar shadowedVariable = 2;
 121     def shadowInner # first # second { int var = shadowedVariable; }
 122   }
 123
 124   // Now the outer variable is back in scope.
 125   def shadowOuterBelowForeach # first { int var = shadowedVariable; }
 126
 127   // An if statement also opens a new scope.
 128   if !eq(first, 1) then {
 129     defvar shadowedVariable = 3;
 130     def shadowInnerIf # first { int var = shadowedVariable; }
 131   }
 132
 133   // Now the outer variable is back in scope again.
 134   def shadowOuterBelowIf # first { int var = shadowedVariable; }
 135 }
 136
 137 // Test that a top-level let statement also makes a variable scope (on the
 138 // general principle of consistency, because it defines a braced sub-block).
 139
 140 let someVariable = "some value" in {
 141   defvar myvar = "override the definition from above and expect no error";
 142 }
 143 // CHECK: def topLevelLetTest {
 144 // CHECK-NEXT: string val = "foo";
 145 def topLevelLetTest { string val = myvar; }