204 lines · plain
1// RUN: llvm-tblgen %s | FileCheck %s2// RUN: not llvm-tblgen -DERROR1 %s 2>&1 | FileCheck --check-prefix=ERROR1 %s3// RUN: not llvm-tblgen -DERROR2 %s 2>&1 | FileCheck --check-prefix=ERROR2 %s4// RUN: not llvm-tblgen -DERROR3 %s 2>&1 | FileCheck --check-prefix=ERROR3 %s5// RUN: not llvm-tblgen -DERROR4 %s 2>&1 | FileCheck --check-prefix=ERROR4 %s6// RUN: not llvm-tblgen -DERROR5 %s 2>&1 | FileCheck --check-prefix=ERROR5 %s7 8#ifdef ERROR19// Refer to a variable we haven't defined *yet*, expecting an error.10// ERROR1: [[@LINE+1]]:22: error: Variable not defined: 'myvar'11def bad { dag x = (? myvar); }12#endif13 14// Define a global variable.15defvar myvar = "foo";16 17#ifdef ERROR218// Demonstrate an error when a global variable is redefined.19// ERROR2: [[@LINE+1]]:8: error: def or global variable of this name already exists20defvar myvar = "another value";21#endif22 23multiclass 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 to28 // 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 ERROR334 // Demonstrate an error when a local variable is redefined.35 // ERROR3: [[@LINE+1]]:10: error: local variable of this name already exists36 defvar myvar = "another value";37#endif38}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";52defm aaa: Test<1>;53defm bbb: Test<2>;54 55// Test that local variables can be defined inside a foreach block, and inside56// an object body.57//58// The scopes nest (you can refer to variables in an outer block from an inner59// one), and the variables go out of scope again at the end of the block (in60// particular, you don't get a redefinition error the next time round the61// 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: }75foreach 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}85defvar 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, we88// 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 the90// 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 115foreach 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 the120 // 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 139class RedefinitionTest<int a, int b> {140 #ifdef ERROR4141 defvar value = !add(a, b);142 #endif143 // ERROR4: [[@LINE+1]]:7: error: local variable of this name already exists144 int value = !add(a, b);145 #ifdef ERROR5146 // ERROR5: [[@LINE+1]]:10: error: field of this name already exists147 defvar value = !add(a, b);148 #endif149}150 151// These variables should be shadowed by class/multiclass template arguments.152defvar a = 2333;153defvar b = 2333;154defvar c = 2333;155class 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 160class 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 166multiclass 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;184def shadowTestOfClassArgument: ShadowClassArgumentTest<2, 3, 3>;185def shadowTestOfGlobals: ShadowGlobalsTest<2, 3, 3>;186foreach 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}193defm shadowTestOfMulticlassArgument: ShadowMulticlassArgumentTest<2, 3, 3>;194 195// Test that a top-level let statement also makes a variable scope (on the196// general principle of consistency, because it defines a braced sub-block).197 198let 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";203def topLevelLetTest { string val = myvar; }204