Created
January 15, 2023 00:24
-
-
Save knaeckeKami/bc202626e87171616e629606d55e9e28 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Info: Compiling with sound null safety. | |
../../runtime/vm/compiler/backend/flow_graph_compiler.cc: 737: error: expected: !is_optimizing() || !instr->HasUnmatchedInputRepresentations() | |
version=3.0.0-75.0.dev (dev) (Thu Dec 29 16:50:26 2022 -0800) on "macos_arm64" | |
pid=72359, thread=-1, isolate_group=isolate(0x13902c800), isolate=(nil)(0x0) | |
os=macos, arch=arm64, comp=no, sim=no | |
isolate_instructions=0, vm_instructions=0 | |
pc 0x0000000104819440 fp 0x000000016b738e20 Cr_z_armv8_crc32_little+0x113f54 | |
pc 0x00000001046f3168 fp 0x000000016b738e40 std::__2::align(unsigned long, unsigned long, void*&, unsigned long&)+0x7344 | |
pc 0x000000010495dccc fp 0x000000016b739000 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x6eab0 | |
pc 0x000000010495d378 fp 0x000000016b739030 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x6e15c | |
pc 0x0000000104a0c3d0 fp 0x000000016b739040 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x11d1b4 | |
pc 0x0000000104a0b2c4 fp 0x000000016b739100 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x11c0a8 | |
pc 0x0000000104924cdc fp 0x000000016b739830 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x35ac0 | |
pc 0x00000001049253ec fp 0x000000016b739f00 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x361d0 | |
pc 0x0000000104920c94 fp 0x000000016b739fd0 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x31a78 | |
pc 0x000000010491ea9c fp 0x000000016b73a090 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x2f880 | |
pc 0x000000010491953c fp 0x000000016b73a0e0 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x2a320 | |
pc 0x00000001049154f0 fp 0x000000016b73a840 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x262d4 | |
pc 0x000000010491422c fp 0x000000016b73ace0 std::__2::__call_once(unsigned long volatile&, void*, void (*)(void*))+0x25010 | |
pc 0x0000000104aa34a4 fp 0x000000016b73ae10 Dart_Precompile+0x1c8 | |
pc 0x00000001046ec8ac fp 0x000000016b73afc0 std::__2::align(unsigned long, unsigned long, void*&, unsigned long&)+0xa88 | |
pc 0x000000018cbc3e50 fp 0x000000016b73b2b0 start+0x9f0 | |
-- End of DumpStackTrace | |
=== Crash occurred when compiling package:barbecue/src/text_render.dart_::_Render|render in AOT mode in GenerateCode pass | |
=== When compiling block B88[target]:694 ParallelMove ? <- ?, ? <- ?, ? <- ? | |
=== When compiling instruction v1776 <- UnboxInt64:1012([non-speculative], v32 T{_Smi}) [0, 576460752303423487] T{int} | |
*** BEGIN CFG | |
GenerateCode | |
==== package:barbecue/src/text_render.dart_::_Render|render (RegularFunction) | |
0: B0[graph]:0 { | |
v0 <- Constant(#null) T{Null?} | |
v5 <- Constant(#1) [1, 1] T{_Smi} | |
v8 <- Constant(#0) [0, 0] T{_Smi} | |
v11 <- Constant(#4) [4, 4] T{_Smi} | |
v14 <- Constant(#border) T{_OneByteString} | |
v19 <- Constant(#TypeArguments: (H1bd5ead4) [Type: Cell] [Type: TextLayout]) T{TypeArguments} | |
v20 <- Constant(#_ImmutableList len:0) T{_ImmutableList} | |
v25 <- Constant(#true) T{bool} | |
v26 <- Constant(#TypeArguments: (H28c6315d) [Type: int]) T{TypeArguments} | |
v49 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v53 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v69 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v73 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v156 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v308 <- Constant(#false) T{bool} | |
v413 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v416 <- Constant(#Closure: (int, int) => int from Function '_plus@18294472': static.) T{_Closure} | |
v423 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v451 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v459 <- Constant(#Function '<anonymous closure>': static.) T{Function} | |
v567 <- Constant(#5) [5, 5] T{_Smi} | |
v743 <- Constant(#TypeParameter: X0; bound: Object?) T{_TypeParameter} | |
v2634 <- UnboxedConstant(#0 int64) [0, 0] T{_Smi} | |
v2635 <- UnboxedConstant(#1 int64) [1, 1] T{_Smi} | |
v2651 <- Constant(#Type: int) T{_Type} | |
} | |
2: B1[function entry]:2 { | |
v2 <- SpecialParameter(ArgDescriptor) T{_ImmutableList} | |
} | |
4: ParallelMove ? <- ? | |
4: v4 <- LoadField(v2 . ArgumentsDescriptor.count {final}) [0, 4611686018427387903] T{_Smi} | |
6: v6 <- BinarySmiOp:4(- [tr], v4, v5) [-1, 4611686018427387902] T{_Smi} | |
8: v7 <- LoadIndexedUnsafe(fp[v6 + 16]) T{Table} | |
9: ParallelMove ? <- ? | |
10: v13 <- LoadIndexed(v2, v11) T{*?} | |
12: Branch if StrictCompare:16(===, v13, v14) goto (2, 3) | |
14: B2[target]:20 | |
16: v569 <- LoadIndexed(v2, v567) T{*?} | |
18: v570 <- BinarySmiOp:10(- [tr], v4, v569) [-4611686018427387903, 4611686018427387903] T{_Smi} | |
20: v571 <- LoadIndexedUnsafe(fp[v570 + 8]) T{TextBorder??} | |
22: ParallelMove ? <- ? goto:26 B5 | |
24: B3[target]:22 | |
26: ParallelMove ? <- ? goto:28 B5 | |
28: B5[join]:24 pred(B2, B3) { | |
v15 <- phi(v571, v0) alive T{TextBorder?} | |
} | |
30: CheckStackOverflow:34(stack=0, loop=0) | |
32: Branch if StrictCompare:38(===, v15, v0) goto (6, 7) | |
34: B6[target]:42 | |
36: v1252 <- LoadStaticField:4(DEFAULT, CallsInitializer) T{TextBorder} | |
37: ParallelMove r0 <- r0 | |
38: ParallelMove ? <- ? goto:50 B8 | |
40: B7[target]:46 | |
42: ParallelMove ? <- ? goto:52 B8 | |
44: B8[join]:48 pred(B6, B7) { | |
v17 <- phi(v1252, v15 T{TextBorder}) alive T{TextBorder} | |
} ParallelMove ? <- ? | |
45: ParallelMove ? <- ? | |
46: PushArgument(v19) | |
48: PushArgument(v20) | |
50: v21 <- StaticCall:54( Map._fromLiteral@0150898<0> v19, v20) T{*?} | |
51: ParallelMove ? <- ?, ? <- ? | |
52: ParallelMove ? <- ? | |
52: v1243 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList} | |
53: ParallelMove ? <- ? | |
54: v1248 <- LoadField(v1243 . :type_arguments {final}) T{TypeArguments} | |
55: ParallelMove ? <- ? | |
56: v1615 <- LoadField(v1243 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
58: v1717 <- UnboxInt64([non-speculative], v1615) [0, 576460752303423487] T{int} | |
59: ParallelMove ? <- ? | |
60: ParallelMove ? <- ? goto:84 B11 | |
62: B11[join]:82 pred(B8, B557) { | |
v2082 <- phi(v2634, v1234) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
63: ParallelMove ? <- ? | |
64: CheckStackOverflow:88(stack=0, loop=1) | |
66: v3950 <- LoadClassId(<non-smi> v1243) | |
68: PushArgument(v1243) | |
69: ParallelMove r0 <- r0 | |
70: v1223 <- DispatchTableCall( cid=v3950 Iterable.length<0>, v1243) T{int} | |
71: ParallelMove r0 <- r0 | |
72: v1719 <- UnboxInt64([non-speculative], v1223 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
73: ParallelMove ? <- ? | |
74: Branch if EqualityCompare(v1717 T{int} != v1719 T{int}) T{bool} goto (560, 561) | |
76: B560[target]:24 ParallelMove r0 <- S-6 | |
78: v1236 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError} | |
79: ParallelMove r0 <- r0, r3 <- S-6 | |
80: StoreField(v1236 . modifiedObject = v1243, NoStoreBarrier) | |
81: ParallelMove r0 <- r0 | |
82: Throw:32(v1236) | |
84: B561[target]:34 ParallelMove ? <- ?, ? <- ? | |
86: Branch if RelationalOp(>=, v2082 T{int}, v1719 T{int}) T{bool} goto (10, 9) | |
88: B10[target]:46 ParallelMove ? <- ?, ? <- ? | |
90: v16 <- AllocateContext:36(num_variables=8) T{Context} | |
91: ParallelMove ? <- ?, ? <- ? | |
92: ParallelMove ? <- ? | |
92: StoreField(v16 . layouts = v21, NoStoreBarrier) | |
93: ParallelMove ? <- ? | |
94: v27 <- LoadField(v7 . columnCount) T{int??} | |
95: ParallelMove ? <- ? | |
96: CheckNull:92(v27, CastError) [-9223372036854775808, 9223372036854775807] T{int?} | |
98: v1720 <- UnboxInt64([non-speculative], v27 T{int?}) [-9223372036854775808, 9223372036854775807] T{int} | |
100: PushArgument(v26) | |
102: PushArgument(v1720) | |
104: PushArgument(v5) | |
106: v28 <- StaticCall:94( _List@0150898.filled<0> v26, v1720, v5, result_type = T{_List}) T{_List} | |
107: ParallelMove r0 <- r0, ? <- ?, ? <- ? | |
108: ParallelMove ? <- ? | |
108: StoreField(v16 . columnWidths = v28) | |
109: ParallelMove ? <- ? | |
110: v29 <- LoadField(v7 . columnCount) T{int??} | |
112: CheckNull:98(v29, CastError) [-9223372036854775808, 9223372036854775807] T{int?} | |
114: v1721 <- UnboxInt64([non-speculative], v29 T{int?}) [-9223372036854775808, 9223372036854775807] T{int} | |
116: v30 <- BinaryInt64Op(+ [tr], v1721, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
117: ParallelMove ? <- ? | |
118: PushArgument(v26) | |
120: PushArgument(v30) | |
122: PushArgument(v8) | |
124: v31 <- StaticCall:102( _List@0150898.filled<0> v26, v30, v8, result_type = T{_List}) T{_List} | |
125: ParallelMove r0 <- r0, ? <- ?, ? <- ? | |
126: ParallelMove ? <- ? | |
126: StoreField(v16 . columnBorderWidths = v31) | |
127: ParallelMove ? <- ? | |
128: v32 <- LoadField(v7 . rowCount {final}) [-9223372036854775808, 9223372036854775807] T{int} | |
129: ParallelMove ? <- ? | |
130: PushArgument(v26) | |
132: PushArgument(v32) | |
134: PushArgument(v5) | |
136: v33 <- StaticCall:106( _List@0150898.filled<0> v26, v32, v5, result_type = T{_List}) T{_List} | |
137: ParallelMove r0 <- r0, ? <- ?, ? <- ? | |
138: ParallelMove ? <- ? | |
138: StoreField(v16 . rowHeights = v33) | |
139: ParallelMove ? <- ? | |
140: v35 <- BinaryInt64Op(+ [tr], v32 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
141: ParallelMove ? <- ? | |
142: PushArgument(v26) | |
144: PushArgument(v35) | |
146: PushArgument(v8) | |
148: v36 <- StaticCall:112( _List@0150898.filled<0> v26, v35, v8, result_type = T{_List}) T{_List} | |
149: ParallelMove r0 <- r0, ? <- ?, ? <- ? | |
150: ParallelMove ? <- ? | |
150: StoreField(v16 . rowBorderHeights = v36) | |
151: ParallelMove ? <- ? | |
152: v1200 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList} | |
153: ParallelMove ? <- ? | |
154: v1205 <- LoadField(v1200 . :type_arguments {final}) T{TypeArguments} | |
155: ParallelMove ? <- ? | |
156: v1606 <- LoadField(v1200 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
158: v1722 <- UnboxInt64([non-speculative], v1606) [0, 576460752303423487] T{int} | |
159: ParallelMove ? <- ?, ? <- ? | |
160: v1907 <- UnboxInt64:664([non-speculative], v27 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int} | |
161: ParallelMove ? <- ? | |
162: v525 <- LoadField:664(v7 . tableStyle {final}) T{TableStyle} | |
163: ParallelMove ? <- ? | |
164: v526 <- LoadField:664(v525 . border {final}) T{bool} | |
165: ParallelMove ? <- ? | |
166: ParallelMove ? <- ?, ? <- ? goto:664 B86 | |
168: B86[join]:662 pred(B10, B85) { | |
v2104 <- phi(v2634, v1191) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} ParallelMove ? <- ?, ? <- ? | |
169: ParallelMove ? <- ? | |
170: CheckStackOverflow:668(stack=0, loop=1) | |
172: v3951 <- LoadClassId(<non-smi> v1200) | |
174: PushArgument(v1200) | |
175: ParallelMove r0 <- r0 | |
176: v1180 <- DispatchTableCall( cid=v3951 Iterable.length<0>, v1200) T{int} | |
177: ParallelMove r0 <- r0 | |
178: v1724 <- UnboxInt64([non-speculative], v1180 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
179: ParallelMove ? <- ? | |
180: Branch if EqualityCompare(v1722 T{int} != v1724 T{int}) T{bool} goto (545, 546) | |
182: B545[target]:24 ParallelMove r0 <- S-22 | |
184: v1193 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError} | |
185: ParallelMove r0 <- r0, r3 <- S-22 | |
186: StoreField(v1193 . modifiedObject = v1200, NoStoreBarrier) | |
187: ParallelMove r0 <- r0 | |
188: Throw:32(v1193) | |
190: B546[target]:34 ParallelMove ? <- ?, ? <- ? | |
192: Branch if RelationalOp(>=, v2104 T{int}, v1724 T{int}) T{bool} goto (13, 12) | |
194: B13[target]:46 ParallelMove ? <- ?, ? <- ? | |
196: v1110 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList} | |
197: ParallelMove ? <- ?, ? <- ?, ? <- ? | |
198: v50 <- AllocateClosure:672(v49, v0) T{_Closure} | |
199: ParallelMove r0 <- r0 | |
200: PushArgument(v1110) | |
202: PushArgument(v50) | |
204: v51 <- StaticCall:674( where<0> v1110, v50, using unchecked entrypoint, result_type = T{WhereIterable}) T{WhereIterable} | |
205: ParallelMove r0 <- r0 | |
206: PushArgument(v51) | |
208: v52 <- StaticCall:676( toList<0> v51, using unchecked entrypoint, result_type = T{*}) T{*?} | |
209: ParallelMove ? <- ?, ? <- ?, r0 <- r0 | |
210: ParallelMove ? <- ? | |
210: v54 <- AllocateClosure:678(v53, v0) T{_Closure} | |
211: ParallelMove r0 <- r0 | |
212: PushArgument(v52) | |
214: PushArgument(v54) | |
216: StaticCall:680( sort<0> v52, v54, using unchecked entrypoint, result_type = T{??}) | |
217: ParallelMove ? <- ? | |
218: v3952 <- LoadClassId(<non-smi> v52) | |
220: PushArgument(v52) | |
221: ParallelMove ? <- ? | |
222: v55 <- DispatchTableCall( cid=v3952 Iterable.iterator<0>, v52) T{*?} | |
223: ParallelMove ? <- ?, ? <- ? | |
224: ParallelMove ? <- ? | |
224: v1744 <- UnboxInt64:860([non-speculative], v27 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int} | |
225: ParallelMove ? <- ? | |
226: ParallelMove ? <- ? goto:860 B104 | |
228: B104[join]:858 pred(B13, B103) ParallelMove ? <- ? | |
230: CheckStackOverflow:864(stack=0, loop=1) | |
232: v3953 <- LoadClassId(<non-smi> v55 T{*?}) | |
234: PushArgument(v55 T{*?}) | |
235: ParallelMove r0 <- r0 | |
236: v67 <- DispatchTableCall( cid=v3953 Iterator.moveNext<0>, v55 T{*?}) T{bool} | |
237: ParallelMove r0 <- r0 | |
238: Branch if StrictCompare:688(===, v67, v25) goto (87, 88) | |
240: B87[target]:692 ParallelMove ? <- ?, ? <- ? | |
242: v3954 <- LoadClassId(<non-smi> v55 T{*}) | |
244: PushArgument(v55 T{*}) | |
245: ParallelMove r0 <- r0 | |
246: v441 <- DispatchTableCall( cid=v3954 Iterator.current<0>, v55 T{*}) T{*?} | |
247: ParallelMove r0 <- r0 | |
248: v442 <- LoadField(v441 T{PositionedCell} . columnIndex {final}) [-9223372036854775808, 9223372036854775807] T{int} | |
249: ParallelMove ? <- ? | |
250: v443 <- LoadField(v441 T{PositionedCell} . cell {final}) T{Cell} | |
252: PushArgument(v21 T{Map<Cell, TextLayout>?}) | |
254: PushArgument(v443) | |
256: v1103 <- StaticCall:10( _getValueOrData@3220832<0> v21 T{Map<Cell, TextLayout>?}, v443, using unchecked entrypoint, result_type = T{*?}) T{Object??} | |
257: ParallelMove ? <- ?, ? <- ? | |
258: v1467 <- LoadField(v21 T{Map<Cell, TextLayout>?} . LinkedHashBase.data) T{_List} | |
260: Branch if StrictCompare:14(===, v1467, v1103) goto (513, 514) | |
262: B513[target]:18 | |
264: ParallelMove ? <- ? goto:24 B515 | |
266: B514[target]:20 | |
268: ParallelMove ? <- ? goto:26 B515 | |
270: B515[join]:22 pred(B513, B514) { | |
v1105 <- phi(v0, v1103) alive T{Object??} | |
} ParallelMove ? <- ? | |
272: CheckNull:704(v1105 T{SimpleLayout?}, CastError) T{SimpleLayout} | |
274: PushArgument(v1105 T{SimpleLayout}) | |
276: v446 <- StaticCall:708( measureWidth<0> v1105 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
277: ParallelMove r0 <- r0 | |
278: ParallelMove ? <- ? | |
278: PushArgument(v26) | |
280: PushArgument(v2634) | |
282: v447 <- StaticCall:710( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList} | |
283: ParallelMove ? <- ?, ? <- ? | |
284: ParallelMove ? <- ? | |
284: v449 <- BinaryInt64Op:732(+ [tr], v442, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
285: ParallelMove ? <- ? | |
286: ParallelMove ? <- ? goto:732 B91 | |
288: B91[join]:730 pred(B506, B515) { | |
v448 <- phi(v489, v442) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
289: ParallelMove ? <- ? | |
290: CheckStackOverflow:736(stack=0, loop=2) | |
292: Branch if RelationalOp(<, v448, v449) T{bool} goto (89, 90) | |
294: B89[target]:722 | |
296: v1456 <- LoadField(v447 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
297: ParallelMove ? <- ? | |
298: v1461 <- LoadField(v447 . GrowableObjectArray.data) T{_List} | |
300: v1462 <- LoadField(v1461 . Array.length {final}) [0, 576460752303423487] T{_Smi} | |
302: Branch if StrictCompare(===, v1456, v1462) T{bool} goto (504, 505) | |
304: B504[target]:24 | |
306: PushArgument(v447) | |
308: StaticCall:26( _growToNextCapacity@0150898<0> v447, using unchecked entrypoint, result_type = T{??}) | |
310: ParallelMove goto:32 B506 | |
312: B505[target]:28 | |
314: ParallelMove goto:34 B506 | |
316: B506[join]:30 pred(B504, B505) ParallelMove ? <- ?, ? <- ?, ? <- ? | |
318: v1727 <- UnboxInt64([non-speculative], v1456) [0, 576460752303423487] T{int} | |
320: v1093 <- BinaryInt64Op(+ [tr], v1727 T{_Smi}, v2635) [1, 576460752303423488] T{int} | |
322: v1728 <- BoxInt64(v1093) [1, 576460752303423488] T{_Smi} | |
324: StoreField(v447 . GrowableObjectArray.length = v1728, NoStoreBarrier) | |
325: ParallelMove r0 <- r0, ? <- ? | |
326: GenericCheckBound:40(v1093 T{_Smi}, v1727 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
328: v1096 <- LoadField(v447 . GrowableObjectArray.data) T{_List} | |
330: v1725 <- BoxInt64(v448 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
331: ParallelMove ? <- ?, r0 <- r0 | |
332: StoreIndexed:40(v1096, v1727 T{_Smi}, v1725 T{int}) | |
334: v489 <- BinaryInt64Op(+ [tr], v448, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
336: ParallelMove r3 <- r3, ? <- ?, ? <- ?, ? <- ? goto:734 B91 | |
338: B90[target]:724 ParallelMove ? <- ? | |
339: ParallelMove ? <- ?, ? <- ? | |
340: v452 <- AllocateClosure:738(v451, v16) T{_Closure} | |
341: ParallelMove r0 <- r0 | |
342: PushArgument(v26) | |
344: PushArgument(v447) | |
346: PushArgument(v452) | |
348: v453 <- StaticCall:740( map<1> v26, v447, v452, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable} | |
349: ParallelMove r0 <- r0 | |
350: PushArgument(v26) | |
352: PushArgument(v453) | |
354: PushArgument(v8) | |
356: PushArgument(v416) | |
358: v454 <- StaticCall:742( fold<1> v26, v453, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
359: ParallelMove r0 <- r0 | |
360: ParallelMove ? <- ? | |
360: PushArgument(v26) | |
362: PushArgument(v2634) | |
364: v455 <- StaticCall:744( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList} | |
365: ParallelMove r0 <- r0 | |
366: ParallelMove ? <- ? | |
366: ParallelMove ? <- ? goto:766 B94 | |
368: B94[join]:764 pred(B90, B497) { | |
v456 <- phi(v442, v488) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} ParallelMove ? <- ? | |
369: ParallelMove ? <- ? | |
370: CheckStackOverflow:770(stack=2, loop=2) | |
372: Branch if RelationalOp(<, v456, v449 T{int}) T{bool} goto (92, 93) | |
374: B92[target]:756 | |
376: v1445 <- LoadField(v455 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
377: ParallelMove ? <- ? | |
378: v1450 <- LoadField(v455 . GrowableObjectArray.data) T{_List} | |
380: v1451 <- LoadField(v1450 . Array.length {final}) [0, 576460752303423487] T{_Smi} | |
382: Branch if StrictCompare(===, v1445, v1451) T{bool} goto (495, 496) | |
384: B495[target]:24 | |
386: PushArgument(v455) | |
388: StaticCall:26( _growToNextCapacity@0150898<0> v455, using unchecked entrypoint, result_type = T{??}) | |
390: ParallelMove goto:32 B497 | |
392: B496[target]:28 | |
394: ParallelMove goto:34 B497 | |
396: B497[join]:30 pred(B495, B496) ParallelMove ? <- ?, ? <- ?, ? <- ? | |
398: v1734 <- UnboxInt64([non-speculative], v1445) [0, 576460752303423487] T{int} | |
400: v1078 <- BinaryInt64Op(+ [tr], v1734 T{_Smi}, v2635) [1, 576460752303423488] T{int} | |
402: v1735 <- BoxInt64(v1078) [1, 576460752303423488] T{_Smi} | |
404: StoreField(v455 . GrowableObjectArray.length = v1735, NoStoreBarrier) | |
405: ParallelMove r0 <- r0, ? <- ? | |
406: GenericCheckBound:40(v1078 T{_Smi}, v1734 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
408: v1081 <- LoadField(v455 . GrowableObjectArray.data) T{_List} | |
410: v1732 <- BoxInt64(v456 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
411: ParallelMove ? <- ?, r0 <- r0 | |
412: StoreIndexed:40(v1081, v1734 T{_Smi}, v1732 T{int}) | |
414: v488 <- BinaryInt64Op(+ [tr], v456, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
416: ParallelMove ? <- ?, ? <- ? goto:768 B94 | |
418: B93[target]:758 ParallelMove ? <- ?, ? <- ?, ? <- ? | |
419: ParallelMove ? <- ?, ? <- ? | |
420: v460 <- AllocateClosure:772(v459, v16) T{_Closure} | |
421: ParallelMove r0 <- r0 | |
422: PushArgument(v26) | |
424: PushArgument(v455) | |
426: PushArgument(v460) | |
428: v461 <- StaticCall:774( map<1> v26, v455, v460, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable} | |
429: ParallelMove r0 <- r0 | |
430: PushArgument(v26) | |
432: PushArgument(v461) | |
434: PushArgument(v8) | |
436: PushArgument(v416) | |
438: v462 <- StaticCall:776( fold<1> v26, v461, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
439: ParallelMove ? <- ?, ? <- ? | |
440: v1731 <- UnboxInt64([non-speculative], v454) [-9223372036854775808, 9223372036854775807] T{int} | |
442: v1738 <- UnboxInt64([non-speculative], v462) [-9223372036854775808, 9223372036854775807] T{int} | |
444: v463 <- BinaryInt64Op(+ [tr], v1731 T{int}, v1738 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
445: ParallelMove ? <- ? | |
446: v464 <- BinaryInt64Op(- [tr], v446, v463) [-9223372036854775808, 9223372036854775807] T{int} | |
448: Branch if RelationalOp(>, v464, v2634) T{bool} goto (95, 102) | |
450: B95[target]:790 ParallelMove ? <- ? | |
452: v473 <- BinaryInt64Op(- [tr], v464, v464 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
454: v1066 <- LoadField:844(v447 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
456: v1739 <- UnboxInt64:844([non-speculative], v1066) [0, 576460752303423487] T{int} | |
458: v593 <- LoadField:844(v447 . GrowableObjectArray.data) T{_List} | |
460: v487 <- BinaryInt64Op:844(+ [tr], v464 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
462: ParallelMove ? <- ?, ? <- ? goto:844 B101 | |
464: B101[join]:842 pred(B95, B100) { | |
v475 <- phi(v2634, v486) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
466: CheckStackOverflow:848(stack=0, loop=2) | |
468: Branch if RelationalOp(<, v475, v1739 T{_Smi}) T{bool} goto (96, 97) | |
470: B96[target]:808 | |
472: v2636 <- LoadIndexed(v593, v475 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
474: Branch if RelationalOp(<, v475 T{int}, v473) T{bool} goto (98, 99) | |
476: B98[target]:824 | |
478: ParallelMove ? <- ? goto:832 B100 | |
480: B99[target]:828 | |
482: ParallelMove ? <- ? goto:834 B100 | |
484: B100[join]:830 pred(B98, B99) { | |
v481 <- phi(v487, v464 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
486: v1743 <- UnboxInt64([non-speculative], v2636 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
487: ParallelMove ? <- ?, ? <- ? | |
488: GenericCheckBound:836(v1744 T{_Smi}, v1743 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
490: v2637 <- LoadIndexed(v28, v1743 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
492: v1746 <- UnboxInt64([non-speculative], v2637 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
494: v484 <- BinaryInt64Op(+ [tr], v1746 T{int}, v481) [-9223372036854775808, 9223372036854775807] T{int} | |
496: v1747 <- BoxInt64(v484 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
497: ParallelMove ? <- ?, r0 <- r0 | |
498: StoreIndexed:840(v28, v1743 T{int}, v1747 T{int}) | |
500: v486 <- BinaryInt64Op(+ [tr], v475 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
502: ParallelMove ? <- ? goto:846 B101 | |
504: B97[target]:810 | |
506: ParallelMove goto:854 B103 | |
508: B102[target]:850 ParallelMove ? <- ? | |
510: ParallelMove goto:856 B103 | |
512: B103[join]:852 pred(B97, B102) | |
514: ParallelMove ? <- ?, ? <- ?, ? <- ?, ? <- ? goto:862 B104 | |
516: B88[target]:694 ParallelMove ? <- ?, ? <- ?, ? <- ? | |
518: v1061 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList} | |
519: ParallelMove ? <- ?, ? <- ?, ? <- ? | |
520: v70 <- AllocateClosure:868(v69, v0) T{_Closure} | |
521: ParallelMove r0 <- r0 | |
522: PushArgument(v1061) | |
524: PushArgument(v70) | |
526: v71 <- StaticCall:870( where<0> v1061, v70, using unchecked entrypoint, result_type = T{WhereIterable}) T{WhereIterable} | |
527: ParallelMove r0 <- r0 | |
528: PushArgument(v71) | |
530: v72 <- StaticCall:872( toList<0> v71, using unchecked entrypoint, result_type = T{*}) T{*?} | |
531: ParallelMove ? <- ?, ? <- ?, r0 <- r0 | |
532: ParallelMove ? <- ? | |
532: v74 <- AllocateClosure:874(v73, v0) T{_Closure} | |
533: ParallelMove r0 <- r0 | |
534: PushArgument(v72) | |
536: PushArgument(v74) | |
538: StaticCall:876( sort<0> v72, v74, using unchecked entrypoint, result_type = T{??}) | |
539: ParallelMove ? <- ? | |
540: v3955 <- LoadClassId(<non-smi> v72) | |
542: PushArgument(v72) | |
543: ParallelMove ? <- ? | |
544: v75 <- DispatchTableCall( cid=v3955 Iterable.iterator<0>, v72) T{*?} | |
545: ParallelMove ? <- ?, ? <- ? | |
546: ParallelMove ? <- ? | |
546: v1776 <- UnboxInt64:1012([non-speculative], v32 T{_Smi}) [0, 576460752303423487] T{int} | |
547: ParallelMove S-25 <- r3 | |
548: ParallelMove r5 <- S-15 goto:1012 B116 | |
550: B116[join]:1010 pred(B88, B115) ParallelMove r4 <- S-7 | |
552: CheckStackOverflow:1016(stack=0, loop=1) | |
554: v3956 <- LoadClassId(<non-smi> v75 T{*?}) | |
556: PushArgument(v75 T{*?}) | |
557: ParallelMove r0 <- r0 | |
558: v85 <- DispatchTableCall( cid=v3956 Iterator.moveNext<0>, v75 T{*?}) T{bool} | |
559: ParallelMove r0 <- r0 | |
560: Branch if StrictCompare:884(===, v85, v25) goto (105, 106) | |
562: B105[target]:888 ParallelMove r2 <- S-7, r1 <- S-24 | |
564: v3957 <- LoadClassId(<non-smi> v75 T{*}) | |
566: PushArgument(v75 T{*}) | |
567: ParallelMove r0 <- r0 | |
568: v403 <- DispatchTableCall( cid=v3957 Iterator.current<0>, v75 T{*}) T{*?} | |
569: ParallelMove r0 <- r0 | |
570: v404 <- LoadField(v403 T{PositionedCell} . rowIndex {final}) [-9223372036854775808, 9223372036854775807] T{int} | |
571: ParallelMove S-26 <- r1 | |
572: v405 <- LoadField(v403 T{PositionedCell} . cell {final}) T{Cell} | |
574: PushArgument(v21 T{Map<Cell, TextLayout>?}) | |
576: PushArgument(v405) | |
578: v1054 <- StaticCall:10( _getValueOrData@3220832<0> v21 T{Map<Cell, TextLayout>?}, v405, using unchecked entrypoint, result_type = T{*?}) T{Object??} | |
579: ParallelMove r1 <- r0, r0 <- S-7 | |
580: v1440 <- LoadField(v21 T{Map<Cell, TextLayout>?} . LinkedHashBase.data) T{_List} | |
582: Branch if StrictCompare:14(===, v1440, v1054) goto (487, 488) | |
584: B487[target]:18 | |
586: ParallelMove r2 <- C goto:24 B489 | |
588: B488[target]:20 | |
590: ParallelMove r2 <- r1 goto:26 B489 | |
592: B489[join]:22 pred(B487, B488) { | |
v1056 <- phi(v0, v1054) alive T{Object??} | |
} ParallelMove r1 <- S-26 | |
594: CheckNull:900(v1056 T{SimpleLayout?}, CastError) T{SimpleLayout} | |
596: PushArgument(v1056 T{SimpleLayout}) | |
598: v408 <- StaticCall:904( measureHeight<0> v1056 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
599: ParallelMove r0 <- r0 | |
600: ParallelMove S-27 <- r0 | |
600: PushArgument(v26) | |
602: PushArgument(v2634) | |
604: v409 <- StaticCall:906( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList} | |
605: ParallelMove r1 <- r0, r0 <- S-26 | |
606: ParallelMove S-31 <- r1 | |
606: v411 <- BinaryInt64Op:928(+ [tr], v404, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
607: ParallelMove S-29 <- r2 | |
608: ParallelMove r0 <- r0 goto:928 B109 | |
610: B109[join]:926 pred(B480, B489) { | |
v410 <- phi(v440, v404) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
611: ParallelMove S-26 <- r0 | |
612: CheckStackOverflow:932(stack=0, loop=2) | |
614: Branch if RelationalOp(<, v410, v411) T{bool} goto (107, 108) | |
616: B107[target]:918 | |
618: v1429 <- LoadField(v409 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
619: ParallelMove S-28 <- r3 | |
620: v1434 <- LoadField(v409 . GrowableObjectArray.data) T{_List} | |
622: v1435 <- LoadField(v1434 . Array.length {final}) [0, 576460752303423487] T{_Smi} | |
624: Branch if StrictCompare(===, v1429, v1435) T{bool} goto (478, 479) | |
626: B478[target]:24 | |
628: PushArgument(v409) | |
630: StaticCall:26( _growToNextCapacity@0150898<0> v409, using unchecked entrypoint, result_type = T{??}) | |
632: ParallelMove goto:32 B480 | |
634: B479[target]:28 | |
636: ParallelMove goto:34 B480 | |
638: B480[join]:30 pred(B478, B479) ParallelMove r3 <- S-31, r2 <- S-26, r0 <- S-28 | |
640: v1752 <- UnboxInt64([non-speculative], v1429) [0, 576460752303423487] T{int} | |
642: v1044 <- BinaryInt64Op(+ [tr], v1752 T{_Smi}, v2635) [1, 576460752303423488] T{int} | |
644: v1753 <- BoxInt64(v1044) [1, 576460752303423488] T{_Smi} | |
646: StoreField(v409 . GrowableObjectArray.length = v1753, NoStoreBarrier) | |
647: ParallelMove r0 <- r0, r1 <- r4 | |
648: GenericCheckBound:40(v1044 T{_Smi}, v1752 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
650: v1047 <- LoadField(v409 . GrowableObjectArray.data) T{_List} | |
652: v1750 <- BoxInt64(v410 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
653: ParallelMove r1 <- r5, r0 <- r0 | |
654: StoreIndexed:40(v1047, v1752 T{_Smi}, v1750 T{int}) | |
656: v440 <- BinaryInt64Op(+ [tr], v410, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
658: ParallelMove r0 <- r0, r1 <- r3, r2 <- S-29 goto:930 B109 | |
660: B108[target]:920 ParallelMove r3 <- r1 | |
661: ParallelMove r1 <- C, r2 <- S-9 | |
662: v414 <- AllocateClosure:934(v413, v16) T{_Closure} | |
663: ParallelMove r0 <- r0 | |
664: PushArgument(v26) | |
666: PushArgument(v409) | |
668: PushArgument(v414) | |
670: v415 <- StaticCall:936( map<1> v26, v409, v414, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable} | |
671: ParallelMove r0 <- r0 | |
672: PushArgument(v26) | |
674: PushArgument(v415) | |
676: PushArgument(v8) | |
678: PushArgument(v416) | |
680: v417 <- StaticCall:938( fold<1> v26, v415, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
681: ParallelMove r0 <- r0 | |
682: ParallelMove S-28 <- r0 | |
682: PushArgument(v26) | |
684: PushArgument(v2634) | |
686: v418 <- StaticCall:940( _GrowableList@0150898.<0> v26, v2634, result_type = T{_GrowableList}) T{_GrowableList} | |
687: ParallelMove r0 <- r0 | |
688: ParallelMove S-33 <- r0 | |
688: ParallelMove r2 <- S-29 goto:964 B112 | |
690: B112[join]:962 pred(B108, B471) { | |
v420 <- phi(v411 T{int}, v439) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} ParallelMove r1 <- S-29 | |
691: ParallelMove S-26 <- r2 | |
692: CheckStackOverflow:968(stack=2, loop=2) | |
694: Branch if RelationalOp(<, v420, v411 T{int}) T{bool} goto (110, 111) | |
696: B110[target]:954 | |
698: v1418 <- LoadField(v418 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
699: ParallelMove S-32 <- r3 | |
700: v1423 <- LoadField(v418 . GrowableObjectArray.data) T{_List} | |
702: v1424 <- LoadField(v1423 . Array.length {final}) [0, 576460752303423487] T{_Smi} | |
704: Branch if StrictCompare(===, v1418, v1424) T{bool} goto (469, 470) | |
706: B469[target]:24 | |
708: PushArgument(v418) | |
710: StaticCall:26( _growToNextCapacity@0150898<0> v418, using unchecked entrypoint, result_type = T{??}) | |
712: ParallelMove goto:32 B471 | |
714: B470[target]:28 | |
716: ParallelMove goto:34 B471 | |
718: B471[join]:30 pred(B469, B470) ParallelMove r3 <- S-33, r2 <- S-26, r0 <- S-32 | |
720: v1759 <- UnboxInt64([non-speculative], v1418) [0, 576460752303423487] T{int} | |
722: v1029 <- BinaryInt64Op(+ [tr], v1759 T{_Smi}, v2635) [1, 576460752303423488] T{int} | |
724: v1760 <- BoxInt64(v1029) [1, 576460752303423488] T{_Smi} | |
726: StoreField(v418 . GrowableObjectArray.length = v1760, NoStoreBarrier) | |
727: ParallelMove r0 <- r0, r1 <- r4 | |
728: GenericCheckBound:40(v1029 T{_Smi}, v1759 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
730: v1032 <- LoadField(v418 . GrowableObjectArray.data) T{_List} | |
732: v1757 <- BoxInt64(v420 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
733: ParallelMove r1 <- r5, r0 <- r0 | |
734: StoreIndexed:40(v1032, v1759 T{_Smi}, v1757 T{int}) | |
736: v439 <- BinaryInt64Op(+ [tr], v420, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
738: ParallelMove r2 <- r0, r0 <- r3 goto:966 B112 | |
740: B111[target]:956 ParallelMove r4 <- S-27, r0 <- S-28, r3 <- r0 | |
741: ParallelMove r1 <- C, r2 <- S-9 | |
742: v424 <- AllocateClosure:970(v423, v16) T{_Closure} | |
743: ParallelMove r0 <- r0 | |
744: PushArgument(v26) | |
746: PushArgument(v418) | |
748: PushArgument(v424) | |
750: v425 <- StaticCall:972( map<1> v26, v418, v424, using unchecked entrypoint, result_type = T{MappedListIterable}) T{MappedListIterable} | |
751: ParallelMove r0 <- r0 | |
752: PushArgument(v26) | |
754: PushArgument(v425) | |
756: PushArgument(v8) | |
758: PushArgument(v416) | |
760: v426 <- StaticCall:974( fold<1> v26, v425, v8, v416, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
761: ParallelMove r1 <- r0, r0 <- S-28 | |
762: v1756 <- UnboxInt64([non-speculative], v417) [-9223372036854775808, 9223372036854775807] T{int} | |
764: v1763 <- UnboxInt64([non-speculative], v426) [-9223372036854775808, 9223372036854775807] T{int} | |
766: v427 <- BinaryInt64Op(+ [tr], v1756 T{int}, v1763 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
767: ParallelMove r0 <- S-27 | |
768: v428 <- BinaryInt64Op(- [tr], v408, v427) [-9223372036854775808, 9223372036854775807] T{int} | |
770: Branch if RelationalOp(>, v428, v2634) T{bool} goto (113, 114) | |
772: B113[target]:988 ParallelMove r0 <- S-31 | |
774: v435 <- BinaryInt64Op(- [tr], v428, v428 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
776: v1413 <- LoadField(v409 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
778: v1767 <- UnboxInt64:56([non-speculative], v1413) [0, 576460752303423487] T{int} | |
780: v1016 <- LoadField:56(v409 . GrowableObjectArray.data) T{_List} | |
782: v1556 <- BinaryInt64Op:56(+ [tr], v428 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
784: ParallelMove r9 <- C, r8 <- C, r7 <- S-15 goto:56 B465 | |
786: B465[join]:54 pred(B113, B464) { | |
v1003 <- phi(v2634, v1012) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
v2970 <- phi(v2634, v1554 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
788: CheckStackOverflow:60(stack=0, loop=1) | |
790: Branch if RelationalOp(<, v1003, v1767 T{_Smi}) T{bool} goto (461, 462) | |
792: B461[target]:22 | |
794: v2638 <- LoadIndexed(v1016, v1003 T{int}) T{*?} | |
796: Branch if RelationalOp(<, v2970 T{int}, v435 T{int}) T{bool} goto (663, 664) | |
798: B663[target]:18 | |
800: ParallelMove r10 <- r6 goto:26 B464 | |
802: B664[target]:22 | |
804: ParallelMove r10 <- r2 goto:28 B464 | |
806: B464[join]:24 pred(B663, B664) { | |
v1545 <- phi(v1556 T{int}, v428 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
808: v1771 <- UnboxInt64([non-speculative], v2638 T{*?}) [-9223372036854775808, 9223372036854775807] T{int} | |
809: ParallelMove r0 <- S-25, r1 <- r11 | |
810: GenericCheckBound:30(v1776 T{_Smi}, v1771) [-9223372036854775808, 9223372036854775807] T{int} | |
812: v2639 <- LoadIndexed(v33, v1771 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
814: v1778 <- UnboxInt64([non-speculative], v2639 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
816: v1549 <- BinaryInt64Op(+ [tr], v1778 T{int}, v1545 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
818: v1780 <- BoxInt64(v1549 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
819: ParallelMove r1 <- r7, r0 <- r0 | |
820: StoreIndexed:34(v33, v1771 T{int}, v1780 T{int}) | |
822: v1554 <- BinaryInt64Op(+ [tr], v2970 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
824: v1012 <- BinaryInt64Op(+ [tr], v1003 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
826: ParallelMove r9 <- r1, r8 <- r0 goto:58 B465 | |
828: B462[target]:24 | |
830: ParallelMove goto:1006 B115 | |
832: B114[target]:1002 ParallelMove r7 <- S-15 | |
834: ParallelMove goto:1008 B115 | |
836: B115[join]:1004 pred(B114, B462) | |
838: ParallelMove r1 <- S-12, r5 <- r7, r2 <- S-24, r3 <- S-25 goto:1014 B116 | |
840: B106[target]:890 ParallelMove r2 <- S-9, r1 <- S-8, r7 <- S-15 | |
842: v1785 <- UnboxInt64([non-speculative], v27 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int} | |
843: ParallelMove S-26 <- r0 | |
844: v88 <- BinaryInt64Op(+ [tr], v1785 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
845: ParallelMove S-25 <- r1 | |
846: PushArgument(v26) | |
848: PushArgument(v88) | |
850: PushArgument(v8) | |
852: v89 <- StaticCall:1022( _List@0150898.filled<0> v26, v88, v8, result_type = T{_List}) T{_List} | |
853: ParallelMove r0 <- r0, r1 <- r0, r2 <- S-9 | |
854: ParallelMove S-24 <- r1 | |
854: StoreField(v16 . tableLefts = v89) | |
856: PushArgument(v26) | |
857: ParallelMove r0 <- S-26 | |
858: PushArgument(v1785 T{_Smi}) | |
860: v92 <- StaticCall:1026( Iterable.generate<0> v26, v1785 T{_Smi}, result_type = T{*}) T{*?} | |
861: ParallelMove r0 <- r0 | |
862: v3958 <- LoadClassId(<non-smi> v92) | |
864: PushArgument(v92) | |
865: ParallelMove r0 <- r1 | |
866: v93 <- DispatchTableCall( cid=v3958 Iterable.iterator<0>, v92) T{*?} | |
867: ParallelMove r1 <- r0 | |
868: ParallelMove S-28 <- r1 | |
868: ParallelMove r4 <- C, r2 <- S-11, r3 <- S-13 goto:1056 B119 | |
870: B119[join]:1054 pred(B106, B117) { | |
v94 <- phi(v2634, v402) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
871: ParallelMove S-27 <- r4 | |
872: CheckStackOverflow:1060(stack=0, loop=1) | |
874: v3959 <- LoadClassId(<non-smi> v93 T{*?}) | |
876: PushArgument(v93 T{*?}) | |
877: ParallelMove r0 <- r0 | |
878: v95 <- DispatchTableCall( cid=v3959 Iterator.moveNext<0>, v93 T{*?}) T{bool} | |
879: ParallelMove r0 <- r0 | |
880: Branch if StrictCompare:1034(===, v95, v25) goto (117, 118) | |
882: B117[target]:1038 ParallelMove r2 <- S-11, r3 <- S-13, r1 <- S-28, r4 <- S-27 | |
884: v3960 <- LoadClassId(<non-smi> v93 T{*}) | |
886: PushArgument(v93 T{*}) | |
887: ParallelMove r0 <- r0 | |
888: v395 <- DispatchTableCall( cid=v3960 Iterator.current<0>, v93 T{*}) T{*?} | |
889: ParallelMove r0 <- r0 | |
890: v1791 <- UnboxInt64([non-speculative], v395 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
891: ParallelMove r0 <- S-25, r1 <- r2 | |
892: GenericCheckBound:1044(v88 T{_Smi}, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
893: ParallelMove r3 <- S-27 | |
894: v1788 <- BoxInt64(v94) [-9223372036854775808, 9223372036854775807] T{int} | |
895: ParallelMove r1 <- S-24, r0 <- r0 | |
896: StoreIndexed:1044(v89, v1791 T{int}, v1788 T{int}) | |
897: ParallelMove r0 <- S-26, r1 <- r2 | |
898: GenericCheckBound:1046(v1785 T{_Smi}, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
899: ParallelMove r5 <- S-11 | |
900: v2640 <- LoadIndexed(v28, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
901: ParallelMove r0 <- S-10, r1 <- r2 | |
902: GenericCheckBound:1048(v30 T{_Smi}, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
903: ParallelMove r6 <- S-13 | |
904: v2641 <- LoadIndexed(v31, v1791 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
906: v1796 <- UnboxInt64([non-speculative], v2640 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
908: v1799 <- UnboxInt64([non-speculative], v2641 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
910: v401 <- BinaryInt64Op(+ [tr], v1796 T{int}, v1799 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
912: v402 <- BinaryInt64Op(+ [tr], v94, v401) [-9223372036854775808, 9223372036854775807] T{int} | |
914: ParallelMove r4 <- r4, r2 <- r5, r3 <- r6, r1 <- S-28 goto:1058 B119 | |
916: B118[target]:1040 ParallelMove r2 <- S-9, r6 <- S-13, r5 <- S-12, r3 <- S-27, r4 <- S-26 | |
917: ParallelMove r0 <- S-25, r1 <- r4 | |
918: GenericCheckBound:1064(v88 T{_Smi}, v1785 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
920: v1787 <- BoxInt64(v94) [-9223372036854775808, 9223372036854775807] T{int} | |
921: ParallelMove r1 <- S-24, r0 <- r0 | |
922: StoreIndexed:1064(v89, v1785 T{_Smi}, v1787 T{int}) | |
923: ParallelMove r0 <- S-10, r1 <- r4 | |
924: GenericCheckBound:1068(v30 T{_Smi}, v1785 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
926: v2642 <- LoadIndexed(v31, v1785 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int} | |
928: v1806 <- UnboxInt64([non-speculative], v2642 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
930: v103 <- BinaryInt64Op(+ [tr], v94, v1806 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
931: ParallelMove S-29 <- r0 | |
932: v106 <- BinaryInt64Op(+ [tr], v32 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
933: ParallelMove S-26 <- r1 | |
934: PushArgument(v26) | |
936: PushArgument(v106) | |
938: PushArgument(v8) | |
940: v107 <- StaticCall:1076( _List@0150898.filled<0> v26, v106, v8, result_type = T{_List}) T{_List} | |
941: ParallelMove r0 <- r0, r1 <- r0, r2 <- S-9 | |
942: ParallelMove S-28 <- r1 | |
942: StoreField(v16 . tableTops = v107) | |
944: PushArgument(v26) | |
945: ParallelMove r0 <- S-12 | |
946: PushArgument(v32 T{_Smi}) | |
948: v110 <- StaticCall:1080( Iterable.generate<0> v26, v32 T{_Smi}, result_type = T{*}) T{*?} | |
949: ParallelMove r0 <- r0 | |
950: v3961 <- LoadClassId(<non-smi> v110) | |
952: PushArgument(v110) | |
953: ParallelMove r0 <- r1 | |
954: v111 <- DispatchTableCall( cid=v3961 Iterable.iterator<0>, v110) T{*?} | |
955: ParallelMove r1 <- r0 | |
956: ParallelMove S-31 <- r1 | |
956: ParallelMove r4 <- C, r2 <- S-15, r3 <- S-23 goto:1110 B122 | |
958: B122[join]:1108 pred(B118, B120) { | |
v112 <- phi(v2634, v394) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
959: ParallelMove S-27 <- r4 | |
960: CheckStackOverflow:1114(stack=0, loop=1) | |
962: v3962 <- LoadClassId(<non-smi> v111 T{*?}) | |
964: PushArgument(v111 T{*?}) | |
965: ParallelMove r0 <- r0 | |
966: v113 <- DispatchTableCall( cid=v3962 Iterator.moveNext<0>, v111 T{*?}) T{bool} | |
967: ParallelMove r0 <- r0 | |
968: Branch if StrictCompare:1088(===, v113, v25) goto (120, 121) | |
970: B120[target]:1092 ParallelMove r2 <- S-15, r3 <- S-23, r1 <- S-31, r4 <- S-27 | |
972: v3963 <- LoadClassId(<non-smi> v111 T{*}) | |
974: PushArgument(v111 T{*}) | |
975: ParallelMove r0 <- r0 | |
976: v387 <- DispatchTableCall( cid=v3963 Iterator.current<0>, v111 T{*}) T{*?} | |
977: ParallelMove r0 <- r0 | |
978: v1814 <- UnboxInt64([non-speculative], v387 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
979: ParallelMove r0 <- S-26, r1 <- r2 | |
980: GenericCheckBound:1098(v106 T{_Smi}, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
981: ParallelMove r3 <- S-27 | |
982: v1811 <- BoxInt64(v112) [-9223372036854775808, 9223372036854775807] T{int} | |
983: ParallelMove r1 <- S-28, r0 <- r0 | |
984: StoreIndexed:1098(v107, v1814 T{int}, v1811 T{int}) | |
985: ParallelMove r0 <- S-12, r1 <- r2 | |
986: GenericCheckBound:1100(v32 T{_Smi}, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
987: ParallelMove r6 <- S-15 | |
988: v2643 <- LoadIndexed(v33, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
989: ParallelMove r0 <- S-14, r1 <- r2 | |
990: GenericCheckBound:1102(v35 T{_Smi}, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
991: ParallelMove r5 <- S-23 | |
992: v2644 <- LoadIndexed(v36, v1814 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
994: v1819 <- UnboxInt64([non-speculative], v2643 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
996: v1822 <- UnboxInt64([non-speculative], v2644 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
998: v393 <- BinaryInt64Op(+ [tr], v1819 T{int}, v1822 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1000: v394 <- BinaryInt64Op(+ [tr], v112, v393) [-9223372036854775808, 9223372036854775807] T{int} | |
1002: ParallelMove r4 <- r4, r2 <- r6, r3 <- r5, r1 <- S-31 goto:1112 B122 | |
1004: B121[target]:1094 ParallelMove r2 <- S-9, r9 <- S-2, r4 <- S-12, r8 <- S-14, r5 <- S-23, r6 <- S-29, r3 <- S-27, r7 <- S-18 | |
1005: ParallelMove r0 <- S-26, r1 <- r4 | |
1006: GenericCheckBound:1118(v106 T{_Smi}, v32 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
1008: v1810 <- BoxInt64(v112) [-9223372036854775808, 9223372036854775807] T{int} | |
1009: ParallelMove r1 <- S-28, r0 <- r0 | |
1010: StoreIndexed:1118(v107, v32 T{_Smi}, v1810 T{int}) | |
1011: ParallelMove r0 <- r8, r1 <- r4 | |
1012: GenericCheckBound:1122(v35 T{_Smi}, v32 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
1014: v2645 <- LoadIndexed(v36, v32 T{_Smi}) [-9223372036854775808, 9223372036854775807] T{int} | |
1016: v1829 <- UnboxInt64([non-speculative], v2645 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1018: v121 <- BinaryInt64Op(+ [tr], v112, v1829 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1019: ParallelMove S-30 <- r10 | |
1020: v1807 <- BoxInt64(v103) [-9223372036854775808, 9223372036854775807] T{int} | |
1021: ParallelMove r0 <- r0 | |
1022: ParallelMove S-31 <- r0 | |
1022: v122 <- AllocateObject:1126(cls=TextSurface) T{TextSurface} | |
1023: ParallelMove r0 <- r0 | |
1024: ParallelMove S-32 <- r0 | |
1024: PushArgument(v122) | |
1026: PushArgument(v1807 T{int}) | |
1027: ParallelMove r1 <- S-30 | |
1028: PushArgument(v121) | |
1030: StaticCall:1128( TextSurface.<0> v122, v1807 T{int}, v121) | |
1031: ParallelMove r0 <- S-32, r2 <- S-9 | |
1032: StoreField(v16 . surface = v122) | |
1034: PushArgument(v26) | |
1035: ParallelMove r0 <- S-14 | |
1036: PushArgument(v35 T{int}) | |
1038: v125 <- StaticCall:1134( Iterable.generate<0> v26, v35 T{int}, result_type = T{*}) T{*?} | |
1039: ParallelMove r0 <- r0 | |
1040: v3964 <- LoadClassId(<non-smi> v125) | |
1042: PushArgument(v125) | |
1043: ParallelMove r0 <- r1 | |
1044: v126 <- DispatchTableCall( cid=v3964 Iterable.iterator<0>, v125) T{*?} | |
1045: ParallelMove r1 <- r0, r7 <- S-18 | |
1046: ParallelMove S-36 <- r1 | |
1046: v255 <- LoadField:2408(v525 . border {final}) T{bool} | |
1047: ParallelMove r8 <- S-2, S-35 <- r2 | |
1048: v262 <- LoadField:2408(v17 . horizontal {final}) T{String} | |
1049: ParallelMove S-34 <- r3 | |
1050: v289 <- LoadField:2408(v17 . vertical {final}) T{String} | |
1051: ParallelMove S-33 <- r4 | |
1052: v903 <- LoadField:2408(v17 . characters {final}) T{StringCharacters} | |
1053: ParallelMove S-31 <- r5 | |
1054: ParallelMove goto:2408 B316 | |
1056: B316[join]:2406 pred(B121, B126) ParallelMove r11 <- S-1, r9 <- S-13, r7 <- S-12, r6 <- S-23, r10 <- S-24, r8 <- S-28 | |
1058: CheckStackOverflow:2412(stack=0, loop=1) | |
1060: v3965 <- LoadClassId(<non-smi> v126 T{*?}) | |
1062: PushArgument(v126 T{*?}) | |
1063: ParallelMove r0 <- r0 | |
1064: v154 <- DispatchTableCall( cid=v3965 Iterator.moveNext<0>, v126 T{*?}) T{bool} | |
1065: ParallelMove r0 <- r0 | |
1066: Branch if StrictCompare:1142(===, v154, v25) goto (123, 124) | |
1068: B123[target]:1146 ParallelMove r3 <- S-1, r2 <- S-28, r1 <- S-36 | |
1070: v3966 <- LoadClassId(<non-smi> v126 T{*}) | |
1072: PushArgument(v126 T{*}) | |
1073: ParallelMove r0 <- r0 | |
1074: v160 <- DispatchTableCall( cid=v3966 Iterator.current<0>, v126 T{*}) T{*?} | |
1075: ParallelMove r2 <- r0 | |
1076: ParallelMove S-38 <- r2 | |
1076: v1842 <- UnboxInt64([non-speculative], v160 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1077: ParallelMove r0 <- S-26, r1 <- r3, S-27 <- r3 | |
1078: GenericCheckBound:1152(v106 T{_Smi}, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1079: ParallelMove r0 <- S-28 | |
1080: v2646 <- LoadIndexed(v107, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1081: ParallelMove r4 <- S-1, S-37 <- r1 | |
1082: v163 <- LoadField(v7 . columnCount) T{int??} | |
1084: CheckNull:1156(v163, CastError) [-9223372036854775808, 9223372036854775807] T{int?} | |
1086: v1846 <- UnboxInt64([non-speculative], v163 T{int?}) [-9223372036854775808, 9223372036854775807] T{int} | |
1088: v164 <- BinaryInt64Op(+ [tr], v1846, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
1090: PushArgument(v26) | |
1092: PushArgument(v164) | |
1094: v165 <- StaticCall:1160( Iterable.generate<0> v26, v164, result_type = T{*}) T{*?} | |
1095: ParallelMove r0 <- r0 | |
1096: v3967 <- LoadClassId(<non-smi> v165) | |
1098: PushArgument(v165) | |
1099: ParallelMove r0 <- r1 | |
1100: v166 <- DispatchTableCall( cid=v3967 Iterable.iterator<0>, v165) T{*?} | |
1101: ParallelMove r3 <- r0, r2 <- S-27 | |
1102: ParallelMove S-40 <- r3 | |
1102: v204 <- BinaryInt64Op:2400(- [tr], v1842 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
1104: v1859 <- BoxInt64:2400(v204) [-9223372036854775808, 9223372036854775807] T{int} | |
1105: ParallelMove r4 <- r0, r1 <- S-37 | |
1106: ParallelMove S-39 <- r4 | |
1106: v1845 <- UnboxInt64:2400([non-speculative], v2646 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1107: ParallelMove S-29 <- r5 | |
1108: ParallelMove goto:2400 B315 | |
1110: B315[join]:2398 pred(B123, B314) ParallelMove r7 <- S-1, r11 <- S-13, r10 <- S-12, r9 <- S-23, r12 <- S-24, r6 <- S-28, r8 <- S-35 | |
1112: CheckStackOverflow:2404(stack=0, loop=2) | |
1114: v3968 <- LoadClassId(<non-smi> v166 T{*?}) | |
1116: PushArgument(v166 T{*?}) | |
1117: ParallelMove r0 <- r0 | |
1118: v191 <- DispatchTableCall( cid=v3968 Iterator.moveNext<0>, v166 T{*?}) T{bool} | |
1119: ParallelMove r0 <- r0 | |
1120: Branch if StrictCompare:1168(===, v191, v25) goto (125, 126) | |
1122: B125[target]:1172 ParallelMove r1 <- S-40 | |
1124: v3969 <- LoadClassId(<non-smi> v166 T{*}) | |
1126: PushArgument(v166 T{*}) | |
1127: ParallelMove r0 <- r0 | |
1128: v192 <- DispatchTableCall( cid=v3969 Iterator.current<0>, v166 T{*}) T{*?} | |
1129: ParallelMove r0 <- r0 | |
1130: ParallelMove S-41 <- r0 | |
1130: v1858 <- UnboxInt64([non-speculative], v192 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1131: ParallelMove S-30 <- r1 | |
1132: PushArgument(v7) | |
1134: PushArgument(v160 T{int}) | |
1136: PushArgument(v1858 T{int}) | |
1138: v193 <- StaticCall:1178( getOrNull<0> v7, v160 T{int}, v1858 T{int}, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?} | |
1139: ParallelMove r0 <- r0 | |
1140: Branch if StrictCompare:1180(===, v193, v0) goto (127, 128) | |
1142: B127[target]:1184 | |
1144: ParallelMove r1 <- C goto:1192 B129 | |
1146: B128[target]:1186 | |
1148: v194 <- LoadField(v193 T{PositionedCell} . cell {final}) T{Cell} | |
1150: ParallelMove r1 <- r1 goto:1194 B129 | |
1152: B129[join]:1190 pred(B127, B128) { | |
v195 <- phi(v0, v194) alive T{Cell?} | |
} | |
1153: ParallelMove S-44 <- r1 | |
1154: Branch if StrictCompare:1196(===, v193, v0) goto (130, 131) | |
1156: B130[target]:1200 | |
1158: ParallelMove r2 <- C goto:1208 B132 | |
1160: B131[target]:1202 | |
1162: v196 <- LoadField(v193 T{PositionedCell} . canonicalStyle {final}) T{CellStyle} | |
1164: ParallelMove r2 <- r2 goto:1210 B132 | |
1166: B132[join]:1206 pred(B130, B131) { | |
v197 <- phi(v0, v196) alive T{CellStyle?} | |
} ParallelMove r0 <- S-30 | |
1167: ParallelMove S-43 <- r2 | |
1168: v198 <- BinaryInt64Op(- [tr], v1858 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
1169: ParallelMove S-42 <- r3 | |
1170: PushArgument(v7) | |
1172: PushArgument(v160 T{int}) | |
1174: PushArgument(v198) | |
1176: v199 <- StaticCall:1214( getOrNull<0> v7, v160 T{int}, v198, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?} | |
1177: ParallelMove r0 <- r0 | |
1178: Branch if StrictCompare:1216(===, v199, v0) goto (133, 134) | |
1180: B133[target]:1220 | |
1182: ParallelMove r1 <- C goto:1228 B135 | |
1184: B134[target]:1222 | |
1186: v200 <- LoadField(v199 T{PositionedCell} . cell {final}) T{Cell} | |
1188: ParallelMove r1 <- r1 goto:1230 B135 | |
1190: B135[join]:1226 pred(B133, B134) { | |
v201 <- phi(v0, v200) alive T{Cell?} | |
} | |
1191: ParallelMove S-46 <- r1 | |
1192: Branch if StrictCompare:1232(===, v199, v0) goto (136, 137) | |
1194: B136[target]:1236 | |
1196: ParallelMove r2 <- C goto:1244 B138 | |
1198: B137[target]:1238 | |
1200: v202 <- LoadField(v199 T{PositionedCell} . canonicalStyle {final}) T{CellStyle} | |
1202: ParallelMove r2 <- r2 goto:1246 B138 | |
1204: B138[join]:1242 pred(B136, B137) { | |
v203 <- phi(v0, v202) alive T{CellStyle?} | |
} ParallelMove r0 <- S-30 | |
1205: ParallelMove S-45 <- r2 | |
1206: PushArgument(v7) | |
1208: PushArgument(v1859 T{int}) | |
1210: PushArgument(v1858 T{int}) | |
1212: v205 <- StaticCall:1250( getOrNull<0> v7, v1859 T{int}, v1858 T{int}, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?} | |
1213: ParallelMove r0 <- r0 | |
1214: Branch if StrictCompare:1252(===, v205, v0) goto (139, 140) | |
1216: B139[target]:1256 | |
1218: ParallelMove r2 <- C goto:1264 B141 | |
1220: B140[target]:1258 | |
1222: v206 <- LoadField(v205 T{PositionedCell} . cell {final}) T{Cell} | |
1224: ParallelMove r2 <- r1 goto:1266 B141 | |
1226: B141[join]:1262 pred(B139, B140) { | |
v207 <- phi(v0, v206) alive T{Cell?} | |
} | |
1227: ParallelMove S-53 <- r2 | |
1228: Branch if StrictCompare:1268(===, v205, v0) goto (142, 143) | |
1230: B142[target]:1272 | |
1232: ParallelMove r8 <- C goto:1280 B144 | |
1234: B143[target]:1274 | |
1236: v208 <- LoadField(v205 T{PositionedCell} . canonicalStyle {final}) T{CellStyle} | |
1238: ParallelMove r8 <- r1 goto:1282 B144 | |
1240: B144[join]:1278 pred(B142, B143) { | |
v209 <- phi(v0, v208) alive T{CellStyle?} | |
} ParallelMove r6 <- S-13, r5 <- S-23, r7 <- S-24, r4 <- S-27, r3 <- S-30 | |
1241: ParallelMove r0 <- S-25, r1 <- r3, S-52 <- r8 | |
1242: GenericCheckBound:1284(v88 T{_Smi}, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1244: v2647 <- LoadIndexed(v89, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1245: ParallelMove r0 <- S-14, r1 <- r4, S-51 <- r9 | |
1246: GenericCheckBound:1286(v35 T{_Smi}, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1248: v2648 <- LoadIndexed(v36, v1842 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1250: v1868 <- UnboxInt64([non-speculative], v2648 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1251: ParallelMove S-50 <- r10 | |
1252: v214 <- EqualityCompare(v1868 T{int} != v2634) T{bool} | |
1253: ParallelMove r0 <- S-10, r1 <- r3, S-49 <- r11 | |
1254: GenericCheckBound:1292(v30 T{_Smi}, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1256: v2649 <- LoadIndexed(v31, v1858 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1258: v1872 <- UnboxInt64([non-speculative], v2649 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1259: ParallelMove S-48 <- r1 | |
1260: v218 <- EqualityCompare(v1872 T{int} != v2634) T{bool} | |
1261: ParallelMove S-47 <- r0 | |
1262: Branch if StrictCompare:1300(===, v214, v25) goto (145, 252) | |
1264: B145[target]:1310 | |
1266: Branch if StrictCompare:1306(===, v218, v25) goto (146, 253) | |
1268: B146[target]:1312 ParallelMove r12 <- S-42 | |
1270: PushArgument(v7) | |
1272: PushArgument(v1859 T{int}) | |
1274: PushArgument(v198 T{int}) | |
1276: v301 <- StaticCall:1318( getOrNull<0> v7, v1859 T{int}, v198 T{int}, using unchecked entrypoint, result_type = T{PositionedCell?}) T{PositionedCell?} | |
1277: ParallelMove r0 <- r0 | |
1278: Branch if StrictCompare:1320(===, v301, v0) goto (147, 148) | |
1280: B147[target]:1324 | |
1282: ParallelMove r1 <- C goto:1332 B149 | |
1284: B148[target]:1326 | |
1286: v302 <- LoadField(v301 T{PositionedCell} . cell {final}) T{Cell} | |
1288: ParallelMove r1 <- r1 goto:1334 B149 | |
1290: B149[join]:1330 pred(B147, B148) { | |
v303 <- phi(v0, v302) alive T{Cell?} | |
} | |
1292: Branch if StrictCompare:1336(===, v301, v0) goto (150, 151) | |
1294: B150[target]:1340 | |
1296: ParallelMove r2 <- C goto:1348 B152 | |
1298: B151[target]:1342 | |
1300: v304 <- LoadField(v301 T{PositionedCell} . canonicalStyle {final}) T{CellStyle} | |
1302: ParallelMove r2 <- r2 goto:1350 B152 | |
1304: B152[join]:1346 pred(B150, B151) { | |
v305 <- phi(v0, v304) alive T{CellStyle?} | |
} ParallelMove r0 <- S-53 | |
1306: Branch if StrictCompare:1354(!==, v303, v207) goto (154, 172) | |
1308: B154[target]:1358 | |
1310: Branch if StrictCompare:1360(===, v305, v0) goto (705, 156) | |
1312: B705[target]:1364 | |
1314: ParallelMove goto:1408 B161 | |
1316: B156[target]:1366 | |
1318: v372 <- LoadField(v305 T{CellStyle} . borderRight {final}) T{bool?} | |
1320: Branch if StrictCompare(===, v372, v25) goto (169, 707) | |
1322: B169[target]:1464 | |
1324: ParallelMove r3 <- S-52 goto:1466 B168 | |
1326: B707[target]:1408 | |
1328: ParallelMove goto:1408 B161 | |
1330: B161[join]:1408 pred(B705, B707) ParallelMove r3 <- S-52 | |
1332: Branch if StrictCompare:1384(===, v209, v0) goto (709, 159) | |
1334: B709[target]:1388 | |
1336: ParallelMove goto:1410 B162 | |
1338: B159[target]:1390 | |
1340: v375 <- LoadField(v209 T{CellStyle} . borderLeft {final}) T{bool?} | |
1342: Branch if StrictCompare(===, v375, v25) goto (170, 711) | |
1344: B170[target]:1468 | |
1346: ParallelMove goto:1470 B168 | |
1348: B168[join]:1462 pred(B169, B170) | |
1350: ParallelMove r9 <- C, r7 <- S-1, r6 <- S-41, r4 <- S-27, r5 <- S-30 goto:1472 B153 | |
1352: B711[target]:1410 | |
1354: ParallelMove goto:1410 B162 | |
1356: B162[join]:1410 pred(B709, B711) ParallelMove r4 <- S-27 | |
1358: Branch if RelationalOp(>, v1842 T{int}, v2634) T{bool} goto (164, 173) | |
1360: B164[target]:1440 ParallelMove r5 <- S-30 | |
1362: Branch if EqualityCompare(v1858 T{int} == v2634) T{bool} goto (166, 163) | |
1364: B166[target]:1444 | |
1366: ParallelMove r7 <- S-1, r6 <- S-41 goto:1446 B165 | |
1368: B163[target]:1438 ParallelMove r7 <- S-1, r6 <- S-41 | |
1370: v380 <- LoadField(v7 . columnCount) T{int??} | |
1372: Branch if EqualityCompare(v192 T{int} == v380) T{bool} goto (167, 174) | |
1374: B167[target]:1448 | |
1376: ParallelMove goto:1450 B165 | |
1378: B165[join]:1442 pred(B166, B167) | |
1380: ParallelMove r9 <- S-35 goto:1460 B153 | |
1382: B174[target]:1484 | |
1384: ParallelMove goto:1486 B171 | |
1386: B173[target]:1480 ParallelMove r7 <- S-1, r6 <- S-41, r5 <- S-30 | |
1388: ParallelMove goto:1482 B171 | |
1390: B172[target]:1476 ParallelMove r7 <- S-1, r6 <- S-41, r3 <- S-52, r4 <- S-27, r5 <- S-30 | |
1392: ParallelMove goto:1478 B171 | |
1394: B171[join]:1474 pred(B172, B173, B174) | |
1396: ParallelMove r9 <- C goto:1488 B153 | |
1398: B153[join]:1352 pred(B165, B168, B171) { | |
v309 <- phi(v255, v25, v308) alive T{bool} | |
} ParallelMove r8 <- S-46 | |
1400: Branch if StrictCompare:1492(!==, v303, v201) goto (176, 194) | |
1402: B176[target]:1496 | |
1404: Branch if StrictCompare:1498(===, v305, v0) goto (713, 178) | |
1406: B713[target]:1502 | |
1408: ParallelMove goto:1546 B183 | |
1410: B178[target]:1504 | |
1412: v357 <- LoadField(v305 T{CellStyle} . borderBottom {final}) T{bool?} | |
1414: Branch if StrictCompare(===, v357, v25) goto (191, 715) | |
1416: B191[target]:1602 | |
1418: ParallelMove r1 <- S-45 goto:1604 B190 | |
1420: B715[target]:1546 | |
1422: ParallelMove goto:1546 B183 | |
1424: B183[join]:1546 pred(B713, B715) ParallelMove r1 <- S-45 | |
1426: Branch if StrictCompare:1522(===, v203, v0) goto (717, 181) | |
1428: B717[target]:1526 | |
1430: ParallelMove goto:1548 B184 | |
1432: B181[target]:1528 | |
1434: v360 <- LoadField(v203 T{CellStyle} . borderTop {final}) T{bool?} | |
1436: Branch if StrictCompare(===, v360, v25) goto (192, 719) | |
1438: B192[target]:1606 | |
1440: ParallelMove goto:1608 B190 | |
1442: B190[join]:1600 pred(B191, B192) | |
1444: ParallelMove r11 <- C, r2 <- S-12 goto:1610 B175 | |
1446: B719[target]:1548 | |
1448: ParallelMove goto:1548 B184 | |
1450: B184[join]:1548 pred(B717, B719) | |
1452: Branch if RelationalOp(>, v1858 T{int}, v2634) T{bool} goto (186, 195) | |
1454: B186[target]:1578 | |
1456: Branch if EqualityCompare(v1842 T{int} == v2634) T{bool} goto (188, 185) | |
1458: B188[target]:1582 | |
1460: ParallelMove r2 <- S-12 goto:1584 B187 | |
1462: B185[target]:1576 ParallelMove r2 <- S-12 | |
1464: Branch if EqualityCompare(v1842 T{int} == v32 T{int}) T{bool} goto (189, 196) | |
1466: B189[target]:1586 | |
1468: ParallelMove goto:1588 B187 | |
1470: B187[join]:1580 pred(B188, B189) | |
1472: ParallelMove r11 <- S-35 goto:1598 B175 | |
1474: B196[target]:1622 | |
1476: ParallelMove goto:1624 B193 | |
1478: B195[target]:1618 ParallelMove r2 <- S-12 | |
1480: ParallelMove goto:1620 B193 | |
1482: B194[target]:1614 ParallelMove r2 <- S-12, r1 <- S-45 | |
1484: ParallelMove goto:1616 B193 | |
1486: B193[join]:1612 pred(B194, B195, B196) | |
1488: ParallelMove r11 <- C goto:1626 B175 | |
1490: B175[join]:1490 pred(B187, B190, B193) { | |
v313 <- phi(v255, v25, v308) alive T{bool} | |
} ParallelMove r10 <- S-44 | |
1492: Branch if StrictCompare:1630(!==, v201, v195) goto (198, 216) | |
1494: B198[target]:1634 | |
1496: Branch if StrictCompare:1636(===, v203, v0) goto (721, 200) | |
1498: B721[target]:1640 | |
1500: ParallelMove goto:1684 B205 | |
1502: B200[target]:1642 | |
1504: v341 <- LoadField(v203 T{CellStyle} . borderRight {final}) T{bool?} | |
1506: Branch if StrictCompare(===, v341, v25) goto (213, 723) | |
1508: B213[target]:1742 | |
1510: ParallelMove r12 <- S-43 goto:1744 B212 | |
1512: B723[target]:1684 | |
1514: ParallelMove goto:1684 B205 | |
1516: B205[join]:1684 pred(B721, B723) ParallelMove r12 <- S-43 | |
1518: Branch if StrictCompare:1660(===, v197, v0) goto (725, 203) | |
1520: B725[target]:1664 | |
1522: ParallelMove goto:1686 B206 | |
1524: B203[target]:1666 | |
1526: v344 <- LoadField(v197 T{CellStyle} . borderLeft {final}) T{bool?} | |
1528: Branch if StrictCompare(===, v344, v25) goto (214, 727) | |
1530: B214[target]:1746 | |
1532: ParallelMove goto:1748 B212 | |
1534: B212[join]:1740 pred(B213, B214) | |
1536: ParallelMove r13 <- C goto:1750 B197 | |
1538: B727[target]:1686 | |
1540: ParallelMove goto:1686 B206 | |
1542: B206[join]:1686 pred(B725, B727) | |
1544: Branch if RelationalOp(<, v1842 T{int}, v32 T{int}) T{bool} goto (208, 217) | |
1546: B208[target]:1718 | |
1548: Branch if EqualityCompare(v1858 T{int} == v2634) T{bool} goto (210, 207) | |
1550: B210[target]:1722 | |
1552: ParallelMove goto:1724 B209 | |
1554: B207[target]:1716 | |
1556: v350 <- LoadField(v7 . columnCount) T{int??} | |
1558: Branch if EqualityCompare(v192 T{int} == v350) T{bool} goto (211, 218) | |
1560: B211[target]:1726 | |
1562: ParallelMove goto:1728 B209 | |
1564: B209[join]:1720 pred(B210, B211) | |
1566: ParallelMove r13 <- S-35 goto:1738 B197 | |
1568: B218[target]:1762 | |
1570: ParallelMove goto:1764 B215 | |
1572: B217[target]:1758 | |
1574: ParallelMove goto:1760 B215 | |
1576: B216[target]:1754 ParallelMove r12 <- S-43 | |
1578: ParallelMove goto:1756 B215 | |
1580: B215[join]:1752 pred(B216, B217, B218) | |
1582: ParallelMove r13 <- C goto:1766 B197 | |
1584: B197[join]:1628 pred(B209, B212, B215) { | |
v317 <- phi(v255, v25, v308) alive T{bool} | |
} | |
1586: Branch if StrictCompare:1770(!==, v207, v195) goto (220, 238) | |
1588: B220[target]:1774 | |
1590: Branch if StrictCompare:1776(===, v209, v0) goto (729, 222) | |
1592: B729[target]:1780 | |
1594: ParallelMove goto:1824 B227 | |
1596: B222[target]:1782 | |
1598: v325 <- LoadField(v209 T{CellStyle} . borderBottom {final}) T{bool?} | |
1600: Branch if StrictCompare(===, v325, v25) goto (235, 731) | |
1602: B235[target]:1884 | |
1604: ParallelMove goto:1886 B234 | |
1606: B731[target]:1824 | |
1608: ParallelMove goto:1824 B227 | |
1610: B227[join]:1824 pred(B729, B731) | |
1612: Branch if StrictCompare:1800(===, v197, v0) goto (733, 225) | |
1614: B733[target]:1804 | |
1616: ParallelMove goto:1826 B228 | |
1618: B225[target]:1806 | |
1620: v328 <- LoadField(v197 T{CellStyle} . borderTop {final}) T{bool?} | |
1622: Branch if StrictCompare(===, v328, v25) goto (236, 735) | |
1624: B236[target]:1888 | |
1626: ParallelMove goto:1890 B234 | |
1628: B234[join]:1882 pred(B235, B236) | |
1630: ParallelMove r14 <- C goto:1892 B219 | |
1632: B735[target]:1826 | |
1634: ParallelMove goto:1826 B228 | |
1636: B228[join]:1826 pred(B733, B735) | |
1638: v331 <- LoadField(v7 . columnCount) T{int??} | |
1640: CheckNull:1830(v331, CastError) [-9223372036854775808, 9223372036854775807] T{int?} | |
1642: v1874 <- UnboxInt64([non-speculative], v331 T{int?}) [-9223372036854775808, 9223372036854775807] T{int} | |
1644: Branch if RelationalOp(<, v1858 T{int}, v1874) T{bool} goto (230, 239) | |
1646: B230[target]:1860 | |
1648: Branch if EqualityCompare(v1842 T{int} == v2634) T{bool} goto (232, 229) | |
1650: B232[target]:1864 | |
1652: ParallelMove goto:1866 B231 | |
1654: B229[target]:1858 | |
1656: Branch if EqualityCompare(v1842 T{int} == v32 T{int}) T{bool} goto (233, 240) | |
1658: B233[target]:1868 | |
1660: ParallelMove goto:1870 B231 | |
1662: B231[join]:1862 pred(B232, B233) | |
1664: ParallelMove r14 <- S-35 goto:1880 B219 | |
1666: B240[target]:1904 | |
1668: ParallelMove goto:1906 B237 | |
1670: B239[target]:1900 | |
1672: ParallelMove goto:1902 B237 | |
1674: B238[target]:1896 | |
1676: ParallelMove goto:1898 B237 | |
1678: B237[join]:1894 pred(B238, B239, B240) | |
1680: ParallelMove r14 <- C goto:1908 B219 | |
1682: B219[join]:1768 pred(B231, B234, B237) { | |
v321 <- phi(v255, v25, v308) alive T{bool} | |
} | |
1684: Branch if StrictCompare:1912(===, v309, v25) goto (245, 241) | |
1686: B245[target]:1942 | |
1688: ParallelMove goto:1944 B432 | |
1690: B241[target]:1922 | |
1692: Branch if StrictCompare:1918(===, v313, v25) goto (246, 242) | |
1694: B246[target]:1946 | |
1696: ParallelMove goto:1948 B432 | |
1698: B242[target]:1930 | |
1700: Branch if StrictCompare:1926(===, v317, v25) goto (247, 243) | |
1702: B247[target]:1950 | |
1704: ParallelMove goto:1952 B432 | |
1706: B243[target]:1938 | |
1708: Branch if StrictCompare:1934(===, v321, v25) goto (248, 249) | |
1710: B248[target]:1954 | |
1712: ParallelMove goto:1956 B432 | |
1714: B432[join]:1940 pred(B245, B246, B247, B248) ParallelMove r19 <- S-51 | |
1716: v1632 <- IfThenElse(===, v317, v25 ? 1 : 0) [0, 1] T{_Smi} | |
1718: v1631 <- IfThenElse(===, v309, v25 ? 2 : 0) [0, 2] T{_Smi} | |
1720: v1875 <- UnboxInt64([non-speculative], v1631) [0, 2] T{int} | |
1722: v1876 <- UnboxInt64([non-speculative], v1632) [0, 1] T{int} | |
1724: v908 <- BinaryInt64Op(| [tr], v1876 T{_Smi}, v1875 T{_Smi}) [0, 3] T{int} | |
1726: v1630 <- IfThenElse(===, v321, v25 ? 4 : 0) [0, 4] T{_Smi} | |
1728: v1877 <- UnboxInt64([non-speculative], v1630) [0, 4] T{int} | |
1730: v910 <- BinaryInt64Op(| [tr], v908 T{int}, v1877 T{_Smi}) [0, 7] T{int} | |
1732: v1629 <- IfThenElse(===, v313, v25 ? 8 : 0) [0, 8] T{_Smi} | |
1734: v1878 <- UnboxInt64([non-speculative], v1629) [0, 8] T{int} | |
1736: v912 <- BinaryInt64Op(| [tr], v910 T{int}, v1878 T{_Smi}) [0, 15] T{int} | |
1738: PushArgument(v903) | |
1740: PushArgument(v912 T{int}) | |
1742: v913 <- StaticCall:82( elementAt<0> v903, v912 T{int}, using unchecked entrypoint, result_type = T{*}) T{String} | |
1743: ParallelMove r0 <- r0 | |
1744: PushArgument(v0) | |
1746: PushArgument(v913 T{String}) | |
1748: v930 <- StaticCall:10( Characters.<0> v0, v913 T{String}, result_type = T{StringCharacters}) T{StringCharacters} | |
1749: ParallelMove r1 <- r0, r0 <- S-51 | |
1750: v1862 <- UnboxInt64([non-speculative], v2647 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1752: PushArgument(v122) | |
1754: PushArgument(v2646 T{int}) | |
1756: PushArgument(v1862 T{int}) | |
1758: PushArgument(v930) | |
1760: StaticCall:12( setCharacter<0> v122, v2646 T{int}, v1862 T{int}, v930, using unchecked entrypoint, result_type = T{??}) | |
1762: ParallelMove goto:1966 B250 | |
1764: B249[target]:1962 | |
1766: ParallelMove goto:1968 B250 | |
1768: B250[join]:1964 pred(B249, B432) | |
1770: ParallelMove goto:1982 B254 | |
1772: B253[target]:1976 | |
1774: ParallelMove goto:1978 B251 | |
1776: B252[target]:1972 | |
1778: ParallelMove goto:1974 B251 | |
1780: B251[join]:1970 pred(B252, B253) | |
1782: ParallelMove goto:1984 B254 | |
1784: B254[join]:1980 pred(B250, B251) ParallelMove r0 <- S-47 | |
1786: Branch if StrictCompare:1988(===, v218, v25) goto (255, 280) | |
1788: B255[target]:1996 ParallelMove r2 <- S-44, r0 <- S-46 | |
1790: Branch if StrictCompare:1992(!==, v201, v195) goto (268, 281) | |
1792: B268[target]:2092 ParallelMove r0 <- S-45 | |
1794: Branch if StrictCompare:1998(===, v203, v0) goto (737, 257) | |
1796: B737[target]:2002 | |
1798: ParallelMove goto:2046 B262 | |
1800: B257[target]:2004 | |
1802: v272 <- LoadField(v203 T{CellStyle} . borderRight {final}) T{bool?} | |
1804: Branch if StrictCompare(===, v272, v25) goto (270, 739) | |
1806: B270[target]:2096 | |
1808: ParallelMove r5 <- S-1, r3 <- S-43, r6 <- S-35, r4 <- S-30 goto:2098 B269 | |
1810: B739[target]:2046 | |
1812: ParallelMove goto:2046 B262 | |
1814: B262[join]:2046 pred(B737, B739) ParallelMove r3 <- S-43 | |
1816: Branch if StrictCompare:2022(===, v197, v0) goto (741, 260) | |
1818: B741[target]:2026 | |
1820: ParallelMove goto:2090 B267 | |
1822: B260[target]:2028 | |
1824: v275 <- LoadField(v197 T{CellStyle} . borderLeft {final}) T{bool?} | |
1826: Branch if StrictCompare(===, v275, v25) goto (271, 743) | |
1828: B271[target]:2100 | |
1830: ParallelMove r5 <- S-1, r6 <- S-35, r4 <- S-30 goto:2102 B269 | |
1832: B743[target]:2090 | |
1834: ParallelMove goto:2090 B267 | |
1836: B267[join]:2090 pred(B741, B743) ParallelMove r4 <- S-30 | |
1838: Branch if EqualityCompare(v1858 T{int} == v2634) T{bool} goto (265, 263) | |
1840: B265[target]:2082 | |
1842: ParallelMove r5 <- S-1 goto:2084 B264 | |
1844: B263[target]:2066 ParallelMove r5 <- S-1, r0 <- S-41 | |
1846: v279 <- LoadField(v7 . columnCount) T{int??} | |
1848: Branch if EqualityCompare(v192 T{int} == v279) T{bool} goto (266, 282) | |
1850: B266[target]:2086 | |
1852: ParallelMove goto:2088 B264 | |
1854: B264[join]:2080 pred(B265, B266) ParallelMove r6 <- S-35 | |
1856: Branch if StrictCompare:2076(===, v255, v25) goto (272, 283) | |
1858: B272[target]:2104 | |
1860: ParallelMove goto:2106 B269 | |
1862: B269[join]:2094 pred(B270, B271, B272) ParallelMove r10 <- S-28, r7 <- S-27, r9 <- S-29, r8 <- S-50 | |
1864: v287 <- BinaryInt64Op(+ [tr], v1842 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
1865: ParallelMove r0 <- S-26, r1 <- r11 | |
1866: GenericCheckBound:2110(v106 T{_Smi}, v287) [-9223372036854775808, 9223372036854775807] T{int} | |
1868: v2650 <- LoadIndexed(v107, v287 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1869: ParallelMove S-41 <- r0 | |
1870: v1593 <- LoadStaticField:4(_emptyList@0150898, CallsInitializer) T{_List} | |
1871: ParallelMove r1 <- C, r0 <- r0 | |
1872: ParallelMove S-45 <- r0 | |
1872: v1391 <- AllocateObject:10(cls=_GrowableList, v26) T{_GrowableList} | |
1873: ParallelMove r2 <- r0, r0 <- S-45 | |
1874: ParallelMove S-46 <- r2 | |
1874: StoreField(v1391 . GrowableObjectArray.data = v1593, NoStoreBarrier) | |
1876: StoreField(v1391 . GrowableObjectArray.length = v8, NoStoreBarrier) | |
1877: ParallelMove r3 <- S-29, r1 <- S-50 | |
1878: v291 <- BinaryInt64Op(+ [tr], v1845 T{int}, v1868 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1879: ParallelMove r1 <- S-41 | |
1880: v1881 <- UnboxInt64:2136([non-speculative], v2650 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1881: ParallelMove S-54 <- r5 | |
1882: ParallelMove r6 <- r4, r4 <- C, r0 <- r0 goto:2136 B275 | |
1884: B275[join]:2134 pred(B269, B406) { | |
v292 <- phi(v291, v298) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
v2451 <- phi(v2634, v872 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
v2450 <- phi(v1593, v875) alive T{_List} | |
} | |
1885: ParallelMove S-42 <- r6, S-50 <- r4 | |
1886: CheckStackOverflow:2140(stack=0, loop=3) | |
1888: Branch if RelationalOp(<, v292, v1881 T{int}) T{bool} goto (273, 274) | |
1890: B273[target]:2126 | |
1892: v1377 <- LoadField(v2450 . Array.length {final}) [0, 576460752303423487] T{_Smi} | |
1894: v3941 <- BoxInt64(v2451 T{_Smi}) | |
1895: ParallelMove r0 <- r0 | |
1896: Branch if StrictCompare(===, v3941 T{_Smi}, v1377) T{bool} goto (404, 405) | |
1898: B404[target]:24 | |
1900: PushArgument(v1391) | |
1902: StaticCall:26( _growToNextCapacity@0150898<0> v1391, using unchecked entrypoint, result_type = T{??}) | |
1904: ParallelMove goto:32 B406 | |
1906: B405[target]:28 | |
1908: ParallelMove goto:34 B406 | |
1910: B406[join]:30 pred(B404, B405) ParallelMove r4 <- S-42, r2 <- S-46, r3 <- S-50 | |
1912: v872 <- BinaryInt64Op(+ [tr], v2451 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
1914: v1885 <- BoxInt64(v872) [-9223372036854775808, 9223372036854775807] T{int} | |
1915: ParallelMove r0 <- r0 | |
1916: StoreField(v1391 . GrowableObjectArray.length = v1885 T{int}, NoStoreBarrier) | |
1917: ParallelMove r0 <- r5, r1 <- r3 | |
1918: GenericCheckBound:40(v872 T{_Smi}, v2451 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
1920: v875 <- LoadField(v1391 . GrowableObjectArray.data) T{_List} | |
1922: v1882 <- BoxInt64(v292 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1923: ParallelMove r1 <- r7, r0 <- r0 | |
1924: StoreIndexed:40(v875, v2451 T{_Smi}, v1882 T{int}) | |
1926: v298 <- BinaryInt64Op(+ [tr], v292, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
1928: ParallelMove r6 <- r6, r4 <- r5, r0 <- r7, r3 <- S-29, r5 <- S-54 goto:2138 B275 | |
1930: B274[target]:2128 ParallelMove r3 <- r4, r1 <- S-51 | |
1932: v1863 <- UnboxInt64:2162([non-speculative], v2647 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1933: ParallelMove S-54 <- r4 | |
1934: ParallelMove r5 <- C goto:2162 B278 | |
1936: B278[join]:2160 pred(B274, B390) { | |
v2495 <- phi(v2634, v850) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
1937: ParallelMove S-42 <- r5 | |
1938: CheckStackOverflow:2166(stack=0, loop=3) | |
1940: v3970 <- LoadClassId(<non-smi> v1391) | |
1942: PushArgument(v1391) | |
1943: ParallelMove r0 <- r0 | |
1944: v839 <- DispatchTableCall( cid=v3970 Iterable.length<0>, v1391) T{int} | |
1945: ParallelMove r0 <- r0 | |
1946: v1890 <- UnboxInt64([non-speculative], v839 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
1947: ParallelMove r2 <- S-50 | |
1948: Branch if EqualityCompare(v2451 T{int} != v1890 T{int}) T{bool} goto (395, 396) | |
1950: B395[target]:24 ParallelMove r0 <- S-46 | |
1952: v852 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError} | |
1953: ParallelMove r0 <- r0, r3 <- S-46 | |
1954: StoreField(v852 . modifiedObject = v1391, NoStoreBarrier) | |
1955: ParallelMove r0 <- r0 | |
1956: Throw:32(v852) | |
1958: B396[target]:34 ParallelMove r3 <- S-46, r4 <- S-42 | |
1960: Branch if RelationalOp(>=, v2495 T{int}, v1890 T{int}) T{bool} goto (277, 276) | |
1962: B277[target]:46 | |
1964: ParallelMove goto:2188 B284 | |
1966: B276[target]:52 | |
1968: v3971 <- LoadClassId(<non-smi> v1391) | |
1970: PushArgument(v1391) | |
1972: PushArgument(v2495 T{int}) | |
1973: ParallelMove r0 <- r0 | |
1974: v847 <- DispatchTableCall( cid=v3971 Iterable.elementAt<0>, v1391, v2495 T{int}) T{*?} | |
1975: ParallelMove r3 <- r0, r0 <- S-42 | |
1976: ParallelMove S-41 <- r3 | |
1976: v850 <- BinaryInt64Op(+ [tr], v2495 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
1977: ParallelMove S-55 <- r5 | |
1978: Branch if StrictCompare:12(===, v847 T{X0??}, v0) goto (388, 389) | |
1980: B388[target]:16 | |
1981: ParallelMove r0 <- r3, r2 <- C, r1 <- C | |
1982: t0 <- AssertAssignable:18(v847 T{X0??}, v2651, ' in type cast', instantiator_type_args(v0), function_type_args(v0)) [-9223372036854775808, 9223372036854775807] T{int} | |
1984: ParallelMove goto:24 B390 | |
1986: B389[target]:20 | |
1988: ParallelMove goto:26 B390 | |
1990: B390[join]:22 pred(B388, B389) ParallelMove r0 <- S-54 | |
1992: PushArgument(v0) | |
1994: PushArgument(v289 T{String}) | |
1996: v833 <- StaticCall:10( Characters.<0> v0, v289 T{String}, result_type = T{StringCharacters}) T{StringCharacters} | |
1997: ParallelMove r0 <- r0 | |
1998: PushArgument(v122) | |
2000: PushArgument(v847 T{X0?}) | |
2001: ParallelMove r1 <- S-54 | |
2002: PushArgument(v1863 T{int}) | |
2004: PushArgument(v833) | |
2006: StaticCall:12( setCharacter<0> v122, v847 T{X0?}, v1863 T{int}, v833, using unchecked entrypoint, result_type = T{??}) | |
2008: ParallelMove r5 <- S-55, r2 <- S-46, r4 <- S-54, r3 <- S-50, r1 <- S-51 goto:2164 B278 | |
2010: B283[target]:2182 | |
2012: ParallelMove goto:2184 B279 | |
2014: B282[target]:2178 | |
2016: ParallelMove goto:2180 B279 | |
2018: B281[target]:2174 | |
2020: ParallelMove goto:2176 B279 | |
2022: B280[target]:2170 | |
2024: ParallelMove goto:2172 B279 | |
2026: B279[join]:2168 pred(B280, B281, B282, B283) | |
2028: ParallelMove goto:2190 B284 | |
2030: B284[join]:2186 pred(B277, B279) ParallelMove r0 <- S-49 | |
2032: Branch if StrictCompare:2194(===, v214, v25) goto (285, 310) | |
2034: B285[target]:2202 ParallelMove r0 <- S-44, r1 <- S-53 | |
2036: Branch if StrictCompare:2198(!==, v207, v195) goto (298, 311) | |
2038: B298[target]:2298 ParallelMove r0 <- S-52 | |
2040: Branch if StrictCompare:2204(===, v209, v0) goto (749, 287) | |
2042: B749[target]:2208 | |
2044: ParallelMove goto:2252 B292 | |
2046: B287[target]:2210 | |
2048: v245 <- LoadField(v209 T{CellStyle} . borderBottom {final}) T{bool?} | |
2050: Branch if StrictCompare(===, v245, v25) goto (300, 751) | |
2052: B300[target]:2302 | |
2054: ParallelMove r3 <- S-12, r4 <- S-35, r2 <- S-27 goto:2304 B299 | |
2056: B751[target]:2252 | |
2058: ParallelMove goto:2252 B292 | |
2060: B292[join]:2252 pred(B749, B751) ParallelMove r0 <- S-43 | |
2062: Branch if StrictCompare:2228(===, v197, v0) goto (753, 290) | |
2064: B753[target]:2232 | |
2066: ParallelMove goto:2296 B297 | |
2068: B290[target]:2234 | |
2070: v248 <- LoadField(v197 T{CellStyle} . borderTop {final}) T{bool?} | |
2072: Branch if StrictCompare(===, v248, v25) goto (301, 755) | |
2074: B301[target]:2306 | |
2076: ParallelMove r3 <- S-12, r4 <- S-35, r2 <- S-27 goto:2308 B299 | |
2078: B755[target]:2296 | |
2080: ParallelMove goto:2296 B297 | |
2082: B297[join]:2296 pred(B753, B755) ParallelMove r2 <- S-27 | |
2084: Branch if EqualityCompare(v1842 T{int} == v2634) T{bool} goto (295, 293) | |
2086: B295[target]:2288 | |
2088: ParallelMove r3 <- S-12 goto:2290 B294 | |
2090: B293[target]:2272 ParallelMove r3 <- S-12 | |
2092: Branch if EqualityCompare(v1842 T{int} == v32 T{int}) T{bool} goto (296, 312) | |
2094: B296[target]:2292 | |
2096: ParallelMove goto:2294 B294 | |
2098: B294[join]:2286 pred(B295, B296) ParallelMove r4 <- S-35 | |
2100: Branch if StrictCompare:2282(===, v255, v25) goto (302, 313) | |
2102: B302[target]:2310 | |
2104: ParallelMove goto:2312 B299 | |
2106: B299[join]:2300 pred(B300, B301, B302) ParallelMove r6 <- S-24, r0 <- S-30, r7 <- S-48, r5 <- S-51 | |
2108: v260 <- BinaryInt64Op(+ [tr], v1858 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2109: ParallelMove r0 <- S-25, r1 <- r8 | |
2110: GenericCheckBound:2316(v88 T{_Smi}, v260) [-9223372036854775808, 9223372036854775807] T{int} | |
2112: v2652 <- LoadIndexed(v89, v260 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2113: ParallelMove S-41 <- r0 | |
2114: v1581 <- LoadStaticField:4(_emptyList@0150898, CallsInitializer) T{_List} | |
2115: ParallelMove r1 <- C, r0 <- r0 | |
2116: ParallelMove S-43 <- r0 | |
2116: v1335 <- AllocateObject:10(cls=_GrowableList, v26) T{_GrowableList} | |
2117: ParallelMove r2 <- r0, r0 <- S-43 | |
2118: ParallelMove S-44 <- r2 | |
2118: StoreField(v1335 . GrowableObjectArray.data = v1581, NoStoreBarrier) | |
2120: StoreField(v1335 . GrowableObjectArray.length = v8, NoStoreBarrier) | |
2121: ParallelMove r1 <- S-51 | |
2122: v1864 <- UnboxInt64([non-speculative], v2647 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2123: ParallelMove r1 <- S-48 | |
2124: v264 <- BinaryInt64Op(+ [tr], v1864 T{int}, v1872 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2125: ParallelMove r1 <- S-41 | |
2126: v1893 <- UnboxInt64:2342([non-speculative], v2652 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2127: ParallelMove S-48 <- r3 | |
2128: ParallelMove r5 <- r4, r4 <- C, r0 <- r0 goto:2342 B305 | |
2130: B305[join]:2340 pred(B299, B373) { | |
v265 <- phi(v264, v271) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
v2540 <- phi(v2634, v793 T{int}) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
v2539 <- phi(v1581, v796) alive T{_List} | |
} | |
2131: ParallelMove S-30 <- r5, S-42 <- r4 | |
2132: CheckStackOverflow:2346(stack=0, loop=3) | |
2134: Branch if RelationalOp(<, v265, v1893 T{int}) T{bool} goto (303, 304) | |
2136: B303[target]:2332 | |
2138: v1321 <- LoadField(v2539 . Array.length {final}) [0, 576460752303423487] T{_Smi} | |
2140: v3945 <- BoxInt64(v2540 T{_Smi}) | |
2141: ParallelMove r0 <- r0 | |
2142: Branch if StrictCompare(===, v3945 T{_Smi}, v1321) T{bool} goto (371, 372) | |
2144: B371[target]:24 | |
2146: PushArgument(v1335) | |
2148: StaticCall:26( _growToNextCapacity@0150898<0> v1335, using unchecked entrypoint, result_type = T{??}) | |
2150: ParallelMove goto:32 B373 | |
2152: B372[target]:28 | |
2154: ParallelMove goto:34 B373 | |
2156: B373[join]:30 pred(B371, B372) ParallelMove r4 <- S-30, r2 <- S-44, r3 <- S-42 | |
2158: v793 <- BinaryInt64Op(+ [tr], v2540 T{_Smi}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2160: v1897 <- BoxInt64(v793) [-9223372036854775808, 9223372036854775807] T{int} | |
2161: ParallelMove r0 <- r0 | |
2162: StoreField(v1335 . GrowableObjectArray.length = v1897 T{int}, NoStoreBarrier) | |
2163: ParallelMove r0 <- r6, r1 <- r3 | |
2164: GenericCheckBound:40(v793 T{_Smi}, v2540 T{_Smi}) [-4611686018427387904, 4611686018427387903] T{_Smi} | |
2166: v796 <- LoadField(v1335 . GrowableObjectArray.data) T{_List} | |
2168: v1894 <- BoxInt64(v265 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2169: ParallelMove r1 <- r7, r0 <- r0 | |
2170: StoreIndexed:40(v796, v2540 T{_Smi}, v1894 T{int}) | |
2172: v271 <- BinaryInt64Op(+ [tr], v265, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2174: ParallelMove r5 <- r5, r4 <- r6, r0 <- r7, r3 <- S-48 goto:2344 B305 | |
2176: B304[target]:2334 ParallelMove r3 <- r4 | |
2178: ParallelMove r1 <- C goto:2368 B308 | |
2180: B308[join]:2366 pred(B304, B357) { | |
v2584 <- phi(v2634, v771) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
} | |
2181: ParallelMove S-30 <- r1 | |
2182: CheckStackOverflow:2372(stack=0, loop=3) | |
2184: v3972 <- LoadClassId(<non-smi> v1335) | |
2186: PushArgument(v1335) | |
2187: ParallelMove r0 <- r0 | |
2188: v760 <- DispatchTableCall( cid=v3972 Iterable.length<0>, v1335) T{int} | |
2189: ParallelMove r0 <- r0 | |
2190: v1902 <- UnboxInt64([non-speculative], v760 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2191: ParallelMove r2 <- S-42 | |
2192: Branch if EqualityCompare(v2540 T{int} != v1902 T{int}) T{bool} goto (362, 363) | |
2194: B362[target]:24 ParallelMove r0 <- S-44 | |
2196: v773 <- AllocateObject:26(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError} | |
2197: ParallelMove r0 <- r0, r3 <- S-44 | |
2198: StoreField(v773 . modifiedObject = v1335, NoStoreBarrier) | |
2199: ParallelMove r0 <- r0 | |
2200: Throw:32(v773) | |
2202: B363[target]:34 ParallelMove r3 <- S-44, r4 <- S-30 | |
2204: Branch if RelationalOp(>=, v2584 T{int}, v1902 T{int}) T{bool} goto (307, 306) | |
2206: B307[target]:46 | |
2208: ParallelMove goto:2394 B314 | |
2210: B306[target]:52 | |
2212: v3973 <- LoadClassId(<non-smi> v1335) | |
2214: PushArgument(v1335) | |
2216: PushArgument(v2584 T{int}) | |
2217: ParallelMove r0 <- r0 | |
2218: v768 <- DispatchTableCall( cid=v3973 Iterable.elementAt<0>, v1335, v2584 T{int}) T{*?} | |
2219: ParallelMove r3 <- r0, r0 <- S-30 | |
2220: ParallelMove S-41 <- r3 | |
2220: v771 <- BinaryInt64Op(+ [tr], v2584 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2221: ParallelMove S-48 <- r4 | |
2222: Branch if StrictCompare:12(===, v768 T{X0??}, v0) goto (355, 356) | |
2224: B355[target]:16 | |
2225: ParallelMove r0 <- r3, r2 <- C, r1 <- C | |
2226: t0 <- AssertAssignable:18(v768 T{X0??}, v2651, ' in type cast', instantiator_type_args(v0), function_type_args(v0)) [-9223372036854775808, 9223372036854775807] T{int} | |
2228: ParallelMove goto:24 B357 | |
2230: B356[target]:20 | |
2232: ParallelMove goto:26 B357 | |
2234: B357[join]:22 pred(B355, B356) ParallelMove r0 <- S-41 | |
2236: PushArgument(v0) | |
2238: PushArgument(v262 T{String}) | |
2240: v754 <- StaticCall:10( Characters.<0> v0, v262 T{String}, result_type = T{StringCharacters}) T{StringCharacters} | |
2241: ParallelMove r1 <- r0, r0 <- S-41 | |
2242: v1903 <- UnboxInt64([non-speculative], v768 T{X0?}) [-9223372036854775808, 9223372036854775807] T{int} | |
2244: PushArgument(v122) | |
2246: PushArgument(v2646 T{int}) | |
2248: PushArgument(v1903) | |
2250: PushArgument(v754) | |
2252: StaticCall:12( setCharacter<0> v122, v2646 T{int}, v1903, v754, using unchecked entrypoint, result_type = T{??}) | |
2254: ParallelMove r1 <- S-48, r2 <- S-44, r3 <- S-42 goto:2370 B308 | |
2256: B313[target]:2388 | |
2258: ParallelMove goto:2390 B309 | |
2260: B312[target]:2384 | |
2262: ParallelMove goto:2386 B309 | |
2264: B311[target]:2380 | |
2266: ParallelMove goto:2382 B309 | |
2268: B310[target]:2376 | |
2270: ParallelMove goto:2378 B309 | |
2272: B309[join]:2374 pred(B310, B311, B312, B313) | |
2274: ParallelMove goto:2396 B314 | |
2276: B314[join]:2392 pred(B307, B309) | |
2278: ParallelMove r3 <- S-40, r2 <- S-27, r5 <- S-29, r4 <- S-39, r1 <- S-37 goto:2402 B315 | |
2280: B126[target]:1174 | |
2282: ParallelMove r1 <- S-36, r2 <- S-35, r3 <- S-34, r4 <- S-33, r5 <- S-31 goto:2410 B316 | |
2284: B124[target]:1148 ParallelMove r10 <- S-1 | |
2286: v708 <- LoadField:4(v7 . positionedCells, CallsInitializer) T{_GrowableList} | |
2287: ParallelMove r1 <- C, r2 <- S-9, S-24 <- r0 | |
2288: v157 <- AllocateClosure:2416(v156, v16) T{_Closure} | |
2289: ParallelMove r3 <- r0, r2 <- S-24 | |
2290: ParallelMove S-31 <- r3 | |
2290: v1280 <- LoadField(v708 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
2291: ParallelMove S-28 <- r4 | |
2292: v3947 <- UnboxInt64([non-speculative], v1280) | |
2294: ParallelMove r5 <- C, r0 <- r0 goto:56 B351 | |
2296: B351[join]:54 pred(B124, B350) { | |
v717 <- phi(v2634, v726) alive [-9223372036854775808, 9223372036854775807] int64 T{int} | |
v2633 <- phi(v3947 T{_Smi}, v3949 T{_Smi}) alive [0, 576460752303423487] int64 T{_Smi} | |
} | |
2297: ParallelMove S-25 <- r5 | |
2298: CheckStackOverflow:60(stack=0, loop=1) | |
2300: Branch if RelationalOp(<, v717, v2633) T{bool} goto (347, 348) | |
2302: B347[target]:22 | |
2303: ParallelMove r0 <- r0, r1 <- r5 | |
2304: GenericCheckBound:28(v2633, v717) [-9223372036854775808, 9223372036854775807] T{int} | |
2306: v730 <- LoadField(v708 . GrowableObjectArray.data) T{_List} | |
2308: v2653 <- LoadIndexed(v730, v717 T{int}) T{*?} | |
2310: PushArgument(v157) | |
2312: PushArgument(v2653 T{*?}) | |
2313: ParallelMove r0 <- r3 | |
2314: v722 <- ClosureCall:32( closure=v157<0>, v157, v2653 T{*?}) T{*?} | |
2315: ParallelMove r0 <- S-24 | |
2316: v1270 <- LoadField(v708 . GrowableObjectArray.length) [0, 576460752303423487] T{_Smi} | |
2317: ParallelMove r2 <- S-28 | |
2318: Branch if StrictCompare(!==, v1270, v1280) T{bool} goto (349, 350) | |
2320: B349[target]:44 | |
2322: v727 <- AllocateObject:46(cls=ConcurrentModificationError, <not-aliased>) T{ConcurrentModificationError} | |
2323: ParallelMove r1 <- r0, r0 <- S-24 | |
2324: StoreField(v727 . modifiedObject = v708, NoStoreBarrier) | |
2325: ParallelMove r0 <- r1 | |
2326: Throw:50(v727) | |
2328: B350[target]:52 ParallelMove r3 <- S-25 | |
2330: v726 <- BinaryInt64Op(+ [tr], v717 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2332: v3949 <- UnboxInt64([non-speculative], v1270) | |
2334: ParallelMove r5 <- r5, r0 <- r3, r3 <- S-31, r2 <- r0, r4 <- r2 goto:58 B351 | |
2336: B348[target]:24 | |
2338: PushArgument(v122) | |
2340: v159 <- StaticCall:2420( toString<0> v122, using unchecked entrypoint, result_type = T{*}) T{String} | |
2341: ParallelMove r0 <- r0 | |
2342: Return:2422(v159) | |
2344: B12[target]:52 ParallelMove r10 <- S-1, r8 <- S-2, r1 <- S-8, r5 <- S-11, r6 <- S-15, r7 <- S-18 | |
2346: v3974 <- LoadClassId(<non-smi> v1200) | |
2348: PushArgument(v1200) | |
2350: PushArgument(v2104 T{int}) | |
2351: ParallelMove r0 <- r0 | |
2352: v1188 <- DispatchTableCall( cid=v3974 Iterable.elementAt<0>, v1200, v2104 T{int}) T{*?} | |
2353: ParallelMove r3 <- r0, r0 <- S-16 | |
2354: ParallelMove S-24 <- r3 | |
2354: v1191 <- BinaryInt64Op(+ [tr], v2104 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2355: ParallelMove S-25 <- r14 | |
2356: Branch if StrictCompare:12(===, v1188 T{X0??}, v0) goto (535, 536) | |
2358: B535[target]:16 | |
2359: ParallelMove r0 <- r3, r2 <- S-21, r1 <- C | |
2360: t0 <- AssertAssignable:18(v1188 T{X0??}, v743, ' in type cast', instantiator_type_args(v1205), function_type_args(v0)) T{X0?} | |
2362: ParallelMove goto:24 B537 | |
2364: B536[target]:20 | |
2366: ParallelMove goto:26 B537 | |
2368: B537[join]:22 pred(B535, B536) ParallelMove r1 <- S-7, r0 <- S-24 | |
2370: v491 <- LoadField(v1188 T{PositionedCell} . rowIndex {final}) [-9223372036854775808, 9223372036854775807] T{int} | |
2371: ParallelMove S-26 <- r2 | |
2372: v492 <- LoadField(v1188 T{PositionedCell} . columnIndex {final}) [-9223372036854775808, 9223372036854775807] T{int} | |
2373: ParallelMove S-16 <- r3 | |
2374: v493 <- LoadField(v1188 T{PositionedCell} . cell {final}) T{Cell} | |
2376: v494 <- LoadField(v1188 T{PositionedCell} . canonicalStyle {final}) T{CellStyle} | |
2377: ParallelMove S-28 <- r5 | |
2378: PushArgument(v21 T{Map<Cell, TextLayout>?}) | |
2380: PushArgument(v493) | |
2382: v1172 <- StaticCall:10( _getValueOrData@3220832<0> v21 T{Map<Cell, TextLayout>?}, v493, using unchecked entrypoint, result_type = T{*?}) T{Object??} | |
2383: ParallelMove r0 <- r0, r2 <- S-7 | |
2384: v1472 <- LoadField(v21 T{Map<Cell, TextLayout>?} . LinkedHashBase.data) T{_List} | |
2386: Branch if StrictCompare:14(===, v1472, v1172) goto (540, 541) | |
2388: B540[target]:18 | |
2390: ParallelMove r5 <- C goto:24 B14 | |
2392: B541[target]:20 | |
2394: ParallelMove r5 <- r0 goto:26 B14 | |
2396: B14[join]:22 pred(B540, B541) { | |
v1174 <- phi(v0, v1172) alive T{Object??} | |
} ParallelMove r4 <- S-11, r3 <- S-16 | |
2397: ParallelMove S-31 <- r5 | |
2398: CheckNull:142(v1174 T{SimpleLayout?}, CastError) T{SimpleLayout} | |
2399: ParallelMove r0 <- S-19, r1 <- r3 | |
2400: GenericCheckBound:156(v1907 T{_Smi}, v492) [-9223372036854775808, 9223372036854775807] T{int} | |
2402: v2654 <- LoadIndexed(v28, v492 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2403: ParallelMove S-24 <- r0 | |
2404: PushArgument(v1174 T{SimpleLayout}) | |
2406: v559 <- StaticCall:158( measureWidth<0> v1174 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2407: ParallelMove r2 <- r0, r0 <- S-24 | |
2408: v1909 <- UnboxInt64([non-speculative], v2654 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2410: Branch if RelationalOp(>, v559, v1909 T{int}) T{bool} goto (15, 16) | |
2412: B15[target]:168 ParallelMove r3 <- S-16 | |
2414: v1910 <- BoxInt64(v559) [-9223372036854775808, 9223372036854775807] T{int} | |
2415: ParallelMove r1 <- S-11, r0 <- r0 | |
2416: StoreIndexed:170(v28, v492 T{int}, v1910 T{int}) | |
2418: ParallelMove goto:176 B20 | |
2420: B16[target]:172 ParallelMove r3 <- S-16 | |
2422: ParallelMove goto:178 B20 | |
2424: B20[join]:174 pred(B15, B16) ParallelMove r4 <- S-15, r2 <- S-26 | |
2425: ParallelMove r0 <- S-12, r1 <- r2 | |
2426: GenericCheckBound:200(v32 T{_Smi}, v491) [-9223372036854775808, 9223372036854775807] T{int} | |
2428: v2655 <- LoadIndexed(v33, v491 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2429: ParallelMove S-24 <- r0 | |
2430: PushArgument(v1174 T{SimpleLayout}) | |
2432: v554 <- StaticCall:202( measureHeight<0> v1174 T{SimpleLayout}, using unchecked entrypoint, result_type = T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2433: ParallelMove r2 <- r0, r0 <- S-24 | |
2434: v1915 <- UnboxInt64([non-speculative], v2655 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2436: Branch if RelationalOp(>, v554, v1915 T{int}) T{bool} goto (21, 22) | |
2438: B21[target]:212 ParallelMove r3 <- S-26 | |
2440: v1916 <- BoxInt64(v554) [-9223372036854775808, 9223372036854775807] T{int} | |
2441: ParallelMove r1 <- S-15, r0 <- r0 | |
2442: StoreIndexed:214(v33, v491 T{int}, v1916 T{int}) | |
2444: ParallelMove goto:220 B25 | |
2446: B22[target]:216 ParallelMove r3 <- S-26 | |
2448: ParallelMove goto:222 B25 | |
2450: B25[join]:218 pred(B21, B22) ParallelMove r2 <- S-16 | |
2452: Branch if EqualityCompare(v492 T{int} == v2634) T{bool} goto (26, 28) | |
2454: B26[target]:252 ParallelMove r4 <- S-17 | |
2456: Branch if StrictCompare:248(===, v526, v25) goto (32, 29) | |
2458: B32[target]:298 | |
2460: ParallelMove r5 <- S-28 goto:300 B34 | |
2462: B29[target]:270 | |
2464: ParallelMove goto:272 B27 | |
2466: B28[target]:266 ParallelMove r4 <- S-17 | |
2468: ParallelMove goto:268 B27 | |
2470: B27[join]:264 pred(B28, B29) ParallelMove r5 <- S-28 | |
2472: v502 <- LoadField(v494 . borderLeft {final}) T{bool?} | |
2474: Branch if StrictCompare(===, v502, v25) T{bool} goto (33, 37) | |
2476: B33[target]:302 | |
2478: ParallelMove goto:304 B34 | |
2480: B34[join]:296 pred(B32, B33) ParallelMove r6 <- S-13 | |
2481: ParallelMove r0 <- S-10, r1 <- r2 | |
2482: GenericCheckBound:316(v30 T{_Smi}, v492 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2484: StoreIndexed:316(v31, v492 T{int}, v5, NoStoreBarrier) | |
2486: ParallelMove goto:330 B40 | |
2488: B37[target]:320 ParallelMove r6 <- S-13 | |
2490: ParallelMove goto:332 B40 | |
2492: B40[join]:328 pred(B34, B37) ParallelMove r7 <- S-1 | |
2494: v504 <- BinaryInt64Op(+ [tr], v492 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2496: v505 <- LoadField(v7 . columnCount) T{int??} | |
2498: v1921 <- BoxInt64(v504) [-9223372036854775808, 9223372036854775807] T{int} | |
2499: ParallelMove r0 <- r0 | |
2500: Branch if EqualityCompare(v1921 T{int} == v505) T{bool} goto (41, 43) | |
2502: B41[target]:358 | |
2504: Branch if StrictCompare:354(===, v526, v25) goto (47, 44) | |
2506: B47[target]:410 | |
2508: ParallelMove goto:412 B49 | |
2510: B44[target]:376 | |
2512: ParallelMove goto:378 B42 | |
2514: B43[target]:372 | |
2516: ParallelMove goto:374 B42 | |
2518: B42[join]:370 pred(B43, B44) | |
2520: v507 <- LoadField(v494 . borderRight {final}) T{bool?} | |
2522: Branch if StrictCompare(===, v507, v25) T{bool} goto (48, 52) | |
2524: B48[target]:414 | |
2526: ParallelMove goto:416 B49 | |
2528: B49[join]:408 pred(B47, B48) | |
2530: CheckNull:384(v505 T{int??}, CastError) [-9223372036854775808, 9223372036854775807] T{int?} | |
2531: ParallelMove r0 <- S-10, r1 <- r8 | |
2532: GenericCheckBound:430(v30 T{_Smi}, v504 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2534: StoreIndexed:430(v31, v504 T{int}, v5, NoStoreBarrier) | |
2536: ParallelMove goto:444 B55 | |
2538: B52[target]:434 | |
2540: ParallelMove goto:446 B55 | |
2542: B55[join]:442 pred(B49, B52) | |
2544: Branch if EqualityCompare(v491 T{int} == v2634) T{bool} goto (56, 58) | |
2546: B56[target]:468 | |
2548: Branch if StrictCompare:464(===, v526, v25) goto (62, 59) | |
2550: B62[target]:514 | |
2552: ParallelMove goto:516 B64 | |
2554: B59[target]:486 | |
2556: ParallelMove goto:488 B57 | |
2558: B58[target]:482 | |
2560: ParallelMove goto:484 B57 | |
2562: B57[join]:480 pred(B58, B59) | |
2564: v510 <- LoadField(v494 . borderTop {final}) T{bool?} | |
2566: Branch if StrictCompare(===, v510, v25) T{bool} goto (63, 67) | |
2568: B63[target]:518 | |
2570: ParallelMove goto:520 B64 | |
2572: B64[join]:512 pred(B62, B63) ParallelMove r2 <- S-23 | |
2573: ParallelMove r0 <- S-14, r1 <- r3 | |
2574: GenericCheckBound:532(v35 T{_Smi}, v491 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2576: StoreIndexed:532(v36, v491 T{int}, v5, NoStoreBarrier) | |
2578: ParallelMove goto:546 B70 | |
2580: B67[target]:536 ParallelMove r2 <- S-23 | |
2582: ParallelMove goto:548 B70 | |
2584: B70[join]:544 pred(B64, B67) ParallelMove r8 <- S-12 | |
2586: v512 <- BinaryInt64Op(+ [tr], v491 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2588: Branch if EqualityCompare(v512 == v32 T{int}) T{bool} goto (71, 73) | |
2590: B71[target]:574 | |
2592: Branch if StrictCompare:570(===, v526, v25) goto (77, 74) | |
2594: B77[target]:624 | |
2596: ParallelMove goto:626 B79 | |
2598: B74[target]:592 | |
2600: ParallelMove goto:594 B72 | |
2602: B73[target]:588 | |
2604: ParallelMove goto:590 B72 | |
2606: B72[join]:586 pred(B73, B74) | |
2608: v515 <- LoadField(v494 . borderBottom {final}) T{bool?} | |
2610: Branch if StrictCompare(===, v515, v25) T{bool} goto (78, 82) | |
2612: B78[target]:628 | |
2614: ParallelMove goto:630 B79 | |
2616: B79[join]:622 pred(B77, B78) | |
2617: ParallelMove r0 <- S-14, r1 <- r9 | |
2618: GenericCheckBound:644(v35 T{_Smi}, v512 T{int}) [-9223372036854775808, 9223372036854775807] T{int} | |
2620: StoreIndexed:644(v36, v512 T{int}, v5, NoStoreBarrier) | |
2622: ParallelMove goto:658 B85 | |
2624: B82[target]:648 | |
2626: ParallelMove goto:660 B85 | |
2628: B85[join]:656 pred(B79, B82) | |
2630: ParallelMove r14 <- S-25, r3 <- r7, r2 <- S-9, r7 <- S-8, r11 <- r8, r1 <- r2, r9 <- S-18, r10 <- r4, r4 <- S-22, r5 <- S-21, r6 <- S-20, r8 <- S-19 goto:666 B86 | |
2632: B9[target]:52 ParallelMove r7 <- S-1 | |
2634: v3975 <- LoadClassId(<non-smi> v1243) | |
2636: PushArgument(v1243) | |
2638: PushArgument(v2082 T{int}) | |
2639: ParallelMove r0 <- r0 | |
2640: v1231 <- DispatchTableCall( cid=v3975 Iterable.elementAt<0>, v1243, v2082 T{int}) T{*?} | |
2641: ParallelMove r3 <- r0, r0 <- S-3 | |
2642: ParallelMove S-8 <- r3 | |
2642: v1234 <- BinaryInt64Op(+ [tr], v2082 T{int}, v2635) [-9223372036854775808, 9223372036854775807] T{int} | |
2643: ParallelMove S-10 <- r6 | |
2644: Branch if StrictCompare:12(===, v1231 T{X0??}, v0) goto (555, 556) | |
2646: B555[target]:16 | |
2647: ParallelMove r0 <- r3, r2 <- S-5, r1 <- C | |
2648: t0 <- AssertAssignable:18(v1231 T{X0??}, v743, ' in type cast', instantiator_type_args(v1248), function_type_args(v0)) T{X0?} | |
2650: ParallelMove goto:24 B557 | |
2652: B556[target]:20 | |
2654: ParallelMove goto:26 B557 | |
2656: B557[join]:22 pred(B555, B556) ParallelMove r0 <- S-8 | |
2658: v563 <- LoadField(v1231 T{PositionedCell} . cell {final}) T{Cell} | |
2659: ParallelMove S-9 <- r1 | |
2660: PushArgument(v1231 T{PositionedCell}) | |
2662: v1259 <- StaticCall:10( _simpleLayoutFactory@18294472<0> v1231 T{PositionedCell}) T{SimpleLayout} | |
2663: ParallelMove r0 <- r0 | |
2664: PushArgument(v21) | |
2666: PushArgument(v563) | |
2668: PushArgument(v1259) | |
2670: StaticCall:80( []=<0> v21, v563, v1259, using unchecked entrypoint, result_type = T{??}) | |
2672: ParallelMove r6 <- S-10, r1 <- S-1, r2 <- S-7, r3 <- S-6, r4 <- S-5, r5 <- S-4 goto:86 B11 | |
*** END CFG | |
Error: AOT compilation failed | |
Generating AOT snapshot failed! |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment