Skip to content

Commit 5f7e351

Browse files
llvm-beanzllvm-beanz
committed
Fixed ActOnBinOp
1 parent a529de0 commit 5f7e351

File tree

4 files changed

+26
-21
lines changed

4 files changed

+26
-21
lines changed

‎clang/lib/CodeGen/CGCall.cpp

Lines changed: 1 addition & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -4136,22 +4136,7 @@ static void emitWriteback(CodeGenFunction &CGF,
41364136
"shouldn't have writeback for provably null argument");
41374137

41384138
if (CGF.getLangOpts().HLSL) {
4139-
assert(!srcLV.isMatrixElt() &&
4140-
"Matrix element expressions not yet supported.");
4141-
assert((srcLV.isSimple() || srcLV.isBitField() || srcLV.isExtVectorElt()) &&
4142-
"Argument expressions should only be simple, bitfield, or "
4143-
"vector/matrix element expressions.");
4144-
// For vector element or bitfield lvalues, we need to emit the store through
4145-
// the lvalue, otherwise we won't get the correct component masking. This
4146-
// will also need to be used for matrices once we support them.
4147-
if (srcLV.isExtVectorElt() || srcLV.isBitField()) {
4148-
RValue TmpVal = CGF.EmitAnyExprToTemp(writeback.CastExpr);
4149-
assert(TmpVal.isScalar() &&
4150-
"a vector lvalue sould only be assigned from a scalar rvalue.");
4151-
CGF.EmitStoreThroughLValue(TmpVal, srcLV);
4152-
} else
4153-
CGF.EmitAnyExprToMem(writeback.CastExpr, srcLV.getAddress(),
4154-
writeback.CastExpr->getType().getQualifiers(), true);
4139+
CGF.EmitIgnoredExpr(writeback.CastExpr);
41554140

41564141
if (writeback.LifetimeSz)
41574142
CGF.EmitLifetimeEnd(writeback.LifetimeSz,

‎clang/lib/Sema/SemaHLSL.cpp

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1218,6 +1218,8 @@ ExprResult SemaHLSL::ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg) {
12181218
auto *ArgOpV = new (Ctx) OpaqueValueExpr(Param->getBeginLoc(), Arg->getType(),
12191219
VK_LValue, OK_Ordinary, Arg);
12201220

1221+
// Parameters are initialized via copy initialization. This allows for
1222+
// overload resolution of argument constructors.
12211223
InitializedEntity Entity =
12221224
InitializedEntity::InitializeParameter(Ctx, Ty, false);
12231225
ExprResult Res =
@@ -1230,10 +1232,10 @@ ExprResult SemaHLSL::ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg) {
12301232
auto *OpV = new (Ctx)
12311233
OpaqueValueExpr(Param->getBeginLoc(), Ty, VK_LValue, OK_Ordinary, Base);
12321234

1233-
// TODO: Revisit this to use ActOnBinOp so that writebacks are assignments.
1234-
Entity =
1235-
InitializedEntity::InitializeParameter(Ctx, Arg->getType(), false);
1236-
Res = SemaRef.PerformCopyInitialization(Entity, Param->getBeginLoc(), OpV);
1235+
// Writebacks are performed with `=` binary operator, which allows for
1236+
// overload resolution on writeback result expressions.
1237+
Res = SemaRef.ActOnBinOp(SemaRef.getCurScope(), Param->getBeginLoc(),
1238+
tok::equal, ArgOpV, OpV);
12371239

12381240
if (Res.isInvalid())
12391241
return ExprError();

‎clang/test/AST/HLSL/OutArgExpr.hlsl

Lines changed: 4 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -43,6 +43,8 @@ void zero(out int Z) { Z = 0; }
4343
// AST-NEXT: ImplicitCastExpr {{.*}} 'float' <LValueToRValue>
4444
// AST-NEXT: OpaqueValueExpr [[LVOpV]] <col:15, col:21> 'float' lvalue
4545

46+
// AST: BinaryOperator {{.*}} 'float' lvalue '='
47+
// AST-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'float' lvalue
4648
// AST: ImplicitCastExpr {{.*}} 'float' <IntegralToFloating>
4749
// AST-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
4850
// AST-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue
@@ -68,7 +70,8 @@ void fn(uint GI) {
6870
// AST-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
6971
// AST-NEXT: OpaqueValueExpr [[LVOpV]] <col:8> 'int' lvalue
7072

71-
73+
// AST: BinaryOperator {{.*}} 'int' lvalue '='
74+
// AST-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
7275
// AST: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
7376
// AST-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue
7477

‎clang/test/SemaHLSL/Language/TemplateOutArg.hlsl

Lines changed: 15 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -38,6 +38,8 @@ void fn(out double F) {
3838
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
3939
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
4040

41+
// CHECK: BinaryOperator {{.*}} 'int' lvalue '='
42+
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
4143
// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
4244
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue
4345

@@ -56,6 +58,9 @@ void fn(out double F) {
5658
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'double' <FloatingCast>
5759
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'float' <LValueToRValue>
5860
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'float' lvalue
61+
62+
// CHECK: BinaryOperator {{.*}} 'float' lvalue '='
63+
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'float' lvalue
5964
// CHECK: ImplicitCastExpr {{.*}} 'float' <FloatingCast>
6065
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'double' <LValueToRValue>
6166
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'double' lvalue
@@ -74,6 +79,8 @@ void fn(out double F) {
7479
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'double' <LValueToRValue>
7580
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'double' lvalue
7681

82+
// CHECK: BinaryOperator {{.*}} 'double' lvalue '='
83+
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'double' lvalue
7784
// CHECK: ImplicitCastExpr {{.*}} 'double' <LValueToRValue>
7885
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'double' lvalue
7986

@@ -128,6 +135,8 @@ void fizz(inout T V) {
128135
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue
129136
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
130137
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
138+
// CHECK: BinaryOperator {{.*}} 'int' lvalue '='
139+
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
131140
// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
132141
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue
133142

@@ -143,6 +152,8 @@ void fizz(inout T V) {
143152
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue
144153
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
145154
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
155+
// CHECK: BinaryOperator {{.*}} 'int' lvalue '='
156+
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
146157
// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
147158
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue
148159

@@ -157,6 +168,8 @@ void fizz(inout T V) {
157168
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue
158169
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
159170
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
171+
// CHECK: BinaryOperator {{.*}} 'int' lvalue '='
172+
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
160173
// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
161174
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue
162175

@@ -171,6 +184,8 @@ void fizz(inout T V) {
171184
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV:0x[0-9a-fA-F]+]] {{.*}} 'int' lvalue
172185
// CHECK-NEXT: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
173186
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
187+
// CHECK: BinaryOperator {{.*}} 'int' lvalue '='
188+
// CHECK-NEXT: OpaqueValueExpr [[LVOpV]] {{.*}} 'int' lvalue
174189
// CHECK: ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
175190
// CHECK-NEXT: OpaqueValueExpr [[TmpOpV]] {{.*}} 'int' lvalue
176191

0 commit comments

Comments
 (0)