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).
4298 lines
197 KiB
Plaintext
4298 lines
197 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 [86 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, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false, i1 false]
|
|
@tn.str = private constant [13 x i8] c"<unresolved>\00"
|
|
@tn.str.7 = private constant [5 x i8] c"bool\00"
|
|
@tn.str.8 = private constant [3 x i8] c"s8\00"
|
|
@tn.str.9 = private constant [4 x i8] c"s16\00"
|
|
@tn.str.10 = private constant [4 x i8] c"s32\00"
|
|
@tn.str.11 = private constant [4 x i8] c"s64\00"
|
|
@tn.str.12 = private constant [3 x i8] c"u8\00"
|
|
@tn.str.13 = private constant [4 x i8] c"u16\00"
|
|
@tn.str.14 = private constant [4 x i8] c"u32\00"
|
|
@tn.str.15 = private constant [4 x i8] c"u64\00"
|
|
@tn.str.16 = private constant [4 x i8] c"f32\00"
|
|
@tn.str.17 = private constant [4 x i8] c"f64\00"
|
|
@tn.str.18 = private constant [7 x i8] c"string\00"
|
|
@tn.str.19 = private constant [4 x i8] c"Any\00"
|
|
@tn.str.20 = private constant [9 x i8] c"noreturn\00"
|
|
@tn.str.21 = private constant [6 x i8] c"isize\00"
|
|
@tn.str.22 = private constant [6 x i8] c"usize\00"
|
|
@tn.str.23 = private constant [5 x i8] c"void\00"
|
|
@tn.str.24 = private constant [6 x i8] c"*void\00"
|
|
@tn.str.25 = private constant [16 x i8] c"Source_Location\00"
|
|
@tn.str.26 = private constant [10 x i8] c"Allocator\00"
|
|
@tn.str.27 = private constant [11 x i8] c"CAllocator\00"
|
|
@tn.str.28 = private constant [12 x i8] c"*CAllocator\00"
|
|
@tn.str.29 = private constant [4 x i8] c"GPA\00"
|
|
@tn.str.30 = private constant [5 x i8] c"*GPA\00"
|
|
@tn.str.31 = private constant [11 x i8] c"ArenaChunk\00"
|
|
@tn.str.32 = private constant [12 x i8] c"*ArenaChunk\00"
|
|
@tn.str.33 = private constant [6 x i8] c"Arena\00"
|
|
@tn.str.34 = private constant [7 x i8] c"*Arena\00"
|
|
@tn.str.35 = private constant [6 x i8] c"[*]u8\00"
|
|
@tn.str.36 = private constant [9 x i8] c"BufAlloc\00"
|
|
@tn.str.37 = private constant [10 x i8] c"*BufAlloc\00"
|
|
@tn.str.38 = private constant [18 x i8] c"TrackingAllocator\00"
|
|
@tn.str.39 = private constant [19 x i8] c"*TrackingAllocator\00"
|
|
@tn.str.40 = private constant [8 x i8] c"Context\00"
|
|
@tn.str.41 = private constant [7 x i8] c"[4]s64\00"
|
|
@tn.str.42 = private constant [9 x i8] c"[]string\00"
|
|
@tn.str.43 = private constant [8 x i8] c"Greeter\00"
|
|
@tn.str.44 = private constant [18 x i8] c"__Greeter__Vtable\00"
|
|
@tn.str.45 = private constant [4 x i8] c"Dog\00"
|
|
@tn.str.46 = private constant [4 x i8] c"Cat\00"
|
|
@tn.str.47 = private constant [5 x i8] c"*Dog\00"
|
|
@tn.str.48 = private constant [5 x i8] c"*Cat\00"
|
|
@tn.str.49 = private constant [10 x i8] c"[]Greeter\00"
|
|
@tn.str.50 = private constant [13 x i8] c"**CAllocator\00"
|
|
@tn.str.51 = private constant [5 x i8] c"*s64\00"
|
|
@tn.str.52 = private constant [7 x i8] c"**void\00"
|
|
@tn.str.53 = private constant [6 x i8] c"[]Any\00"
|
|
@tn.str.54 = private constant [5 x i8] c"*Any\00"
|
|
@tn.str.55 = private constant [7 x i8] c"[2]Any\00"
|
|
@tn.str.56 = private constant [8 x i8] c"*[2]Any\00"
|
|
@tn.str.57 = private constant [7 x i8] c"*[]Any\00"
|
|
@tn.str.58 = private constant [6 x i8] c"**Dog\00"
|
|
@tn.str.59 = private constant [6 x i8] c"**Cat\00"
|
|
@tn.str.60 = private constant [8 x i8] c"*string\00"
|
|
@tn.str.61 = private constant [7 x i8] c"[1]Any\00"
|
|
@tn.str.62 = private constant [8 x i8] c"*[1]Any\00"
|
|
@tn.str.63 = private constant [4 x i8] c"*u8\00"
|
|
@tn.str.64 = private constant [6 x i8] c"*bool\00"
|
|
@tn.str.65 = private constant [8 x i8] c"*[4]s64\00"
|
|
@tn.str.66 = private constant [5 x i8] c"*f64\00"
|
|
@tn.str.67 = private constant [17 x i8] c"*Source_Location\00"
|
|
@tn.str.68 = private constant [11 x i8] c"*Allocator\00"
|
|
@tn.str.69 = private constant [9 x i8] c"*Context\00"
|
|
@tn.str.70 = private constant [9 x i8] c"*Greeter\00"
|
|
@tn.str.71 = private constant [19 x i8] c"*__Greeter__Vtable\00"
|
|
@tn.str.72 = private constant [10 x i8] c"*[]string\00"
|
|
@tn.str.73 = private constant [11 x i8] c"*[]Greeter\00"
|
|
@tn.str.74 = private constant [6 x i8] c"**GPA\00"
|
|
@tn.str.75 = private constant [13 x i8] c"**ArenaChunk\00"
|
|
@tn.str.76 = private constant [8 x i8] c"**Arena\00"
|
|
@tn.str.77 = private constant [7 x i8] c"*[*]u8\00"
|
|
@tn.str.78 = private constant [11 x i8] c"**BufAlloc\00"
|
|
@tn.str.79 = private constant [20 x i8] c"**TrackingAllocator\00"
|
|
@tn.str.80 = private constant [14 x i8] c"***CAllocator\00"
|
|
@tn.str.81 = private constant [6 x i8] c"**s64\00"
|
|
@tn.str.82 = private constant [8 x i8] c"***void\00"
|
|
@tn.str.83 = private constant [6 x i8] c"**Any\00"
|
|
@tn.str.84 = private constant [9 x i8] c"**[2]Any\00"
|
|
@tn.str.85 = private constant [8 x i8] c"**[]Any\00"
|
|
@tn.str.86 = private constant [7 x i8] c"***Dog\00"
|
|
@tn.str.87 = private constant [7 x i8] c"***Cat\00"
|
|
@tn.str.88 = private constant [9 x i8] c"**string\00"
|
|
@tn.str.89 = private constant [9 x i8] c"**[1]Any\00"
|
|
@tn.str.90 = private constant [5 x i8] c"**u8\00"
|
|
@tn.str.91 = private constant [7 x i8] c"**bool\00"
|
|
@__sx_type_names = private constant [86 x { ptr, i64 }] [{ ptr, i64 } { ptr @tn.str, i64 12 }, { ptr, i64 } { ptr @tn.str.7, i64 4 }, { ptr, i64 } { ptr @tn.str.8, i64 2 }, { ptr, i64 } { ptr @tn.str.9, i64 3 }, { ptr, i64 } { ptr @tn.str.10, i64 3 }, { ptr, i64 } { ptr @tn.str.11, i64 3 }, { ptr, i64 } { ptr @tn.str.12, i64 2 }, { ptr, i64 } { ptr @tn.str.13, i64 3 }, { ptr, i64 } { ptr @tn.str.14, i64 3 }, { 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 6 }, { ptr, i64 } { ptr @tn.str.19, i64 3 }, { ptr, i64 } { ptr @tn.str.20, i64 8 }, { ptr, i64 } { ptr @tn.str.21, i64 5 }, { ptr, i64 } { ptr @tn.str.22, i64 5 }, { ptr, i64 } { ptr @tn.str.23, i64 4 }, { ptr, i64 } { ptr @tn.str.24, i64 5 }, { ptr, i64 } { ptr @tn.str.25, i64 15 }, { ptr, i64 } { ptr @tn.str.26, i64 9 }, { ptr, i64 } { ptr @tn.str.27, i64 10 }, { ptr, i64 } { ptr @tn.str.28, i64 11 }, { ptr, i64 } { ptr @tn.str.29, i64 3 }, { ptr, i64 } { ptr @tn.str.30, i64 4 }, { ptr, i64 } { ptr @tn.str.31, i64 10 }, { ptr, i64 } { ptr @tn.str.32, i64 11 }, { ptr, i64 } { ptr @tn.str.33, i64 5 }, { ptr, i64 } { ptr @tn.str.34, i64 6 }, { ptr, i64 } { ptr @tn.str.35, i64 5 }, { ptr, i64 } { ptr @tn.str.36, i64 8 }, { ptr, i64 } { ptr @tn.str.37, i64 9 }, { ptr, i64 } { ptr @tn.str.38, i64 17 }, { ptr, i64 } { ptr @tn.str.39, i64 18 }, { ptr, i64 } { ptr @tn.str.40, i64 7 }, { ptr, i64 } { ptr @tn.str.41, i64 6 }, { ptr, i64 } { ptr @tn.str.42, i64 8 }, { ptr, i64 } { ptr @tn.str.43, i64 7 }, { ptr, i64 } { ptr @tn.str.44, i64 17 }, { ptr, i64 } { ptr @tn.str.45, i64 3 }, { ptr, i64 } { ptr @tn.str.46, i64 3 }, { ptr, i64 } { ptr @tn.str.47, i64 4 }, { ptr, i64 } { ptr @tn.str.48, i64 4 }, { ptr, i64 } { ptr @tn.str.49, i64 9 }, { ptr, i64 } { ptr @tn.str.50, i64 12 }, { ptr, i64 } { ptr @tn.str.51, i64 4 }, { ptr, i64 } { ptr @tn.str.52, i64 6 }, { ptr, i64 } { ptr @tn.str.53, i64 5 }, { ptr, i64 } { ptr @tn.str.54, i64 4 }, { ptr, i64 } { ptr @tn.str.55, i64 6 }, { ptr, i64 } { ptr @tn.str.56, i64 7 }, { ptr, i64 } { ptr @tn.str.57, i64 6 }, { ptr, i64 } { ptr @tn.str.58, i64 5 }, { ptr, i64 } { ptr @tn.str.59, i64 5 }, { ptr, i64 } { ptr @tn.str.60, i64 7 }, { ptr, i64 } { ptr @tn.str.61, i64 6 }, { ptr, i64 } { ptr @tn.str.62, i64 7 }, { ptr, i64 } { ptr @tn.str.63, i64 3 }, { ptr, i64 } { ptr @tn.str.64, i64 5 }, { ptr, i64 } { ptr @tn.str.65, i64 7 }, { ptr, i64 } { ptr @tn.str.66, i64 4 }, { ptr, i64 } { ptr @tn.str.67, i64 16 }, { ptr, i64 } { ptr @tn.str.68, i64 10 }, { ptr, i64 } { ptr @tn.str.69, i64 8 }, { ptr, i64 } { ptr @tn.str.70, i64 8 }, { ptr, i64 } { ptr @tn.str.71, i64 18 }, { ptr, i64 } { ptr @tn.str.72, i64 9 }, { ptr, i64 } { ptr @tn.str.73, i64 10 }, { ptr, i64 } { ptr @tn.str.74, i64 5 }, { ptr, i64 } { ptr @tn.str.75, i64 12 }, { ptr, i64 } { ptr @tn.str.76, i64 7 }, { ptr, i64 } { ptr @tn.str.77, i64 6 }, { ptr, i64 } { ptr @tn.str.78, i64 10 }, { ptr, i64 } { ptr @tn.str.79, i64 19 }, { ptr, i64 } { ptr @tn.str.80, i64 13 }, { ptr, i64 } { ptr @tn.str.81, i64 5 }, { ptr, i64 } { ptr @tn.str.82, i64 7 }, { ptr, i64 } { ptr @tn.str.83, i64 5 }, { ptr, i64 } { ptr @tn.str.84, i64 8 }, { ptr, i64 } { ptr @tn.str.85, i64 7 }, { ptr, i64 } { ptr @tn.str.86, i64 6 }, { ptr, i64 } { ptr @tn.str.87, i64 6 }, { ptr, i64 } { ptr @tn.str.88, i64 8 }, { ptr, i64 } { ptr @tn.str.89, i64 8 }, { ptr, i64 } { ptr @tn.str.90, i64 4 }, { ptr, i64 } { ptr @tn.str.91, i64 6 }]
|
|
@str.92 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.93 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.94 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.95 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.96 = private unnamed_addr constant [15 x i8] c"result := \22\22; \00", align 1
|
|
@str.97 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.98 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.99 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@str.100 = private unnamed_addr constant [44 x i8] c"result = concat(result, any_to_string(args[\00", align 1
|
|
@str.101 = private unnamed_addr constant [6 x i8] c"])); \00", align 1
|
|
@str.102 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.103 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.104 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@str.105 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.106 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.107 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@str.108 = private unnamed_addr constant [37 x i8] c"result = concat(result, substr(fmt, \00", align 1
|
|
@str.109 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.110 = private unnamed_addr constant [5 x i8] c")); \00", align 1
|
|
@str.111 = private unnamed_addr constant [12 x i8] c"dog+cat={}\0A\00", align 1
|
|
@str.112 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.113 = private unnamed_addr constant [12 x i8] c"dog+cat={}\0A\00", align 1
|
|
@str.114 = private unnamed_addr constant [12 x i8] c"cat+dog={}\0A\00", align 1
|
|
@str.115 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.116 = private unnamed_addr constant [12 x i8] c"cat+dog={}\0A\00", align 1
|
|
@str.117 = private unnamed_addr constant [12 x i8] c"dog+dog={}\0A\00", align 1
|
|
@str.118 = private unnamed_addr constant [1 x i8] zeroinitializer, align 1
|
|
@str.119 = private unnamed_addr constant [12 x i8] c"dog+dog={}\0A\00", align 1
|
|
@str.120 = private unnamed_addr constant [16 x i8] c"Source_Location\00", align 1
|
|
@str.121 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.122 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.123 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str = private constant [5 x i8] c"file\00"
|
|
@fld.str.124 = private constant [5 x i8] c"line\00"
|
|
@fld.str.125 = private constant [4 x i8] c"col\00"
|
|
@fld.str.126 = 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.124, i64 4 }, { ptr, i64 } { ptr @fld.str.125, i64 3 }, { ptr, i64 } { ptr @fld.str.126, i64 4 }]
|
|
@str.127 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.128 = private unnamed_addr constant [10 x i8] c"Allocator\00", align 1
|
|
@str.129 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.130 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.131 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.132 = private constant [4 x i8] c"ctx\00"
|
|
@fld.str.133 = private constant [6 x i8] c"alloc\00"
|
|
@fld.str.134 = private constant [8 x i8] c"dealloc\00"
|
|
@field_names.135 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.132, i64 3 }, { ptr, i64 } { ptr @fld.str.133, i64 5 }, { ptr, i64 } { ptr @fld.str.134, i64 7 }]
|
|
@str.136 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.137 = private unnamed_addr constant [11 x i8] c"CAllocator\00", align 1
|
|
@str.138 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.139 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.140 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@field_names.141 = private constant [0 x { ptr, i64 }] zeroinitializer
|
|
@str.142 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.143 = private unnamed_addr constant [4 x i8] c"GPA\00", align 1
|
|
@str.144 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.145 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.146 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.147 = private constant [12 x i8] c"alloc_count\00"
|
|
@field_names.148 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.147, i64 11 }]
|
|
@str.149 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.150 = private unnamed_addr constant [11 x i8] c"ArenaChunk\00", align 1
|
|
@str.151 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.152 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.153 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.154 = private constant [5 x i8] c"next\00"
|
|
@fld.str.155 = private constant [4 x i8] c"cap\00"
|
|
@field_names.156 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.154, i64 4 }, { ptr, i64 } { ptr @fld.str.155, i64 3 }]
|
|
@str.157 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.158 = private unnamed_addr constant [6 x i8] c"Arena\00", align 1
|
|
@str.159 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.160 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.161 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.162 = private constant [6 x i8] c"first\00"
|
|
@fld.str.163 = private constant [10 x i8] c"end_index\00"
|
|
@fld.str.164 = private constant [7 x i8] c"parent\00"
|
|
@field_names.165 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.162, i64 5 }, { ptr, i64 } { ptr @fld.str.163, i64 9 }, { ptr, i64 } { ptr @fld.str.164, i64 6 }]
|
|
@str.166 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.167 = private unnamed_addr constant [9 x i8] c"BufAlloc\00", align 1
|
|
@str.168 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.169 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.170 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.171 = private constant [4 x i8] c"buf\00"
|
|
@fld.str.172 = private constant [4 x i8] c"len\00"
|
|
@fld.str.173 = private constant [4 x i8] c"pos\00"
|
|
@field_names.174 = private constant [3 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.171, i64 3 }, { ptr, i64 } { ptr @fld.str.172, i64 3 }, { ptr, i64 } { ptr @fld.str.173, i64 3 }]
|
|
@str.175 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.176 = private unnamed_addr constant [18 x i8] c"TrackingAllocator\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 [7 x i8] c"parent\00"
|
|
@fld.str.181 = private constant [12 x i8] c"alloc_count\00"
|
|
@fld.str.182 = private constant [14 x i8] c"dealloc_count\00"
|
|
@fld.str.183 = private constant [18 x i8] c"total_alloc_bytes\00"
|
|
@field_names.184 = private constant [4 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.180, i64 6 }, { ptr, i64 } { ptr @fld.str.181, i64 11 }, { ptr, i64 } { ptr @fld.str.182, i64 13 }, { ptr, i64 } { ptr @fld.str.183, i64 17 }]
|
|
@str.185 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.186 = private unnamed_addr constant [8 x i8] c"Context\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
|
|
@fld.str.190 = private constant [10 x i8] c"allocator\00"
|
|
@fld.str.191 = private constant [5 x i8] c"data\00"
|
|
@field_names.192 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.190, i64 9 }, { ptr, i64 } { ptr @fld.str.191, i64 4 }]
|
|
@str.193 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.194 = private unnamed_addr constant [8 x i8] c"Greeter\00", align 1
|
|
@str.195 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.196 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.197 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.198 = private constant [4 x i8] c"ctx\00"
|
|
@fld.str.199 = private constant [9 x i8] c"__vtable\00"
|
|
@field_names.200 = private constant [2 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.198, i64 3 }, { ptr, i64 } { ptr @fld.str.199, i64 8 }]
|
|
@str.201 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.202 = private unnamed_addr constant [18 x i8] c"__Greeter__Vtable\00", align 1
|
|
@str.203 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.204 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.205 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.206 = private constant [6 x i8] c"greet\00"
|
|
@field_names.207 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.206, i64 5 }]
|
|
@str.208 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.209 = private unnamed_addr constant [4 x i8] c"Dog\00", align 1
|
|
@str.210 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.211 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.212 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.213 = private constant [4 x i8] c"age\00"
|
|
@field_names.214 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.213, i64 3 }]
|
|
@str.215 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.216 = private unnamed_addr constant [4 x i8] c"Cat\00", align 1
|
|
@str.217 = private unnamed_addr constant [2 x i8] c"{\00", align 1
|
|
@str.218 = private unnamed_addr constant [2 x i8] c"}\00", align 1
|
|
@str.219 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@fld.str.220 = private constant [6 x i8] c"lives\00"
|
|
@field_names.221 = private constant [1 x { ptr, i64 }] [{ ptr, i64 } { ptr @fld.str.220, i64 5 }]
|
|
@str.222 = private unnamed_addr constant [3 x i8] c": \00", align 1
|
|
@str.223 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.224 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.225 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.226 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.227 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.228 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.229 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.230 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.231 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.232 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.233 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.234 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.235 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.236 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.237 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.238 = private unnamed_addr constant [2 x i8] c"[\00", align 1
|
|
@str.239 = private unnamed_addr constant [2 x i8] c"]\00", align 1
|
|
@str.240 = private unnamed_addr constant [3 x i8] c", \00", align 1
|
|
@str.241 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.242 = private unnamed_addr constant [6 x i8] c"*void\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 [12 x i8] c"*CAllocator\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 [5 x i8] c"*GPA\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 [12 x i8] c"*ArenaChunk\00", align 1
|
|
@str.252 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.253 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.254 = private unnamed_addr constant [7 x i8] c"*Arena\00", align 1
|
|
@str.255 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.256 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.257 = private unnamed_addr constant [6 x i8] c"[*]u8\00", align 1
|
|
@str.258 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.259 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.260 = private unnamed_addr constant [10 x i8] c"*BufAlloc\00", align 1
|
|
@str.261 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.262 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.263 = private unnamed_addr constant [19 x i8] c"*TrackingAllocator\00", align 1
|
|
@str.264 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.265 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.266 = private unnamed_addr constant [5 x i8] c"*Dog\00", align 1
|
|
@str.267 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.268 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.269 = private unnamed_addr constant [5 x i8] c"*Cat\00", align 1
|
|
@str.270 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.271 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.272 = private unnamed_addr constant [13 x i8] c"**CAllocator\00", align 1
|
|
@str.273 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.274 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.275 = private unnamed_addr constant [5 x i8] c"*s64\00", align 1
|
|
@str.276 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.277 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.278 = private unnamed_addr constant [7 x i8] c"**void\00", align 1
|
|
@str.279 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.280 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.281 = private unnamed_addr constant [5 x i8] c"*Any\00", align 1
|
|
@str.282 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.283 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.284 = private unnamed_addr constant [8 x i8] c"*[2]Any\00", align 1
|
|
@str.285 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.286 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.287 = private unnamed_addr constant [7 x i8] c"*[]Any\00", align 1
|
|
@str.288 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.289 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.290 = private unnamed_addr constant [6 x i8] c"**Dog\00", align 1
|
|
@str.291 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.292 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.293 = private unnamed_addr constant [6 x i8] c"**Cat\00", align 1
|
|
@str.294 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.295 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.296 = private unnamed_addr constant [8 x i8] c"*string\00", align 1
|
|
@str.297 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.298 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.299 = private unnamed_addr constant [8 x i8] c"*[1]Any\00", align 1
|
|
@str.300 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.301 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.302 = private unnamed_addr constant [4 x i8] c"*u8\00", align 1
|
|
@str.303 = private unnamed_addr constant [4 x i8] c"@0x\00", align 1
|
|
@str.304 = private unnamed_addr constant [5 x i8] c"null\00", align 1
|
|
@str.305 = private unnamed_addr constant [6 x i8] c"*bool\00", align 1
|
|
@str.306 = 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.14, label %if.merge.15
|
|
|
|
if.then.14: ; preds = %entry
|
|
ret { ptr, i64 } { ptr @str, i64 1 }
|
|
|
|
if.merge.15: ; 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.16
|
|
|
|
while.hdr.16: ; preds = %if.merge.20, %if.merge.15
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp ne i64 %loadN, 0
|
|
br i1 %icmpN, label %while.body.17, label %while.exit.18
|
|
|
|
while.body.17: ; preds = %while.hdr.16
|
|
%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.19, label %if.merge.20
|
|
|
|
while.exit.18: ; preds = %while.hdr.16
|
|
%loadN = load i1, ptr %allocaN, align 1
|
|
br i1 %loadN, label %if.then.21, label %if.merge.22
|
|
|
|
if.then.19: ; preds = %while.body.17
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 0, %loadN
|
|
store i64 %sub, ptr %allocaN, align 8
|
|
br label %if.merge.20
|
|
|
|
if.merge.20: ; preds = %if.then.19, %while.body.17
|
|
%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.16
|
|
|
|
if.then.21: ; preds = %while.exit.18
|
|
%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.22
|
|
|
|
if.merge.22: ; preds = %if.then.21, %while.exit.18
|
|
%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.56, label %if.merge.57
|
|
|
|
if.then.56: ; preds = %entry
|
|
ret { ptr, i64 } { ptr @str.1, i64 1 }
|
|
|
|
if.merge.57: ; 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.66
|
|
|
|
while.hdr.66: ; preds = %while.exit.77, %if.merge.57
|
|
%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.70, label %or.rhs.69
|
|
|
|
while.body.67: ; preds = %or.merge.74
|
|
store i64 0, ptr %allocaN, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.75
|
|
|
|
while.exit.68: ; preds = %or.merge.74
|
|
%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.69: ; preds = %while.hdr.66
|
|
%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.70
|
|
|
|
or.merge.70: ; preds = %or.rhs.69, %while.hdr.66
|
|
%bp = phi i1 [ true, %while.hdr.66 ], [ %icmpN, %or.rhs.69 ]
|
|
br i1 %bp, label %or.merge.72, label %or.rhs.71
|
|
|
|
or.rhs.71: ; preds = %or.merge.70
|
|
%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.72
|
|
|
|
or.merge.72: ; preds = %or.rhs.71, %or.merge.70
|
|
%bpN = phi i1 [ true, %or.merge.70 ], [ %icmpN, %or.rhs.71 ]
|
|
br i1 %bpN, label %or.merge.74, label %or.rhs.73
|
|
|
|
or.rhs.73: ; preds = %or.merge.72
|
|
%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.74
|
|
|
|
or.merge.74: ; preds = %or.rhs.73, %or.merge.72
|
|
%bpN = phi i1 [ true, %or.merge.72 ], [ %icmpN, %or.rhs.73 ]
|
|
br i1 %bpN, label %while.body.67, label %while.exit.68
|
|
|
|
while.hdr.75: ; preds = %while.body.76, %while.body.67
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp slt i64 %loadN, 4
|
|
br i1 %icmpN, label %while.body.76, label %while.exit.77
|
|
|
|
while.body.76: ; preds = %while.hdr.75
|
|
%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.75
|
|
|
|
while.exit.77: ; preds = %while.hdr.75
|
|
%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.66
|
|
}
|
|
|
|
; 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.78, label %if.else.79
|
|
|
|
if.then.78: ; preds = %entry
|
|
br label %if.merge.80
|
|
|
|
if.else.79: ; preds = %entry
|
|
br label %if.merge.80
|
|
|
|
if.merge.80: ; preds = %if.else.79, %if.then.78
|
|
%bp = phi { ptr, i64 } [ { ptr @str.2, i64 4 }, %if.then.78 ], [ { ptr @str.3, i64 5 }, %if.else.79 ]
|
|
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.84, label %if.else.85
|
|
|
|
if.then.84: ; preds = %entry
|
|
%loadN = load double, ptr %alloca, align 8
|
|
%fsub = fsub double 0.000000e+00, %loadN
|
|
br label %if.merge.86
|
|
|
|
if.else.85: ; preds = %entry
|
|
%loadN = load double, ptr %alloca, align 8
|
|
br label %if.merge.86
|
|
|
|
if.merge.86: ; preds = %if.else.85, %if.then.84
|
|
%bp = phi double [ %fsub, %if.then.84 ], [ %loadN, %if.else.85 ]
|
|
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.87, label %if.merge.88
|
|
|
|
if.then.87: ; preds = %if.merge.86
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 0, %loadN
|
|
store i64 %sub, ptr %allocaN, align 8
|
|
br label %if.merge.88
|
|
|
|
if.merge.88: ; preds = %if.then.87, %if.merge.86
|
|
%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.89, label %if.else.90
|
|
|
|
if.then.89: ; preds = %if.merge.88
|
|
br label %if.merge.91
|
|
|
|
if.else.90: ; preds = %if.merge.88
|
|
br label %if.merge.91
|
|
|
|
if.merge.91: ; preds = %if.else.90, %if.then.89
|
|
%bpN = phi i64 [ 1, %if.then.89 ], [ 0, %if.else.90 ]
|
|
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.92, label %if.merge.93
|
|
|
|
if.then.92: ; preds = %if.merge.91
|
|
%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.93
|
|
|
|
if.merge.93: ; preds = %if.then.92, %if.merge.91
|
|
%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.243
|
|
|
|
while.hdr.243: ; preds = %if.merge.248, %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.244, label %while.exit.245
|
|
|
|
while.body.244: ; preds = %while.hdr.243
|
|
%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.246, label %if.else.247
|
|
|
|
while.exit.245: ; preds = %while.hdr.243
|
|
ret void
|
|
|
|
if.then.246: ; preds = %while.body.244
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 48
|
|
br label %if.merge.248
|
|
|
|
if.else.247: ; preds = %while.body.244
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%sub = sub i64 %loadN, 10
|
|
%addN = add i64 %sub, 97
|
|
br label %if.merge.248
|
|
|
|
if.merge.248: ; preds = %if.else.247, %if.then.246
|
|
%bp = phi i64 [ %addN, %if.then.246 ], [ %addN, %if.else.247 ]
|
|
%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.243
|
|
}
|
|
|
|
; 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.58, label %if.merge.59
|
|
|
|
if.then.58: ; 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.59
|
|
|
|
if.merge.59: ; preds = %if.then.58, %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.60, label %if.merge.61
|
|
|
|
if.then.60: ; preds = %if.merge.59
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 65536
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.61
|
|
|
|
if.merge.61: ; preds = %if.then.60, %if.merge.59
|
|
%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.62, label %if.merge.63
|
|
|
|
if.then.62: ; preds = %if.merge.61
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 65536
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.63
|
|
|
|
if.merge.63: ; preds = %if.then.62, %if.merge.61
|
|
%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.64, label %if.merge.65
|
|
|
|
if.then.64: ; preds = %if.merge.63
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 65536
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.65
|
|
|
|
if.merge.65: ; preds = %if.then.64, %if.merge.63
|
|
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.241, label %if.merge.242
|
|
|
|
if.then.241: ; preds = %entry
|
|
ret { ptr, i64 } { ptr @str.4, i64 1 }
|
|
|
|
if.merge.242: ; 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.249
|
|
|
|
while.hdr.249: ; preds = %if.merge.253, %if.merge.242
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp slt i64 %loadN, 15
|
|
br i1 %icmpN, label %while.body.250, label %while.exit.251
|
|
|
|
while.body.250: ; preds = %while.hdr.249
|
|
%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.252, label %if.merge.253
|
|
|
|
while.exit.251: ; preds = %if.then.252, %while.hdr.249
|
|
%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.252: ; preds = %while.body.250
|
|
br label %while.exit.251
|
|
|
|
if.merge.253: ; preds = %while.body.250
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%add = add i64 %loadN, 1
|
|
store i64 %add, ptr %allocaN, align 8
|
|
br label %while.hdr.249
|
|
}
|
|
|
|
; 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 { 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.52 [
|
|
i64 17, label %match.arm.38
|
|
i64 2, label %match.arm.39
|
|
i64 3, label %match.arm.39
|
|
i64 4, label %match.arm.39
|
|
i64 5, label %match.arm.39
|
|
i64 6, label %match.arm.39
|
|
i64 7, label %match.arm.39
|
|
i64 8, label %match.arm.39
|
|
i64 9, label %match.arm.39
|
|
i64 16, label %match.arm.39
|
|
i64 15, label %match.arm.39
|
|
i64 12, label %match.arm.40
|
|
i64 1, label %match.arm.41
|
|
i64 10, label %match.arm.42
|
|
i64 11, label %match.arm.42
|
|
i64 19, label %match.arm.43
|
|
i64 20, label %match.arm.43
|
|
i64 21, label %match.arm.43
|
|
i64 23, label %match.arm.43
|
|
i64 25, label %match.arm.43
|
|
i64 27, label %match.arm.43
|
|
i64 30, label %match.arm.43
|
|
i64 32, label %match.arm.43
|
|
i64 34, label %match.arm.43
|
|
i64 37, label %match.arm.43
|
|
i64 38, label %match.arm.43
|
|
i64 39, label %match.arm.43
|
|
i64 40, label %match.arm.43
|
|
i64 35, label %match.arm.47
|
|
i64 49, label %match.arm.47
|
|
i64 55, label %match.arm.47
|
|
i64 36, label %match.arm.48
|
|
i64 43, label %match.arm.48
|
|
i64 47, label %match.arm.48
|
|
i64 18, label %match.arm.49
|
|
i64 22, label %match.arm.49
|
|
i64 24, label %match.arm.49
|
|
i64 26, label %match.arm.49
|
|
i64 28, label %match.arm.49
|
|
i64 29, label %match.arm.49
|
|
i64 31, label %match.arm.49
|
|
i64 33, label %match.arm.49
|
|
i64 41, label %match.arm.49
|
|
i64 42, label %match.arm.49
|
|
i64 44, label %match.arm.49
|
|
i64 45, label %match.arm.49
|
|
i64 46, label %match.arm.49
|
|
i64 48, label %match.arm.49
|
|
i64 50, label %match.arm.49
|
|
i64 51, label %match.arm.49
|
|
i64 52, label %match.arm.49
|
|
i64 53, label %match.arm.49
|
|
i64 54, label %match.arm.49
|
|
i64 56, label %match.arm.49
|
|
i64 57, label %match.arm.49
|
|
i64 58, label %match.arm.49
|
|
i64 13, label %match.arm.51
|
|
]
|
|
|
|
match.merge.37: ; preds = %dispatch.merge.214, %dispatch.merge.194, %dispatch.merge.174, %dispatch.merge.94, %float.merge.83, %if.merge.55, %match.unr.52, %match.arm.51, %match.arm.41, %match.arm.40, %match.arm.38
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
|
|
match.arm.38: ; preds = %entry
|
|
store { ptr, i64 } { ptr @str.6, i64 0 }, ptr %allocaN, align 8
|
|
br label %match.merge.37
|
|
|
|
match.arm.39: ; 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 [86 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.53, label %if.else.54
|
|
|
|
match.arm.40: ; 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.37
|
|
|
|
match.arm.41: ; 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.37
|
|
|
|
match.arm.42: ; 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.81, label %fN.unbox.82
|
|
|
|
match.arm.43: ; preds = %entry, %entry, %entry, %entry, %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.95 [
|
|
i64 19, label %dispatch.case.96
|
|
i64 20, label %dispatch.case.97
|
|
i64 21, label %dispatch.case.98
|
|
i64 23, label %dispatch.case.99
|
|
i64 25, label %dispatch.case.100
|
|
i64 27, label %dispatch.case.101
|
|
i64 30, label %dispatch.case.102
|
|
i64 32, label %dispatch.case.103
|
|
i64 34, label %dispatch.case.104
|
|
i64 37, label %dispatch.case.105
|
|
i64 38, label %dispatch.case.106
|
|
i64 39, label %dispatch.case.107
|
|
i64 40, label %dispatch.case.108
|
|
]
|
|
|
|
match.arm.44: ; No predecessors!
|
|
unreachable
|
|
|
|
match.arm.45: ; No predecessors!
|
|
unreachable
|
|
|
|
match.arm.46: ; No predecessors!
|
|
unreachable
|
|
|
|
match.arm.47: ; preds = %entry, %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%ua.raw20 = extractvalue { i64, i64 } %loadN, 1
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
switch i64 %ua.raw20, label %dispatch.default.175 [
|
|
i64 35, label %dispatch.case.176
|
|
i64 49, label %dispatch.case.177
|
|
i64 55, label %dispatch.case.178
|
|
]
|
|
|
|
match.arm.48: ; preds = %entry, %entry, %entry
|
|
%loadN = load { i64, i64 }, ptr %allocaN, align 8
|
|
%ua.raw24 = extractvalue { i64, i64 } %loadN, 1
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
switch i64 %ua.raw24, label %dispatch.default.195 [
|
|
i64 36, label %dispatch.case.196
|
|
i64 43, label %dispatch.case.197
|
|
i64 47, label %dispatch.case.198
|
|
]
|
|
|
|
match.arm.49: ; preds = %entry, %entry, %entry, %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.raw28 = extractvalue { i64, i64 } %loadN, 1
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
switch i64 %ua.raw28, label %dispatch.default.215 [
|
|
i64 18, label %dispatch.case.216
|
|
i64 22, label %dispatch.case.217
|
|
i64 24, label %dispatch.case.218
|
|
i64 26, label %dispatch.case.219
|
|
i64 28, label %dispatch.case.220
|
|
i64 29, label %dispatch.case.221
|
|
i64 31, label %dispatch.case.222
|
|
i64 33, label %dispatch.case.223
|
|
i64 41, label %dispatch.case.224
|
|
i64 42, label %dispatch.case.225
|
|
i64 44, label %dispatch.case.226
|
|
i64 45, label %dispatch.case.227
|
|
i64 46, label %dispatch.case.228
|
|
i64 48, label %dispatch.case.229
|
|
i64 50, label %dispatch.case.230
|
|
i64 51, label %dispatch.case.231
|
|
i64 52, label %dispatch.case.232
|
|
i64 53, label %dispatch.case.233
|
|
i64 54, label %dispatch.case.234
|
|
i64 56, label %dispatch.case.235
|
|
i64 57, label %dispatch.case.236
|
|
i64 58, label %dispatch.case.237
|
|
]
|
|
|
|
match.arm.50: ; No predecessors!
|
|
unreachable
|
|
|
|
match.arm.51: ; preds = %entry
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%refl.tag32 = extractvalue { i64, i64 } %loadN, 0
|
|
%refl.val33 = extractvalue { i64, i64 } %loadN, 1
|
|
%refl.istype34 = icmp eq i64 %refl.tag32, 13
|
|
%refl.tid35 = select i1 %refl.istype34, i64 %refl.val33, i64 %refl.tag32
|
|
%tn.gep = getelementptr inbounds [86 x { ptr, i64 }], ptr @__sx_type_names, i64 0, i64 %refl.tid35
|
|
%tn.load = load { ptr, i64 }, ptr %tn.gep, align 8
|
|
store { ptr, i64 } %tn.load, ptr %allocaN, align 8
|
|
br label %match.merge.37
|
|
|
|
match.unr.52: ; preds = %entry
|
|
br label %match.merge.37
|
|
|
|
if.then.53: ; preds = %match.arm.39
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%ua.raw37 = extractvalue { i64, i64 } %loadN, 1
|
|
%callN = call { ptr, i64 } @uint_to_string(ptr %0, i64 %ua.raw37)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.55
|
|
|
|
if.else.54: ; preds = %match.arm.39
|
|
%loadN = load { i64, i64 }, ptr %alloca, align 8
|
|
%ua.raw40 = extractvalue { i64, i64 } %loadN, 1
|
|
%callN = call { ptr, i64 } @int_to_string(ptr %0, i64 %ua.raw40)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.55
|
|
|
|
if.merge.55: ; preds = %if.else.54, %if.then.53
|
|
br label %match.merge.37
|
|
|
|
f32.unbox.81: ; preds = %match.arm.42
|
|
%ua.raw42 = extractvalue { i64, i64 } %loadN, 1
|
|
%trN = trunc i64 %ua.raw42 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.83
|
|
|
|
f64.unbox.82: ; preds = %match.arm.42
|
|
%ua.raw43 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNd = bitcast i64 %ua.raw43 to double
|
|
store double %iNd, ptr %allocaN, align 8
|
|
br label %float.merge.83
|
|
|
|
float.merge.83: ; preds = %fN.unbox.82, %fN.unbox.81
|
|
%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.37
|
|
|
|
dispatch.merge.94: ; preds = %dispatch.case.108, %dispatch.case.107, %dispatch.case.106, %dispatch.case.105, %dispatch.case.104, %dispatch.case.103, %dispatch.case.102, %dispatch.case.101, %dispatch.case.100, %dispatch.case.99, %dispatch.case.98, %dispatch.case.97, %dispatch.case.96, %dispatch.default.95
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.37
|
|
|
|
dispatch.default.95: ; preds = %match.arm.43
|
|
store { ptr, i64 } { ptr @str.92, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.96: ; preds = %match.arm.43
|
|
%ua.raw47 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr48 = inttoptr i64 %ua.raw47 to ptr
|
|
%ua.load49 = load { { ptr, i64 }, i32, i32, { ptr, i64 } }, ptr %ua.ptr48, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Source_Location(ptr %0, { { ptr, i64 }, i32, i32, { ptr, i64 } } %ua.load49)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.97: ; preds = %match.arm.43
|
|
%ua.raw51 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr52 = inttoptr i64 %ua.raw51 to ptr
|
|
%ua.load53 = load { ptr, ptr, ptr }, ptr %ua.ptr52, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Allocator(ptr %0, { ptr, ptr, ptr } %ua.load53)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.98: ; preds = %match.arm.43
|
|
%ua.raw55 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr56 = inttoptr i64 %ua.raw55 to ptr
|
|
%ua.load57 = load {}, ptr %ua.ptr56, align 1
|
|
%callN = call { ptr, i64 } @struct_to_string__CAllocator(ptr %0, {} %ua.load57)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.99: ; preds = %match.arm.43
|
|
%ua.raw59 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr60 = inttoptr i64 %ua.raw59 to ptr
|
|
%ua.load61 = load { i64 }, ptr %ua.ptr60, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__GPA(ptr %0, { i64 } %ua.load61)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.100: ; preds = %match.arm.43
|
|
%ua.raw63 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr64 = inttoptr i64 %ua.raw63 to ptr
|
|
%ua.load65 = load { ptr, i64 }, ptr %ua.ptr64, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__ArenaChunk(ptr %0, { ptr, i64 } %ua.load65)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.101: ; preds = %match.arm.43
|
|
%ua.raw67 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr68 = inttoptr i64 %ua.raw67 to ptr
|
|
%ua.load69 = load { ptr, i64, { ptr, ptr, ptr } }, ptr %ua.ptr68, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Arena(ptr %0, { ptr, i64, { ptr, ptr, ptr } } %ua.load69)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.102: ; preds = %match.arm.43
|
|
%ua.raw71 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr72 = inttoptr i64 %ua.raw71 to ptr
|
|
%ua.load73 = load { ptr, i64, i64 }, ptr %ua.ptr72, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__BufAlloc(ptr %0, { ptr, i64, i64 } %ua.load73)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.103: ; preds = %match.arm.43
|
|
%ua.raw75 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr76 = inttoptr i64 %ua.raw75 to ptr
|
|
%ua.load77 = load { { ptr, ptr, ptr }, i64, i64, i64 }, ptr %ua.ptr76, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__TrackingAllocator(ptr %0, { { ptr, ptr, ptr }, i64, i64, i64 } %ua.load77)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.104: ; preds = %match.arm.43
|
|
%ua.raw79 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr80 = inttoptr i64 %ua.raw79 to ptr
|
|
%ua.load81 = load { { ptr, ptr, ptr }, ptr }, ptr %ua.ptr80, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Context(ptr %0, { { ptr, ptr, ptr }, ptr } %ua.load81)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.105: ; preds = %match.arm.43
|
|
%ua.raw83 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr84 = inttoptr i64 %ua.raw83 to ptr
|
|
%ua.load85 = load { ptr, ptr }, ptr %ua.ptr84, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Greeter(ptr %0, { ptr, ptr } %ua.load85)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.106: ; preds = %match.arm.43
|
|
%ua.raw87 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr88 = inttoptr i64 %ua.raw87 to ptr
|
|
%ua.load89 = load { ptr }, ptr %ua.ptr88, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string____Greeter__Vtable(ptr %0, { ptr } %ua.load89)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.107: ; preds = %match.arm.43
|
|
%ua.raw91 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr92 = inttoptr i64 %ua.raw91 to ptr
|
|
%ua.load93 = load { i64 }, ptr %ua.ptr92, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Dog(ptr %0, { i64 } %ua.load93)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.case.108: ; preds = %match.arm.43
|
|
%ua.raw95 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr96 = inttoptr i64 %ua.raw95 to ptr
|
|
%ua.load97 = load { i64 }, ptr %ua.ptr96, align 8
|
|
%callN = call { ptr, i64 } @struct_to_string__Cat(ptr %0, { i64 } %ua.load97)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.94
|
|
|
|
dispatch.merge.174: ; preds = %dispatch.case.178, %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.37
|
|
|
|
dispatch.default.175: ; preds = %match.arm.47
|
|
store { ptr, i64 } { ptr @str.93, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.174
|
|
|
|
dispatch.case.176: ; preds = %match.arm.47
|
|
%ua.raw100 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr101 = inttoptr i64 %ua.raw100 to ptr
|
|
%ua.load102 = load [4 x i64], ptr %ua.ptr101, align 8
|
|
%callN = call { ptr, i64 } @array_to_string__AR_4_s64(ptr %0, [4 x i64] %ua.load102)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.174
|
|
|
|
dispatch.case.177: ; preds = %match.arm.47
|
|
%ua.raw104 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr105 = inttoptr i64 %ua.raw104 to ptr
|
|
%ua.load106 = load [2 x { i64, i64 }], ptr %ua.ptr105, align 8
|
|
%callN = call { ptr, i64 } @array_to_string__AR_2_Any(ptr %0, [2 x { i64, i64 }] %ua.load106)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.174
|
|
|
|
dispatch.case.178: ; preds = %match.arm.47
|
|
%ua.raw108 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr109 = inttoptr i64 %ua.raw108 to ptr
|
|
%ua.load110 = load [1 x { i64, i64 }], ptr %ua.ptr109, align 8
|
|
%callN = call { ptr, i64 } @array_to_string__AR_1_Any(ptr %0, [1 x { i64, i64 }] %ua.load110)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.174
|
|
|
|
dispatch.merge.194: ; preds = %dispatch.case.198, %dispatch.case.197, %dispatch.case.196, %dispatch.default.195
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.37
|
|
|
|
dispatch.default.195: ; preds = %match.arm.48
|
|
store { ptr, i64 } { ptr @str.94, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.194
|
|
|
|
dispatch.case.196: ; preds = %match.arm.48
|
|
%ua.raw113 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr114 = inttoptr i64 %ua.raw113 to ptr
|
|
%ua.load115 = load { ptr, i64 }, ptr %ua.ptr114, align 8
|
|
%callN = call { ptr, i64 } @slice_to_string__string(ptr %0, { ptr, i64 } %ua.load115)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.194
|
|
|
|
dispatch.case.197: ; preds = %match.arm.48
|
|
%ua.raw117 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr118 = inttoptr i64 %ua.raw117 to ptr
|
|
%ua.load119 = load { ptr, i64 }, ptr %ua.ptr118, align 8
|
|
%callN = call { ptr, i64 } @slice_to_string__Greeter(ptr %0, { ptr, i64 } %ua.load119)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.194
|
|
|
|
dispatch.case.198: ; preds = %match.arm.48
|
|
%ua.raw121 = extractvalue { i64, i64 } %loadN, 1
|
|
%ua.ptr122 = inttoptr i64 %ua.raw121 to ptr
|
|
%ua.load123 = load { ptr, i64 }, ptr %ua.ptr122, align 8
|
|
%callN = call { ptr, i64 } @slice_to_string__Any(ptr %0, { ptr, i64 } %ua.load123)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.194
|
|
|
|
dispatch.merge.214: ; preds = %dispatch.case.237, %dispatch.case.236, %dispatch.case.235, %dispatch.case.234, %dispatch.case.233, %dispatch.case.232, %dispatch.case.231, %dispatch.case.230, %dispatch.case.229, %dispatch.case.228, %dispatch.case.227, %dispatch.case.226, %dispatch.case.225, %dispatch.case.224, %dispatch.case.223, %dispatch.case.222, %dispatch.case.221, %dispatch.case.220, %dispatch.case.219, %dispatch.case.218, %dispatch.case.217, %dispatch.case.216, %dispatch.default.215
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
store { ptr, i64 } %loadN, ptr %allocaN, align 8
|
|
br label %match.merge.37
|
|
|
|
dispatch.default.215: ; preds = %match.arm.49
|
|
store { ptr, i64 } { ptr @str.95, i64 0 }, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.216: ; preds = %match.arm.49
|
|
%ua.raw126 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp = inttoptr i64 %ua.raw126 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.214
|
|
|
|
dispatch.case.217: ; preds = %match.arm.49
|
|
%ua.raw128 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp129 = inttoptr i64 %ua.raw128 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_CAllocator(ptr %0, ptr %iNp129)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.218: ; preds = %match.arm.49
|
|
%ua.raw131 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp132 = inttoptr i64 %ua.raw131 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_GPA(ptr %0, ptr %iNp132)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.219: ; preds = %match.arm.49
|
|
%ua.raw134 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp135 = inttoptr i64 %ua.raw134 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ArenaChunk(ptr %0, ptr %iNp135)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.220: ; preds = %match.arm.49
|
|
%ua.raw137 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp138 = inttoptr i64 %ua.raw137 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_Arena(ptr %0, ptr %iNp138)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.221: ; preds = %match.arm.49
|
|
%ua.raw140 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp141 = inttoptr i64 %ua.raw140 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__mptr_u8(ptr %0, ptr %iNp141)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.222: ; preds = %match.arm.49
|
|
%ua.raw143 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp144 = inttoptr i64 %ua.raw143 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_BufAlloc(ptr %0, ptr %iNp144)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.223: ; preds = %match.arm.49
|
|
%ua.raw146 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp147 = inttoptr i64 %ua.raw146 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_TrackingAllocator(ptr %0, ptr %iNp147)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.224: ; preds = %match.arm.49
|
|
%ua.raw149 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp150 = inttoptr i64 %ua.raw149 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_Dog(ptr %0, ptr %iNp150)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.225: ; preds = %match.arm.49
|
|
%ua.raw152 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp153 = inttoptr i64 %ua.raw152 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_Cat(ptr %0, ptr %iNp153)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.226: ; preds = %match.arm.49
|
|
%ua.raw155 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp156 = inttoptr i64 %ua.raw155 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_CAllocator(ptr %0, ptr %iNp156)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.227: ; preds = %match.arm.49
|
|
%ua.raw158 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp159 = inttoptr i64 %ua.raw158 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_s64(ptr %0, ptr %iNp159)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.228: ; preds = %match.arm.49
|
|
%ua.raw161 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp162 = inttoptr i64 %ua.raw161 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_void(ptr %0, ptr %iNp162)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.229: ; preds = %match.arm.49
|
|
%ua.raw164 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp165 = inttoptr i64 %ua.raw164 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_Any(ptr %0, ptr %iNp165)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.230: ; preds = %match.arm.49
|
|
%ua.raw167 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp168 = inttoptr i64 %ua.raw167 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_AR_2_Any(ptr %0, ptr %iNp168)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.231: ; preds = %match.arm.49
|
|
%ua.raw170 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp171 = inttoptr i64 %ua.raw170 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_SL_Any(ptr %0, ptr %iNp171)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.232: ; preds = %match.arm.49
|
|
%ua.raw173 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp174 = inttoptr i64 %ua.raw173 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_Dog(ptr %0, ptr %iNp174)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.233: ; preds = %match.arm.49
|
|
%ua.raw176 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp177 = inttoptr i64 %ua.raw176 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_ptr_Cat(ptr %0, ptr %iNp177)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.234: ; preds = %match.arm.49
|
|
%ua.raw179 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp180 = inttoptr i64 %ua.raw179 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_string(ptr %0, ptr %iNp180)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.235: ; preds = %match.arm.49
|
|
%ua.raw182 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp183 = inttoptr i64 %ua.raw182 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_AR_1_Any(ptr %0, ptr %iNp183)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.236: ; preds = %match.arm.49
|
|
%ua.raw185 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp186 = inttoptr i64 %ua.raw185 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_u8(ptr %0, ptr %iNp186)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
|
|
dispatch.case.237: ; preds = %match.arm.49
|
|
%ua.raw188 = extractvalue { i64, i64 } %loadN, 1
|
|
%iNp189 = inttoptr i64 %ua.raw188 to ptr
|
|
%callN = call { ptr, i64 } @pointer_to_string__ptr_bool(ptr %0, ptr %iNp189)
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %dispatch.merge.214
|
|
}
|
|
|
|
; 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.96, 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.0
|
|
|
|
while.hdr.0: ; preds = %if.merge.5, %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.1, label %while.exit.2
|
|
|
|
while.body.1: ; preds = %while.hdr.0
|
|
%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.3, label %if.else.4
|
|
|
|
while.exit.2: ; preds = %while.hdr.0
|
|
%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.35, label %if.merge.36
|
|
|
|
if.then.3: ; preds = %while.body.1
|
|
%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.6, label %if.else.7
|
|
|
|
if.else.4: ; preds = %while.body.1
|
|
%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.26, label %if.else.27
|
|
|
|
if.merge.5: ; preds = %if.merge.28, %if.merge.8
|
|
br label %while.hdr.0
|
|
|
|
if.then.6: ; preds = %if.then.3
|
|
%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.9, label %if.else.10
|
|
|
|
if.else.7: ; preds = %if.then.3
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.8
|
|
|
|
if.merge.8: ; preds = %if.merge.11, %if.else.7
|
|
br label %if.merge.5
|
|
|
|
if.then.9: ; preds = %if.then.6
|
|
%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.12, label %if.merge.13
|
|
|
|
if.else.10: ; preds = %if.then.6
|
|
%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.23, label %if.else.24
|
|
|
|
if.merge.11: ; preds = %if.merge.25, %if.merge.13
|
|
br label %if.merge.8
|
|
|
|
if.then.12: ; preds = %if.then.9
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.97, 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.98, 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.99, i64 4 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.13
|
|
|
|
if.merge.13: ; preds = %if.then.12, %if.then.9
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.100, 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.101, 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.11
|
|
|
|
if.then.23: ; preds = %if.else.10
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.102, 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.103, 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.104, 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.25
|
|
|
|
if.else.24: ; preds = %if.else.10
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.25
|
|
|
|
if.merge.25: ; preds = %if.else.24, %if.then.23
|
|
br label %if.merge.11
|
|
|
|
if.then.26: ; preds = %if.else.4
|
|
%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.29, label %if.else.30
|
|
|
|
if.else.27: ; preds = %if.else.4
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.28
|
|
|
|
if.merge.28: ; preds = %if.merge.31, %if.else.27
|
|
br label %if.merge.5
|
|
|
|
if.then.29: ; preds = %if.then.26
|
|
%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.32, label %if.else.33
|
|
|
|
if.else.30: ; preds = %if.then.26
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.31
|
|
|
|
if.merge.31: ; preds = %if.merge.34, %if.else.30
|
|
br label %if.merge.28
|
|
|
|
if.then.32: ; preds = %if.then.29
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.105, 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.106, 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.107, 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.34
|
|
|
|
if.else.33: ; preds = %if.then.29
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%addN = add i64 %loadN, 1
|
|
store i64 %addN, ptr %allocaN, align 8
|
|
br label %if.merge.34
|
|
|
|
if.merge.34: ; preds = %if.else.33, %if.then.32
|
|
br label %if.merge.31
|
|
|
|
if.then.35: ; preds = %while.exit.2
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.108, 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.109, 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.110, i64 4 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.36
|
|
|
|
if.merge.36: ; preds = %if.then.35, %while.exit.2
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
ret { ptr, i64 } %loadN
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal i64 @Dog.greet(ptr %0, ptr %1) #0 {
|
|
entry:
|
|
%alloca = alloca ptr, align 8
|
|
store ptr %1, ptr %alloca, align 8
|
|
%load = load ptr, ptr %alloca, align 8
|
|
%loadN = load { i64 }, ptr %load, align 8
|
|
%sg = extractvalue { i64 } %loadN, 0
|
|
ret i64 %sg
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal i64 @Cat.greet(ptr %0, ptr %1) #0 {
|
|
entry:
|
|
%alloca = alloca ptr, align 8
|
|
store ptr %1, ptr %alloca, align 8
|
|
%load = load ptr, ptr %alloca, align 8
|
|
%loadN = load { i64 }, ptr %load, align 8
|
|
%sg = extractvalue { i64 } %loadN, 0
|
|
%mul = mul i64 %sg, 100
|
|
ret i64 %mul
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
declare i64 @pair_sum(ptr, ptr) #0
|
|
|
|
; Function Attrs: nounwind
|
|
define i32 @main() #0 {
|
|
entry:
|
|
%alloca = alloca { i64 }, align 8
|
|
store { i64 } { i64 3 }, ptr %alloca, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } { i64 9 }, ptr %allocaN, align 8
|
|
%load = load { i64 }, ptr %alloca, align 8
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%call = call i64 @pair_sum__pack_Dog_Cat(ptr @__sx_default_context, { i64 } %load, { i64 } %loadN)
|
|
call void @print__ct_sa93836785e55c522__pack_s64(ptr @__sx_default_context, i64 %call)
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%loadN = load { i64 }, ptr %alloca, align 8
|
|
%callN = call i64 @pair_sum__pack_Cat_Dog(ptr @__sx_default_context, { i64 } %loadN, { i64 } %loadN)
|
|
call void @print__ct_sdcda2f2aa37cf168__pack_s64(ptr @__sx_default_context, i64 %callN)
|
|
%loadN = load { i64 }, ptr %alloca, align 8
|
|
%callN = call i64 @pair_sum__pack_Dog_Dog(ptr @__sx_default_context, { i64 } %loadN, { i64 } { i64 4 })
|
|
call void @print__ct_s1a602d8c97d1af91__pack_s64(ptr @__sx_default_context, i64 %callN)
|
|
ret i32 0
|
|
}
|
|
|
|
; 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 i64 @pair_sum__pack_Dog_Cat(ptr %0, { i64 } %1, { i64 } %2) #0 {
|
|
entry:
|
|
%alloca = alloca { i64 }, align 8
|
|
store { i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %2, ptr %allocaN, align 8
|
|
%allocaN = alloca [2 x { i64, i64 }], align 8
|
|
%load = load { i64 }, ptr %alloca, align 8
|
|
%ba.tmp = alloca { i64 }, align 8
|
|
store { i64 } %load, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 39, i64 undef }, i64 %ba.p2i, 1
|
|
%igp.ptr = getelementptr { i64, i64 }, ptr %allocaN, i64 0
|
|
store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%ba.tmp4 = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %ba.tmp4, align 8
|
|
%ba.p2i5 = ptrtoint ptr %ba.tmp4 to i64
|
|
%ba.val6 = insertvalue { i64, i64 } { i64 40, i64 undef }, i64 %ba.p2i5, 1
|
|
%igp.ptr7 = getelementptr { i64, i64 }, ptr %allocaN, i64 1
|
|
store { i64, i64 } %ba.val6, ptr %igp.ptr7, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%igp.ptr9 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
|
|
%gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
|
|
store ptr %igp.ptr9, ptr %gep, align 8
|
|
%gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
|
|
store i64 2, ptr %gepN, align 8
|
|
%loadN = load { i64 }, ptr %alloca, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %allocaN, align 8
|
|
%call = call i64 @Dog.greet(ptr %0, ptr %allocaN)
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %allocaN, align 8
|
|
%callN = call i64 @Cat.greet(ptr %0, ptr %allocaN)
|
|
%add = add i64 %call, %callN
|
|
ret i64 %add
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal void @print__ct_sa93836785e55c522__pack_s64(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.111, i64 11 }, ptr %alloca, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %1, ptr %allocaN, align 8
|
|
%allocaN = alloca [1 x { i64, i64 }], align 8
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%ba.val = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %load, 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.112, 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 8)
|
|
%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 i64, ptr %allocaN, align 8
|
|
%ba.val12 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %loadN, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val12)
|
|
%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 10, 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.113, i64 11 })
|
|
ret { ptr, i64 } %call
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal i64 @pair_sum__pack_Cat_Dog(ptr %0, { i64 } %1, { i64 } %2) #0 {
|
|
entry:
|
|
%alloca = alloca { i64 }, align 8
|
|
store { i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %2, ptr %allocaN, align 8
|
|
%allocaN = alloca [2 x { i64, i64 }], align 8
|
|
%load = load { i64 }, ptr %alloca, align 8
|
|
%ba.tmp = alloca { i64 }, align 8
|
|
store { i64 } %load, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 40, i64 undef }, i64 %ba.p2i, 1
|
|
%igp.ptr = getelementptr { i64, i64 }, ptr %allocaN, i64 0
|
|
store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%ba.tmp4 = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %ba.tmp4, align 8
|
|
%ba.p2i5 = ptrtoint ptr %ba.tmp4 to i64
|
|
%ba.val6 = insertvalue { i64, i64 } { i64 39, i64 undef }, i64 %ba.p2i5, 1
|
|
%igp.ptr7 = getelementptr { i64, i64 }, ptr %allocaN, i64 1
|
|
store { i64, i64 } %ba.val6, ptr %igp.ptr7, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%igp.ptr9 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
|
|
%gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
|
|
store ptr %igp.ptr9, ptr %gep, align 8
|
|
%gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
|
|
store i64 2, ptr %gepN, align 8
|
|
%loadN = load { i64 }, ptr %alloca, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %allocaN, align 8
|
|
%call = call i64 @Cat.greet(ptr %0, ptr %allocaN)
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %allocaN, align 8
|
|
%callN = call i64 @Dog.greet(ptr %0, ptr %allocaN)
|
|
%add = add i64 %call, %callN
|
|
ret i64 %add
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal void @print__ct_sdcda2f2aa37cf168__pack_s64(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.114, i64 11 }, ptr %alloca, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %1, ptr %allocaN, align 8
|
|
%allocaN = alloca [1 x { i64, i64 }], align 8
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%ba.val = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %load, 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.115, 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 8)
|
|
%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 i64, ptr %allocaN, align 8
|
|
%ba.val12 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %loadN, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val12)
|
|
%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 10, 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_1(ptr %0) #0 {
|
|
entry:
|
|
%call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.116, i64 11 })
|
|
ret { ptr, i64 } %call
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal i64 @pair_sum__pack_Dog_Dog(ptr %0, { i64 } %1, { i64 } %2) #0 {
|
|
entry:
|
|
%alloca = alloca { i64 }, align 8
|
|
store { i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %2, ptr %allocaN, align 8
|
|
%allocaN = alloca [2 x { i64, i64 }], align 8
|
|
%load = load { i64 }, ptr %alloca, align 8
|
|
%ba.tmp = alloca { i64 }, align 8
|
|
store { i64 } %load, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 39, i64 undef }, i64 %ba.p2i, 1
|
|
%igp.ptr = getelementptr { i64, i64 }, ptr %allocaN, i64 0
|
|
store { i64, i64 } %ba.val, ptr %igp.ptr, align 8
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%ba.tmp4 = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %ba.tmp4, align 8
|
|
%ba.p2i5 = ptrtoint ptr %ba.tmp4 to i64
|
|
%ba.val6 = insertvalue { i64, i64 } { i64 39, i64 undef }, i64 %ba.p2i5, 1
|
|
%igp.ptr7 = getelementptr { i64, i64 }, ptr %allocaN, i64 1
|
|
store { i64, i64 } %ba.val6, ptr %igp.ptr7, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
%igp.ptr9 = getelementptr { i64, i64 }, ptr %allocaN, i64 0
|
|
%gep = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 0
|
|
store ptr %igp.ptr9, ptr %gep, align 8
|
|
%gepN = getelementptr inbounds { ptr, i64 }, ptr %allocaN, i32 0, i32 1
|
|
store i64 2, ptr %gepN, align 8
|
|
%loadN = load { i64 }, ptr %alloca, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %allocaN, align 8
|
|
%call = call i64 @Dog.greet(ptr %0, ptr %allocaN)
|
|
%loadN = load { i64 }, ptr %allocaN, align 8
|
|
%allocaN = alloca { i64 }, align 8
|
|
store { i64 } %loadN, ptr %allocaN, align 8
|
|
%callN = call i64 @Dog.greet(ptr %0, ptr %allocaN)
|
|
%add = add i64 %call, %callN
|
|
ret i64 %add
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal void @print__ct_s1a602d8c97d1af91__pack_s64(ptr %0, i64 %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.117, i64 11 }, ptr %alloca, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 %1, ptr %allocaN, align 8
|
|
%allocaN = alloca [1 x { i64, i64 }], align 8
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%ba.val = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %load, 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.118, 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 8)
|
|
%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 i64, ptr %allocaN, align 8
|
|
%ba.val12 = insertvalue { i64, i64 } { i64 5, i64 undef }, i64 %loadN, 1
|
|
%callN = call { ptr, i64 } @any_to_string(ptr %0, { i64, i64 } %ba.val12)
|
|
%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 10, 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_2(ptr %0) #0 {
|
|
entry:
|
|
%call = call { ptr, i64 } @build_format(ptr %0, { ptr, i64 } { ptr @str.119, i64 11 })
|
|
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.120, i64 15 }, { ptr, i64 } { ptr @str.121, 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.109
|
|
|
|
while.hdr.109: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 4
|
|
br i1 %icmp, label %while.body.110, label %while.exit.111
|
|
|
|
while.body.110: ; preds = %while.hdr.109
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.112, label %if.merge.113
|
|
|
|
while.exit.111: ; preds = %while.hdr.109
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.122, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.112: ; preds = %while.body.110
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.123, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.113
|
|
|
|
if.merge.113: ; preds = %if.then.112, %while.body.110
|
|
%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.127, 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.109
|
|
|
|
fv.default: ; preds = %if.merge.113
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.113
|
|
%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.113
|
|
%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.113
|
|
%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.113
|
|
%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.128, i64 9 }, { ptr, i64 } { ptr @str.129, 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.114
|
|
|
|
while.hdr.114: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 3
|
|
br i1 %icmp, label %while.body.115, label %while.exit.116
|
|
|
|
while.body.115: ; preds = %while.hdr.114
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.117, label %if.merge.118
|
|
|
|
while.exit.116: ; preds = %while.hdr.114
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.130, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.117: ; preds = %while.body.115
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.131, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.118
|
|
|
|
if.merge.118: ; preds = %if.then.117, %while.body.115
|
|
%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.135, 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.136, 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.114
|
|
|
|
fv.default: ; preds = %if.merge.118
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.118
|
|
%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.118
|
|
%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.118
|
|
%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.137, i64 10 }, { ptr, i64 } { ptr @str.138, 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.119
|
|
|
|
while.hdr.119: ; preds = %if.merge.123, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 0
|
|
br i1 %icmp, label %while.body.120, label %while.exit.121
|
|
|
|
while.body.120: ; preds = %while.hdr.119
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.122, label %if.merge.123
|
|
|
|
while.exit.121: ; preds = %while.hdr.119
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.139, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.122: ; preds = %while.body.120
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.140, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.123
|
|
|
|
if.merge.123: ; preds = %if.then.122, %while.body.120
|
|
%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.141, 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.142, 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.119
|
|
}
|
|
|
|
; 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.143, i64 3 }, { ptr, i64 } { ptr @str.144, 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.124
|
|
|
|
while.hdr.124: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 1
|
|
br i1 %icmp, label %while.body.125, label %while.exit.126
|
|
|
|
while.body.125: ; preds = %while.hdr.124
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.127, label %if.merge.128
|
|
|
|
while.exit.126: ; preds = %while.hdr.124
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.145, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.127: ; preds = %while.body.125
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.146, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.128
|
|
|
|
if.merge.128: ; preds = %if.then.127, %while.body.125
|
|
%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.148, 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.149, 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.124
|
|
|
|
fv.default: ; preds = %if.merge.128
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.128
|
|
%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.150, i64 10 }, { ptr, i64 } { ptr @str.151, 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.129
|
|
|
|
while.hdr.129: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 2
|
|
br i1 %icmp, label %while.body.130, label %while.exit.131
|
|
|
|
while.body.130: ; preds = %while.hdr.129
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.132, label %if.merge.133
|
|
|
|
while.exit.131: ; preds = %while.hdr.129
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.152, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.132: ; preds = %while.body.130
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.153, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.133
|
|
|
|
if.merge.133: ; preds = %if.then.132, %while.body.130
|
|
%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.156, 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.157, 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.129
|
|
|
|
fv.default: ; preds = %if.merge.133
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.133
|
|
%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.133
|
|
%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.158, i64 5 }, { ptr, i64 } { ptr @str.159, 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.134
|
|
|
|
while.hdr.134: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 3
|
|
br i1 %icmp, label %while.body.135, label %while.exit.136
|
|
|
|
while.body.135: ; preds = %while.hdr.134
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.137, label %if.merge.138
|
|
|
|
while.exit.136: ; preds = %while.hdr.134
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.160, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.137: ; preds = %while.body.135
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.161, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.138
|
|
|
|
if.merge.138: ; preds = %if.then.137, %while.body.135
|
|
%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.165, 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.166, 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.134
|
|
|
|
fv.default: ; preds = %if.merge.138
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.138
|
|
%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.138
|
|
%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.138
|
|
%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.167, i64 8 }, { ptr, i64 } { ptr @str.168, 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.139
|
|
|
|
while.hdr.139: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 3
|
|
br i1 %icmp, label %while.body.140, label %while.exit.141
|
|
|
|
while.body.140: ; preds = %while.hdr.139
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.142, label %if.merge.143
|
|
|
|
while.exit.141: ; preds = %while.hdr.139
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.169, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.142: ; preds = %while.body.140
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.170, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.143
|
|
|
|
if.merge.143: ; preds = %if.then.142, %while.body.140
|
|
%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.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, 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.139
|
|
|
|
fv.default: ; preds = %if.merge.143
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.143
|
|
%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.143
|
|
%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.143
|
|
%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.176, i64 17 }, { 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.144
|
|
|
|
while.hdr.144: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 4
|
|
br i1 %icmp, label %while.body.145, label %while.exit.146
|
|
|
|
while.body.145: ; preds = %while.hdr.144
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.147, label %if.merge.148
|
|
|
|
while.exit.146: ; preds = %while.hdr.144
|
|
%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.147: ; preds = %while.body.145
|
|
%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.148
|
|
|
|
if.merge.148: ; preds = %if.then.147, %while.body.145
|
|
%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.184, 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.185, 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.144
|
|
|
|
fv.default: ; preds = %if.merge.148
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.148
|
|
%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.148
|
|
%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.148
|
|
%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.148
|
|
%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.186, i64 7 }, { ptr, i64 } { ptr @str.187, 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.149
|
|
|
|
while.hdr.149: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 2
|
|
br i1 %icmp, label %while.body.150, label %while.exit.151
|
|
|
|
while.body.150: ; preds = %while.hdr.149
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.152, label %if.merge.153
|
|
|
|
while.exit.151: ; preds = %while.hdr.149
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.188, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.152: ; preds = %while.body.150
|
|
%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.153
|
|
|
|
if.merge.153: ; preds = %if.then.152, %while.body.150
|
|
%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.192, 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.193, 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.149
|
|
|
|
fv.default: ; preds = %if.merge.153
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.153
|
|
%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.153
|
|
%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 } @struct_to_string__Greeter(ptr %0, { ptr, ptr } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, ptr }, align 8
|
|
store { ptr, ptr } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.194, i64 7 }, { ptr, i64 } { ptr @str.195, 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.154
|
|
|
|
while.hdr.154: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 2
|
|
br i1 %icmp, label %while.body.155, label %while.exit.156
|
|
|
|
while.body.155: ; preds = %while.hdr.154
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.157, label %if.merge.158
|
|
|
|
while.exit.156: ; preds = %while.hdr.154
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.196, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.157: ; preds = %while.body.155
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.197, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.158
|
|
|
|
if.merge.158: ; preds = %if.then.157, %while.body.155
|
|
%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.200, 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.201, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { 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.val20, %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.154
|
|
|
|
fv.default: ; preds = %if.merge.158
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.158
|
|
%fv.field = extractvalue { 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.158
|
|
%fv.field18 = extractvalue { 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
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string____Greeter__Vtable(ptr %0, { ptr } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr }, align 8
|
|
store { ptr } %1, ptr %alloca, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.202, i64 17 }, { ptr, i64 } { ptr @str.203, 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.159
|
|
|
|
while.hdr.159: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 1
|
|
br i1 %icmp, label %while.body.160, label %while.exit.161
|
|
|
|
while.body.160: ; preds = %while.hdr.159
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.162, label %if.merge.163
|
|
|
|
while.exit.161: ; preds = %while.hdr.159
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.204, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
if.then.162: ; preds = %while.body.160
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.205, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.163
|
|
|
|
if.merge.163: ; preds = %if.then.162, %while.body.160
|
|
%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.207, 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.208, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load { ptr }, 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.159
|
|
|
|
fv.default: ; preds = %if.merge.163
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.163
|
|
%fv.field = extractvalue { 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
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @struct_to_string__Dog(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.209, i64 3 }, { ptr, i64 } { ptr @str.210, 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.164
|
|
|
|
while.hdr.164: ; preds = %fv.merge, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 1
|
|
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
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.211, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
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.212, 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 i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [1 x { ptr, i64 }], ptr @field_names.214, 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.215, 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.164
|
|
|
|
fv.default: ; preds = %if.merge.168
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.168
|
|
%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__Cat(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.216, i64 3 }, { ptr, i64 } { ptr @str.217, 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.169
|
|
|
|
while.hdr.169: ; preds = %fv.merge, %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
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.218, i64 1 })
|
|
ret { ptr, i64 } %callN
|
|
|
|
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.219, 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 i64, ptr %allocaN, align 8
|
|
%fn.gep = getelementptr inbounds [1 x { ptr, i64 }], ptr @field_names.221, 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.222, 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.169
|
|
|
|
fv.default: ; preds = %if.merge.173
|
|
br label %fv.merge
|
|
|
|
fv.case: ; preds = %if.merge.173
|
|
%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 } @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.223, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.179
|
|
|
|
while.hdr.179: ; preds = %if.merge.183, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 4
|
|
br i1 %icmp, label %while.body.180, label %while.exit.181
|
|
|
|
while.body.180: ; preds = %while.hdr.179
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.182, label %if.merge.183
|
|
|
|
while.exit.181: ; preds = %while.hdr.179
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.224, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.182: ; preds = %while.body.180
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.225, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.183
|
|
|
|
if.merge.183: ; preds = %if.then.182, %while.body.180
|
|
%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.179
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @array_to_string__AR_2_Any(ptr %0, [2 x { i64, i64 }] %1) #0 {
|
|
entry:
|
|
%alloca = alloca [2 x { i64, i64 }], align 8
|
|
%ig.tmp = alloca [2 x { i64, i64 }], align 8
|
|
%ba.tmp = alloca { i64, i64 }, align 8
|
|
store [2 x { i64, i64 }] %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.226, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.184
|
|
|
|
while.hdr.184: ; preds = %if.merge.188, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 2
|
|
br i1 %icmp, label %while.body.185, label %while.exit.186
|
|
|
|
while.body.185: ; preds = %while.hdr.184
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.187, label %if.merge.188
|
|
|
|
while.exit.186: ; preds = %while.hdr.184
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.227, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.187: ; preds = %while.body.185
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.228, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.188
|
|
|
|
if.merge.188: ; preds = %if.then.187, %while.body.185
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%loadN = load [2 x { i64, i64 }], ptr %alloca, align 8
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
store [2 x { i64, i64 }] %loadN, ptr %ig.tmp, align 8
|
|
%ig.ptr = getelementptr [2 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.184
|
|
}
|
|
|
|
; 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.229, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.189
|
|
|
|
while.hdr.189: ; preds = %if.merge.193, %entry
|
|
%load = load i64, ptr %allocaN, align 8
|
|
%icmp = icmp slt i64 %load, 1
|
|
br i1 %icmp, label %while.body.190, label %while.exit.191
|
|
|
|
while.body.190: ; preds = %while.hdr.189
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.192, label %if.merge.193
|
|
|
|
while.exit.191: ; preds = %while.hdr.189
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.230, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.192: ; preds = %while.body.190
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.231, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.193
|
|
|
|
if.merge.193: ; preds = %if.then.192, %while.body.190
|
|
%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.189
|
|
}
|
|
|
|
; 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.232, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.199
|
|
|
|
while.hdr.199: ; preds = %if.merge.203, %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.200, label %while.exit.201
|
|
|
|
while.body.200: ; preds = %while.hdr.199
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.202, label %if.merge.203
|
|
|
|
while.exit.201: ; preds = %while.hdr.199
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.233, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.202: ; preds = %while.body.200
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.234, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.203
|
|
|
|
if.merge.203: ; preds = %if.then.202, %while.body.200
|
|
%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.199
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @slice_to_string__Greeter(ptr %0, { ptr, i64 } %1) #0 {
|
|
entry:
|
|
%alloca = alloca { ptr, i64 }, align 8
|
|
%ba.tmp = alloca { ptr, ptr }, align 8
|
|
store { ptr, i64 } %1, ptr %alloca, align 8
|
|
%allocaN = alloca { ptr, i64 }, align 8
|
|
store { ptr, i64 } { ptr @str.235, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.204
|
|
|
|
while.hdr.204: ; preds = %if.merge.208, %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.205, label %while.exit.206
|
|
|
|
while.body.205: ; preds = %while.hdr.204
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.207, label %if.merge.208
|
|
|
|
while.exit.206: ; preds = %while.hdr.204
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.236, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.207: ; preds = %while.body.205
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.237, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.208
|
|
|
|
if.merge.208: ; preds = %if.then.207, %while.body.205
|
|
%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, ptr }, ptr %ig.data, i64 %loadN
|
|
%ig.val = load { ptr, ptr }, ptr %ig.ptr, align 8
|
|
store { ptr, ptr } %ig.val, ptr %ba.tmp, align 8
|
|
%ba.p2i = ptrtoint ptr %ba.tmp to i64
|
|
%ba.val = insertvalue { i64, i64 } { i64 37, 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.204
|
|
}
|
|
|
|
; 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.238, i64 1 }, ptr %allocaN, align 8
|
|
%allocaN = alloca i64, align 8
|
|
store i64 0, ptr %allocaN, align 8
|
|
br label %while.hdr.209
|
|
|
|
while.hdr.209: ; preds = %if.merge.213, %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.210, label %while.exit.211
|
|
|
|
while.body.210: ; preds = %while.hdr.209
|
|
%loadN = load i64, ptr %allocaN, align 8
|
|
%icmpN = icmp sgt i64 %loadN, 0
|
|
br i1 %icmpN, label %if.then.212, label %if.merge.213
|
|
|
|
while.exit.211: ; preds = %while.hdr.209
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%call = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.239, i64 1 })
|
|
ret { ptr, i64 } %call
|
|
|
|
if.then.212: ; preds = %while.body.210
|
|
%loadN = load { ptr, i64 }, ptr %allocaN, align 8
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } %loadN, { ptr, i64 } { ptr @str.240, i64 2 })
|
|
store { ptr, i64 } %callN, ptr %allocaN, align 8
|
|
br label %if.merge.213
|
|
|
|
if.merge.213: ; preds = %if.then.212, %while.body.210
|
|
%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.209
|
|
}
|
|
|
|
; 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.238, label %if.else.239
|
|
|
|
if.then.238: ; preds = %entry
|
|
br label %if.merge.240
|
|
|
|
if.else.239: ; 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 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.240
|
|
|
|
if.merge.240: ; preds = %if.else.239, %if.then.238
|
|
%bp = phi { ptr, i64 } [ { ptr @str.241, i64 4 }, %if.then.238 ], [ %callN, %if.else.239 ]
|
|
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.254, label %if.else.255
|
|
|
|
if.then.254: ; preds = %entry
|
|
br label %if.merge.256
|
|
|
|
if.else.255: ; 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 11 }, { ptr, i64 } %callN)
|
|
br label %if.merge.256
|
|
|
|
if.merge.256: ; preds = %if.else.255, %if.then.254
|
|
%bp = phi { ptr, i64 } [ { ptr @str.244, i64 4 }, %if.then.254 ], [ %callN, %if.else.255 ]
|
|
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.257, label %if.else.258
|
|
|
|
if.then.257: ; preds = %entry
|
|
br label %if.merge.259
|
|
|
|
if.else.258: ; 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 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.259
|
|
|
|
if.merge.259: ; preds = %if.else.258, %if.then.257
|
|
%bp = phi { ptr, i64 } [ { ptr @str.247, i64 4 }, %if.then.257 ], [ %callN, %if.else.258 ]
|
|
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.260, label %if.else.261
|
|
|
|
if.then.260: ; preds = %entry
|
|
br label %if.merge.262
|
|
|
|
if.else.261: ; 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 11 }, { ptr, i64 } %callN)
|
|
br label %if.merge.262
|
|
|
|
if.merge.262: ; preds = %if.else.261, %if.then.260
|
|
%bp = phi { ptr, i64 } [ { ptr @str.250, i64 4 }, %if.then.260 ], [ %callN, %if.else.261 ]
|
|
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.263, label %if.else.264
|
|
|
|
if.then.263: ; preds = %entry
|
|
br label %if.merge.265
|
|
|
|
if.else.264: ; 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.255, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.254, i64 6 }, { ptr, i64 } %callN)
|
|
br label %if.merge.265
|
|
|
|
if.merge.265: ; preds = %if.else.264, %if.then.263
|
|
%bp = phi { ptr, i64 } [ { ptr @str.253, i64 4 }, %if.then.263 ], [ %callN, %if.else.264 ]
|
|
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.266, label %if.else.267
|
|
|
|
if.then.266: ; preds = %entry
|
|
br label %if.merge.268
|
|
|
|
if.else.267: ; 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.258, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.257, i64 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.268
|
|
|
|
if.merge.268: ; preds = %if.else.267, %if.then.266
|
|
%bp = phi { ptr, i64 } [ { ptr @str.256, i64 4 }, %if.then.266 ], [ %callN, %if.else.267 ]
|
|
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.269, label %if.else.270
|
|
|
|
if.then.269: ; preds = %entry
|
|
br label %if.merge.271
|
|
|
|
if.else.270: ; 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.261, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.260, i64 9 }, { ptr, i64 } %callN)
|
|
br label %if.merge.271
|
|
|
|
if.merge.271: ; preds = %if.else.270, %if.then.269
|
|
%bp = phi { ptr, i64 } [ { ptr @str.259, i64 4 }, %if.then.269 ], [ %callN, %if.else.270 ]
|
|
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.272, label %if.else.273
|
|
|
|
if.then.272: ; preds = %entry
|
|
br label %if.merge.274
|
|
|
|
if.else.273: ; 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.264, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.263, i64 18 }, { ptr, i64 } %callN)
|
|
br label %if.merge.274
|
|
|
|
if.merge.274: ; preds = %if.else.273, %if.then.272
|
|
%bp = phi { ptr, i64 } [ { ptr @str.262, i64 4 }, %if.then.272 ], [ %callN, %if.else.273 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_Dog(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.275, label %if.else.276
|
|
|
|
if.then.275: ; preds = %entry
|
|
br label %if.merge.277
|
|
|
|
if.else.276: ; 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.267, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.266, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.277
|
|
|
|
if.merge.277: ; preds = %if.else.276, %if.then.275
|
|
%bp = phi { ptr, i64 } [ { ptr @str.265, i64 4 }, %if.then.275 ], [ %callN, %if.else.276 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_Cat(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.278, label %if.else.279
|
|
|
|
if.then.278: ; preds = %entry
|
|
br label %if.merge.280
|
|
|
|
if.else.279: ; 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.270, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.269, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.280
|
|
|
|
if.merge.280: ; preds = %if.else.279, %if.then.278
|
|
%bp = phi { ptr, i64 } [ { ptr @str.268, i64 4 }, %if.then.278 ], [ %callN, %if.else.279 ]
|
|
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.281, label %if.else.282
|
|
|
|
if.then.281: ; preds = %entry
|
|
br label %if.merge.283
|
|
|
|
if.else.282: ; 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.273, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.272, i64 12 }, { ptr, i64 } %callN)
|
|
br label %if.merge.283
|
|
|
|
if.merge.283: ; preds = %if.else.282, %if.then.281
|
|
%bp = phi { ptr, i64 } [ { ptr @str.271, i64 4 }, %if.then.281 ], [ %callN, %if.else.282 ]
|
|
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.284, label %if.else.285
|
|
|
|
if.then.284: ; preds = %entry
|
|
br label %if.merge.286
|
|
|
|
if.else.285: ; 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.276, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.275, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.286
|
|
|
|
if.merge.286: ; preds = %if.else.285, %if.then.284
|
|
%bp = phi { ptr, i64 } [ { ptr @str.274, i64 4 }, %if.then.284 ], [ %callN, %if.else.285 ]
|
|
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.287, label %if.else.288
|
|
|
|
if.then.287: ; preds = %entry
|
|
br label %if.merge.289
|
|
|
|
if.else.288: ; 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.279, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.278, i64 6 }, { ptr, i64 } %callN)
|
|
br label %if.merge.289
|
|
|
|
if.merge.289: ; preds = %if.else.288, %if.then.287
|
|
%bp = phi { ptr, i64 } [ { ptr @str.277, i64 4 }, %if.then.287 ], [ %callN, %if.else.288 ]
|
|
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.290, label %if.else.291
|
|
|
|
if.then.290: ; preds = %entry
|
|
br label %if.merge.292
|
|
|
|
if.else.291: ; 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.282, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.281, i64 4 }, { ptr, i64 } %callN)
|
|
br label %if.merge.292
|
|
|
|
if.merge.292: ; preds = %if.else.291, %if.then.290
|
|
%bp = phi { ptr, i64 } [ { ptr @str.280, i64 4 }, %if.then.290 ], [ %callN, %if.else.291 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_AR_2_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.293, label %if.else.294
|
|
|
|
if.then.293: ; preds = %entry
|
|
br label %if.merge.295
|
|
|
|
if.else.294: ; 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.285, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.284, i64 7 }, { ptr, i64 } %callN)
|
|
br label %if.merge.295
|
|
|
|
if.merge.295: ; preds = %if.else.294, %if.then.293
|
|
%bp = phi { ptr, i64 } [ { ptr @str.283, i64 4 }, %if.then.293 ], [ %callN, %if.else.294 ]
|
|
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.296, label %if.else.297
|
|
|
|
if.then.296: ; preds = %entry
|
|
br label %if.merge.298
|
|
|
|
if.else.297: ; 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.288, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.287, i64 6 }, { ptr, i64 } %callN)
|
|
br label %if.merge.298
|
|
|
|
if.merge.298: ; preds = %if.else.297, %if.then.296
|
|
%bp = phi { ptr, i64 } [ { ptr @str.286, i64 4 }, %if.then.296 ], [ %callN, %if.else.297 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_ptr_Dog(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.299, label %if.else.300
|
|
|
|
if.then.299: ; preds = %entry
|
|
br label %if.merge.301
|
|
|
|
if.else.300: ; 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.291, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.290, i64 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.301
|
|
|
|
if.merge.301: ; preds = %if.else.300, %if.then.299
|
|
%bp = phi { ptr, i64 } [ { ptr @str.289, i64 4 }, %if.then.299 ], [ %callN, %if.else.300 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
; Function Attrs: nounwind
|
|
define internal { ptr, i64 } @pointer_to_string__ptr_ptr_Cat(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.302, label %if.else.303
|
|
|
|
if.then.302: ; preds = %entry
|
|
br label %if.merge.304
|
|
|
|
if.else.303: ; 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.294, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.293, i64 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.304
|
|
|
|
if.merge.304: ; preds = %if.else.303, %if.then.302
|
|
%bp = phi { ptr, i64 } [ { ptr @str.292, i64 4 }, %if.then.302 ], [ %callN, %if.else.303 ]
|
|
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.305, label %if.else.306
|
|
|
|
if.then.305: ; preds = %entry
|
|
br label %if.merge.307
|
|
|
|
if.else.306: ; 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.297, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.296, i64 7 }, { ptr, i64 } %callN)
|
|
br label %if.merge.307
|
|
|
|
if.merge.307: ; preds = %if.else.306, %if.then.305
|
|
%bp = phi { ptr, i64 } [ { ptr @str.295, i64 4 }, %if.then.305 ], [ %callN, %if.else.306 ]
|
|
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.308, label %if.else.309
|
|
|
|
if.then.308: ; preds = %entry
|
|
br label %if.merge.310
|
|
|
|
if.else.309: ; 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.300, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.299, i64 7 }, { ptr, i64 } %callN)
|
|
br label %if.merge.310
|
|
|
|
if.merge.310: ; preds = %if.else.309, %if.then.308
|
|
%bp = phi { ptr, i64 } [ { ptr @str.298, i64 4 }, %if.then.308 ], [ %callN, %if.else.309 ]
|
|
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.311, label %if.else.312
|
|
|
|
if.then.311: ; preds = %entry
|
|
br label %if.merge.313
|
|
|
|
if.else.312: ; 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.303, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.302, i64 3 }, { ptr, i64 } %callN)
|
|
br label %if.merge.313
|
|
|
|
if.merge.313: ; preds = %if.else.312, %if.then.311
|
|
%bp = phi { ptr, i64 } [ { ptr @str.301, i64 4 }, %if.then.311 ], [ %callN, %if.else.312 ]
|
|
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.314, label %if.else.315
|
|
|
|
if.then.314: ; preds = %entry
|
|
br label %if.merge.316
|
|
|
|
if.else.315: ; 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.306, i64 3 }, { ptr, i64 } %call)
|
|
%callN = call { ptr, i64 } @concat(ptr %0, { ptr, i64 } { ptr @str.305, i64 5 }, { ptr, i64 } %callN)
|
|
br label %if.merge.316
|
|
|
|
if.merge.316: ; preds = %if.else.315, %if.then.314
|
|
%bp = phi { ptr, i64 } [ { ptr @str.304, i64 4 }, %if.then.314 ], [ %callN, %if.else.315 ]
|
|
ret { ptr, i64 } %bp
|
|
}
|
|
|
|
declare i64 @write(i32, ptr, i64)
|