diff --git a/src/tint/lang/core/ir/BUILD.bazel b/src/tint/lang/core/ir/BUILD.bazel
index 4567416..5b389d9 100644
--- a/src/tint/lang/core/ir/BUILD.bazel
+++ b/src/tint/lang/core/ir/BUILD.bazel
@@ -240,6 +240,7 @@
     "validator_call_test.cc",
     "validator_flow_control_test.cc",
     "validator_function_test.cc",
+    "validator_immediate_test.cc",
     "validator_test.cc",
     "validator_test.h",
     "validator_type_test.cc",
diff --git a/src/tint/lang/core/ir/BUILD.cmake b/src/tint/lang/core/ir/BUILD.cmake
index 7343968..08ded12 100644
--- a/src/tint/lang/core/ir/BUILD.cmake
+++ b/src/tint/lang/core/ir/BUILD.cmake
@@ -246,6 +246,7 @@
   lang/core/ir/validator_call_test.cc
   lang/core/ir/validator_flow_control_test.cc
   lang/core/ir/validator_function_test.cc
+  lang/core/ir/validator_immediate_test.cc
   lang/core/ir/validator_test.cc
   lang/core/ir/validator_test.h
   lang/core/ir/validator_type_test.cc
diff --git a/src/tint/lang/core/ir/BUILD.gn b/src/tint/lang/core/ir/BUILD.gn
index 621d52f..fb4b1f6 100644
--- a/src/tint/lang/core/ir/BUILD.gn
+++ b/src/tint/lang/core/ir/BUILD.gn
@@ -241,6 +241,7 @@
       "validator_call_test.cc",
       "validator_flow_control_test.cc",
       "validator_function_test.cc",
+      "validator_immediate_test.cc",
       "validator_test.cc",
       "validator_test.h",
       "validator_type_test.cc",
diff --git a/src/tint/lang/core/ir/validator.cc b/src/tint/lang/core/ir/validator.cc
index 482bbe3..9e3b748 100644
--- a/src/tint/lang/core/ir/validator.cc
+++ b/src/tint/lang/core/ir/validator.cc
@@ -33,6 +33,7 @@
 #include <string>
 #include <string_view>
 #include <utility>
+#include <vector>
 
 #include "src/tint/lang/core/intrinsic/table.h"
 #include "src/tint/lang/core/ir/access.h"
@@ -4306,6 +4307,74 @@
     return Success;
 }
 
+Result<uint32_t> ValidateSingleUserImmediate(const Module& ir) {
+    uint32_t user_immediate_size = 0;
+    for (auto* inst : *ir.root_block) {
+        auto* var = inst->As<core::ir::Var>();
+        if (!var) {
+            continue;
+        }
+        auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
+        if (!ptr) {
+            continue;
+        }
+        if (ptr->AddressSpace() == core::AddressSpace::kImmediate) {
+            if (user_immediate_size > 0) {
+                return Failure("module contains multiple user-declared immediate data");
+            }
+            user_immediate_size = tint::RoundUp(4u, ptr->StoreType()->Size());
+        }
+    }
+    return user_immediate_size;  // 0 if none found
+}
+
+Result<SuccessType> ValidateInternalImmediateOffset(uint32_t max_immediate_block_size,
+                                                    uint32_t user_immediate_data_size,
+                                                    const std::vector<ImmediateInfo>& immediates) {
+    struct Range {
+        uint32_t offset;
+        uint32_t size;
+    };
+    std::vector<Range> ranges;
+    ranges.reserve(immediates.size());
+    for (size_t i = 0; i < immediates.size(); ++i) {
+        const auto& info = immediates[i];
+        if (info.size == 0) {
+            return Failure("immediate data #" + std::to_string(i) + " has zero size");
+        }
+        if (info.offset & 0x3) {
+            return Failure("immediate data #" + std::to_string(i) +
+                           " offset is not 4-byte aligned");
+        }
+        if (info.offset < user_immediate_data_size) {
+            return Failure("immediate data #" + std::to_string(i) +
+                           " overlaps user-declared immediate data region");
+        }
+        if (info.offset > max_immediate_block_size) {
+            return Failure("immediate data #" + std::to_string(i) +
+                           " offset exceeds maximum immediate block size");
+        }
+        if (info.size > max_immediate_block_size ||
+            info.offset > max_immediate_block_size - info.size) {
+            return Failure("immediate data #" + std::to_string(i) +
+                           " (offset + size) exceeds maximum immediate block size");
+        }
+        ranges.push_back(Range{info.offset, info.size});
+    }
+    std::sort(ranges.begin(), ranges.end(),
+              [](const Range& a, const Range& b) { return a.offset < b.offset; });
+    for (size_t i = 1; i < ranges.size(); ++i) {
+        const auto& prev = ranges[i - 1];
+        const auto& cur = ranges[i];
+        if (cur.offset < prev.offset + prev.size) {
+            return Failure("immediate data ranges overlap (offset " + std::to_string(prev.offset) +
+                           " size " + std::to_string(prev.size) + " and offset " +
+                           std::to_string(cur.offset) + " size " + std::to_string(cur.size) + ")");
+        }
+    }
+    return Success;
+}
+
 }  // namespace tint::core::ir
 
 namespace std {
diff --git a/src/tint/lang/core/ir/validator.h b/src/tint/lang/core/ir/validator.h
index fedfacd..708cc48 100644
--- a/src/tint/lang/core/ir/validator.h
+++ b/src/tint/lang/core/ir/validator.h
@@ -28,6 +28,7 @@
 #ifndef SRC_TINT_LANG_CORE_IR_VALIDATOR_H_
 #define SRC_TINT_LANG_CORE_IR_VALIDATOR_H_
 
+#include <vector>
 #include "src/tint/utils/containers/enum_set.h"
 #include "src/tint/utils/result.h"
 
@@ -105,6 +106,26 @@
                                             Capabilities capabilities = {},
                                             std::string_view timing = "before");
 
+// Scans the module root block for user-declared immediate data (module-scope
+// `var<immediate>` declarations). Returns Success if there is at most one.
+// On success, the returned uint32_t is the 4-byte rounded-up size of the
+// user-declared immediate data (or 0 if none present). Fails if multiple
+// immediates are declared.
+Result<uint32_t> ValidateSingleUserImmediate(const Module& ir);
+
+// Immediate data validation helpers
+struct ImmediateInfo {
+    uint32_t offset = 0;
+    uint32_t size = 0;
+};
+
+// Validates internal (implementation-provided) immediates. Offsets must not overlap each other
+// or the user-declared immediate data (if present). `user_immediate_data_size` is the 4-byte
+// rounded size of the user immediate block, or 0 if none exists.
+Result<SuccessType> ValidateInternalImmediateOffset(uint32_t max_immediate_block_size,
+                                                    uint32_t user_immediate_data_size,
+                                                    const std::vector<ImmediateInfo>& immediates);
+
 }  // namespace tint::core::ir
 
 #endif  // SRC_TINT_LANG_CORE_IR_VALIDATOR_H_
diff --git a/src/tint/lang/core/ir/validator_immediate_test.cc b/src/tint/lang/core/ir/validator_immediate_test.cc
new file mode 100644
index 0000000..7bc3c98
--- /dev/null
+++ b/src/tint/lang/core/ir/validator_immediate_test.cc
@@ -0,0 +1,147 @@
+// Copyright 2025 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "src/tint/lang/core/ir/validator_test.h"
+
+#include "gtest/gtest.h"
+
+#include "src/tint/lang/core/ir/builder.h"
+#include "src/tint/lang/core/ir/validator.h"
+#include "src/tint/lang/core/type/pointer.h"
+#include "src/tint/lang/core/type/struct.h"
+
+namespace tint::core::ir {
+
+using namespace tint::core::fluent_types;  // NOLINT
+
+// Helper to make a module-scope immediate variable with given store type.
+static Var* MakeImmediate(Builder& b,
+                          Module& mod,
+                          const char* name,
+                          const core::type::Type* store_ty) {
+    auto* v = b.Var(name, core::AddressSpace::kImmediate, store_ty);
+    mod.root_block->Append(v);
+    return v;
+}
+
+class IR_ValidatorImmediateTest : public IR_ValidatorTest {};
+
+TEST_F(IR_ValidatorImmediateTest, ValidateSingleUserImmediate_None) {
+    // Empty module (no immediates)
+    auto res = ValidateSingleUserImmediate(mod);
+    ASSERT_EQ(res, Success) << res.Failure();
+    EXPECT_EQ(res.Get(), 0u);
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateSingleUserImmediate_One) {
+    // Single immediate variable with size 12 -> rounded to 12 (already multiple of 4)
+    auto* s = ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("a"), ty.array<i32, 3>()}});
+    MakeImmediate(b, mod, "immediate_data", s);
+    auto res = ValidateSingleUserImmediate(mod);
+    ASSERT_EQ(res, Success) << res.Failure();
+    EXPECT_EQ(res.Get(), 12u);  // 3 * 4 bytes
+}
+
+// Round-up behavior is implicitly covered by using a struct whose size is already a multiple of 4.
+
+TEST_F(IR_ValidatorImmediateTest, ValidateSingleUserImmediate_Multiple) {
+    auto* s = ty.Struct(mod.symbols.New("S"), {{mod.symbols.New("a"), ty.i32()}});
+    MakeImmediate(b, mod, "immediate0", s);
+    MakeImmediate(b, mod, "immediate1", s);
+    auto res = ValidateSingleUserImmediate(mod);
+    ASSERT_NE(res, Success);
+    EXPECT_THAT(res.Failure().reason,
+                ::testing::HasSubstr("multiple user-declared immediate data"));
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateInternalImmediateOffset_BasicSuccess) {
+    // No user immediate, two internal ranges non-overlapping
+    std::vector<ImmediateInfo> immediates = {
+        {0u, 16u},  // starts after user (none), size 16
+        {32u, 8u},
+    };
+    auto res = ValidateInternalImmediateOffset(0x1000u, 0u, immediates);
+    ASSERT_EQ(res, Success) << res.Failure();
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateInternalImmediateOffset_OverlapUser) {
+    // User immediate occupies first 32 bytes
+    std::vector<ImmediateInfo> immediates = {
+        {16u, 8u},
+    };
+    auto res = ValidateInternalImmediateOffset(0x1000u, 32u, immediates);
+    ASSERT_NE(res, Success);
+    EXPECT_THAT(res.Failure().reason,
+                ::testing::HasSubstr("overlaps user-declared immediate data"));
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateInternalImmediateOffset_ZeroSize) {
+    std::vector<ImmediateInfo> immediates = {
+        {64u, 0u},
+    };
+    auto res = ValidateInternalImmediateOffset(0x1000u, 0u, immediates);
+    ASSERT_NE(res, Success);
+    EXPECT_THAT(res.Failure().reason, ::testing::HasSubstr("zero size"));
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateInternalImmediateOffset_Misaligned) {
+    std::vector<ImmediateInfo> immediates = {
+        {10u, 4u},
+    };
+    auto res = ValidateInternalImmediateOffset(0x1000u, 0u, immediates);
+    ASSERT_NE(res, Success);
+    EXPECT_THAT(res.Failure().reason, ::testing::HasSubstr("not 4-byte aligned"));
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateInternalImmediateOffset_ExceedsMax) {
+    std::vector<ImmediateInfo> immediates = {
+        {0x2000u, 4u},
+    };
+    auto res = ValidateInternalImmediateOffset(0x1000u, 0u, immediates);
+    ASSERT_NE(res, Success);
+    EXPECT_THAT(res.Failure().reason, ::testing::HasSubstr("offset exceeds"));
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateInternalImmediateOffset_OffsetPlusSizeExceeds) {
+    std::vector<ImmediateInfo> immediates = {
+        {0x0FFCu, 16u},  // 0x0FFC + 16 > 0x1000
+    };
+    auto res = ValidateInternalImmediateOffset(0x1000u, 0u, immediates);
+    ASSERT_NE(res, Success);
+    EXPECT_THAT(res.Failure().reason, ::testing::HasSubstr("(offset + size)"));
+}
+
+TEST_F(IR_ValidatorImmediateTest, ValidateInternalImmediateOffset_RangesOverlap) {
+    std::vector<ImmediateInfo> immediates = {
+        {64u, 32u}, {80u, 16u},  // overlaps previous (64..96) vs (80..96)
+    };
+    auto res = ValidateInternalImmediateOffset(0x1000u, 0u, immediates);
+    ASSERT_NE(res, Success);
+    EXPECT_THAT(res.Failure().reason, ::testing::HasSubstr("ranges overlap"));
+}
+
+}  // namespace tint::core::ir
diff --git a/src/tint/lang/glsl/writer/writer.cc b/src/tint/lang/glsl/writer/writer.cc
index 4596eda6..f85e94e 100644
--- a/src/tint/lang/glsl/writer/writer.cc
+++ b/src/tint/lang/glsl/writer/writer.cc
@@ -27,8 +27,10 @@
 
 #include "src/tint/lang/glsl/writer/writer.h"
 
+#include <vector>
 #include "src/tint/lang/core/ir/core_builtin_call.h"
 #include "src/tint/lang/core/ir/module.h"
+#include "src/tint/lang/core/ir/validator.h"
 #include "src/tint/lang/core/ir/var.h"
 #include "src/tint/lang/core/type/binding_array.h"
 #include "src/tint/lang/core/type/pointer.h"
@@ -63,9 +65,8 @@
     // Make sure that every texture variable is in the texture_builtins_from_uniform binding list,
     // otherwise TextureBuiltinsFromUniform will fail.
     // TODO(https://issues.chromium.org/427172887) Be more precise for the
-    // texture_builtins_from_uniform checks. Also make sure there is at most one user-declared
-    // immediate, and make a note of its size.
-    uint32_t user_immediate_size = 0;
+    // texture_builtins_from_uniform checks. Also ensure there is at most one user-declared
+    // immediate.
     for (auto* inst : *ir.root_block) {
         auto* var = inst->As<core::ir::Var>();
 
@@ -125,15 +126,16 @@
             }
         }
 
-        if (ptr->AddressSpace() == core::AddressSpace::kImmediate) {
-            if (user_immediate_size > 0) {
-                // We've already seen a user-declared immediate data.
-                return Failure("multiple user-declared immediate data");
-            }
-            user_immediate_size = tint::RoundUp(4u, ptr->StoreType()->Size());
-        }
+        // user-declared immediate validation handled later by helper.
     }
 
+    auto user_immediate_res = core::ir::ValidateSingleUserImmediate(ir);
+    if (user_immediate_res != Success) {
+        return user_immediate_res.Failure();
+    }
+
+    uint32_t user_immediate_size = user_immediate_res.Get();
+
     // Check for calls to unsupported builtin functions.
     for (auto* inst : ir.Instructions()) {
         auto* call = inst->As<core::ir::CoreBuiltinCall>();
@@ -184,40 +186,22 @@
         }
     }
 
-    static constexpr uint32_t kMaxOffset = 0x1000;
-    Hashset<uint32_t, 4> immediate_word_offsets;
-    auto check_immediate_offset = [&](uint32_t offset) {
-        // Excessive values can cause OOM / timeouts when padding structures in the printer.
-        if (offset > kMaxOffset) {
-            return false;
+    {
+        std::vector<core::ir::ImmediateInfo> immediates;
+        if (options.first_instance_offset) {
+            immediates.push_back({*options.first_instance_offset, 4u});
         }
-        // Offset must be 4-byte aligned.
-        if (offset & 0x3) {
-            return false;
+        if (options.first_vertex_offset) {
+            immediates.push_back({*options.first_vertex_offset, 4u});
         }
-        // Offset must not have already been used.
-        if (!immediate_word_offsets.Add(offset >> 2)) {
-            return false;
+        if (options.depth_range_offsets) {
+            immediates.push_back({options.depth_range_offsets->max, 4u});
+            immediates.push_back({options.depth_range_offsets->min, 4u});
         }
-        // Offset must be after the user-defined immediate data.
-        if (offset < user_immediate_size) {
-            return false;
-        }
-        return true;
-    };
-
-    if (options.first_instance_offset && !check_immediate_offset(*options.first_instance_offset)) {
-        return Failure("invalid offset for first_instance_offset immediate data");
-    }
-
-    if (options.first_vertex_offset && !check_immediate_offset(*options.first_vertex_offset)) {
-        return Failure("invalid offset for first_vertex_offset immediate data");
-    }
-
-    if (options.depth_range_offsets) {
-        if (!check_immediate_offset(options.depth_range_offsets->max) ||
-            !check_immediate_offset(options.depth_range_offsets->min)) {
-            return Failure("invalid offsets for depth range immediate data");
+        if (auto res =
+                core::ir::ValidateInternalImmediateOffset(0x1000, user_immediate_size, immediates);
+            res != Success) {
+            return res.Failure();
         }
     }
 
diff --git a/src/tint/lang/hlsl/writer/writer.cc b/src/tint/lang/hlsl/writer/writer.cc
index 0ead198..60b23c6 100644
--- a/src/tint/lang/hlsl/writer/writer.cc
+++ b/src/tint/lang/hlsl/writer/writer.cc
@@ -29,9 +29,11 @@
 
 #include <memory>
 #include <utility>
+#include <vector>
 
 #include "src/tint/lang/core/ir/function.h"
 #include "src/tint/lang/core/ir/module.h"
+#include "src/tint/lang/core/ir/validator.h"
 #include "src/tint/lang/core/ir/var.h"
 #include "src/tint/lang/core/type/binding_array.h"
 #include "src/tint/lang/core/type/input_attachment.h"
@@ -66,21 +68,51 @@
     }
 
     // Check for unsupported module-scope variable address spaces and types.
-    for (auto* inst : *ir.root_block) {
-        auto* var = inst->As<core::ir::Var>();
-        auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
-        if (ptr->AddressSpace() == core::AddressSpace::kPixelLocal) {
-            // Check the pixel_local variables have corresponding entries in the PLS attachment map.
-            auto* str = ptr->StoreType()->As<core::type::Struct>();
-            for (uint32_t i = 0; i < str->Members().Length(); i++) {
-                if (options.pixel_local.attachments.count(i) == 0) {
-                    return Failure("missing pixel local attachment for member index " +
-                                   std::to_string(i));
+    {
+        for (auto* inst : *ir.root_block) {
+            auto* var = inst->As<core::ir::Var>();
+            auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
+            if (ptr->AddressSpace() == core::AddressSpace::kPixelLocal) {
+                // Check the pixel_local variables have corresponding entries in the PLS attachment
+                // map.
+                auto* str = ptr->StoreType()->As<core::type::Struct>();
+                for (uint32_t i = 0; i < str->Members().Length(); i++) {
+                    if (options.pixel_local.attachments.count(i) == 0) {
+                        return Failure("missing pixel local attachment for member index " +
+                                       std::to_string(i));
+                    }
                 }
             }
+            if (ptr->StoreType()->Is<core::type::InputAttachment>()) {
+                return Failure("input attachments are not supported by the HLSL backend");
+            }
         }
-        if (ptr->StoreType()->Is<core::type::InputAttachment>()) {
-            return Failure("input attachments are not supported by the HLSL backend");
+    }
+
+    auto user_immediate_res = core::ir::ValidateSingleUserImmediate(ir);
+    if (user_immediate_res != Success) {
+        return user_immediate_res.Failure();
+    }
+
+    uint32_t user_immediate_size = user_immediate_res.Get();
+
+    // Validate internal immediate offsets using shared helper.
+    {
+        std::vector<core::ir::ImmediateInfo> immediates;
+        if (options.first_index_offset) {
+            immediates.push_back({*options.first_index_offset, 4u});
+        }
+        if (options.first_instance_offset) {
+            immediates.push_back({*options.first_instance_offset, 4u});
+        }
+        if (options.num_workgroups_start_offset) {
+            immediates.push_back({*options.num_workgroups_start_offset, 4u});
+        }
+        // Pass user immediate size so internal offsets don't overlap user region.
+        if (auto res =
+                core::ir::ValidateInternalImmediateOffset(0x1000, user_immediate_size, immediates);
+            res != Success) {
+            return res.Failure();
         }
     }
 
diff --git a/src/tint/lang/msl/writer/writer.cc b/src/tint/lang/msl/writer/writer.cc
index 9a4c5b7..73f4981 100644
--- a/src/tint/lang/msl/writer/writer.cc
+++ b/src/tint/lang/msl/writer/writer.cc
@@ -27,7 +27,10 @@
 
 #include "src/tint/lang/msl/writer/writer.h"
 
+#include <vector>
+
 #include "src/tint/lang/core/ir/module.h"
+#include "src/tint/lang/core/ir/validator.h"
 #include "src/tint/lang/core/ir/var.h"
 #include "src/tint/lang/core/type/binding_array.h"
 #include "src/tint/lang/core/type/f16.h"
@@ -60,10 +63,8 @@
         }
     }
 
-    // Check for unsupported module-scope variable address spaces and types.
-    // Also make sure there is at most one user-declared immediate data, and make a note of its
-    // size.
-    uint32_t user_immediate_data_size = 0;
+    // Check for unsupported module-scope variable address spaces and types and ensure at most one
+    // user-declared immediate data.
     for (auto* inst : *ir.root_block) {
         auto* var = inst->As<core::ir::Var>();
         auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
@@ -73,52 +74,28 @@
         if (ptr->StoreType()->Is<core::type::InputAttachment>()) {
             return Failure("input attachments are not supported by the MSL backend");
         }
-        if (ptr->AddressSpace() == core::AddressSpace::kImmediate) {
-            if (user_immediate_data_size > 0) {
-                // We've already seen a user-declared immediate data.
-                return Failure("module contains multiple user-declared immediate data");
-            }
-            user_immediate_data_size = tint::RoundUp(4u, ptr->StoreType()->Size());
-        }
     }
 
-    // Metal suggested smaller than 4KB data uses SetBytes.
-    static constexpr uint32_t kMaxOffset = 0x1000;
-    Hashset<uint32_t, 4> immediate_data_word_offsets;
-    auto check_immediate_data_offset = [&](uint32_t offset) {
-        // Offset must be 4-byte aligned.
-        if (offset & 0x3) {
-            return false;
-        }
-        // Offset must not have already been used.
-        if (!immediate_data_word_offsets.Add(offset >> 2)) {
-            return false;
-        }
-        // Offset must be after the user-defined immediate data.
-        if (offset < user_immediate_data_size) {
-            return false;
-        }
-        return true;
-    };
+    auto user_immediate_res = core::ir::ValidateSingleUserImmediate(ir);
+    if (user_immediate_res != Success) {
+        return user_immediate_res.Failure();
+    }
 
-    auto valid_buffer_sizes_offset = [](const auto& buffer_sizes_offset) -> bool {
-        if (!buffer_sizes_offset) {
-            return false;
+    uint32_t user_immediate_size = user_immediate_res.Get();
+
+    // Buffer sizes uses vec4 array which requires 16 bytes alignment. Validate general
+    // constraints with shared helper first (size 16 here to reflect vec4 requirement for
+    // alignment checking later) then enforce 16-byte requirement.
+    if (options.array_length_from_constants.buffer_sizes_offset) {
+        std::vector<core::ir::ImmediateInfo> immediates = {
+            {*options.array_length_from_constants.buffer_sizes_offset, 16u},
+        };
+        if (auto res =
+                core::ir::ValidateInternalImmediateOffset(0x1000, user_immediate_size, immediates);
+            res != Success) {
+            return res.Failure();
         }
-
-        // Excessive values can cause OOM / timeouts when padding structures in the printer.
-        if (buffer_sizes_offset.value() > kMaxOffset) {
-            return false;
-        }
-
-        return true;
-    };
-
-    // Buffer sizes uses vec4 array which requires 16 bytes alignment.
-    if (valid_buffer_sizes_offset(options.array_length_from_constants.buffer_sizes_offset)) {
-        if (!check_immediate_data_offset(
-                options.array_length_from_constants.buffer_sizes_offset.value()) ||
-            (options.array_length_from_constants.buffer_sizes_offset.value() & 0xF)) {
+        if ((*options.array_length_from_constants.buffer_sizes_offset) & 0xF) {
             return Failure("invalid offsets for buffer sizes offset in immediate block");
         }
     }
diff --git a/src/tint/lang/spirv/writer/writer.cc b/src/tint/lang/spirv/writer/writer.cc
index f045e5f..72e896d 100644
--- a/src/tint/lang/spirv/writer/writer.cc
+++ b/src/tint/lang/spirv/writer/writer.cc
@@ -29,7 +29,9 @@
 
 #include <string>
 #include <utility>
+#include <vector>
 
+#include "src/tint/lang/core/ir/validator.h"
 #include "src/tint/lang/core/ir/var.h"
 #include "src/tint/lang/core/type/binding_array.h"
 #include "src/tint/lang/core/type/pointer.h"
@@ -82,52 +84,32 @@
         }
     }
 
-    // Check for unsupported module-scope variable address spaces and types.
-    // Also make sure there is at most one user-declared immediate data, and make a note of its
-    // size.
-    uint32_t user_immediate_data_size = 0;
+    // Check for unsupported module-scope variable address spaces and ensure at most one user
+    // immediate.
     for (auto* inst : *ir.root_block) {
         auto* var = inst->As<core::ir::Var>();
         auto* ptr = var->Result()->Type()->As<core::type::Pointer>();
         if (ptr->AddressSpace() == core::AddressSpace::kPixelLocal) {
             return Failure("pixel_local address space is not supported by the SPIR-V backend");
         }
-
-        if (ptr->AddressSpace() == core::AddressSpace::kImmediate) {
-            if (user_immediate_data_size > 0) {
-                // We've already seen a user-declared immediate data.
-                return Failure("module contains multiple user-declared immediate data");
-            }
-            user_immediate_data_size = tint::RoundUp(4u, ptr->StoreType()->Size());
-        }
     }
 
-    static constexpr uint32_t kMaxOffset = 0x1000;
-    Hashset<uint32_t, 4> immediate_data_word_offsets;
-    auto check_immediate_data_offset = [&](uint32_t offset) {
-        // Excessive values can cause OOM / timeouts when padding structures in the printer.
-        if (offset > kMaxOffset) {
-            return false;
-        }
-        // Offset must be 4-byte aligned.
-        if (offset & 0x3) {
-            return false;
-        }
-        // Offset must not have already been used.
-        if (!immediate_data_word_offsets.Add(offset >> 2)) {
-            return false;
-        }
-        // Offset must be after the user-defined immediate data.
-        if (offset < user_immediate_data_size) {
-            return false;
-        }
-        return true;
-    };
+    auto user_immediate_res = core::ir::ValidateSingleUserImmediate(ir);
+    if (user_immediate_res != Success) {
+        return user_immediate_res.Failure();
+    }
+
+    uint32_t user_immediate_size = user_immediate_res.Get();
 
     if (options.depth_range_offsets) {
-        if (!check_immediate_data_offset(options.depth_range_offsets->max) ||
-            !check_immediate_data_offset(options.depth_range_offsets->min)) {
-            return Failure("invalid offsets for depth range immediate data");
+        std::vector<core::ir::ImmediateInfo> immediates = {
+            {options.depth_range_offsets->max, 4u},
+            {options.depth_range_offsets->min, 4u},
+        };
+        if (auto res =
+                core::ir::ValidateInternalImmediateOffset(0x1000, user_immediate_size, immediates);
+            res != Success) {
+            return res.Failure();
         }
     }