diff --git a/build.zig b/build.zig
index 5bf9a9ad..a43d7938 100644
--- a/build.zig
+++ b/build.zig
@@ -7,7 +7,7 @@ pub fn build(b: *std.Build) void {
     const optimize = b.standardOptimizeOption(.{});
 
     const static_llvm = b.option(bool, "static-llvm", "Statically link LLVM (self-contained binary, no LLVM needed at runtime)") orelse false;
-    const llvm_prefix = b.option([]const u8, "llvm-prefix", "Path to LLVM installation") orelse "/opt/homebrew/opt/llvm@19";
+    const llvm_prefix = b.option([]const u8, "llvm-prefix", "Path to LLVM installation") orelse "/opt/homebrew/opt/llvm@22";
 
     const include_dir = b.fmt("{s}/include", .{llvm_prefix});
     const lib_dir = b.fmt("{s}/lib", .{llvm_prefix});
@@ -153,7 +153,7 @@ pub fn build(b: *std.Build) void {
             mod.link_libcpp = true;
         }
     } else {
-        mod.linkSystemLibrary("LLVM-19", .{});
+        mod.linkSystemLibrary("LLVM-22", .{});
         mod.linkSystemLibrary("clang-cpp", .{});
         // clang-cpp is C++ — need libc++ on macOS
         if (target_os != .windows and target_os != .linux) {
diff --git a/clang_shim.cpp b/clang_shim.cpp
index 4a7d8a5e..e371bcaa 100644
--- a/clang_shim.cpp
+++ b/clang_shim.cpp
@@ -113,7 +113,10 @@ buildCompilerInstance(const char *filename,
                       const llvm::SmallVectorImpl<const char *> &extra_flags,
                       char **out_error)
 {
-    auto diagOpts = new clang::DiagnosticOptions();
+    // LLVM 21+: DiagnosticOptions is a plain value passed by reference (no
+    // longer an IntrusiveRefCntPtr). It must outlive `diags` — both are locals
+    // in this scope, declared opts-before-engine, so destruction order is safe.
+    clang::DiagnosticOptions diagOpts;
     auto diagIDs = new clang::DiagnosticIDs();
     clang::DiagnosticsEngine diags(diagIDs, diagOpts,
                                     new clang::IgnoringDiagConsumer());
@@ -128,7 +131,7 @@ buildCompilerInstance(const char *filename,
     driver_args.push_back("-w");
 
 #ifdef SX_LLVM_PREFIX
-    static std::string resource_dir = std::string(SX_LLVM_PREFIX) + "/lib/clang/19";
+    static std::string resource_dir = std::string(SX_LLVM_PREFIX) + "/lib/clang/22";
     driver_args.push_back("-resource-dir");
     driver_args.push_back(resource_dir.c_str());
 
@@ -164,8 +167,10 @@ buildCompilerInstance(const char *filename,
         return nullptr;
     }
 
-    auto CI = std::make_unique<clang::CompilerInstance>();
-    CI->setInvocation(std::move(invocation));
+    // LLVM 21+: setInvocation() was removed — the invocation is constructor-
+    // injected instead. createDiagnostics(DiagnosticConsumer*) still exists as
+    // the convenience overload (it builds a default VFS internally).
+    auto CI = std::make_unique<clang::CompilerInstance>(std::move(invocation));
     CI->createDiagnostics(new clang::IgnoringDiagConsumer());
     return CI;
 }
@@ -283,8 +288,9 @@ extern "C" LLVMMemoryBufferRef sx_clang_compile_to_object(
         return nullptr;
     }
 
-    // Compile LLVM module to native object code
-    std::string triple = mod->getTargetTriple();
+    // Compile LLVM module to native object code.
+    // LLVM 21+: getTargetTriple() returns a const Triple& (was std::string).
+    const llvm::Triple &triple = mod->getTargetTriple();
     std::string err_str;
     const llvm::Target *target = llvm::TargetRegistry::lookupTarget(triple, err_str);
     if (!target) {
diff --git a/design/bundled-zig-link-backend-design.md b/design/bundled-zig-link-backend-design.md
index 1c652e93..d9de9441 100644
--- a/design/bundled-zig-link-backend-design.md
+++ b/design/bundled-zig-link-backend-design.md
@@ -290,7 +290,7 @@ Rules:
 
 | Alternative | Why not (now) |
 |-------------|---------------|
-| **In-process lld + bundled musl sysroot** (sx owns the pipeline; no zig) | Requires a custom LLVM build *with* lld — the Homebrew `llvm@19` here ships none (`liblld*.a`, headers, `ld.lld` all absent) — plus a C++ lld shim and per-arch prebuilt musl. Strictly more work for the same user-visible result. The right *eventual* target if we want zero foreign binaries; tracked as a follow-up. |
+| **In-process lld + bundled musl sysroot** (sx owns the pipeline; no zig) | Requires a custom LLVM build *with* lld — the Homebrew `llvm@22` here ships none (`liblld*.a`, headers, `ld.lld` all absent) — plus a C++ lld shim and per-arch prebuilt musl. Strictly more work for the same user-visible result. The right *eventual* target if we want zero foreign binaries; tracked as a follow-up. |
 | **Full Zig-style: build libc from source on demand** | Most flexible (any arch/libc version, no prebuilt blobs) but the most work; only worth it after the in-process-lld path exists. |
 | **Document a hard dependency on system `cc`** | Zero engineering, but defeats the goal — the box still needs `build-essential`. Acceptable only as the current fallback, not the distribution story. |
 | **Bundle just `ld.lld` + a musl sysroot (no full zig)** | Smaller than a whole zig, but we'd hand-manage crt object selection, dynamic-linker paths, and import libs — i.e. re-derive what `zig cc` already encapsulates. Bundle-size saving doesn't justify the fragility. |
diff --git a/design/inline-asm-design.md b/design/inline-asm-design.md
index 47f40e47..0cc05e63 100644
--- a/design/inline-asm-design.md
+++ b/design/inline-asm-design.md
@@ -14,10 +14,10 @@
 ## 0. TL;DR + feasibility
 
 * **Feasible today, no new infrastructure.** sx already links LLVM (`build.zig:10`
-  → `/opt/homebrew/opt/llvm@19`) and `@cImport`s `llvm-c/Core.h`
+  → `/opt/homebrew/opt/llvm@22`) and `@cImport`s `llvm-c/Core.h`
   (`src/llvm_api.zig:1-17`). That header exposes everything inline asm needs,
   reachable right now through `llvm_api.c.*`:
-  * `LLVMGetInlineAsm(Ty, AsmString, AsmStringSize, Constraints, ConstraintsSize, HasSideEffects, IsAlignStack, Dialect, CanThrow)` — builds the asm callee (LLVM 19/21 share this 9-arg signature).
+  * `LLVMGetInlineAsm(Ty, AsmString, AsmStringSize, Constraints, ConstraintsSize, HasSideEffects, IsAlignStack, Dialect, CanThrow)` — builds the asm callee (LLVM 19–22 share this 9-arg signature).
   * `LLVMInlineAsmDialectATT` / `LLVMInlineAsmDialectIntel`.
   * `LLVMBuildCall2(...)` — already used pervasively in `src/ir/emit_llvm.zig` (e.g. the Obj-C msgSend path) — calls the asm value like a function.
   * `LLVMAppendModuleInlineAsm(M, Asm, Len)` — module-level (global) asm.
diff --git a/examples/0101-types-types.sx b/examples/0101-types-types.sx
index 36fe2ebe..fa555621 100644
--- a/examples/0101-types-types.sx
+++ b/examples/0101-types-types.sx
@@ -13,18 +13,24 @@ Foo :: struct {
 }
 
 main :: () {
-    a : Foo; // default value of 0
+    a : Foo; // a=0, b=42, d=17 from defaults; c is `---` (undefined)
+    // `c` was declared `---`, so its contents are undefined here. Pin it
+    // before printing so the snapshot is deterministic — printing the raw
+    // undefined byte yields whatever garbage the stack/codegen leaves.
+    a.c = 0;
     print("a 0 : {}\n", a);
-    a.a = 1; 
-    // a.c is still undefined at this point
+    a.a = 1;
     a.c = 8;
     print("a 1 : {}\n", a);
 
     large: f64 = 5989.5;
-    b : Foo = ---; // undefined
+    b : Foo = ---; // EVERY field undefined — `= ---` skips all defaults
+    // Assign each field explicitly; nothing here may be read before it is
+    // written, since `= ---` left the whole struct undefined.
     b.a = 1;
-    b.c = xx large; // converts f64 to u8
-    // expect stdout : "b: Foo{a:1, b: 42, c: 7, d: 12}"
+    b.b = SPECIAL_VALUE;      // re-supply the default `= ---` skipped
+    b.c = xx large;           // converts f64 to u8 (5989.5 -> 101)
+    b.d = xx resolve(5);      // converts i32 to u8 (17)
     print("b: {}", b);
     print("\n");
 
diff --git a/examples/expected/0031-basic-local-fn-return.ir b/examples/expected/0031-basic-local-fn-return.ir
index 0528550c..6a37ee8a 100644
--- a/examples/expected/0031-basic-local-fn-return.ir
+++ b/examples/expected/0031-basic-local-fn-return.ir
@@ -1101,11 +1101,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -5625,9 +5625,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.713, i64 28 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.714, i64 0 }, ptr %allocaN, align 8
@@ -5678,9 +5678,9 @@ entry:
   store { i64, i64 } %ba.val6, ptr %igp.ptr7, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr9 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr9, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 2, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.717, i64 0 }, ptr %allocaN, align 8
@@ -5731,9 +5731,9 @@ entry:
 define internal { i64, [8 x i8] } @local_sh__1(ptr %0) #0 {
 entry:
   %ei.tmp = alloca { i64, [8 x i8] }, align 8
-  %ei.tagp = getelementptr inbounds { i64, [8 x i8] }, ptr %ei.tmp, i32 0, i32 0
+  %ei.tagp = getelementptr inbounds nuw { i64, [8 x i8] }, ptr %ei.tmp, i32 0, i32 0
   store i64 0, ptr %ei.tagp, align 8
-  %ei.pp = getelementptr inbounds { i64, [8 x i8] }, ptr %ei.tmp, i32 0, i32 1
+  %ei.pp = getelementptr inbounds nuw { i64, [8 x i8] }, ptr %ei.tmp, i32 0, i32 1
   store float 2.500000e+00, ptr %ei.pp, align 4
   %ei.val = load { i64, [8 x i8] }, ptr %ei.tmp, align 8
   ret { i64, [8 x i8] } %ei.val
@@ -5756,9 +5756,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.720, i64 0 }, ptr %allocaN, align 8
@@ -10406,7 +10406,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -10414,14 +10414,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -10430,7 +10430,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -10439,7 +10439,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
@@ -10586,7 +10586,7 @@ fv.default:                                       ; preds = %entry
 
 fv.case:                                          ; preds = %entry
   store { i64, [8 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [8 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [8 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load float, ptr %fv.pp, align 4
   %fNi32 = bitcast float %fv.field to i32
   %zN = zext i32 %fNi32 to i64
@@ -10595,7 +10595,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [8 x i8] } %loadN, ptr %fv.utmp7, align 8
-  %fv.pp8 = getelementptr inbounds { i64, [8 x i8] }, ptr %fv.utmp7, i32 0, i32 1
+  %fv.pp8 = getelementptr inbounds nuw { i64, [8 x i8] }, ptr %fv.utmp7, i32 0, i32 1
   %fv.field9 = load { float, float }, ptr %fv.pp8, align 4
   store { float, float } %fv.field9, ptr %ba.tmp, align 4
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
diff --git a/examples/expected/0032-basic-ufcs-return-type.ir b/examples/expected/0032-basic-ufcs-return-type.ir
index 7637e2b9..02c8f1c9 100644
--- a/examples/expected/0032-basic-ufcs-return-type.ir
+++ b/examples/expected/0032-basic-ufcs-return-type.ir
@@ -1069,11 +1069,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -5553,9 +5553,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.705, i64 29 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.706, i64 0 }, ptr %allocaN, align 8
@@ -5593,9 +5593,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.709, i64 0 }, ptr %allocaN, align 8
@@ -5645,9 +5645,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.712, i64 0 }, ptr %allocaN, align 8
@@ -10214,7 +10214,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -10222,14 +10222,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -10238,7 +10238,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -10247,7 +10247,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0044-basic-default-arg-expansion.ir b/examples/expected/0044-basic-default-arg-expansion.ir
index 3d9ba62f..2591d38a 100644
--- a/examples/expected/0044-basic-default-arg-expansion.ir
+++ b/examples/expected/0044-basic-default-arg-expansion.ir
@@ -1046,11 +1046,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4465,9 +4465,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.379, i64 0 }, ptr %allocaN, align 8
@@ -4517,9 +4517,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.382, i64 0 }, ptr %allocaN, align 8
@@ -4587,9 +4587,9 @@ entry:
   store { i64, i64 } %ba.val11, ptr %igp.ptr12, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr14 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr14, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 3, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.385, i64 0 }, ptr %allocaN, align 8
@@ -8941,7 +8941,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8949,14 +8949,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8965,7 +8965,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8974,7 +8974,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0101-types-types.stdout b/examples/expected/0101-types-types.stdout
index 17052bbf..86ee77ae 100644
--- a/examples/expected/0101-types-types.stdout
+++ b/examples/expected/0101-types-types.stdout
@@ -1,4 +1,4 @@
 a 0 : Foo{a: 0, b: 42, c: 0, d: 17}
 a 1 : Foo{a: 1, b: 42, c: 8, d: 17}
-b: Foo{a: 1, b: 0, c: 101, d: 0}
+b: Foo{a: 1, b: 42, c: 101, d: 17}
 Pack{a: 1, b: 0, c: 3, d: 5, f: 9, v: 100, x: 3.500000}
diff --git a/examples/expected/0107-types-int-cmp-in-float-ternary.ir b/examples/expected/0107-types-int-cmp-in-float-ternary.ir
index 51fa8606..1353519a 100644
--- a/examples/expected/0107-types-int-cmp-in-float-ternary.ir
+++ b/examples/expected/0107-types-int-cmp-in-float-ternary.ir
@@ -1031,11 +1031,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4432,9 +4432,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.373, i64 0 }, ptr %allocaN, align 8
@@ -8774,7 +8774,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8782,14 +8782,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8798,7 +8798,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8807,7 +8807,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0200-generics-generic.ir b/examples/expected/0200-generics-generic.ir
index fba4330c..e367c2e9 100644
--- a/examples/expected/0200-generics-generic.ir
+++ b/examples/expected/0200-generics-generic.ir
@@ -1032,11 +1032,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4425,9 +4425,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.371, i64 0 }, ptr %allocaN, align 8
@@ -4489,9 +4489,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.374, i64 0 }, ptr %allocaN, align 8
@@ -8830,7 +8830,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8838,14 +8838,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8854,7 +8854,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8863,7 +8863,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0201-generics-generic-struct.ir b/examples/expected/0201-generics-generic-struct.ir
index fe4186ad..fa26e36e 100644
--- a/examples/expected/0201-generics-generic-struct.ir
+++ b/examples/expected/0201-generics-generic-struct.ir
@@ -1168,11 +1168,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4800,7 +4800,7 @@ entry:
   %loadN = load float, ptr %allocaN, align 4
   call void @print__ct_sd243afec30847211__pack_f32(ptr @__sx_default_context, float %loadN)
   %loadN = load <3 x float>, ptr %allocaN, align 16
-  %fmul = fmul <3 x float> %loadN, <float 2.000000e+00, float 2.000000e+00, float 2.000000e+00>
+  %fmul = fmul <3 x float> %loadN, splat (float 2.000000e+00)
   %allocaN = alloca <3 x float>, align 16
   store <3 x float> %fmul, ptr %allocaN, align 16
   %loadN = load <3 x float>, ptr %allocaN, align 16
@@ -4817,9 +4817,9 @@ entry:
   %loadN = load double, ptr %allocaN, align 8
   call void @print__ct_sa2a846ee0ce9045d__pack_f64(ptr @__sx_default_context, double %loadN)
   %ei.tmp = alloca { i64, [4 x i8] }, align 8
-  %ei.tagp = getelementptr inbounds { i64, [4 x i8] }, ptr %ei.tmp, i32 0, i32 0
+  %ei.tagp = getelementptr inbounds nuw { i64, [4 x i8] }, ptr %ei.tmp, i32 0, i32 0
   store i64 1, ptr %ei.tagp, align 8
-  %ei.pp = getelementptr inbounds { i64, [4 x i8] }, ptr %ei.tmp, i32 0, i32 1
+  %ei.pp = getelementptr inbounds nuw { i64, [4 x i8] }, ptr %ei.tmp, i32 0, i32 1
   store float 5.000000e-01, ptr %ei.pp, align 4
   %ei.val = load { i64, [4 x i8] }, ptr %ei.tmp, align 8
   %allocaN = alloca { i64, [4 x i8] }, align 8
@@ -4863,9 +4863,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.399, i64 0 }, ptr %allocaN, align 8
@@ -4919,9 +4919,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.402, i64 0 }, ptr %allocaN, align 8
@@ -4975,9 +4975,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.405, i64 0 }, ptr %allocaN, align 8
@@ -5031,9 +5031,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.408, i64 0 }, ptr %allocaN, align 8
@@ -5087,9 +5087,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.411, i64 0 }, ptr %allocaN, align 8
@@ -5142,9 +5142,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.414, i64 0 }, ptr %allocaN, align 8
@@ -5196,9 +5196,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.417, i64 0 }, ptr %allocaN, align 8
@@ -5251,9 +5251,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.420, i64 0 }, ptr %allocaN, align 8
@@ -5307,9 +5307,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.423, i64 0 }, ptr %allocaN, align 8
@@ -5370,9 +5370,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.426, i64 0 }, ptr %allocaN, align 8
@@ -5424,9 +5424,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.429, i64 0 }, ptr %allocaN, align 8
@@ -5472,9 +5472,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.432, i64 0 }, ptr %allocaN, align 8
@@ -10256,7 +10256,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -10264,14 +10264,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -10280,7 +10280,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -10289,7 +10289,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
@@ -10434,7 +10434,7 @@ fv.default:                                       ; preds = %entry
 
 fv.case:                                          ; preds = %entry
   store { i64, [4 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [4 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [4 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i32, ptr %fv.pp, align 4
   %iN = sext i32 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %iN, 1
@@ -10442,7 +10442,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [4 x i8] } %loadN, ptr %fv.utmp7, align 8
-  %fv.pp8 = getelementptr inbounds { i64, [4 x i8] }, ptr %fv.utmp7, i32 0, i32 1
+  %fv.pp8 = getelementptr inbounds nuw { i64, [4 x i8] }, ptr %fv.utmp7, i32 0, i32 1
   %fv.field9 = load float, ptr %fv.pp8, align 4
   %fNi32 = bitcast float %fv.field9 to i32
   %zN = zext i32 %fNi32 to i64
diff --git a/examples/expected/0301-closures-fn-pointers.ir b/examples/expected/0301-closures-fn-pointers.ir
index b6182bad..2e98aced 100644
--- a/examples/expected/0301-closures-fn-pointers.ir
+++ b/examples/expected/0301-closures-fn-pointers.ir
@@ -1037,11 +1037,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4464,9 +4464,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.373, i64 0 }, ptr %allocaN, align 8
@@ -4516,9 +4516,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.376, i64 0 }, ptr %allocaN, align 8
@@ -4568,9 +4568,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.379, i64 0 }, ptr %allocaN, align 8
@@ -8909,7 +8909,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8917,14 +8917,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8933,7 +8933,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8942,7 +8942,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0400-protocols-impl-for-builtin.ir b/examples/expected/0400-protocols-impl-for-builtin.ir
index 14a2ea31..f1de52c4 100644
--- a/examples/expected/0400-protocols-impl-for-builtin.ir
+++ b/examples/expected/0400-protocols-impl-for-builtin.ir
@@ -1117,11 +1117,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4512,9 +4512,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.376, i64 0 }, ptr %allocaN, align 8
@@ -4577,9 +4577,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.379, i64 0 }, ptr %allocaN, align 8
@@ -8996,7 +8996,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -9004,14 +9004,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9020,7 +9020,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9029,7 +9029,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0413-protocols-parameterized-protocol-value.ir b/examples/expected/0413-protocols-parameterized-protocol-value.ir
index 558bcb29..a9fae725 100644
--- a/examples/expected/0413-protocols-parameterized-protocol-value.ir
+++ b/examples/expected/0413-protocols-parameterized-protocol-value.ir
@@ -1119,11 +1119,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4680,9 +4680,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.391, i64 0 }, ptr %allocaN, align 8
@@ -4740,9 +4740,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.394, i64 0 }, ptr %allocaN, align 8
@@ -9518,7 +9518,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -9526,14 +9526,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9542,7 +9542,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9551,7 +9551,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0414-protocols-generic-struct-protocol-erase.ir b/examples/expected/0414-protocols-generic-struct-protocol-erase.ir
index 50f839fc..7c8c3fe6 100644
--- a/examples/expected/0414-protocols-generic-struct-protocol-erase.ir
+++ b/examples/expected/0414-protocols-generic-struct-protocol-erase.ir
@@ -1124,11 +1124,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4654,19 +4654,19 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { { { ptr, ptr } }, i64 }, align 8
   store { { { ptr, ptr } }, i64 } undef, ptr %allocaN, align 8
-  %gepN = getelementptr inbounds { { { ptr, ptr } }, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { { { ptr, ptr } }, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 99, ptr %gepN, align 8
   %loadN = load { i64 }, ptr %alloca, align 8
   %si = insertvalue { ptr, ptr } undef, ptr %alloca, 0
   %siN = insertvalue { ptr, ptr } %si, ptr @__VL__i64__IntCell__vtable, 1
   %ti = insertvalue { { ptr, ptr } } undef, { ptr, ptr } %siN, 0
-  %gepN = getelementptr inbounds { { { ptr, ptr } }, i64 }, ptr %allocaN, i32 0, i32 0
+  %gepN = getelementptr inbounds nuw { { { ptr, ptr } }, i64 }, ptr %allocaN, i32 0, i32 0
   store { { ptr, ptr } } %ti, ptr %gepN, align 8
   %loadN = load { { { ptr, ptr } }, i64 }, ptr %allocaN, align 8
   %siN = insertvalue { ptr, ptr } undef, ptr %allocaN, 0
@@ -4713,9 +4713,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.395, i64 0 }, ptr %allocaN, align 8
@@ -9507,7 +9507,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -9515,14 +9515,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9531,7 +9531,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9540,7 +9540,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0416-protocols-auto-type-erasure.ir b/examples/expected/0416-protocols-auto-type-erasure.ir
index 2c23a4d6..3d0cea0d 100644
--- a/examples/expected/0416-protocols-auto-type-erasure.ir
+++ b/examples/expected/0416-protocols-auto-type-erasure.ir
@@ -1175,11 +1175,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -5753,7 +5753,7 @@ entry:
   %alloca = alloca ptr, align 8
   store ptr %1, ptr %alloca, align 8
   %load = load ptr, ptr %alloca, align 8
-  %gep = getelementptr inbounds { i32 }, ptr %load, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { i32 }, ptr %load, i32 0, i32 0
   %loadN = load i32, ptr %gep, align 4
   %add = add i32 %loadN, 1
   store i32 %add, ptr %gep, align 4
@@ -5783,7 +5783,7 @@ entry:
   store i32 %2, ptr %allocaN, align 4
   %load = load i32, ptr %allocaN, align 4
   %loadN = load ptr, ptr %alloca, align 8
-  %gep = getelementptr inbounds { i32 }, ptr %loadN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { i32 }, ptr %loadN, i32 0, i32 0
   %loadN = load i32, ptr %gep, align 4
   %add = add i32 %loadN, %load
   store i32 %add, ptr %gep, align 4
@@ -5909,9 +5909,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.727, i64 26 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.728, i64 0 }, ptr %allocaN, align 8
@@ -5989,9 +5989,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.731, i64 0 }, ptr %allocaN, align 8
@@ -6055,9 +6055,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.734, i64 0 }, ptr %allocaN, align 8
@@ -6133,9 +6133,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.737, i64 0 }, ptr %allocaN, align 8
@@ -6205,9 +6205,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.740, i64 0 }, ptr %allocaN, align 8
@@ -6269,9 +6269,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.743, i64 0 }, ptr %allocaN, align 8
@@ -11363,7 +11363,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -11371,14 +11371,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -11387,7 +11387,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -11396,7 +11396,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0507-packs-pack-mono-dedup.ir b/examples/expected/0507-packs-pack-mono-dedup.ir
index 0cb1b1cf..284de085 100644
--- a/examples/expected/0507-packs-pack-mono-dedup.ir
+++ b/examples/expected/0507-packs-pack-mono-dedup.ir
@@ -1053,11 +1053,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4483,9 +4483,9 @@ entry:
 define internal i64 @count__pack(ptr %0) #0 {
 entry:
   %alloca = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %alloca, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %alloca, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %alloca, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %alloca, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   ret i64 0
 }
@@ -4502,9 +4502,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret i64 1
 }
@@ -4533,9 +4533,9 @@ entry:
   store { i64, i64 } %ba.val8, ptr %igp.ptr9, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr11 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr11, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 3, ptr %gepN, align 8
   ret i64 3
 }
@@ -4562,9 +4562,9 @@ entry:
   store { i64, i64 } %ba.val4, ptr %igp.ptr5, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr7 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr7, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 2, ptr %gepN, align 8
   ret i64 2
 }
@@ -4607,9 +4607,9 @@ entry:
   store { i64, i64 } %ba.val17, ptr %igp.ptr18, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr20 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr20, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 5, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.380, i64 0 }, ptr %allocaN, align 8
@@ -8986,7 +8986,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8994,14 +8994,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9010,7 +9010,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9019,7 +9019,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0513-packs-pack-mixed-comptime.ir b/examples/expected/0513-packs-pack-mixed-comptime.ir
index aac4d7eb..db33bd9b 100644
--- a/examples/expected/0513-packs-pack-mixed-comptime.ir
+++ b/examples/expected/0513-packs-pack-mixed-comptime.ir
@@ -1034,11 +1034,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4431,9 +4431,9 @@ entry:
   store { i64, i64 } %ba.val9, ptr %igp.ptr10, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr12 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr12, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 3, ptr %gepN, align 8
   %loadN = load i64, ptr %alloca, align 8
   %mul = mul i64 %loadN, 100
@@ -4455,9 +4455,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.373, i64 0 }, ptr %allocaN, align 8
@@ -4492,9 +4492,9 @@ entry:
   %alloca = alloca i64, align 8
   store i64 9, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %load = load i64, ptr %alloca, align 8
   %mul = mul i64 %load, 100
@@ -8806,7 +8806,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8814,14 +8814,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8830,7 +8830,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8839,7 +8839,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0518-packs-pack-value-dispatch.ir b/examples/expected/0518-packs-pack-value-dispatch.ir
index 86469a76..4f0de205 100644
--- a/examples/expected/0518-packs-pack-value-dispatch.ir
+++ b/examples/expected/0518-packs-pack-value-dispatch.ir
@@ -1038,11 +1038,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4421,9 +4421,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret { ptr, i64 } { ptr @str.372, i64 3 }
 }
@@ -4445,9 +4445,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.374, i64 0 }, ptr %allocaN, align 8
@@ -4494,9 +4494,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret { ptr, i64 } { ptr @str.376, i64 6 }
 }
@@ -4514,9 +4514,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret { ptr, i64 } { ptr @str.377, i64 3 }
 }
@@ -4533,9 +4533,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret { ptr, i64 } { ptr @str.378, i64 7 }
 }
@@ -4555,9 +4555,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret { ptr, i64 } { ptr @str.379, i64 10 }
 }
@@ -4575,9 +4575,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret { ptr, i64 } { ptr @str.380, i64 8 }
 }
@@ -4595,9 +4595,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr3 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr3, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   ret { ptr, i64 } { ptr @str.381, i64 9 }
 }
@@ -8906,7 +8906,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8914,14 +8914,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8930,7 +8930,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8939,7 +8939,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0528-packs-protocol-pack-methods.ir b/examples/expected/0528-packs-protocol-pack-methods.ir
index 6380919c..fa98ef94 100644
--- a/examples/expected/0528-packs-protocol-pack-methods.ir
+++ b/examples/expected/0528-packs-protocol-pack-methods.ir
@@ -1098,11 +1098,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4616,9 +4616,9 @@ entry:
   store { i64, i64 } %ba.val6, ptr %igp.ptr7, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr9 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr9, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 2, ptr %gepN, align 8
   %loadN = load { i64 }, ptr %alloca, align 8
   %allocaN = alloca { i64 }, align 8
@@ -4646,9 +4646,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.387, i64 0 }, ptr %allocaN, align 8
@@ -4706,9 +4706,9 @@ entry:
   store { i64, i64 } %ba.val6, ptr %igp.ptr7, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr9 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr9, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 2, ptr %gepN, align 8
   %loadN = load { i64 }, ptr %alloca, align 8
   %allocaN = alloca { i64 }, align 8
@@ -4736,9 +4736,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.390, i64 0 }, ptr %allocaN, align 8
@@ -4796,9 +4796,9 @@ entry:
   store { i64, i64 } %ba.val6, ptr %igp.ptr7, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr9 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr9, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 2, ptr %gepN, align 8
   %loadN = load { i64 }, ptr %alloca, align 8
   %allocaN = alloca { i64 }, align 8
@@ -4826,9 +4826,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.393, i64 0 }, ptr %allocaN, align 8
@@ -9451,7 +9451,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -9459,14 +9459,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9475,7 +9475,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9484,7 +9484,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0903-optionals-optional-roundtrip.ir b/examples/expected/0903-optionals-optional-roundtrip.ir
index 60a672af..239adc99 100644
--- a/examples/expected/0903-optionals-optional-roundtrip.ir
+++ b/examples/expected/0903-optionals-optional-roundtrip.ir
@@ -1122,11 +1122,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4764,9 +4764,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.387, i64 21 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.388, i64 0 }, ptr %allocaN, align 8
@@ -4805,9 +4805,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.391, i64 0 }, ptr %allocaN, align 8
@@ -4859,9 +4859,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.394, i64 0 }, ptr %allocaN, align 8
@@ -4913,9 +4913,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.397, i64 0 }, ptr %allocaN, align 8
@@ -4967,9 +4967,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.400, i64 0 }, ptr %allocaN, align 8
@@ -5011,9 +5011,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.402, i64 26 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.403, i64 0 }, ptr %allocaN, align 8
@@ -5059,9 +5059,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.406, i64 0 }, ptr %allocaN, align 8
@@ -5113,9 +5113,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.409, i64 0 }, ptr %allocaN, align 8
@@ -5167,9 +5167,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.412, i64 0 }, ptr %allocaN, align 8
@@ -5221,9 +5221,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.415, i64 0 }, ptr %allocaN, align 8
@@ -9846,7 +9846,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -9854,14 +9854,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9870,7 +9870,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9879,7 +9879,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/0904-optionals-any-to-string-optional.ir b/examples/expected/0904-optionals-any-to-string-optional.ir
index 08703f66..ecc8230f 100644
--- a/examples/expected/0904-optionals-any-to-string-optional.ir
+++ b/examples/expected/0904-optionals-any-to-string-optional.ir
@@ -1047,11 +1047,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4459,9 +4459,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.378, i64 0 }, ptr %allocaN, align 8
@@ -8887,7 +8887,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8895,14 +8895,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8911,7 +8911,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8920,7 +8920,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/1004-errors-try.ir b/examples/expected/1004-errors-try.ir
index 53b26328..387f4877 100644
--- a/examples/expected/1004-errors-try.ir
+++ b/examples/expected/1004-errors-try.ir
@@ -1040,11 +1040,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4491,9 +4491,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.380, i64 0 }, ptr %allocaN, align 8
@@ -8832,7 +8832,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8840,14 +8840,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8856,7 +8856,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8865,7 +8865,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/1006-errors-inferred-error-sets.ir b/examples/expected/1006-errors-inferred-error-sets.ir
index 14d5a40d..5e014971 100644
--- a/examples/expected/1006-errors-inferred-error-sets.ir
+++ b/examples/expected/1006-errors-inferred-error-sets.ir
@@ -1046,11 +1046,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4510,9 +4510,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.387, i64 0 }, ptr %allocaN, align 8
@@ -8851,7 +8851,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8859,14 +8859,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8875,7 +8875,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8884,7 +8884,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/1009-errors-catch.ir b/examples/expected/1009-errors-catch.ir
index 9c9719c6..ce50fd69 100644
--- a/examples/expected/1009-errors-catch.ir
+++ b/examples/expected/1009-errors-catch.ir
@@ -1042,11 +1042,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4602,9 +4602,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.382, i64 0 }, ptr %allocaN, align 8
@@ -8943,7 +8943,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -8951,14 +8951,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -8967,7 +8967,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -8976,7 +8976,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/1309-ffi-objc-class-method-lowering.ir b/examples/expected/1309-ffi-objc-class-method-lowering.ir
index 2433af1e..61ad008b 100644
--- a/examples/expected/1309-ffi-objc-class-method-lowering.ir
+++ b/examples/expected/1309-ffi-objc-class-method-lowering.ir
@@ -68,11 +68,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1648,7 +1648,7 @@ entry:
   %load = load ptr, ptr %alloca, align 8
   %loadN = load ptr, ptr @__SxFoo_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %load, ptr %loadN)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 1
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 1
   %loadN = load i32, ptr %gep, align 4
   %add = add i32 %loadN, 1
   store i32 %add, ptr %gep, align 4
@@ -1683,9 +1683,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.129, i64 9 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.130, i64 0 }, ptr %allocaN, align 8
@@ -1721,7 +1721,7 @@ entry:
   %sgN = extractvalue { ptr, ptr, ptr } %sg, 1
   %icall = call ptr %sgN(ptr @__sx_default_context, ptr %sgN, i64 32)
   %callN = call ptr @memset(ptr %icall, i32 0, i64 32)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32 }, ptr %icall, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32 }, ptr %icall, i32 0, i32 0
   store { ptr, ptr, ptr } %sg, ptr %gep, align 8
   %loadN = load ptr, ptr @__SxFoo_state_ivar, align 8
   call void @object_setIvar(ptr %call, ptr %loadN, ptr %icall)
@@ -1739,17 +1739,17 @@ define void @__SxFoo_dealloc_imp(ptr %0, ptr %1) #0 {
 entry:
   %load = load ptr, ptr @__SxFoo_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 0
   %loadN = load { ptr, ptr, ptr }, ptr %gep, align 8
   %sg = extractvalue { ptr, ptr, ptr } %loadN, 0
   %sgN = extractvalue { ptr, ptr, ptr } %loadN, 2
   call void %sgN(ptr @__sx_default_context, ptr %sg, ptr %call)
   call void @object_setIvar(ptr %0, ptr %load, ptr null)
   %alloca = alloca { ptr, ptr }, align 8
-  %gepN = getelementptr inbounds { ptr, ptr }, ptr %alloca, i32 0, i32 0
+  %gepN = getelementptr inbounds nuw { ptr, ptr }, ptr %alloca, i32 0, i32 0
   store ptr %0, ptr %gepN, align 8
   %loadN = load ptr, ptr @__SxFoo_class, align 8
-  %gepN = getelementptr inbounds { ptr, ptr }, ptr %alloca, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, ptr }, ptr %alloca, i32 0, i32 1
   store ptr %loadN, ptr %gepN, align 8
   %callN = call ptr @sel_registerName(ptr @__sx_objc_cstr_dealloc)
   call void @objc_msgSendSuper2(ptr %alloca, ptr %callN)
diff --git a/examples/expected/1314-ffi-objc-class-dealloc-roundtrip.ir b/examples/expected/1314-ffi-objc-class-dealloc-roundtrip.ir
index 5ecc40ee..b8da1828 100644
--- a/examples/expected/1314-ffi-objc-class-dealloc-roundtrip.ir
+++ b/examples/expected/1314-ffi-objc-class-dealloc-roundtrip.ir
@@ -84,11 +84,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1721,7 +1721,7 @@ entry:
   %load = load ptr, ptr %alloca, align 8
   %loadN = load ptr, ptr @__SxFoo_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %load, ptr %loadN)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 1
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 1
   %loadN = load i32, ptr %gep, align 4
   %add = add i32 %loadN, 1
   store i32 %add, ptr %gep, align 4
@@ -1833,9 +1833,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.133, i64 27 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.134, i64 0 }, ptr %allocaN, align 8
@@ -1864,9 +1864,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.136, i64 26 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.137, i64 0 }, ptr %allocaN, align 8
@@ -1895,9 +1895,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.139, i64 27 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.140, i64 0 }, ptr %allocaN, align 8
@@ -1926,9 +1926,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.142, i64 35 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.143, i64 0 }, ptr %allocaN, align 8
@@ -1957,9 +1957,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.145, i64 12 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.146, i64 0 }, ptr %allocaN, align 8
@@ -1992,7 +1992,7 @@ entry:
   %sgN = extractvalue { ptr, ptr, ptr } %sg, 1
   %icall = call ptr %sgN(ptr @__sx_default_context, ptr %sgN, i64 32)
   %callN = call ptr @memset(ptr %icall, i32 0, i64 32)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32 }, ptr %icall, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32 }, ptr %icall, i32 0, i32 0
   store { ptr, ptr, ptr } %sg, ptr %gep, align 8
   %loadN = load ptr, ptr @__SxFoo_state_ivar, align 8
   call void @object_setIvar(ptr %call, ptr %loadN, ptr %icall)
@@ -2004,17 +2004,17 @@ define void @__SxFoo_dealloc_imp(ptr %0, ptr %1) #0 {
 entry:
   %load = load ptr, ptr @__SxFoo_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32 }, ptr %call, i32 0, i32 0
   %loadN = load { ptr, ptr, ptr }, ptr %gep, align 8
   %sg = extractvalue { ptr, ptr, ptr } %loadN, 0
   %sgN = extractvalue { ptr, ptr, ptr } %loadN, 2
   call void %sgN(ptr @__sx_default_context, ptr %sg, ptr %call)
   call void @object_setIvar(ptr %0, ptr %load, ptr null)
   %alloca = alloca { ptr, ptr }, align 8
-  %gepN = getelementptr inbounds { ptr, ptr }, ptr %alloca, i32 0, i32 0
+  %gepN = getelementptr inbounds nuw { ptr, ptr }, ptr %alloca, i32 0, i32 0
   store ptr %0, ptr %gepN, align 8
   %loadN = load ptr, ptr @__SxFoo_class, align 8
-  %gepN = getelementptr inbounds { ptr, ptr }, ptr %alloca, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, ptr }, ptr %alloca, i32 0, i32 1
   store ptr %loadN, ptr %gepN, align 8
   %callN = call ptr @sel_registerName(ptr @__sx_objc_cstr_dealloc)
   call void @objc_msgSendSuper2(ptr %alloca, ptr %callN)
diff --git a/examples/expected/1319-ffi-objc-property-sx-defined.ir b/examples/expected/1319-ffi-objc-property-sx-defined.ir
index 97733644..d52dceef 100644
--- a/examples/expected/1319-ffi-objc-property-sx-defined.ir
+++ b/examples/expected/1319-ffi-objc-property-sx-defined.ir
@@ -1125,11 +1125,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4712,7 +4712,7 @@ entry:
   %sgN = extractvalue { ptr, ptr, ptr } %sg, 1
   %icall = call ptr %sgN(ptr @__sx_default_context, ptr %sgN, i64 40)
   %callN = call ptr @memset(ptr %icall, i32 0, i64 40)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %icall, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %icall, i32 0, i32 0
   store { ptr, ptr, ptr } %sg, ptr %gep, align 8
   %loadN = load ptr, ptr @__SxBox_state_ivar, align 8
   call void @object_setIvar(ptr %call, ptr %loadN, ptr %icall)
@@ -4815,9 +4815,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.424, i64 30 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.425, i64 0 }, ptr %allocaN, align 8
@@ -4855,9 +4855,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.428, i64 0 }, ptr %allocaN, align 8
@@ -4898,9 +4898,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.430, i64 51 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.431, i64 0 }, ptr %allocaN, align 8
@@ -4952,9 +4952,9 @@ entry:
   store { i64, i64 } %ba.val11, ptr %igp.ptr12, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr14 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr14, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 3, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.434, i64 0 }, ptr %allocaN, align 8
@@ -9520,7 +9520,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -9528,14 +9528,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9544,7 +9544,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9553,7 +9553,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
@@ -11929,7 +11929,7 @@ entry:
   %sgN = extractvalue { ptr, ptr, ptr } %sg, 1
   %icall = call ptr %sgN(ptr @__sx_default_context, ptr %sgN, i64 40)
   %callN = call ptr @memset(ptr %icall, i32 0, i64 40)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %icall, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %icall, i32 0, i32 0
   store { ptr, ptr, ptr } %sg, ptr %gep, align 8
   %loadN = load ptr, ptr @__SxBox_state_ivar, align 8
   call void @object_setIvar(ptr %call, ptr %loadN, ptr %icall)
@@ -11941,17 +11941,17 @@ define void @__SxBox_dealloc_imp(ptr %0, ptr %1) #0 {
 entry:
   %load = load ptr, ptr @__SxBox_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 0
   %loadN = load { ptr, ptr, ptr }, ptr %gep, align 8
   %sg = extractvalue { ptr, ptr, ptr } %loadN, 0
   %sgN = extractvalue { ptr, ptr, ptr } %loadN, 2
   call void %sgN(ptr @__sx_default_context, ptr %sg, ptr %call)
   call void @object_setIvar(ptr %0, ptr %load, ptr null)
   %alloca = alloca { ptr, ptr }, align 8
-  %gepN = getelementptr inbounds { ptr, ptr }, ptr %alloca, i32 0, i32 0
+  %gepN = getelementptr inbounds nuw { ptr, ptr }, ptr %alloca, i32 0, i32 0
   store ptr %0, ptr %gepN, align 8
   %loadN = load ptr, ptr @__SxBox_class, align 8
-  %gepN = getelementptr inbounds { ptr, ptr }, ptr %alloca, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, ptr }, ptr %alloca, i32 0, i32 1
   store ptr %loadN, ptr %gepN, align 8
   %callN = call ptr @sel_registerName(ptr @__sx_objc_cstr_dealloc)
   call void @objc_msgSendSuper2(ptr %alloca, ptr %callN)
@@ -11966,7 +11966,7 @@ define i32 @__SxBox_width_imp(ptr %0, ptr %1) #0 {
 entry:
   %load = load ptr, ptr @__SxBox_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 1
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 1
   %loadN = load i32, ptr %gep, align 4
   ret i32 %loadN
 }
@@ -11976,7 +11976,7 @@ define void @__SxBox_setWidth_imp(ptr %0, ptr %1, i32 %2) #0 {
 entry:
   %load = load ptr, ptr @__SxBox_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 1
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 1
   store i32 %2, ptr %gep, align 4
   ret void
 }
@@ -11986,7 +11986,7 @@ define i32 @__SxBox_height_imp(ptr %0, ptr %1) #0 {
 entry:
   %load = load ptr, ptr @__SxBox_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 2
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 2
   %loadN = load i32, ptr %gep, align 4
   ret i32 %loadN
 }
@@ -11996,7 +11996,7 @@ define void @__SxBox_setHeight_imp(ptr %0, ptr %1, i32 %2) #0 {
 entry:
   %load = load ptr, ptr @__SxBox_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 2
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 2
   store i32 %2, ptr %gep, align 4
   ret void
 }
@@ -12006,7 +12006,7 @@ define i32 @__SxBox_area_imp(ptr %0, ptr %1) #0 {
 entry:
   %load = load ptr, ptr @__SxBox_state_ivar, align 8
   %call = call ptr @object_getIvar(ptr %0, ptr %load)
-  %gep = getelementptr inbounds { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 3
+  %gep = getelementptr inbounds nuw { { ptr, ptr, ptr }, i32, i32, i32 }, ptr %call, i32 0, i32 3
   %loadN = load i32, ptr %gep, align 4
   ret i32 %loadN
 }
diff --git a/examples/expected/1329-ffi-objc-call-03-selector-sharing.ir b/examples/expected/1329-ffi-objc-call-03-selector-sharing.ir
index d0cce8dc..09b4597a 100644
--- a/examples/expected/1329-ffi-objc-call-03-selector-sharing.ir
+++ b/examples/expected/1329-ffi-objc-call-03-selector-sharing.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1668,9 +1668,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.129, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.130, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1332-ffi-objc-call-06-sret-return.ir b/examples/expected/1332-ffi-objc-call-06-sret-return.ir
index 81a1c7b0..2be0d659 100644
--- a/examples/expected/1332-ffi-objc-call-06-sret-return.ir
+++ b/examples/expected/1332-ffi-objc-call-06-sret-return.ir
@@ -1072,11 +1072,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -4703,9 +4703,9 @@ entry:
   store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr4, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 1, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.421, i64 0 }, ptr %allocaN, align 8
@@ -4766,9 +4766,9 @@ entry:
   store { i64, i64 } %ba.val9, ptr %igp.ptr10, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   %igp.ptr12 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr %igp.ptr12, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 3, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.424, i64 0 }, ptr %allocaN, align 8
@@ -9264,7 +9264,7 @@ fv.case:                                          ; preds = %entry
 
 fv.case6:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp, align 8
-  %fv.pp = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
+  %fv.pp = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp, i32 0, i32 1
   %fv.field = load i1, ptr %fv.pp, align 1
   %zN = zext i1 %fv.field to i64
   %fv.val = insertvalue { i64, i64 } { i64 1, i64 undef }, i64 %zN, 1
@@ -9272,14 +9272,14 @@ fv.case6:                                         ; preds = %entry
 
 fv.case7:                                         ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp8, align 8
-  %fv.pp9 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
+  %fv.pp9 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp8, i32 0, i32 1
   %fv.field10 = load i64, ptr %fv.pp9, align 8
   %fv.val11 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field10, 1
   br label %fv.merge
 
 fv.case12:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp13, align 8
-  %fv.pp14 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
+  %fv.pp14 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp13, i32 0, i32 1
   %fv.field15 = load { ptr, i64 }, ptr %fv.pp14, align 8
   store { ptr, i64 } %fv.field15, ptr %ba.tmp, align 8
   %ba.p2i = ptrtoint ptr %ba.tmp to i64
@@ -9288,7 +9288,7 @@ fv.case12:                                        ; preds = %entry
 
 fv.case17:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp18, align 8
-  %fv.pp19 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
+  %fv.pp19 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp18, i32 0, i32 1
   %fv.field20 = load { ptr, i64, i64 }, ptr %fv.pp19, align 8
   store { ptr, i64, i64 } %fv.field20, ptr %ba.tmp21, align 8
   %ba.p2i22 = ptrtoint ptr %ba.tmp21 to i64
@@ -9297,7 +9297,7 @@ fv.case17:                                        ; preds = %entry
 
 fv.case24:                                        ; preds = %entry
   store { i64, [24 x i8] } %loadN, ptr %fv.utmp25, align 8
-  %fv.pp26 = getelementptr inbounds { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
+  %fv.pp26 = getelementptr inbounds nuw { i64, [24 x i8] }, ptr %fv.utmp25, i32 0, i32 1
   %fv.field27 = load { ptr, i64, i64 }, ptr %fv.pp26, align 8
   store { ptr, i64, i64 } %fv.field27, ptr %ba.tmp28, align 8
   %ba.p2i29 = ptrtoint ptr %ba.tmp28 to i64
diff --git a/examples/expected/1347-ffi-objc-dsl-07-mangling-table.ir b/examples/expected/1347-ffi-objc-dsl-07-mangling-table.ir
index 35eecd58..f361b18e 100644
--- a/examples/expected/1347-ffi-objc-dsl-07-mangling-table.ir
+++ b/examples/expected/1347-ffi-objc-dsl-07-mangling-table.ir
@@ -86,11 +86,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1817,9 +1817,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.145, i64 18 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.146, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1402-ffi-jni-call-03-methodid-sharing.ir b/examples/expected/1402-ffi-jni-call-03-methodid-sharing.ir
index f5718018..8af720b7 100644
--- a/examples/expected/1402-ffi-jni-call-03-methodid-sharing.ir
+++ b/examples/expected/1402-ffi-jni-call-03-methodid-sharing.ir
@@ -62,11 +62,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1628,9 +1628,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.96, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.97, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1403-ffi-jni-call-04-jint-return.ir b/examples/expected/1403-ffi-jni-call-04-jint-return.ir
index e8777b93..ffebfa2e 100644
--- a/examples/expected/1403-ffi-jni-call-04-jint-return.ir
+++ b/examples/expected/1403-ffi-jni-call-04-jint-return.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1603,9 +1603,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1404-ffi-jni-call-05-jlong-return.ir b/examples/expected/1404-ffi-jni-call-05-jlong-return.ir
index 12ad0d69..dd1fb5eb 100644
--- a/examples/expected/1404-ffi-jni-call-05-jlong-return.ir
+++ b/examples/expected/1404-ffi-jni-call-05-jlong-return.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1603,9 +1603,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1405-ffi-jni-call-06-jdouble-return.ir b/examples/expected/1405-ffi-jni-call-06-jdouble-return.ir
index 7b2adbbe..65940b91 100644
--- a/examples/expected/1405-ffi-jni-call-06-jdouble-return.ir
+++ b/examples/expected/1405-ffi-jni-call-06-jdouble-return.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1603,9 +1603,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1406-ffi-jni-call-07-jboolean-return.ir b/examples/expected/1406-ffi-jni-call-07-jboolean-return.ir
index fcb10e46..230513f8 100644
--- a/examples/expected/1406-ffi-jni-call-07-jboolean-return.ir
+++ b/examples/expected/1406-ffi-jni-call-07-jboolean-return.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1603,9 +1603,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1407-ffi-jni-call-08-jobject-return.ir b/examples/expected/1407-ffi-jni-call-08-jobject-return.ir
index ade56fbf..d816f409 100644
--- a/examples/expected/1407-ffi-jni-call-08-jobject-return.ir
+++ b/examples/expected/1407-ffi-jni-call-08-jobject-return.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1603,9 +1603,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1408-ffi-jni-call-09-static.ir b/examples/expected/1408-ffi-jni-call-09-static.ir
index dd800da7..ebed7f7c 100644
--- a/examples/expected/1408-ffi-jni-call-09-static.ir
+++ b/examples/expected/1408-ffi-jni-call-09-static.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1600,9 +1600,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1418-ffi-jni-class-08-call.ir b/examples/expected/1418-ffi-jni-class-08-call.ir
index 3a1db542..a8584fb9 100644
--- a/examples/expected/1418-ffi-jni-class-08-call.ir
+++ b/examples/expected/1418-ffi-jni-class-08-call.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1603,9 +1603,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/examples/expected/1421-ffi-jni-env-02-lexical-direct.ir b/examples/expected/1421-ffi-jni-env-02-lexical-direct.ir
index dbca2d1c..d23c2ce7 100644
--- a/examples/expected/1421-ffi-jni-env-02-lexical-direct.ir
+++ b/examples/expected/1421-ffi-jni-env-02-lexical-direct.ir
@@ -60,11 +60,11 @@ entry:
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } undef, ptr %allocaN, align 8
   %loadN = load ptr, ptr %allocaN, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   %pti = ptrtoint ptr %loadN to i64
   store i64 %pti, ptr %gep, align 8
   %loadN = load i64, ptr %alloca, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 %loadN, ptr %gepN, align 8
   %loadN = load { ptr, i64 }, ptr %allocaN, align 8
   ret { ptr, i64 } %loadN
@@ -1601,9 +1601,9 @@ entry:
   %alloca = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.94, i64 3 }, ptr %alloca, align 8
   %allocaN = alloca { ptr, i64 }, align 8
-  %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
+  %gep = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 0
   store ptr null, ptr %gep, align 8
-  %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
+  %gepN = getelementptr inbounds nuw { ptr, i64 }, ptr %allocaN, i32 0, i32 1
   store i64 0, ptr %gepN, align 8
   %allocaN = alloca { ptr, i64 }, align 8
   store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
diff --git a/readme.md b/readme.md
index 05df0144..adb64354 100644
--- a/readme.md
+++ b/readme.md
@@ -42,7 +42,7 @@ zig build
 
 On macOS with Homebrew LLVM:
 ```sh
-# default path: /opt/homebrew/opt/llvm@19
+# default path: /opt/homebrew/opt/llvm@22  (Homebrew `llvm@22`)
 zig build
 ```