[DirectX] [Scalarizer] Validator is erroring with Instructions must be of an allowed type.

[farzonl]

We are generating code that looks like this:

  %43 = bitcast i64 %42 to <2 x i32>
  %44 = extractelement <2 x i32> %43, i32 0
  %45 = extractelement <2 x i32> %43, i32 1

There are 160 errors that look just like this. In all cases it is an extractelement <2 x i32> we emit the error for both index extractions.

The code is coming from the InstCombinePass

This appears to be a bug in the scalarizer missing the scalarization of the bitcast:

1. running scalarizer with insertelement: https://godbolt.org/z/6aExzxdPM
2. running scalarizer with bitcast: https://godbolt.org/z/s8fb7936E

The fix likely needs to be in:

llvm-project/llvm/lib/Transforms/Scalar/Scalarizer.cpp

Line 932 in 73ca116

bool ScalarizerVisitor::visitBitCastInst(BitCastInst &BCI) {

The issue is this InstCombinePass is trying to split an i64 into its low and high half. A quick hack to confirm this fixes all cases would be to convert

%bc = bitcast i64 %42 to <2 x i32>
%low = extractelement <2 x i32> %bc, i32 0 ; low 32 bits
%high = extractelement <2 x i32> %bc, i32 1 ; high 32 bits

to

%low  = trunc i64 %42 to i32
%high = lshr i64 %42, 32
%high = trunc i64 %high to i32

We can test this out this fix via the legalizer.

diff --git a/llvm/lib/Target/DirectX/DXILLegalizePass.cpp b/llvm/lib/Target/DirectX/DXILLegalizePass.cpp
index be77a70fa46b..46cbb53debfa 100644
--- a/llvm/lib/Target/DirectX/DXILLegalizePass.cpp
+++ b/llvm/lib/Target/DirectX/DXILLegalizePass.cpp
@@ -8,6 +8,8 @@
 
 #include "DXILLegalizePass.h"
 #include "DirectX.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstIterator.h"
@@ -317,6 +319,47 @@ static void removeMemSet(Instruction &I,
   ToRemove.push_back(CI);
 }
 
+static void
+legalizeGetHighLowi64Bytes(Instruction &I,
+                            SmallVectorImpl<Instruction *> &ToRemove,
+                            DenseMap<Value *, Value *> &ReplacedValues) {
+  if (auto *BitCast = dyn_cast<BitCastInst>(&I)) {
+    if (BitCast->getDestTy() ==
+            FixedVectorType::get(Type::getInt32Ty(I.getContext()), 2) &&
+        BitCast->getSrcTy()->isIntegerTy(64)) {
+      ToRemove.push_back(BitCast);
+      ReplacedValues[BitCast] = BitCast->getOperand(0);
+    }
+  }
+
+  if (auto *Extract = dyn_cast<ExtractElementInst>(&I)) {
+    auto *VecTy = dyn_cast<FixedVectorType>(Extract->getVectorOperandType());
+    if (VecTy && VecTy->getElementType()->isIntegerTy(32) &&
+        VecTy->getNumElements() == 2) {
+      if (auto *Index = dyn_cast<ConstantInt>(Extract->getIndexOperand())) {
+        unsigned Idx = Index->getZExtValue();
+        IRBuilder<> Builder(&I);
+        assert(dyn_cast<BitCastInst>(Extract->getVectorOperand()));
+        auto *Replacement = ReplacedValues[Extract->getVectorOperand()];
+        if (Idx == 0) {
+          Value *LowBytes = Builder.CreateTrunc(
+              Replacement, Type::getInt32Ty(I.getContext()));
+          ReplacedValues[Extract] = LowBytes;
+        } else {
+          assert(Idx == 1);
+          Value *LogicalShiftRight = Builder.CreateLShr(
+              Replacement,
+              ConstantInt::get(Replacement->getType(),
+                              APInt(Replacement->getType()->getIntegerBitWidth(), 32)));
+          Value *HighBytes = Builder.CreateTrunc(
+              LogicalShiftRight, Type::getInt32Ty(I.getContext()));
+          ReplacedValues[Extract] = HighBytes;
+        }
+        ToRemove.push_back(Extract);
+      }
+    }
+  }
+}
 namespace {
 class DXILLegalizationPipeline {
 
@@ -349,6 +391,7 @@ private:
     LegalizationPipeline.push_back(downcastI64toI32InsertExtractElements);
     LegalizationPipeline.push_back(legalizeFreeze);
     LegalizationPipeline.push_back(removeMemSet);
+    LegalizationPipeline.push_back(legalizeGetHighLowi64Bytes);

[farzonl]

The first time i'm seeing this pattern of representing an int64 as a vec2 of i32 is in the AlwaysInlinerPass The previous pass SimplifyCFGPass has _Z6CSMainDv3_j and _GLOBAL__sub_I_Philox_Int64_256_4.hlsl that need to be investigated.

; *** IR Dump After SimplifyCFGPass on CSMain ***
; Function Attrs: convergent noinline norecurse
define void @CSMain() local_unnamed_addr #7 {
  call fastcc void @_GLOBAL__sub_I_Philox_Int64_256_4.hlsl()
  %1 = call i32 @llvm.dx.thread.id(i32 0)
  %2 = insertelement <3 x i32> poison, i32 %1, i64 0
  %3 = call i32 @llvm.dx.thread.id(i32 1)
  %4 = insertelement <3 x i32> %2, i32 %3, i64 1
  %5 = call i32 @llvm.dx.thread.id(i32 2)
  %6 = insertelement <3 x i32> %4, i32 %5, i64 2
  call fastcc void @_Z6CSMainDv3_j(<3 x i32> %6)
  ret void

you should be able to get the same results via

clang-dxc DirectML/Product/Shaders/Generated/Philox_Int64_256_4.hlsl -E CSMain -T cs_6_0   -O3 -D DXC_COMPILER=1 -D __SHADER_TARGET_MAJOR=6 -D __SHADER_TARGET_MINOR=0 -I  DirectML/Product/Shaders/ -Xclang -emit-llvm -mllvm --print-after-all -mllvm -filter-print-funcs=CSMain 2> extractelement.ll

[farzonl]

This looks to be a result of the InstCombinePass pass

Before InstCombinePass

; *** IR Dump After PromotePass on _Z7MulLoHijj ***
; Function Attrs: alwaysinline convergent mustprogress norecurse nounwind
define noundef <2 x i32> @_Z7MulLoHijj(i32 noundef %0, i32 noundef %1) local_unnamed_addr #1 {
  %3 = zext i32 %0 to i64
  %4 = zext i32 %1 to i64
  %5 = mul nuw i64 %3, %4
  %6 = trunc i64 %5 to i32
  %7 = insertelement <2 x i32> undef, i32 %6, i32 0
  %8 = lshr i64 %5, 32
  %9 = trunc nuw i64 %8 to i32
  %10 = insertelement <2 x i32> %7, i32 %9, i32 1
  ret <2 x i32> %10
}

After InstCombinePass

; *** IR Dump After InstCombinePass on _Z7MulLoHijj ***
; Function Attrs: alwaysinline convergent mustprogress norecurse nounwind
define noundef <2 x i32> @_Z7MulLoHijj(i32 noundef %0, i32 noundef %1) local_unnamed_addr #1 {
  %3 = zext i32 %0 to i64
  %4 = zext i32 %1 to i64
  %5 = mul nuw i64 %3, %4
  %6 = bitcast i64 %5 to <2 x i32>
  ret <2 x i32> %6
}