[clang] [llvm] [AMDGPU] Validate prefetch length and cache policy operands (PR #232143)

Gheorghe-Teodor Bercea via cfe-commits cfe-commits at lists.llvm.org
Thu Nov 5 14:58:06 PST 2026


https://github.com/doru1004 updated https://github.com/llvm/llvm-project/pull/232143

>From 92c0438f0ecc38905db312958b8567b6568df214 Mon Sep 17 00:00:00 2001
From: Gheorghe-Teodor Bercea <dobercea at amd.com>
Date: Wed, 14 Oct 2026 15:16:01 -0400
Subject: [PATCH 1/4] Validate prefetch length and cache policy operands

---
 .../clang/Basic/DiagnosticSemaKinds.td        |  2 ++
 clang/lib/Sema/SemaAMDGPU.cpp                 | 29 +++++++++++++++
 .../builtins-amdgcn-error-gfx1250-param.cl    | 12 +++++++
 llvm/lib/IR/VerifierAMDGPU.cpp                | 21 ++++++++++-
 .../AMDGPU/AsmParser/AMDGPUAsmParser.cpp      | 19 ++++++++++
 llvm/test/MC/AMDGPU/gfx12_asm_smem_err.s      |  9 +++++
 .../Verifier/AMDGPU/intrinsic-prefetch.ll     | 35 +++++++++++++++++++
 7 files changed, 126 insertions(+), 1 deletion(-)

diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index a4a7fb91e6b39d..c9ff0389ae5a5a 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -14480,6 +14480,8 @@ def warn_amdgpu_av_requires_atomic : Warning<
 def err_amdgcn_dmask_has_too_many_bits_set
     : Error<"dmask argument cannot have more bits set than there are elements "
             "in return type">;
+def err_amdgcn_prefetch_reserved_th
+    : Error<"cache policy uses the reserved th value 7">;
 
 def warn_amdgpu_s_wait_event_mask_no_effect_target :
   Warning<"event mask has no effect for target">,
diff --git a/clang/lib/Sema/SemaAMDGPU.cpp b/clang/lib/Sema/SemaAMDGPU.cpp
index b1f6fa33649bd1..30f0dea1477547 100644
--- a/clang/lib/Sema/SemaAMDGPU.cpp
+++ b/clang/lib/Sema/SemaAMDGPU.cpp
@@ -168,6 +168,35 @@ bool SemaAMDGPU::CheckAMDGCNBuiltinFunctionCall(const TargetInfo &TI,
   case AMDGPU::BI__builtin_amdgcn_s_setreg:
     return SemaRef.BuiltinConstantArgRange(TheCall, /*ArgNum=*/0, /*Low=*/0,
                                            /*High=*/UINT16_MAX);
+  case AMDGPU::BI__builtin_amdgcn_flat_prefetch:
+  case AMDGPU::BI__builtin_amdgcn_global_prefetch: {
+    // Only th (bits 0-2, where 7 is reserved), scope (bits 3-4) and nv (bit 5)
+    // may be set.
+    llvm::APSInt CPol;
+    if (SemaRef.BuiltinConstantArgRange(TheCall, /*ArgNum=*/1, /*Low=*/0,
+                                        /*High=*/63) ||
+        SemaRef.BuiltinConstantArg(TheCall, /*ArgNum=*/1, CPol))
+      return true;
+    if ((CPol.getZExtValue() & 0x7) != 0x7)
+      return false;
+    Expr *ArgExpr = TheCall->getArg(1);
+    SemaRef.targetDiag(ArgExpr->getExprLoc(),
+                       diag::err_amdgcn_prefetch_reserved_th)
+        << ArgExpr->getSourceRange();
+    return true;
+  }
+  case AMDGPU::BI__builtin_amdgcn_s_prefetch_data:
+  case AMDGPU::BI__builtin_amdgcn_s_prefetch_inst:
+  case AMDGPU::BI__builtin_amdgcn_s_buffer_prefetch_data: {
+    // The length may be a register; a constant one is encoded in 5 bits.
+    unsigned LenArgNo =
+        BuiltinID == AMDGPU::BI__builtin_amdgcn_s_buffer_prefetch_data ? 2 : 1;
+    const Expr *Len = TheCall->getArg(LenArgNo);
+    if (Len->isValueDependent() || !Len->isIntegerConstantExpr(getASTContext()))
+      return false;
+    return SemaRef.BuiltinConstantArgRange(TheCall, LenArgNo, /*Low=*/0,
+                                           /*High=*/31);
+  }
   case AMDGPU::BI__builtin_amdgcn_s_wait_event: {
     llvm::APSInt Result;
     if (SemaRef.BuiltinConstantArg(TheCall, 0, Result))
diff --git a/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl b/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl
index 0fdf8df507bec7..fe881ff7270bd4 100644
--- a/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl
+++ b/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl
@@ -194,6 +194,18 @@ void test_amdgcn_tensor_load_store(v4u sg0, v8u sg1, v4u sg2, v4u sg3, v8u sg4,
 void test_prefetch(generic void *fptr, global void *gptr, int cpol) {
   __builtin_amdgcn_flat_prefetch(fptr, cpol); // expected-error {{'__builtin_amdgcn_flat_prefetch' must be a constant integer}}
   __builtin_amdgcn_global_prefetch(gptr, cpol); // expected-error {{'__builtin_amdgcn_global_prefetch' must be a constant integer}}
+  __builtin_amdgcn_flat_prefetch(fptr, 64); // expected-error {{argument value 64 is outside the valid range [0, 63]}}
+  __builtin_amdgcn_global_prefetch(gptr, 2048); // expected-error {{argument value 2048 is outside the valid range [0, 63]}}
+  __builtin_amdgcn_flat_prefetch(fptr, 15); // expected-error {{cache policy uses the reserved th value 7}}
+  __builtin_amdgcn_global_prefetch(gptr, 7); // expected-error {{cache policy uses the reserved th value 7}}
+  __builtin_amdgcn_global_prefetch(gptr, 62);
+}
+
+void test_s_prefetch_len(global void *gptr, int len) {
+  __builtin_amdgcn_s_prefetch_data(gptr, len);
+  __builtin_amdgcn_s_prefetch_data(gptr, 31);
+  __builtin_amdgcn_s_prefetch_data(gptr, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
+  __builtin_amdgcn_s_prefetch_inst(gptr, 300); // expected-error {{argument value 300 is outside the valid range [0, 31]}}
 }
 
 void test_cvt_f32_fp8_e5m3(global int* out, int a)
diff --git a/llvm/lib/IR/VerifierAMDGPU.cpp b/llvm/lib/IR/VerifierAMDGPU.cpp
index 5d7b46357d2849..55f3035a7dccce 100644
--- a/llvm/lib/IR/VerifierAMDGPU.cpp
+++ b/llvm/lib/IR/VerifierAMDGPU.cpp
@@ -291,11 +291,30 @@ void llvm::verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID,
     }
     break;
   }
-  case Intrinsic::amdgcn_s_prefetch_data: {
+  case Intrinsic::amdgcn_s_prefetch_data:
     Check(
         AMDGPU::isFlatGlobalAddrSpace(
             Call.getArgOperand(0)->getType()->getPointerAddressSpace()),
         "llvm.amdgcn.s.prefetch.data only supports global or constant memory");
+    [[fallthrough]];
+  case Intrinsic::amdgcn_s_prefetch_inst:
+  case Intrinsic::amdgcn_s_buffer_prefetch_data: {
+    // The length is encoded in 5 bits: 0-31 means 1-32 chunks of 128 bytes.
+    unsigned LenIdx = ID == Intrinsic::amdgcn_s_buffer_prefetch_data ? 2 : 1;
+    if (auto *Len = dyn_cast<ConstantInt>(Call.getArgOperand(LenIdx)))
+      Check(Len->getZExtValue() <= 31,
+            "prefetch length must be in the range [0, 31]", &Call);
+    break;
+  }
+  case Intrinsic::amdgcn_flat_prefetch:
+  case Intrinsic::amdgcn_global_prefetch: {
+    // Only th (bits 0-2, where 7 is reserved), scope (bits 3-4) and nv (bit 5)
+    // may be set; scale_offset depends on the address form that is selected.
+    if (auto *CPolArg = dyn_cast<ConstantInt>(Call.getArgOperand(1))) {
+      uint64_t CPol = CPolArg->getZExtValue();
+      Check(CPol <= 0x3f && (CPol & 0x7) != 0x7,
+            "invalid cache policy for prefetch", &Call);
+    }
     break;
   }
   case Intrinsic::amdgcn_load_to_lds:
diff --git a/llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp b/llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp
index 0231e75eb2f476..44eeed2ee786b4 100644
--- a/llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp
+++ b/llvm/lib/Target/AMDGPU/AsmParser/AMDGPUAsmParser.cpp
@@ -1616,6 +1616,7 @@ class AMDGPUAsmParser : public MCTargetAsmParser {
   bool validateOffset(const MCInst &Inst, const OperandVector &Operands);
   bool validateFlatOffset(const MCInst &Inst, const OperandVector &Operands);
   bool validateSMEMOffset(const MCInst &Inst, const OperandVector &Operands);
+  bool validateSMEMSData(const MCInst &Inst, const OperandVector &Operands);
   bool validateBF16InlineConst(const MCInst &Inst,
                                const OperandVector &Operands);
   bool validateSOPLiteral(const MCInst &Inst, const OperandVector &Operands);
@@ -4675,6 +4676,22 @@ bool AMDGPUAsmParser::validateSMEMOffset(const MCInst &Inst,
   return false;
 }
 
+// GFX12+ SMEM prefetches and probes encode an immediate sdata in 5 bits.
+bool AMDGPUAsmParser::validateSMEMSData(const MCInst &Inst,
+                                        const OperandVector &Operands) {
+  if (!isGFX12Plus() || !SIInstrFlags::isSMRD(MII, Inst))
+    return true;
+
+  int OpNum =
+      AMDGPU::getNamedOperandIdx(Inst.getOpcode(), AMDGPU::OpName::sdata);
+  if (OpNum == -1 || !Inst.getOperand(OpNum).isImm() ||
+      isUInt<5>(Inst.getOperand(OpNum).getImm()))
+    return true;
+
+  Error(getOperandLoc(Operands, OpNum), "expected a 5-bit unsigned immediate");
+  return false;
+}
+
 // On subtargets with FeatureBF16InlineConstFromUpperFP32 the hardware generates
 // a bf16 inline constant in the high half of the corresponding fp32 inline
 // constant. A VOP1 bf16 opcode (v_cvt_f32_bf16 and the bf16 transcendentals)
@@ -5668,6 +5685,8 @@ bool AMDGPUAsmParser::validateInstruction(const MCInst &Inst, SMLoc IDLoc,
   if (!validateOffset(Inst, Operands)) {
     return false;
   }
+  if (!validateSMEMSData(Inst, Operands))
+    return false;
   if (!validateBF16InlineConst(Inst, Operands)) {
     return false;
   }
diff --git a/llvm/test/MC/AMDGPU/gfx12_asm_smem_err.s b/llvm/test/MC/AMDGPU/gfx12_asm_smem_err.s
index d26cc9bdca9944..5f0e1208fd7fb1 100644
--- a/llvm/test/MC/AMDGPU/gfx12_asm_smem_err.s
+++ b/llvm/test/MC/AMDGPU/gfx12_asm_smem_err.s
@@ -1,6 +1,9 @@
 // NOTE: Assertions have been autogenerated by utils/update_mc_test_checks.py UTC_ARGS: --unique --sort --version 6
 // RUN: not llvm-mc -triple=amdgpu12.00 %s -filetype=null 2>&1 | FileCheck --check-prefixes=NOGFX12 --implicit-check-not=error: %s
 
+s_atc_probe 32, s[4:5], 0x64
+// NOGFX12: :[[@LINE-1]]:13: error: expected a 5-bit unsigned immediate
+
 s_atc_probe_buffer 7, null, s2
 // NOGFX12: :[[@LINE-1]]:23: error: invalid operand for instruction
 
@@ -48,3 +51,9 @@ s_buffer_load_u8 s5, null, s0
 
 s_buffer_prefetch_data null, 100, s10, 7
 // NOGFX12: :[[@LINE-1]]:24: error: invalid operand for instruction
+
+s_prefetch_data s[18:19], 100, null, 32
+// NOGFX12: :[[@LINE-1]]:38: error: expected a 5-bit unsigned immediate
+
+s_prefetch_inst s[18:19], 100, null, 0x100
+// NOGFX12: :[[@LINE-1]]:38: error: expected a 5-bit unsigned immediate
diff --git a/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll b/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
index 2c7f23a34fb10c..d8c6d3eda59396 100644
--- a/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
+++ b/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
@@ -6,3 +6,38 @@ entry:
   tail call void @llvm.amdgcn.s.prefetch.data.p3(ptr addrspace(3) %ptr, i32 31)
   ret void
 }
+
+define amdgpu_ps void @prefetch_data_len_too_large(ptr addrspace(1) inreg %ptr) {
+  ; CHECK: prefetch length must be in the range [0, 31]
+  ; CHECK-NEXT: call void @llvm.amdgcn.s.prefetch.data.p1(ptr addrspace(1) %ptr, i32 32)
+  call void @llvm.amdgcn.s.prefetch.data.p1(ptr addrspace(1) %ptr, i32 32)
+  ret void
+}
+
+define amdgpu_ps void @prefetch_inst_len_too_large(ptr inreg %ptr) {
+  ; CHECK: prefetch length must be in the range [0, 31]
+  ; CHECK-NEXT: call void @llvm.amdgcn.s.prefetch.inst.p0(ptr %ptr, i32 255)
+  call void @llvm.amdgcn.s.prefetch.inst.p0(ptr %ptr, i32 255)
+  ret void
+}
+
+define amdgpu_ps void @buffer_prefetch_data_len_too_large(ptr addrspace(8) inreg %rsrc) {
+  ; CHECK: prefetch length must be in the range [0, 31]
+  ; CHECK-NEXT: call void @llvm.amdgcn.s.buffer.prefetch.data(ptr addrspace(8) %rsrc, i32 0, i32 64)
+  call void @llvm.amdgcn.s.buffer.prefetch.data(ptr addrspace(8) %rsrc, i32 0, i32 64)
+  ret void
+}
+
+define amdgpu_ps void @global_prefetch_reserved_th(ptr addrspace(1) %ptr) {
+  ; CHECK: invalid cache policy for prefetch
+  ; CHECK-NEXT: call void @llvm.amdgcn.global.prefetch(ptr addrspace(1) %ptr, i32 7)
+  call void @llvm.amdgcn.global.prefetch(ptr addrspace(1) %ptr, i32 7)
+  ret void
+}
+
+define amdgpu_ps void @flat_prefetch_extra_cpol_bits(ptr %ptr) {
+  ; CHECK: invalid cache policy for prefetch
+  ; CHECK-NEXT: call void @llvm.amdgcn.flat.prefetch(ptr %ptr, i32 2048)
+  call void @llvm.amdgcn.flat.prefetch(ptr %ptr, i32 2048)
+  ret void
+}

>From 199e5640e7d38d3c8c2d7b5f99d470b7c8d32f74 Mon Sep 17 00:00:00 2001
From: Gheorghe-Teodor Bercea <dobercea at amd.com>
Date: Wed, 14 Oct 2026 20:11:58 -0400
Subject: [PATCH 2/4] Validate prefetch length and cache policy operands

---
 clang/lib/Sema/SemaAMDGPU.cpp                 | 12 ---
 .../builtins-amdgcn-error-gfx1250-param.cl    |  7 --
 llvm/lib/IR/VerifierAMDGPU.cpp                | 10 +--
 llvm/lib/Target/AMDGPU/AMDGPUGISel.td         |  3 +
 .../AMDGPU/AMDGPUInstructionSelector.cpp      | 11 +++
 .../Target/AMDGPU/AMDGPUInstructionSelector.h |  2 +
 llvm/lib/Target/AMDGPU/SMInstructions.td      | 16 ++--
 .../llvm.amdgcn.s.buffer.prefetch.data.ll     | 10 +++
 .../AMDGPU/llvm.amdgcn.s.prefetch.data.ll     | 77 +++++++++++++++++++
 .../AMDGPU/llvm.amdgcn.s.prefetch.inst.ll     | 37 +++++++++
 .../Verifier/AMDGPU/intrinsic-prefetch.ll     | 21 -----
 11 files changed, 152 insertions(+), 54 deletions(-)

diff --git a/clang/lib/Sema/SemaAMDGPU.cpp b/clang/lib/Sema/SemaAMDGPU.cpp
index 30f0dea1477547..f1c855d12fbcba 100644
--- a/clang/lib/Sema/SemaAMDGPU.cpp
+++ b/clang/lib/Sema/SemaAMDGPU.cpp
@@ -185,18 +185,6 @@ bool SemaAMDGPU::CheckAMDGCNBuiltinFunctionCall(const TargetInfo &TI,
         << ArgExpr->getSourceRange();
     return true;
   }
-  case AMDGPU::BI__builtin_amdgcn_s_prefetch_data:
-  case AMDGPU::BI__builtin_amdgcn_s_prefetch_inst:
-  case AMDGPU::BI__builtin_amdgcn_s_buffer_prefetch_data: {
-    // The length may be a register; a constant one is encoded in 5 bits.
-    unsigned LenArgNo =
-        BuiltinID == AMDGPU::BI__builtin_amdgcn_s_buffer_prefetch_data ? 2 : 1;
-    const Expr *Len = TheCall->getArg(LenArgNo);
-    if (Len->isValueDependent() || !Len->isIntegerConstantExpr(getASTContext()))
-      return false;
-    return SemaRef.BuiltinConstantArgRange(TheCall, LenArgNo, /*Low=*/0,
-                                           /*High=*/31);
-  }
   case AMDGPU::BI__builtin_amdgcn_s_wait_event: {
     llvm::APSInt Result;
     if (SemaRef.BuiltinConstantArg(TheCall, 0, Result))
diff --git a/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl b/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl
index fe881ff7270bd4..75b0bec29baffa 100644
--- a/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl
+++ b/clang/test/SemaOpenCL/builtins-amdgcn-error-gfx1250-param.cl
@@ -201,13 +201,6 @@ void test_prefetch(generic void *fptr, global void *gptr, int cpol) {
   __builtin_amdgcn_global_prefetch(gptr, 62);
 }
 
-void test_s_prefetch_len(global void *gptr, int len) {
-  __builtin_amdgcn_s_prefetch_data(gptr, len);
-  __builtin_amdgcn_s_prefetch_data(gptr, 31);
-  __builtin_amdgcn_s_prefetch_data(gptr, 32); // expected-error {{argument value 32 is outside the valid range [0, 31]}}
-  __builtin_amdgcn_s_prefetch_inst(gptr, 300); // expected-error {{argument value 300 is outside the valid range [0, 31]}}
-}
-
 void test_cvt_f32_fp8_e5m3(global int* out, int a)
 {
   *out = __builtin_amdgcn_cvt_f32_fp8_e5m3(a, a); // expected-error {{'__builtin_amdgcn_cvt_f32_fp8_e5m3' must be a constant integer}}
diff --git a/llvm/lib/IR/VerifierAMDGPU.cpp b/llvm/lib/IR/VerifierAMDGPU.cpp
index 55f3035a7dccce..c2b3df901cfa23 100644
--- a/llvm/lib/IR/VerifierAMDGPU.cpp
+++ b/llvm/lib/IR/VerifierAMDGPU.cpp
@@ -291,19 +291,11 @@ void llvm::verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID,
     }
     break;
   }
-  case Intrinsic::amdgcn_s_prefetch_data:
+  case Intrinsic::amdgcn_s_prefetch_data: {
     Check(
         AMDGPU::isFlatGlobalAddrSpace(
             Call.getArgOperand(0)->getType()->getPointerAddressSpace()),
         "llvm.amdgcn.s.prefetch.data only supports global or constant memory");
-    [[fallthrough]];
-  case Intrinsic::amdgcn_s_prefetch_inst:
-  case Intrinsic::amdgcn_s_buffer_prefetch_data: {
-    // The length is encoded in 5 bits: 0-31 means 1-32 chunks of 128 bytes.
-    unsigned LenIdx = ID == Intrinsic::amdgcn_s_buffer_prefetch_data ? 2 : 1;
-    if (auto *Len = dyn_cast<ConstantInt>(Call.getArgOperand(LenIdx)))
-      Check(Len->getZExtValue() <= 31,
-            "prefetch length must be in the range [0, 31]", &Call);
     break;
   }
   case Intrinsic::amdgcn_flat_prefetch:
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUGISel.td b/llvm/lib/Target/AMDGPU/AMDGPUGISel.td
index a1c4af109b44a3..1725e97f0c7e21 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUGISel.td
+++ b/llvm/lib/Target/AMDGPU/AMDGPUGISel.td
@@ -457,6 +457,9 @@ def gi_as_i16timm : GICustomOperandRenderer<"renderTruncTImm">,
 def gi_as_i8timm : GICustomOperandRenderer<"renderTruncTImm">,
   GISDNodeXFormEquiv<as_i8timm>;
 
+def gi_as_prefetch_len : GICustomOperandRenderer<"renderPrefetchLen">,
+  GISDNodeXFormEquiv<as_prefetch_len>;
+
 def gi_as_i1timm : GICustomOperandRenderer<"renderTruncTImm">,
   GISDNodeXFormEquiv<as_i1timm>;
 
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp
index f4b6bc12c5f216..74577b7deedf47 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp
@@ -7590,6 +7590,17 @@ void AMDGPUInstructionSelector::renderTruncTImm(MachineInstrBuilder &MIB,
     MIB.addImm(Op.getImm());
 }
 
+void AMDGPUInstructionSelector::renderPrefetchLen(MachineInstrBuilder &MIB,
+                                                  const MachineInstr &MI,
+                                                  int OpIdx) const {
+  const MachineOperand &Op = MI.getOperand(OpIdx);
+  int64_t Imm;
+  if (Op.isReg() && mi_match(Op.getReg(), *MRI, m_ICst(Imm)))
+    MIB.addImm(Imm & 0x1f);
+  else
+    MIB.addImm(Op.getImm() & 0x1f);
+}
+
 void AMDGPUInstructionSelector::renderZextBoolTImm(MachineInstrBuilder &MIB,
                                                    const MachineInstr &MI,
                                                    int OpIdx) const {
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.h b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.h
index 0fac1edfb89f16..1e34f090040e46 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.h
+++ b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.h
@@ -359,6 +359,8 @@ class AMDGPUInstructionSelector final : public InstructionSelector {
 
   void renderTruncTImm(MachineInstrBuilder &MIB, const MachineInstr &MI,
                        int OpIdx) const;
+  void renderPrefetchLen(MachineInstrBuilder &MIB, const MachineInstr &MI,
+                         int OpIdx) const;
   void renderZextBoolTImm(MachineInstrBuilder &MIB, const MachineInstr &MI,
                           int OpIdx) const;
 
diff --git a/llvm/lib/Target/AMDGPU/SMInstructions.td b/llvm/lib/Target/AMDGPU/SMInstructions.td
index 3d8cf52e2e753b..2b711b0fd9e508 100644
--- a/llvm/lib/Target/AMDGPU/SMInstructions.td
+++ b/llvm/lib/Target/AMDGPU/SMInstructions.td
@@ -1160,6 +1160,12 @@ defm : SMPrefetchPat<"INST", i32imm_zero>;
 let AddedComplexity = 12 in // Prefer scalar prefetch over global for r/o case.
 defm : SMPrefetchPat<"DATA", i32imm_one>;
 
+// The length field holds 5 bits; the high bits of a constant length are
+// dropped.
+def as_prefetch_len : SDNodeXForm<timm, [{
+  return CurDAG->getTargetConstant(N->getZExtValue() & 0x1f, SDLoc(N), MVT::i8);
+}]>;
+
 let SubtargetPredicate = HasSmemPrefetchInsts in {
   def : GCNPat <
     (int_amdgcn_s_prefetch_data (SMRDImm i64:$sbase, i32:$offset), (i32 SReg_32:$len)),
@@ -1173,12 +1179,12 @@ let SubtargetPredicate = HasSmemPrefetchInsts in {
 
   def : GCNPat <
     (int_amdgcn_s_prefetch_data (SMRDImm i64:$sbase, i32:$offset), imm:$len),
-    (S_PREFETCH_DATA $sbase, $offset, (i32 SGPR_NULL), (as_i8timm $len), 0)
+    (S_PREFETCH_DATA $sbase, $offset, (i32 SGPR_NULL), (as_prefetch_len $len), 0)
   >;
 
   def : GCNPat <
     (int_amdgcn_s_prefetch_data (i64 SReg_64:$sbase), imm:$len),
-    (S_PREFETCH_DATA $sbase, 0, (i32 SGPR_NULL), (as_i8timm $len), 0)
+    (S_PREFETCH_DATA $sbase, 0, (i32 SGPR_NULL), (as_prefetch_len $len), 0)
 
   >;
 
@@ -1189,7 +1195,7 @@ let SubtargetPredicate = HasSmemPrefetchInsts in {
 
   def : GCNPat <
     (SIsbuffer_prefetch v4i32:$sbase, (SMRDBufferImm i32:$offset), imm:$len),
-    (S_BUFFER_PREFETCH_DATA SReg_128:$sbase, i32imm:$offset, (i32 SGPR_NULL), (as_i8timm $len), 0)
+    (S_BUFFER_PREFETCH_DATA SReg_128:$sbase, i32imm:$offset, (i32 SGPR_NULL), (as_prefetch_len $len), 0)
   >;
 
   def : GCNPat <
@@ -1204,12 +1210,12 @@ let SubtargetPredicate = HasSmemPrefetchInsts in {
 
   def : GCNPat <
     (int_amdgcn_s_prefetch_inst (SMRDImm i64:$sbase, i32:$offset), imm:$len),
-    (S_PREFETCH_INST $sbase, $offset, (i32 SGPR_NULL), (as_i8timm $len), 0)
+    (S_PREFETCH_INST $sbase, $offset, (i32 SGPR_NULL), (as_prefetch_len $len), 0)
   >;
 
   def : GCNPat <
     (int_amdgcn_s_prefetch_inst (i64 SReg_64:$sbase), imm:$len),
-    (S_PREFETCH_INST $sbase, 0, (i32 SGPR_NULL), (as_i8timm $len), 0)
+    (S_PREFETCH_INST $sbase, 0, (i32 SGPR_NULL), (as_prefetch_len $len), 0)
   >;
 } // End let SubtargetPredicate = HasSmemPrefetchInsts
 
diff --git a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.buffer.prefetch.data.ll b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.buffer.prefetch.data.ll
index 06b602386ddaf1..c42cea693b4d48 100644
--- a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.buffer.prefetch.data.ll
+++ b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.buffer.prefetch.data.ll
@@ -24,6 +24,16 @@ entry:
   ret void
 }
 
+define amdgpu_ps void @buffer_prefetch_data_imm_offset_large_imm_len(ptr addrspace(8) inreg %rsrc) {
+; GCN-LABEL: buffer_prefetch_data_imm_offset_large_imm_len:
+; GCN:       ; %bb.0: ; %entry
+; GCN-NEXT:    s_buffer_prefetch_data s[0:3], 0x0, null, 8
+; GCN-NEXT:    s_endpgm
+entry:
+  tail call void @llvm.amdgcn.s.buffer.prefetch.data(ptr addrspace(8) inreg %rsrc, i32 0, i32 40)
+  ret void
+}
+
 define amdgpu_ps void @buffer_prefetch_data_imm_offset_vgpr_len(ptr addrspace(8) inreg %rsrc, i32 %len) {
 ; GCN-LABEL: buffer_prefetch_data_imm_offset_vgpr_len:
 ; GCN:       ; %bb.0: ; %entry
diff --git a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.data.ll b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.data.ll
index 8535133bab9be9..75a99c4916bf00 100644
--- a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.data.ll
+++ b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.data.ll
@@ -160,6 +160,83 @@ entry:
   ret void
 }
 
+define amdgpu_ps void @prefetch_data_sgpr_base_large_imm_len(ptr addrspace(4) inreg %ptr) {
+; GCN-LABEL: prefetch_data_sgpr_base_large_imm_len:
+; GCN:       ; %bb.0: ; %entry
+; GCN-NEXT:    s_prefetch_data s[0:1], 0x0, null, 8
+; GCN-NEXT:    s_endpgm
+;
+; GFX1250-SDAG-LABEL: prefetch_data_sgpr_base_large_imm_len:
+; GFX1250-SDAG:       ; %bb.0: ; %entry
+; GFX1250-SDAG-NEXT:    s_setreg_imm32_b32 hwreg(HW_REG_WAVE_MODE, 25, 1), 1 ; msbs: dst=0 src0=0 src1=0 src2=0
+; GFX1250-SDAG-NEXT:    s_mov_b64 s[64:65], 0
+; GFX1250-SDAG-NEXT:    v_nop
+; GFX1250-SDAG-NEXT:    global_prefetch_b8 v0, s[64:65] scope:SCOPE_SE
+; GFX1250-SDAG-NEXT:    s_prefetch_data s[0:1], 0x0, null, 8
+; GFX1250-SDAG-NEXT:    s_endpgm
+;
+; GFX1250-GISEL-LABEL: prefetch_data_sgpr_base_large_imm_len:
+; GFX1250-GISEL:       ; %bb.0: ; %entry
+; GFX1250-GISEL-NEXT:    s_setreg_imm32_b32 hwreg(HW_REG_WAVE_MODE, 25, 1), 1 ; msbs: dst=0 src0=0 src1=0 src2=0
+; GFX1250-GISEL-NEXT:    s_mov_b64 s[64:65], 0
+; GFX1250-GISEL-NEXT:    v_nop
+; GFX1250-GISEL-NEXT:    global_prefetch_b8 v0, s[64:65] scope:SCOPE_SE
+; GFX1250-GISEL-NEXT:    s_prefetch_data s[0:1], 0x0, null, 8
+; GFX1250-GISEL-NEXT:    s_endpgm
+;
+; GFX1310-SDAG-LABEL: prefetch_data_sgpr_base_large_imm_len:
+; GFX1310-SDAG:       ; %bb.0: ; %entry
+; GFX1310-SDAG-NEXT:    s_prefetch_data s[0:1], 0x0, null, 8
+; GFX1310-SDAG-NEXT:    s_endpgm
+;
+; GFX1310-GISEL-LABEL: prefetch_data_sgpr_base_large_imm_len:
+; GFX1310-GISEL:       ; %bb.0: ; %entry
+; GFX1310-GISEL-NEXT:    s_prefetch_data s[0:1], 0x0, null, 8
+; GFX1310-GISEL-NEXT:    s_endpgm
+entry:
+  tail call void @llvm.amdgcn.s.prefetch.data.p4(ptr addrspace(4) %ptr, i32 40)
+  ret void
+}
+
+define amdgpu_ps void @prefetch_data_sgpr_imm_base_large_imm_len(ptr addrspace(4) inreg %ptr) {
+; GCN-LABEL: prefetch_data_sgpr_imm_base_large_imm_len:
+; GCN:       ; %bb.0: ; %entry
+; GCN-NEXT:    s_prefetch_data s[0:1], 0x200, null, 8
+; GCN-NEXT:    s_endpgm
+;
+; GFX1250-SDAG-LABEL: prefetch_data_sgpr_imm_base_large_imm_len:
+; GFX1250-SDAG:       ; %bb.0: ; %entry
+; GFX1250-SDAG-NEXT:    s_setreg_imm32_b32 hwreg(HW_REG_WAVE_MODE, 25, 1), 1 ; msbs: dst=0 src0=0 src1=0 src2=0
+; GFX1250-SDAG-NEXT:    s_mov_b64 s[64:65], 0
+; GFX1250-SDAG-NEXT:    v_nop
+; GFX1250-SDAG-NEXT:    global_prefetch_b8 v0, s[64:65] scope:SCOPE_SE
+; GFX1250-SDAG-NEXT:    s_prefetch_data s[0:1], 0x200, null, 8
+; GFX1250-SDAG-NEXT:    s_endpgm
+;
+; GFX1250-GISEL-LABEL: prefetch_data_sgpr_imm_base_large_imm_len:
+; GFX1250-GISEL:       ; %bb.0: ; %entry
+; GFX1250-GISEL-NEXT:    s_setreg_imm32_b32 hwreg(HW_REG_WAVE_MODE, 25, 1), 1 ; msbs: dst=0 src0=0 src1=0 src2=0
+; GFX1250-GISEL-NEXT:    s_mov_b64 s[64:65], 0
+; GFX1250-GISEL-NEXT:    v_nop
+; GFX1250-GISEL-NEXT:    global_prefetch_b8 v0, s[64:65] scope:SCOPE_SE
+; GFX1250-GISEL-NEXT:    s_prefetch_data s[0:1], 0x200, null, 8
+; GFX1250-GISEL-NEXT:    s_endpgm
+;
+; GFX1310-SDAG-LABEL: prefetch_data_sgpr_imm_base_large_imm_len:
+; GFX1310-SDAG:       ; %bb.0: ; %entry
+; GFX1310-SDAG-NEXT:    s_prefetch_data s[0:1], 0x200, null, 8
+; GFX1310-SDAG-NEXT:    s_endpgm
+;
+; GFX1310-GISEL-LABEL: prefetch_data_sgpr_imm_base_large_imm_len:
+; GFX1310-GISEL:       ; %bb.0: ; %entry
+; GFX1310-GISEL-NEXT:    s_prefetch_data s[0:1], 0x200, null, 8
+; GFX1310-GISEL-NEXT:    s_endpgm
+entry:
+  %gep = getelementptr i32, ptr addrspace(4) %ptr, i32 128
+  tail call void @llvm.amdgcn.s.prefetch.data.p4(ptr addrspace(4) %gep, i32 40)
+  ret void
+}
+
 define amdgpu_ps void @prefetch_data_vgpr_base_sgpr_len(ptr addrspace(4) %ptr, i32 inreg %len) {
 ; GCN-LABEL: prefetch_data_vgpr_base_sgpr_len:
 ; GCN:       ; %bb.0: ; %entry
diff --git a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.inst.ll b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.inst.ll
index 30a645bcfc8d1b..520065077a6ef8 100644
--- a/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.inst.ll
+++ b/llvm/test/CodeGen/AMDGPU/llvm.amdgcn.s.prefetch.inst.ll
@@ -78,6 +78,43 @@ define amdgpu_ps void @prefetch_inst_sgpr_imm_base_imm_len(ptr addrspace(4) inre
   ret void
 }
 
+define amdgpu_ps void @prefetch_inst_sgpr_base_large_imm_len(ptr addrspace(4) inreg %ptr) {
+; GFX12-LABEL: prefetch_inst_sgpr_base_large_imm_len:
+; GFX12:       ; %bb.0:
+; GFX12-NEXT:    s_prefetch_inst s[0:1], 0x0, null, 8
+; GFX12-NEXT:    s_endpgm
+;
+; GFX1250-LABEL: prefetch_inst_sgpr_base_large_imm_len:
+; GFX1250:       ; %bb.0:
+; GFX1250-NEXT:    s_setreg_imm32_b32 hwreg(HW_REG_WAVE_MODE, 25, 1), 1 ; msbs: dst=0 src0=0 src1=0 src2=0
+; GFX1250-NEXT:    s_mov_b64 s[64:65], 0
+; GFX1250-NEXT:    v_nop
+; GFX1250-NEXT:    global_prefetch_b8 v0, s[64:65] scope:SCOPE_SE
+; GFX1250-NEXT:    s_prefetch_inst s[0:1], 0x0, null, 8
+; GFX1250-NEXT:    s_endpgm
+  tail call void @llvm.amdgcn.s.prefetch.inst.p4(ptr addrspace(4) %ptr, i32 40)
+  ret void
+}
+
+define amdgpu_ps void @prefetch_inst_sgpr_imm_base_large_imm_len(ptr addrspace(4) inreg %ptr) {
+; GFX12-LABEL: prefetch_inst_sgpr_imm_base_large_imm_len:
+; GFX12:       ; %bb.0:
+; GFX12-NEXT:    s_prefetch_inst s[0:1], 0x200, null, 8
+; GFX12-NEXT:    s_endpgm
+;
+; GFX1250-LABEL: prefetch_inst_sgpr_imm_base_large_imm_len:
+; GFX1250:       ; %bb.0:
+; GFX1250-NEXT:    s_setreg_imm32_b32 hwreg(HW_REG_WAVE_MODE, 25, 1), 1 ; msbs: dst=0 src0=0 src1=0 src2=0
+; GFX1250-NEXT:    s_mov_b64 s[64:65], 0
+; GFX1250-NEXT:    v_nop
+; GFX1250-NEXT:    global_prefetch_b8 v0, s[64:65] scope:SCOPE_SE
+; GFX1250-NEXT:    s_prefetch_inst s[0:1], 0x200, null, 8
+; GFX1250-NEXT:    s_endpgm
+  %gep = getelementptr i32, ptr addrspace(4) %ptr, i32 128
+  tail call void @llvm.amdgcn.s.prefetch.inst.p4(ptr addrspace(4) %gep, i32 40)
+  ret void
+}
+
 define amdgpu_ps void @prefetch_inst_vgpr_base_sgpr_len(ptr addrspace(4) %ptr, i32 inreg %len) {
 ; GFX12-LABEL: prefetch_inst_vgpr_base_sgpr_len:
 ; GFX12:       ; %bb.0:
diff --git a/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll b/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
index d8c6d3eda59396..d3280be4dacb39 100644
--- a/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
+++ b/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
@@ -7,27 +7,6 @@ entry:
   ret void
 }
 
-define amdgpu_ps void @prefetch_data_len_too_large(ptr addrspace(1) inreg %ptr) {
-  ; CHECK: prefetch length must be in the range [0, 31]
-  ; CHECK-NEXT: call void @llvm.amdgcn.s.prefetch.data.p1(ptr addrspace(1) %ptr, i32 32)
-  call void @llvm.amdgcn.s.prefetch.data.p1(ptr addrspace(1) %ptr, i32 32)
-  ret void
-}
-
-define amdgpu_ps void @prefetch_inst_len_too_large(ptr inreg %ptr) {
-  ; CHECK: prefetch length must be in the range [0, 31]
-  ; CHECK-NEXT: call void @llvm.amdgcn.s.prefetch.inst.p0(ptr %ptr, i32 255)
-  call void @llvm.amdgcn.s.prefetch.inst.p0(ptr %ptr, i32 255)
-  ret void
-}
-
-define amdgpu_ps void @buffer_prefetch_data_len_too_large(ptr addrspace(8) inreg %rsrc) {
-  ; CHECK: prefetch length must be in the range [0, 31]
-  ; CHECK-NEXT: call void @llvm.amdgcn.s.buffer.prefetch.data(ptr addrspace(8) %rsrc, i32 0, i32 64)
-  call void @llvm.amdgcn.s.buffer.prefetch.data(ptr addrspace(8) %rsrc, i32 0, i32 64)
-  ret void
-}
-
 define amdgpu_ps void @global_prefetch_reserved_th(ptr addrspace(1) %ptr) {
   ; CHECK: invalid cache policy for prefetch
   ; CHECK-NEXT: call void @llvm.amdgcn.global.prefetch(ptr addrspace(1) %ptr, i32 7)

>From d59b402b77aa5ca67371cbb5bfa1aa1f1fb60d59 Mon Sep 17 00:00:00 2001
From: Gheorghe-Teodor Bercea <dobercea at amd.com>
Date: Wed, 14 Oct 2026 20:30:33 -0400
Subject: [PATCH 3/4] Simplify prefetch operand checks

---
 clang/lib/Sema/SemaAMDGPU.cpp                        |  3 +--
 llvm/lib/IR/VerifierAMDGPU.cpp                       | 11 ++++-------
 llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp |  8 ++------
 llvm/lib/Target/AMDGPU/SMInstructions.td             |  3 +--
 4 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/clang/lib/Sema/SemaAMDGPU.cpp b/clang/lib/Sema/SemaAMDGPU.cpp
index f1c855d12fbcba..779e86c9822b2c 100644
--- a/clang/lib/Sema/SemaAMDGPU.cpp
+++ b/clang/lib/Sema/SemaAMDGPU.cpp
@@ -170,8 +170,7 @@ bool SemaAMDGPU::CheckAMDGCNBuiltinFunctionCall(const TargetInfo &TI,
                                            /*High=*/UINT16_MAX);
   case AMDGPU::BI__builtin_amdgcn_flat_prefetch:
   case AMDGPU::BI__builtin_amdgcn_global_prefetch: {
-    // Only th (bits 0-2, where 7 is reserved), scope (bits 3-4) and nv (bit 5)
-    // may be set.
+    // Only th (bits 0-2, not 7), scope (bits 3-4) and nv (bit 5) may be set.
     llvm::APSInt CPol;
     if (SemaRef.BuiltinConstantArgRange(TheCall, /*ArgNum=*/1, /*Low=*/0,
                                         /*High=*/63) ||
diff --git a/llvm/lib/IR/VerifierAMDGPU.cpp b/llvm/lib/IR/VerifierAMDGPU.cpp
index c2b3df901cfa23..81b4df3ce8e794 100644
--- a/llvm/lib/IR/VerifierAMDGPU.cpp
+++ b/llvm/lib/IR/VerifierAMDGPU.cpp
@@ -300,13 +300,10 @@ void llvm::verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID,
   }
   case Intrinsic::amdgcn_flat_prefetch:
   case Intrinsic::amdgcn_global_prefetch: {
-    // Only th (bits 0-2, where 7 is reserved), scope (bits 3-4) and nv (bit 5)
-    // may be set; scale_offset depends on the address form that is selected.
-    if (auto *CPolArg = dyn_cast<ConstantInt>(Call.getArgOperand(1))) {
-      uint64_t CPol = CPolArg->getZExtValue();
-      Check(CPol <= 0x3f && (CPol & 0x7) != 0x7,
-            "invalid cache policy for prefetch", &Call);
-    }
+    // Only th (bits 0-2, not 7), scope (bits 3-4) and nv (bit 5) may be set.
+    uint64_t CPol = cast<ConstantInt>(Call.getArgOperand(1))->getZExtValue();
+    Check(CPol <= 0x3f && (CPol & 0x7) != 0x7,
+          "invalid cache policy for prefetch", &Call);
     break;
   }
   case Intrinsic::amdgcn_load_to_lds:
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp
index 74577b7deedf47..f523bb2c0d67fc 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp
@@ -7593,12 +7593,8 @@ void AMDGPUInstructionSelector::renderTruncTImm(MachineInstrBuilder &MIB,
 void AMDGPUInstructionSelector::renderPrefetchLen(MachineInstrBuilder &MIB,
                                                   const MachineInstr &MI,
                                                   int OpIdx) const {
-  const MachineOperand &Op = MI.getOperand(OpIdx);
-  int64_t Imm;
-  if (Op.isReg() && mi_match(Op.getReg(), *MRI, m_ICst(Imm)))
-    MIB.addImm(Imm & 0x1f);
-  else
-    MIB.addImm(Op.getImm() & 0x1f);
+  Register Len = MI.getOperand(OpIdx).getReg();
+  MIB.addImm(*getIConstantVRegSExtVal(Len, *MRI) & 0x1f);
 }
 
 void AMDGPUInstructionSelector::renderZextBoolTImm(MachineInstrBuilder &MIB,
diff --git a/llvm/lib/Target/AMDGPU/SMInstructions.td b/llvm/lib/Target/AMDGPU/SMInstructions.td
index 2b711b0fd9e508..3d8ee085052e6e 100644
--- a/llvm/lib/Target/AMDGPU/SMInstructions.td
+++ b/llvm/lib/Target/AMDGPU/SMInstructions.td
@@ -1160,8 +1160,7 @@ defm : SMPrefetchPat<"INST", i32imm_zero>;
 let AddedComplexity = 12 in // Prefer scalar prefetch over global for r/o case.
 defm : SMPrefetchPat<"DATA", i32imm_one>;
 
-// The length field holds 5 bits; the high bits of a constant length are
-// dropped.
+// The length field holds only 5 bits.
 def as_prefetch_len : SDNodeXForm<timm, [{
   return CurDAG->getTargetConstant(N->getZExtValue() & 0x1f, SDLoc(N), MVT::i8);
 }]>;

>From fa075c96872d0bb2cc6fa94a4f803799615ac3b9 Mon Sep 17 00:00:00 2001
From: Gheorghe-Teodor Bercea <dobercea at amd.com>
Date: Mon, 19 Oct 2026 16:04:38 -0400
Subject: [PATCH 4/4] Declare the valid prefetch cache policies in TableGen

---
 llvm/include/llvm/IR/IntrinsicsAMDGPU.td        | 11 +++++++++--
 llvm/lib/IR/VerifierAMDGPU.cpp                  |  8 --------
 llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll |  4 ++--
 3 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/llvm/include/llvm/IR/IntrinsicsAMDGPU.td b/llvm/include/llvm/IR/IntrinsicsAMDGPU.td
index 49c3e990e27f4e..6e6396487e7faf 100644
--- a/llvm/include/llvm/IR/IntrinsicsAMDGPU.td
+++ b/llvm/include/llvm/IR/IntrinsicsAMDGPU.td
@@ -3407,12 +3407,18 @@ def int_amdgcn_ds_bpermute_fi_b32 :
   Intrinsic<[llvm_i32_ty], [llvm_i32_ty, llvm_i32_ty],
     [IntrNoMem, IntrConvergent, IntrWillReturn, IntrNoCallback, IntrNoFree]>;
 
+// A prefetch cache policy sets th (bits 0-2) to anything but the reserved
+// value 7, scope (bits 3-4) and nv (bit 5).
+defvar PrefetchCachePolicyRanges =
+    !foreach(i, !range(8), [!mul(i, 8), !add(!mul(i, 8), 6)]);
+
 def int_amdgcn_flat_prefetch : ClangBuiltin<"__builtin_amdgcn_flat_prefetch">,
   DefaultAttrsIntrinsic<[],
     [llvm_ptr_ty,  // Pointer
      llvm_i32_ty], // cachepolicy(imm), bits [0-2] = th, bits [3-4] = scope
     [IntrInaccessibleMemOrArgMemOnly, ReadOnly<ArgIndex<0>>,
-     NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<1>>],
+     NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<1>>,
+     RangeSet<ArgIndex<1>, PrefetchCachePolicyRanges>],
     "",
     [SDNPMemOperand]
   >;
@@ -3422,7 +3428,8 @@ def int_amdgcn_global_prefetch : ClangBuiltin<"__builtin_amdgcn_global_prefetch"
     [LLVMQualPointerType<1>, // Pointer
      llvm_i32_ty],           // cachepolicy(imm), bits [0-2] = th, bits [3-4] = scope
     [IntrInaccessibleMemOrArgMemOnly, ReadOnly<ArgIndex<0>>,
-     NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<1>>],
+     NoCapture<ArgIndex<0>>, ImmArg<ArgIndex<1>>,
+     RangeSet<ArgIndex<1>, PrefetchCachePolicyRanges>],
     "",
     [SDNPMemOperand]
   >;
diff --git a/llvm/lib/IR/VerifierAMDGPU.cpp b/llvm/lib/IR/VerifierAMDGPU.cpp
index 81b4df3ce8e794..5d7b46357d2849 100644
--- a/llvm/lib/IR/VerifierAMDGPU.cpp
+++ b/llvm/lib/IR/VerifierAMDGPU.cpp
@@ -298,14 +298,6 @@ void llvm::verifyAMDGPUIntrinsicCall(VerifierSupport &VS, Intrinsic::ID ID,
         "llvm.amdgcn.s.prefetch.data only supports global or constant memory");
     break;
   }
-  case Intrinsic::amdgcn_flat_prefetch:
-  case Intrinsic::amdgcn_global_prefetch: {
-    // Only th (bits 0-2, not 7), scope (bits 3-4) and nv (bit 5) may be set.
-    uint64_t CPol = cast<ConstantInt>(Call.getArgOperand(1))->getZExtValue();
-    Check(CPol <= 0x3f && (CPol & 0x7) != 0x7,
-          "invalid cache policy for prefetch", &Call);
-    break;
-  }
   case Intrinsic::amdgcn_load_to_lds:
   case Intrinsic::amdgcn_load_async_to_lds:
   case Intrinsic::amdgcn_global_load_lds:
diff --git a/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll b/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
index d3280be4dacb39..83cb16c5863123 100644
--- a/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
+++ b/llvm/test/Verifier/AMDGPU/intrinsic-prefetch.ll
@@ -8,14 +8,14 @@ entry:
 }
 
 define amdgpu_ps void @global_prefetch_reserved_th(ptr addrspace(1) %ptr) {
-  ; CHECK: invalid cache policy for prefetch
+  ; CHECK: immarg value 7 for arg 1 out of range set
   ; CHECK-NEXT: call void @llvm.amdgcn.global.prefetch(ptr addrspace(1) %ptr, i32 7)
   call void @llvm.amdgcn.global.prefetch(ptr addrspace(1) %ptr, i32 7)
   ret void
 }
 
 define amdgpu_ps void @flat_prefetch_extra_cpol_bits(ptr %ptr) {
-  ; CHECK: invalid cache policy for prefetch
+  ; CHECK: immarg value 2048 for arg 1 out of range set
   ; CHECK-NEXT: call void @llvm.amdgcn.flat.prefetch(ptr %ptr, i32 2048)
   call void @llvm.amdgcn.flat.prefetch(ptr %ptr, i32 2048)
   ret void



More information about the cfe-commits mailing list