298 lines · plain
1// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.0-compute -finclude-default-header %s -ast-dump | FileCheck %s2 3// Case 1: Template declaration with a call to an inout or out argument that is4// resolved based on the template parameter. For this case the template decl5// should have an UnresolvedLookupExpr for the call, and the HLSLOutArgExpr is6// built during call resolution.7 8// CHECK: FunctionDecl {{.*}} used fn 'void (inout int)'9void fn(inout int I) {10 I += 1;11}12 13// CHECK: FunctionDecl {{.*}} used fn 'void (out double)'14void fn(out double F) {15 F = 1.5;16}17 18// CHECK-LABEL: FunctionTemplateDecl {{.*}} wrapper19// CHECK-NEXT: TemplateTypeParmDecl {{.*}} referenced typename depth 0 index 0 T20 21// Verify that the template has an unresolved call.22// CHECK-NEXT: FunctionDecl {{.*}} wrapper 'T (T)'23// CHECK-NEXT: ParmVarDecl {{.*}} referenced V 'T'24// CHECK: CallExpr {{.*}} '<dependent type>'25// CHECK: UnresolvedLookupExpr {{.*}} '<overloaded function type>' lvalue (ADL) = 'fn'26 27// Verify that the int instantiation resolves an inout argument expression.28 29// CHECK-LABEL: FunctionDecl {{.*}} used wrapper 'int (int)' implicit_instantiation30// CHECK: CallExpr {{.*}} 'void'31// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(inout int)' <FunctionToPointerDecay>32// CHECK-NEXT: DeclRefExpr {{.*}} 'void (inout int)' lvalue Function {{.*}} 'fn' 'void (inout int)'33// CHECK-NEXT: HLSLOutArgExpr {{.*}} 'int' lvalue inout34 35// CHECK-NEXT: OpaqueValueExpr [[LVOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue36// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} 'V' 'int'37// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue38// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>39// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue40 41// CHECK: BinaryOperator {{.*}} 'int' lvalue '='42// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue43// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>44// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue45 46 47// Verify that the float instantiation has an out argument expression48// containing casts to and from double.49 50// CHECK-LABEL: FunctionDecl {{.*}} used wrapper 'float (float)' implicit_instantiation51// CHECK: CallExpr {{.*}} 'void'52// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(out double)' <FunctionToPointerDecay>53// CHECK-NEXT: DeclRefExpr {{.*}}'void (out double)' lvalue Function {{.*}} 'fn' 'void (out double)'54// CHECK-NEXT: HLSLOutArgExpr {{.*}} 'double' lvalue out55// CHECK-NEXT: OpaqueValueExpr [[LVOpV:0x[0-9a-fA-F]+]] {{.*}} 'float' lvalue56// CHECK-NEXT: DeclRefExpr {{.*}} 'float' lvalue ParmVar {{.*}} 'V' 'float'57// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'double' lvalue58// CHECK-NEXT: ImplicitCastExpr {{.*}} 'double' <FloatingCast>59// CHECK-NEXT: ImplicitCastExpr {{.*}} 'float' <LValueToRValue>60// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'float' lvalue61 62// CHECK: BinaryOperator {{.*}} 'float' lvalue '='63// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'float' lvalue64// CHECK: ImplicitCastExpr {{.*}} 'float' <FloatingCast>65// CHECK-NEXT: ImplicitCastExpr {{.*}} 'double' <LValueToRValue>66// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'double' lvalue67 68 69// Verify that the double instantiation is just an out expression.70 71// CHECK-LABEL: FunctionDecl {{.*}} used wrapper 'double (double)' implicit_instantiation72// CHECK: CallExpr {{.*}} 'void'73// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(out double)' <FunctionToPointerDecay>74// CHECK-NEXT: DeclRefExpr {{.*}}'void (out double)' lvalue Function {{.*}} 'fn' 'void (out double)'75// CHECK-NEXT: HLSLOutArgExpr {{.*}} 'double' lvalue out76// CHECK-NEXT: OpaqueValueExpr [[LVOpV:0x[0-9a-fA-F]+]] {{.*}} 'double' lvalue77// CHECK-NEXT: DeclRefExpr {{.*}} 'double' lvalue ParmVar {{.*}} 'V' 'double'78// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'double' lvalue79// CHECK-NEXT: ImplicitCastExpr {{.*}} 'double' <LValueToRValue>80// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'double' lvalue81 82// CHECK: BinaryOperator {{.*}} 'double' lvalue '='83// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'double' lvalue84// CHECK: ImplicitCastExpr {{.*}} 'double' <LValueToRValue>85// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'double' lvalue86 87template <typename T>88T wrapper(T V) {89 fn(V);90 return V;91}92 93// Case 2: Verify that the parameter modifier attribute is instantiated with the94// template (this one is a gimme).95 96// CHECK-LABEL: FunctionTemplateDecl {{.*}} fizz97 98// Check the pattern decl.99// CHECK: FunctionDecl {{.*}} fizz 'void (inout T)'100// CHECK-NEXT: ParmVarDecl {{.*}} referenced V 'T'101// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout102 103// Check the 3 instantiations (int, float, & double).104 105// CHECK-LABEL: FunctionDecl {{.*}} used fizz 'void (inout int)' implicit_instantiation106// CHECK: ParmVarDecl {{.*}} used V 'int &__restrict'107// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout108 109// CHECK-LABEL: FunctionDecl {{.*}} used fizz 'void (inout float)' implicit_instantiation110// CHECK: ParmVarDecl {{.*}} used V 'float &__restrict'111// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout112 113// CHECK-LABEL: FunctionDecl {{.*}} used fizz 'void (inout double)' implicit_instantiation114// CHECK: ParmVarDecl {{.*}} used V 'double &__restrict'115// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout116template <typename T>117void fizz(inout T V) {118 V += 2;119}120 121// Case 3: Verify that HLSLOutArgExpr nodes which are present in the template122// are correctly instantiated into the instantation.123 124// First we check that the AST node is in the template.125 126// CHECK-LABEL: FunctionTemplateDecl {{.*}} buzz127 128// CHECK: FunctionDecl {{.*}} buzz 'T (int, T)'129// CHECK: CallExpr {{.*}} 'void'130// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(inout int)' <FunctionToPointerDecay>131// CHECK-NEXT: DeclRefExpr {{.*}} 'void (inout int)' lvalue Function {{.*}} 'fn' 'void (inout int)'132// CHECK-NEXT: HLSLOutArgExpr {{.*}} 'int' lvalue inout133// CHECK-NEXT: OpaqueValueExpr [[LVOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue134// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} 'X' 'int'135// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue136// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>137// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue138// CHECK: BinaryOperator {{.*}} 'int' lvalue '='139// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue140// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>141// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue142 143 144 145// CHECK-LABEL: FunctionDecl {{.*}} used buzz 'int (int, int)' implicit_instantiation146// CHECK: CallExpr {{.*}} 'void'147// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(inout int)' <FunctionToPointerDecay>148// CHECK-NEXT: DeclRefExpr {{.*}} 'void (inout int)' lvalue Function {{.*}} 'fn' 'void (inout int)'149// CHECK-NEXT: HLSLOutArgExpr {{.*}} 'int' lvalue inout150// CHECK-NEXT: OpaqueValueExpr [[LVOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue151// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} 'X' 'int'152// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue153// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>154// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue155// CHECK: BinaryOperator {{.*}} 'int' lvalue '='156// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue157// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>158// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue159 160 161// CHECK-LABEL: FunctionDecl {{.*}} used buzz 'float (int, float)' implicit_instantiation162// CHECK: CallExpr {{.*}} 'void'163// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(inout int)' <FunctionToPointerDecay>164// CHECK-NEXT: DeclRefExpr {{.*}} 'void (inout int)' lvalue Function {{.*}} 'fn' 'void (inout int)'165// CHECK-NEXT: HLSLOutArgExpr {{.*}} 'int' lvalue inout166// CHECK-NEXT: OpaqueValueExpr [[LVOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue167// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} 'X' 'int'168// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue169// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>170// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue171// CHECK: BinaryOperator {{.*}} 'int' lvalue '='172// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue173// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>174// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue175 176 177// CHECK-LABEL: FunctionDecl {{.*}} used buzz 'double (int, double)' implicit_instantiation178// CHECK: CallExpr {{.*}} 'void'179// CHECK-NEXT: ImplicitCastExpr {{.*}} 'void (*)(inout int)' <FunctionToPointerDecay>180// CHECK-NEXT: DeclRefExpr {{.*}} 'void (inout int)' lvalue Function {{.*}} 'fn' 'void (inout int)'181// CHECK-NEXT: HLSLOutArgExpr {{.*}} 'int' lvalue inout182// CHECK-NEXT: OpaqueValueExpr [[LVOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue183// CHECK-NEXT: DeclRefExpr {{.*}} 'int' lvalue ParmVar {{.*}} 'X' 'int'184// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue185// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>186// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue187// CHECK: BinaryOperator {{.*}} 'int' lvalue '='188// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue189// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>190// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue191 192template <typename T>193T buzz(int X, T Y) {194 fn(X);195 return X + Y;196}197 198// Case 4: Verify that the parameter modifier attributes are instantiated 199// for both templated and non-templated arguments, and that the non-templated200// out argument type is not modified by the template instantiation.201 202// CHECK-LABEL: FunctionTemplateDecl {{.*}} fizz_two203 204// Check the pattern decl.205// CHECK: FunctionDecl {{.*}} fizz_two 'void (inout T, out int)'206// CHECK-NEXT: ParmVarDecl {{.*}} referenced V 'T'207// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout208// CHECK-NEXT: ParmVarDecl {{.*}} referenced I 'int &__restrict'209// CHECK-NEXT: HLSLParamModifierAttr {{.*}} out210 211// Check the 3 instantiations (int, float, & double).212 213// CHECK-LABEL: FunctionDecl {{.*}} used fizz_two 'void (inout int, out int)' implicit_instantiation214// CHECK: ParmVarDecl {{.*}} used V 'int &__restrict'215// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout216// CHECK: ParmVarDecl {{.*}} used I 'int &__restrict'217// CHECK-NEXT: HLSLParamModifierAttr {{.*}} out218 219// CHECK-LABEL: FunctionDecl {{.*}} used fizz_two 'void (inout float, out int)' implicit_instantiation220// CHECK: ParmVarDecl {{.*}} used V 'float &__restrict'221// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout222// CHECK: ParmVarDecl {{.*}} used I 'int &__restrict'223// CHECK-NEXT: HLSLParamModifierAttr {{.*}} out224 225// CHECK-LABEL: FunctionDecl {{.*}} used fizz_two 'void (inout double, out int)' implicit_instantiation226// CHECK: ParmVarDecl {{.*}} used V 'double &__restrict'227// CHECK-NEXT: HLSLParamModifierAttr {{.*}} inout228// CHECK: ParmVarDecl {{.*}} used I 'int &__restrict'229// CHECK-NEXT: HLSLParamModifierAttr {{.*}} out230template <typename T>231void fizz_two(inout T V, out int I) {232 V += 2;233 I = V;234}235 236// Case 5: Verify that `in` parameter modifier attributes are instantiated 237// for both templated and non-templated arguments and argument types are not238// modified239 240// CHECK-LABEL: FunctionTemplateDecl {{.*}} buzz_two241 242// Check the pattern decl.243// CHECK: FunctionDecl {{.*}} buzz_two 'int (T, int)'244// CHECK-NEXT: ParmVarDecl {{.*}} referenced A 'T'245// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in246// CHECK-NEXT: ParmVarDecl {{.*}} referenced B 'int'247// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in248 249// Check the 3 instantiations (int, float, & double).250 251// CHECK-LABEL: FunctionDecl {{.*}} used buzz_two 'int (int, int)' implicit_instantiation252// CHECK: ParmVarDecl {{.*}} used A 'int'253// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in254// CHECK: ParmVarDecl {{.*}} used B 'int'255// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in256 257// CHECK-LABEL: FunctionDecl {{.*}} used buzz_two 'int (float, int)' implicit_instantiation258// CHECK: ParmVarDecl {{.*}} used A 'float'259// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in260// CHECK: ParmVarDecl {{.*}} used B 'int'261// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in262 263// CHECK-LABEL: FunctionDecl {{.*}} used buzz_two 'int (double, int)' implicit_instantiation264// CHECK: ParmVarDecl {{.*}} used A 'double'265// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in266// CHECK: ParmVarDecl {{.*}} used B 'int'267// CHECK-NEXT: HLSLParamModifierAttr {{.*}} in268template <typename T>269int buzz_two(in T A, in int B) {270 return A + B;271}272 273export void caller() {274 int X = 2;275 float Y = 3.3;276 double Z = 2.2;277 278 X = wrapper(X);279 Y = wrapper(Y);280 Z = wrapper(Z);281 282 fizz(X);283 fizz(Y);284 fizz(Z);285 286 X = buzz(X, X);287 Y = buzz(X, Y);288 Z = buzz(X, Z);289 290 fizz_two(X, X);291 fizz_two(Y, X);292 fizz_two(Z, X);293 294 X = buzz_two(X, X);295 X = buzz_two(Y, X);296 X = buzz_two(Z, X);297}298