Preserve bounds for laundered root indices

Extract range information from laundered integer operands before
lowering root signature accesses. This keeps dynamic array bounds
available when the launder carries range metadata.

Author: krystian-andrzejewski

IGC/Compiler/CISACodeGen/helper.cpp

@@ -14,6 +14,7 @@ SPDX-License-Identifier: MIT
 #include "common/LLVMWarningsPush.hpp"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
+#include <llvm/IR/ConstantRange.h>
 #include <llvm/IR/InstIterator.h>
 #include <llvm/IR/Intrinsics.h>
 #include <llvm/Support/KnownBits.h>
@@ -2993,4 +2994,71 @@ bool AllowRemovingUnusedImplicitLocalIDs(const CodeGenContext *ctx) {
   return ctx->platform.isCoreChildOf(IGFX_XE2_HPG_CORE);
 }
 
+ExtractBoundsResult ExtractBounds(llvm::Use &U, llvm::AssumptionCache &AC, llvm::Instruction *CtxI,
+                                  bool peelLaunder /*= true*/) {
+  IGC_ASSERT_MESSAGE(U.get() && U.get()->getType()->isIntegerTy(), "Expecting an integer operand");
+
+  ExtractBoundsResult Result;
+  llvm::Value *V = U.get();
+  std::optional<llvm::ConstantRange> CRFromErasedLaunder;
+  Result.SourceValue = V;
+
+  if (peelLaunder) {
+    auto *MaybeLaunder = llvm::dyn_cast<GenIntrinsicInst>(V);
+    const bool IsLaunder = MaybeLaunder && MaybeLaunder->isGenIntrinsic(GenISAIntrinsic::GenISA_launder);
+    if (IsLaunder) {
+      llvm::Value *Operand = MaybeLaunder->getOperand(0);
+      Result.SourceValue = Operand;
+      auto *OperandTy = llvm::dyn_cast<llvm::IntegerType>(Operand->getType());
+      if (!OperandTy || OperandTy->getBitWidth() > 64)
+        return Result;
+
+      if (auto *Constant = llvm::dyn_cast<llvm::ConstantInt>(Operand)) {
+        MaybeLaunder->replaceAllUsesWith(Operand);
+        MaybeLaunder->eraseFromParent();
+        const uint64_t Lo = Constant->getZExtValue();
+        Result.Bounds = std::make_pair(Lo, Lo + 1);
+        return Result;
+      }
+
+      U.set(Operand);
+
+      if (MaybeLaunder->user_empty()) {
+        CRFromErasedLaunder = llvm::computeConstantRange(MaybeLaunder, /*ForSigned=*/false,
+                                                         /*UseInstrInfo=*/true, &AC, CtxI,
+                                                         /*DT=*/nullptr, /*Depth=*/0);
+        MaybeLaunder->eraseFromParent();
+        V = nullptr;
+      }
+    }
+  }
+
+  auto *Ty = llvm::dyn_cast<llvm::IntegerType>(Result.SourceValue->getType());
+  if (!Ty || Ty->getBitWidth() > 64 || !CtxI)
+    return Result;
+
+  const llvm::DataLayout &DL = CtxI->getModule()->getDataLayout();
+
+  llvm::ConstantRange CRFromOperand = llvm::computeConstantRange(
+      Result.SourceValue, /*ForSigned=*/false, /*UseInstrInfo=*/true, &AC, CtxI, /*DT=*/nullptr, /*Depth=*/0);
+  llvm::KnownBits KB = IGCLLVM::computeKnownBits(Result.SourceValue, DL, &AC, CtxI);
+  llvm::ConstantRange Combined = CRFromOperand.intersectWith(llvm::ConstantRange::fromKnownBits(KB, false));
+
+  if (CRFromErasedLaunder.has_value()) {
+    Combined = Combined.intersectWith(*CRFromErasedLaunder);
+  } else if (V && V != Result.SourceValue) {
+    llvm::ConstantRange CRFromV = llvm::computeConstantRange(V, /*ForSigned=*/false, /*UseInstrInfo=*/true, &AC, CtxI,
+                                                             /*DT=*/nullptr, /*Depth=*/0);
+    Combined = Combined.intersectWith(CRFromV);
+  }
+
+  if (!Combined.isFullSet()) {
+    const uint64_t Lo = Combined.getUnsignedMin().getZExtValue();
+    const uint64_t Hi = Combined.getUnsignedMax().getZExtValue() + 1;
+    Result.Bounds = std::make_pair(Lo, Hi);
+  }
+
+  return Result;
+}
+
 } // namespace IGC

IGC/Compiler/CISACodeGen/helper.h

@@ -42,6 +42,8 @@ SPDX-License-Identifier: MIT
 #include "LLVM3DBuilder/MetadataBuilder.h"
 #include "Probe/Assertion.h"
 #include <functional>
+#include <optional>
+#include <utility>
 #include "common/ResourceAddrSpace.h"
 
 typedef unsigned int uint;
@@ -590,4 +592,20 @@ bool UsedWithoutImmInMemInst(llvm::Value *v);
 bool AllowShortImplicitPayloadHeader(const CodeGenContext *ctx);
 bool AllowRemovingUnusedImplicitArguments(const CodeGenContext *ctx);
 bool AllowRemovingUnusedImplicitLocalIDs(const CodeGenContext *ctx);
+
+struct ExtractBoundsResult {
+  llvm::Value *SourceValue = nullptr;
+  std::optional<std::pair<uint64_t, uint64_t>> Bounds; // [Lo, Hi), or nullopt if no useful constraint.
+};
+
+/// Given a Use U that may reference a GenISA_launder:
+///  1. Replaces U in-place with the launder's operand.
+///  2. If the launder has no remaining users, erases it.
+///  3. Returns the tightest [Lo, Hi) by intersecting:
+///     a) computeConstantRange(operand, depth=0), including assumes on the operand,
+///     b) ConstantRange::fromKnownBits(computeKnownBits(operand)),
+///     c) computeConstantRange(launder, depth=0), including assumes/range on the launder.
+/// If U does not reference a launder, only (a) and (b) are applied.
+ExtractBoundsResult ExtractBounds(llvm::Use &U, llvm::AssumptionCache &AC, llvm::Instruction *CtxI,
+                                  bool peelLaunder = true);
 } // namespace IGC

IGC/GenISAIntrinsics/GenIntrinsicInst.h

@@ -1976,8 +1976,16 @@ class LocalRootSignatureValueIntrinsic : public GenIntrinsicInst {
 
   static inline bool classof(const Value *V) { return isa<GenIntrinsicInst>(V) && classof(cast<GenIntrinsicInst>(V)); }
 
-  Value *getByteOffset() const { return getOperand(0); }
-  uint32_t getRootSigSize() const { return int_cast<uint32_t>(getImm64Operand(1)); }
+  enum class Argument { Offset, Size, Count };
+  static constexpr unsigned int GetArgumentIndex(Argument arg) { return static_cast<unsigned int>(arg); }
+  inline llvm::Value *GetArgument(Argument arg) const { return getOperand(GetArgumentIndex(arg)); }
+  inline llvm::Use &GetArgumentUse(Argument arg) { return getOperandUse(GetArgumentIndex(arg)); }
+  inline const llvm::Use &GetArgumentUse(Argument arg) const { return getOperandUse(GetArgumentIndex(arg)); }
+
+  Value *getByteOffset() const { return GetArgument(Argument::Offset); }
+  llvm::Use &getByteOffsetUse() { return GetArgumentUse(Argument::Offset); }
+  const llvm::Use &getByteOffsetUse() const { return GetArgumentUse(Argument::Offset); }
+  uint32_t getRootSigSize() const { return int_cast<uint32_t>(getImm64Operand(GetArgumentIndex(Argument::Size))); }
 };
 
 class StaticConstantPatchIntrinsic : public GenIntrinsicInst {