Repurpose replaceExtractElementTypeOfCallUsages to replace InsertValueInsts as well

- Renamed replaceExtractElementTypeOfCallUsages to replaceAggregateTypeOfCallUsages and made it replace uses of InsertValueInsts in addition to ExtractValueInst
  - Added a test case to UAddc_errors.ll to ensure there are no other uses, and emit an error if so
  - Added a test case to UAddc.ll to test the replacement of InsertValueInsts

- Removed the check on the number of indices, as this is error case is already handled. (It would be invalid LLVM IR.) This also makes the function more generally applicable in case another function would like to use it

Author: Icohedron

llvm/lib/Target/DirectX/DXILOpLowering.cpp

@@ -359,21 +359,17 @@ class OpLowerer {
     return lowerToBindAndAnnotateHandle(F);
   }
 
-  Error replaceExtractElementTypeOfCallUsages(CallInst *Intrin, CallInst *Op) {
+  Error replaceAggregateTypeOfCallUsages(CallInst *Intrin, CallInst *Op) {
     for (Use &U : make_early_inc_range(Intrin->uses())) {
       if (auto *EVI = dyn_cast<ExtractValueInst>(U.getUser())) {
-
-        if (EVI->getNumIndices() != 1)
-          return createStringError(
-              std::errc::invalid_argument,
-              (std::string(Intrin->getOpcodeName()) + " has only 2 elements")
-                  .c_str());
         EVI->setOperand(0, Op);
+      } else if (auto *IVI = dyn_cast<InsertValueInst>(U.getUser())) {
+        IVI->setOperand(0, Op);
       } else {
-        return make_error<StringError>((std::string(Intrin->getOpcodeName()) +
-                                        " use is not ExtractValueInst")
-                                           .c_str(),
-                                       inconvertibleErrorCode());
+        return make_error<StringError>(
+            (Intrin->getCalledFunction()->getName() +
+             " use is not a ExtractValueInst or InsertValueInst"),
+            inconvertibleErrorCode());
       }
     }
 
@@ -824,7 +820,7 @@ class OpLowerer {
             F, OpCode::SplitDouble,
             OpBuilder.getSplitDoubleType(M.getContext()),
             [&](CallInst *CI, CallInst *Op) {
-              return replaceExtractElementTypeOfCallUsages(CI, Op);
+              return replaceAggregateTypeOfCallUsages(CI, Op);
             });
         break;
       // TODO: this can be removed when
@@ -833,7 +829,7 @@ class OpLowerer {
         HasErrors |= replaceFunctionWithNamedStructOp(
             F, OpCode::UAddc, OpBuilder.getBinaryWithCarryType(M.getContext()),
             [&](CallInst *CI, CallInst *Op) {
-              return replaceExtractElementTypeOfCallUsages(CI, Op);
+              return replaceAggregateTypeOfCallUsages(CI, Op);
             });
         break;
       case Intrinsic::ctpop:

llvm/test/CodeGen/DirectX/UAddc.ll

@@ -20,6 +20,21 @@ define noundef i32 @test_UAddc(i32 noundef %a, i32 noundef %b) {
   ret i32 %result
 }
 
+
+define noundef i32 @test_UAddc_insert(i32 noundef %a, i32 noundef %b) {
+; CHECK-LABEL: define noundef i32 @test_UAddc_insert(
+; CHECK-SAME: i32 noundef [[A:%.*]], i32 noundef [[B:%.*]]) {
+; CHECK-NEXT:    [[UAddc:%.*]] = call %dx.types.i32c @dx.op.binaryWithCarryOrBorrow.i32(i32 44, i32 [[A]], i32 [[B]])
+; CHECK-NEXT:    insertvalue %dx.types.i32c [[UAddc]], i32 [[A]], 0
+; CHECK-NEXT:    [[Result:%.*]] = extractvalue %dx.types.i32c [[UAddc]], 0
+; CHECK-NEXT:    ret i32 [[Result]]
+; 
+  %uaddc = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
+  insertvalue { i32, i1 } %uaddc, i32 %a, 0
+  %result = extractvalue { i32, i1 } %uaddc, 0
+  ret i32 %result
+}
+
 declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32)
 ; CHECK: declare %dx.types.i32c @dx.op.binaryWithCarryOrBorrow.i32(i32, i32, i32)
 

llvm/test/CodeGen/DirectX/UAddc_errors.ll

@@ -1,10 +1,14 @@
-; RUN: not opt -S -dxil-op-lower -mtriple=dxil-pc-shadermodel6.3-library %s 2>&1 | FileCheck %s
+; We use llc for this test so that we don't abort after the first error.
+; RUN: not llc %s -o /dev/null 2>&1 | FileCheck %s
+
+target triple = "dxil-pc-shadermodel6.3-library"
 
 ; DXIL operation UAddc only supports i32. Other integer types are unsupported.
-; CHECK: in function uaddc_i16
+; CHECK: error:
+; CHECK-SAME: in function uaddc_i16
 ; CHECK-SAME: Cannot create UAddc operation: Invalid overload type
 
-define noundef i16 @uaddc_i16(i16 noundef %a, i16 noundef %b) {
+define noundef i16 @uaddc_i16(i16 noundef %a, i16 noundef %b) "hlsl.export" {
   %uaddc = call { i16, i1 } @llvm.uadd.with.overflow.i16(i16 %a, i16 %b)
   %carry = extractvalue { i16, i1 } %uaddc, 1
   %sum = extractvalue { i16, i1 } %uaddc, 0
@@ -13,5 +17,14 @@ define noundef i16 @uaddc_i16(i16 noundef %a, i16 noundef %b) {
   ret i16 %result
 }
 
+; CHECK: error:
+; CHECK-SAME: in function uaddc_return
+; CHECK-SAME: llvm.uadd.with.overflow.i32 use is not a ExtractValueInst or InsertValueInst
+
+define noundef { i32, i1 } @uaddc_return(i32 noundef %a, i32 noundef %b) "hlsl.export" {
+  %uaddc = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 %a, i32 %b)
+  ret { i32, i1 } %uaddc
+}
+
 declare { i16, i1 } @llvm.uadd.with.overflow.i16(i16, i16)