From 3020d4d3bd4d592ec94e6ded057071a59c6b6dd3 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 21 Feb 2026 00:25:31 +0000
Subject: [PATCH 1/7] Initial plan


From a05bd445f0825eb229a59626a67ca951009b5141 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 21 Feb 2026 00:56:18 +0000
Subject: [PATCH 2/7] Add validation for odd-sized integer types in DXIL
 instruction operands and results

Extends the existing i8 check in the instruction validation loop to also
reject integer types with non-standard widths (anything other than
i1/i8/i16/i32/i64). This catches cases where optimizations produce
odd-sized types like i25 that are not valid DXIL types.

Adds a LIT test that verifies i25 types are rejected by the validator.

Fixes microsoft/DirectXShaderCompiler#6563

Co-authored-by: damyanp <8118402+damyanp@users.noreply.github.com>
---
 lib/DxilValidation/DxilValidation.cpp         | 18 ++++-
 .../LitDXILValidation/int-width-validation.ll | 70 +++++++++++++++++++
 2 files changed, 86 insertions(+), 2 deletions(-)
 create mode 100644 tools/clang/test/LitDXILValidation/int-width-validation.ll

diff --git a/lib/DxilValidation/DxilValidation.cpp b/lib/DxilValidation/DxilValidation.cpp
index 2236dd11f7..43ec9e990f 100644
--- a/lib/DxilValidation/DxilValidation.cpp
+++ b/lib/DxilValidation/DxilValidation.cpp
@@ -3388,10 +3388,17 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
           }
         }
         if (IntegerType *IT = dyn_cast<IntegerType>(op->getType())) {
-          if (IT->getBitWidth() == 8) {
+          unsigned BW = IT->getBitWidth();
+          if (BW == 8) {
             // We always fail if we see i8 as operand type of a non-lifetime
             // instruction.
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
+          } else if (BW != 1 && BW != 16 && BW != 32 && BW != 64) {
+            std::string O;
+            raw_string_ostream OSS(O);
+            IT->print(OSS);
+            ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
+                                        {OSS.str()});
           }
         }
       }
@@ -3402,12 +3409,19 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
       while (isa<ArrayType>(Ty))
         Ty = Ty->getArrayElementType();
       if (IntegerType *IT = dyn_cast<IntegerType>(Ty)) {
-        if (IT->getBitWidth() == 8) {
+        unsigned BW = IT->getBitWidth();
+        if (BW == 8) {
           // Allow i8* cast for llvm.lifetime.* intrinsics.
           if (!SupportsLifetimeIntrinsics || !isa<BitCastInst>(I) ||
               !onlyUsedByLifetimeMarkers(&I)) {
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
           }
+        } else if (BW != 1 && BW != 16 && BW != 32 && BW != 64) {
+          std::string O;
+          raw_string_ostream OSS(O);
+          IT->print(OSS);
+          ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
+                                      {OSS.str()});
         }
       }
 
diff --git a/tools/clang/test/LitDXILValidation/int-width-validation.ll b/tools/clang/test/LitDXILValidation/int-width-validation.ll
new file mode 100644
index 0000000000..5a13eca440
--- /dev/null
+++ b/tools/clang/test/LitDXILValidation/int-width-validation.ll
@@ -0,0 +1,70 @@
+; RUN: not %dxv %s 2>&1 | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-ms-dx"
+
+%dx.types.Handle = type { i8* }
+%dx.types.CBufRet.i32 = type { i32, i32, i32, i32 }
+%"$Globals" = type { i32 }
+
+define void @main() {
+  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
+  %2 = call %dx.types.CBufRet.i32 @dx.op.cbufferLoadLegacy.i32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
+  %3 = extractvalue %dx.types.CBufRet.i32 %2, 0
+  %4 = icmp ult i32 %3, 25
+  br i1 %4, label %5, label %11
+
+; <label>:5
+; CHECK: Int type 'i25' has an invalid width.
+  %6 = trunc i32 %3 to i25
+  %7 = lshr i25 15728638, %6
+  %8 = and i25 %7, 1
+  %9 = icmp ne i25 %8, 0
+  %10 = select i1 %9, float 1.000000e+00, float 0.000000e+00
+  br label %11
+
+; <label>:11
+  %12 = phi float [ %10, %5 ], [ 1.000000e+00, %0 ]
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+  ret void
+}
+
+; CHECK: Validation failed.
+
+; Function Attrs: nounwind
+declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #0
+
+; Function Attrs: nounwind readonly
+declare %dx.types.CBufRet.i32 @dx.op.cbufferLoadLegacy.i32(i32, %dx.types.Handle, i32) #1
+
+; Function Attrs: nounwind readonly
+declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #1
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readonly }
+
+!llvm.ident = !{!0}
+!dx.version = !{!1}
+!dx.valver = !{!2}
+!dx.shaderModel = !{!3}
+!dx.resources = !{!4}
+!dx.viewIdState = !{!7}
+!dx.entryPoints = !{!8}
+
+!0 = !{!"dxc(private) 1.9.0.2 (int-width-validation-test)"}
+!1 = !{i32 1, i32 0}
+!2 = !{i32 1, i32 10}
+!3 = !{!"ps", i32 6, i32 0}
+!4 = !{null, null, !5, null}
+!5 = !{!6}
+!6 = !{i32 0, %"$Globals"* undef, !"", i32 0, i32 0, i32 1, i32 4, null}
+!7 = !{[2 x i32] [i32 0, i32 4]}
+!8 = !{void ()* @main, !"main", !9, !4, null}
+!9 = !{null, !10, null}
+!10 = !{!11}
+!11 = !{i32 0, !"SV_Target", i8 9, i8 16, !12, i8 0, i32 1, i8 4, i32 0, i8 0, !13}
+!12 = !{i32 0}
+!13 = !{i32 3, i32 15}

From c961d90ac6c4e0502390f55e98a921503061a78f Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 21 Feb 2026 02:03:46 +0000
Subject: [PATCH 3/7] Refactor int width checks to switch and simplify test

Address review feedback:
- Replace if/else chains with switch statements for both operand
  and result type integer width validation
- Simplify LIT test to minimal IR with a single i25 add instruction

Co-authored-by: damyanp <8118402+damyanp@users.noreply.github.com>
---
 lib/DxilValidation/DxilValidation.cpp         | 28 +++++--
 .../LitDXILValidation/int-width-validation.ll | 73 +++++--------------
 2 files changed, 39 insertions(+), 62 deletions(-)

diff --git a/lib/DxilValidation/DxilValidation.cpp b/lib/DxilValidation/DxilValidation.cpp
index 43ec9e990f..b6293261b0 100644
--- a/lib/DxilValidation/DxilValidation.cpp
+++ b/lib/DxilValidation/DxilValidation.cpp
@@ -3388,17 +3388,25 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
           }
         }
         if (IntegerType *IT = dyn_cast<IntegerType>(op->getType())) {
-          unsigned BW = IT->getBitWidth();
-          if (BW == 8) {
+          switch (IT->getBitWidth()) {
+          case 1:
+          case 16:
+          case 32:
+          case 64:
+            break;
+          case 8:
             // We always fail if we see i8 as operand type of a non-lifetime
             // instruction.
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
-          } else if (BW != 1 && BW != 16 && BW != 32 && BW != 64) {
+            break;
+          default: {
             std::string O;
             raw_string_ostream OSS(O);
             IT->print(OSS);
             ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
                                         {OSS.str()});
+            break;
+          }
           }
         }
       }
@@ -3409,19 +3417,27 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
       while (isa<ArrayType>(Ty))
         Ty = Ty->getArrayElementType();
       if (IntegerType *IT = dyn_cast<IntegerType>(Ty)) {
-        unsigned BW = IT->getBitWidth();
-        if (BW == 8) {
+        switch (IT->getBitWidth()) {
+        case 1:
+        case 16:
+        case 32:
+        case 64:
+          break;
+        case 8:
           // Allow i8* cast for llvm.lifetime.* intrinsics.
           if (!SupportsLifetimeIntrinsics || !isa<BitCastInst>(I) ||
               !onlyUsedByLifetimeMarkers(&I)) {
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
           }
-        } else if (BW != 1 && BW != 16 && BW != 32 && BW != 64) {
+          break;
+        default: {
           std::string O;
           raw_string_ostream OSS(O);
           IT->print(OSS);
           ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
                                       {OSS.str()});
+          break;
+        }
         }
       }
 
diff --git a/tools/clang/test/LitDXILValidation/int-width-validation.ll b/tools/clang/test/LitDXILValidation/int-width-validation.ll
index 5a13eca440..e2f5478722 100644
--- a/tools/clang/test/LitDXILValidation/int-width-validation.ll
+++ b/tools/clang/test/LitDXILValidation/int-width-validation.ll
@@ -3,68 +3,29 @@
 target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
 target triple = "dxil-ms-dx"
 
-%dx.types.Handle = type { i8* }
-%dx.types.CBufRet.i32 = type { i32, i32, i32, i32 }
-%"$Globals" = type { i32 }
-
-define void @main() {
-  %1 = call %dx.types.Handle @dx.op.createHandle(i32 57, i8 2, i32 0, i32 0, i1 false)  ; CreateHandle(resourceClass,rangeId,index,nonUniformIndex)
-  %2 = call %dx.types.CBufRet.i32 @dx.op.cbufferLoadLegacy.i32(i32 59, %dx.types.Handle %1, i32 0)  ; CBufferLoadLegacy(handle,regIndex)
-  %3 = extractvalue %dx.types.CBufRet.i32 %2, 0
-  %4 = icmp ult i32 %3, 25
-  br i1 %4, label %5, label %11
-
-; <label>:5
 ; CHECK: Int type 'i25' has an invalid width.
-  %6 = trunc i32 %3 to i25
-  %7 = lshr i25 15728638, %6
-  %8 = and i25 %7, 1
-  %9 = icmp ne i25 %8, 0
-  %10 = select i1 %9, float 1.000000e+00, float 0.000000e+00
-  br label %11
+; CHECK: Validation failed.
 
-; <label>:11
-  %12 = phi float [ %10, %5 ], [ 1.000000e+00, %0 ]
-  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
-  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 1, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
-  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 2, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
-  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 3, float %12)  ; StoreOutput(outputSigId,rowIndex,colIndex,value)
+define void @main() {
+  %1 = add i25 0, 1
+  call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float 0.000000e+00)
   ret void
 }
 
-; CHECK: Validation failed.
-
-; Function Attrs: nounwind
 declare void @dx.op.storeOutput.f32(i32, i32, i32, i8, float) #0
 
-; Function Attrs: nounwind readonly
-declare %dx.types.CBufRet.i32 @dx.op.cbufferLoadLegacy.i32(i32, %dx.types.Handle, i32) #1
-
-; Function Attrs: nounwind readonly
-declare %dx.types.Handle @dx.op.createHandle(i32, i8, i32, i32, i1) #1
-
 attributes #0 = { nounwind }
-attributes #1 = { nounwind readonly }
-
-!llvm.ident = !{!0}
-!dx.version = !{!1}
-!dx.valver = !{!2}
-!dx.shaderModel = !{!3}
-!dx.resources = !{!4}
-!dx.viewIdState = !{!7}
-!dx.entryPoints = !{!8}
 
-!0 = !{!"dxc(private) 1.9.0.2 (int-width-validation-test)"}
-!1 = !{i32 1, i32 0}
-!2 = !{i32 1, i32 10}
-!3 = !{!"ps", i32 6, i32 0}
-!4 = !{null, null, !5, null}
-!5 = !{!6}
-!6 = !{i32 0, %"$Globals"* undef, !"", i32 0, i32 0, i32 1, i32 4, null}
-!7 = !{[2 x i32] [i32 0, i32 4]}
-!8 = !{void ()* @main, !"main", !9, !4, null}
-!9 = !{null, !10, null}
-!10 = !{!11}
-!11 = !{i32 0, !"SV_Target", i8 9, i8 16, !12, i8 0, i32 1, i8 4, i32 0, i8 0, !13}
-!12 = !{i32 0}
-!13 = !{i32 3, i32 15}
+!dx.version = !{!0}
+!dx.valver = !{!0}
+!dx.shaderModel = !{!1}
+!dx.entryPoints = !{!2}
+
+!0 = !{i32 1, i32 0}
+!1 = !{!"ps", i32 6, i32 0}
+!2 = !{void ()* @main, !"main", !3, null, null}
+!3 = !{null, !4, null}
+!4 = !{!5}
+!5 = !{i32 0, !"SV_Target", i8 9, i8 16, !6, i8 0, i32 1, i8 1, i32 0, i8 0, !7}
+!6 = !{i32 0}
+!7 = !{i32 3, i32 1}

From 6b616b599782f09eef1dc22a5d000fa1f14e310b Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 21 Feb 2026 04:16:32 +0000
Subject: [PATCH 4/7] Add test coverage for array-wrapped invalid int width

Add a select instruction with [2 x i25] result type to exercise the
array unwrapping path in the result type integer width validation.

Co-authored-by: damyanp <8118402+damyanp@users.noreply.github.com>
---
 tools/clang/test/LitDXILValidation/int-width-validation.ll | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/clang/test/LitDXILValidation/int-width-validation.ll b/tools/clang/test/LitDXILValidation/int-width-validation.ll
index e2f5478722..e1ee2c975f 100644
--- a/tools/clang/test/LitDXILValidation/int-width-validation.ll
+++ b/tools/clang/test/LitDXILValidation/int-width-validation.ll
@@ -3,11 +3,15 @@
 target datalayout = "e-m:e-p:32:32-i1:32-i8:32-i16:32-i32:32-i64:64-f16:32-f32:32-f64:64-n8:16:32:64"
 target triple = "dxil-ms-dx"
 
+; CHECK: Int type 'i25' has an invalid width.
 ; CHECK: Int type 'i25' has an invalid width.
 ; CHECK: Validation failed.
 
 define void @main() {
+  ; Test invalid int width in operand and result types.
   %1 = add i25 0, 1
+  ; Test invalid int width inside array result type.
+  %2 = select i1 true, [2 x i25] zeroinitializer, [2 x i25] zeroinitializer
   call void @dx.op.storeOutput.f32(i32 5, i32 0, i32 0, i8 0, float 0.000000e+00)
   ret void
 }

From 4fc1db86caa2d6f73fa985d45fa133a987e652f9 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Sat, 21 Feb 2026 04:43:21 +0000
Subject: [PATCH 5/7] Extract IsValidIntBitWidth helper for integer width
 validation

Consolidate three duplicate bit width checks into a single
IsValidIntBitWidth(unsigned) helper used by ValidateType and
both instruction-level checks.

Co-authored-by: damyanp <8118402+damyanp@users.noreply.github.com>
---
 lib/DxilValidation/DxilValidation.cpp | 44 ++++++++++++---------------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/lib/DxilValidation/DxilValidation.cpp b/lib/DxilValidation/DxilValidation.cpp
index b6293261b0..f6a2055bae 100644
--- a/lib/DxilValidation/DxilValidation.cpp
+++ b/lib/DxilValidation/DxilValidation.cpp
@@ -2659,6 +2659,19 @@ static bool IsDxilBuiltinStructType(StructType *ST, hlsl::OP *HlslOP) {
   }
 }
 
+static bool IsValidIntBitWidth(unsigned Width) {
+  switch (Width) {
+  case 1:
+  case 8:
+  case 16:
+  case 32:
+  case 64:
+    return true;
+  default:
+    return false;
+  }
+}
+
 // outer type may be: [ptr to][1 dim array of]( UDT struct | scalar )
 // inner type (UDT struct member) may be: [N dim array of]( UDT struct | scalar
 // ) scalar type may be: ( float(16|32|64) | int(16|32|64) )
@@ -2717,8 +2730,7 @@ static bool ValidateType(Type *Ty, ValidationContext &ValCtx,
     return true;
   }
   if (Ty->isIntegerTy()) {
-    unsigned Width = Ty->getIntegerBitWidth();
-    if (Width != 1 && Width != 8 && Width != 16 && Width != 32 && Width != 64) {
+    if (!IsValidIntBitWidth(Ty->getIntegerBitWidth())) {
       ValCtx.EmitTypeError(Ty, ValidationRule::TypesIntWidth);
       return false;
     }
@@ -3388,25 +3400,17 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
           }
         }
         if (IntegerType *IT = dyn_cast<IntegerType>(op->getType())) {
-          switch (IT->getBitWidth()) {
-          case 1:
-          case 16:
-          case 32:
-          case 64:
-            break;
-          case 8:
+          unsigned BW = IT->getBitWidth();
+          if (BW == 8) {
             // We always fail if we see i8 as operand type of a non-lifetime
             // instruction.
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
-            break;
-          default: {
+          } else if (!IsValidIntBitWidth(BW)) {
             std::string O;
             raw_string_ostream OSS(O);
             IT->print(OSS);
             ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
                                         {OSS.str()});
-            break;
-          }
           }
         }
       }
@@ -3417,27 +3421,19 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
       while (isa<ArrayType>(Ty))
         Ty = Ty->getArrayElementType();
       if (IntegerType *IT = dyn_cast<IntegerType>(Ty)) {
-        switch (IT->getBitWidth()) {
-        case 1:
-        case 16:
-        case 32:
-        case 64:
-          break;
-        case 8:
+        unsigned BW = IT->getBitWidth();
+        if (BW == 8) {
           // Allow i8* cast for llvm.lifetime.* intrinsics.
           if (!SupportsLifetimeIntrinsics || !isa<BitCastInst>(I) ||
               !onlyUsedByLifetimeMarkers(&I)) {
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
           }
-          break;
-        default: {
+        } else if (!IsValidIntBitWidth(BW)) {
           std::string O;
           raw_string_ostream OSS(O);
           IT->print(OSS);
           ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
                                       {OSS.str()});
-          break;
-        }
         }
       }
 

From d38ca6da8331ef426063362a6af3bc85e66a7ed6 Mon Sep 17 00:00:00 2001
From: "copilot-swe-agent[bot]" <198982749+Copilot@users.noreply.github.com>
Date: Mon, 23 Feb 2026 18:00:17 +0000
Subject: [PATCH 6/7] Add release note for integer width validation

Co-authored-by: damyanp <8118402+damyanp@users.noreply.github.com>
---
 docs/ReleaseNotes.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/ReleaseNotes.md b/docs/ReleaseNotes.md
index d426b955f2..609fd82f15 100644
--- a/docs/ReleaseNotes.md
+++ b/docs/ReleaseNotes.md
@@ -39,6 +39,7 @@ line upon naming the release. Refer to previous for appropriate section names.
 
 #### Other Changes
 - Fixed mesh shader semantics that were incorrectly case sensitive.
+- DXIL validation now rejects non-standard integer bit widths (e.g. `i25`) in instructions.
 
 ### Version 1.9.2602
 

From 0e181e0f33b5ab32e5106a2b6beacf4882a6058f Mon Sep 17 00:00:00 2001
From: Damyan Pepper <damyanp@microsoft.com>
Date: Thu, 26 Feb 2026 17:54:54 -0800
Subject: [PATCH 7/7] Use ValidateType instead of embedding bits of validation
 logic

---
 lib/DxilValidation/DxilValidation.cpp | 16 ++++------------
 1 file changed, 4 insertions(+), 12 deletions(-)

diff --git a/lib/DxilValidation/DxilValidation.cpp b/lib/DxilValidation/DxilValidation.cpp
index f6a2055bae..e8eb2b9c74 100644
--- a/lib/DxilValidation/DxilValidation.cpp
+++ b/lib/DxilValidation/DxilValidation.cpp
@@ -3405,12 +3405,8 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
             // We always fail if we see i8 as operand type of a non-lifetime
             // instruction.
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
-          } else if (!IsValidIntBitWidth(BW)) {
-            std::string O;
-            raw_string_ostream OSS(O);
-            IT->print(OSS);
-            ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
-                                        {OSS.str()});
+          } else {
+            ValidateType(IT, ValCtx);
           }
         }
       }
@@ -3428,12 +3424,8 @@ static void ValidateFunctionBody(Function *F, ValidationContext &ValCtx) {
               !onlyUsedByLifetimeMarkers(&I)) {
             ValCtx.EmitInstrError(&I, ValidationRule::TypesI8);
           }
-        } else if (!IsValidIntBitWidth(BW)) {
-          std::string O;
-          raw_string_ostream OSS(O);
-          IT->print(OSS);
-          ValCtx.EmitInstrFormatError(&I, ValidationRule::TypesIntWidth,
-                                      {OSS.str()});
+        } else {
+          ValidateType(IT, ValCtx);
         }
       }