| --- C. |
| B0 = EntryBlock() |
| v6 = Constant(null) |
| v1 = Parameter(this) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| DirectCall Object.(v1) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v6) # RA: (R0) |
| |
| --- C.typeParameters |
| B0 = EntryBlock() |
| v12 = Constant(null) |
| v30 = Constant(<dynamic>) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(this) # RA: param[1] <- () |
| v3 = Parameter(x) # RA: param[2] <- () |
| ParallelMove output(param[2] -> vloc:R0, param[1] -> vloc:param[1], param[0] -> vloc:param[0]) |
| v8 = AllocateContext() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[1] -> R3) |
| ParallelMove spill(R0 -> stack[0]) |
| StoreInstanceField(#context-field:, v8, v2) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3], objects: [R0, R3, stack[0]]} |
| v37 = LoadInstanceField(C.#typeArguments, v2) # RA: R1 <- (R3) |
| ParallelMove output(param[2] -> R0, R1 -> stack[1]) |
| ParallelMove input(vloc:R0 -> R0, vloc:R1 -> R2, NullConstant(null) -> R1) |
| v13 = TypeTest(v3, v37, v12, List<C.T%>) # RA: R7 <- (R0, R2, R1) temps: [R3, R4, R5, R6, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R0, R1, R2], objects: [R0, R1, R2, stack[0], stack[1]]} |
| ParallelMove output(R7 -> vloc:R7) |
| DirectCall print(v13) # RA: R0 <- (R7) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0], stack[1]]} |
| ParallelMove output(param[0] -> R0, param[2] -> R1) |
| ParallelMove input(vloc:R1 -> R0, NullConstant(null) -> R2, vloc:R0 -> R1) |
| v16 = TypeTest(v3, v12, v1, List<C.typeParameters.U%>) # RA: R7 <- (R0, R2, R1) temps: [R3, R4, R5, R6, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R0, R1, R2], objects: [R0, R1, R2, stack[0], stack[1]]} |
| ParallelMove output(R7 -> vloc:R7) |
| DirectCall print(v16) # RA: R0 <- (R7) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0], stack[1]]} |
| ParallelMove output(param[0] -> R0, param[2] -> R1, stack[1] -> R2) |
| ParallelMove input(vloc:R1 -> R0, vloc:R2 -> R2, vloc:R0 -> R1) |
| v19 = TypeCast(v3, v37, v1, Map<C.T%, C.typeParameters.U%>) # RA: R0 <- (R0, R2, R1) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R0, R1, R2], objects: [R0, R1, R2, stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v19) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| v21 = AllocateClosure() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0, param[0] -> R3) |
| StoreInstanceField(#closure-field[0], v21, v1) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3], objects: [R0, R3, stack[0]]} |
| ParallelMove output(stack[0] -> R4) |
| StoreInstanceField(#closure-field[1], v21, v8) # RA: (R0, R4) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3], objects: [R0, R3]} |
| DirectCall closure FunctionDeclaration(void local1() { |
| print(C.T%); |
| print(C.typeParameters.U%); |
| }) at C.typeParameters(v21) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| v27 = AllocateClosure() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[0] -> R3) |
| StoreInstanceField(#closure-field[1], v27, v1) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| DirectCall closure FunctionDeclaration(void local2<V extends Object?>() { |
| print(Map<C.typeParameters.U%, V%>); |
| }) at C.typeParameters(v30, v27) # RA: R0 <- (-, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v12) # RA: (R0) |
| |
| --- closure FunctionDeclaration(void local1() { |
| print(C.T%); |
| print(C.typeParameters.U%); |
| }) at C.typeParameters |
| B0 = EntryBlock() |
| v11 = Constant(null) |
| v1 = Parameter(#closure) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| v3 = LoadInstanceField(#closure-field[0], v1) # RA: R1 <- (R0) |
| ParallelMove output(R1 -> stack[0]) |
| v6 = LoadInstanceField(#closure-field[1], v1) # RA: R2 <- (R0) |
| v7 = LoadInstanceField(#context-field:, v6) # RA: R2 <- (R2) |
| LoadInstanceField(#closure-field[1], v1) # RA: R0 <- (R0) |
| v17 = LoadInstanceField(C.#typeArguments, v7) # RA: R0 <- (R2) |
| ParallelMove input(NullConstant(null) -> vloc:R2) |
| v12 = TypeLiteral(C.T%, v17, v11) # RA: R0 <- (R0, R2) |
| DirectCall print(v12) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(stack[0] -> R2) |
| ParallelMove input(NullConstant(null) -> vloc:R1) |
| v14 = TypeLiteral(C.typeParameters.U%, v11, v3) # RA: R0 <- (R1, R2) |
| DirectCall print(v14) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v11) # RA: (R0) |
| |
| --- closure FunctionDeclaration(void local2<V extends Object?>() { |
| print(Map<C.typeParameters.U%, V%>); |
| }) at C.typeParameters |
| B0 = EntryBlock() |
| v11 = Constant(null) |
| v16 = Constant(1) |
| v17 = Constant(2) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(#closure) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v5 = LoadInstanceField(#closure-field[1], v2) # RA: R2 <- (R1) |
| v15 = DirectCall _prependTypeArguments(v1, v5, v16, v17) # RA: R0 <- (R0, R2, -, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[1] -> R1) |
| v8 = LoadInstanceField(#closure-field[1], v2) # RA: R1 <- (R1) |
| LoadInstanceField(#context-field:, v8) # RA: R1 <- (R1) |
| ParallelMove input(NullConstant(null) -> R1, vloc:R0 -> R2) |
| v12 = TypeLiteral(Map<C.typeParameters.U%, V%>, v11, v15) # RA: R0 <- (R1, R2) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1, R2], objects: [R1, R2]} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v12) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v11) # RA: (R0) |
| |
| --- D. |
| B0 = EntryBlock() |
| v6 = Constant(null) |
| v1 = Parameter(this) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| DirectCall Object.(v1) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v6) # RA: (R0) |
| |
| --- E. |
| B0 = EntryBlock() |
| v6 = Constant(null) |
| v1 = Parameter(this) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| DirectCall D.(v1) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v6) # RA: (R0) |
| |
| --- F. |
| B0 = EntryBlock() |
| v4 = Constant(null) |
| v1 = Parameter(this) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| DirectCall E.(v1) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v4) # RA: (R0) |
| |
| --- test1 |
| B0 = EntryBlock() |
| Constant(0) |
| v1 = Parameter(a) # RA: param[0] <- () |
| v2 = Parameter(b) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v9 = UnboxInt(v1) # RA: R0 <- (R0) |
| v10 = UnboxInt(v2) # RA: R1 <- (R1) |
| v7 = Comparison int & == 0(v9, v10) # RA: R0 <- (R0, R1) |
| ParallelMove input(vloc:R0 -> R0) |
| Return(v7) # RA: (R0) |
| |
| --- test2 |
| B0 = EntryBlock() dominates:(B9, B11, B8) |
| Constant(0) |
| v13 = Constant("yes") |
| v25 = Constant("no") |
| v28 = Constant(null) |
| v1 = Parameter(a) # RA: param[0] <- () |
| v2 = Parameter(b) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v30 = UnboxInt(v1) # RA: R0 <- (R0) |
| v31 = UnboxInt(v2) # RA: R1 <- (R1) |
| v7 = Comparison int & == 0(v30, v31) # RA: R0 <- (R0, R1) |
| ParallelMove output(R0 -> stack[0]) |
| Branch(v7, true: B8, false: B9) # RA: (R0) |
| B8 = TargetBlock() idom:B0 |
| DirectCall print(v13) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| Goto(B11) |
| B9 = TargetBlock() idom:B0 |
| Goto(B11) |
| B11 = JoinBlock(B9, B8) idom:B0 dominates:(B21, B23, B20) |
| ParallelMove output(stack[0] -> R0) |
| Branch(v7, true: B20, false: B21) # RA: (R0) |
| B20 = TargetBlock() idom:B11 |
| Goto(B23) |
| B21 = TargetBlock() idom:B11 |
| DirectCall print(v25) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| Goto(B23) |
| B23 = JoinBlock(B21, B20) idom:B11 |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v28) # RA: (R0) |
| |
| --- test3 |
| B0 = EntryBlock() dominates:(B11, B13, B10) |
| Constant(0) |
| v15 = Constant("yes") |
| v1 = Parameter(a) # RA: param[0] <- () |
| v2 = Parameter(b) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v20 = UnboxInt(v1) # RA: R0 <- (R0) |
| v21 = UnboxInt(v2) # RA: R1 <- (R1) |
| v7 = Comparison int & == 0(v20, v21) # RA: R0 <- (R0, R1) |
| ParallelMove output(R0 -> stack[0]) |
| Branch(v7, true: B10, false: B11) # RA: (R0) |
| B10 = TargetBlock() idom:B0 |
| DirectCall print(v15) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| Goto(B13) |
| B11 = TargetBlock() idom:B0 |
| Goto(B13) |
| B13 = JoinBlock(B11, B10) idom:B0 |
| ParallelMove output(stack[0] -> R0) |
| ParallelMove input(vloc:R0 -> R0) |
| Return(v7) # RA: (R0) |
| |
| --- test4 |
| B0 = EntryBlock() dominates:(B8, B14, B16, B7) |
| v19 = Constant(1) |
| v30 = Constant(2) |
| v33 = Constant(null) |
| v1 = Parameter(a) # RA: param[0] <- () |
| v2 = Parameter(b) # RA: param[1] <- () |
| v3 = Parameter(c) # RA: param[2] <- () |
| ParallelMove output(param[2] -> vloc:R2, param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v35 = UnboxInt(v1) # RA: R0 <- (R0) |
| v36 = UnboxInt(v2) # RA: R1 <- (R1) |
| v6 = Comparison int >(v35, v36) # RA: R0 <- (R0, R1) |
| ParallelMove output(R0 -> stack[0]) |
| Branch(v6, true: B7, false: B8) # RA: (R0) |
| B7 = TargetBlock() idom:B0 |
| Goto(B16) |
| B8 = TargetBlock() idom:B0 dominates:(B12, B11) |
| Branch(v3, true: B11, false: B12) # RA: (R2) |
| B11 = TargetBlock() idom:B8 |
| Goto(B16) |
| B16 = JoinBlock(B11, B7) idom:B0 |
| DirectCall print(v19) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| Goto(B14) |
| B12 = TargetBlock() idom:B8 |
| Goto(B14) |
| B14 = JoinBlock(B12, B16) idom:B0 dominates:(B26, B28, B25) |
| ParallelMove output(stack[0] -> R0) |
| Branch(v6, true: B25, false: B26) # RA: (R0) |
| B25 = TargetBlock() idom:B14 |
| DirectCall print(v30) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| Goto(B28) |
| B26 = TargetBlock() idom:B14 |
| Goto(B28) |
| B28 = JoinBlock(B26, B25) idom:B14 |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v33) # RA: (R0) |
| |
| --- test5 |
| B0 = EntryBlock() dominates:(B7, B6) |
| Constant(32) |
| v11 = Constant(1) |
| Constant(16) |
| Constant(8) |
| v23 = Constant(2) |
| Constant(257) |
| v37 = Constant(3) |
| v47 = Constant(4) |
| Constant(7) |
| v58 = Constant(5) |
| v62 = Constant(-1) |
| v69 = Constant(UnboxedIntConstant(32)) |
| v71 = Constant(UnboxedIntConstant(16)) |
| v72 = Constant(UnboxedIntConstant(8)) |
| v74 = Constant(UnboxedIntConstant(257)) |
| v77 = Constant(UnboxedIntConstant(7)) |
| v1 = Parameter(a) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| v68 = UnboxInt(v1) # RA: R1 <- (R0) |
| CompareAndBranch int & != 0(v68, v69, true: B6, false: B7) # RA: (R1, -) |
| B6 = TargetBlock() idom:B0 |
| ParallelMove input(IntConstant(1) -> R0) |
| Return(v11) # RA: (R0) |
| B7 = TargetBlock() idom:B0 dominates:(B19, B18) |
| v70 = UnboxInt(v1) # RA: R1 <- (R0) |
| v15 = BinaryIntOp &(v70, v71) # RA: R1 <- (R1, -) |
| CompareAndBranch int ==(v15, v72, true: B18, false: B19) # RA: (R1, -) |
| B18 = TargetBlock() idom:B7 |
| ParallelMove input(IntConstant(2) -> R0) |
| Return(v23) # RA: (R0) |
| B19 = TargetBlock() idom:B7 dominates:(B33, B32) |
| v73 = UnboxInt(v1) # RA: R1 <- (R0) |
| v29 = BinaryIntOp &(v73, v74) # RA: R1 <- (R1, -) |
| CompareAndBranch int ==(v29, v74, true: B32, false: B33) # RA: (R1, -) |
| B32 = TargetBlock() idom:B19 |
| ParallelMove input(IntConstant(3) -> R0) |
| Return(v37) # RA: (R0) |
| B33 = TargetBlock() idom:B19 dominates:(B43, B42) |
| v75 = UnboxInt(v1) # RA: R1 <- (R0) |
| CompareAndBranch int & != 0(v75, v72, true: B42, false: B43) # RA: (R1, -) |
| B42 = TargetBlock() idom:B33 dominates:(B54, B53) |
| v76 = UnboxInt(v1) # RA: R0 <- (R0) |
| v51 = BinaryIntOp &(v76, v77) # RA: R0 <- (R0, -) |
| CompareAndBranch int ==(v51, v77, true: B53, false: B54) # RA: (R0, -) |
| B53 = TargetBlock() idom:B42 |
| ParallelMove input(IntConstant(-1) -> R0) |
| Return(v62) # RA: (R0) |
| B54 = TargetBlock() idom:B42 |
| ParallelMove input(IntConstant(5) -> R0) |
| Return(v58) # RA: (R0) |
| B43 = TargetBlock() idom:B33 |
| ParallelMove input(IntConstant(4) -> R0) |
| Return(v47) # RA: (R0) |
| |
| --- listLiterals |
| B0 = EntryBlock() |
| v5 = Constant(<dynamic>) |
| v6 = Constant(0) |
| v9 = Constant(null) |
| v13 = Constant(<int>) |
| v14 = Constant(1) |
| v15 = Constant(2) |
| v16 = Constant(3) |
| v19 = Constant(4) |
| v20 = Constant(5) |
| v21 = Constant(6) |
| v22 = Constant(7) |
| v23 = Constant(8) |
| v24 = Constant(9) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(x) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:param[1], param[0] -> vloc:R0) |
| v7 = DirectCall _GrowableList.(v5, v6) # RA: R0 <- (-, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v7) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(param[0] -> R1) |
| ParallelMove input(NullConstant(null) -> R2, vloc:R1 -> R1) |
| v10 = TypeArguments(v9, v1, <listLiterals.T%>) # RA: R0 <- (R2, R1) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1, R2], objects: [R1, R2]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[0]) |
| v11 = DirectCall _GrowableList.(v10, v6) # RA: R0 <- (R0, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v11) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| v17 = DirectCall _GrowableList._literal3(v13, v14, v15, v16) # RA: R0 <- (-, -, -, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v17) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| v40 = AllocateList(v24) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove input(IntConstant(1) -> vloc:R2) |
| SetListElement(v40, v6, v14) # RA: (R0, -, R2) temps: [R1, R3] SAFEPT{live: [R0, R1, R3], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(2) -> vloc:R3) |
| SetListElement(v40, v14, v15) # RA: (R0, -, R3) temps: [R2, R1] SAFEPT{live: [R0, R1, R2], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(3) -> vloc:R3) |
| SetListElement(v40, v15, v16) # RA: (R0, -, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(4) -> vloc:R2) |
| SetListElement(v40, v16, v19) # RA: (R0, -, R2) temps: [R1, R3] SAFEPT{live: [R0, R1, R3], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(5) -> vloc:R1) |
| SetListElement(v40, v19, v20) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(6) -> vloc:R1) |
| SetListElement(v40, v20, v21) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(7) -> vloc:R1) |
| SetListElement(v40, v21, v22) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(8) -> vloc:R1) |
| SetListElement(v40, v22, v23) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0, stack[0]]} |
| ParallelMove input(IntConstant(9) -> vloc:R1) |
| SetListElement(v40, v23, v24) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0, stack[0]]} |
| v50 = DirectCall _GrowableList._literal(v13, v40) # RA: R0 <- (-, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v50) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| v51 = AllocateList(v24) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R2, param[1] -> R3) |
| SetListElement(v51, v6, v2) # RA: (R2, -, R3) temps: [R0, R1] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v14, v2) # RA: (R2, -, R3) temps: [R0, R1] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v15, v2) # RA: (R2, -, R3) temps: [R0, R1] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v16, v2) # RA: (R2, -, R3) temps: [R0, R1] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v19, v2) # RA: (R2, -, R3) temps: [R0, R1] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v20, v2) # RA: (R2, -, R3) temps: [R0, R1] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v21, v2) # RA: (R2, -, R3) temps: [R1, R0] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v22, v2) # RA: (R2, -, R3) temps: [R1, R0] SAFEPT{live: [R0, R1, R2, R3], objects: [R2, R3, stack[0]]} |
| SetListElement(v51, v23, v2) # RA: (R2, -, R3) temps: [R1, R0] SAFEPT{live: [R0, R1, R2], objects: [R2, stack[0]]} |
| ParallelMove output(stack[0] -> R0) |
| v61 = DirectCall _GrowableList._literal(v10, v51) # RA: R0 <- (R0, R2) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v61) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v9) # RA: (R0) |
| |
| --- mapLiterals |
| B0 = EntryBlock() |
| v8 = Constant(<dynamic, dynamic>) |
| v11 = Constant(null) |
| v15 = Constant(<String, String>) |
| v16 = Constant("a") |
| v17 = Constant("aa") |
| v18 = Constant("b") |
| v19 = Constant("bb") |
| v31 = Constant(ListConstant(const <dynamic>[])) |
| v34 = Constant(4) |
| v36 = Constant(0) |
| v38 = Constant(1) |
| v40 = Constant(2) |
| v42 = Constant(3) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(key) # RA: param[1] <- () |
| v3 = Parameter(value) # RA: param[2] <- () |
| v4 = Parameter(key2) # RA: param[3] <- () |
| v5 = Parameter(value2) # RA: param[4] <- () |
| ParallelMove output(param[4] -> vloc:R0, param[3] -> vloc:param[3], param[2] -> vloc:param[2], param[1] -> vloc:param[1], param[0] -> vloc:param[0]) |
| v32 = DirectCall Map._fromLiteral(v8, v31) # RA: R0 <- (-, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v32) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(param[0] -> R1) |
| ParallelMove input(NullConstant(null) -> R2, vloc:R1 -> R1) |
| v12 = TypeArguments(v11, v1, <mapLiterals.S%, mapLiterals.T%>) # RA: R0 <- (R2, R1) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1, R2], objects: [R1, R2]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[0]) |
| v33 = DirectCall Map._fromLiteral(v12, v31) # RA: R0 <- (R0, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v33) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| v35 = AllocateList(v34) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R1) |
| ParallelMove input(StringConstant("a") -> vloc:R2) |
| SetListElement(v35, v36, v16) # RA: (R1, -, R2) temps: [R0, R3] SAFEPT{live: [R0, R1, R3], objects: [R1, stack[0]]} |
| ParallelMove input(StringConstant("aa") -> vloc:R3) |
| SetListElement(v35, v38, v17) # RA: (R1, -, R3) temps: [R2, R0] SAFEPT{live: [R0, R1, R2], objects: [R1, stack[0]]} |
| ParallelMove input(StringConstant("b") -> vloc:R3) |
| SetListElement(v35, v40, v18) # RA: (R1, -, R3) temps: [R2, R0] SAFEPT{live: [R0, R1, R2], objects: [R1, stack[0]]} |
| ParallelMove input(StringConstant("bb") -> vloc:R0) |
| SetListElement(v35, v42, v19) # RA: (R1, -, R0) temps: [R2, R3] SAFEPT{live: [R1, R2, R3], objects: [R1, stack[0]]} |
| v44 = DirectCall Map._fromLiteral(v15, v35) # RA: R0 <- (-, R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v44) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(param[2] -> R1) |
| v25 = ClosureCall(v3) # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[1]) |
| v45 = AllocateList(v34) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0], stack[1]]} |
| ParallelMove output(R0 -> vloc:R0, param[1] -> R3) |
| SetListElement(v45, v36, v2) # RA: (R0, -, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0, stack[0], stack[1]]} |
| ParallelMove output(stack[1] -> R3) |
| SetListElement(v45, v38, v25) # RA: (R0, -, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0, stack[0]]} |
| ParallelMove output(param[3] -> R3) |
| SetListElement(v45, v40, v4) # RA: (R0, -, R3) temps: [R2, R1] SAFEPT{live: [R0, R1, R2], objects: [R0, stack[0]]} |
| ParallelMove output(param[4] -> R3) |
| SetListElement(v45, v42, v5) # RA: (R0, -, R3) temps: [R2, R1] SAFEPT{live: [R0, R1, R2], objects: [R0, stack[0]]} |
| ParallelMove output(stack[0] -> R1) |
| v50 = DirectCall Map._fromLiteral(v12, v45) # RA: R0 <- (R1, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v50) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v11) # RA: (R0) |
| |
| --- recordLiterals |
| B0 = EntryBlock() |
| v30 = Constant(null) |
| Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(a) # RA: param[1] <- () |
| v3 = Parameter(b) # RA: param[2] <- () |
| v4 = Parameter(c) # RA: param[3] <- () |
| ParallelMove output(param[3] -> vloc:R0, param[2] -> vloc:param[2], param[1] -> vloc:param[1]) |
| v32 = AllocateRecord (int)() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[1] -> R3) |
| StoreInstanceField(#record-field[0], v32, v2) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3], objects: [R0, R3]} |
| DirectCall print(v32) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| v34 = AllocateRecord (int, String, recordLiterals.T%)() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[1] -> R3) |
| StoreInstanceField(#record-field[0], v34, v2) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3], objects: [R0, R3]} |
| ParallelMove output(param[2] -> R4) |
| StoreInstanceField(#record-field[1], v34, v3) # RA: (R0, R4) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3, R4], objects: [R0, R3, R4]} |
| ParallelMove output(param[3] -> R5) |
| StoreInstanceField(#record-field[2], v34, v4) # RA: (R0, R5) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3, R4, R5], objects: [R0, R3, R4, R5]} |
| DirectCall print(v34) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| v38 = AllocateRecord ({recordLiterals.T% bar, String foo})() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[3] -> R3) |
| StoreInstanceField(#record-field[0:bar], v38, v4) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3], objects: [R0, R3]} |
| ParallelMove output(param[2] -> R4) |
| StoreInstanceField(#record-field[1:foo], v38, v3) # RA: (R0, R4) temps: [R1, R2] SAFEPT{live: [R0, R1, R2, R3, R4], objects: [R0, R3, R4]} |
| DirectCall print(v38) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| v41 = AllocateRecord (int, {recordLiterals.T% bar, String foo})() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[1] -> R3) |
| StoreInstanceField(#record-field[0], v41, v2) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| ParallelMove output(param[3] -> R3) |
| StoreInstanceField(#record-field[1:bar], v41, v4) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| ParallelMove output(param[2] -> R3) |
| StoreInstanceField(#record-field[2:foo], v41, v3) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| DirectCall print(v41) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v30) # RA: (R0) |
| |
| --- stringInterpolation |
| B0 = EntryBlock() |
| v7 = Constant("Hey, x=") |
| v9 = Constant(", s=") |
| v11 = Constant(", o=") |
| v15 = Constant(null) |
| v18 = Constant(6) |
| v20 = Constant(0) |
| v22 = Constant(1) |
| v24 = Constant(2) |
| v26 = Constant(3) |
| v28 = Constant(4) |
| v30 = Constant(5) |
| v1 = Parameter(x) # RA: param[0] <- () |
| v2 = Parameter(s) # RA: param[1] <- () |
| v3 = Parameter(o) # RA: param[2] <- () |
| ParallelMove output(param[2] -> vloc:R0, param[1] -> vloc:param[1], param[0] -> vloc:param[0]) |
| v17 = DirectCall _StringBase._interpolateSingle(v3) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v17) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| v19 = AllocateList(v18) # RA: R0 <- (-) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove input(StringConstant("Hey, x=") -> vloc:R1) |
| SetListElement(v19, v20, v7) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0]} |
| ParallelMove output(param[0] -> R3) |
| SetListElement(v19, v22, v1) # RA: (R0, -, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| ParallelMove input(StringConstant(", s=") -> vloc:R1) |
| SetListElement(v19, v24, v9) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0]} |
| ParallelMove output(param[1] -> R3) |
| SetListElement(v19, v26, v2) # RA: (R0, -, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| ParallelMove input(StringConstant(", o=") -> vloc:R1) |
| SetListElement(v19, v28, v11) # RA: (R0, -, R1) temps: [R2, R3] SAFEPT{live: [R0, R2, R3], objects: [R0]} |
| ParallelMove output(param[2] -> R3) |
| SetListElement(v19, v30, v3) # RA: (R0, -, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| v32 = DirectCall _StringBase._interpolate(v19) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v32) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v15) # RA: (R0) |
| |
| --- nestedFunctionTypeParameters1 |
| B0 = EntryBlock() |
| v7 = Constant(<String>) |
| v10 = Constant(null) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| v4 = AllocateClosure() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[0] -> R3) |
| StoreInstanceField(#closure-field[1], v4, v1) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| DirectCall closure FunctionDeclaration(void nested1<T extends Object?>() { |
| void nested2<U extends Object?>() { |
| print(nestedFunctionTypeParameters1.S%); |
| print(T%); |
| print(U%); |
| } |
| nested2<int>(); |
| }) at nestedFunctionTypeParameters1(v7, v4) # RA: R0 <- (-, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v10) # RA: (R0) |
| |
| --- closure FunctionDeclaration(void nested1<T extends Object?>() { |
| void nested2<U extends Object?>() { |
| print(nestedFunctionTypeParameters1.S%); |
| print(T%); |
| print(U%); |
| } |
| nested2<int>(); |
| }) at nestedFunctionTypeParameters1 |
| B0 = EntryBlock() |
| v10 = Constant(<int>) |
| v13 = Constant(null) |
| v17 = Constant(1) |
| v18 = Constant(2) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(#closure) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v5 = LoadInstanceField(#closure-field[1], v2) # RA: R1 <- (R1) |
| v16 = DirectCall _prependTypeArguments(v1, v5, v17, v18) # RA: R0 <- (R0, R1, -, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[0]) |
| v7 = AllocateClosure() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0, stack[0] -> R3) |
| StoreInstanceField(#closure-field[1], v7, v16) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| DirectCall closure FunctionDeclaration(void nested2<U extends Object?>() { |
| print(nestedFunctionTypeParameters1.S%); |
| print(T%); |
| print(U%); |
| }) at nestedFunctionTypeParameters1(v10, v7) # RA: R0 <- (-, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v13) # RA: (R0) |
| |
| --- closure FunctionDeclaration(void nested2<U extends Object?>() { |
| print(nestedFunctionTypeParameters1.S%); |
| print(T%); |
| print(U%); |
| }) at nestedFunctionTypeParameters1 |
| B0 = EntryBlock() |
| v7 = Constant(null) |
| v16 = Constant(2) |
| v17 = Constant(3) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(#closure) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v5 = LoadInstanceField(#closure-field[1], v2) # RA: R1 <- (R1) |
| v15 = DirectCall _prependTypeArguments(v1, v5, v16, v17) # RA: R0 <- (R0, R1, -, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[0]) |
| ParallelMove input(NullConstant(null) -> vloc:R1) |
| v8 = TypeLiteral(nestedFunctionTypeParameters1.S%, v7, v15) # RA: R1 <- (R1, R0) |
| DirectCall print(v8) # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(stack[0] -> R2) |
| ParallelMove input(NullConstant(null) -> vloc:R1) |
| v10 = TypeLiteral(T%, v7, v15) # RA: R0 <- (R1, R2) |
| DirectCall print(v10) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(stack[0] -> R2) |
| ParallelMove input(NullConstant(null) -> vloc:R1) |
| v12 = TypeLiteral(U%, v7, v15) # RA: R0 <- (R1, R2) |
| DirectCall print(v12) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v7) # RA: (R0) |
| |
| --- nestedFunctionTypeParameters2 |
| B0 = EntryBlock() |
| v9 = Constant(null) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| v4 = AllocateClosure() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0, param[0] -> R3) |
| StoreInstanceField(#closure-field[0], v4, v1) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| DirectCall closure FunctionDeclaration(void nested1() { |
| void nested2<T extends Object?>() { |
| print(nestedFunctionTypeParameters2.S%); |
| print(T%); |
| } |
| nested2<int>(); |
| }) at nestedFunctionTypeParameters2(v4) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v9) # RA: (R0) |
| |
| --- closure FunctionDeclaration(void nested1() { |
| void nested2<T extends Object?>() { |
| print(nestedFunctionTypeParameters2.S%); |
| print(T%); |
| } |
| nested2<int>(); |
| }) at nestedFunctionTypeParameters2 |
| B0 = EntryBlock() |
| v8 = Constant(<int>) |
| v11 = Constant(null) |
| v1 = Parameter(#closure) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| v3 = LoadInstanceField(#closure-field[0], v1) # RA: R0 <- (R0) |
| ParallelMove output(R0 -> stack[0]) |
| v5 = AllocateClosure() # RA: R0 <- () temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(R0 -> vloc:R0, stack[0] -> R3) |
| StoreInstanceField(#closure-field[1], v5, v3) # RA: (R0, R3) temps: [R1, R2] SAFEPT{live: [R0, R1, R2], objects: [R0]} |
| DirectCall closure FunctionDeclaration(void nested2<T extends Object?>() { |
| print(nestedFunctionTypeParameters2.S%); |
| print(T%); |
| }) at nestedFunctionTypeParameters2(v8, v5) # RA: R0 <- (-, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v11) # RA: (R0) |
| |
| --- closure FunctionDeclaration(void nested2<T extends Object?>() { |
| print(nestedFunctionTypeParameters2.S%); |
| print(T%); |
| }) at nestedFunctionTypeParameters2 |
| B0 = EntryBlock() |
| v7 = Constant(null) |
| v14 = Constant(1) |
| v15 = Constant(2) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(#closure) # RA: param[1] <- () |
| ParallelMove output(param[1] -> vloc:R1, param[0] -> vloc:R0) |
| v5 = LoadInstanceField(#closure-field[1], v2) # RA: R1 <- (R1) |
| v13 = DirectCall _prependTypeArguments(v1, v5, v14, v15) # RA: R0 <- (R0, R1, -, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[0]) |
| ParallelMove input(NullConstant(null) -> vloc:R1) |
| v8 = TypeLiteral(nestedFunctionTypeParameters2.S%, v7, v13) # RA: R1 <- (R1, R0) |
| DirectCall print(v8) # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(stack[0] -> R2) |
| ParallelMove input(NullConstant(null) -> vloc:R1) |
| v10 = TypeLiteral(T%, v7, v13) # RA: R0 <- (R1, R2) |
| DirectCall print(v10) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v7) # RA: (R0) |
| |
| --- allocateObjects |
| B0 = EntryBlock() |
| v4 = Constant(<int, double>) |
| v11 = Constant(null) |
| v20 = Constant(<String, int, double>) |
| v22 = Constant(<String, num, double>) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| ParallelMove output(param[0] -> vloc:R0) |
| ParallelMove input(<int, double> -> R1) |
| v5 = AllocateObject D<int, double>(v4) # RA: R0 <- (R1) temps: [R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1], objects: [R1]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[0]) |
| DirectCall D.(v5) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[0]]} |
| ParallelMove output(stack[0] -> R1) |
| DirectCall print(v5) # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(<String, int, double> -> R1) |
| v8 = AllocateObject E<int, double>(v20) # RA: R0 <- (R1) temps: [R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1], objects: [R1]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[1]) |
| DirectCall E.(v8) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[1]]} |
| ParallelMove output(stack[1] -> R1) |
| DirectCall print(v8) # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(param[0] -> R0) |
| ParallelMove input(NullConstant(null) -> R2, vloc:R0 -> R1) |
| TypeArguments(v11, v1, <allocateObjects.K%, List<allocateObjects.K%>>) # RA: R0 <- (R2, R1) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1, R2], objects: [R1, R2]} |
| ParallelMove output(param[0] -> R1) |
| ParallelMove input(NullConstant(null) -> R2, vloc:R1 -> R1) |
| v21 = TypeArguments(v11, v1, <String, allocateObjects.K%, List<allocateObjects.K%>>) # RA: R0 <- (R2, R1) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1, R2], objects: [R1, R2]} |
| ParallelMove output(R0 -> vloc:R1) |
| ParallelMove input(vloc:R1 -> R1) |
| v13 = AllocateObject E<allocateObjects.K%, List<allocateObjects.K%>>(v21) # RA: R0 <- (R1) temps: [R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1], objects: [R1]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[3]) |
| DirectCall E.(v13) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[3]]} |
| ParallelMove output(stack[3] -> R1) |
| DirectCall print(v13) # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(<String, num, double> -> R1) |
| v23 = AllocateObject F(v22) # RA: R0 <- (R1) temps: [R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1], objects: [R1]} |
| ParallelMove output(R0 -> vloc:R0) |
| ParallelMove spill(R0 -> stack[4]) |
| DirectCall F.(v23) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: [stack[4]]} |
| ParallelMove output(stack[4] -> R1) |
| DirectCall print(v23) # RA: R0 <- (R1) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v11) # RA: (R0) |
| |
| --- instantiateClosures |
| B0 = EntryBlock() |
| v6 = Constant(<int>) |
| v10 = Constant(null) |
| v1 = Parameter(#functionTypeParameters) # RA: param[0] <- () |
| v2 = Parameter(foo) # RA: param[1] <- () |
| v3 = Parameter(bar) # RA: param[2] <- () |
| ParallelMove output(param[2] -> vloc:R0, param[1] -> vloc:R1, param[0] -> vloc:param[0]) |
| v22 = DirectCall _instantiateClosure(v2, v6) # RA: R0 <- (R1, -) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v22) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(param[0] -> R0) |
| ParallelMove input(NullConstant(null) -> R2, vloc:R0 -> R1) |
| v11 = TypeArguments(v10, v1, <instantiateClosures.T1%, String>) # RA: R0 <- (R2, R1) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1, R2], objects: [R1, R2]} |
| ParallelMove output(R0 -> vloc:R0, param[2] -> R1) |
| v23 = DirectCall _instantiateClosure(v3, v11) # RA: R0 <- (R1, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v23) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(param[0] -> R1) |
| ParallelMove input(NullConstant(null) -> R2, vloc:R1 -> R1) |
| v15 = TypeArguments(v10, v1, <int, instantiateClosures.T2%>) # RA: R0 <- (R2, R1) temps: [R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [R1, R2], objects: [R1, R2]} |
| ParallelMove output(R0 -> vloc:R0, param[2] -> R1) |
| v24 = DirectCall _instantiateClosure(v3, v15) # RA: R0 <- (R1, R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove output(R0 -> vloc:R0) |
| DirectCall print(v24) # RA: R0 <- (R0) temps: [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, R13, R14, R19, R20, R23, R25, V0, V1, V2, V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30] SAFEPT{live: [], objects: []} |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v10) # RA: (R0) |
| |
| --- main |
| B0 = EntryBlock() |
| v1 = Constant(null) |
| ParallelMove input(NullConstant(null) -> R0) |
| Return(v1) # RA: (R0) |
| |
