modify the i8 legalization pass to be a more generic legalization so we can reduce i64 insert/extracts to i32

Author: farzonl

llvm/lib/Target/DirectX/CMakeLists.txt

@@ -32,7 +32,7 @@ add_llvm_target(DirectXCodeGen
   DXILShaderFlags.cpp
   DXILTranslateMetadata.cpp
   DXILRootSignature.cpp
-  LegalizeI8Pass.cpp
+  DXILLegalizePass.cpp
 
   LINK_COMPONENTS
   Analysis

llvm/lib/Target/DirectX/DXILLegalizePass.cpp

@@ -0,0 +1,198 @@
+//===- DXILLegalizePass.cpp - Legalizes llvm IR for DXIL-*- C++----------*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===---------------------------------------------------------------------===//
+//===---------------------------------------------------------------------===//
+///
+/// \file This file contains a pass to remove i8 truncations and i64 extract
+/// and insert elements.
+///
+//===----------------------------------------------------------------------===//
+#include "DXILLegalizePass.h"
+#include "DirectX.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/IRBuilder.h"
+#include "llvm/IR/InstIterator.h"
+#include "llvm/IR/Instruction.h"
+#include "llvm/Pass.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
+#include <functional>
+#include <map>
+#include <stack>
+#include <vector>
+
+#define DEBUG_TYPE "dxil-legalize"
+
+using namespace llvm;
+namespace {
+
+static bool fixI8TruncUseChain(Instruction &I,
+                               std::stack<Instruction *> &ToRemove,
+                               std::map<Value *, Value *> &ReplacedValues) {
+
+  if (auto *Trunc = dyn_cast<TruncInst>(&I)) {
+    if (Trunc->getDestTy()->isIntegerTy(8)) {
+      ReplacedValues[Trunc] = Trunc->getOperand(0);
+      ToRemove.push(Trunc);
+    }
+  } else if (I.getType()->isIntegerTy(8)) {
+    IRBuilder<> Builder(&I);
+
+    std::vector<Value *> NewOperands;
+    Type *InstrType = nullptr;
+    for (unsigned OpIdx = 0; OpIdx < I.getNumOperands(); ++OpIdx) {
+      Value *Op = I.getOperand(OpIdx);
+      if (ReplacedValues.count(Op)) {
+        InstrType = ReplacedValues[Op]->getType();
+        NewOperands.push_back(ReplacedValues[Op]);
+      } else if (auto *Imm = dyn_cast<ConstantInt>(Op)) {
+        APInt Value = Imm->getValue();
+        unsigned NewBitWidth = InstrType->getIntegerBitWidth();
+        // Note: options here are sext or sextOrTrunc.
+        // Since i8 isn't suppport we assume new values
+        // will always have a higher bitness.
+        APInt NewValue = Value.sext(NewBitWidth);
+        NewOperands.push_back(ConstantInt::get(InstrType, NewValue));
+      } else {
+        assert(!Op->getType()->isIntegerTy(8));
+        NewOperands.push_back(Op);
+      }
+    }
+
+    Value *NewInst = nullptr;
+    if (auto *BO = dyn_cast<BinaryOperator>(&I))
+      NewInst =
+          Builder.CreateBinOp(BO->getOpcode(), NewOperands[0], NewOperands[1]);
+    else if (auto *Cmp = dyn_cast<CmpInst>(&I))
+      NewInst = Builder.CreateCmp(Cmp->getPredicate(), NewOperands[0],
+                                  NewOperands[1]);
+    else if (auto *Cast = dyn_cast<CastInst>(&I))
+      NewInst = Builder.CreateCast(Cast->getOpcode(), NewOperands[0],
+                                   Cast->getDestTy());
+    else if (auto *UnaryOp = dyn_cast<UnaryOperator>(&I))
+      NewInst = Builder.CreateUnOp(UnaryOp->getOpcode(), NewOperands[0]);
+
+    if (NewInst) {
+      ReplacedValues[&I] = NewInst;
+      ToRemove.push(&I);
+    }
+  } else if (auto *Sext = dyn_cast<SExtInst>(&I)) {
+    if (Sext->getSrcTy()->isIntegerTy(8)) {
+      ToRemove.push(Sext);
+      Sext->replaceAllUsesWith(ReplacedValues[Sext->getOperand(0)]);
+    }
+  }
+
+  return !ToRemove.empty();
+}
+
+static bool downcastI64toI32InsertExtractElements(
+    Instruction &I, std::stack<Instruction *> &ToRemove, std::map<Value *, Value *> &) {
+
+  if (auto *Extract = dyn_cast<ExtractElementInst>(&I)) {
+    Value *Idx = Extract->getIndexOperand();
+    auto *CI = dyn_cast<ConstantInt>(Idx);
+    if (CI && CI->getBitWidth() == 64) {
+      IRBuilder<> Builder(Extract);
+      int64_t IndexValue = CI->getSExtValue();
+      auto *Idx32 =
+          ConstantInt::get(Type::getInt32Ty(I.getContext()), IndexValue);
+      Value *NewExtract =
+          Builder.CreateExtractElement(Extract->getVectorOperand(), Idx32,Extract->getName());
+
+      Extract->replaceAllUsesWith(NewExtract);
+      ToRemove.push(Extract);
+    }
+  }
+
+  if (auto *Insert = dyn_cast<InsertElementInst>(&I)) {
+    Value *Idx = Insert->getOperand(2);
+    auto *CI = dyn_cast<ConstantInt>(Idx);
+    if (CI && CI->getBitWidth() == 64) {
+      int64_t IndexValue = CI->getSExtValue();
+      auto *Idx32 =
+          ConstantInt::get(Type::getInt32Ty(I.getContext()), IndexValue);
+      IRBuilder<> Builder(Insert);
+      Value *Insert32Index = Builder.CreateInsertElement(
+          Insert->getOperand(0), Insert->getOperand(1), Idx32, Insert->getName());
+
+      Insert->replaceAllUsesWith(Insert32Index);
+      ToRemove.push(Insert);
+    }
+  }
+
+  return !ToRemove.empty();
+}
+
+class DXILLegalizationPipeline {
+
+public:
+  DXILLegalizationPipeline() { initializeLegalizationPipeline(); }
+
+  bool runLegalizationPipeline(Function &F) {
+    std::stack<Instruction *> ToRemove;
+    std::map<Value *, Value *> ReplacedValues;
+    bool MadeChanges = false;
+    for (auto &I : instructions(F)) {
+      for (auto &LegalizationFn : LegalizationPipeline) {
+        MadeChanges = LegalizationFn(I, ToRemove, ReplacedValues);
+      }
+    }
+    while (!ToRemove.empty()) {
+      Instruction *I = ToRemove.top();
+      I->eraseFromParent();
+      ToRemove.pop();
+    }
+
+    return MadeChanges;
+  }
+
+private:
+  std::vector<std::function<bool(Instruction &, std::stack<Instruction *> &,
+                                 std::map<Value *, Value *> &)>>
+      LegalizationPipeline;
+
+  void initializeLegalizationPipeline() {
+    LegalizationPipeline.push_back(fixI8TruncUseChain);
+    LegalizationPipeline.push_back(downcastI64toI32InsertExtractElements);
+  }
+};
+
+class DXILLegalizeLegacy : public FunctionPass {
+
+public:
+  bool runOnFunction(Function &F) override;
+  DXILLegalizeLegacy() : FunctionPass(ID) {}
+
+  static char ID; // Pass identification.
+};
+} // namespace
+
+PreservedAnalyses DXILLegalizePass::run(Function &F,
+                                        FunctionAnalysisManager &FAM) {
+  DXILLegalizationPipeline DXLegalize;
+  bool MadeChanges = DXLegalize.runLegalizationPipeline(F);
+  if (!MadeChanges)
+    return PreservedAnalyses::all();
+  PreservedAnalyses PA;
+  return PA;
+}
+
+bool DXILLegalizeLegacy::runOnFunction(Function &F) {
+  DXILLegalizationPipeline DXLegalize;
+  return DXLegalize.runLegalizationPipeline(F);
+}
+
+char DXILLegalizeLegacy::ID = 0;
+
+INITIALIZE_PASS_BEGIN(DXILLegalizeLegacy, DEBUG_TYPE, "DXIL Legalizer", false,
+                      false)
+INITIALIZE_PASS_END(DXILLegalizeLegacy, DEBUG_TYPE, "DXIL Legalizer", false,
+                    false)
+
+FunctionPass *llvm::createDXILLegalizeLegacyPass() {
+  return new DXILLegalizeLegacy();
+}

llvm/lib/Target/DirectX/LegalizeI8Pass.h renamed to llvm/lib/Target/DirectX/DXILLegalizePass.h

@@ -1,23 +1,22 @@
-//===- LegalizeI8Pass.h - A pass that reverts i8 conversions-*- C++ -----*-===//
+//===- DXILLegalizePass.h - Legalizes llvm IR for DXIL-*- C++------------*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===---------------------------------------------------------------------===//
 
-#ifndef LLVM_TARGET_DIRECTX_LEGALIZEI8_H
-#define LLVM_TARGET_DIRECTX_LEGALIZEI8_H
+#ifndef LLVM_TARGET_DIRECTX_LEGALIZE_H
+#define LLVM_TARGET_DIRECTX_LEGALIZE_H
 
 #include "llvm/IR/PassManager.h"
 
 namespace llvm {
 
-/// A pass that transforms multidimensional arrays into one-dimensional arrays.
-class LegalizeI8Pass : public PassInfoMixin<LegalizeI8Pass> {
+class DXILLegalizePass : public PassInfoMixin<DXILLegalizePass> {
 public:
   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
 };
 } // namespace llvm
 
-#endif // LLVM_TARGET_DIRECTX_LEGALIZEI8_H
+#endif // LLVM_TARGET_DIRECTX_LEGALIZE_H

llvm/lib/Target/DirectX/DirectX.h

@@ -47,11 +47,12 @@ void initializeDXILFlattenArraysLegacyPass(PassRegistry &);
 /// Pass to flatten arrays into a one dimensional DXIL legal form
 ModulePass *createDXILFlattenArraysLegacyPass();
 
-/// Initializer I8 legalizationPass
-void initializeLegalizeI8LegacyPass(PassRegistry &);
+/// Initializer DXIL legalizationPass
+void initializeDXILLegalizeLegacyPass(PassRegistry &);
 
-/// Pass to remove i8 truncations
-FunctionPass *createLegalizeI8LegacyPass();
+/// Pass to Legalize DXIL by remove i8 truncations and i64 insert/extract
+/// elements
+FunctionPass *createDXILLegalizeLegacyPass();
 
 /// Initializer for DXILOpLowering
 void initializeDXILOpLoweringLegacyPass(PassRegistry &);

llvm/lib/Target/DirectX/DirectXPassRegistry.def

@@ -38,5 +38,5 @@ MODULE_PASS("print<dxil-root-signature>", dxil::RootSignatureAnalysisPrinter(dbg
 #define FUNCTION_PASS(NAME, CREATE_PASS)
 #endif
 FUNCTION_PASS("dxil-resource-access", DXILResourceAccess())
-FUNCTION_PASS("dxil-legalize-i8", LegalizeI8Pass())
+FUNCTION_PASS("dxil-legalize", DXILLegalizePass())
 #undef FUNCTION_PASS

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

@@ -15,6 +15,7 @@
 #include "DXILDataScalarization.h"
 #include "DXILFlattenArrays.h"
 #include "DXILIntrinsicExpansion.h"
+#include "DXILLegalizePass.h"
 #include "DXILOpLowering.h"
 #include "DXILPrettyPrinter.h"
 #include "DXILResourceAccess.h"
@@ -25,7 +26,6 @@
 #include "DirectX.h"
 #include "DirectXSubtarget.h"
 #include "DirectXTargetTransformInfo.h"
-#include "LegalizeI8Pass.h"
 #include "TargetInfo/DirectXTargetInfo.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/Passes.h"
@@ -53,7 +53,7 @@ extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTarget() {
   initializeDXILDataScalarizationLegacyPass(*PR);
   initializeDXILFlattenArraysLegacyPass(*PR);
   initializeScalarizerLegacyPassPass(*PR);
-  initializeLegalizeI8LegacyPass(*PR);
+  initializeDXILLegalizeLegacyPass(*PR);
   initializeDXILPrepareModulePass(*PR);
   initializeEmbedDXILPassPass(*PR);
   initializeWriteDXILPassPass(*PR);
@@ -101,8 +101,8 @@ class DirectXPassConfig : public TargetPassConfig {
     ScalarizerPassOptions DxilScalarOptions;
     DxilScalarOptions.ScalarizeLoadStore = true;
     addPass(createScalarizerPass(DxilScalarOptions));
+    addPass(createDXILLegalizeLegacyPass());
     addPass(createDXILTranslateMetadataLegacyPass());
-    addPass(createLegalizeI8LegacyPass());
     addPass(createDXILOpLoweringLegacyPass());
     addPass(createDXILPrepareModulePass());
   }