From 4bf59087927021aef9329d14fb711f56f1e7d07f Mon Sep 17 00:00:00 2001 From: agra Date: Mon, 25 May 2026 09:10:04 +0300 Subject: [PATCH] =?UTF-8?q?mem:=20Steps=205-7=20=E2=80=94=20context-identi?= =?UTF-8?q?fier=20rebind=20+=20interp=20ctx=20bootstrap?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Step 5 — `context` resolves through `current_ctx_ref`. The compile-time emit of the default GPA into the `context` global is gone; entry points already bind `current_ctx_ref` to `&__sx_default_context` and every sx-to-sx call forwards it. `allocViaContext` sources from `current_ctx_ref` too. `matchContextAllocCall` is kept as a comptime escape hatch: the ct_module spun up by `evalComptimeString` doesn't get the full Allocator/CAllocator/Context type registration so the protocol- dispatch chain wouldn't run in the interp; codegen also wins from the direct libc malloc/free. Step 6 — `push Context.{...}` stack-discipline rewrite. Allocates a fresh `Context` slot, binds `current_ctx_ref` to it for the body's lexical scope, restores on exit. No global, no walk. Step 7 — interp parity. `defaultContextValue()` builds the Context aggregate (CAllocator thunks for alloc/dealloc, null data) on demand. `interp.call` bootstraps slot_ptr(0) when an entry function with implicit ctx is called sans args; `materializeCtxArg` dereferences the caller's slot_ptr into the aggregate at every sx-to-sx call boundary so the callee's `load(ref_0)` lands on the value; `load` of an aggregate is a passthrough. `.global_addr` of `__sx_default_context` returns the aggregate directly so exported entries' first-line `global_addr(...)` runs cleanly in `#run`. `ct_lowering` inherits `implicit_ctx_enabled` + `has_implicit_ctx` so functions lowered into the ct module carry ctx like their main-module twins. 152/152 example tests pass. Snapshots regen. --- src/ir/interp.zig | 92 ++- src/ir/lower.zig | 128 ++-- tests/expected/08-types.txt | 4 +- .../ffi-jni-call-03-methodid-sharing.ir | 60 +- tests/expected/ffi-jni-call-04-jint-return.ir | 58 +- .../expected/ffi-jni-call-05-jlong-return.ir | 58 +- .../ffi-jni-call-06-jdouble-return.ir | 58 +- .../ffi-jni-call-07-jboolean-return.ir | 58 +- .../ffi-jni-call-08-jobject-return.ir | 58 +- tests/expected/ffi-jni-call-09-static.ir | 58 +- tests/expected/ffi-jni-class-08-call.ir | 60 +- .../expected/ffi-jni-env-02-lexical-direct.ir | 60 +- .../ffi-objc-call-03-selector-sharing.ir | 60 +- .../expected/ffi-objc-call-06-sret-return.ir | 594 ++++++++---------- 14 files changed, 440 insertions(+), 966 deletions(-) diff --git a/src/ir/interp.zig b/src/ir/interp.zig index ab6fd89..1f05bbb 100644 --- a/src/ir/interp.zig +++ b/src/ir/interp.zig @@ -164,6 +164,37 @@ pub const Interpreter = struct { self.hooks.deinit(); } + // ── Implicit Context ────────────────────────────────────────── + + /// Build the default Context aggregate for top-level interp calls. + /// Mirrors the static `__sx_default_context` LLVM global: a Context + /// whose `allocator` field is the stateless CAllocator inline-protocol + /// value (alloc/dealloc thunks bottom out at libc malloc/free). + fn defaultContextValue(self: *Interpreter) Value { + const tbl_ptr: *const @import("types.zig").TypeTable = &self.module.types; + const tbl = @constCast(tbl_ptr); + const alloc_thunk_name = tbl.internString("__thunk_CAllocator_Allocator_alloc"); + const dealloc_thunk_name = tbl.internString("__thunk_CAllocator_Allocator_dealloc"); + + var alloc_fn: Value = .null_val; + var dealloc_fn: Value = .null_val; + for (self.module.functions.items, 0..) |func, i| { + if (func.name == alloc_thunk_name) alloc_fn = .{ .func_ref = FuncId.fromIndex(@intCast(i)) }; + if (func.name == dealloc_thunk_name) dealloc_fn = .{ .func_ref = FuncId.fromIndex(@intCast(i)) }; + } + + const allocator_fields = self.alloc.alloc(Value, 3) catch unreachable; + allocator_fields[0] = .null_val; // CAllocator receiver — stateless + allocator_fields[1] = alloc_fn; + allocator_fields[2] = dealloc_fn; + const allocator_val: Value = .{ .aggregate = allocator_fields }; + + const ctx_fields = self.alloc.alloc(Value, 2) catch unreachable; + ctx_fields[0] = allocator_val; + ctx_fields[1] = .null_val; + return .{ .aggregate = ctx_fields }; + } + // ── Heap operations ──────────────────────────────────────────── fn heapAlloc(self: *Interpreter, size: usize) Value.HeapPtr { @@ -367,9 +398,23 @@ pub const Interpreter = struct { var frame = Frame.initSized(self.alloc, total_refs); defer frame.deinit(); - // Bind parameters as initial refs (indices 0..N-1) + // Implicit-context bootstrap: when an entry point with implicit + // ctx is called without an explicit ctx arg, materialise the + // default context in a fresh slot and bind slot_ptr(0) to ref 0. + // This is the interp-side equivalent of FFI-inbound wrappers + // installing `&__sx_default_context` at function entry. + var skip_first: u32 = 0; + if (func.has_implicit_ctx and args.len + 1 == func.params.len) { + const ctx_val = self.defaultContextValue(); + const slot = frame.allocSlot(self.alloc); + frame.storeSlot(slot, ctx_val); + frame.setRef(0, .{ .slot_ptr = slot }); + skip_first = 1; + } + + // Bind parameters as initial refs (indices skip_first..N-1) for (args, 0..) |arg, i| { - frame.setRef(@intCast(i), arg); + frame.setRef(@intCast(i + skip_first), arg); } // Start at the entry block (index 0) @@ -536,6 +581,10 @@ pub const Interpreter = struct { } return .{ .value = slot_val }; }, + // The implicit __sx_ctx arrives as an aggregate after + // materializeCtxArg dereferences the caller's slot_ptr. + // `load(ref_0)` then naturally yields the Context value. + .aggregate => return .{ .value = ptr }, else => return error.CannotEvalComptime, } }, @@ -667,6 +716,14 @@ pub const Interpreter = struct { // its own slot table and read garbage. args[i] = self.materializeForCall(frame, frame.getRef(ref)); } + // The implicit __sx_ctx is logically a `*Context` but the + // interp can't dereference cross-frame slot_ptrs. Materialise + // args[0] to the loaded Context aggregate so the callee can + // treat its slot 0 as the value directly. + const callee_func = self.module.getFunction(c.callee); + if (callee_func.has_implicit_ctx and args.len >= 1) { + args[0] = self.materializeCtxArg(frame, args[0]); + } const result = try self.call(c.callee, args); return .{ .value = result }; }, @@ -1020,8 +1077,18 @@ pub const Interpreter = struct { const val = try self.getGlobal(gid); return .{ .value = val }; }, - .global_addr => { - // Address-of-global not meaningful in interpreter + .global_addr => |gid| { + // The implicit-context default global is the only global + // whose address sees runtime use. Return the Context + // aggregate directly so `load(args[0])` yields it via the + // aggregate-passthrough branch of the `.load` handler. + if (gid.index() < self.module.globals.items.len) { + const global = &self.module.globals.items[gid.index()]; + const name = self.module.types.getString(global.name); + if (std.mem.eql(u8, name, "__sx_default_context")) { + return .{ .value = self.defaultContextValue() }; + } + } return error.CannotEvalComptime; }, .func_ref => |fid| { @@ -1114,7 +1181,11 @@ pub const Interpreter = struct { const args = self.alloc.alloc(Value, ci.args.len) catch return error.CannotEvalComptime; defer self.alloc.free(args); for (ci.args, 0..) |ref, i| { - args[i] = frame.getRef(ref); + args[i] = self.materializeForCall(frame, frame.getRef(ref)); + } + const target = self.module.getFunction(fid); + if (target.has_implicit_ctx and args.len >= 1) { + args[0] = self.materializeCtxArg(frame, args[0]); } const result = try self.call(fid, args); return .{ .value = result }; @@ -1232,6 +1303,17 @@ pub const Interpreter = struct { /// emitted by `struct_gep` / `index_gep`) into the resolved parent value. /// Slot indices are frame-local; a slice passed across a call would otherwise /// read its data_ptr out of the callee's slot table. + /// Resolve the implicit __sx_ctx arg to its loaded Context value so + /// callees can treat their own slot 0 as the aggregate directly + /// (no cross-frame slot_ptr indirection). + fn materializeCtxArg(self: *Interpreter, frame: *Frame, val: Value) Value { + _ = self; + return switch (val) { + .slot_ptr => |slot| frame.loadSlot(slot), + else => val, + }; + } + fn materializeForCall(self: *Interpreter, frame: *Frame, val: Value) Value { switch (val) { .aggregate => |fields| { diff --git a/src/ir/lower.zig b/src/ir/lower.zig index f1a4f7a..bbdddde 100644 --- a/src/ir/lower.zig +++ b/src/ir/lower.zig @@ -1014,11 +1014,6 @@ pub const Lowering = struct { } } - // Auto-initialize context with default GPA at the start of main() - if (std.mem.eql(u8, name, "main")) { - self.emitDefaultContextInit(); - } - // Lower the function body (set target_type to return type for implicit returns) const saved_target = self.target_type; self.target_type = if (ret_ty != .void) ret_ty else null; @@ -1907,6 +1902,18 @@ pub const Lowering = struct { .enum_tag => |et| break :blk self.builder.constInt(@intCast(et.tag), et.ty), } } + // `context` resolves to a load through the lowering's + // current `__sx_ctx` pointer. Every sx function (and + // every `push Context.{...}` body) sets `current_ctx_ref` + // to a `*Context` it owns, so this is one indirection. + if (self.implicit_ctx_enabled and std.mem.eql(u8, id.name, "context")) { + if (self.current_ctx_ref != Ref.none) { + const ctx_ty = self.module.types.findByName(self.module.types.internString("Context")) orelse { + break :blk self.emitError("context", node.span); + }; + break :blk self.builder.load(self.current_ctx_ref, ctx_ty); + } + } // Check globals (#run constants) if (self.global_names.get(id.name)) |gi| { break :blk self.builder.emit(.{ .global_get = gi.id }, gi.ty); @@ -5013,7 +5020,11 @@ pub const Lowering = struct { } } - // Pattern-match context.allocator.alloc/dealloc → heap_alloc/heap_free + // Pattern-match context.allocator.alloc/dealloc → heap_alloc/heap_free. + // The comptime interp doesn't register the full Allocator + // protocol in ct_module, so the protocol-dispatch chain it + // would otherwise emit can't run. Codegen also benefits — + // direct libc malloc/free, no thunk indirection. if (self.matchContextAllocCall(fa, args.items)) |ref| return ref; // Type constructor call: Sx(f32).user(0.5) — obj is a call that returns a type @@ -5459,15 +5470,18 @@ pub const Lowering = struct { /// allocators.sx, so the fallback exists strictly for the bootstrapping /// edge case. fn allocViaContext(self: *Lowering, size_ref: Ref, void_ptr_ty: TypeId) Ref { - const ctx_gi = self.global_names.get("context") orelse { + if (!self.implicit_ctx_enabled or self.current_ctx_ref == Ref.none) { + return self.builder.emit(.{ .heap_alloc = .{ .operand = size_ref } }, void_ptr_ty); + } + const ctx_ty = self.module.types.findByName(self.module.types.internString("Context")) orelse { return self.builder.emit(.{ .heap_alloc = .{ .operand = size_ref } }, void_ptr_ty); }; - const ctx_ty_info = self.module.types.get(ctx_gi.ty); + const ctx_ty_info = self.module.types.get(ctx_ty); if (ctx_ty_info != .@"struct" or ctx_ty_info.@"struct".fields.len < 1) { return self.builder.emit(.{ .heap_alloc = .{ .operand = size_ref } }, void_ptr_ty); } const allocator_ty = ctx_ty_info.@"struct".fields[0].ty; - const ctx = self.builder.emit(.{ .global_get = ctx_gi.id }, ctx_gi.ty); + const ctx = self.builder.load(self.current_ctx_ref, ctx_ty); const allocator = self.builder.structGet(ctx, 0, allocator_ty); // #inline Allocator protocol layout: { ctx, alloc_fn_ptr, dealloc_fn_ptr }. // field 0 = receiver ctx, field 1 = alloc fn-ptr. @@ -5512,16 +5526,18 @@ pub const Lowering = struct { return new_args; } - /// Pattern-match `context.allocator.alloc(size)` → heap_alloc, - /// `context.allocator.dealloc(ptr)` → heap_free. + /// Pattern-match `context.allocator.alloc(size)` → heap_alloc and + /// `context.allocator.dealloc(ptr)` → heap_free. Required because the + /// comptime interpreter doesn't get a full type/protocol registration + /// of the Allocator chain; the protocol-dispatch lowering would + /// produce IR that the interp can't execute. Codegen wins from this + /// short-circuit too (libc malloc/free direct, no thunk indirection + /// for the trivial default-context case). fn matchContextAllocCall(self: *Lowering, fa: ast.FieldAccess, call_args: []const Ref) ?Ref { - // fa is the callee field_access: expecting .alloc or .dealloc if (!std.mem.eql(u8, fa.field, "alloc") and !std.mem.eql(u8, fa.field, "dealloc")) return null; - // fa.object should be `context.allocator` — another field_access if (fa.object.data != .field_access) return null; const inner = fa.object.data.field_access; if (!std.mem.eql(u8, inner.field, "allocator")) return null; - // inner.object should be `context` — an identifier if (inner.object.data != .identifier) return null; if (!std.mem.eql(u8, inner.object.data.identifier.name, "context")) return null; @@ -5530,7 +5546,6 @@ pub const Lowering = struct { const ptr_void = self.module.types.ptrTo(.void); return self.builder.emit(.{ .heap_alloc = .{ .operand = call_args[0] } }, ptr_void); } else { - // dealloc if (call_args.len < 1) return null; return self.builder.emit(.{ .heap_free = .{ .operand = call_args[0] } }, .void); } @@ -6171,23 +6186,30 @@ pub const Lowering = struct { } fn lowerPush(self: *Lowering, ps: *const ast.PushStmt) void { - // push context_expr { body } - // → save = global_get(context), global_set(context, new_val), body, global_set(context, save) - const gi = self.global_names.get("context") orelse { - // No context global — just lower the body without push/pop + // push Context.{...} { body } — allocates a fresh Context on the + // stack frame, rebinds the lowering's `current_ctx_ref` to it for + // the body's lexical scope, then restores. No global, no walk. + if (!self.implicit_ctx_enabled) { + self.lowerBlock(ps.body); + return; + } + const ctx_ty = self.module.types.findByName(self.module.types.internString("Context")) orelse { self.lowerBlock(ps.body); return; }; - // Save current context - const save = self.builder.emit(.{ .global_get = gi.id }, gi.ty); - // Lower the new context value + const saved_ctx_ref = self.current_ctx_ref; + defer self.current_ctx_ref = saved_ctx_ref; + + const saved_target = self.target_type; + self.target_type = ctx_ty; const ctx_val = self.lowerExpr(ps.context_expr); - // Store into context global - self.builder.emitVoid(.{ .global_set = .{ .global = gi.id, .value = ctx_val } }, .void); - // Lower the body + self.target_type = saved_target; + + const slot = self.builder.alloca(ctx_ty); + self.builder.store(slot, ctx_val); + self.current_ctx_ref = slot; + self.lowerBlock(ps.body); - // Restore saved context - self.builder.emitVoid(.{ .global_set = .{ .global = gi.id, .value = save } }, .void); } fn lowerMultiAssign(self: *Lowering, ma: *const ast.MultiAssign) void { @@ -6419,6 +6441,12 @@ pub const Lowering = struct { ct_lowering.main_file = null; // no main file filtering ct_lowering.comptime_param_nodes = self.comptime_param_nodes; ct_lowering.fn_ast_map = self.fn_ast_map; // share AST map for lazy resolution + // Inherit the implicit-ctx switch: the parent program uses + // Context, so functions lowered into ct_module must carry + // __sx_ctx too (otherwise the inserted code's `context.X` + // reads can't resolve through current_ctx_ref). + ct_lowering.implicit_ctx_enabled = self.implicit_ctx_enabled; + ct_module.has_implicit_ctx = self.implicit_ctx_enabled; // Lower only the functions reachable from this expression. // For a call like build_format(fmt), we need build_format's AST. @@ -10419,52 +10447,6 @@ pub const Lowering = struct { }; } - /// Auto-initialize the global `context` with a default GPA allocator at the start of main(). - /// Emits IR instructions equivalent to: - /// __default_gpa : GPA = .{ alloc_count = 0 }; - /// context = Context.{ allocator = GPA.create(@__default_gpa), data = null }; - fn emitDefaultContextInit(self: *Lowering) void { - // Look up the context global - const ctx_gi = self.global_names.get("context") orelse return; - const ctx_ty = ctx_gi.ty; - - // Look up GPA type - const gpa_ty = self.module.types.findByName(self.module.types.internString("GPA")) orelse return; - // Look up Allocator type - const alloc_ty = self.module.types.findByName(self.module.types.internString("Allocator")) orelse return; - - // Get GPA→Allocator thunks - const thunks = self.getOrCreateThunks("Allocator", "GPA"); - if (thunks.len < 2) return; - - // 1. Stack-allocate GPA with alloc_count = 0 - const gpa_slot = self.builder.alloca(gpa_ty); - const zero = self.builder.constInt(0, .s64); - const gpa_val = self.builder.emit(.{ .struct_init = .{ - .fields = self.alloc.dupe(Ref, &.{zero}) catch return, - } }, gpa_ty); - self.builder.store(gpa_slot, gpa_val); - - // 2. Build Allocator inline protocol value: { ctx: *void, alloc_fn, dealloc_fn } - const void_ptr_ty = self.module.types.ptrTo(.void); - const gpa_ptr = gpa_slot; // alloca already gives us *GPA, all pointers are compatible - const alloc_fn = self.builder.emit(.{ .func_ref = thunks[0] }, void_ptr_ty); - const dealloc_fn = self.builder.emit(.{ .func_ref = thunks[1] }, void_ptr_ty); - - const alloc_val = self.builder.emit(.{ .struct_init = .{ - .fields = self.alloc.dupe(Ref, &.{ gpa_ptr, alloc_fn, dealloc_fn }) catch return, - } }, alloc_ty); - - // 3. Build Context struct: { allocator, data: null } - const null_ptr = self.builder.constNull(void_ptr_ty); - const ctx_val = self.builder.emit(.{ .struct_init = .{ - .fields = self.alloc.dupe(Ref, &.{ alloc_val, null_ptr }) catch return, - } }, ctx_ty); - - // 4. Store into context global - self.builder.emitVoid(.{ .global_set = .{ .global = ctx_gi.id, .value = ctx_val } }, .void); - } - fn emitModuleConst(self: *Lowering, ci: ModuleConstInfo) Ref { switch (ci.value.data) { .int_literal => |lit| { diff --git a/tests/expected/08-types.txt b/tests/expected/08-types.txt index 17052bb..fb37801 100644 --- a/tests/expected/08-types.txt +++ b/tests/expected/08-types.txt @@ -1,4 +1,4 @@ -a 0 : Foo{a: 0, b: 42, c: 0, d: 17} +a 0 : Foo{a: 0, b: 42, c: 1, 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: 1, c: 101, d: 1} Pack{a: 1, b: 0, c: 3, d: 5, f: 9, v: 100, x: 3.500000} diff --git a/tests/expected/ffi-jni-call-03-methodid-sharing.ir b/tests/expected/ffi-jni-call-03-methodid-sharing.ir index c3b56e9..7736b02 100644 --- a/tests/expected/ffi-jni-call-03-methodid-sharing.ir +++ b/tests/expected/ffi-jni-call-03-methodid-sharing.ir @@ -50,38 +50,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -313,14 +285,6 @@ jni.cont8: ; preds = %jni.miss7, %jni.con ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 @@ -329,10 +293,10 @@ if.then.0: ; preds = %entry br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry - %allocaN = alloca { ptr, i64 }, align 8 - %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0 + %alloca = alloca { ptr, i64 }, align 8 + %gep = getelementptr inbounds { ptr, i64 }, ptr %alloca, 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 { ptr, i64 }, ptr %alloca, i32 0, i32 1 store i64 0, ptr %gepN, align 8 %allocaN = alloca { ptr, i64 }, align 8 store { ptr, i64 } { ptr @str.4, i64 3 }, ptr %allocaN, align 8 @@ -364,20 +328,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-call-04-jint-return.ir b/tests/expected/ffi-jni-call-04-jint-return.ir index c1b3d98..be00dd5 100644 --- a/tests/expected/ffi-jni-call-04-jint-return.ir +++ b/tests/expected/ffi-jni-call-04-jint-return.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -286,21 +258,13 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 if.then.0: ; preds = %entry %call = call i32 @read_int(ptr @__sx_default_context, ptr null, ptr null) - %allocaN = alloca i32, align 4 - store i32 %call, ptr %allocaN, align 4 + %alloca = alloca i32, align 4 + store i32 %call, ptr %alloca, align 4 br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry @@ -339,20 +303,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-call-05-jlong-return.ir b/tests/expected/ffi-jni-call-05-jlong-return.ir index a2fdcbb..6eb7c23 100644 --- a/tests/expected/ffi-jni-call-05-jlong-return.ir +++ b/tests/expected/ffi-jni-call-05-jlong-return.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -286,21 +258,13 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 if.then.0: ; preds = %entry %call = call i64 @read_long(ptr @__sx_default_context, ptr null, ptr null) - %allocaN = alloca i64, align 8 - store i64 %call, ptr %allocaN, align 8 + %alloca = alloca i64, align 8 + store i64 %call, ptr %alloca, align 8 br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry @@ -339,20 +303,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-call-06-jdouble-return.ir b/tests/expected/ffi-jni-call-06-jdouble-return.ir index 282f217..450c79c 100644 --- a/tests/expected/ffi-jni-call-06-jdouble-return.ir +++ b/tests/expected/ffi-jni-call-06-jdouble-return.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -286,21 +258,13 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 if.then.0: ; preds = %entry %call = call double @read_double(ptr @__sx_default_context, ptr null, ptr null) - %allocaN = alloca double, align 8 - store double %call, ptr %allocaN, align 8 + %alloca = alloca double, align 8 + store double %call, ptr %alloca, align 8 br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry @@ -339,20 +303,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-call-07-jboolean-return.ir b/tests/expected/ffi-jni-call-07-jboolean-return.ir index 67c7a52..fc3b284 100644 --- a/tests/expected/ffi-jni-call-07-jboolean-return.ir +++ b/tests/expected/ffi-jni-call-07-jboolean-return.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -286,21 +258,13 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 if.then.0: ; preds = %entry %call = call i1 @read_bool(ptr @__sx_default_context, ptr null, ptr null) - %allocaN = alloca i1, align 1 - store i1 %call, ptr %allocaN, align 1 + %alloca = alloca i1, align 1 + store i1 %call, ptr %alloca, align 1 br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry @@ -339,20 +303,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-call-08-jobject-return.ir b/tests/expected/ffi-jni-call-08-jobject-return.ir index 314c244..298655c 100644 --- a/tests/expected/ffi-jni-call-08-jobject-return.ir +++ b/tests/expected/ffi-jni-call-08-jobject-return.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -286,21 +258,13 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 if.then.0: ; preds = %entry %call = call ptr @get_window(ptr @__sx_default_context, ptr null, ptr null) - %allocaN = alloca ptr, align 8 - store ptr %call, ptr %allocaN, align 8 + %alloca = alloca ptr, align 8 + store ptr %call, ptr %alloca, align 8 br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry @@ -339,20 +303,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-call-09-static.ir b/tests/expected/ffi-jni-call-09-static.ir index 9e3eb06..17d369c 100644 --- a/tests/expected/ffi-jni-call-09-static.ir +++ b/tests/expected/ffi-jni-call-09-static.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -283,21 +255,13 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 if.then.0: ; preds = %entry %call = call i32 @call_static_max(ptr @__sx_default_context, ptr null, ptr null) - %allocaN = alloca i32, align 4 - store i32 %call, ptr %allocaN, align 4 + %alloca = alloca i32, align 4 + store i32 %call, ptr %alloca, align 4 br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry @@ -336,20 +300,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-class-08-call.ir b/tests/expected/ffi-jni-class-08-call.ir index 5894690..6ddcbcb 100644 --- a/tests/expected/ffi-jni-class-08-call.ir +++ b/tests/expected/ffi-jni-class-08-call.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -288,14 +260,6 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 @@ -304,10 +268,10 @@ if.then.0: ; preds = %entry br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry - %allocaN = alloca { ptr, i64 }, align 8 - %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0 + %alloca = alloca { ptr, i64 }, align 8 + %gep = getelementptr inbounds { ptr, i64 }, ptr %alloca, 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 { ptr, i64 }, ptr %alloca, i32 0, i32 1 store i64 0, ptr %gepN, align 8 %allocaN = alloca { ptr, i64 }, align 8 store { ptr, i64 } { ptr @str.2, i64 3 }, ptr %allocaN, align 8 @@ -339,20 +303,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-jni-env-02-lexical-direct.ir b/tests/expected/ffi-jni-env-02-lexical-direct.ir index 3faa01d..1b6d44f 100644 --- a/tests/expected/ffi-jni-env-02-lexical-direct.ir +++ b/tests/expected/ffi-jni-env-02-lexical-direct.ir @@ -48,38 +48,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -286,14 +258,6 @@ jni.cont: ; preds = %jni.miss, %entry ; Function Attrs: nounwind define i32 @main() #0 { entry: - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %gload = load i1, ptr @g_should_call, align 1 br i1 %gload, label %if.then.0, label %if.merge.1 @@ -302,10 +266,10 @@ if.then.0: ; preds = %entry br label %if.merge.1 if.merge.1: ; preds = %if.then.0, %entry - %allocaN = alloca { ptr, i64 }, align 8 - %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0 + %alloca = alloca { ptr, i64 }, align 8 + %gep = getelementptr inbounds { ptr, i64 }, ptr %alloca, 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 { ptr, i64 }, ptr %alloca, i32 0, i32 1 store i64 0, ptr %gepN, align 8 %allocaN = alloca { ptr, i64 }, align 8 store { ptr, i64 } { ptr @str.2, i64 3 }, ptr %allocaN, align 8 @@ -337,20 +301,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind declare ptr @sx_jni_env_tl_get() #0 diff --git a/tests/expected/ffi-objc-call-03-selector-sharing.ir b/tests/expected/ffi-objc-call-03-selector-sharing.ir index d6c123d..e7eb4ed 100644 --- a/tests/expected/ffi-objc-call-03-selector-sharing.ir +++ b/tests/expected/ffi-objc-call-03-selector-sharing.ir @@ -51,38 +51,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -362,14 +334,6 @@ declare i64 @build_options() #0 define i32 @main() #0 { entry: call void @__sx_objc_selector_init() - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %load = load ptr, ptr @OBJC_SELECTOR_REFERENCES_init, align 8 call void @objc_msgSend(ptr null, ptr %load) %loadN = load ptr, ptr @OBJC_SELECTOR_REFERENCES_init, align 8 @@ -378,10 +342,10 @@ entry: call void @objc_msgSend(ptr null, ptr %loadN) %loadN = load ptr, ptr @OBJC_SELECTOR_REFERENCES_release, align 8 call void @objc_msgSend(ptr null, ptr %loadN) - %allocaN = alloca { ptr, i64 }, align 8 - %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0 + %alloca = alloca { ptr, i64 }, align 8 + %gep = getelementptr inbounds { ptr, i64 }, ptr %alloca, 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 { ptr, i64 }, ptr %alloca, i32 0, i32 1 store i64 0, ptr %gepN, align 8 %allocaN = alloca { ptr, i64 }, align 8 store { ptr, i64 } { ptr @str, i64 3 }, ptr %allocaN, align 8 @@ -413,20 +377,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - declare ptr @objc_msgSend(ptr, ptr) declare i64 @write(i32, ptr, i64) diff --git a/tests/expected/ffi-objc-call-06-sret-return.ir b/tests/expected/ffi-objc-call-06-sret-return.ir index 78c822e..feb6aeb 100644 --- a/tests/expected/ffi-objc-call-06-sret-return.ir +++ b/tests/expected/ffi-objc-call-06-sret-return.ir @@ -171,32 +171,29 @@ @str.161 = private unnamed_addr constant [7 x i8] c"**void\00", align 1 @str.162 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.163 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.164 = private unnamed_addr constant [6 x i8] c"**GPA\00", align 1 +@str.164 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1 @str.165 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.166 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.167 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1 +@str.167 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1 @str.168 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.169 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.170 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1 +@str.170 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1 @str.171 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.172 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.173 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1 +@str.173 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1 @str.174 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.175 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.176 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1 +@str.176 = private unnamed_addr constant [8 x i8] c"*string\00", align 1 @str.177 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.178 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.179 = private unnamed_addr constant [8 x i8] c"*string\00", align 1 +@str.179 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1 @str.180 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.181 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.182 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1 +@str.182 = private unnamed_addr constant [8 x i8] c"*Triple\00", align 1 @str.183 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @str.184 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.185 = private unnamed_addr constant [8 x i8] c"*Triple\00", align 1 +@str.185 = private unnamed_addr constant [8 x i8] c"*[3]Any\00", align 1 @str.186 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 -@str.187 = private unnamed_addr constant [5 x i8] c"null\00", align 1 -@str.188 = private unnamed_addr constant [8 x i8] c"*[3]Any\00", align 1 -@str.189 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1 @OBJC_METH_VAR_NAME_ = private unnamed_addr constant [12 x i8] c"tripleValue\00" @llvm.global_ctors = appending global [1 x { i32, ptr, ptr }] [{ i32, ptr, ptr } { i32 65535, ptr @__sx_objc_selector_init, ptr null }] @@ -239,38 +236,10 @@ entry: declare ptr @GPA.init(ptr) #0 ; Function Attrs: nounwind -define internal ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - store i64 %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %add = add i64 %loadN, 1 - store i64 %add, ptr %gep, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %call = call ptr @malloc(i64 %loadN) - ret ptr %call -} +declare ptr @GPA.alloc(ptr, ptr, i64) #0 ; Function Attrs: nounwind -define internal void @GPA.dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca ptr, align 8 - store ptr %2, ptr %allocaN, align 8 - %load = load ptr, ptr %alloca, align 8 - %gep = getelementptr inbounds { i64 }, ptr %load, i32 0, i32 0 - %loadN = load i64, ptr %gep, align 8 - %sub = sub i64 %loadN, 1 - store i64 %sub, ptr %gep, align 8 - %loadN = load ptr, ptr %allocaN, align 8 - call void @free(ptr %loadN) - ret void -} +declare void @GPA.dealloc(ptr, ptr, ptr) #0 ; Function Attrs: nounwind declare void @Arena.add_chunk(ptr, ptr, i64) #0 @@ -616,39 +585,39 @@ entry: %loadN = load i64, ptr %allocaN, align 8 %allocaN = alloca i64, align 8 store i64 %loadN, ptr %allocaN, align 8 - br label %while.hdr.173 + br label %while.hdr.172 -while.hdr.173: ; preds = %if.merge.178, %entry +while.hdr.172: ; preds = %if.merge.177, %entry %loadN = load i64, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp sge i64 %loadN, %loadN - br i1 %icmp, label %while.body.174, label %while.exit.175 + br i1 %icmp, label %while.body.173, label %while.exit.174 -while.body.174: ; preds = %while.hdr.173 +while.body.173: ; preds = %while.hdr.172 %loadN = load i64, ptr %allocaN, align 8 %srem = srem i64 %loadN, 16 %allocaN = alloca i64, align 8 store i64 %srem, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmpN = icmp slt i64 %loadN, 10 - br i1 %icmpN, label %if.then.176, label %if.else.177 + br i1 %icmpN, label %if.then.175, label %if.else.176 -while.exit.175: ; preds = %while.hdr.173 +while.exit.174: ; preds = %while.hdr.172 ret void -if.then.176: ; preds = %while.body.174 +if.then.175: ; preds = %while.body.173 %loadN = load i64, ptr %allocaN, align 8 %addN = add i64 %loadN, 48 - br label %if.merge.178 + br label %if.merge.177 -if.else.177: ; preds = %while.body.174 +if.else.176: ; preds = %while.body.173 %loadN = load i64, ptr %allocaN, align 8 %sub = sub i64 %loadN, 10 %addN = add i64 %sub, 97 - br label %if.merge.178 + br label %if.merge.177 -if.merge.178: ; preds = %if.else.177, %if.then.176 - %bp = phi i64 [ %addN, %if.then.176 ], [ %addN, %if.else.177 ] +if.merge.177: ; preds = %if.else.176, %if.then.175 + %bp = phi i64 [ %addN, %if.then.175 ], [ %addN, %if.else.176 ] %loadN = load i64, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %alloca, align 8 %igp.data = extractvalue { ptr, i64 } %loadN, 0 @@ -661,7 +630,7 @@ if.merge.178: ; preds = %if.else.177, %if.th %loadN = load i64, ptr %allocaN, align 8 %subN = sub i64 %loadN, 1 store i64 %subN, ptr %allocaN, align 8 - br label %while.hdr.173 + br label %while.hdr.172 } ; Function Attrs: nounwind @@ -671,27 +640,27 @@ entry: store i64 %1, ptr %alloca, align 8 %load = load i64, ptr %alloca, align 8 %icmp = icmp eq i64 %load, 0 - br i1 %icmp, label %if.then.163, label %if.merge.164 + br i1 %icmp, label %if.then.162, label %if.merge.163 -if.then.163: ; preds = %entry +if.then.162: ; preds = %entry ret { ptr, i64 } { ptr @str.3, i64 1 } -if.merge.164: ; preds = %entry +if.merge.163: ; preds = %entry %loadN = load i64, ptr %alloca, align 8 %srem = srem i64 %loadN, 65536 %allocaN = alloca i64, align 8 store i64 %srem, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmpN = icmp slt i64 %loadN, 0 - br i1 %icmpN, label %if.then.165, label %if.merge.166 + br i1 %icmpN, label %if.then.164, label %if.merge.165 -if.then.165: ; preds = %if.merge.164 +if.then.164: ; preds = %if.merge.163 %loadN = load i64, ptr %allocaN, align 8 %add = add i64 %loadN, 65536 store i64 %add, ptr %allocaN, align 8 - br label %if.merge.166 + br label %if.merge.165 -if.merge.166: ; preds = %if.then.165, %if.merge.164 +if.merge.165: ; preds = %if.then.164, %if.merge.163 %loadN = load i64, ptr %alloca, align 8 %loadN = load i64, ptr %allocaN, align 8 %sub = sub i64 %loadN, %loadN @@ -704,15 +673,15 @@ if.merge.166: ; preds = %if.then.165, %if.me store i64 %sremN, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmpN = icmp slt i64 %loadN, 0 - br i1 %icmpN, label %if.then.167, label %if.merge.168 + br i1 %icmpN, label %if.then.166, label %if.merge.167 -if.then.167: ; preds = %if.merge.166 +if.then.166: ; preds = %if.merge.165 %loadN = load i64, ptr %allocaN, align 8 %addN = add i64 %loadN, 65536 store i64 %addN, ptr %allocaN, align 8 - br label %if.merge.168 + br label %if.merge.167 -if.merge.168: ; preds = %if.then.167, %if.merge.166 +if.merge.167: ; preds = %if.then.166, %if.merge.165 %loadN = load i64, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %subN = sub i64 %loadN, %loadN @@ -725,15 +694,15 @@ if.merge.168: ; preds = %if.then.167, %if.me store i64 %sremN, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmpN = icmp slt i64 %loadN, 0 - br i1 %icmpN, label %if.then.169, label %if.merge.170 + br i1 %icmpN, label %if.then.168, label %if.merge.169 -if.then.169: ; preds = %if.merge.168 +if.then.168: ; preds = %if.merge.167 %loadN = load i64, ptr %allocaN, align 8 %addN = add i64 %loadN, 65536 store i64 %addN, ptr %allocaN, align 8 - br label %if.merge.170 + br label %if.merge.169 -if.merge.170: ; preds = %if.then.169, %if.merge.168 +if.merge.169: ; preds = %if.then.168, %if.merge.167 %loadN = load i64, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %subN = sub i64 %loadN, %loadN @@ -746,15 +715,15 @@ if.merge.170: ; preds = %if.then.169, %if.me store i64 %sremN, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmpN = icmp slt i64 %loadN, 0 - br i1 %icmpN, label %if.then.171, label %if.merge.172 + br i1 %icmpN, label %if.then.170, label %if.merge.171 -if.then.171: ; preds = %if.merge.170 +if.then.170: ; preds = %if.merge.169 %loadN = load i64, ptr %allocaN, align 8 %addN = add i64 %loadN, 65536 store i64 %addN, ptr %allocaN, align 8 - br label %if.merge.172 + br label %if.merge.171 -if.merge.172: ; preds = %if.then.171, %if.merge.170 +if.merge.171: ; preds = %if.then.170, %if.merge.169 %call = call { ptr, i64 } @cstring(ptr %0, i64 16) %allocaN = alloca { ptr, i64 }, align 8 store { ptr, i64 } %call, ptr %allocaN, align 8 @@ -772,14 +741,14 @@ if.merge.172: ; preds = %if.then.171, %if.me call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 12, i64 %loadN) %allocaN = alloca i64, align 8 store i64 0, ptr %allocaN, align 8 - br label %while.hdr.179 + br label %while.hdr.178 -while.hdr.179: ; preds = %if.merge.183, %if.merge.172 +while.hdr.178: ; preds = %if.merge.182, %if.merge.171 %loadN = load i64, ptr %allocaN, align 8 %icmpN = icmp slt i64 %loadN, 15 - br i1 %icmpN, label %while.body.180, label %while.exit.181 + br i1 %icmpN, label %while.body.179, label %while.exit.180 -while.body.180: ; preds = %while.hdr.179 +while.body.179: ; preds = %while.hdr.178 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %ig.data = extractvalue { ptr, i64 } %loadN, 0 @@ -787,9 +756,9 @@ while.body.180: ; preds = %while.hdr.179 %ig.val = load i8, ptr %ig.ptr, align 1 %cmp.ext = zext i8 %ig.val to i64 %icmpN = icmp ne i64 %cmp.ext, 48 - br i1 %icmpN, label %if.then.182, label %if.merge.183 + br i1 %icmpN, label %if.then.181, label %if.merge.182 -while.exit.181: ; preds = %if.then.182, %while.hdr.179 +while.exit.180: ; preds = %if.then.181, %while.hdr.178 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 @@ -797,14 +766,14 @@ while.exit.181: ; preds = %if.then.182, %while %callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 %loadN, i64 %subN) ret { ptr, i64 } %callN -if.then.182: ; preds = %while.body.180 - br label %while.exit.181 +if.then.181: ; preds = %while.body.179 + br label %while.exit.180 -if.merge.183: ; preds = %while.body.180 +if.merge.182: ; preds = %while.body.179 %loadN = load i64, ptr %allocaN, align 8 %addN = add i64 %loadN, 1 store i64 %addN, ptr %allocaN, align 8 - br label %while.hdr.179 + br label %while.hdr.178 } ; Function Attrs: nounwind @@ -917,10 +886,10 @@ entry: i64 38, label %match.arm.6 i64 34, label %match.arm.7 i64 35, label %match.arm.7 - i64 45, label %match.arm.9 - i64 52, label %match.arm.9 + i64 44, label %match.arm.9 + i64 51, label %match.arm.9 i64 33, label %match.arm.10 - i64 44, label %match.arm.10 + i64 43, label %match.arm.10 i64 17, label %match.arm.11 i64 20, label %match.arm.11 i64 22, label %match.arm.11 @@ -933,14 +902,13 @@ entry: i64 40, label %match.arm.11 i64 41, label %match.arm.11 i64 42, label %match.arm.11 - i64 43, label %match.arm.11 + i64 45, label %match.arm.11 i64 46, label %match.arm.11 i64 47, label %match.arm.11 i64 48, label %match.arm.11 i64 49, label %match.arm.11 i64 50, label %match.arm.11 - i64 51, label %match.arm.11 - i64 53, label %match.arm.11 + i64 52, label %match.arm.11 i64 13, label %match.arm.12 ] @@ -1019,8 +987,8 @@ match.arm.9: ; preds = %entry, %entry %loadN = load { i64, i64 }, ptr %alloca, align 8 %allocaN = alloca { ptr, i64 }, align 8 switch i64 %loadN, label %dispatch.default.111 [ - i64 45, label %dispatch.case.112 - i64 52, label %dispatch.case.113 + i64 44, label %dispatch.case.112 + i64 51, label %dispatch.case.113 ] match.arm.10: ; preds = %entry, %entry @@ -1029,10 +997,10 @@ match.arm.10: ; preds = %entry, %entry %allocaN = alloca { ptr, i64 }, align 8 switch i64 %loadN, label %dispatch.default.125 [ i64 33, label %dispatch.case.126 - i64 44, label %dispatch.case.127 + i64 43, label %dispatch.case.127 ] -match.arm.11: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry +match.arm.11: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry %loadN = load i64, ptr %allocaN, align 8 %loadN = load { i64, i64 }, ptr %alloca, align 8 %allocaN = alloca { ptr, i64 }, align 8 @@ -1049,14 +1017,13 @@ match.arm.11: ; preds = %entry, %entry, %ent i64 40, label %dispatch.case.149 i64 41, label %dispatch.case.150 i64 42, label %dispatch.case.151 - i64 43, label %dispatch.case.152 + i64 45, label %dispatch.case.152 i64 46, label %dispatch.case.153 i64 47, label %dispatch.case.154 i64 48, label %dispatch.case.155 i64 49, label %dispatch.case.156 i64 50, label %dispatch.case.157 - i64 51, label %dispatch.case.158 - i64 53, label %dispatch.case.159 + i64 52, label %dispatch.case.158 ] match.arm.12: ; preds = %entry @@ -1253,7 +1220,7 @@ dispatch.case.127: ; preds = %match.arm.10 store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.124 -dispatch.merge.138: ; preds = %dispatch.case.159, %dispatch.case.158, %dispatch.case.157, %dispatch.case.156, %dispatch.case.155, %dispatch.case.154, %dispatch.case.153, %dispatch.case.152, %dispatch.case.151, %dispatch.case.150, %dispatch.case.149, %dispatch.case.148, %dispatch.case.147, %dispatch.case.146, %dispatch.case.145, %dispatch.case.144, %dispatch.case.143, %dispatch.case.142, %dispatch.case.141, %dispatch.case.140, %dispatch.default.139 +dispatch.merge.138: ; preds = %dispatch.case.158, %dispatch.case.157, %dispatch.case.156, %dispatch.case.155, %dispatch.case.154, %dispatch.case.153, %dispatch.case.152, %dispatch.case.151, %dispatch.case.150, %dispatch.case.149, %dispatch.case.148, %dispatch.case.147, %dispatch.case.146, %dispatch.case.145, %dispatch.case.144, %dispatch.case.143, %dispatch.case.142, %dispatch.case.141, %dispatch.case.140, %dispatch.default.139 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 store { ptr, i64 } %loadN, ptr %allocaN, align 8 br label %match.merge.0 @@ -1342,63 +1309,56 @@ dispatch.case.150: ; preds = %match.arm.11 dispatch.case.151: ; preds = %match.arm.11 %ua.raw138 = extractvalue { i64, i64 } %loadN, 1 %iNp139 = inttoptr i64 %ua.raw138 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_GPA(ptr %0, ptr %iNp139) + %callN = call { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %iNp139) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 dispatch.case.152: ; preds = %match.arm.11 %ua.raw141 = extractvalue { i64, i64 } %loadN, 1 %iNp142 = inttoptr i64 %ua.raw141 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %iNp142) + %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %iNp142) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 dispatch.case.153: ; preds = %match.arm.11 %ua.raw144 = extractvalue { i64, i64 } %loadN, 1 %iNp145 = inttoptr i64 %ua.raw144 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %iNp145) + %callN = call { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %iNp145) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 dispatch.case.154: ; preds = %match.arm.11 %ua.raw147 = extractvalue { i64, i64 } %loadN, 1 %iNp148 = inttoptr i64 %ua.raw147 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %iNp148) + %callN = call { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %iNp148) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 dispatch.case.155: ; preds = %match.arm.11 %ua.raw150 = extractvalue { i64, i64 } %loadN, 1 %iNp151 = inttoptr i64 %ua.raw150 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %iNp151) + %callN = call { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %iNp151) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 dispatch.case.156: ; preds = %match.arm.11 %ua.raw153 = extractvalue { i64, i64 } %loadN, 1 %iNp154 = inttoptr i64 %ua.raw153 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %iNp154) + %callN = call { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %iNp154) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 dispatch.case.157: ; preds = %match.arm.11 %ua.raw156 = extractvalue { i64, i64 } %loadN, 1 %iNp157 = inttoptr i64 %ua.raw156 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %iNp157) + %callN = call { ptr, i64 } @pointer_to_string__ptr_Triple(ptr %0, ptr %iNp157) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 dispatch.case.158: ; preds = %match.arm.11 %ua.raw159 = extractvalue { i64, i64 } %loadN, 1 %iNp160 = inttoptr i64 %ua.raw159 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_Triple(ptr %0, ptr %iNp160) - store { ptr, i64 } %callN, ptr %allocaN, align 8 - br label %dispatch.merge.138 - -dispatch.case.159: ; preds = %match.arm.11 - %ua.raw162 = extractvalue { i64, i64 } %loadN, 1 - %iNp163 = inttoptr i64 %ua.raw162 to ptr - %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_3_Any(ptr %0, ptr %iNp163) + %callN = call { ptr, i64 } @pointer_to_string__ptr_AR_3_Any(ptr %0, ptr %iNp160) store { ptr, i64 } %callN, ptr %allocaN, align 8 br label %dispatch.merge.138 } @@ -1574,18 +1534,10 @@ entry: define i32 @main() #0 { entry: call void @__sx_objc_selector_init() - %alloca = alloca { i64 }, align 8 - store { i64 } zeroinitializer, ptr %alloca, align 8 - %si = insertvalue { ptr, ptr, ptr } undef, ptr %alloca, 0 - %siN = insertvalue { ptr, ptr, ptr } %si, ptr @__thunk_GPA_Allocator_alloc, 1 - %siN = insertvalue { ptr, ptr, ptr } %siN, ptr @__thunk_GPA_Allocator_dealloc, 2 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } undef, { ptr, ptr, ptr } %siN, 0 - %siN = insertvalue { { ptr, ptr, ptr }, ptr } %siN, ptr null, 1 - store { { ptr, ptr, ptr }, ptr } %siN, ptr @context, align 8 %call = call ptr @objc_getClass(ptr @str.11) - %allocaN = alloca ptr, align 8 - store ptr %call, ptr %allocaN, align 8 - %load = load ptr, ptr %allocaN, align 8 + %alloca = alloca ptr, align 8 + store ptr %call, ptr %alloca, align 8 + %load = load ptr, ptr %alloca, align 8 %callN = call ptr @objc_allocateClassPair(ptr %load, ptr @str.12, i64 0) %allocaN = alloca ptr, align 8 store ptr %callN, ptr %allocaN, align 8 @@ -1604,9 +1556,9 @@ entry: %igp.ptr = getelementptr { i64, i64 }, ptr %allocaN, i64 0 store { i64, i64 } %ba.val, ptr %igp.ptr, align 8 %allocaN = alloca { ptr, i64 }, align 8 - %igp.ptr17 = getelementptr { i64, i64 }, ptr %allocaN, i64 0 + %igp.ptr12 = getelementptr { i64, i64 }, ptr %allocaN, i64 0 %gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0 - store ptr %igp.ptr17, ptr %gep, align 8 + store ptr %igp.ptr12, ptr %gep, align 8 %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1 store i64 1, ptr %gepN, align 8 %allocaN = alloca { ptr, i64 }, align 8 @@ -1651,23 +1603,23 @@ entry: %allocaN = alloca [3 x { i64, i64 }], align 8 %loadN = load { i64, i64, i64 }, ptr %allocaN, align 8 %sg = extractvalue { i64, i64, i64 } %loadN, 0 - %ba.val43 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %sg, 1 - %igp.ptr44 = getelementptr { i64, i64 }, ptr %allocaN, i64 0 - store { i64, i64 } %ba.val43, ptr %igp.ptr44, align 8 + %ba.val38 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %sg, 1 + %igp.ptr39 = getelementptr { i64, i64 }, ptr %allocaN, i64 0 + store { i64, i64 } %ba.val38, ptr %igp.ptr39, align 8 %loadN = load { i64, i64, i64 }, ptr %allocaN, align 8 %sgN = extractvalue { i64, i64, i64 } %loadN, 1 - %ba.val47 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %sgN, 1 - %igp.ptr48 = getelementptr { i64, i64 }, ptr %allocaN, i64 1 - store { i64, i64 } %ba.val47, ptr %igp.ptr48, align 8 + %ba.val42 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %sgN, 1 + %igp.ptr43 = getelementptr { i64, i64 }, ptr %allocaN, i64 1 + store { i64, i64 } %ba.val42, ptr %igp.ptr43, align 8 %loadN = load { i64, i64, i64 }, ptr %allocaN, align 8 %sgN = extractvalue { i64, i64, i64 } %loadN, 2 - %ba.val51 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %sgN, 1 - %igp.ptr52 = getelementptr { i64, i64 }, ptr %allocaN, i64 2 - store { i64, i64 } %ba.val51, ptr %igp.ptr52, align 8 + %ba.val46 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %sgN, 1 + %igp.ptr47 = getelementptr { i64, i64 }, ptr %allocaN, i64 2 + store { i64, i64 } %ba.val46, ptr %igp.ptr47, align 8 %allocaN = alloca { ptr, i64 }, align 8 - %igp.ptr54 = getelementptr { i64, i64 }, ptr %allocaN, i64 0 + %igp.ptr49 = getelementptr { i64, i64 }, ptr %allocaN, i64 0 %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0 - store ptr %igp.ptr54, ptr %gepN, align 8 + store ptr %igp.ptr49, ptr %gepN, align 8 %gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1 store i64 3, ptr %gepN, align 8 %allocaN = alloca { ptr, i64 }, align 8 @@ -1681,10 +1633,10 @@ entry: store { ptr, i64 } %callN, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 - %ig.data65 = extractvalue { ptr, i64 } %loadN, 0 - %ig.ptr66 = getelementptr { i64, i64 }, ptr %ig.data65, i64 0 - %ig.val67 = load { i64, i64 }, ptr %ig.ptr66, align 8 - %callN = call { ptr, i64 } @any_to_string(ptr @__sx_default_context, { i64, i64 } %ig.val67) + %ig.data60 = extractvalue { ptr, i64 } %loadN, 0 + %ig.ptr61 = getelementptr { i64, i64 }, ptr %ig.data60, i64 0 + %ig.val62 = load { i64, i64 }, ptr %ig.ptr61, align 8 + %callN = call { ptr, i64 } @any_to_string(ptr @__sx_default_context, { i64, i64 } %ig.val62) %callN = call { ptr, i64 } @concat(ptr @__sx_default_context, { ptr, i64 } %loadN, { ptr, i64 } %callN) store { ptr, i64 } %callN, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 @@ -1694,10 +1646,10 @@ entry: store { ptr, i64 } %callN, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 - %ig.data76 = extractvalue { ptr, i64 } %loadN, 0 - %ig.ptr77 = getelementptr { i64, i64 }, ptr %ig.data76, i64 1 - %ig.val78 = load { i64, i64 }, ptr %ig.ptr77, align 8 - %callN = call { ptr, i64 } @any_to_string(ptr @__sx_default_context, { i64, i64 } %ig.val78) + %ig.data71 = extractvalue { ptr, i64 } %loadN, 0 + %ig.ptr72 = getelementptr { i64, i64 }, ptr %ig.data71, i64 1 + %ig.val73 = load { i64, i64 }, ptr %ig.ptr72, align 8 + %callN = call { ptr, i64 } @any_to_string(ptr @__sx_default_context, { i64, i64 } %ig.val73) %callN = call { ptr, i64 } @concat(ptr @__sx_default_context, { ptr, i64 } %loadN, { ptr, i64 } %callN) store { ptr, i64 } %callN, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 @@ -1707,10 +1659,10 @@ entry: store { ptr, i64 } %callN, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 - %ig.data87 = extractvalue { ptr, i64 } %loadN, 0 - %ig.ptr88 = getelementptr { i64, i64 }, ptr %ig.data87, i64 2 - %ig.val89 = load { i64, i64 }, ptr %ig.ptr88, align 8 - %callN = call { ptr, i64 } @any_to_string(ptr @__sx_default_context, { i64, i64 } %ig.val89) + %ig.data82 = extractvalue { ptr, i64 } %loadN, 0 + %ig.ptr83 = getelementptr { i64, i64 }, ptr %ig.data82, i64 2 + %ig.val84 = load { i64, i64 }, ptr %ig.ptr83, align 8 + %callN = call { ptr, i64 } @any_to_string(ptr @__sx_default_context, { i64, i64 } %ig.val84) %callN = call { ptr, i64 } @concat(ptr @__sx_default_context, { ptr, i64 } %loadN, { ptr, i64 } %callN) store { ptr, i64 } %callN, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 @@ -1719,9 +1671,9 @@ entry: %callN = call { ptr, i64 } @concat(ptr @__sx_default_context, { ptr, i64 } %loadN, { ptr, i64 } %callN) store { ptr, i64 } %callN, ptr %allocaN, align 8 %loadN = load { ptr, i64 }, ptr %allocaN, align 8 - %str.ptr97 = extractvalue { ptr, i64 } %loadN, 0 - %str.len98 = extractvalue { ptr, i64 } %loadN, 1 - %1 = call i64 @write(i32 1, ptr %str.ptr97, i64 %str.len98) + %str.ptr92 = extractvalue { ptr, i64 } %loadN, 0 + %str.len93 = extractvalue { ptr, i64 } %loadN, 1 + %1 = call i64 @write(i32 1, ptr %str.ptr92, i64 %str.len93) ret i32 0 } @@ -1739,20 +1691,6 @@ entry: ret void } -; Function Attrs: nounwind -define internal ptr @__thunk_GPA_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 { -entry: - %call = call ptr @GPA.alloc(ptr %0, ptr %1, i64 %2) - ret ptr %call -} - -; Function Attrs: nounwind -define internal void @__thunk_GPA_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 { -entry: - call void @GPA.dealloc(ptr %0, ptr %1, ptr %2) - ret void -} - ; Function Attrs: nounwind define internal { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %1) #0 { entry: @@ -2816,20 +2754,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.160, label %if.else.161 + br i1 %icmp, label %if.then.159, label %if.else.160 -if.then.160: ; preds = %entry - br label %if.merge.162 +if.then.159: ; preds = %entry + br label %if.merge.161 -if.else.161: ; preds = %entry +if.else.160: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.132, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.131, i64 5 }, { ptr, i64 } %callN) - br label %if.merge.162 + br label %if.merge.161 -if.merge.162: ; preds = %if.else.161, %if.then.160 - %bp = phi { ptr, i64 } [ { ptr @str.130, i64 4 }, %if.then.160 ], [ %callN, %if.else.161 ] +if.merge.161: ; preds = %if.else.160, %if.then.159 + %bp = phi { ptr, i64 } [ { ptr @str.130, i64 4 }, %if.then.159 ], [ %callN, %if.else.160 ] ret { ptr, i64 } %bp } @@ -2844,20 +2782,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.184, label %if.else.185 + br i1 %icmp, label %if.then.183, label %if.else.184 -if.then.184: ; preds = %entry - br label %if.merge.186 +if.then.183: ; preds = %entry + br label %if.merge.185 -if.else.185: ; preds = %entry +if.else.184: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.135, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.134, i64 11 }, { ptr, i64 } %callN) - br label %if.merge.186 + br label %if.merge.185 -if.merge.186: ; preds = %if.else.185, %if.then.184 - %bp = phi { ptr, i64 } [ { ptr @str.133, i64 4 }, %if.then.184 ], [ %callN, %if.else.185 ] +if.merge.185: ; preds = %if.else.184, %if.then.183 + %bp = phi { ptr, i64 } [ { ptr @str.133, i64 4 }, %if.then.183 ], [ %callN, %if.else.184 ] ret { ptr, i64 } %bp } @@ -2872,20 +2810,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.187, label %if.else.188 + br i1 %icmp, label %if.then.186, label %if.else.187 -if.then.187: ; preds = %entry - br label %if.merge.189 +if.then.186: ; preds = %entry + br label %if.merge.188 -if.else.188: ; preds = %entry +if.else.187: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.138, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.137, i64 4 }, { ptr, i64 } %callN) - br label %if.merge.189 + br label %if.merge.188 -if.merge.189: ; preds = %if.else.188, %if.then.187 - %bp = phi { ptr, i64 } [ { ptr @str.136, i64 4 }, %if.then.187 ], [ %callN, %if.else.188 ] +if.merge.188: ; preds = %if.else.187, %if.then.186 + %bp = phi { ptr, i64 } [ { ptr @str.136, i64 4 }, %if.then.186 ], [ %callN, %if.else.187 ] ret { ptr, i64 } %bp } @@ -2900,20 +2838,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.190, label %if.else.191 + br i1 %icmp, label %if.then.189, label %if.else.190 -if.then.190: ; preds = %entry - br label %if.merge.192 +if.then.189: ; preds = %entry + br label %if.merge.191 -if.else.191: ; preds = %entry +if.else.190: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.141, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.140, i64 11 }, { ptr, i64 } %callN) - br label %if.merge.192 + br label %if.merge.191 -if.merge.192: ; preds = %if.else.191, %if.then.190 - %bp = phi { ptr, i64 } [ { ptr @str.139, i64 4 }, %if.then.190 ], [ %callN, %if.else.191 ] +if.merge.191: ; preds = %if.else.190, %if.then.189 + %bp = phi { ptr, i64 } [ { ptr @str.139, i64 4 }, %if.then.189 ], [ %callN, %if.else.190 ] ret { ptr, i64 } %bp } @@ -2928,20 +2866,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.193, label %if.else.194 + br i1 %icmp, label %if.then.192, label %if.else.193 -if.then.193: ; preds = %entry - br label %if.merge.195 +if.then.192: ; preds = %entry + br label %if.merge.194 -if.else.194: ; preds = %entry +if.else.193: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.144, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.143, i64 6 }, { ptr, i64 } %callN) - br label %if.merge.195 + br label %if.merge.194 -if.merge.195: ; preds = %if.else.194, %if.then.193 - %bp = phi { ptr, i64 } [ { ptr @str.142, i64 4 }, %if.then.193 ], [ %callN, %if.else.194 ] +if.merge.194: ; preds = %if.else.193, %if.then.192 + %bp = phi { ptr, i64 } [ { ptr @str.142, i64 4 }, %if.then.192 ], [ %callN, %if.else.193 ] ret { ptr, i64 } %bp } @@ -2955,20 +2893,20 @@ entry: store ptr %load, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.196, label %if.else.197 + br i1 %icmp, label %if.then.195, label %if.else.196 -if.then.196: ; preds = %entry - br label %if.merge.198 +if.then.195: ; preds = %entry + br label %if.merge.197 -if.else.197: ; preds = %entry +if.else.196: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.147, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.146, i64 5 }, { ptr, i64 } %callN) - br label %if.merge.198 + br label %if.merge.197 -if.merge.198: ; preds = %if.else.197, %if.then.196 - %bp = phi { ptr, i64 } [ { ptr @str.145, i64 4 }, %if.then.196 ], [ %callN, %if.else.197 ] +if.merge.197: ; preds = %if.else.196, %if.then.195 + %bp = phi { ptr, i64 } [ { ptr @str.145, i64 4 }, %if.then.195 ], [ %callN, %if.else.196 ] ret { ptr, i64 } %bp } @@ -2983,20 +2921,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.199, label %if.else.200 + br i1 %icmp, label %if.then.198, label %if.else.199 -if.then.199: ; preds = %entry - br label %if.merge.201 +if.then.198: ; preds = %entry + br label %if.merge.200 -if.else.200: ; preds = %entry +if.else.199: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.150, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.149, i64 9 }, { ptr, i64 } %callN) - br label %if.merge.201 + br label %if.merge.200 -if.merge.201: ; preds = %if.else.200, %if.then.199 - %bp = phi { ptr, i64 } [ { ptr @str.148, i64 4 }, %if.then.199 ], [ %callN, %if.else.200 ] +if.merge.200: ; preds = %if.else.199, %if.then.198 + %bp = phi { ptr, i64 } [ { ptr @str.148, i64 4 }, %if.then.198 ], [ %callN, %if.else.199 ] ret { ptr, i64 } %bp } @@ -3011,20 +2949,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.202, label %if.else.203 + br i1 %icmp, label %if.then.201, label %if.else.202 -if.then.202: ; preds = %entry - br label %if.merge.204 +if.then.201: ; preds = %entry + br label %if.merge.203 -if.else.203: ; preds = %entry +if.else.202: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.153, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.152, i64 18 }, { ptr, i64 } %callN) - br label %if.merge.204 + br label %if.merge.203 -if.merge.204: ; preds = %if.else.203, %if.then.202 - %bp = phi { ptr, i64 } [ { ptr @str.151, i64 4 }, %if.then.202 ], [ %callN, %if.else.203 ] +if.merge.203: ; preds = %if.else.202, %if.then.201 + %bp = phi { ptr, i64 } [ { ptr @str.151, i64 4 }, %if.then.201 ], [ %callN, %if.else.202 ] ret { ptr, i64 } %bp } @@ -3039,20 +2977,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.205, label %if.else.206 + br i1 %icmp, label %if.then.204, label %if.else.205 -if.then.205: ; preds = %entry - br label %if.merge.207 +if.then.204: ; preds = %entry + br label %if.merge.206 -if.else.206: ; preds = %entry +if.else.205: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.156, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.155, i64 12 }, { ptr, i64 } %callN) - br label %if.merge.207 + br label %if.merge.206 -if.merge.207: ; preds = %if.else.206, %if.then.205 - %bp = phi { ptr, i64 } [ { ptr @str.154, i64 4 }, %if.then.205 ], [ %callN, %if.else.206 ] +if.merge.206: ; preds = %if.else.205, %if.then.204 + %bp = phi { ptr, i64 } [ { ptr @str.154, i64 4 }, %if.then.204 ], [ %callN, %if.else.205 ] ret { ptr, i64 } %bp } @@ -3067,20 +3005,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.208, label %if.else.209 + br i1 %icmp, label %if.then.207, label %if.else.208 -if.then.208: ; preds = %entry - br label %if.merge.210 +if.then.207: ; preds = %entry + br label %if.merge.209 -if.else.209: ; preds = %entry +if.else.208: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.159, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.158, i64 4 }, { ptr, i64 } %callN) - br label %if.merge.210 + br label %if.merge.209 -if.merge.210: ; preds = %if.else.209, %if.then.208 - %bp = phi { ptr, i64 } [ { ptr @str.157, i64 4 }, %if.then.208 ], [ %callN, %if.else.209 ] +if.merge.209: ; preds = %if.else.208, %if.then.207 + %bp = phi { ptr, i64 } [ { ptr @str.157, i64 4 }, %if.then.207 ], [ %callN, %if.else.208 ] ret { ptr, i64 } %bp } @@ -3095,48 +3033,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.211, label %if.else.212 + br i1 %icmp, label %if.then.210, label %if.else.211 -if.then.211: ; preds = %entry - br label %if.merge.213 +if.then.210: ; preds = %entry + br label %if.merge.212 -if.else.212: ; preds = %entry +if.else.211: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.162, i64 3 }, { ptr, i64 } %call) %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.161, i64 6 }, { ptr, i64 } %callN) - br label %if.merge.213 + br label %if.merge.212 -if.merge.213: ; preds = %if.else.212, %if.then.211 - %bp = phi { ptr, i64 } [ { ptr @str.160, i64 4 }, %if.then.211 ], [ %callN, %if.else.212 ] - ret { ptr, i64 } %bp -} - -; Function Attrs: nounwind -define internal { ptr, i64 } @pointer_to_string__ptr_ptr_GPA(ptr %0, ptr %1) #0 { -entry: - %alloca = alloca ptr, align 8 - store ptr %1, ptr %alloca, align 8 - %allocaN = alloca i64, align 8 - %load = load ptr, ptr %alloca, align 8 - %pti = ptrtoint ptr %load to i64 - store i64 %pti, ptr %allocaN, align 8 - %loadN = load i64, ptr %allocaN, align 8 - %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.214, label %if.else.215 - -if.then.214: ; preds = %entry - br label %if.merge.216 - -if.else.215: ; preds = %entry - %loadN = load i64, ptr %allocaN, align 8 - %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.165, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.164, i64 5 }, { ptr, i64 } %callN) - br label %if.merge.216 - -if.merge.216: ; preds = %if.else.215, %if.then.214 - %bp = phi { ptr, i64 } [ { ptr @str.163, i64 4 }, %if.then.214 ], [ %callN, %if.else.215 ] +if.merge.212: ; preds = %if.else.211, %if.then.210 + %bp = phi { ptr, i64 } [ { ptr @str.160, i64 4 }, %if.then.210 ], [ %callN, %if.else.211 ] ret { ptr, i64 } %bp } @@ -3151,20 +3061,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.217, label %if.else.218 + br i1 %icmp, label %if.then.213, label %if.else.214 -if.then.217: ; preds = %entry - br label %if.merge.219 +if.then.213: ; preds = %entry + br label %if.merge.215 -if.else.218: ; preds = %entry +if.else.214: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.168, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.167, i64 5 }, { ptr, i64 } %callN) - br label %if.merge.219 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.165, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.164, i64 5 }, { ptr, i64 } %callN) + br label %if.merge.215 -if.merge.219: ; preds = %if.else.218, %if.then.217 - %bp = phi { ptr, i64 } [ { ptr @str.166, i64 4 }, %if.then.217 ], [ %callN, %if.else.218 ] +if.merge.215: ; preds = %if.else.214, %if.then.213 + %bp = phi { ptr, i64 } [ { ptr @str.163, i64 4 }, %if.then.213 ], [ %callN, %if.else.214 ] ret { ptr, i64 } %bp } @@ -3179,20 +3089,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.220, label %if.else.221 + br i1 %icmp, label %if.then.216, label %if.else.217 -if.then.220: ; preds = %entry - br label %if.merge.222 +if.then.216: ; preds = %entry + br label %if.merge.218 -if.else.221: ; preds = %entry +if.else.217: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.171, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.170, i64 7 }, { ptr, i64 } %callN) - br label %if.merge.222 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.168, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.167, i64 7 }, { ptr, i64 } %callN) + br label %if.merge.218 -if.merge.222: ; preds = %if.else.221, %if.then.220 - %bp = phi { ptr, i64 } [ { ptr @str.169, i64 4 }, %if.then.220 ], [ %callN, %if.else.221 ] +if.merge.218: ; preds = %if.else.217, %if.then.216 + %bp = phi { ptr, i64 } [ { ptr @str.166, i64 4 }, %if.then.216 ], [ %callN, %if.else.217 ] ret { ptr, i64 } %bp } @@ -3207,20 +3117,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.223, label %if.else.224 + br i1 %icmp, label %if.then.219, label %if.else.220 -if.then.223: ; preds = %entry - br label %if.merge.225 +if.then.219: ; preds = %entry + br label %if.merge.221 -if.else.224: ; preds = %entry +if.else.220: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.174, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.173, i64 4 }, { ptr, i64 } %callN) - br label %if.merge.225 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.171, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.170, i64 4 }, { ptr, i64 } %callN) + br label %if.merge.221 -if.merge.225: ; preds = %if.else.224, %if.then.223 - %bp = phi { ptr, i64 } [ { ptr @str.172, i64 4 }, %if.then.223 ], [ %callN, %if.else.224 ] +if.merge.221: ; preds = %if.else.220, %if.then.219 + %bp = phi { ptr, i64 } [ { ptr @str.169, i64 4 }, %if.then.219 ], [ %callN, %if.else.220 ] ret { ptr, i64 } %bp } @@ -3235,20 +3145,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.226, label %if.else.227 + br i1 %icmp, label %if.then.222, label %if.else.223 -if.then.226: ; preds = %entry - br label %if.merge.228 +if.then.222: ; preds = %entry + br label %if.merge.224 -if.else.227: ; preds = %entry +if.else.223: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.177, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.176, i64 6 }, { ptr, i64 } %callN) - br label %if.merge.228 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.174, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.173, i64 6 }, { ptr, i64 } %callN) + br label %if.merge.224 -if.merge.228: ; preds = %if.else.227, %if.then.226 - %bp = phi { ptr, i64 } [ { ptr @str.175, i64 4 }, %if.then.226 ], [ %callN, %if.else.227 ] +if.merge.224: ; preds = %if.else.223, %if.then.222 + %bp = phi { ptr, i64 } [ { ptr @str.172, i64 4 }, %if.then.222 ], [ %callN, %if.else.223 ] ret { ptr, i64 } %bp } @@ -3263,20 +3173,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.229, label %if.else.230 + br i1 %icmp, label %if.then.225, label %if.else.226 -if.then.229: ; preds = %entry - br label %if.merge.231 +if.then.225: ; preds = %entry + br label %if.merge.227 -if.else.230: ; preds = %entry +if.else.226: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.180, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.179, i64 7 }, { ptr, i64 } %callN) - br label %if.merge.231 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.177, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.176, i64 7 }, { ptr, i64 } %callN) + br label %if.merge.227 -if.merge.231: ; preds = %if.else.230, %if.then.229 - %bp = phi { ptr, i64 } [ { ptr @str.178, i64 4 }, %if.then.229 ], [ %callN, %if.else.230 ] +if.merge.227: ; preds = %if.else.226, %if.then.225 + %bp = phi { ptr, i64 } [ { ptr @str.175, i64 4 }, %if.then.225 ], [ %callN, %if.else.226 ] ret { ptr, i64 } %bp } @@ -3291,20 +3201,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.232, label %if.else.233 + br i1 %icmp, label %if.then.228, label %if.else.229 -if.then.232: ; preds = %entry - br label %if.merge.234 +if.then.228: ; preds = %entry + br label %if.merge.230 -if.else.233: ; preds = %entry +if.else.229: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.183, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.182, i64 3 }, { ptr, i64 } %callN) - br label %if.merge.234 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.180, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.179, i64 3 }, { ptr, i64 } %callN) + br label %if.merge.230 -if.merge.234: ; preds = %if.else.233, %if.then.232 - %bp = phi { ptr, i64 } [ { ptr @str.181, i64 4 }, %if.then.232 ], [ %callN, %if.else.233 ] +if.merge.230: ; preds = %if.else.229, %if.then.228 + %bp = phi { ptr, i64 } [ { ptr @str.178, i64 4 }, %if.then.228 ], [ %callN, %if.else.229 ] ret { ptr, i64 } %bp } @@ -3319,20 +3229,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.235, label %if.else.236 + br i1 %icmp, label %if.then.231, label %if.else.232 -if.then.235: ; preds = %entry - br label %if.merge.237 +if.then.231: ; preds = %entry + br label %if.merge.233 -if.else.236: ; preds = %entry +if.else.232: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.186, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.185, i64 7 }, { ptr, i64 } %callN) - br label %if.merge.237 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.183, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.182, i64 7 }, { ptr, i64 } %callN) + br label %if.merge.233 -if.merge.237: ; preds = %if.else.236, %if.then.235 - %bp = phi { ptr, i64 } [ { ptr @str.184, i64 4 }, %if.then.235 ], [ %callN, %if.else.236 ] +if.merge.233: ; preds = %if.else.232, %if.then.231 + %bp = phi { ptr, i64 } [ { ptr @str.181, i64 4 }, %if.then.231 ], [ %callN, %if.else.232 ] ret { ptr, i64 } %bp } @@ -3347,20 +3257,20 @@ entry: store i64 %pti, ptr %allocaN, align 8 %loadN = load i64, ptr %allocaN, align 8 %icmp = icmp eq i64 %loadN, 0 - br i1 %icmp, label %if.then.238, label %if.else.239 + br i1 %icmp, label %if.then.234, label %if.else.235 -if.then.238: ; preds = %entry - br label %if.merge.240 +if.then.234: ; preds = %entry + br label %if.merge.236 -if.else.239: ; preds = %entry +if.else.235: ; preds = %entry %loadN = load i64, ptr %allocaN, align 8 %call = call { ptr, i64 } @int_to_hex_string(ptr %0, i64 %loadN) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.189, i64 3 }, { ptr, i64 } %call) - %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.188, i64 7 }, { ptr, i64 } %callN) - br label %if.merge.240 + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.186, i64 3 }, { ptr, i64 } %call) + %callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.185, i64 7 }, { ptr, i64 } %callN) + br label %if.merge.236 -if.merge.240: ; preds = %if.else.239, %if.then.238 - %bp = phi { ptr, i64 } [ { ptr @str.187, i64 4 }, %if.then.238 ], [ %callN, %if.else.239 ] +if.merge.236: ; preds = %if.else.235, %if.then.234 + %bp = phi { ptr, i64 } [ { ptr @str.184, i64 4 }, %if.then.234 ], [ %callN, %if.else.235 ] ret { ptr, i64 } %bp }