878c4226a6
An alloca built at its use site re-executes on every pass through that block, and LLVM reclaims allocas only at ret — so loop-body locals, nested-loop index slots, and emitter spill temps (ig.tmp, sret slots, ABI coercion temps, byval materialization) grew the stack per iteration and long loops segfaulted on stack exhaustion. New LLVMEmitter.buildEntryAlloca inserts after existing entry-block allocas and restores the builder position; every LLVMBuildAlloca site reachable during instruction emission now routes through it. Initialization stores stay at the use site (per-iteration re-init is unchanged), and entry slots become mem2reg-promotable. The 35 .ir snapshot diffs are pure alloca position moves (type multisets verified identical per file). Regression: examples/0047-basic-loop-local-stack-reuse.sx (segfaulted pre-fix on both the 1M-iteration body-local loop and the 3M-iteration nested loop).
3515 lines
160 KiB
Plaintext
3515 lines
160 KiB
Plaintext
|
|
@__sx_default_context = internal global { { ptr, ptr, ptr }, ptr } { { ptr, ptr, ptr } { ptr null, ptr @__thunk_CAllocator_Allocator_alloc, ptr @__thunk_CAllocator_Allocator_dealloc }, ptr null }
|
|
@str = private unnamed_addr constant [2 x i8] c"0\00", align 1
|
|
@str.1 = private unnamed_addr constant [2 x i8] c"0\00", align 1
|
|
@str.2 = private unnamed_addr constant [5 x i8] c"true\00", align 1
|
|
@str.3 = private unnamed_addr constant [6 x i8] c"false\00", align 1
|
|
@str.4 = private unnamed_addr constant [2 x i8] c"0\00", align 1
|
|
@str.5 = private unnamed_addr constant [4 x i8] c"<?>\00", align 1
|
|
@str.6 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@__sx_type_is_unsigned = private constant [75 x i1] [i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true, i1 true, i1 true, i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 true, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false]
|
|
@tag.str = private constant [1 x i8] zeroinitializer
|
|
@tag.str.7 = private constant [4 x i8] c"Bad\00"
|
|
@tag.str.8 = private constant [6 x i8] c"Worse\00"
|
|
@tag_names = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @tag.str, i64 0 }, { ptr, i64 } { ptr @tag.str.7, i64 3 }, { ptr, i64 } { ptr @tag.str.8, i64 5 }]
|
|
@tn.str = private constant [13 x i8] c"<unresolved>\00"
|
|
@tn.str.9 = private constant [5 x i8] c"bool\00"
|
|
@tn.str.10 = private constant [3 x i8] c"s8\00"
|
|
@tn.str.11 = private constant [4 x i8] c"s16\00"
|
|
@tn.str.12 = private constant [4 x i8] c"s32\00"
|
|
@tn.str.13 = private constant [4 x i8] c"s64\00"
|
|
@tn.str.14 = private constant [3 x i8] c"u8\00"
|
|
@tn.str.15 = private constant [4 x i8] c"u16\00"
|
|
@tn.str.16 = private constant [4 x i8] c"u32\00"
|
|
@tn.str.17 = private constant [4 x i8] c"u64\00"
|
|
@tn.str.18 = private constant [4 x i8] c"f32\00"
|
|
@tn.str.19 = private constant [4 x i8] c"f64\00"
|
|
@tn.str.20 = private constant [7 x i8] c"string\00"
|
|
@tn.str.21 = private constant [4 x i8] c"Any\00"
|
|
@tn.str.22 = private constant [9 x i8] c"noreturn\00"
|
|
@tn.str.23 = private constant [6 x i8] c"isize\00"
|
|
@tn.str.24 = private constant [6 x i8] c"usize\00"
|
|
@tn.str.25 = private constant [5 x i8] c"void\00"
|
|
@tn.str.26 = private constant [6 x i8] c"*void\00"
|
|
@tn.str.27 = private constant [16 x i8] c"Source_Location\00"
|
|
@tn.str.28 = private constant [10 x i8] c"Allocator\00"
|
|
@tn.str.29 = private constant [11 x i8] c"CAllocator\00"
|
|
@tn.str.30 = private constant [12 x i8] c"*CAllocator\00"
|
|
@tn.str.31 = private constant [4 x i8] c"GPA\00"
|
|
@tn.str.32 = private constant [5 x i8] c"*GPA\00"
|
|
@tn.str.33 = private constant [11 x i8] c"ArenaChunk\00"
|
|
@tn.str.34 = private constant [12 x i8] c"*ArenaChunk\00"
|
|
@tn.str.35 = private constant [6 x i8] c"Arena\00"
|
|
@tn.str.36 = private constant [7 x i8] c"*Arena\00"
|
|
@tn.str.37 = private constant [6 x i8] c"[*]u8\00"
|
|
@tn.str.38 = private constant [9 x i8] c"BufAlloc\00"
|
|
@tn.str.39 = private constant [10 x i8] c"*BufAlloc\00"
|
|
@tn.str.40 = private constant [18 x i8] c"TrackingAllocator\00"
|
|
@tn.str.41 = private constant [19 x i8] c"*TrackingAllocator\00"
|
|
@tn.str.42 = private constant [8 x i8] c"Context\00"
|
|
@tn.str.43 = private constant [7 x i8] c"[4]s64\00"
|
|
@tn.str.44 = private constant [9 x i8] c"[]string\00"
|
|
@tn.str.45 = private constant [2 x i8] c"E\00"
|
|
@tn.str.46 = private constant [13 x i8] c"**CAllocator\00"
|
|
@tn.str.47 = private constant [5 x i8] c"*s64\00"
|
|
@tn.str.48 = private constant [7 x i8] c"**void\00"
|
|
@tn.str.49 = private constant [5 x i8] c"*s32\00"
|
|
@tn.str.50 = private constant [3 x i8] c"*E\00"
|
|
@tn.str.51 = private constant [8 x i8] c"*string\00"
|
|
@tn.str.52 = private constant [6 x i8] c"[]Any\00"
|
|
@tn.str.53 = private constant [5 x i8] c"*Any\00"
|
|
@tn.str.54 = private constant [7 x i8] c"[1]Any\00"
|
|
@tn.str.55 = private constant [8 x i8] c"*[1]Any\00"
|
|
@tn.str.56 = private constant [7 x i8] c"*[]Any\00"
|
|
@tn.str.57 = private constant [4 x i8] c"*u8\00"
|
|
@tn.str.58 = private constant [6 x i8] c"*bool\00"
|
|
@tn.str.59 = private constant [8 x i8] c"*[4]s64\00"
|
|
@tn.str.60 = private constant [5 x i8] c"*f64\00"
|
|
@tn.str.61 = private constant [17 x i8] c"*Source_Location\00"
|
|
@tn.str.62 = private constant [11 x i8] c"*Allocator\00"
|
|
@tn.str.63 = private constant [9 x i8] c"*Context\00"
|
|
@tn.str.64 = private constant [5 x i8] c"*u32\00"
|
|
@tn.str.65 = private constant [10 x i8] c"*[]string\00"
|
|
@tn.str.66 = private constant [6 x i8] c"**GPA\00"
|
|
@tn.str.67 = private constant [13 x i8] c"**ArenaChunk\00"
|
|
@tn.str.68 = private constant [8 x i8] c"**Arena\00"
|
|
@tn.str.69 = private constant [7 x i8] c"*[*]u8\00"
|
|
@tn.str.70 = private constant [11 x i8] c"**BufAlloc\00"
|
|
@tn.str.71 = private constant [20 x i8] c"**TrackingAllocator\00"
|
|
@tn.str.72 = private constant [14 x i8] c"***CAllocator\00"
|
|
@tn.str.73 = private constant [6 x i8] c"**s64\00"
|
|
@tn.str.74 = private constant [8 x i8] c"***void\00"
|
|
@tn.str.75 = private constant [6 x i8] c"**s32\00"
|
|
@tn.str.76 = private constant [4 x i8] c"**E\00"
|
|
@tn.str.77 = private constant [9 x i8] c"**string\00"
|
|
@tn.str.78 = private constant [6 x i8] c"**Any\00"
|
|
@tn.str.79 = private constant [9 x i8] c"**[1]Any\00"
|
|
@tn.str.80 = private constant [8 x i8] c"**[]Any\00"
|
|
@tn.str.81 = private constant [5 x i8] c"**u8\00"
|
|
@tn.str.82 = private constant [7 x i8] c"**bool\00"
|
|
@__sx_type_names = private constant [75 x { ptr, i64 }] [{ ptr, i64 } { ptr @tn.str, i64 12 }, { ptr, i64 } { ptr @tn.str.9, i64 4 }, { ptr, i64 } { ptr @tn.str.10, i64 2 }, { ptr, i64 } { ptr @tn.str.11, i64 3 }, { ptr, i64 } { ptr @tn.str.12, i64 3 }, { ptr, i64 } { ptr @tn.str.13, i64 3 }, { ptr, i64 } { ptr @tn.str.14, i64 2 }, { ptr, i64 } { ptr @tn.str.15, i64 3 }, { ptr, i64 } { ptr @tn.str.16, i64 3 }, { ptr, i64 } { ptr @tn.str.17, i64 3 }, { ptr, i64 } { ptr @tn.str.18, i64 3 }, { ptr, i64 } { ptr @tn.str.19, i64 3 }, { ptr, i64 } { ptr @tn.str.20, i64 6 }, { ptr, i64 } { ptr @tn.str.21, i64 3 }, { ptr, i64 } { ptr @tn.str.22, i64 8 }, { ptr, i64 } { ptr @tn.str.23, i64 5 }, { ptr, i64 } { ptr @tn.str.24, i64 5 }, { ptr, i64 } { ptr @tn.str.25, i64 4 }, { ptr, i64 } { ptr @tn.str.26, i64 5 }, { ptr, i64 } { ptr @tn.str.27, i64 15 }, { ptr, i64 } { ptr @tn.str.28, i64 9 }, { ptr, i64 } { ptr @tn.str.29, i64 10 }, { ptr, i64 } { ptr @tn.str.30, i64 11 }, { ptr, i64 } { ptr @tn.str.31, i64 3 }, { ptr, i64 } { ptr @tn.str.32, i64 4 }, { ptr, i64 } { ptr @tn.str.33, i64 10 }, { ptr, i64 } { ptr @tn.str.34, i64 11 }, { ptr, i64 } { ptr @tn.str.35, i64 5 }, { ptr, i64 } { ptr @tn.str.36, i64 6 }, { ptr, i64 } { ptr @tn.str.37, i64 5 }, { ptr, i64 } { ptr @tn.str.38, i64 8 }, { ptr, i64 } { ptr @tn.str.39, i64 9 }, { ptr, i64 } { ptr @tn.str.40, i64 17 }, { ptr, i64 } { ptr @tn.str.41, i64 18 }, { ptr, i64 } { ptr @tn.str.42, i64 7 }, { ptr, i64 } { ptr @tn.str.43, i64 6 }, { ptr, i64 } { ptr @tn.str.44, i64 8 }, { ptr, i64 } { ptr @tn.str.45, i64 1 }, { ptr, i64 } { ptr @tn.str.46, i64 12 }, { ptr, i64 } { ptr @tn.str.47, i64 4 }, { ptr, i64 } { ptr @tn.str.48, i64 6 }, { ptr, i64 } { ptr @tn.str.49, i64 4 }, { ptr, i64 } { ptr @tn.str.50, i64 2 }, { ptr, i64 } { ptr @tn.str.51, i64 7 }, { ptr, i64 } { ptr @tn.str.52, i64 5 }, { ptr, i64 } { ptr @tn.str.53, i64 4 }, { ptr, i64 } { ptr @tn.str.54, i64 6 }, { ptr, i64 } { ptr @tn.str.55, i64 7 }, { ptr, i64 } { ptr @tn.str.56, i64 6 }, { ptr, i64 } { ptr @tn.str.57, i64 3 }, { ptr, i64 } { ptr @tn.str.58, i64 5 }, { ptr, i64 } { ptr @tn.str.59, i64 7 }, { ptr, i64 } { ptr @tn.str.60, i64 4 }, { ptr, i64 } { ptr @tn.str.61, i64 16 }, { ptr, i64 } { ptr @tn.str.62, i64 10 }, { ptr, i64 } { ptr @tn.str.63, i64 8 }, { ptr, i64 } { ptr @tn.str.64, i64 4 }, { ptr, i64 } { ptr @tn.str.65, i64 9 }, { ptr, i64 } { ptr @tn.str.66, i64 5 }, { ptr, i64 } { ptr @tn.str.67, i64 12 }, { ptr, i64 } { ptr @tn.str.68, i64 7 }, { ptr, i64 } { ptr @tn.str.69, i64 6 }, { ptr, i64 } { ptr @tn.str.70, i64 10 }, { ptr, i64 } { ptr @tn.str.71, i64 19 }, { ptr, i64 } { ptr @tn.str.72, i64 13 }, { ptr, i64 } { ptr @tn.str.73, i64 5 }, { ptr, i64 } { ptr @tn.str.74, i64 7 }, { ptr, i64 } { ptr @tn.str.75, i64 5 }, { ptr, i64 } { ptr @tn.str.76, i64 3 }, { ptr, i64 } { ptr @tn.str.77, i64 8 }, { ptr, i64 } { ptr @tn.str.78, i64 5 }, { ptr, i64 } { ptr @tn.str.79, i64 8 }, { ptr, i64 } { ptr @tn.str.80, i64 7 }, { ptr, i64 } { ptr @tn.str.81, i64 4 }, { ptr, i64 } { ptr @tn.str.82, i64 6 }]
|
|
@str.83 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.84 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.85 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.86 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.87 = private unnamed_addr constant [15 x i8] c"result := \22\22; \00", align 1
|
|
@str.88 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.89 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.90 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@str.91 = private unnamed_addr constant [44 x i8] c"result = concat(result, any_to_string(args[\00", align 1
|
|
@str.92 = private unnamed_addr constant [6 x i8] c"])); \00", align 1
|
|
@str.93 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.94 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.95 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@str.96 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.97 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.98 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@str.99 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.100 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.101 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@frame.str = private unnamed_addr constant [19 x i8] c"1004-errors-try.sx\00"
|
|
@frame.str.102 = private unnamed_addr constant [6 x i8] c"inner\00"
|
|
@frame.str.103 = private unnamed_addr constant [34 x i8] c" if n < 0 { raise error.Bad; }\00"
|
|
@trace.frame = private constant { { ptr, i64 }, i32, i32, { ptr, i64 }, { ptr, i64 } } { { ptr, i64 } { ptr @frame.str, i64 18 }, i32 13, i32 16, { ptr, i64 } { ptr @frame.str.102, i64 5 }, { ptr, i64 } { ptr @frame.str.103, i64 33 } }
|
|
@frame.str.104 = private unnamed_addr constant [6 x i8] c"outer\00"
|
|
@frame.str.105 = private unnamed_addr constant [18 x i8] c" try inner(n);\00"
|
|
@trace.frame.106 = private constant { { ptr, i64 }, i32, i32, { ptr, i64 }, { ptr, i64 } } { { ptr, i64 } { ptr @frame.str, i64 18 }, i32 19, i32 5, { ptr, i64 } { ptr @frame.str.104, i64 5 }, { ptr, i64 } { ptr @frame.str.105, i64 17 } }
|
|
@str.107 = private unnamed_addr constant [16 x i8] c"try result: {}\0A\00", align 1
|
|
@str.108 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.109 = private unnamed_addr constant [16 x i8] c"try result: {}\0A\00", align 1
|
|
@str.110 = private unnamed_addr constant [16 x i8] c"Source_Location\00", align 1
|
|
@str.111 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.112 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.113 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str = private constant [5 x i8] c"file\00"
|
|
@fld.str.114 = private constant [5 x i8] c"line\00"
|
|
@fld.str.115 = private constant [4 x i8] c"col\00"
|
|
@fld.str.116 = private constant [5 x i8] c"func\00"
|
|
@field_names = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str, i64 4 }, { ptr, i64 } { ptr @fld.str.114, i64 4 }, { ptr, i64 } { ptr @fld.str.115, i64 3 }, { ptr, i64 } { ptr @fld.str.116, i64 4 }]
|
|
@str.117 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.118 = private unnamed_addr constant [10 x i8] c"Allocator\00", align 1
|
|
@str.119 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.120 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.121 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.122 = private constant [4 x i8] c"ctx\00"
|
|
@fld.str.123 = private constant [6 x i8] c"alloc\00"
|
|
@fld.str.124 = private constant [8 x i8] c"dealloc\00"
|
|
@field_names.125 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.122, i64 3 }, { ptr, i64 } { ptr @fld.str.123, i64 5 }, { ptr, i64 } { ptr @fld.str.124, i64 7 }]
|
|
@str.126 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.127 = private unnamed_addr constant [11 x i8] c"CAllocator\00", align 1
|
|
@str.128 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.129 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.130 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@field_names.131 = private constant [0 x { ptr, i64 }] zeroinitializer
|
|
@str.132 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.133 = private unnamed_addr constant [4 x i8] c"GPA\00", align 1
|
|
@str.134 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.135 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.136 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.137 = private constant [12 x i8] c"alloc_count\00"
|
|
@field_names.138 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.137, i64 11 }]
|
|
@str.139 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.140 = private unnamed_addr constant [11 x i8] c"ArenaChunk\00", align 1
|
|
@str.141 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.142 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.143 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.144 = private constant [5 x i8] c"next\00"
|
|
@fld.str.145 = private constant [4 x i8] c"cap\00"
|
|
@field_names.146 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.144, i64 4 }, { ptr, i64 } { ptr @fld.str.145, i64 3 }]
|
|
@str.147 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.148 = private unnamed_addr constant [6 x i8] c"Arena\00", align 1
|
|
@str.149 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.150 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.151 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.152 = private constant [6 x i8] c"first\00"
|
|
@fld.str.153 = private constant [10 x i8] c"end_index\00"
|
|
@fld.str.154 = private constant [7 x i8] c"parent\00"
|
|
@field_names.155 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.152, i64 5 }, { ptr, i64 } { ptr @fld.str.153, i64 9 }, { ptr, i64 } { ptr @fld.str.154, i64 6 }]
|
|
@str.156 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.157 = private unnamed_addr constant [9 x i8] c"BufAlloc\00", align 1
|
|
@str.158 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.159 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.160 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.161 = private constant [4 x i8] c"buf\00"
|
|
@fld.str.162 = private constant [4 x i8] c"len\00"
|
|
@fld.str.163 = private constant [4 x i8] c"pos\00"
|
|
@field_names.164 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.161, i64 3 }, { ptr, i64 } { ptr @fld.str.162, i64 3 }, { ptr, i64 } { ptr @fld.str.163, i64 3 }]
|
|
@str.165 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.166 = private unnamed_addr constant [18 x i8] c"TrackingAllocator\00", align 1
|
|
@str.167 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.168 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.169 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.170 = private constant [7 x i8] c"parent\00"
|
|
@fld.str.171 = private constant [12 x i8] c"alloc_count\00"
|
|
@fld.str.172 = private constant [14 x i8] c"dealloc_count\00"
|
|
@fld.str.173 = private constant [18 x i8] c"total_alloc_bytes\00"
|
|
@field_names.174 = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.170, i64 6 }, { ptr, i64 } { ptr @fld.str.171, i64 11 }, { ptr, i64 } { ptr @fld.str.172, i64 13 }, { ptr, i64 } { ptr @fld.str.173, i64 17 }]
|
|
@str.175 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.176 = private unnamed_addr constant [8 x i8] c"Context\00", align 1
|
|
@str.177 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.178 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.179 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.180 = private constant [10 x i8] c"allocator\00"
|
|
@fld.str.181 = private constant [5 x i8] c"data\00"
|
|
@field_names.182 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.180, i64 9 }, { ptr, i64 } { ptr @fld.str.181, i64 4 }]
|
|
@str.183 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.184 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.185 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.186 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.187 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.188 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.189 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.190 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.191 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.192 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.193 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.194 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.195 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.196 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.197 = private unnamed_addr constant [6 x i8] c"*void\00", align 1
|
|
@str.198 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.199 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.200 = private unnamed_addr constant [12 x i8] c"*CAllocator\00", align 1
|
|
@str.201 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.202 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.203 = private unnamed_addr constant [5 x i8] c"*GPA\00", align 1
|
|
@str.204 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.205 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.206 = private unnamed_addr constant [12 x i8] c"*ArenaChunk\00", align 1
|
|
@str.207 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.208 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.209 = private unnamed_addr constant [7 x i8] c"*Arena\00", align 1
|
|
@str.210 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.211 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.212 = private unnamed_addr constant [6 x i8] c"[*]u8\00", align 1
|
|
@str.213 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.214 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.215 = private unnamed_addr constant [10 x i8] c"*BufAlloc\00", align 1
|
|
@str.216 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.217 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.218 = private unnamed_addr constant [19 x i8] c"*TrackingAllocator\00", align 1
|
|
@str.219 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.220 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.221 = private unnamed_addr constant [13 x i8] c"**CAllocator\00", align 1
|
|
@str.222 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.223 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.224 = private unnamed_addr constant [5 x i8] c"*s64\00", align 1
|
|
@str.225 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.226 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.227 = private unnamed_addr constant [7 x i8] c"**void\00", align 1
|
|
@str.228 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.229 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.230 = private unnamed_addr constant [5 x i8] c"*s32\00", align 1
|
|
@str.231 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.232 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.233 = private unnamed_addr constant [11 x i8] c"*error_set\00", align 1
|
|
@str.234 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.235 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.236 = private unnamed_addr constant [8 x i8] c"*string\00", align 1
|
|
@str.237 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.238 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.239 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1
|
|
@str.240 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.241 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.242 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1
|
|
@str.243 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.244 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.245 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1
|
|
@str.246 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.247 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.248 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1
|
|
@str.249 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.250 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.251 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1
|
|
@str.252 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @out(ptr) #0
|
|
|
|
declare ptr @malloc(i64)
|
|
|
|
declare void @free(ptr)
|
|
|
|
declare ptr @memcpy(ptr, ptr, i64)
|
|
|
|
declare ptr @memset(ptr, i32, i64)
|
|
|
|
; Function Attrs: nounwind
|
|
define internal ptr @CAllocator.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 i64, ptr %allocaN, align 8
|
|
%call = call ptr @malloc(i64 %load)
|
|
ret ptr %call
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal void @CAllocator.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 %allocaN, align 8
|
|
call void @free(ptr %load)
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
declare i64 @GPA.init(ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare ptr @GPA.alloc(ptr, ptr, i64) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @GPA.dealloc(ptr, ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @Arena.add_chunk(ptr, ptr, i64) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @Arena.init(ptr sret({ ptr, i64, { ptr, ptr, ptr } }), ptr, ptr, i64) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @Arena.reset(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @Arena.deinit(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare ptr @Arena.alloc(ptr, ptr, i64) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @Arena.dealloc(ptr, ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare ptr @BufAlloc.init(ptr, ptr, i64) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @BufAlloc.reset(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare ptr @BufAlloc.alloc(ptr, ptr, i64) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @BufAlloc.dealloc(ptr, ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @TrackingAllocator.init(ptr sret({ { ptr, ptr, ptr }, i64, i64, i64 }), ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare i64 @TrackingAllocator.leak_count(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @TrackingAllocator.report(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare ptr @TrackingAllocator.alloc(ptr, ptr, i64) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare void @TrackingAllocator.dealloc(ptr, ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @cstring(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i64, align 8
|
|
store i64 %1, ptr %alloca, align 8
|
|
%load = load i64, ptr %alloca, align 8
|
|
%add = add i64 %load, 1
|
|
%loadN = load { { ptr, ptr, ptr }, ptr }, ptr %0, align 8
|
|
%sg = extractvalue { { ptr, ptr, ptr }, ptr } %loadN, 0
|
|
%sgN = extractvalue { ptr, ptr, ptr } %sg, 0
|
|
%sgN = extractvalue { ptr, ptr, ptr } %sg, 1
|
|
%icall = call ptr %sgN(ptr %0, ptr %sgN, i64 %add)
|
|
%allocaN = alloca ptr, align 8
|
|
store ptr %icall, ptr %allocaN, align 8
|
|
%loadN = load ptr, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %alloca, align 8
|
|
%addN = add i64 %loadN, 1
|
|
%2 = call ptr @memset(ptr %loadN, i32 0, i64 %addN)
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } undef, ptr %allocaN, align 8
|
|
%loadN = load ptr, ptr %allocaN, align 8
|
|
%gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
|
|
%pti = ptrtoint ptr %loadN to i64
|
|
store i64 %pti, ptr %gep, align 8
|
|
%loadN = load i64, ptr %alloca, align 8
|
|
%gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
|
|
store i64 %loadN, ptr %gepN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @int_to_string(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i64, align 8
|
|
%allocaN = alloca i1, align 1
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
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.24, label %if.merge.25
|
|
|
|
if.then.24: ; preds = %entry
|
|
ret { ptr, i64 } { ptr @str, i64 1 }
|
|
|
|
if.merge.25: ; preds = %entry
|
|
%loadN = load i64, ptr %alloca, align 8
|
|
%icmpN = icmp slt i64 %loadN, 0
|
|
store i1 %icmpN, ptr %allocaN, align 1
|
|
%call = call { ptr, i64 } @cstring(ptr %0, i64 20)
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
store i64 19, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %alloca, align 8
|
|
store i64 %loadN, ptr %allocaN, align 8
|
|
br label %while.hdr.26
|
|
|
|
while.hdr.26: ; preds = %if.merge.30, %if.merge.25
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp ne i64 %loadN, 0
|
|
br i1 %icmpN, label %while.body.27, label %while.exit.28
|
|
|
|
while.body.27: ; preds = %while.hdr.26
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%srem = srem i64 %loadN, 10
|
|
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.29, label %if.merge.30
|
|
|
|
while.exit.28: ; preds = %while.hdr.26
|
|
%loadN = load i1, ptr %allocaN, align 1
|
|
br i1 %loadN, label %if.then.31, label %if.merge.32
|
|
|
|
if.then.29: ; preds = %while.body.27
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 0, %loadN
|
|
store i64 %sub, ptr %allocaN, align 8
|
|
br label %if.merge.30
|
|
|
|
if.merge.30: ; preds = %if.then.29, %while.body.27
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 48
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
|
|
%trunc = trunc i64 %add to i8
|
|
store i8 %trunc, ptr %igp.ptr, align 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sdiv = sdiv i64 %loadN, 10
|
|
store i64 %sdiv, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, 1
|
|
store i64 %subN, ptr %allocaN, align 8
|
|
br label %while.hdr.26
|
|
|
|
if.then.31: ; preds = %while.exit.28
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data24 = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr25 = getelementptr i8, ptr %igp.data24, i64 %loadN
|
|
store i8 45, ptr %igp.ptr25, align 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, 1
|
|
store i64 %subN, ptr %allocaN, align 8
|
|
br label %if.merge.32
|
|
|
|
if.merge.32: ; preds = %if.then.31, %while.exit.28
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 19, %loadN
|
|
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 %addN, i64 %subN)
|
|
ret { ptr, i64 } %callN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @uint_to_string(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i64, align 8
|
|
%allocaN = alloca [4 x i64], align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%ig.tmp = alloca [4 x i64], align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%ig.tmp15 = alloca [4 x i64], align 8
|
|
%ig.tmp20 = alloca [4 x i64], align 8
|
|
%ig.tmp26 = alloca [4 x i64], align 8
|
|
%ig.tmp36 = alloca [4 x i64], align 8
|
|
%allocaN = alloca i64, align 8
|
|
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.66, label %if.merge.67
|
|
|
|
if.then.66: ; preds = %entry
|
|
ret { ptr, i64 } { ptr @str.1, i64 1 }
|
|
|
|
if.merge.67: ; preds = %entry
|
|
%loadN = load i64, ptr %alloca, align 8
|
|
%call = call [4 x i64] @decompose_u16x4(ptr %0, i64 %loadN)
|
|
store [4 x i64] %call, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @cstring(ptr %0, i64 20)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
store i64 19, ptr %allocaN, align 8
|
|
br label %while.hdr.76
|
|
|
|
while.hdr.76: ; preds = %while.exit.87, %if.merge.67
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp, align 8
|
|
%ig.ptr = getelementptr [4 x i64], ptr %ig.tmp, i64 0, i64 0
|
|
%ig.val = load i64, ptr %ig.ptr, align 8
|
|
%icmpN = icmp ne i64 %ig.val, 0
|
|
br i1 %icmpN, label %or.merge.80, label %or.rhs.79
|
|
|
|
while.body.77: ; preds = %or.merge.84
|
|
store i64 0, ptr %allocaN, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.85
|
|
|
|
while.exit.78: ; preds = %or.merge.84
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 19, %loadN
|
|
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 %add, i64 %sub)
|
|
ret { ptr, i64 } %callN
|
|
|
|
or.rhs.79: ; preds = %while.hdr.76
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp15, align 8
|
|
%ig.ptr16 = getelementptr [4 x i64], ptr %ig.tmp15, i64 0, i64 1
|
|
%ig.val17 = load i64, ptr %ig.ptr16, align 8
|
|
%icmpN = icmp ne i64 %ig.val17, 0
|
|
br label %or.merge.80
|
|
|
|
or.merge.80: ; preds = %or.rhs.79, %while.hdr.76
|
|
%bp = phi i1 [ true, %while.hdr.76 ], [ %icmpN, %or.rhs.79 ]
|
|
br i1 %bp, label %or.merge.82, label %or.rhs.81
|
|
|
|
or.rhs.81: ; preds = %or.merge.80
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp20, align 8
|
|
%ig.ptr21 = getelementptr [4 x i64], ptr %ig.tmp20, i64 0, i64 2
|
|
%ig.val22 = load i64, ptr %ig.ptr21, align 8
|
|
%icmpN = icmp ne i64 %ig.val22, 0
|
|
br label %or.merge.82
|
|
|
|
or.merge.82: ; preds = %or.rhs.81, %or.merge.80
|
|
%bpN = phi i1 [ true, %or.merge.80 ], [ %icmpN, %or.rhs.81 ]
|
|
br i1 %bpN, label %or.merge.84, label %or.rhs.83
|
|
|
|
or.rhs.83: ; preds = %or.merge.82
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp26, align 8
|
|
%ig.ptr27 = getelementptr [4 x i64], ptr %ig.tmp26, i64 0, i64 3
|
|
%ig.val28 = load i64, ptr %ig.ptr27, align 8
|
|
%icmpN = icmp ne i64 %ig.val28, 0
|
|
br label %or.merge.84
|
|
|
|
or.merge.84: ; preds = %or.rhs.83, %or.merge.82
|
|
%bpN = phi i1 [ true, %or.merge.82 ], [ %icmpN, %or.rhs.83 ]
|
|
br i1 %bpN, label %while.body.77, label %while.exit.78
|
|
|
|
while.hdr.85: ; preds = %while.body.86, %while.body.77
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp slt i64 %loadN, 4
|
|
br i1 %icmpN, label %while.body.86, label %while.exit.87
|
|
|
|
while.body.86: ; preds = %while.hdr.85
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%mul = mul i64 %loadN, 65536
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp36, align 8
|
|
%ig.ptr37 = getelementptr [4 x i64], ptr %ig.tmp36, i64 0, i64 %loadN
|
|
%ig.val38 = load i64, ptr %ig.ptr37, align 8
|
|
%addN = add i64 %mul, %ig.val38
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sdiv = sdiv i64 %loadN, 10
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%igp.ptr = getelementptr i64, ptr %allocaN, i64 %loadN
|
|
store i64 %sdiv, ptr %igp.ptr, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%srem = srem i64 %loadN, 10
|
|
store i64 %srem, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %while.hdr.85
|
|
|
|
while.exit.87: ; preds = %while.hdr.85
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 48
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr50 = getelementptr i8, ptr %igp.data, i64 %loadN
|
|
%trunc = trunc i64 %addN to i8
|
|
store i8 %trunc, ptr %igp.ptr50, align 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, 1
|
|
store i64 %subN, ptr %allocaN, align 8
|
|
br label %while.hdr.76
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @bool_to_string(ptr %0, i1 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i1, align 1
|
|
store i1 %1, ptr %alloca, align 1
|
|
%load = load i1, ptr %alloca, align 1
|
|
br i1 %load, label %if.then.88, label %if.else.89
|
|
|
|
if.then.88: ; preds = %entry
|
|
br label %if.merge.90
|
|
|
|
if.else.89: ; preds = %entry
|
|
br label %if.merge.90
|
|
|
|
if.merge.90: ; preds = %if.else.89, %if.then.88
|
|
%bp = phi { ptr, i64 } [ { ptr @str.2, i64 4 }, %if.then.88 ], [ { ptr @str.3, i64 5 }, %if.else.89 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @float_to_string(ptr %0, double %1) #0 {
|
|
entry:
|
|
%alloca = alloca double, align 8
|
|
%allocaN = alloca double, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store double %1, ptr %alloca, align 8
|
|
%load = load double, ptr %alloca, align 8
|
|
%fcmp = fcmp olt double %load, 0.000000e+00
|
|
%allocaN = alloca i1, align 1
|
|
store i1 %fcmp, ptr %allocaN, align 1
|
|
%loadN = load i1, ptr %allocaN, align 1
|
|
br i1 %loadN, label %if.then.94, label %if.else.95
|
|
|
|
if.then.94: ; preds = %entry
|
|
%loadN = load double, ptr %alloca, align 8
|
|
%fsub = fsub double 0.000000e+00, %loadN
|
|
br label %if.merge.96
|
|
|
|
if.else.95: ; preds = %entry
|
|
%loadN = load double, ptr %alloca, align 8
|
|
br label %if.merge.96
|
|
|
|
if.merge.96: ; preds = %if.else.95, %if.then.94
|
|
%bp = phi double [ %fsub, %if.then.94 ], [ %loadN, %if.else.95 ]
|
|
store double %bp, ptr %allocaN, align 8
|
|
%loadN = load double, ptr %allocaN, align 8
|
|
%fptosi = fptosi double %loadN to i64
|
|
store i64 %fptosi, ptr %allocaN, align 8
|
|
%loadN = load double, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sitofp = sitofp i64 %loadN to double
|
|
%fsubN = fsub double %loadN, %sitofp
|
|
%fmul = fmul double %fsubN, 1.000000e+06
|
|
%fptosiN = fptosi double %fmul to i64
|
|
store i64 %fptosiN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %loadN, 0
|
|
br i1 %icmp, label %if.then.97, label %if.merge.98
|
|
|
|
if.then.97: ; preds = %if.merge.96
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 0, %loadN
|
|
store i64 %sub, ptr %allocaN, align 8
|
|
br label %if.merge.98
|
|
|
|
if.merge.98: ; preds = %if.then.97, %if.merge.96
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%len = extractvalue { ptr, i64 } %loadN, 1
|
|
store i64 %len, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%lenN = extractvalue { ptr, i64 } %loadN, 1
|
|
store i64 %lenN, ptr %allocaN, align 8
|
|
%loadN = load i1, ptr %allocaN, align 1
|
|
br i1 %loadN, label %if.then.99, label %if.else.100
|
|
|
|
if.then.99: ; preds = %if.merge.98
|
|
br label %if.merge.101
|
|
|
|
if.else.100: ; preds = %if.merge.98
|
|
br label %if.merge.101
|
|
|
|
if.merge.101: ; preds = %if.else.100, %if.then.99
|
|
%bpN = phi i64 [ 1, %if.then.99 ], [ 0, %if.else.100 ]
|
|
store i64 %bpN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, %loadN
|
|
%addN = add i64 %add, 1
|
|
%addN = add i64 %addN, 6
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @cstring(ptr %0, i64 %loadN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
%loadN = load i1, ptr %allocaN, align 1
|
|
br i1 %loadN, label %if.then.102, label %if.merge.103
|
|
|
|
if.then.102: ; preds = %if.merge.101
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr = getelementptr i8, ptr %igp.data, i64 0
|
|
store i8 45, ptr %igp.ptr, align 1
|
|
store i64 1, ptr %allocaN, align 8
|
|
br label %if.merge.103
|
|
|
|
if.merge.103: ; preds = %if.then.102, %if.merge.101
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data41 = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr42 = getelementptr i8, ptr %igp.data41, i64 %loadN
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%dptr = extractvalue { ptr, i64 } %loadN, 0
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call ptr @memcpy(ptr %igp.ptr42, ptr %dptr, i64 %loadN)
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, %loadN
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data51 = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr52 = getelementptr i8, ptr %igp.data51, i64 %loadN
|
|
store i8 46, ptr %igp.ptr52, align 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 6, %loadN
|
|
store i64 %subN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data60 = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr61 = getelementptr i8, ptr %igp.data60, i64 %loadN
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%2 = call ptr @memset(ptr %igp.ptr61, i32 48, i64 %loadN)
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, %loadN
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data68 = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr69 = getelementptr i8, ptr %igp.data68, i64 %loadN
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%dptrN = extractvalue { ptr, i64 } %loadN, 0
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call ptr @memcpy(ptr %igp.ptr69, ptr %dptrN, i64 %loadN)
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal void @hex_group(ptr %0, { ptr, i64 } %1, i64 %2, i64 %3) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %2, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %3, ptr %allocaN, align 8
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %load, 3
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %add, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %loadN, ptr %allocaN, align 8
|
|
br label %while.hdr.214
|
|
|
|
while.hdr.214: ; preds = %if.merge.219, %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.215, label %while.exit.216
|
|
|
|
while.body.215: ; preds = %while.hdr.214
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%srem = srem i64 %loadN, 16
|
|
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.217, label %if.else.218
|
|
|
|
while.exit.216: ; preds = %while.hdr.214
|
|
ret void
|
|
|
|
if.then.217: ; preds = %while.body.215
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 48
|
|
br label %if.merge.219
|
|
|
|
if.else.218: ; preds = %while.body.215
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 %loadN, 10
|
|
%addN = add i64 %sub, 97
|
|
br label %if.merge.219
|
|
|
|
if.merge.219: ; preds = %if.else.218, %if.then.217
|
|
%bp = phi i64 [ %addN, %if.then.217 ], [ %addN, %if.else.218 ]
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%igp.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
|
|
%trunc = trunc i64 %bp to i8
|
|
store i8 %trunc, ptr %igp.ptr, align 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sdiv = sdiv i64 %loadN, 16
|
|
store i64 %sdiv, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, 1
|
|
store i64 %subN, ptr %allocaN, align 8
|
|
br label %while.hdr.214
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal [4 x i64] @decompose_u16x4(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca i64, align 8
|
|
%allocaN = alloca [4 x i64], align 8
|
|
store i64 %1, ptr %alloca, align 8
|
|
%load = load i64, ptr %alloca, align 8
|
|
%srem = srem i64 %load, 65536
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %srem, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %loadN, 0
|
|
br i1 %icmp, label %if.then.68, label %if.merge.69
|
|
|
|
if.then.68: ; preds = %entry
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 65536
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %if.merge.69
|
|
|
|
if.merge.69: ; preds = %if.then.68, %entry
|
|
%loadN = load i64, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 %loadN, %loadN
|
|
%sdiv = sdiv i64 %sub, 65536
|
|
store i64 %sdiv, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sremN = srem i64 %loadN, 65536
|
|
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.70, label %if.merge.71
|
|
|
|
if.then.70: ; preds = %if.merge.69
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 65536
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.71
|
|
|
|
if.merge.71: ; preds = %if.then.70, %if.merge.69
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, %loadN
|
|
%sdivN = sdiv i64 %subN, 65536
|
|
store i64 %sdivN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sremN = srem i64 %loadN, 65536
|
|
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.72, label %if.merge.73
|
|
|
|
if.then.72: ; preds = %if.merge.71
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 65536
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.73
|
|
|
|
if.merge.73: ; preds = %if.then.72, %if.merge.71
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, %loadN
|
|
%sdivN = sdiv i64 %subN, 65536
|
|
store i64 %sdivN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sremN = srem i64 %loadN, 65536
|
|
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.74, label %if.merge.75
|
|
|
|
if.then.74: ; preds = %if.merge.73
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 65536
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.75
|
|
|
|
if.merge.75: ; preds = %if.then.74, %if.merge.73
|
|
store [4 x i64] undef, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%igp.ptr = getelementptr i64, ptr %allocaN, i64 0
|
|
store i64 %loadN, ptr %igp.ptr, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%igp.ptr41 = getelementptr i64, ptr %allocaN, i64 1
|
|
store i64 %loadN, ptr %igp.ptr41, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%igp.ptr43 = getelementptr i64, ptr %allocaN, i64 2
|
|
store i64 %loadN, ptr %igp.ptr43, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%igp.ptr45 = getelementptr i64, ptr %allocaN, i64 3
|
|
store i64 %loadN, ptr %igp.ptr45, align 8
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
ret [4 x i64] %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @int_to_hex_string(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i64, align 8
|
|
%allocaN = alloca [4 x i64], align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%ig.tmp = alloca [4 x i64], align 8
|
|
%ig.tmp9 = alloca [4 x i64], align 8
|
|
%ig.tmp14 = alloca [4 x i64], align 8
|
|
%ig.tmp19 = alloca [4 x i64], align 8
|
|
%allocaN = alloca i64, align 8
|
|
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.212, label %if.merge.213
|
|
|
|
if.then.212: ; preds = %entry
|
|
ret { ptr, i64 } { ptr @str.4, i64 1 }
|
|
|
|
if.merge.213: ; preds = %entry
|
|
%loadN = load i64, ptr %alloca, align 8
|
|
%call = call [4 x i64] @decompose_u16x4(ptr %0, i64 %loadN)
|
|
store [4 x i64] %call, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @cstring(ptr %0, i64 16)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp, align 8
|
|
%ig.ptr = getelementptr [4 x i64], ptr %ig.tmp, i64 0, i64 0
|
|
%ig.val = load i64, ptr %ig.ptr, align 8
|
|
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 0, i64 %ig.val)
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp9, align 8
|
|
%ig.ptr10 = getelementptr [4 x i64], ptr %ig.tmp9, i64 0, i64 1
|
|
%ig.val11 = load i64, ptr %ig.ptr10, align 8
|
|
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 4, i64 %ig.val11)
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp14, align 8
|
|
%ig.ptr15 = getelementptr [4 x i64], ptr %ig.tmp14, i64 0, i64 2
|
|
%ig.val16 = load i64, ptr %ig.ptr15, align 8
|
|
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 8, i64 %ig.val16)
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load [4 x i64], ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp19, align 8
|
|
%ig.ptr20 = getelementptr [4 x i64], ptr %ig.tmp19, i64 0, i64 3
|
|
%ig.val21 = load i64, ptr %ig.ptr20, align 8
|
|
call void @hex_group(ptr %0, { ptr, i64 } %loadN, i64 12, i64 %ig.val21)
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.220
|
|
|
|
while.hdr.220: ; preds = %if.merge.224, %if.merge.213
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp slt i64 %loadN, 15
|
|
br i1 %icmpN, label %while.body.221, label %while.exit.222
|
|
|
|
while.body.221: ; preds = %while.hdr.220
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%ig.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr27 = getelementptr i8, ptr %ig.data, i64 %loadN
|
|
%ig.val28 = load i8, ptr %ig.ptr27, align 1
|
|
%cmp.ext = zext i8 %ig.val28 to i64
|
|
%icmpN = icmp ne i64 %cmp.ext, 48
|
|
br i1 %icmpN, label %if.then.223, label %if.merge.224
|
|
|
|
while.exit.222: ; preds = %if.then.223, %while.hdr.220
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 16, %loadN
|
|
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 %loadN, i64 %sub)
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.223: ; preds = %while.body.221
|
|
br label %while.exit.222
|
|
|
|
if.merge.224: ; preds = %while.body.221
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.220
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @concat(ptr %0, { ptr, i64 } %1, { ptr, i64 } %2) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %2, ptr %allocaN, align 8
|
|
%load = load { ptr, i64 }, ptr %alloca, align 8
|
|
%len = extractvalue { ptr, i64 } %load, 1
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %len, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%lenN = extractvalue { ptr, i64 } %loadN, 1
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %lenN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, %loadN
|
|
%call = call { ptr, i64 } @cstring(ptr %0, i64 %add)
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%dptr = extractvalue { ptr, i64 } %loadN, 0
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%dptrN = extractvalue { ptr, i64 } %loadN, 0
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call ptr @memcpy(ptr %dptr, ptr %dptrN, i64 %loadN)
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%igp.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%dptrN = extractvalue { ptr, i64 } %loadN, 0
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call ptr @memcpy(ptr %igp.ptr, ptr %dptrN, i64 %loadN)
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @substr(ptr %0, { ptr, i64 } %1, i64 %2, i64 %3) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %2, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %3, ptr %allocaN, align 8
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @cstring(ptr %0, i64 %load)
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%dptr = extractvalue { ptr, i64 } %loadN, 0
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%igp.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%igp.ptr = getelementptr i8, ptr %igp.data, i64 %loadN
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call ptr @memcpy(ptr %dptr, ptr %igp.ptr, i64 %loadN)
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
declare ptr @xml_escape(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
declare ptr @path_join(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { i64, i64 }, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca double, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca i32, align 4
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { i64, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.5, i64 3 }, ptr %allocaN, align 8
|
|
%load = load { i64, i64 }, ptr %alloca, align 8
|
|
%sg = extractvalue { i64, i64 } %load, 0
|
|
%ba.val = insertvalue { i64, i64 } { i64 13, i64 undef }, i64 %sg, 1
|
|
%allocaN = alloca { i64, i64 }, align 8
|
|
store { i64, i64 } %ba.val, ptr %allocaN, align 8
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%ua.raw = extractvalue { i64, i64 } %loadN, 1
|
|
switch i64 %ua.raw, label %match.unr.62 [
|
|
i64 17, label %match.arm.48
|
|
i64 2, label %match.arm.49
|
|
i64 3, label %match.arm.49
|
|
i64 4, label %match.arm.49
|
|
i64 5, label %match.arm.49
|
|
i64 6, label %match.arm.49
|
|
i64 7, label %match.arm.49
|
|
i64 8, label %match.arm.49
|
|
i64 9, label %match.arm.49
|
|
i64 16, label %match.arm.49
|
|
i64 15, label %match.arm.49
|
|
i64 12, label %match.arm.50
|
|
i64 1, label %match.arm.51
|
|
i64 10, label %match.arm.52
|
|
i64 11, label %match.arm.52
|
|
i64 19, label %match.arm.53
|
|
i64 20, label %match.arm.53
|
|
i64 21, label %match.arm.53
|
|
i64 23, label %match.arm.53
|
|
i64 25, label %match.arm.53
|
|
i64 27, label %match.arm.53
|
|
i64 30, label %match.arm.53
|
|
i64 32, label %match.arm.53
|
|
i64 34, label %match.arm.53
|
|
i64 37, label %match.arm.55
|
|
i64 35, label %match.arm.57
|
|
i64 46, label %match.arm.57
|
|
i64 36, label %match.arm.58
|
|
i64 44, label %match.arm.58
|
|
i64 18, label %match.arm.59
|
|
i64 22, label %match.arm.59
|
|
i64 24, label %match.arm.59
|
|
i64 26, label %match.arm.59
|
|
i64 28, label %match.arm.59
|
|
i64 29, label %match.arm.59
|
|
i64 31, label %match.arm.59
|
|
i64 33, label %match.arm.59
|
|
i64 38, label %match.arm.59
|
|
i64 39, label %match.arm.59
|
|
i64 40, label %match.arm.59
|
|
i64 41, label %match.arm.59
|
|
i64 42, label %match.arm.59
|
|
i64 43, label %match.arm.59
|
|
i64 45, label %match.arm.59
|
|
i64 47, label %match.arm.59
|
|
i64 48, label %match.arm.59
|
|
i64 49, label %match.arm.59
|
|
i64 50, label %match.arm.59
|
|
i64 13, label %match.arm.61
|
|
]
|
|
|
|
match.merge.47: ; preds = %dispatch.merge.188, %dispatch.merge.174, %dispatch.merge.160, %dispatch.merge.104, %float.merge.93, %if.merge.65, %match.unr.62, %match.arm.61, %match.arm.55, %match.arm.51, %match.arm.50, %match.arm.48
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
|
|
match.arm.48: ; preds = %entry
|
|
store { ptr, i64 } { ptr @str.6, i64 0 }, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
match.arm.49: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%refl.tag = extractvalue { i64, i64 } %loadN, 0
|
|
%refl.val = extractvalue { i64, i64 } %loadN, 1
|
|
%refl.istype = icmp eq i64 %refl.tag, 13
|
|
%refl.tid = select i1 %refl.istype, i64 %refl.val, i64 %refl.tag
|
|
%tiu.gep = getelementptr inbounds [75 x i1], ptr @__sx_type_is_unsigned, i64 0, i64 %refl.tid
|
|
%tiu.load = load i1, ptr %tiu.gep, align 1
|
|
br i1 %tiu.load, label %if.then.63, label %if.else.64
|
|
|
|
match.arm.50: ; preds = %entry
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%ua.raw8 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr = inttoptr i64 %ua.raw8 to ptr
|
|
%ua.load = load { ptr, i64 }, ptr %ua.ptr, align 8
|
|
store { ptr, i64 } %ua.load, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
match.arm.51: ; preds = %entry
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%ua.raw11 = extractvalue { i64, i64 } %loadN, 1
|
|
%tr = trunc i64 %ua.raw11 to i1
|
|
%call = call { ptr, i64 } @bool_to_string(ptr %0, i1 %tr)
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
match.arm.52: ; preds = %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%sgN = extractvalue { i64, i64 } %loadN, 0
|
|
%icmp = icmp eq i64 %sgN, 10
|
|
br i1 %icmp, label %fN.unbox.91, label %fN.unbox.92
|
|
|
|
match.arm.53: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%ua.raw16 = extractvalue { i64, i64 } %loadN, 1
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
switch i64 %ua.raw16, label %dispatch.default.105 [
|
|
i64 19, label %dispatch.case.106
|
|
i64 20, label %dispatch.case.107
|
|
i64 21, label %dispatch.case.108
|
|
i64 23, label %dispatch.case.109
|
|
i64 25, label %dispatch.case.110
|
|
i64 27, label %dispatch.case.111
|
|
i64 30, label %dispatch.case.112
|
|
i64 32, label %dispatch.case.113
|
|
i64 34, label %dispatch.case.114
|
|
]
|
|
|
|
match.arm.54: ; No predecessors!
|
|
unreachable
|
|
|
|
match.arm.55: ; preds = %entry
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%ua.raw21 = extractvalue { i64, i64 } %loadN, 1
|
|
%trN = trunc i64 %ua.raw21 to i32
|
|
store i32 %trN, ptr %allocaN, align 4
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
%etn.idx = zext i32 %loadN to i64
|
|
%etn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @tag_names, i64 0, i64 %etn.idx
|
|
%etn.load = load { ptr, i64 }, ptr %etn.gep, align 8
|
|
store { ptr, i64 } %etn.load, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
match.arm.56: ; No predecessors!
|
|
unreachable
|
|
|
|
match.arm.57: ; preds = %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%ua.raw25 = extractvalue { i64, i64 } %loadN, 1
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
switch i64 %ua.raw25, label %dispatch.default.161 [
|
|
i64 35, label %dispatch.case.162
|
|
i64 46, label %dispatch.case.163
|
|
]
|
|
|
|
match.arm.58: ; preds = %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%ua.raw29 = extractvalue { i64, i64 } %loadN, 1
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
switch i64 %ua.raw29, label %dispatch.default.175 [
|
|
i64 36, label %dispatch.case.176
|
|
i64 44, label %dispatch.case.177
|
|
]
|
|
|
|
match.arm.59: ; preds = %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%ua.raw33 = extractvalue { i64, i64 } %loadN, 1
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
switch i64 %ua.raw33, label %dispatch.default.189 [
|
|
i64 18, label %dispatch.case.190
|
|
i64 22, label %dispatch.case.191
|
|
i64 24, label %dispatch.case.192
|
|
i64 26, label %dispatch.case.193
|
|
i64 28, label %dispatch.case.194
|
|
i64 29, label %dispatch.case.195
|
|
i64 31, label %dispatch.case.196
|
|
i64 33, label %dispatch.case.197
|
|
i64 38, label %dispatch.case.198
|
|
i64 39, label %dispatch.case.199
|
|
i64 40, label %dispatch.case.200
|
|
i64 41, label %dispatch.case.201
|
|
i64 42, label %dispatch.case.202
|
|
i64 43, label %dispatch.case.203
|
|
i64 45, label %dispatch.case.204
|
|
i64 47, label %dispatch.case.205
|
|
i64 48, label %dispatch.case.206
|
|
i64 49, label %dispatch.case.207
|
|
i64 50, label %dispatch.case.208
|
|
]
|
|
|
|
match.arm.60: ; No predecessors!
|
|
unreachable
|
|
|
|
match.arm.61: ; preds = %entry
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%refl.tag37 = extractvalue { i64, i64 } %loadN, 0
|
|
%refl.val38 = extractvalue { i64, i64 } %loadN, 1
|
|
%refl.istype39 = icmp eq i64 %refl.tag37, 13
|
|
%refl.tid40 = select i1 %refl.istype39, i64 %refl.val38, i64 %refl.tag37
|
|
%tn.gep = getelementptr inbounds [75 x { ptr, i64 }], ptr @__sx_type_names, i64 0, i64 %refl.tid40
|
|
%tn.load = load { ptr, i64 }, ptr %tn.gep, align 8
|
|
store { ptr, i64 } %tn.load, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
match.unr.62: ; preds = %entry
|
|
br label %match.merge.47
|
|
|
|
if.then.63: ; preds = %match.arm.49
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%ua.raw42 = extractvalue { i64, i64 } %loadN, 1
|
|
%callN = call { ptr, i64 } @uint_to_string(ptr %0, i64 %ua.raw42)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.65
|
|
|
|
if.else.64: ; preds = %match.arm.49
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%ua.raw45 = extractvalue { i64, i64 } %loadN, 1
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %ua.raw45)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.65
|
|
|
|
if.merge.65: ; preds = %if.else.64, %if.then.63
|
|
br label %match.merge.47
|
|
|
|
f32.unbox.91: ; preds = %match.arm.52
|
|
%ua.raw47 = extractvalue { i64, i64 } %loadN, 1
|
|
%trN = trunc i64 %ua.raw47 to i32
|
|
%iNf = bitcast i32 %trN to float
|
|
%fpext = fpext float %iNf to double
|
|
store double %fpext, ptr %allocaN, align 8
|
|
br label %float.merge.93
|
|
|
|
f64.unbox.92: ; preds = %match.arm.52
|
|
%ua.raw48 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNd = bitcast i64 %ua.raw48 to double
|
|
store double %iNd, ptr %allocaN, align 8
|
|
br label %float.merge.93
|
|
|
|
float.merge.93: ; preds = %fN.unbox.92, %fN.unbox.91
|
|
%loadN = load double, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @float_to_string(ptr %0, double %loadN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
dispatch.merge.104: ; preds = %dispatch.case.114, %dispatch.case.113, %dispatch.case.112, %dispatch.case.111, %dispatch.case.110, %dispatch.case.109, %dispatch.case.108, %dispatch.case.107, %dispatch.case.106, %dispatch.default.105
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
dispatch.default.105: ; preds = %match.arm.53
|
|
store { ptr, i64 } { ptr @str.83, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.106: ; preds = %match.arm.53
|
|
%ua.raw52 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr53 = inttoptr i64 %ua.raw52 to ptr
|
|
%ua.load54 = load { { ptr, i64 }, i32, i32, { ptr, i64 } }, ptr %ua.ptr53, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Source_Location(ptr %0, { { ptr, i64 }, i32, i32, { ptr, i64 } } %ua.load54)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.107: ; preds = %match.arm.53
|
|
%ua.raw56 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr57 = inttoptr i64 %ua.raw56 to ptr
|
|
%ua.load58 = load { ptr, ptr, ptr }, ptr %ua.ptr57, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %ua.load58)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.108: ; preds = %match.arm.53
|
|
%ua.raw60 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr61 = inttoptr i64 %ua.raw60 to ptr
|
|
%ua.load62 = load {}, ptr %ua.ptr61, align 1
|
|
%callN = call { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %ua.load62)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.109: ; preds = %match.arm.53
|
|
%ua.raw64 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr65 = inttoptr i64 %ua.raw64 to ptr
|
|
%ua.load66 = load { i64 }, ptr %ua.ptr65, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %ua.load66)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.110: ; preds = %match.arm.53
|
|
%ua.raw68 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr69 = inttoptr i64 %ua.raw68 to ptr
|
|
%ua.load70 = load { ptr, i64 }, ptr %ua.ptr69, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 } %ua.load70)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.111: ; preds = %match.arm.53
|
|
%ua.raw72 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr73 = inttoptr i64 %ua.raw72 to ptr
|
|
%ua.load74 = load { ptr, i64, { ptr, ptr, ptr } }, ptr %ua.ptr73, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr, ptr, ptr } } %ua.load74)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.112: ; preds = %match.arm.53
|
|
%ua.raw76 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr77 = inttoptr i64 %ua.raw76 to ptr
|
|
%ua.load78 = load { ptr, i64, i64 }, ptr %ua.ptr77, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64 } %ua.load78)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.113: ; preds = %match.arm.53
|
|
%ua.raw80 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr81 = inttoptr i64 %ua.raw80 to ptr
|
|
%ua.load82 = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %ua.ptr81, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { ptr, ptr, ptr }, i64, i64, i64 } %ua.load82)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.case.114: ; preds = %match.arm.53
|
|
%ua.raw84 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr85 = inttoptr i64 %ua.raw84 to ptr
|
|
%ua.load86 = load { { ptr, ptr, ptr }, ptr }, ptr %ua.ptr85, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, ptr }, ptr } %ua.load86)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.104
|
|
|
|
dispatch.merge.160: ; preds = %dispatch.case.163, %dispatch.case.162, %dispatch.default.161
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
dispatch.default.161: ; preds = %match.arm.57
|
|
store { ptr, i64 } { ptr @str.84, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.160
|
|
|
|
dispatch.case.162: ; preds = %match.arm.57
|
|
%ua.raw89 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr90 = inttoptr i64 %ua.raw89 to ptr
|
|
%ua.load91 = load [4 x i64], ptr %ua.ptr90, align 8
|
|
%callN = call { ptr, i64 } @array_to_string__AR_4_s64(ptr %0, [4 x i64] %ua.load91)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.160
|
|
|
|
dispatch.case.163: ; preds = %match.arm.57
|
|
%ua.raw93 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr94 = inttoptr i64 %ua.raw93 to ptr
|
|
%ua.load95 = load [1 x { i64, i64 }], ptr %ua.ptr94, align 8
|
|
%callN = call { ptr, i64 } @array_to_string__AR_1_Any(ptr %0, [1 x { i64, i64 }] %ua.load95)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.160
|
|
|
|
dispatch.merge.174: ; preds = %dispatch.case.177, %dispatch.case.176, %dispatch.default.175
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
dispatch.default.175: ; preds = %match.arm.58
|
|
store { ptr, i64 } { ptr @str.85, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.174
|
|
|
|
dispatch.case.176: ; preds = %match.arm.58
|
|
%ua.raw98 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr99 = inttoptr i64 %ua.raw98 to ptr
|
|
%ua.load100 = load { ptr, i64 }, ptr %ua.ptr99, align 8
|
|
%callN = call { ptr, i64 } @slice_to_string__string(ptr %0, { ptr, i64 } %ua.load100)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.174
|
|
|
|
dispatch.case.177: ; preds = %match.arm.58
|
|
%ua.raw102 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr103 = inttoptr i64 %ua.raw102 to ptr
|
|
%ua.load104 = load { ptr, i64 }, ptr %ua.ptr103, align 8
|
|
%callN = call { ptr, i64 } @slice_to_string__Any(ptr %0, { ptr, i64 } %ua.load104)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.174
|
|
|
|
dispatch.merge.188: ; preds = %dispatch.case.208, %dispatch.case.207, %dispatch.case.206, %dispatch.case.205, %dispatch.case.204, %dispatch.case.203, %dispatch.case.202, %dispatch.case.201, %dispatch.case.200, %dispatch.case.199, %dispatch.case.198, %dispatch.case.197, %dispatch.case.196, %dispatch.case.195, %dispatch.case.194, %dispatch.case.193, %dispatch.case.192, %dispatch.case.191, %dispatch.case.190, %dispatch.default.189
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.47
|
|
|
|
dispatch.default.189: ; preds = %match.arm.59
|
|
store { ptr, i64 } { ptr @str.86, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.190: ; preds = %match.arm.59
|
|
%ua.raw107 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp = inttoptr i64 %ua.raw107 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_void(ptr %0, ptr %iNp)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.191: ; preds = %match.arm.59
|
|
%ua.raw109 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp110 = inttoptr i64 %ua.raw109 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_CAllocator(ptr %0, ptr %iNp110)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.192: ; preds = %match.arm.59
|
|
%ua.raw112 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp113 = inttoptr i64 %ua.raw112 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_GPA(ptr %0, ptr %iNp113)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.193: ; preds = %match.arm.59
|
|
%ua.raw115 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp116 = inttoptr i64 %ua.raw115 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ArenaChunk(ptr %0, ptr %iNp116)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.194: ; preds = %match.arm.59
|
|
%ua.raw118 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp119 = inttoptr i64 %ua.raw118 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_Arena(ptr %0, ptr %iNp119)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.195: ; preds = %match.arm.59
|
|
%ua.raw121 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp122 = inttoptr i64 %ua.raw121 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__mptr_u8(ptr %0, ptr %iNp122)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.196: ; preds = %match.arm.59
|
|
%ua.raw124 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp125 = inttoptr i64 %ua.raw124 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_BufAlloc(ptr %0, ptr %iNp125)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.197: ; preds = %match.arm.59
|
|
%ua.raw127 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp128 = inttoptr i64 %ua.raw127 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_TrackingAllocator(ptr %0, ptr %iNp128)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.198: ; preds = %match.arm.59
|
|
%ua.raw130 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp131 = inttoptr i64 %ua.raw130 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_CAllocator(ptr %0, ptr %iNp131)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.199: ; preds = %match.arm.59
|
|
%ua.raw133 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp134 = inttoptr i64 %ua.raw133 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_s64(ptr %0, ptr %iNp134)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.200: ; preds = %match.arm.59
|
|
%ua.raw136 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp137 = inttoptr i64 %ua.raw136 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_void(ptr %0, ptr %iNp137)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.201: ; preds = %match.arm.59
|
|
%ua.raw139 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp140 = inttoptr i64 %ua.raw139 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_s32(ptr %0, ptr %iNp140)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.202: ; preds = %match.arm.59
|
|
%ua.raw142 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp143 = inttoptr i64 %ua.raw142 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_error_set(ptr %0, ptr %iNp143)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.203: ; preds = %match.arm.59
|
|
%ua.raw145 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp146 = inttoptr i64 %ua.raw145 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %iNp146)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.204: ; preds = %match.arm.59
|
|
%ua.raw148 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp149 = inttoptr i64 %ua.raw148 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %iNp149)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.205: ; preds = %match.arm.59
|
|
%ua.raw151 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp152 = inttoptr i64 %ua.raw151 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %iNp152)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.206: ; preds = %match.arm.59
|
|
%ua.raw154 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp155 = inttoptr i64 %ua.raw154 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %iNp155)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.207: ; preds = %match.arm.59
|
|
%ua.raw157 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp158 = inttoptr i64 %ua.raw157 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %iNp158)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
|
|
dispatch.case.208: ; preds = %match.arm.59
|
|
%ua.raw160 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp161 = inttoptr i64 %ua.raw160 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %iNp161)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.188
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @build_format(ptr %0, { ptr, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.87, i64 14 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.10
|
|
|
|
while.hdr.10: ; preds = %if.merge.15, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%len = extractvalue { ptr, i64 } %loadN, 1
|
|
%icmp = icmp slt i64 %load, %len
|
|
br i1 %icmp, label %while.body.11, label %while.exit.12
|
|
|
|
while.body.11: ; preds = %while.hdr.10
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%ig.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr = getelementptr i8, ptr %ig.data, i64 %loadN
|
|
%ig.val = load i8, ptr %ig.ptr, align 1
|
|
%cmp.ext = zext i8 %ig.val to i64
|
|
%icmpN = icmp eq i64 %cmp.ext, 123
|
|
br i1 %icmpN, label %if.then.13, label %if.else.14
|
|
|
|
while.exit.12: ; preds = %while.hdr.10
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%lenN = extractvalue { ptr, i64 } %loadN, 1
|
|
%icmpN = icmp slt i64 %loadN, %lenN
|
|
br i1 %icmpN, label %if.then.45, label %if.merge.46
|
|
|
|
if.then.13: ; preds = %while.body.11
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%lenN = extractvalue { ptr, i64 } %loadN, 1
|
|
%icmpN = icmp slt i64 %add, %lenN
|
|
br i1 %icmpN, label %if.then.16, label %if.else.17
|
|
|
|
if.else.14: ; preds = %while.body.11
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%ig.data19 = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr20 = getelementptr i8, ptr %ig.data19, i64 %loadN
|
|
%ig.val21 = load i8, ptr %ig.ptr20, align 1
|
|
%cmp.ext22 = zext i8 %ig.val21 to i64
|
|
%icmpN = icmp eq i64 %cmp.ext22, 125
|
|
br i1 %icmpN, label %if.then.36, label %if.else.37
|
|
|
|
if.merge.15: ; preds = %if.merge.38, %if.merge.18
|
|
br label %while.hdr.10
|
|
|
|
if.then.16: ; preds = %if.then.13
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
%ig.data27 = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr28 = getelementptr i8, ptr %ig.data27, i64 %addN
|
|
%ig.val29 = load i8, ptr %ig.ptr28, align 1
|
|
%cmp.ext30 = zext i8 %ig.val29 to i64
|
|
%icmpN = icmp eq i64 %cmp.ext30, 125
|
|
br i1 %icmpN, label %if.then.19, label %if.else.20
|
|
|
|
if.else.17: ; preds = %if.then.13
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.18
|
|
|
|
if.merge.18: ; preds = %if.merge.21, %if.else.17
|
|
br label %if.merge.15
|
|
|
|
if.then.19: ; preds = %if.then.16
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, %loadN
|
|
br i1 %icmpN, label %if.then.22, label %if.merge.23
|
|
|
|
if.else.20: ; preds = %if.then.16
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
%ig.data40 = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr41 = getelementptr i8, ptr %ig.data40, i64 %addN
|
|
%ig.val42 = load i8, ptr %ig.ptr41, align 1
|
|
%cmp.ext43 = zext i8 %ig.val42 to i64
|
|
%icmpN = icmp eq i64 %cmp.ext43, 123
|
|
br i1 %icmpN, label %if.then.33, label %if.else.34
|
|
|
|
if.merge.21: ; preds = %if.merge.35, %if.merge.23
|
|
br label %if.merge.18
|
|
|
|
if.then.22: ; preds = %if.then.19
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.88, i64 36 })
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.89, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 %loadN, %loadN
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %sub)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.90, i64 4 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.23
|
|
|
|
if.merge.23: ; preds = %if.then.22, %if.then.19
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.91, i64 43 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.92, i64 5 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 2
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
store i64 %loadN, ptr %allocaN, align 8
|
|
br label %if.merge.21
|
|
|
|
if.then.33: ; preds = %if.else.20
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.93, i64 36 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.94, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, %loadN
|
|
%addN = add i64 %subN, 1
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %addN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.95, i64 4 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 2
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
store i64 %loadN, ptr %allocaN, align 8
|
|
br label %if.merge.35
|
|
|
|
if.else.34: ; preds = %if.else.20
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.35
|
|
|
|
if.merge.35: ; preds = %if.else.34, %if.then.33
|
|
br label %if.merge.21
|
|
|
|
if.then.36: ; preds = %if.else.14
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%lenN = extractvalue { ptr, i64 } %loadN, 1
|
|
%icmpN = icmp slt i64 %addN, %lenN
|
|
br i1 %icmpN, label %if.then.39, label %if.else.40
|
|
|
|
if.else.37: ; preds = %if.else.14
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.38
|
|
|
|
if.merge.38: ; preds = %if.merge.41, %if.else.37
|
|
br label %if.merge.15
|
|
|
|
if.then.39: ; preds = %if.then.36
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
%ig.data104 = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr105 = getelementptr i8, ptr %ig.data104, i64 %addN
|
|
%ig.val106 = load i8, ptr %ig.ptr105, align 1
|
|
%cmp.ext107 = zext i8 %ig.val106 to i64
|
|
%icmpN = icmp eq i64 %cmp.ext107, 125
|
|
br i1 %icmpN, label %if.then.42, label %if.else.43
|
|
|
|
if.else.40: ; preds = %if.then.36
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.41
|
|
|
|
if.merge.41: ; preds = %if.merge.44, %if.else.40
|
|
br label %if.merge.38
|
|
|
|
if.then.42: ; preds = %if.then.39
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.96, i64 36 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.97, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %loadN, %loadN
|
|
%addN = add i64 %subN, 1
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %addN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.98, i64 4 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 2
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
store i64 %loadN, ptr %allocaN, align 8
|
|
br label %if.merge.44
|
|
|
|
if.else.43: ; preds = %if.then.39
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.44
|
|
|
|
if.merge.44: ; preds = %if.else.43, %if.then.42
|
|
br label %if.merge.41
|
|
|
|
if.then.45: ; preds = %while.exit.12
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.99, i64 36 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %loadN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.100, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%lenN = extractvalue { ptr, i64 } %loadN, 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%subN = sub i64 %lenN, %loadN
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %subN)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.101, i64 4 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.46
|
|
|
|
if.merge.46: ; preds = %if.then.45, %while.exit.12
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal i32 @inner(ptr %0, i32 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i32, align 4
|
|
store i32 %1, ptr %alloca, align 4
|
|
%load = load i32, ptr %alloca, align 4
|
|
%cmp.ext = sext i32 %load to i64
|
|
%icmp = icmp slt i64 %cmp.ext, 0
|
|
br i1 %icmp, label %if.then.0, label %if.merge.1
|
|
|
|
if.then.0: ; preds = %entry
|
|
ret i32 1
|
|
|
|
if.merge.1: ; preds = %entry
|
|
ret i32 0
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal i32 @outer(ptr %0, i32 %1) #0 {
|
|
entry:
|
|
%alloca = alloca i32, align 4
|
|
store i32 %1, ptr %alloca, align 4
|
|
%load = load i32, ptr %alloca, align 4
|
|
%call = call i32 @inner(ptr %0, i32 %load)
|
|
%icmp = icmp ne i32 %call, 0
|
|
br i1 %icmp, label %try.prop.2, label %try.ok.3
|
|
|
|
try.prop.2: ; preds = %entry
|
|
ret i32 %call
|
|
|
|
try.ok.3: ; preds = %entry
|
|
ret i32 0
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define i32 @main() #0 {
|
|
entry:
|
|
%call = call i32 @outer(ptr @__sx_default_context, i32 -1)
|
|
%alloca = alloca i32, align 4
|
|
store i32 %call, ptr %alloca, align 4
|
|
%callN = call i32 @outer(ptr @__sx_default_context, i32 7)
|
|
%allocaN = alloca i32, align 4
|
|
store i32 %callN, ptr %allocaN, align 4
|
|
%allocaN = alloca i32, align 4
|
|
store i32 0, ptr %allocaN, align 4
|
|
%load = load i32, ptr %alloca, align 4
|
|
%icmp = icmp eq i32 %load, 1
|
|
br i1 %icmp, label %if.then.4, label %if.merge.5
|
|
|
|
if.then.4: ; preds = %entry
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
%add = add i32 %loadN, 5
|
|
store i32 %add, ptr %allocaN, align 4
|
|
br label %if.merge.5
|
|
|
|
if.merge.5: ; preds = %if.then.4, %entry
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
%icmpN = icmp eq i32 %loadN, 1
|
|
br i1 %icmpN, label %if.then.6, label %if.merge.7
|
|
|
|
if.then.6: ; preds = %if.merge.5
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
%addN = add i32 %loadN, 1
|
|
store i32 %addN, ptr %allocaN, align 4
|
|
br label %if.merge.7
|
|
|
|
if.merge.7: ; preds = %if.then.6, %if.merge.5
|
|
%loadN = load i32, ptr %alloca, align 4
|
|
%icmpN = icmp eq i32 %loadN, 2
|
|
br i1 %icmpN, label %if.then.8, label %if.merge.9
|
|
|
|
if.then.8: ; preds = %if.merge.7
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
%addN = add i32 %loadN, 2
|
|
store i32 %addN, ptr %allocaN, align 4
|
|
br label %if.merge.9
|
|
|
|
if.merge.9: ; preds = %if.then.8, %if.merge.7
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
call void @print__ct_s1c36e8f510df0c92__pack_s32(ptr @__sx_default_context, i32 %loadN)
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
ret i32 %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal ptr @__thunk_CAllocator_Allocator_alloc(ptr %0, ptr %1, i64 %2) #0 {
|
|
entry:
|
|
%call = call ptr @CAllocator.alloc(ptr %0, ptr %1, i64 %2)
|
|
ret ptr %call
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal void @__thunk_CAllocator_Allocator_dealloc(ptr %0, ptr %1, ptr %2) #0 {
|
|
entry:
|
|
call void @CAllocator.dealloc(ptr %0, ptr %1, ptr %2)
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal void @print__ct_s1c36e8f510df0c92__pack_s32(ptr %0, i32 %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.107, i64 15 }, ptr %alloca, align 8
|
|
%allocaN = alloca i32, align 4
|
|
store i32 %1, ptr %allocaN, align 4
|
|
%allocaN = alloca [1 x { i64, i64 }], align 8
|
|
%load = load i32, ptr %allocaN, align 4
|
|
%sN = sext i32 %load to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
|
|
%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.ptr4 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
|
|
%gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
|
|
store ptr %igp.ptr4, ptr %gep, align 8
|
|
%gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
|
|
store i64 1, ptr %gepN, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.108, i64 0 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 0, i64 12)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %call)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i32, ptr %allocaN, align 4
|
|
%sN = sext i32 %loadN to i64
|
|
%ba.val13 = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val13)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%callN = call { ptr, i64 } @substr(ptr %0, { ptr, i64 } %loadN, i64 14, i64 1)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%str.ptr = extractvalue { ptr, i64 } %loadN, 0
|
|
%str.len = extractvalue { ptr, i64 } %loadN, 1
|
|
%2 = call i64 @write(i32 1, ptr %str.ptr, i64 %str.len)
|
|
ret void
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @__insert_0(ptr %0) #0 {
|
|
entry:
|
|
%call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.109, i64 15 })
|
|
ret { ptr, i64 } %call
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__Source_Location(ptr %0, { { ptr, i64 }, i32, i32, { ptr, i64 } } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { { ptr, i64 }, i32, i32, { ptr, i64 } }, align 8
|
|
%ba.tmp = alloca { ptr, i64 }, align 8
|
|
%ba.tmp26 = alloca { ptr, i64 }, align 8
|
|
store { { ptr, i64 }, i32, i32, { ptr, i64 } } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.110, i64 15 }, { ptr, i64 } { ptr @str.111, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.115
|
|
|
|
while.hdr.115: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 4
|
|
br i1 %icmp, label %while.body.116, label %while.exit.117
|
|
|
|
while.body.116: ; preds = %while.hdr.115
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.118, label %if.merge.119
|
|
|
|
while.exit.117: ; preds = %while.hdr.115
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.112, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.118: ; preds = %while.body.116
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.113, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.119
|
|
|
|
if.merge.119: ; preds = %if.then.118, %while.body.116
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [4 x { ptr, i64 }], ptr @field_names, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.117, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { { ptr, i64 }, i32, i32, { ptr, i64 } }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
i64 1, label %fv.case17
|
|
i64 2, label %fv.case20
|
|
i64 3, label %fv.case24
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case24, %fv.case20, %fv.case17, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val23, %fv.case20 ], [ %fv.val28, %fv.case24 ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.115
|
|
|
|
fv.default: ; preds = %if.merge.119
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.119
|
|
%fv.field = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 0
|
|
store { ptr, i64 } %fv.field, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%fv.val = insertvalue { i64, i64 } { i64 12, i64 undef }, i64 %ba.p2i, 1
|
|
br label %fv.merge
|
|
|
|
fv.case17: ; preds = %if.merge.119
|
|
%fv.field18 = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 1
|
|
%sN = sext i32 %fv.field18 to i64
|
|
%fv.val19 = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
|
|
br label %fv.merge
|
|
|
|
fv.case20: ; preds = %if.merge.119
|
|
%fv.field21 = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 2
|
|
%sN = sext i32 %fv.field21 to i64
|
|
%fv.val23 = insertvalue { i64, i64 } { i64 4, i64 undef }, i64 %sN, 1
|
|
br label %fv.merge
|
|
|
|
fv.case24: ; preds = %if.merge.119
|
|
%fv.field25 = extractvalue { { ptr, i64 }, i32, i32, { ptr, i64 } } %loadN, 3
|
|
store { ptr, i64 } %fv.field25, ptr %ba.tmp26, align 8
|
|
%ba.p2i27 = ptrtoint ptr %ba.tmp26 to i64
|
|
%fv.val28 = insertvalue { i64, i64 } { i64 12, i64 undef }, i64 %ba.p2i27, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, ptr, ptr }, align 8
|
|
store { ptr, ptr, ptr } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.118, i64 9 }, { ptr, i64 } { ptr @str.119, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.120
|
|
|
|
while.hdr.120: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 3
|
|
br i1 %icmp, label %while.body.121, label %while.exit.122
|
|
|
|
while.body.121: ; preds = %while.hdr.120
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.123, label %if.merge.124
|
|
|
|
while.exit.122: ; preds = %while.hdr.120
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.120, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.123: ; preds = %while.body.121
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.121, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.124
|
|
|
|
if.merge.124: ; preds = %if.then.123, %while.body.121
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.125, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.126, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, ptr, ptr }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
i64 1, label %fv.case17
|
|
i64 2, label %fv.case21
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case21, %fv.case17, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val20, %fv.case17 ], [ %fv.val24, %fv.case21 ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.120
|
|
|
|
fv.default: ; preds = %if.merge.124
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.124
|
|
%fv.field = extractvalue { ptr, ptr, ptr } %loadN, 0
|
|
%pNi = ptrtoint ptr %fv.field to i64
|
|
%fv.val = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi, 1
|
|
br label %fv.merge
|
|
|
|
fv.case17: ; preds = %if.merge.124
|
|
%fv.field18 = extractvalue { ptr, ptr, ptr } %loadN, 1
|
|
%pNi19 = ptrtoint ptr %fv.field18 to i64
|
|
%fv.val20 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi19, 1
|
|
br label %fv.merge
|
|
|
|
fv.case21: ; preds = %if.merge.124
|
|
%fv.field22 = extractvalue { ptr, ptr, ptr } %loadN, 2
|
|
%pNi23 = ptrtoint ptr %fv.field22 to i64
|
|
%fv.val24 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi23, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %1) #0 {
|
|
entry:
|
|
%alloca = alloca {}, align 8
|
|
store {} %1, ptr %alloca, align 1
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.127, i64 10 }, { ptr, i64 } { ptr @str.128, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.125
|
|
|
|
while.hdr.125: ; preds = %if.merge.129, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 0
|
|
br i1 %icmp, label %while.body.126, label %while.exit.127
|
|
|
|
while.body.126: ; preds = %while.hdr.125
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.128, label %if.merge.129
|
|
|
|
while.exit.127: ; preds = %while.hdr.125
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.129, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.128: ; preds = %while.body.126
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.130, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.129
|
|
|
|
if.merge.129: ; preds = %if.then.128, %while.body.126
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [0 x { ptr, i64 }], ptr @field_names.131, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.132, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load {}, ptr %alloca, align 1
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } { i64 17, i64 0 })
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.125
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { i64 }, align 8
|
|
store { i64 } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.133, i64 3 }, { ptr, i64 } { ptr @str.134, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.130
|
|
|
|
while.hdr.130: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 1
|
|
br i1 %icmp, label %while.body.131, label %while.exit.132
|
|
|
|
while.body.131: ; preds = %while.hdr.130
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.133, label %if.merge.134
|
|
|
|
while.exit.132: ; preds = %while.hdr.130
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.135, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.133: ; preds = %while.body.131
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.136, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.134
|
|
|
|
if.merge.134: ; preds = %if.then.133, %while.body.131
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [1 x { ptr, i64 }], ptr @field_names.138, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.139, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.130
|
|
|
|
fv.default: ; preds = %if.merge.134
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.134
|
|
%fv.field = extractvalue { i64 } %loadN, 0
|
|
%fv.val = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.140, i64 10 }, { ptr, i64 } { ptr @str.141, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.135
|
|
|
|
while.hdr.135: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 2
|
|
br i1 %icmp, label %while.body.136, label %while.exit.137
|
|
|
|
while.body.136: ; preds = %while.hdr.135
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.138, label %if.merge.139
|
|
|
|
while.exit.137: ; preds = %while.hdr.135
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.142, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.138: ; preds = %while.body.136
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.143, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.139
|
|
|
|
if.merge.139: ; preds = %if.then.138, %while.body.136
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.146, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.147, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
i64 1, label %fv.case17
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case17, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.135
|
|
|
|
fv.default: ; preds = %if.merge.139
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.139
|
|
%fv.field = extractvalue { ptr, i64 } %loadN, 0
|
|
%pNi = ptrtoint ptr %fv.field to i64
|
|
%fv.val = insertvalue { i64, i64 } { i64 26, i64 undef }, i64 %pNi, 1
|
|
br label %fv.merge
|
|
|
|
fv.case17: ; preds = %if.merge.139
|
|
%fv.field18 = extractvalue { ptr, i64 } %loadN, 1
|
|
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr, ptr, ptr } } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64, { ptr, ptr, ptr } }, align 8
|
|
%ba.tmp = alloca { ptr, ptr, ptr }, align 8
|
|
store { ptr, i64, { ptr, ptr, ptr } } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.148, i64 5 }, { ptr, i64 } { ptr @str.149, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.140
|
|
|
|
while.hdr.140: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 3
|
|
br i1 %icmp, label %while.body.141, label %while.exit.142
|
|
|
|
while.body.141: ; preds = %while.hdr.140
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.143, label %if.merge.144
|
|
|
|
while.exit.142: ; preds = %while.hdr.140
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.150, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.143: ; preds = %while.body.141
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.151, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.144
|
|
|
|
if.merge.144: ; preds = %if.then.143, %while.body.141
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.155, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.156, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64, { ptr, ptr, ptr } }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
i64 1, label %fv.case17
|
|
i64 2, label %fv.case20
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case20, %fv.case17, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val22, %fv.case20 ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.140
|
|
|
|
fv.default: ; preds = %if.merge.144
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.144
|
|
%fv.field = extractvalue { ptr, i64, { ptr, ptr, ptr } } %loadN, 0
|
|
%pNi = ptrtoint ptr %fv.field to i64
|
|
%fv.val = insertvalue { i64, i64 } { i64 26, i64 undef }, i64 %pNi, 1
|
|
br label %fv.merge
|
|
|
|
fv.case17: ; preds = %if.merge.144
|
|
%fv.field18 = extractvalue { ptr, i64, { ptr, ptr, ptr } } %loadN, 1
|
|
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
|
|
br label %fv.merge
|
|
|
|
fv.case20: ; preds = %if.merge.144
|
|
%fv.field21 = extractvalue { ptr, i64, { ptr, ptr, ptr } } %loadN, 2
|
|
store { ptr, ptr, ptr } %fv.field21, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%fv.val22 = insertvalue { i64, i64 } { i64 20, i64 undef }, i64 %ba.p2i, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64, i64 }, align 8
|
|
store { ptr, i64, i64 } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.157, i64 8 }, { ptr, i64 } { ptr @str.158, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.145
|
|
|
|
while.hdr.145: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 3
|
|
br i1 %icmp, label %while.body.146, label %while.exit.147
|
|
|
|
while.body.146: ; preds = %while.hdr.145
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.148, label %if.merge.149
|
|
|
|
while.exit.147: ; preds = %while.hdr.145
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.159, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.148: ; preds = %while.body.146
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.160, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.149
|
|
|
|
if.merge.149: ; preds = %if.then.148, %while.body.146
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [3 x { ptr, i64 }], ptr @field_names.164, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.165, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
i64 1, label %fv.case17
|
|
i64 2, label %fv.case20
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case20, %fv.case17, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val22, %fv.case20 ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.145
|
|
|
|
fv.default: ; preds = %if.merge.149
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.149
|
|
%fv.field = extractvalue { ptr, i64, i64 } %loadN, 0
|
|
%pNi = ptrtoint ptr %fv.field to i64
|
|
%fv.val = insertvalue { i64, i64 } { i64 29, i64 undef }, i64 %pNi, 1
|
|
br label %fv.merge
|
|
|
|
fv.case17: ; preds = %if.merge.149
|
|
%fv.field18 = extractvalue { ptr, i64, i64 } %loadN, 1
|
|
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
|
|
br label %fv.merge
|
|
|
|
fv.case20: ; preds = %if.merge.149
|
|
%fv.field21 = extractvalue { ptr, i64, i64 } %loadN, 2
|
|
%fv.val22 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field21, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { ptr, ptr, ptr }, i64, i64, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { { ptr, ptr, ptr }, i64, i64, i64 }, align 8
|
|
%ba.tmp = alloca { ptr, ptr, ptr }, align 8
|
|
store { { ptr, ptr, ptr }, i64, i64, i64 } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.166, i64 17 }, { ptr, i64 } { ptr @str.167, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.150
|
|
|
|
while.hdr.150: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 4
|
|
br i1 %icmp, label %while.body.151, label %while.exit.152
|
|
|
|
while.body.151: ; preds = %while.hdr.150
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.153, label %if.merge.154
|
|
|
|
while.exit.152: ; preds = %while.hdr.150
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.168, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.153: ; preds = %while.body.151
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.169, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.154
|
|
|
|
if.merge.154: ; preds = %if.then.153, %while.body.151
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [4 x { ptr, i64 }], ptr @field_names.174, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.175, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
i64 1, label %fv.case17
|
|
i64 2, label %fv.case20
|
|
i64 3, label %fv.case23
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case23, %fv.case20, %fv.case17, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ %fv.val22, %fv.case20 ], [ %fv.val25, %fv.case23 ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.150
|
|
|
|
fv.default: ; preds = %if.merge.154
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.154
|
|
%fv.field = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 0
|
|
store { ptr, ptr, ptr } %fv.field, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%fv.val = insertvalue { i64, i64 } { i64 20, i64 undef }, i64 %ba.p2i, 1
|
|
br label %fv.merge
|
|
|
|
fv.case17: ; preds = %if.merge.154
|
|
%fv.field18 = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 1
|
|
%fv.val19 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field18, 1
|
|
br label %fv.merge
|
|
|
|
fv.case20: ; preds = %if.merge.154
|
|
%fv.field21 = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 2
|
|
%fv.val22 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field21, 1
|
|
br label %fv.merge
|
|
|
|
fv.case23: ; preds = %if.merge.154
|
|
%fv.field24 = extractvalue { { ptr, ptr, ptr }, i64, i64, i64 } %loadN, 3
|
|
%fv.val25 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %fv.field24, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, ptr }, ptr } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { { ptr, ptr, ptr }, ptr }, align 8
|
|
%ba.tmp = alloca { ptr, ptr, ptr }, align 8
|
|
store { { ptr, ptr, ptr }, ptr } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.176, i64 7 }, { ptr, i64 } { ptr @str.177, i64 1 })
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %call, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.155
|
|
|
|
while.hdr.155: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 2
|
|
br i1 %icmp, label %while.body.156, label %while.exit.157
|
|
|
|
while.body.156: ; preds = %while.hdr.155
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.158, label %if.merge.159
|
|
|
|
while.exit.157: ; preds = %while.hdr.155
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.178, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.158: ; preds = %while.body.156
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.179, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.159
|
|
|
|
if.merge.159: ; preds = %if.then.158, %while.body.156
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [2 x { ptr, i64 }], ptr @field_names.182, i64 0, i64 %loadN
|
|
%fn.load = load { ptr, i64 }, ptr %fn.gep, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %fn.load)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.183, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { { ptr, ptr, ptr }, ptr }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
switch i64 %loadN, label %fv.default [
|
|
i64 0, label %fv.case
|
|
i64 1, label %fv.case17
|
|
]
|
|
|
|
fv.merge: ; preds = %fv.default, %fv.case17, %fv.case
|
|
%fv.phi = phi { i64, i64 } [ %fv.val, %fv.case ], [ %fv.val19, %fv.case17 ], [ undef, %fv.default ]
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %fv.phi)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.155
|
|
|
|
fv.default: ; preds = %if.merge.159
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.159
|
|
%fv.field = extractvalue { { ptr, ptr, ptr }, ptr } %loadN, 0
|
|
store { ptr, ptr, ptr } %fv.field, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%fv.val = insertvalue { i64, i64 } { i64 20, i64 undef }, i64 %ba.p2i, 1
|
|
br label %fv.merge
|
|
|
|
fv.case17: ; preds = %if.merge.159
|
|
%fv.field18 = extractvalue { { ptr, ptr, ptr }, ptr } %loadN, 1
|
|
%pNi = ptrtoint ptr %fv.field18 to i64
|
|
%fv.val19 = insertvalue { i64, i64 } { i64 18, i64 undef }, i64 %pNi, 1
|
|
br label %fv.merge
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @array_to_string__AR_4_s64(ptr %0, [4 x i64] %1) #0 {
|
|
entry:
|
|
%alloca = alloca [4 x i64], align 8
|
|
%ig.tmp = alloca [4 x i64], align 8
|
|
store [4 x i64] %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.184, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.164
|
|
|
|
while.hdr.164: ; preds = %if.merge.168, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 4
|
|
br i1 %icmp, label %while.body.165, label %while.exit.166
|
|
|
|
while.body.165: ; preds = %while.hdr.164
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.167, label %if.merge.168
|
|
|
|
while.exit.166: ; preds = %while.hdr.164
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.185, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.167: ; preds = %while.body.165
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.186, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.168
|
|
|
|
if.merge.168: ; preds = %if.then.167, %while.body.165
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load [4 x i64], ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
store [4 x i64] %loadN, ptr %ig.tmp, align 8
|
|
%ig.ptr = getelementptr [4 x i64], ptr %ig.tmp, i64 0, i64 %loadN
|
|
%ig.val = load i64, ptr %ig.ptr, align 8
|
|
%ba.val = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %ig.val, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.164
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @array_to_string__AR_1_Any(ptr %0, [1 x { i64, i64 }] %1) #0 {
|
|
entry:
|
|
%alloca = alloca [1 x { i64, i64 }], align 8
|
|
%ig.tmp = alloca [1 x { i64, i64 }], align 8
|
|
%ba.tmp = alloca { i64, i64 }, align 8
|
|
store [1 x { i64, i64 }] %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.187, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.169
|
|
|
|
while.hdr.169: ; preds = %if.merge.173, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 1
|
|
br i1 %icmp, label %while.body.170, label %while.exit.171
|
|
|
|
while.body.170: ; preds = %while.hdr.169
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.172, label %if.merge.173
|
|
|
|
while.exit.171: ; preds = %while.hdr.169
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.188, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.172: ; preds = %while.body.170
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.189, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.173
|
|
|
|
if.merge.173: ; preds = %if.then.172, %while.body.170
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load [1 x { i64, i64 }], ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
store [1 x { i64, i64 }] %loadN, ptr %ig.tmp, align 8
|
|
%ig.ptr = getelementptr [1 x { i64, i64 }], ptr %ig.tmp, i64 0, i64 %loadN
|
|
%ig.val = load { i64, i64 }, ptr %ig.ptr, align 8
|
|
store { i64, i64 } %ig.val, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 13, i64 undef }, i64 %ba.p2i, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.169
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @slice_to_string__string(ptr %0, { ptr, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
%ba.tmp = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.190, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.178
|
|
|
|
while.hdr.178: ; preds = %if.merge.182, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%len = extractvalue { ptr, i64 } %loadN, 1
|
|
%icmp = icmp slt i64 %load, %len
|
|
br i1 %icmp, label %while.body.179, label %while.exit.180
|
|
|
|
while.body.179: ; preds = %while.hdr.178
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.181, label %if.merge.182
|
|
|
|
while.exit.180: ; preds = %while.hdr.178
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.191, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.181: ; preds = %while.body.179
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.192, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.182
|
|
|
|
if.merge.182: ; preds = %if.then.181, %while.body.179
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%ig.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr = getelementptr { ptr, i64 }, ptr %ig.data, i64 %loadN
|
|
%ig.val = load { ptr, i64 }, ptr %ig.ptr, align 8
|
|
store { ptr, i64 } %ig.val, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 12, i64 undef }, i64 %ba.p2i, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.178
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @slice_to_string__Any(ptr %0, { ptr, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
%ba.tmp = alloca { i64, i64 }, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.193, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.183
|
|
|
|
while.hdr.183: ; preds = %if.merge.187, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%len = extractvalue { ptr, i64 } %loadN, 1
|
|
%icmp = icmp slt i64 %load, %len
|
|
br i1 %icmp, label %while.body.184, label %while.exit.185
|
|
|
|
while.body.184: ; preds = %while.hdr.183
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.186, label %if.merge.187
|
|
|
|
while.exit.185: ; preds = %while.hdr.183
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.194, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.186: ; preds = %while.body.184
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.195, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.187
|
|
|
|
if.merge.187: ; preds = %if.then.186, %while.body.184
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%ig.data = extractvalue { ptr, i64 } %loadN, 0
|
|
%ig.ptr = getelementptr { i64, i64 }, ptr %ig.data, i64 %loadN
|
|
%ig.val = load { i64, i64 }, ptr %ig.ptr, align 8
|
|
store { i64, i64 } %ig.val, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 13, i64 undef }, i64 %ba.p2i, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } %callN)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.183
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_void(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.209, label %if.else.210
|
|
|
|
if.then.209: ; preds = %entry
|
|
br label %if.merge.211
|
|
|
|
if.else.210: ; 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.198, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.197, i64 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.211
|
|
|
|
if.merge.211: ; preds = %if.else.210, %if.then.209
|
|
%bp = phi { ptr, i64 } [ { ptr @str.196, i64 4 }, %if.then.209 ], [ %callN, %if.else.210 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_CAllocator(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.225, label %if.else.226
|
|
|
|
if.then.225: ; preds = %entry
|
|
br label %if.merge.227
|
|
|
|
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.201, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.200, i64 11 }, { ptr, i64 } %callN)
|
|
br label %if.merge.227
|
|
|
|
if.merge.227: ; preds = %if.else.226, %if.then.225
|
|
%bp = phi { ptr, i64 } [ { ptr @str.199, i64 4 }, %if.then.225 ], [ %callN, %if.else.226 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__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.228, label %if.else.229
|
|
|
|
if.then.228: ; preds = %entry
|
|
br label %if.merge.230
|
|
|
|
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.204, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.203, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.230
|
|
|
|
if.merge.230: ; preds = %if.else.229, %if.then.228
|
|
%bp = phi { ptr, i64 } [ { ptr @str.202, i64 4 }, %if.then.228 ], [ %callN, %if.else.229 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_ArenaChunk(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.231, label %if.else.232
|
|
|
|
if.then.231: ; preds = %entry
|
|
br label %if.merge.233
|
|
|
|
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.207, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.206, i64 11 }, { ptr, i64 } %callN)
|
|
br label %if.merge.233
|
|
|
|
if.merge.233: ; preds = %if.else.232, %if.then.231
|
|
%bp = phi { ptr, i64 } [ { ptr @str.205, i64 4 }, %if.then.231 ], [ %callN, %if.else.232 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_Arena(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.234, label %if.else.235
|
|
|
|
if.then.234: ; preds = %entry
|
|
br label %if.merge.236
|
|
|
|
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.210, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.209, i64 6 }, { ptr, i64 } %callN)
|
|
br label %if.merge.236
|
|
|
|
if.merge.236: ; preds = %if.else.235, %if.then.234
|
|
%bp = phi { ptr, i64 } [ { ptr @str.208, i64 4 }, %if.then.234 ], [ %callN, %if.else.235 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__mptr_u8(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
|
|
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.237, label %if.else.238
|
|
|
|
if.then.237: ; preds = %entry
|
|
br label %if.merge.239
|
|
|
|
if.else.238: ; 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.213, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.212, i64 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.239
|
|
|
|
if.merge.239: ; preds = %if.else.238, %if.then.237
|
|
%bp = phi { ptr, i64 } [ { ptr @str.211, i64 4 }, %if.then.237 ], [ %callN, %if.else.238 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_BufAlloc(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.240, label %if.else.241
|
|
|
|
if.then.240: ; preds = %entry
|
|
br label %if.merge.242
|
|
|
|
if.else.241: ; 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.216, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.215, i64 9 }, { ptr, i64 } %callN)
|
|
br label %if.merge.242
|
|
|
|
if.merge.242: ; preds = %if.else.241, %if.then.240
|
|
%bp = phi { ptr, i64 } [ { ptr @str.214, i64 4 }, %if.then.240 ], [ %callN, %if.else.241 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_TrackingAllocator(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.243, label %if.else.244
|
|
|
|
if.then.243: ; preds = %entry
|
|
br label %if.merge.245
|
|
|
|
if.else.244: ; 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.219, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.218, i64 18 }, { ptr, i64 } %callN)
|
|
br label %if.merge.245
|
|
|
|
if.merge.245: ; preds = %if.else.244, %if.then.243
|
|
%bp = phi { ptr, i64 } [ { ptr @str.217, i64 4 }, %if.then.243 ], [ %callN, %if.else.244 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_ptr_CAllocator(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.246, label %if.else.247
|
|
|
|
if.then.246: ; preds = %entry
|
|
br label %if.merge.248
|
|
|
|
if.else.247: ; 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.222, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.221, i64 12 }, { ptr, i64 } %callN)
|
|
br label %if.merge.248
|
|
|
|
if.merge.248: ; preds = %if.else.247, %if.then.246
|
|
%bp = phi { ptr, i64 } [ { ptr @str.220, i64 4 }, %if.then.246 ], [ %callN, %if.else.247 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_s64(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.249, label %if.else.250
|
|
|
|
if.then.249: ; preds = %entry
|
|
br label %if.merge.251
|
|
|
|
if.else.250: ; 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.225, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.224, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.251
|
|
|
|
if.merge.251: ; preds = %if.else.250, %if.then.249
|
|
%bp = phi { ptr, i64 } [ { ptr @str.223, i64 4 }, %if.then.249 ], [ %callN, %if.else.250 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_ptr_void(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.252, label %if.else.253
|
|
|
|
if.then.252: ; preds = %entry
|
|
br label %if.merge.254
|
|
|
|
if.else.253: ; 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.228, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.227, i64 6 }, { ptr, i64 } %callN)
|
|
br label %if.merge.254
|
|
|
|
if.merge.254: ; preds = %if.else.253, %if.then.252
|
|
%bp = phi { ptr, i64 } [ { ptr @str.226, i64 4 }, %if.then.252 ], [ %callN, %if.else.253 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_s32(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.255, label %if.else.256
|
|
|
|
if.then.255: ; preds = %entry
|
|
br label %if.merge.257
|
|
|
|
if.else.256: ; 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.231, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.230, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.257
|
|
|
|
if.merge.257: ; preds = %if.else.256, %if.then.255
|
|
%bp = phi { ptr, i64 } [ { ptr @str.229, i64 4 }, %if.then.255 ], [ %callN, %if.else.256 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_error_set(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.258, label %if.else.259
|
|
|
|
if.then.258: ; preds = %entry
|
|
br label %if.merge.260
|
|
|
|
if.else.259: ; 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.234, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.233, i64 10 }, { ptr, i64 } %callN)
|
|
br label %if.merge.260
|
|
|
|
if.merge.260: ; preds = %if.else.259, %if.then.258
|
|
%bp = phi { ptr, i64 } [ { ptr @str.232, i64 4 }, %if.then.258 ], [ %callN, %if.else.259 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_string(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.261, label %if.else.262
|
|
|
|
if.then.261: ; preds = %entry
|
|
br label %if.merge.263
|
|
|
|
if.else.262: ; 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.237, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.236, i64 7 }, { ptr, i64 } %callN)
|
|
br label %if.merge.263
|
|
|
|
if.merge.263: ; preds = %if.else.262, %if.then.261
|
|
%bp = phi { ptr, i64 } [ { ptr @str.235, i64 4 }, %if.then.261 ], [ %callN, %if.else.262 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_Any(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.264, label %if.else.265
|
|
|
|
if.then.264: ; preds = %entry
|
|
br label %if.merge.266
|
|
|
|
if.else.265: ; 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.240, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.239, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.266
|
|
|
|
if.merge.266: ; preds = %if.else.265, %if.then.264
|
|
%bp = phi { ptr, i64 } [ { ptr @str.238, i64 4 }, %if.then.264 ], [ %callN, %if.else.265 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(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.267, label %if.else.268
|
|
|
|
if.then.267: ; preds = %entry
|
|
br label %if.merge.269
|
|
|
|
if.else.268: ; 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.243, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.242, i64 7 }, { ptr, i64 } %callN)
|
|
br label %if.merge.269
|
|
|
|
if.merge.269: ; preds = %if.else.268, %if.then.267
|
|
%bp = phi { ptr, i64 } [ { ptr @str.241, i64 4 }, %if.then.267 ], [ %callN, %if.else.268 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_SL_Any(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.270, label %if.else.271
|
|
|
|
if.then.270: ; preds = %entry
|
|
br label %if.merge.272
|
|
|
|
if.else.271: ; 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.246, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.245, i64 6 }, { ptr, i64 } %callN)
|
|
br label %if.merge.272
|
|
|
|
if.merge.272: ; preds = %if.else.271, %if.then.270
|
|
%bp = phi { ptr, i64 } [ { ptr @str.244, i64 4 }, %if.then.270 ], [ %callN, %if.else.271 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_u8(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.273, label %if.else.274
|
|
|
|
if.then.273: ; preds = %entry
|
|
br label %if.merge.275
|
|
|
|
if.else.274: ; 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.249, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.248, i64 3 }, { ptr, i64 } %callN)
|
|
br label %if.merge.275
|
|
|
|
if.merge.275: ; preds = %if.else.274, %if.then.273
|
|
%bp = phi { ptr, i64 } [ { ptr @str.247, i64 4 }, %if.then.273 ], [ %callN, %if.else.274 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_bool(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.276, label %if.else.277
|
|
|
|
if.then.276: ; preds = %entry
|
|
br label %if.merge.278
|
|
|
|
if.else.277: ; 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.252, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.251, i64 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.278
|
|
|
|
if.merge.278: ; preds = %if.else.277, %if.then.276
|
|
%bp = phi { ptr, i64 } [ { ptr @str.250, i64 4 }, %if.then.276 ], [ %callN, %if.else.277 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
declare i64 @write(i32, ptr, i64)
|