lower: use Ptr type for pointer-typed loads and stores
aedb2deccd8436f6daa7363862af30a1e2ef82016040a8568e4c8e9dcc33eefe
Phase 2: ensure Load/Store instructions use il::Type::Ptr when the loaded/stored value is a pointer, not W64. - Add emitLoadPtrAt/emitStorePtrAt helpers alongside the W64 variants - loadSlicePtr: load data pointer as Ptr - optionalNilReg: load slice pointer for nil check as Ptr - Nested pattern deref loads: use Ptr for pointer-through-field loads - Allocator loads: load fn pointer and context pointer as Ptr - Slice append: store new pointer as Ptr - Regenerate 15 affected .ril test snapshots
1 parent
b1f8d523
lib/std/lang/lower.rad
+17 -7
| 2095 | 2095 | /// Emit a 64-bit load instruction at the given offset. |
|
| 2096 | 2096 | fn emitLoadW64At(self: *mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) { |
|
| 2097 | 2097 | emit(self, il::Instr::Load { typ: il::Type::W64, dst, src, offset }); |
|
| 2098 | 2098 | } |
|
| 2099 | 2099 | ||
| 2100 | + | /// Emit a pointer-typed store instruction at the given offset. |
|
| 2101 | + | fn emitStorePtrAt(self: *mut FnLowerer, src: il::Val, dst: il::Reg, offset: i32) { |
|
| 2102 | + | emit(self, il::Instr::Store { typ: il::Type::Ptr, src, dst, offset }); |
|
| 2103 | + | } |
|
| 2104 | + | ||
| 2105 | + | /// Emit a pointer-typed load instruction at the given offset. |
|
| 2106 | + | fn emitLoadPtrAt(self: *mut FnLowerer, dst: il::Reg, src: il::Reg, offset: i32) { |
|
| 2107 | + | emit(self, il::Instr::Load { typ: il::Type::Ptr, dst, src, offset }); |
|
| 2108 | + | } |
|
| 2109 | + | ||
| 2100 | 2110 | /// Load a tag from memory at `src` plus `offset` with the given IL type. |
|
| 2101 | 2111 | fn loadTag(self: *mut FnLowerer, src: il::Reg, offset: i32, tagType: il::Type) -> il::Val { |
|
| 2102 | 2112 | let dst = nextReg(self); |
|
| 2103 | 2113 | emit(self, il::Instr::Load { typ: tagType, dst, src, offset }); |
|
| 2104 | 2114 | return il::Val::Reg(dst); |
|
| 2105 | 2115 | } |
|
| 2106 | 2116 | ||
| 2107 | 2117 | /// Load the data pointer from a slice value. |
|
| 2108 | 2118 | fn loadSlicePtr(self: *mut FnLowerer, sliceReg: il::Reg) -> il::Reg { |
|
| 2109 | 2119 | let ptrReg = nextReg(self); |
|
| 2110 | - | emitLoadW64At(self, ptrReg, sliceReg, SLICE_PTR_OFFSET); |
|
| 2120 | + | emitLoadPtrAt(self, ptrReg, sliceReg, SLICE_PTR_OFFSET); |
|
| 2111 | 2121 | return ptrReg; |
|
| 2112 | 2122 | } |
|
| 2113 | 2123 | ||
| 2114 | 2124 | /// Load the length from a slice value. |
|
| 2115 | 2125 | fn loadSliceLen(self: *mut FnLowerer, sliceReg: il::Reg) -> il::Val { |
| 2975 | 2985 | let reg = emitValToReg(self, val); |
|
| 2976 | 2986 | ||
| 2977 | 2987 | match typ { |
|
| 2978 | 2988 | case resolver::Type::Optional(resolver::Type::Slice { .. }) => { |
|
| 2979 | 2989 | let ptrReg = nextReg(self); |
|
| 2980 | - | emitLoadW64At(self, ptrReg, reg, SLICE_PTR_OFFSET); |
|
| 2990 | + | emitLoadPtrAt(self, ptrReg, reg, SLICE_PTR_OFFSET); |
|
| 2981 | 2991 | return ptrReg; |
|
| 2982 | 2992 | } |
|
| 2983 | 2993 | case resolver::Type::Optional(resolver::Type::Pointer { .. }) => return reg, |
|
| 2984 | 2994 | case resolver::Type::Optional(_) => return tvalTagReg(self, reg), |
|
| 2985 | 2995 | else => return reg, |
| 3197 | 3207 | // Auto-deref: if the field is a pointer, load it first. |
|
| 3198 | 3208 | let mut derefType = fieldInfo.fieldType; |
|
| 3199 | 3209 | let mut nestedBase = emitPtrOffset(self, base, fieldInfo.offset); |
|
| 3200 | 3210 | if let case resolver::Type::Pointer { target, .. } = fieldInfo.fieldType { |
|
| 3201 | 3211 | let ptrReg = nextReg(self); |
|
| 3202 | - | emitLoadW64At(self, ptrReg, nestedBase, 0); |
|
| 3212 | + | emitLoadPtrAt(self, ptrReg, nestedBase, 0); |
|
| 3203 | 3213 | nestedBase = ptrReg; |
|
| 3204 | 3214 | derefType = *target; |
|
| 3205 | 3215 | } |
|
| 3206 | 3216 | let recInfo = resolver::getRecord(derefType) |
|
| 3207 | 3217 | else throw LowerError::ExpectedRecord; |
| 3234 | 3244 | // The loaded pointer becomes the base address for the nested subject. |
|
| 3235 | 3245 | let mut derefBase: ?il::Reg = nil; |
|
| 3236 | 3246 | if let case resolver::Type::Pointer { target, .. } = fieldType { |
|
| 3237 | 3247 | if resolver::isDestructuringPattern(pattern) { |
|
| 3238 | 3248 | let ptrReg = nextReg(self); |
|
| 3239 | - | emitLoadW64At(self, ptrReg, fieldPtr, 0); |
|
| 3249 | + | emitLoadPtrAt(self, ptrReg, fieldPtr, 0); |
|
| 3240 | 3250 | derefBase = ptrReg; |
|
| 3241 | 3251 | fieldType = *target; |
|
| 3242 | 3252 | } |
|
| 3243 | 3253 | } |
|
| 3244 | 3254 | // Build a MatchSubject for the nested field. |
| 6257 | 6267 | let doubledVal = emitTypedBinOp(self, il::BinOp::Shl, il::Type::W32, capVal, il::Val::Imm(1)); |
|
| 6258 | 6268 | let newCapVal = emitTypedBinOp(self, il::BinOp::Or, il::Type::W32, doubledVal, il::Val::Imm(1)); |
|
| 6259 | 6269 | ||
| 6260 | 6270 | // Call allocator: `a.func(a.ctx, newCap * stride, alignment)`. |
|
| 6261 | 6271 | let allocFnReg = nextReg(self); |
|
| 6262 | - | emitLoadW64At(self, allocFnReg, allocReg, 0); |
|
| 6272 | + | emitLoadPtrAt(self, allocFnReg, allocReg, 0); |
|
| 6263 | 6273 | ||
| 6264 | 6274 | let allocCtxReg = nextReg(self); |
|
| 6265 | - | emitLoadW64At(self, allocCtxReg, allocReg, 8); |
|
| 6275 | + | emitLoadPtrAt(self, allocCtxReg, allocReg, 8); |
|
| 6266 | 6276 | ||
| 6267 | 6277 | let byteSize = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, newCapVal, il::Val::Imm(stride as i64)); |
|
| 6268 | 6278 | let args = try allocVals(self, 3); |
|
| 6269 | 6279 | ||
| 6270 | 6280 | args[0] = il::Val::Reg(allocCtxReg); |
| 6283 | 6293 | let oldPtrReg = loadSlicePtr(self, sliceReg); |
|
| 6284 | 6294 | let copyBytes = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, lenVal, il::Val::Imm(stride as i64)); |
|
| 6285 | 6295 | try emitByteCopyLoop(self, newPtrReg, oldPtrReg, copyBytes, "append"); |
|
| 6286 | 6296 | ||
| 6287 | 6297 | // Update slice header. |
|
| 6288 | - | emitStoreW64At(self, il::Val::Reg(newPtrReg), sliceReg, SLICE_PTR_OFFSET); |
|
| 6298 | + | emitStorePtrAt(self, il::Val::Reg(newPtrReg), sliceReg, SLICE_PTR_OFFSET); |
|
| 6289 | 6299 | emitStoreW32At(self, newCapVal, sliceReg, SLICE_CAP_OFFSET); |
|
| 6290 | 6300 | ||
| 6291 | 6301 | try emitJmp(self, storeBlock); |
|
| 6292 | 6302 | try switchToAndSeal(self, storeBlock); |
|
| 6293 | 6303 |
test/tests/average.ril
+1 -1
| 1 | 1 | fn w32 $average(ptr %0) { |
|
| 2 | 2 | @entry0 |
|
| 3 | 3 | load w32 %1 %0 8; |
|
| 4 | - | load w64 %2 %0 0; |
|
| 4 | + | load ptr %2 %0 0; |
|
| 5 | 5 | jmp @loop1(0, 0); |
|
| 6 | 6 | @loop1(w32 %3, w32 %7) |
|
| 7 | 7 | br.slt w32 %3 %1 @body2 @merge3; |
|
| 8 | 8 | @body2 |
|
| 9 | 9 | mul w64 %4 %3 4; |
test/tests/byte.load.store.ril
+1 -1
| 32 | 32 | fn w8 $byteSliceAccess(ptr %0, w32 %1) { |
|
| 33 | 33 | @entry0 |
|
| 34 | 34 | load w32 %2 %0 8; |
|
| 35 | 35 | br.ult w32 %1 %2 @guard#pass1 @guard#trap2; |
|
| 36 | 36 | @guard#pass1 |
|
| 37 | - | load w64 %3 %0 0; |
|
| 37 | + | load ptr %3 %0 0; |
|
| 38 | 38 | add ptr %4 %3 %1; |
|
| 39 | 39 | load w8 %5 %4 0; |
|
| 40 | 40 | ret %5; |
|
| 41 | 41 | @guard#trap2 |
|
| 42 | 42 | ebreak; |
test/tests/const.slice.of.slices.ril
+1 -1
| 45 | 45 | add w32 %6 %1 %5; |
|
| 46 | 46 | copy %7 $GROUPS; |
|
| 47 | 47 | load w32 %8 %7 8; |
|
| 48 | 48 | br.ult w32 1 %8 @guard#pass1 @guard#trap2; |
|
| 49 | 49 | @guard#pass1 |
|
| 50 | - | load w64 %9 %7 0; |
|
| 50 | + | load ptr %9 %7 0; |
|
| 51 | 51 | mul w64 %10 1 16; |
|
| 52 | 52 | add ptr %11 %9 %10; |
|
| 53 | 53 | load w32 %12 %11 8; |
|
| 54 | 54 | add w32 %13 %6 %12; |
|
| 55 | 55 | ret %13; |
test/tests/literal.slice.record.ril
+2 -2
| 13 | 13 | store w32 2 %1 8; |
|
| 14 | 14 | store w32 2 %1 12; |
|
| 15 | 15 | load w32 %2 %1 8; |
|
| 16 | 16 | br.ult w32 0 %2 @guard#pass1 @guard#trap2; |
|
| 17 | 17 | @guard#pass1 |
|
| 18 | - | load w64 %3 %1 0; |
|
| 18 | + | load ptr %3 %1 0; |
|
| 19 | 19 | sload w32 %4 %3 0; |
|
| 20 | 20 | load w32 %5 %1 8; |
|
| 21 | 21 | br.ult w32 1 %5 @guard#pass3 @guard#trap4; |
|
| 22 | 22 | @guard#trap2 |
|
| 23 | 23 | ebreak; |
|
| 24 | 24 | unreachable; |
|
| 25 | 25 | @guard#pass3 |
|
| 26 | - | load w64 %6 %1 0; |
|
| 26 | + | load ptr %6 %1 0; |
|
| 27 | 27 | mul w64 %7 1 8; |
|
| 28 | 28 | add ptr %8 %6 %7; |
|
| 29 | 29 | sload w32 %9 %8 4; |
|
| 30 | 30 | add w32 %10 %4 %9; |
|
| 31 | 31 | ret %10; |
test/tests/loop.for.slice.ril
+1 -1
| 1 | 1 | fn w32 $forSliceIndexed(ptr %0) { |
|
| 2 | 2 | @entry0 |
|
| 3 | 3 | load w32 %1 %0 8; |
|
| 4 | - | load w64 %2 %0 0; |
|
| 4 | + | load ptr %2 %0 0; |
|
| 5 | 5 | jmp @loop1(0, 0); |
|
| 6 | 6 | @loop1(w32 %3, w32 %7) |
|
| 7 | 7 | br.slt w32 %3 %1 @body2 @merge3; |
|
| 8 | 8 | @body2 |
|
| 9 | 9 | mul w64 %4 %3 4; |
test/tests/loop.mutable.ril
+1 -1
| 17 | 17 | load w32 %5 %4 8; |
|
| 18 | 18 | br.ult w32 %2 %5 @guard#pass4 @guard#trap5; |
|
| 19 | 19 | @merge3 |
|
| 20 | 20 | ret %3; |
|
| 21 | 21 | @guard#pass4 |
|
| 22 | - | load w64 %6 %4 0; |
|
| 22 | + | load ptr %6 %4 0; |
|
| 23 | 23 | mul w64 %7 %2 4; |
|
| 24 | 24 | add ptr %8 %6 %7; |
|
| 25 | 25 | load w32 %9 %8 0; |
|
| 26 | 26 | call w32 %10 $max(%3, %9); |
|
| 27 | 27 | add w32 %11 %2 1; |
test/tests/opt.slice.npo.ril
+13 -13
| 23 | 23 | @entry0 |
|
| 24 | 24 | reserve %0 16 8; |
|
| 25 | 25 | store ptr 0 %0 0; |
|
| 26 | 26 | store w32 0 %0 8; |
|
| 27 | 27 | store w32 0 %0 12; |
|
| 28 | - | load w64 %1 %0 0; |
|
| 28 | + | load ptr %1 %0 0; |
|
| 29 | 29 | eq ptr %2 %1 0; |
|
| 30 | 30 | br.ne w32 %2 0 @assert.ok2 @assert.fail1; |
|
| 31 | 31 | @assert.fail1 |
|
| 32 | 32 | unreachable; |
|
| 33 | 33 | @assert.ok2 |
| 44 | 44 | store ptr %0 %1 0; |
|
| 45 | 45 | store w32 3 %1 8; |
|
| 46 | 46 | store w32 3 %1 12; |
|
| 47 | 47 | reserve %2 16 8; |
|
| 48 | 48 | blit %2 %1 16; |
|
| 49 | - | load w64 %3 %2 0; |
|
| 49 | + | load ptr %3 %2 0; |
|
| 50 | 50 | ne ptr %4 %3 0; |
|
| 51 | 51 | br.ne w32 %4 0 @assert.ok2 @assert.fail1; |
|
| 52 | 52 | @assert.fail1 |
|
| 53 | 53 | unreachable; |
|
| 54 | 54 | @assert.ok2 |
| 67 | 67 | store w32 3 %1 12; |
|
| 68 | 68 | reserve %2 16 8; |
|
| 69 | 69 | blit %2 %1 16; |
|
| 70 | 70 | reserve %3 16 8; |
|
| 71 | 71 | blit %3 %2 16; |
|
| 72 | - | load w64 %4 %3 0; |
|
| 72 | + | load ptr %4 %3 0; |
|
| 73 | 73 | br.ne w32 %4 0 @then1 @else2; |
|
| 74 | 74 | @then1 |
|
| 75 | 75 | load w32 %5 %3 8; |
|
| 76 | 76 | br.eq w32 %5 3 @assert.ok4 @assert.fail3; |
|
| 77 | 77 | @else2 |
| 85 | 85 | unreachable; |
|
| 86 | 86 | @assert.ok6 |
|
| 87 | 87 | load w32 %9 %3 8; |
|
| 88 | 88 | br.ult w32 1 %9 @guard#pass11 @guard#trap12; |
|
| 89 | 89 | @guard#pass7 |
|
| 90 | - | load w64 %7 %3 0; |
|
| 90 | + | load ptr %7 %3 0; |
|
| 91 | 91 | load w8 %8 %7 0; |
|
| 92 | 92 | br.eq w8 %8 10 @assert.ok6 @assert.fail5; |
|
| 93 | 93 | @guard#trap8 |
|
| 94 | 94 | ebreak; |
|
| 95 | 95 | unreachable; |
|
| 96 | 96 | @assert.fail9 |
|
| 97 | 97 | unreachable; |
|
| 98 | 98 | @assert.ok10 |
|
| 99 | 99 | jmp @merge13; |
|
| 100 | 100 | @guard#pass11 |
|
| 101 | - | load w64 %10 %3 0; |
|
| 101 | + | load ptr %10 %3 0; |
|
| 102 | 102 | add ptr %11 %10 1; |
|
| 103 | 103 | load w8 %12 %11 0; |
|
| 104 | 104 | br.eq w8 %12 20 @assert.ok10 @assert.fail9; |
|
| 105 | 105 | @guard#trap12 |
|
| 106 | 106 | ebreak; |
| 110 | 110 | store ptr 0 %13 0; |
|
| 111 | 111 | store w32 0 %13 8; |
|
| 112 | 112 | store w32 0 %13 12; |
|
| 113 | 113 | reserve %14 16 8; |
|
| 114 | 114 | blit %14 %13 16; |
|
| 115 | - | load w64 %15 %14 0; |
|
| 115 | + | load ptr %15 %14 0; |
|
| 116 | 116 | br.ne w32 %15 0 @then14 @else15; |
|
| 117 | 117 | @then14 |
|
| 118 | 118 | ret 35; |
|
| 119 | 119 | @else15 |
|
| 120 | 120 | jmp @merge16; |
| 134 | 134 | store w32 3 %1 12; |
|
| 135 | 135 | reserve %2 16 8; |
|
| 136 | 136 | blit %2 %1 16; |
|
| 137 | 137 | reserve %3 16 8; |
|
| 138 | 138 | blit %3 %2 16; |
|
| 139 | - | load w64 %4 %3 0; |
|
| 139 | + | load ptr %4 %3 0; |
|
| 140 | 140 | br.ne w32 %4 0 @merge1 @else2; |
|
| 141 | 141 | @merge1 |
|
| 142 | 142 | load w32 %5 %3 8; |
|
| 143 | 143 | br.eq w32 %5 3 @assert.ok4 @assert.fail3; |
|
| 144 | 144 | @else2 |
| 174 | 174 | ||
| 175 | 175 | fn w8 $checkReturn() { |
|
| 176 | 176 | @entry0 |
|
| 177 | 177 | reserve %0 16 8; |
|
| 178 | 178 | call ptr %1 $returnNil(%0); |
|
| 179 | - | load w64 %2 %1 0; |
|
| 179 | + | load ptr %2 %1 0; |
|
| 180 | 180 | eq ptr %3 %2 0; |
|
| 181 | 181 | br.ne w32 %3 0 @assert.ok2 @assert.fail1; |
|
| 182 | 182 | @assert.fail1 |
|
| 183 | 183 | unreachable; |
|
| 184 | 184 | @assert.ok2 |
|
| 185 | 185 | reserve %4 16 8; |
|
| 186 | 186 | call ptr %5 $returnSome(%4); |
|
| 187 | - | load w64 %6 %5 0; |
|
| 187 | + | load ptr %6 %5 0; |
|
| 188 | 188 | ne ptr %7 %6 0; |
|
| 189 | 189 | br.ne w32 %7 0 @assert.ok4 @assert.fail3; |
|
| 190 | 190 | @assert.fail3 |
|
| 191 | 191 | unreachable; |
|
| 192 | 192 | @assert.ok4 |
|
| 193 | 193 | reserve %8 16 8; |
|
| 194 | 194 | blit %8 %5 16; |
|
| 195 | - | load w64 %9 %8 0; |
|
| 195 | + | load ptr %9 %8 0; |
|
| 196 | 196 | br.ne w32 %9 0 @then5 @else6; |
|
| 197 | 197 | @then5 |
|
| 198 | 198 | load w32 %10 %8 8; |
|
| 199 | 199 | br.ult w32 0 %10 @guard#pass9 @guard#trap10; |
|
| 200 | 200 | @else6 |
| 202 | 202 | @assert.fail7 |
|
| 203 | 203 | unreachable; |
|
| 204 | 204 | @assert.ok8 |
|
| 205 | 205 | jmp @merge11; |
|
| 206 | 206 | @guard#pass9 |
|
| 207 | - | load w64 %11 %8 0; |
|
| 207 | + | load ptr %11 %8 0; |
|
| 208 | 208 | load w8 %12 %11 0; |
|
| 209 | 209 | br.eq w8 %12 42 @assert.ok8 @assert.fail7; |
|
| 210 | 210 | @guard#trap10 |
|
| 211 | 211 | ebreak; |
|
| 212 | 212 | unreachable; |
| 227 | 227 | blit %2 %1 16; |
|
| 228 | 228 | reserve %3 16 8; |
|
| 229 | 229 | blit %3 %2 16; |
|
| 230 | 230 | jmp @arm1; |
|
| 231 | 231 | @arm1 |
|
| 232 | - | load w64 %4 %3 0; |
|
| 232 | + | load ptr %4 %3 0; |
|
| 233 | 233 | br.eq ptr %4 0 @case2 @arm3; |
|
| 234 | 234 | @case2 |
|
| 235 | 235 | ret 60; |
|
| 236 | 236 | @arm3 |
|
| 237 | 237 | jmp @else4; |
| 244 | 244 | store w32 0 %5 12; |
|
| 245 | 245 | reserve %6 16 8; |
|
| 246 | 246 | blit %6 %5 16; |
|
| 247 | 247 | jmp @arm7; |
|
| 248 | 248 | @arm7 |
|
| 249 | - | load w64 %7 %6 0; |
|
| 249 | + | load ptr %7 %6 0; |
|
| 250 | 250 | br.eq ptr %7 0 @case8 @arm9; |
|
| 251 | 251 | @case8 |
|
| 252 | 252 | jmp @merge10; |
|
| 253 | 253 | @arm9 |
|
| 254 | 254 | jmp @else11; |
test/tests/ptr.deref.ril
+1 -1
| 15 | 15 | fn w32 $derefSliceIndex(ptr %0) { |
|
| 16 | 16 | @entry0 |
|
| 17 | 17 | load w32 %1 %0 8; |
|
| 18 | 18 | br.ult w32 2 %1 @guard#pass1 @guard#trap2; |
|
| 19 | 19 | @guard#pass1 |
|
| 20 | - | load w64 %2 %0 0; |
|
| 20 | + | load ptr %2 %0 0; |
|
| 21 | 21 | mul w64 %3 2 4; |
|
| 22 | 22 | add ptr %4 %2 %3; |
|
| 23 | 23 | sload w32 %5 %4 0; |
|
| 24 | 24 | ret %5; |
|
| 25 | 25 | @guard#trap2 |
test/tests/ptr.subscript.assign.ril
+1 -1
| 1 | 1 | fn w64 $subscriptAssign(ptr %0, w32 %1, w32 %2) { |
|
| 2 | 2 | @entry0 |
|
| 3 | 3 | load w32 %3 %0 8; |
|
| 4 | 4 | br.ult w32 %1 %3 @guard#pass1 @guard#trap2; |
|
| 5 | 5 | @guard#pass1 |
|
| 6 | - | load w64 %4 %0 0; |
|
| 6 | + | load ptr %4 %0 0; |
|
| 7 | 7 | mul w64 %5 %1 4; |
|
| 8 | 8 | add ptr %6 %4 %5; |
|
| 9 | 9 | store w32 %2 %6 0; |
|
| 10 | 10 | ret; |
|
| 11 | 11 | @guard#trap2 |
test/tests/slice.append.ril
+79 -79
| 25 | 25 | unreachable; |
|
| 26 | 26 | @assert.ok2 |
|
| 27 | 27 | load w32 %10 %0 8; |
|
| 28 | 28 | br.ult w32 %7 %10 @guard#pass3 @guard#trap4; |
|
| 29 | 29 | @guard#pass3 |
|
| 30 | - | load w64 %11 %0 0; |
|
| 30 | + | load ptr %11 %0 0; |
|
| 31 | 31 | add ptr %12 %11 %7; |
|
| 32 | 32 | store w32 %8 %0 16; |
|
| 33 | 33 | ret %12; |
|
| 34 | 34 | @guard#trap4 |
|
| 35 | 35 | ebreak; |
| 71 | 71 | store w32 4 %8 12; |
|
| 72 | 72 | load w32 %9 %8 8; |
|
| 73 | 73 | load w32 %10 %8 12; |
|
| 74 | 74 | br.ult w32 %9 %10 @append.store1 @append.grow2; |
|
| 75 | 75 | @append.store1 |
|
| 76 | - | load w64 %24 %8 0; |
|
| 76 | + | load ptr %24 %8 0; |
|
| 77 | 77 | mul w64 %25 %9 4; |
|
| 78 | 78 | add ptr %26 %24 %25; |
|
| 79 | 79 | store w32 10 %26 0; |
|
| 80 | 80 | add w32 %27 %9 1; |
|
| 81 | 81 | store w32 %27 %8 8; |
| 83 | 83 | load w32 %33 %8 12; |
|
| 84 | 84 | br.ult w32 %32 %33 @append.store6 @append.grow7; |
|
| 85 | 85 | @append.grow2 |
|
| 86 | 86 | shl w32 %11 %10 1; |
|
| 87 | 87 | or w32 %12 %11 1; |
|
| 88 | - | load w64 %13 %5 0; |
|
| 89 | - | load w64 %14 %5 8; |
|
| 88 | + | load ptr %13 %5 0; |
|
| 89 | + | load ptr %14 %5 8; |
|
| 90 | 90 | mul w32 %15 %12 4; |
|
| 91 | 91 | call ptr %16 %13(%14, %15, 4); |
|
| 92 | - | load w64 %17 %8 0; |
|
| 92 | + | load ptr %17 %8 0; |
|
| 93 | 93 | mul w32 %18 %9 4; |
|
| 94 | 94 | jmp @append3(0); |
|
| 95 | 95 | @append3(w32 %19) |
|
| 96 | 96 | br.ult w32 %19 %18 @append4 @append5; |
|
| 97 | 97 | @append4 |
| 100 | 100 | add ptr %22 %16 %19; |
|
| 101 | 101 | store w8 %21 %22 0; |
|
| 102 | 102 | add w32 %23 %19 1; |
|
| 103 | 103 | jmp @append3(%23); |
|
| 104 | 104 | @append5 |
|
| 105 | - | store w64 %16 %8 0; |
|
| 105 | + | store ptr %16 %8 0; |
|
| 106 | 106 | store w32 %12 %8 12; |
|
| 107 | 107 | jmp @append.store1; |
|
| 108 | 108 | @append.store6 |
|
| 109 | - | load w64 %47 %8 0; |
|
| 109 | + | load ptr %47 %8 0; |
|
| 110 | 110 | mul w64 %48 %32 4; |
|
| 111 | 111 | add ptr %49 %47 %48; |
|
| 112 | 112 | store w32 20 %49 0; |
|
| 113 | 113 | add w32 %50 %32 1; |
|
| 114 | 114 | store w32 %50 %8 8; |
| 116 | 116 | load w32 %56 %8 12; |
|
| 117 | 117 | br.ult w32 %55 %56 @append.store11 @append.grow12; |
|
| 118 | 118 | @append.grow7 |
|
| 119 | 119 | shl w32 %34 %33 1; |
|
| 120 | 120 | or w32 %35 %34 1; |
|
| 121 | - | load w64 %36 %5 0; |
|
| 122 | - | load w64 %37 %5 8; |
|
| 121 | + | load ptr %36 %5 0; |
|
| 122 | + | load ptr %37 %5 8; |
|
| 123 | 123 | mul w32 %38 %35 4; |
|
| 124 | 124 | call ptr %39 %36(%37, %38, 4); |
|
| 125 | - | load w64 %40 %8 0; |
|
| 125 | + | load ptr %40 %8 0; |
|
| 126 | 126 | mul w32 %41 %32 4; |
|
| 127 | 127 | jmp @append8(0); |
|
| 128 | 128 | @append8(w32 %42) |
|
| 129 | 129 | br.ult w32 %42 %41 @append9 @append10; |
|
| 130 | 130 | @append9 |
| 133 | 133 | add ptr %45 %39 %42; |
|
| 134 | 134 | store w8 %44 %45 0; |
|
| 135 | 135 | add w32 %46 %42 1; |
|
| 136 | 136 | jmp @append8(%46); |
|
| 137 | 137 | @append10 |
|
| 138 | - | store w64 %39 %8 0; |
|
| 138 | + | store ptr %39 %8 0; |
|
| 139 | 139 | store w32 %35 %8 12; |
|
| 140 | 140 | jmp @append.store6; |
|
| 141 | 141 | @append.store11 |
|
| 142 | - | load w64 %70 %8 0; |
|
| 142 | + | load ptr %70 %8 0; |
|
| 143 | 143 | mul w64 %71 %55 4; |
|
| 144 | 144 | add ptr %72 %70 %71; |
|
| 145 | 145 | store w32 30 %72 0; |
|
| 146 | 146 | add w32 %73 %55 1; |
|
| 147 | 147 | store w32 %73 %8 8; |
|
| 148 | 148 | load w32 %76 %8 8; |
|
| 149 | 149 | br.ne w32 %76 3 @then16 @merge17; |
|
| 150 | 150 | @append.grow12 |
|
| 151 | 151 | shl w32 %57 %56 1; |
|
| 152 | 152 | or w32 %58 %57 1; |
|
| 153 | - | load w64 %59 %5 0; |
|
| 154 | - | load w64 %60 %5 8; |
|
| 153 | + | load ptr %59 %5 0; |
|
| 154 | + | load ptr %60 %5 8; |
|
| 155 | 155 | mul w32 %61 %58 4; |
|
| 156 | 156 | call ptr %62 %59(%60, %61, 4); |
|
| 157 | - | load w64 %63 %8 0; |
|
| 157 | + | load ptr %63 %8 0; |
|
| 158 | 158 | mul w32 %64 %55 4; |
|
| 159 | 159 | jmp @append13(0); |
|
| 160 | 160 | @append13(w32 %65) |
|
| 161 | 161 | br.ult w32 %65 %64 @append14 @append15; |
|
| 162 | 162 | @append14 |
| 165 | 165 | add ptr %68 %62 %65; |
|
| 166 | 166 | store w8 %67 %68 0; |
|
| 167 | 167 | add w32 %69 %65 1; |
|
| 168 | 168 | jmp @append13(%69); |
|
| 169 | 169 | @append15 |
|
| 170 | - | store w64 %62 %8 0; |
|
| 170 | + | store ptr %62 %8 0; |
|
| 171 | 171 | store w32 %58 %8 12; |
|
| 172 | 172 | jmp @append.store11; |
|
| 173 | 173 | @then16 |
|
| 174 | 174 | ret 1; |
|
| 175 | 175 | @merge17 |
| 184 | 184 | ret 3; |
|
| 185 | 185 | @merge21 |
|
| 186 | 186 | load w32 %81 %8 8; |
|
| 187 | 187 | br.ult w32 1 %81 @guard#pass26 @guard#trap27; |
|
| 188 | 188 | @guard#pass22 |
|
| 189 | - | load w64 %79 %8 0; |
|
| 189 | + | load ptr %79 %8 0; |
|
| 190 | 190 | sload w32 %80 %79 0; |
|
| 191 | 191 | br.ne w32 %80 10 @then20 @merge21; |
|
| 192 | 192 | @guard#trap23 |
|
| 193 | 193 | ebreak; |
|
| 194 | 194 | unreachable; |
| 196 | 196 | ret 4; |
|
| 197 | 197 | @merge25 |
|
| 198 | 198 | load w32 %86 %8 8; |
|
| 199 | 199 | br.ult w32 2 %86 @guard#pass30 @guard#trap31; |
|
| 200 | 200 | @guard#pass26 |
|
| 201 | - | load w64 %82 %8 0; |
|
| 201 | + | load ptr %82 %8 0; |
|
| 202 | 202 | mul w64 %83 1 4; |
|
| 203 | 203 | add ptr %84 %82 %83; |
|
| 204 | 204 | sload w32 %85 %84 0; |
|
| 205 | 205 | br.ne w32 %85 20 @then24 @merge25; |
|
| 206 | 206 | @guard#trap27 |
| 211 | 211 | @merge29 |
|
| 212 | 212 | load w32 %93 %8 8; |
|
| 213 | 213 | load w32 %94 %8 12; |
|
| 214 | 214 | br.ult w32 %93 %94 @append.store32 @append.grow33; |
|
| 215 | 215 | @guard#pass30 |
|
| 216 | - | load w64 %87 %8 0; |
|
| 216 | + | load ptr %87 %8 0; |
|
| 217 | 217 | mul w64 %88 2 4; |
|
| 218 | 218 | add ptr %89 %87 %88; |
|
| 219 | 219 | sload w32 %90 %89 0; |
|
| 220 | 220 | br.ne w32 %90 30 @then28 @merge29; |
|
| 221 | 221 | @guard#trap31 |
|
| 222 | 222 | ebreak; |
|
| 223 | 223 | unreachable; |
|
| 224 | 224 | @append.store32 |
|
| 225 | - | load w64 %108 %8 0; |
|
| 225 | + | load ptr %108 %8 0; |
|
| 226 | 226 | mul w64 %109 %93 4; |
|
| 227 | 227 | add ptr %110 %108 %109; |
|
| 228 | 228 | store w32 40 %110 0; |
|
| 229 | 229 | add w32 %111 %93 1; |
|
| 230 | 230 | store w32 %111 %8 8; |
|
| 231 | 231 | load w32 %114 %8 8; |
|
| 232 | 232 | br.ne w32 %114 4 @then37 @merge38; |
|
| 233 | 233 | @append.grow33 |
|
| 234 | 234 | shl w32 %95 %94 1; |
|
| 235 | 235 | or w32 %96 %95 1; |
|
| 236 | - | load w64 %97 %5 0; |
|
| 237 | - | load w64 %98 %5 8; |
|
| 236 | + | load ptr %97 %5 0; |
|
| 237 | + | load ptr %98 %5 8; |
|
| 238 | 238 | mul w32 %99 %96 4; |
|
| 239 | 239 | call ptr %100 %97(%98, %99, 4); |
|
| 240 | - | load w64 %101 %8 0; |
|
| 240 | + | load ptr %101 %8 0; |
|
| 241 | 241 | mul w32 %102 %93 4; |
|
| 242 | 242 | jmp @append34(0); |
|
| 243 | 243 | @append34(w32 %103) |
|
| 244 | 244 | br.ult w32 %103 %102 @append35 @append36; |
|
| 245 | 245 | @append35 |
| 248 | 248 | add ptr %106 %100 %103; |
|
| 249 | 249 | store w8 %105 %106 0; |
|
| 250 | 250 | add w32 %107 %103 1; |
|
| 251 | 251 | jmp @append34(%107); |
|
| 252 | 252 | @append36 |
|
| 253 | - | store w64 %100 %8 0; |
|
| 253 | + | store ptr %100 %8 0; |
|
| 254 | 254 | store w32 %96 %8 12; |
|
| 255 | 255 | jmp @append.store32; |
|
| 256 | 256 | @then37 |
|
| 257 | 257 | ret 6; |
|
| 258 | 258 | @merge38 |
| 263 | 263 | @merge40 |
|
| 264 | 264 | load w32 %118 %8 8; |
|
| 265 | 265 | load w32 %119 %8 12; |
|
| 266 | 266 | br.ult w32 %118 %119 @append.store41 @append.grow42; |
|
| 267 | 267 | @append.store41 |
|
| 268 | - | load w64 %133 %8 0; |
|
| 268 | + | load ptr %133 %8 0; |
|
| 269 | 269 | mul w64 %134 %118 4; |
|
| 270 | 270 | add ptr %135 %133 %134; |
|
| 271 | 271 | store w32 50 %135 0; |
|
| 272 | 272 | add w32 %136 %118 1; |
|
| 273 | 273 | store w32 %136 %8 8; |
|
| 274 | 274 | load w32 %139 %8 8; |
|
| 275 | 275 | br.ne w32 %139 5 @then46 @merge47; |
|
| 276 | 276 | @append.grow42 |
|
| 277 | 277 | shl w32 %120 %119 1; |
|
| 278 | 278 | or w32 %121 %120 1; |
|
| 279 | - | load w64 %122 %5 0; |
|
| 280 | - | load w64 %123 %5 8; |
|
| 279 | + | load ptr %122 %5 0; |
|
| 280 | + | load ptr %123 %5 8; |
|
| 281 | 281 | mul w32 %124 %121 4; |
|
| 282 | 282 | call ptr %125 %122(%123, %124, 4); |
|
| 283 | - | load w64 %126 %8 0; |
|
| 283 | + | load ptr %126 %8 0; |
|
| 284 | 284 | mul w32 %127 %118 4; |
|
| 285 | 285 | jmp @append43(0); |
|
| 286 | 286 | @append43(w32 %128) |
|
| 287 | 287 | br.ult w32 %128 %127 @append44 @append45; |
|
| 288 | 288 | @append44 |
| 291 | 291 | add ptr %131 %125 %128; |
|
| 292 | 292 | store w8 %130 %131 0; |
|
| 293 | 293 | add w32 %132 %128 1; |
|
| 294 | 294 | jmp @append43(%132); |
|
| 295 | 295 | @append45 |
|
| 296 | - | store w64 %125 %8 0; |
|
| 296 | + | store ptr %125 %8 0; |
|
| 297 | 297 | store w32 %121 %8 12; |
|
| 298 | 298 | jmp @append.store41; |
|
| 299 | 299 | @then46 |
|
| 300 | 300 | ret 8; |
|
| 301 | 301 | @merge47 |
| 310 | 310 | ret 10; |
|
| 311 | 311 | @merge51 |
|
| 312 | 312 | load w32 %146 %8 8; |
|
| 313 | 313 | br.ult w32 0 %146 @guard#pass56 @guard#trap57; |
|
| 314 | 314 | @guard#pass52 |
|
| 315 | - | load w64 %142 %8 0; |
|
| 315 | + | load ptr %142 %8 0; |
|
| 316 | 316 | mul w64 %143 4 4; |
|
| 317 | 317 | add ptr %144 %142 %143; |
|
| 318 | 318 | sload w32 %145 %144 0; |
|
| 319 | 319 | br.ne w32 %145 50 @then50 @merge51; |
|
| 320 | 320 | @guard#trap53 |
| 324 | 324 | ret 11; |
|
| 325 | 325 | @merge55 |
|
| 326 | 326 | load w32 %149 %8 8; |
|
| 327 | 327 | br.ult w32 3 %149 @guard#pass60 @guard#trap61; |
|
| 328 | 328 | @guard#pass56 |
|
| 329 | - | load w64 %147 %8 0; |
|
| 329 | + | load ptr %147 %8 0; |
|
| 330 | 330 | sload w32 %148 %147 0; |
|
| 331 | 331 | br.ne w32 %148 10 @then54 @merge55; |
|
| 332 | 332 | @guard#trap57 |
|
| 333 | 333 | ebreak; |
|
| 334 | 334 | unreachable; |
| 341 | 341 | store w32 0 %164 12; |
|
| 342 | 342 | load w32 %167 %164 8; |
|
| 343 | 343 | load w32 %168 %164 12; |
|
| 344 | 344 | br.ult w32 %167 %168 @append.store62 @append.grow63; |
|
| 345 | 345 | @guard#pass60 |
|
| 346 | - | load w64 %150 %8 0; |
|
| 346 | + | load ptr %150 %8 0; |
|
| 347 | 347 | mul w64 %151 3 4; |
|
| 348 | 348 | add ptr %152 %150 %151; |
|
| 349 | 349 | sload w32 %153 %152 0; |
|
| 350 | 350 | br.ne w32 %153 40 @then58 @merge59; |
|
| 351 | 351 | @guard#trap61 |
|
| 352 | 352 | ebreak; |
|
| 353 | 353 | unreachable; |
|
| 354 | 354 | @append.store62 |
|
| 355 | - | load w64 %182 %164 0; |
|
| 355 | + | load ptr %182 %164 0; |
|
| 356 | 356 | mul w64 %183 %167 4; |
|
| 357 | 357 | add ptr %184 %182 %183; |
|
| 358 | 358 | store w32 99 %184 0; |
|
| 359 | 359 | add w32 %185 %167 1; |
|
| 360 | 360 | store w32 %185 %164 8; |
|
| 361 | 361 | load w32 %188 %164 8; |
|
| 362 | 362 | br.ne w32 %188 1 @then67 @merge68; |
|
| 363 | 363 | @append.grow63 |
|
| 364 | 364 | shl w32 %169 %168 1; |
|
| 365 | 365 | or w32 %170 %169 1; |
|
| 366 | - | load w64 %171 %5 0; |
|
| 367 | - | load w64 %172 %5 8; |
|
| 366 | + | load ptr %171 %5 0; |
|
| 367 | + | load ptr %172 %5 8; |
|
| 368 | 368 | mul w32 %173 %170 4; |
|
| 369 | 369 | call ptr %174 %171(%172, %173, 4); |
|
| 370 | - | load w64 %175 %164 0; |
|
| 370 | + | load ptr %175 %164 0; |
|
| 371 | 371 | mul w32 %176 %167 4; |
|
| 372 | 372 | jmp @append64(0); |
|
| 373 | 373 | @append64(w32 %177) |
|
| 374 | 374 | br.ult w32 %177 %176 @append65 @append66; |
|
| 375 | 375 | @append65 |
| 378 | 378 | add ptr %180 %174 %177; |
|
| 379 | 379 | store w8 %179 %180 0; |
|
| 380 | 380 | add w32 %181 %177 1; |
|
| 381 | 381 | jmp @append64(%181); |
|
| 382 | 382 | @append66 |
|
| 383 | - | store w64 %174 %164 0; |
|
| 383 | + | store ptr %174 %164 0; |
|
| 384 | 384 | store w32 %170 %164 12; |
|
| 385 | 385 | jmp @append.store62; |
|
| 386 | 386 | @then67 |
|
| 387 | 387 | ret 13; |
|
| 388 | 388 | @merge68 |
| 395 | 395 | br.ult w32 0 %190 @guard#pass73 @guard#trap74; |
|
| 396 | 396 | @then71 |
|
| 397 | 397 | ret 15; |
|
| 398 | 398 | @merge72 |
|
| 399 | 399 | load w32 %195 %8 8; |
|
| 400 | - | load w64 %196 %8 0; |
|
| 400 | + | load ptr %196 %8 0; |
|
| 401 | 401 | jmp @loop75(0, 0); |
|
| 402 | 402 | @guard#pass73 |
|
| 403 | - | load w64 %191 %164 0; |
|
| 403 | + | load ptr %191 %164 0; |
|
| 404 | 404 | sload w32 %192 %191 0; |
|
| 405 | 405 | br.ne w32 %192 99 @then71 @merge72; |
|
| 406 | 406 | @guard#trap74 |
|
| 407 | 407 | ebreak; |
|
| 408 | 408 | unreachable; |
| 427 | 427 | store w32 2 %218 12; |
|
| 428 | 428 | load w32 %222 %218 8; |
|
| 429 | 429 | load w32 %223 %218 12; |
|
| 430 | 430 | br.ult w32 %222 %223 @append.store80 @append.grow81; |
|
| 431 | 431 | @append.store80 |
|
| 432 | - | load w64 %237 %218 0; |
|
| 432 | + | load ptr %237 %218 0; |
|
| 433 | 433 | add ptr %238 %237 %222; |
|
| 434 | 434 | store w8 171 %238 0; |
|
| 435 | 435 | add w32 %239 %222 1; |
|
| 436 | 436 | store w32 %239 %218 8; |
|
| 437 | 437 | load w32 %244 %218 8; |
|
| 438 | 438 | load w32 %245 %218 12; |
|
| 439 | 439 | br.ult w32 %244 %245 @append.store85 @append.grow86; |
|
| 440 | 440 | @append.grow81 |
|
| 441 | 441 | shl w32 %224 %223 1; |
|
| 442 | 442 | or w32 %225 %224 1; |
|
| 443 | - | load w64 %226 %5 0; |
|
| 444 | - | load w64 %227 %5 8; |
|
| 443 | + | load ptr %226 %5 0; |
|
| 444 | + | load ptr %227 %5 8; |
|
| 445 | 445 | mul w32 %228 %225 1; |
|
| 446 | 446 | call ptr %229 %226(%227, %228, 1); |
|
| 447 | - | load w64 %230 %218 0; |
|
| 447 | + | load ptr %230 %218 0; |
|
| 448 | 448 | mul w32 %231 %222 1; |
|
| 449 | 449 | jmp @append82(0); |
|
| 450 | 450 | @append82(w32 %232) |
|
| 451 | 451 | br.ult w32 %232 %231 @append83 @append84; |
|
| 452 | 452 | @append83 |
| 455 | 455 | add ptr %235 %229 %232; |
|
| 456 | 456 | store w8 %234 %235 0; |
|
| 457 | 457 | add w32 %236 %232 1; |
|
| 458 | 458 | jmp @append82(%236); |
|
| 459 | 459 | @append84 |
|
| 460 | - | store w64 %229 %218 0; |
|
| 460 | + | store ptr %229 %218 0; |
|
| 461 | 461 | store w32 %225 %218 12; |
|
| 462 | 462 | jmp @append.store80; |
|
| 463 | 463 | @append.store85 |
|
| 464 | - | load w64 %259 %218 0; |
|
| 464 | + | load ptr %259 %218 0; |
|
| 465 | 465 | add ptr %260 %259 %244; |
|
| 466 | 466 | store w8 205 %260 0; |
|
| 467 | 467 | add w32 %261 %244 1; |
|
| 468 | 468 | store w32 %261 %218 8; |
|
| 469 | 469 | load w32 %264 %218 8; |
|
| 470 | 470 | br.ne w32 %264 2 @then90 @merge91; |
|
| 471 | 471 | @append.grow86 |
|
| 472 | 472 | shl w32 %246 %245 1; |
|
| 473 | 473 | or w32 %247 %246 1; |
|
| 474 | - | load w64 %248 %5 0; |
|
| 475 | - | load w64 %249 %5 8; |
|
| 474 | + | load ptr %248 %5 0; |
|
| 475 | + | load ptr %249 %5 8; |
|
| 476 | 476 | mul w32 %250 %247 1; |
|
| 477 | 477 | call ptr %251 %248(%249, %250, 1); |
|
| 478 | - | load w64 %252 %218 0; |
|
| 478 | + | load ptr %252 %218 0; |
|
| 479 | 479 | mul w32 %253 %244 1; |
|
| 480 | 480 | jmp @append87(0); |
|
| 481 | 481 | @append87(w32 %254) |
|
| 482 | 482 | br.ult w32 %254 %253 @append88 @append89; |
|
| 483 | 483 | @append88 |
| 486 | 486 | add ptr %257 %251 %254; |
|
| 487 | 487 | store w8 %256 %257 0; |
|
| 488 | 488 | add w32 %258 %254 1; |
|
| 489 | 489 | jmp @append87(%258); |
|
| 490 | 490 | @append89 |
|
| 491 | - | store w64 %251 %218 0; |
|
| 491 | + | store ptr %251 %218 0; |
|
| 492 | 492 | store w32 %247 %218 12; |
|
| 493 | 493 | jmp @append.store85; |
|
| 494 | 494 | @then90 |
|
| 495 | 495 | ret 17; |
|
| 496 | 496 | @merge91 |
| 500 | 500 | ret 18; |
|
| 501 | 501 | @merge93 |
|
| 502 | 502 | load w32 %268 %218 8; |
|
| 503 | 503 | br.ult w32 1 %268 @guard#pass98 @guard#trap99; |
|
| 504 | 504 | @guard#pass94 |
|
| 505 | - | load w64 %266 %218 0; |
|
| 505 | + | load ptr %266 %218 0; |
|
| 506 | 506 | load w8 %267 %266 0; |
|
| 507 | 507 | br.ne w8 %267 171 @then92 @merge93; |
|
| 508 | 508 | @guard#trap95 |
|
| 509 | 509 | ebreak; |
|
| 510 | 510 | unreachable; |
| 513 | 513 | @merge97 |
|
| 514 | 514 | load w32 %274 %218 8; |
|
| 515 | 515 | load w32 %275 %218 12; |
|
| 516 | 516 | br.ult w32 %274 %275 @append.store100 @append.grow101; |
|
| 517 | 517 | @guard#pass98 |
|
| 518 | - | load w64 %269 %218 0; |
|
| 518 | + | load ptr %269 %218 0; |
|
| 519 | 519 | add ptr %270 %269 1; |
|
| 520 | 520 | load w8 %271 %270 0; |
|
| 521 | 521 | br.ne w8 %271 205 @then96 @merge97; |
|
| 522 | 522 | @guard#trap99 |
|
| 523 | 523 | ebreak; |
|
| 524 | 524 | unreachable; |
|
| 525 | 525 | @append.store100 |
|
| 526 | - | load w64 %289 %218 0; |
|
| 526 | + | load ptr %289 %218 0; |
|
| 527 | 527 | add ptr %290 %289 %274; |
|
| 528 | 528 | store w8 239 %290 0; |
|
| 529 | 529 | add w32 %291 %274 1; |
|
| 530 | 530 | store w32 %291 %218 8; |
|
| 531 | 531 | load w32 %294 %218 8; |
|
| 532 | 532 | br.ne w32 %294 3 @then105 @merge106; |
|
| 533 | 533 | @append.grow101 |
|
| 534 | 534 | shl w32 %276 %275 1; |
|
| 535 | 535 | or w32 %277 %276 1; |
|
| 536 | - | load w64 %278 %5 0; |
|
| 537 | - | load w64 %279 %5 8; |
|
| 536 | + | load ptr %278 %5 0; |
|
| 537 | + | load ptr %279 %5 8; |
|
| 538 | 538 | mul w32 %280 %277 1; |
|
| 539 | 539 | call ptr %281 %278(%279, %280, 1); |
|
| 540 | - | load w64 %282 %218 0; |
|
| 540 | + | load ptr %282 %218 0; |
|
| 541 | 541 | mul w32 %283 %274 1; |
|
| 542 | 542 | jmp @append102(0); |
|
| 543 | 543 | @append102(w32 %284) |
|
| 544 | 544 | br.ult w32 %284 %283 @append103 @append104; |
|
| 545 | 545 | @append103 |
| 548 | 548 | add ptr %287 %281 %284; |
|
| 549 | 549 | store w8 %286 %287 0; |
|
| 550 | 550 | add w32 %288 %284 1; |
|
| 551 | 551 | jmp @append102(%288); |
|
| 552 | 552 | @append104 |
|
| 553 | - | store w64 %281 %218 0; |
|
| 553 | + | store ptr %281 %218 0; |
|
| 554 | 554 | store w32 %277 %218 12; |
|
| 555 | 555 | jmp @append.store100; |
|
| 556 | 556 | @then105 |
|
| 557 | 557 | ret 20; |
|
| 558 | 558 | @merge106 |
| 567 | 567 | ret 22; |
|
| 568 | 568 | @merge110 |
|
| 569 | 569 | load w32 %300 %218 8; |
|
| 570 | 570 | br.ult w32 0 %300 @guard#pass115 @guard#trap116; |
|
| 571 | 571 | @guard#pass111 |
|
| 572 | - | load w64 %297 %218 0; |
|
| 572 | + | load ptr %297 %218 0; |
|
| 573 | 573 | add ptr %298 %297 2; |
|
| 574 | 574 | load w8 %299 %298 0; |
|
| 575 | 575 | br.ne w8 %299 239 @then109 @merge110; |
|
| 576 | 576 | @guard#trap112 |
|
| 577 | 577 | ebreak; |
| 587 | 587 | store w32 2 %311 12; |
|
| 588 | 588 | load w32 %314 %311 8; |
|
| 589 | 589 | load w32 %315 %311 12; |
|
| 590 | 590 | br.ult w32 %314 %315 @append.store117 @append.grow118; |
|
| 591 | 591 | @guard#pass115 |
|
| 592 | - | load w64 %301 %218 0; |
|
| 592 | + | load ptr %301 %218 0; |
|
| 593 | 593 | load w8 %302 %301 0; |
|
| 594 | 594 | br.ne w8 %302 171 @then113 @merge114; |
|
| 595 | 595 | @guard#trap116 |
|
| 596 | 596 | ebreak; |
|
| 597 | 597 | unreachable; |
|
| 598 | 598 | @append.store117 |
|
| 599 | - | load w64 %329 %311 0; |
|
| 599 | + | load ptr %329 %311 0; |
|
| 600 | 600 | mul w64 %330 %314 4; |
|
| 601 | 601 | add ptr %331 %329 %330; |
|
| 602 | 602 | store w32 42 %331 0; |
|
| 603 | 603 | add w32 %332 %314 1; |
|
| 604 | 604 | store w32 %332 %311 8; |
| 606 | 606 | load w32 %335 %311 8; |
|
| 607 | 607 | br.eq w32 %335 1 @assert.ok123 @assert.fail122; |
|
| 608 | 608 | @append.grow118 |
|
| 609 | 609 | shl w32 %316 %315 1; |
|
| 610 | 610 | or w32 %317 %316 1; |
|
| 611 | - | load w64 %318 %5 0; |
|
| 612 | - | load w64 %319 %5 8; |
|
| 611 | + | load ptr %318 %5 0; |
|
| 612 | + | load ptr %319 %5 8; |
|
| 613 | 613 | mul w32 %320 %317 4; |
|
| 614 | 614 | call ptr %321 %318(%319, %320, 4); |
|
| 615 | - | load w64 %322 %311 0; |
|
| 615 | + | load ptr %322 %311 0; |
|
| 616 | 616 | mul w32 %323 %314 4; |
|
| 617 | 617 | jmp @append119(0); |
|
| 618 | 618 | @append119(w32 %324) |
|
| 619 | 619 | br.ult w32 %324 %323 @append120 @append121; |
|
| 620 | 620 | @append120 |
| 623 | 623 | add ptr %327 %321 %324; |
|
| 624 | 624 | store w8 %326 %327 0; |
|
| 625 | 625 | add w32 %328 %324 1; |
|
| 626 | 626 | jmp @append119(%328); |
|
| 627 | 627 | @append121 |
|
| 628 | - | store w64 %321 %311 0; |
|
| 628 | + | store ptr %321 %311 0; |
|
| 629 | 629 | store w32 %317 %311 12; |
|
| 630 | 630 | jmp @append.store117; |
|
| 631 | 631 | @assert.fail122 |
|
| 632 | 632 | unreachable; |
|
| 633 | 633 | @assert.ok123 |
| 638 | 638 | @assert.ok125 |
|
| 639 | 639 | load w32 %341 %311 8; |
|
| 640 | 640 | load w32 %342 %311 12; |
|
| 641 | 641 | br.ult w32 %341 %342 @append.store128 @append.grow129; |
|
| 642 | 642 | @guard#pass126 |
|
| 643 | - | load w64 %337 %311 0; |
|
| 643 | + | load ptr %337 %311 0; |
|
| 644 | 644 | sload w32 %338 %337 0; |
|
| 645 | 645 | br.eq w32 %338 42 @assert.ok125 @assert.fail124; |
|
| 646 | 646 | @guard#trap127 |
|
| 647 | 647 | ebreak; |
|
| 648 | 648 | unreachable; |
|
| 649 | 649 | @append.store128 |
|
| 650 | - | load w64 %356 %311 0; |
|
| 650 | + | load ptr %356 %311 0; |
|
| 651 | 651 | mul w64 %357 %341 4; |
|
| 652 | 652 | add ptr %358 %356 %357; |
|
| 653 | 653 | store w32 43 %358 0; |
|
| 654 | 654 | add w32 %359 %341 1; |
|
| 655 | 655 | store w32 %359 %311 8; |
| 657 | 657 | load w32 %362 %311 8; |
|
| 658 | 658 | br.eq w32 %362 2 @assert.ok134 @assert.fail133; |
|
| 659 | 659 | @append.grow129 |
|
| 660 | 660 | shl w32 %343 %342 1; |
|
| 661 | 661 | or w32 %344 %343 1; |
|
| 662 | - | load w64 %345 %5 0; |
|
| 663 | - | load w64 %346 %5 8; |
|
| 662 | + | load ptr %345 %5 0; |
|
| 663 | + | load ptr %346 %5 8; |
|
| 664 | 664 | mul w32 %347 %344 4; |
|
| 665 | 665 | call ptr %348 %345(%346, %347, 4); |
|
| 666 | - | load w64 %349 %311 0; |
|
| 666 | + | load ptr %349 %311 0; |
|
| 667 | 667 | mul w32 %350 %341 4; |
|
| 668 | 668 | jmp @append130(0); |
|
| 669 | 669 | @append130(w32 %351) |
|
| 670 | 670 | br.ult w32 %351 %350 @append131 @append132; |
|
| 671 | 671 | @append131 |
| 674 | 674 | add ptr %354 %348 %351; |
|
| 675 | 675 | store w8 %353 %354 0; |
|
| 676 | 676 | add w32 %355 %351 1; |
|
| 677 | 677 | jmp @append130(%355); |
|
| 678 | 678 | @append132 |
|
| 679 | - | store w64 %348 %311 0; |
|
| 679 | + | store ptr %348 %311 0; |
|
| 680 | 680 | store w32 %344 %311 12; |
|
| 681 | 681 | jmp @append.store128; |
|
| 682 | 682 | @assert.fail133 |
|
| 683 | 683 | unreachable; |
|
| 684 | 684 | @assert.ok134 |
|
| 685 | 685 | load w32 %363 %311 8; |
|
| 686 | 686 | br.ult w32 0 %363 @guard#pass135 @guard#trap136; |
|
| 687 | 687 | @guard#pass135 |
|
| 688 | - | load w64 %364 %311 0; |
|
| 688 | + | load ptr %364 %311 0; |
|
| 689 | 689 | load w32 %367 %311 8; |
|
| 690 | 690 | load w32 %368 %311 12; |
|
| 691 | 691 | br.ult w32 %367 %368 @append.store137 @append.grow138; |
|
| 692 | 692 | @guard#trap136 |
|
| 693 | 693 | ebreak; |
|
| 694 | 694 | unreachable; |
|
| 695 | 695 | @append.store137 |
|
| 696 | - | load w64 %382 %311 0; |
|
| 696 | + | load ptr %382 %311 0; |
|
| 697 | 697 | mul w64 %383 %367 4; |
|
| 698 | 698 | add ptr %384 %382 %383; |
|
| 699 | 699 | store w32 44 %384 0; |
|
| 700 | 700 | add w32 %385 %367 1; |
|
| 701 | 701 | store w32 %385 %311 8; |
| 703 | 703 | load w32 %388 %311 8; |
|
| 704 | 704 | br.eq w32 %388 3 @assert.ok143 @assert.fail142; |
|
| 705 | 705 | @append.grow138 |
|
| 706 | 706 | shl w32 %369 %368 1; |
|
| 707 | 707 | or w32 %370 %369 1; |
|
| 708 | - | load w64 %371 %5 0; |
|
| 709 | - | load w64 %372 %5 8; |
|
| 708 | + | load ptr %371 %5 0; |
|
| 709 | + | load ptr %372 %5 8; |
|
| 710 | 710 | mul w32 %373 %370 4; |
|
| 711 | 711 | call ptr %374 %371(%372, %373, 4); |
|
| 712 | - | load w64 %375 %311 0; |
|
| 712 | + | load ptr %375 %311 0; |
|
| 713 | 713 | mul w32 %376 %367 4; |
|
| 714 | 714 | jmp @append139(0); |
|
| 715 | 715 | @append139(w32 %377) |
|
| 716 | 716 | br.ult w32 %377 %376 @append140 @append141; |
|
| 717 | 717 | @append140 |
| 720 | 720 | add ptr %380 %374 %377; |
|
| 721 | 721 | store w8 %379 %380 0; |
|
| 722 | 722 | add w32 %381 %377 1; |
|
| 723 | 723 | jmp @append139(%381); |
|
| 724 | 724 | @append141 |
|
| 725 | - | store w64 %374 %311 0; |
|
| 725 | + | store ptr %374 %311 0; |
|
| 726 | 726 | store w32 %370 %311 12; |
|
| 727 | 727 | jmp @append.store137; |
|
| 728 | 728 | @assert.fail142 |
|
| 729 | 729 | unreachable; |
|
| 730 | 730 | @assert.ok143 |
| 734 | 734 | unreachable; |
|
| 735 | 735 | @assert.ok145 |
|
| 736 | 736 | load w32 %390 %311 8; |
|
| 737 | 737 | br.ult w32 0 %390 @guard#pass146 @guard#trap147; |
|
| 738 | 738 | @guard#pass146 |
|
| 739 | - | load w64 %391 %311 0; |
|
| 739 | + | load ptr %391 %311 0; |
|
| 740 | 740 | br.ne ptr %364 %391 @assert.ok149 @assert.fail148; |
|
| 741 | 741 | @guard#trap147 |
|
| 742 | 742 | ebreak; |
|
| 743 | 743 | unreachable; |
|
| 744 | 744 | @assert.fail148 |
| 750 | 750 | unreachable; |
|
| 751 | 751 | @assert.ok151 |
|
| 752 | 752 | load w32 %397 %311 8; |
|
| 753 | 753 | br.ult w32 1 %397 @guard#pass156 @guard#trap157; |
|
| 754 | 754 | @guard#pass152 |
|
| 755 | - | load w64 %395 %311 0; |
|
| 755 | + | load ptr %395 %311 0; |
|
| 756 | 756 | sload w32 %396 %395 0; |
|
| 757 | 757 | br.eq w32 %396 42 @assert.ok151 @assert.fail150; |
|
| 758 | 758 | @guard#trap153 |
|
| 759 | 759 | ebreak; |
|
| 760 | 760 | unreachable; |
| 762 | 762 | unreachable; |
|
| 763 | 763 | @assert.ok155 |
|
| 764 | 764 | load w32 %402 %311 8; |
|
| 765 | 765 | br.ult w32 2 %402 @guard#pass160 @guard#trap161; |
|
| 766 | 766 | @guard#pass156 |
|
| 767 | - | load w64 %398 %311 0; |
|
| 767 | + | load ptr %398 %311 0; |
|
| 768 | 768 | mul w64 %399 1 4; |
|
| 769 | 769 | add ptr %400 %398 %399; |
|
| 770 | 770 | sload w32 %401 %400 0; |
|
| 771 | 771 | br.eq w32 %401 43 @assert.ok155 @assert.fail154; |
|
| 772 | 772 | @guard#trap157 |
| 775 | 775 | @assert.fail158 |
|
| 776 | 776 | unreachable; |
|
| 777 | 777 | @assert.ok159 |
|
| 778 | 778 | ret 0; |
|
| 779 | 779 | @guard#pass160 |
|
| 780 | - | load w64 %403 %311 0; |
|
| 780 | + | load ptr %403 %311 0; |
|
| 781 | 781 | mul w64 %404 2 4; |
|
| 782 | 782 | add ptr %405 %403 %404; |
|
| 783 | 783 | sload w32 %406 %405 0; |
|
| 784 | 784 | br.eq w32 %406 44 @assert.ok159 @assert.fail158; |
|
| 785 | 785 | @guard#trap161 |
test/tests/slice.delete.ril
+12 -12
| 11 | 11 | store w32 5 %1 8; |
|
| 12 | 12 | store w32 5 %1 12; |
|
| 13 | 13 | load w32 %2 %1 8; |
|
| 14 | 14 | br.ult w32 2 %2 @guard#pass1 @guard#trap2; |
|
| 15 | 15 | @guard#pass1 |
|
| 16 | - | load w64 %3 %1 0; |
|
| 16 | + | load ptr %3 %1 0; |
|
| 17 | 17 | mul w64 %4 2 4; |
|
| 18 | 18 | add ptr %5 %3 %4; |
|
| 19 | 19 | add ptr %6 %5 4; |
|
| 20 | 20 | sub w32 %7 %2 2; |
|
| 21 | 21 | sub w32 %8 %7 1; |
| 47 | 47 | ret 2; |
|
| 48 | 48 | @merge9 |
|
| 49 | 49 | load w32 %21 %1 8; |
|
| 50 | 50 | br.ult w32 1 %21 @guard#pass14 @guard#trap15; |
|
| 51 | 51 | @guard#pass10 |
|
| 52 | - | load w64 %19 %1 0; |
|
| 52 | + | load ptr %19 %1 0; |
|
| 53 | 53 | sload w32 %20 %19 0; |
|
| 54 | 54 | br.ne w32 %20 10 @then8 @merge9; |
|
| 55 | 55 | @guard#trap11 |
|
| 56 | 56 | ebreak; |
|
| 57 | 57 | unreachable; |
| 59 | 59 | ret 3; |
|
| 60 | 60 | @merge13 |
|
| 61 | 61 | load w32 %26 %1 8; |
|
| 62 | 62 | br.ult w32 2 %26 @guard#pass18 @guard#trap19; |
|
| 63 | 63 | @guard#pass14 |
|
| 64 | - | load w64 %22 %1 0; |
|
| 64 | + | load ptr %22 %1 0; |
|
| 65 | 65 | mul w64 %23 1 4; |
|
| 66 | 66 | add ptr %24 %22 %23; |
|
| 67 | 67 | sload w32 %25 %24 0; |
|
| 68 | 68 | br.ne w32 %25 20 @then12 @merge13; |
|
| 69 | 69 | @guard#trap15 |
| 73 | 73 | ret 4; |
|
| 74 | 74 | @merge17 |
|
| 75 | 75 | load w32 %31 %1 8; |
|
| 76 | 76 | br.ult w32 3 %31 @guard#pass22 @guard#trap23; |
|
| 77 | 77 | @guard#pass18 |
|
| 78 | - | load w64 %27 %1 0; |
|
| 78 | + | load ptr %27 %1 0; |
|
| 79 | 79 | mul w64 %28 2 4; |
|
| 80 | 80 | add ptr %29 %27 %28; |
|
| 81 | 81 | sload w32 %30 %29 0; |
|
| 82 | 82 | br.ne w32 %30 40 @then16 @merge17; |
|
| 83 | 83 | @guard#trap19 |
| 87 | 87 | ret 5; |
|
| 88 | 88 | @merge21 |
|
| 89 | 89 | load w32 %36 %1 8; |
|
| 90 | 90 | br.ult w32 0 %36 @guard#pass24 @guard#trap25; |
|
| 91 | 91 | @guard#pass22 |
|
| 92 | - | load w64 %32 %1 0; |
|
| 92 | + | load ptr %32 %1 0; |
|
| 93 | 93 | mul w64 %33 3 4; |
|
| 94 | 94 | add ptr %34 %32 %33; |
|
| 95 | 95 | sload w32 %35 %34 0; |
|
| 96 | 96 | br.ne w32 %35 50 @then20 @merge21; |
|
| 97 | 97 | @guard#trap23 |
|
| 98 | 98 | ebreak; |
|
| 99 | 99 | unreachable; |
|
| 100 | 100 | @guard#pass24 |
|
| 101 | - | load w64 %37 %1 0; |
|
| 101 | + | load ptr %37 %1 0; |
|
| 102 | 102 | add ptr %38 %37 4; |
|
| 103 | 103 | sub w32 %39 %36 0; |
|
| 104 | 104 | sub w32 %40 %39 1; |
|
| 105 | 105 | mul w32 %41 %40 4; |
|
| 106 | 106 | jmp @delete26(0); |
| 130 | 130 | ret 7; |
|
| 131 | 131 | @merge32 |
|
| 132 | 132 | load w32 %53 %1 8; |
|
| 133 | 133 | br.ult w32 1 %53 @guard#pass37 @guard#trap38; |
|
| 134 | 134 | @guard#pass33 |
|
| 135 | - | load w64 %51 %1 0; |
|
| 135 | + | load ptr %51 %1 0; |
|
| 136 | 136 | sload w32 %52 %51 0; |
|
| 137 | 137 | br.ne w32 %52 20 @then31 @merge32; |
|
| 138 | 138 | @guard#trap34 |
|
| 139 | 139 | ebreak; |
|
| 140 | 140 | unreachable; |
| 142 | 142 | ret 8; |
|
| 143 | 143 | @merge36 |
|
| 144 | 144 | load w32 %58 %1 8; |
|
| 145 | 145 | br.ult w32 2 %58 @guard#pass41 @guard#trap42; |
|
| 146 | 146 | @guard#pass37 |
|
| 147 | - | load w64 %54 %1 0; |
|
| 147 | + | load ptr %54 %1 0; |
|
| 148 | 148 | mul w64 %55 1 4; |
|
| 149 | 149 | add ptr %56 %54 %55; |
|
| 150 | 150 | sload w32 %57 %56 0; |
|
| 151 | 151 | br.ne w32 %57 40 @then35 @merge36; |
|
| 152 | 152 | @guard#trap38 |
| 156 | 156 | ret 9; |
|
| 157 | 157 | @merge40 |
|
| 158 | 158 | load w32 %63 %1 8; |
|
| 159 | 159 | br.ult w32 2 %63 @guard#pass43 @guard#trap44; |
|
| 160 | 160 | @guard#pass41 |
|
| 161 | - | load w64 %59 %1 0; |
|
| 161 | + | load ptr %59 %1 0; |
|
| 162 | 162 | mul w64 %60 2 4; |
|
| 163 | 163 | add ptr %61 %59 %60; |
|
| 164 | 164 | sload w32 %62 %61 0; |
|
| 165 | 165 | br.ne w32 %62 50 @then39 @merge40; |
|
| 166 | 166 | @guard#trap42 |
|
| 167 | 167 | ebreak; |
|
| 168 | 168 | unreachable; |
|
| 169 | 169 | @guard#pass43 |
|
| 170 | - | load w64 %64 %1 0; |
|
| 170 | + | load ptr %64 %1 0; |
|
| 171 | 171 | mul w64 %65 2 4; |
|
| 172 | 172 | add ptr %66 %64 %65; |
|
| 173 | 173 | add ptr %67 %66 4; |
|
| 174 | 174 | sub w32 %68 %63 2; |
|
| 175 | 175 | sub w32 %69 %68 1; |
| 201 | 201 | ret 11; |
|
| 202 | 202 | @merge51 |
|
| 203 | 203 | load w32 %82 %1 8; |
|
| 204 | 204 | br.ult w32 1 %82 @guard#pass56 @guard#trap57; |
|
| 205 | 205 | @guard#pass52 |
|
| 206 | - | load w64 %80 %1 0; |
|
| 206 | + | load ptr %80 %1 0; |
|
| 207 | 207 | sload w32 %81 %80 0; |
|
| 208 | 208 | br.ne w32 %81 20 @then50 @merge51; |
|
| 209 | 209 | @guard#trap53 |
|
| 210 | 210 | ebreak; |
|
| 211 | 211 | unreachable; |
| 213 | 213 | ret 12; |
|
| 214 | 214 | @merge55 |
|
| 215 | 215 | load w32 %87 %1 12; |
|
| 216 | 216 | br.ne w32 %87 5 @then58 @merge59; |
|
| 217 | 217 | @guard#pass56 |
|
| 218 | - | load w64 %83 %1 0; |
|
| 218 | + | load ptr %83 %1 0; |
|
| 219 | 219 | mul w64 %84 1 4; |
|
| 220 | 220 | add ptr %85 %83 %84; |
|
| 221 | 221 | sload w32 %86 %85 0; |
|
| 222 | 222 | br.ne w32 %86 40 @then54 @merge55; |
|
| 223 | 223 | @guard#trap57 |
test/tests/slice.index.ril
+1 -1
| 1 | 1 | fn w32 $sliceIndex(ptr %0, w32 %1) { |
|
| 2 | 2 | @entry0 |
|
| 3 | 3 | load w32 %2 %0 8; |
|
| 4 | 4 | br.ult w32 %1 %2 @guard#pass1 @guard#trap2; |
|
| 5 | 5 | @guard#pass1 |
|
| 6 | - | load w64 %3 %0 0; |
|
| 6 | + | load ptr %3 %0 0; |
|
| 7 | 7 | mul w64 %4 %1 4; |
|
| 8 | 8 | add ptr %5 %3 %4; |
|
| 9 | 9 | sload w32 %6 %5 0; |
|
| 10 | 10 | ret %6; |
|
| 11 | 11 | @guard#trap2 |
test/tests/slice.mutable.ril
+7 -7
| 1 | 1 | fn w64 $mutSliceStore(ptr %0, w32 %1, w32 %2) { |
|
| 2 | 2 | @entry0 |
|
| 3 | 3 | load w32 %3 %0 8; |
|
| 4 | 4 | br.ult w32 %1 %3 @guard#pass1 @guard#trap2; |
|
| 5 | 5 | @guard#pass1 |
|
| 6 | - | load w64 %4 %0 0; |
|
| 6 | + | load ptr %4 %0 0; |
|
| 7 | 7 | mul w64 %5 %1 4; |
|
| 8 | 8 | add ptr %6 %4 %5; |
|
| 9 | 9 | store w32 %2 %6 0; |
|
| 10 | 10 | ret; |
|
| 11 | 11 | @guard#trap2 |
| 16 | 16 | fn w64 $mutSliceIncrement(ptr %0, w32 %1) { |
|
| 17 | 17 | @entry0 |
|
| 18 | 18 | load w32 %2 %0 8; |
|
| 19 | 19 | br.ult w32 %1 %2 @guard#pass1 @guard#trap2; |
|
| 20 | 20 | @guard#pass1 |
|
| 21 | - | load w64 %3 %0 0; |
|
| 21 | + | load ptr %3 %0 0; |
|
| 22 | 22 | mul w64 %4 %1 4; |
|
| 23 | 23 | add ptr %5 %3 %4; |
|
| 24 | 24 | sload w32 %6 %5 0; |
|
| 25 | 25 | add w32 %7 %6 1; |
|
| 26 | 26 | load w32 %8 %0 8; |
|
| 27 | 27 | br.ult w32 %1 %8 @guard#pass3 @guard#trap4; |
|
| 28 | 28 | @guard#trap2 |
|
| 29 | 29 | ebreak; |
|
| 30 | 30 | unreachable; |
|
| 31 | 31 | @guard#pass3 |
|
| 32 | - | load w64 %9 %0 0; |
|
| 32 | + | load ptr %9 %0 0; |
|
| 33 | 33 | mul w64 %10 %1 4; |
|
| 34 | 34 | add ptr %11 %9 %10; |
|
| 35 | 35 | store w32 %7 %11 0; |
|
| 36 | 36 | ret; |
|
| 37 | 37 | @guard#trap4 |
| 42 | 42 | fn w64 $mutSliceSwap(ptr %0, w32 %1, w32 %2) { |
|
| 43 | 43 | @entry0 |
|
| 44 | 44 | load w32 %3 %0 8; |
|
| 45 | 45 | br.ult w32 %1 %3 @guard#pass1 @guard#trap2; |
|
| 46 | 46 | @guard#pass1 |
|
| 47 | - | load w64 %4 %0 0; |
|
| 47 | + | load ptr %4 %0 0; |
|
| 48 | 48 | mul w64 %5 %1 4; |
|
| 49 | 49 | add ptr %6 %4 %5; |
|
| 50 | 50 | sload w32 %7 %6 0; |
|
| 51 | 51 | load w32 %8 %0 8; |
|
| 52 | 52 | br.ult w32 %2 %8 @guard#pass3 @guard#trap4; |
|
| 53 | 53 | @guard#trap2 |
|
| 54 | 54 | ebreak; |
|
| 55 | 55 | unreachable; |
|
| 56 | 56 | @guard#pass3 |
|
| 57 | - | load w64 %9 %0 0; |
|
| 57 | + | load ptr %9 %0 0; |
|
| 58 | 58 | mul w64 %10 %2 4; |
|
| 59 | 59 | add ptr %11 %9 %10; |
|
| 60 | 60 | sload w32 %12 %11 0; |
|
| 61 | 61 | load w32 %13 %0 8; |
|
| 62 | 62 | br.ult w32 %1 %13 @guard#pass5 @guard#trap6; |
|
| 63 | 63 | @guard#trap4 |
|
| 64 | 64 | ebreak; |
|
| 65 | 65 | unreachable; |
|
| 66 | 66 | @guard#pass5 |
|
| 67 | - | load w64 %14 %0 0; |
|
| 67 | + | load ptr %14 %0 0; |
|
| 68 | 68 | mul w64 %15 %1 4; |
|
| 69 | 69 | add ptr %16 %14 %15; |
|
| 70 | 70 | store w32 %12 %16 0; |
|
| 71 | 71 | load w32 %17 %0 8; |
|
| 72 | 72 | br.ult w32 %2 %17 @guard#pass7 @guard#trap8; |
|
| 73 | 73 | @guard#trap6 |
|
| 74 | 74 | ebreak; |
|
| 75 | 75 | unreachable; |
|
| 76 | 76 | @guard#pass7 |
|
| 77 | - | load w64 %18 %0 0; |
|
| 77 | + | load ptr %18 %0 0; |
|
| 78 | 78 | mul w64 %19 %2 4; |
|
| 79 | 79 | add ptr %20 %18 %19; |
|
| 80 | 80 | store w32 %7 %20 0; |
|
| 81 | 81 | ret; |
|
| 82 | 82 | @guard#trap8 |
test/tests/slice.range.ril
+4 -4
| 1 | 1 | fn ptr $sliceRange(ptr %0, ptr %1, w32 %2, w32 %3) { |
|
| 2 | 2 | @entry0 |
|
| 3 | - | load w64 %4 %1 0; |
|
| 3 | + | load ptr %4 %1 0; |
|
| 4 | 4 | load w32 %5 %1 8; |
|
| 5 | 5 | mul w64 %6 %2 4; |
|
| 6 | 6 | add ptr %7 %4 %6; |
|
| 7 | 7 | sub w32 %8 %3 %2; |
|
| 8 | 8 | reserve %9 16 8; |
| 13 | 13 | ret %0; |
|
| 14 | 14 | } |
|
| 15 | 15 | ||
| 16 | 16 | fn ptr $sliceRangeOpenEnd(ptr %0, ptr %1, w32 %2) { |
|
| 17 | 17 | @entry0 |
|
| 18 | - | load w64 %3 %1 0; |
|
| 18 | + | load ptr %3 %1 0; |
|
| 19 | 19 | load w32 %4 %1 8; |
|
| 20 | 20 | mul w64 %5 %2 4; |
|
| 21 | 21 | add ptr %6 %3 %5; |
|
| 22 | 22 | sub w32 %7 %4 %2; |
|
| 23 | 23 | reserve %8 16 8; |
| 28 | 28 | ret %0; |
|
| 29 | 29 | } |
|
| 30 | 30 | ||
| 31 | 31 | fn ptr $sliceRangeOpenStart(ptr %0, ptr %1, w32 %2) { |
|
| 32 | 32 | @entry0 |
|
| 33 | - | load w64 %3 %1 0; |
|
| 33 | + | load ptr %3 %1 0; |
|
| 34 | 34 | load w32 %4 %1 8; |
|
| 35 | 35 | reserve %5 16 8; |
|
| 36 | 36 | store ptr %3 %5 0; |
|
| 37 | 37 | store w32 %2 %5 8; |
|
| 38 | 38 | store w32 %2 %5 12; |
| 40 | 40 | ret %0; |
|
| 41 | 41 | } |
|
| 42 | 42 | ||
| 43 | 43 | fn ptr $sliceRangeFull(ptr %0, ptr %1) { |
|
| 44 | 44 | @entry0 |
|
| 45 | - | load w64 %2 %1 0; |
|
| 45 | + | load ptr %2 %1 0; |
|
| 46 | 46 | load w32 %3 %1 8; |
|
| 47 | 47 | reserve %4 16 8; |
|
| 48 | 48 | store ptr %2 %4 0; |
|
| 49 | 49 | store w32 %3 %4 8; |
|
| 50 | 50 | store w32 %3 %4 12; |
test/tests/trait.supertrait.ril
+2 -2
| 43 | 43 | br.ult w32 %3 %16 @guard#pass9 @guard#trap10; |
|
| 44 | 44 | @guard#trap8 |
|
| 45 | 45 | ebreak; |
|
| 46 | 46 | unreachable; |
|
| 47 | 47 | @guard#pass9 |
|
| 48 | - | load w64 %17 %4 0; |
|
| 48 | + | load ptr %17 %4 0; |
|
| 49 | 49 | add ptr %18 %17 %3; |
|
| 50 | 50 | store w8 %13 %18 0; |
|
| 51 | 51 | sload w32 %19 %6 32; |
|
| 52 | 52 | add w32 %20 %19 1; |
|
| 53 | 53 | store w32 %20 %6 32; |
| 75 | 75 | ret %7; |
|
| 76 | 76 | @merge5 |
|
| 77 | 77 | load w32 %8 %3 8; |
|
| 78 | 78 | br.ult w32 %2 %8 @guard#pass6 @guard#trap7; |
|
| 79 | 79 | @guard#pass6 |
|
| 80 | - | load w64 %9 %3 0; |
|
| 80 | + | load ptr %9 %3 0; |
|
| 81 | 81 | add ptr %10 %9 %2; |
|
| 82 | 82 | load w8 %11 %10 0; |
|
| 83 | 83 | sload w32 %12 %5 72; |
|
| 84 | 84 | add ptr %13 %5 40; |
|
| 85 | 85 | br.ult w32 %12 32 @guard#pass8 @guard#trap9; |