+++ start of data +++ +++ external: "KPunboundVKi" +++ +++ external: "KPfalseVKi" +++ +++ external: "KPtrueVKi" +++ +++ external: "KPempty_listVKi" +++ +++ external: "KPempty_vectorVKi" +++ +++ external: "Ddirect_object_mm_wrappersVKi" +++ +++ external: "Ddirect_object_classesVKi" +++ +++ external: "KLtraceable_value_cellGVKiW" +++ +++ external: "KLuntraceable_value_cellGVKiW" +++ +++ external: "KLuntraceable_double_value_cellGVKiW" +++ +++ external: "KLmachine_wordGVKeW" +++ +++ external: "Tdispatch_profiling_enabledQTVKe" +++ +++ external: "Tclass_profiling_enabledQTVKe" +++ +++ external: "KLobjectGVKd" +++ +++ external: "KLobjectGVKdW" +++ +++ external: "KLsingle_floatGVKdW" +++ +++ external: "KLdouble_floatGVKdW" +++ +++ external: "KLsimple_object_vectorGVKdW" +++ +++ external: "KLbyte_stringGVKdW" +++ +++ external: "KLmethodGVKdW" +++ +++ external: "KerrorVKd" +++ +++ external: "Kargument_count_errorVKiI" +++ +++ external: "Kodd_keyword_arguments_errorVKiI" +++ +++ external: "Kunknown_keyword_argument_errorVKiI" +++ +++ external: "Ktype_check_errorVKiI" +++ +++ external: "Kstack_overflow_errorVKiI" +++ +++ external: "Kgrounded_instanceQVKeI" +++ +++ external: "MMCollectCount" +++ +++ external: "dylan__malloc__misc" +++ +++ external: "dylan__malloc__ambig" +++ +++ external: "dylan__malloc__exact" +++ +++ external: "dylan__free__root" +++ +++ external: "mps__malloc" +++ +++ external: "mps__free" +++ +++ external: "primitive_mps_park" +++ +++ external: "primitive_mps_release" +++ +++ defining "Kprimitive_error_string" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 65 BYTE "Primitive error." BYTE 0 +++ (public) variable{constant "dylan_false"} " in section untraced-data" = {constant "KPfalseVKi"} +++ +++ external: "Ksignal_low_memoryVKe" +++ +++ (public) variable{constant "dylan_signal_low_memory"} " in section untraced-data" = {constant "Ksignal_low_memoryVKe"} +++ +++ external: "Kkeyboard_break_handlerVKe" +++ +++ (public) variable{constant "dylan_keyboard_break_handler"} " in section untraced-data" = {constant "Kkeyboard_break_handlerVKe"} +++ +++ (public) variable{indirect-constant "dylan_keyboard_interruptQ"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "Prunning_under_dylan_debuggerQ"} " in section untraced-data" = 0 +++ +++ external: "primitive_alloc" +++ +++ external: "primitive_alloc_s1" +++ +++ external: "primitive_alloc_s2" +++ +++ external: "primitive_alloc_s" +++ +++ external: "primitive_alloc_r" +++ +++ external: "primitive_alloc_rf" +++ +++ external: "primitive_alloc_rt" +++ +++ external: "primitive_alloc_s_r" +++ +++ external: "primitive_alloc_s_rb" +++ +++ external: "primitive_alloc_leaf" +++ +++ external: "primitive_alloc_leaf_s_r" +++ +++ external: "primitive_alloc_leaf_s1" +++ +++ external: "primitive_alloc_leaf_s2" +++ +++ external: "primitive_alloc_leaf_s" +++ +++ external: "primitive_alloc_leaf_r" +++ +++ external: "primitive_alloc_leaf_s_rbf" +++ +++ external: "primitive_alloc_leaf_s_rbfz" +++ +++ external: "primitive_alloc_leaf_rbfz" +++ +++ external: "primitive_alloc_leaf_s_rb" +++ +++ external: "primitive_alloc_exact_awl_s_r" +++ +++ external: "primitive_alloc_exact_awl_rf" +++ +++ external: "primitive_alloc_weak_awl_s_r" +++ +++ external: "primitive_alloc_weak_awl_rf" +++ +++ external: "primitive_alloc_wrapper_s_r" +++ +++ external: "primitive_copy" +++ +++ external: "primitive_copy_r" +++ +++ external: "primitive_wrap_machine_word" +++ +++ external: "primitive_wrap_c_pointer" +++ +++ defining "Klow_zeros_table" in section untraced-data +++ BYTE 4 BYTE 0 BYTE 1 BYTE 0 BYTE 2 BYTE 0 BYTE 1 BYTE 0 BYTE 3 BYTE 0 BYTE 1 BYTE 0 BYTE 2 BYTE 0 BYTE 1 BYTE 0 +++ defining "Khigh_zeros_table" in section untraced-data +++ BYTE 4 BYTE 3 BYTE 2 BYTE 2 BYTE 1 BYTE 1 BYTE 1 BYTE 1 BYTE 0 BYTE 0 BYTE 0 BYTE 0 BYTE 0 BYTE 0 BYTE 0 BYTE 0+++ external: "primitive_exit_application" +++ +++ (public) variable{constant "Pmaster_gc_teb"} " in section ambiguous-data" = 0 +++ +++ (public) variable{constant "Pmaster_teb"} " in section ambiguous-data" = 0 +++ +++ (public) variable{indirect-constant "Pteb_tlv_index"} " in section untraced-data" = -1 +++ +++ (public) variable{indirect-constant "Pteb_chain"} " in section untraced-data" = 0 +++ +++ external: "dylan_init_thread" +++ +++ external: "dylan_callin_handler" +++ +++ external: "trampoline_body" +++ +++ external: "dylan_mm_register_thread" +++ +++ external: "dylan_mm_deregister_thread_from_teb" +++ +++ external: "dylan_init_memory_manager" +++ +++ external: "dylan_shut_down_memory_manager" +++ +++ external: "MMRegisterRootStatic" +++ +++ external: "MMRegisterRootImmut" +++ +++ external: "MMRegisterRootAmbig" +++ +++ external: "MMRegisterRootExact" +++ +++ external: "MMDeregisterRoot" +++ +++ external: "MMFreeMisc" +++ +++ external: "Kmake_foreign_threadYthreads_primitivesVdylanI" +++ +++ external: "Kcall_application_exit_functionsVKeI" +++ +++ (public) variable{constant "Pstatic_root"} " in section untraced-data" = 0 +++ +++ (public) variable{constant "Pimmut_root"} " in section untraced-data" = 0 +++ +++ (public) variable{constant "Pambig_root"} " in section untraced-data" = 0 +++ +++ (public) variable{constant "Pexact_root"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "Pstarted_unloading"} " in section untraced-data" = 0 +++ +++ (public) variable{constant "module_hInstance"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "_init_dylan_library"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "Pruntime_spin_lock"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "Pruntime_thread_count"} " in section untraced-data" = 0 +++ +++ external: "primitive_ensure_valid_teb" +++ +++ external: "primitive_register_traced_roots" +++ +++ external: "primitive_deregister_traced_roots" +++ +++ external: "dylan_init_thread_local" +++ +++ external: "primitive_call_first_dylan_iep" +++ +++ (public) variable{indirect-constant "Prunning_dylan_spy_functionQ"} " in section untraced-data" = 0 +++ +++ external: "spy_invoke_dylan_under_coded_restartVKi" +++ +++ external: "Kmake_simple_lockYthreads_primitivesVdylan" +++ +++ (public) variable{constant "default_tlv_vector"} " in section ambiguous-data" = 0 +++ +++ external: "KPslotacc_single_q_instance_getterVKiI" +++ +++ external: "KPslotacc_single_q_instance_setterVKiI" +++ +++ external: "KPslotacc_single_q_class_getterVKiI" +++ +++ external: "KPslotacc_single_q_class_setterVKiI" +++ +++ external: "KPslotacc_repeated_instance_getterVKiI" +++ +++ external: "KPslotacc_repeated_instance_setterVKiI" +++ +++ external: "Kunbound_instance_slotVKeI" +++ +++ external: "Kunbound_repeated_slotVKeI" +++ +++ external: "Kinvalid_keyword_trapVKeI" +++ +++ external: "Kodd_number_of_keyword_args_trapVKeI" +++ +++ external: "Krepeated_slot_getter_index_out_of_range_trapVKeI" +++ +++ external: "Krepeated_slot_setter_index_out_of_range_trapVKeI" +++ +++ external: "Dinapplicable_engine_nodeVKg" +++ +++ external: "Dabsent_engine_nodeVKg" +++ +++ defining "Kinitialize_engine_node_table" in section untraced-data +++ DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_1" DATA "initialize_engine_node_table_entries_2" DATA "initialize_engine_node_table_entries_3" DATA "initialize_engine_node_table_entries_4" DATA "initialize_engine_node_table_entries_5" DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_default" DATA "initialize_engine_node_table_entries_13" DATA "initialize_engine_node_table_entries_14" DATA "initialize_engine_node_table_entries_1" DATA "initialize_engine_node_table_entries_16" DATA "initialize_engine_node_table_entries_17" DATA "initialize_engine_node_table_entries_18" DATA "initialize_engine_node_table_entries_19" DATA "initialize_engine_node_table_entries_20" DATA "initialize_engine_node_table_entries_21" DATA "initialize_engine_node_table_entries_22" DATA "initialize_engine_node_table_entries_23" DATA "initialize_engine_node_table_entries_20" DATA "initialize_engine_node_table_entries_21" DATA "initialize_engine_node_table_entries_20" DATA "initialize_engine_node_table_entries_21" DATA "initialize_engine_node_table_entries_21" DATA "initialize_engine_node_table_entries_29" DATA "initialize_engine_node_table_entries_21" DATA "initialize_engine_node_table_entries_29"+++ external: "KLsymbolGVKdW" +++ +++ (public) variable{indirect-constant "Poblist"} " in section ambiguous-data" = 0 +++ +++ (public) variable{indirect-constant "PoblistUsize"} " in section untraced-data" = 8 +++ +++ (public) variable{indirect-constant "PoblistUcursor"} " in section untraced-data" = 8 +++ +++ external: "Kmachine_word_overflowVKmI" +++ +++ defining "Kfloat_overflow_error_string" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 85 BYTE "Float overflow error." BYTE 0 +++ defining "Kfloat_underflow_error_string" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 89 BYTE "Float underflow error." BYTE 0 +++ defining "Kfloat_divide_0_error_string" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 97 BYTE "Float divide by 0 error." BYTE 0 +++ defining "Kunsupported_float" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 45 BYTE "unsupported" BYTE 0 +++ defining "Knan_float" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 13 BYTE "nan" BYTE 0 +++ defining "Knormal_float" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 25 BYTE "normal" BYTE 0 +++ defining "Kinfinity_float" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 33 BYTE "infinity" BYTE 0 +++ defining "Kzero_float" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 17 BYTE "zero" BYTE 0 +++ defining "Kempty_float" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 21 BYTE "empty" BYTE 0 +++ defining "Kdenormal_float" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 33 BYTE "denormal" BYTE 0 +++ defining "Kfloating_point_classes" in section untraced-data +++ DATA 0 DATA "Kunsupported_float" DATA 256 DATA "Knan_float" DATA 1024 DATA "Knormal_float" DATA 1280 DATA "Kinfinity_float" DATA 16384 DATA "Kzero_float" DATA 16640 DATA "Kempty_float" DATA 17408 DATA "Kdenormal_float"+++ external: "c_primitive_start_timer" +++ +++ external: "c_primitive_stop_timer" +++ +++ external: "exit" +++ +++ external: "system" +++ +++ (public) variable{constant "Pthread_local_storage"} " in section ambiguous-data" = 0 +++ +++ Defining glue symbols +++ Data start is "_dylan_data_start" Data end is "_dylan_data_end" Variables start is "_dylan_vars_start" Variables end is "_dylan_vars_end" Objects start is "_dylan_objs_start" Objects end is "_dylan_objs_end" Fixup start is "_dylan_fixup_start" Fixup end is "_dylan_fixup_end" Import start is "_dylan_import_start" Import end is "_dylan_import_end" +++ start of code +++ +++ Exported function definition primitive_break +++ +++ starting code for primitive_break +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) halt #() [10->15] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_break +++ +++ No Source Code Locators for primitive_break +++ +++ Exported function definition primitive_error +++ +++ starting code for primitive_error +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:35}) 35 50}) rem "This is a dummy first basic block." #({tag 2:35}) [35->50] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 25}) move r3, {constant "Kprimitive_error_string"} move r22, {constant "KerrorVKd"} move r0, 1 call-indirect r22, 4, 1 #() [25->25] (level:0) is red with stack state with #({basic-block #({tag 1:30}) 30 35}) #({tag 1:30}) [30->35] (level:0) is #f with stack state #f #({basic-block #() 25 30}) preserve-registers-exit #() [25->30] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_error +++ +++ Live variable scopes for primitive_error +++ Start scope at 8 with frame for no variables End scope at 23 +++ No Source Code Locators for primitive_error +++ +++ Exported function definition primitive_debug_message +++ +++ starting code for primitive_debug_message +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state before #({basic-block #({tag 7:85}) 85 100}, {basic-block #({tag 1:75}) 75 75}) beq {tag 1:75}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0 #({tag 7:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:10}) 80 80}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 2:10}) [80->80] (level:0) is brown with stack state with #({basic-block #({tag 2:10}) 10 75}) #({tag 2:10}) [10->75] (level:0) is red with stack state with #({basic-block #({tag 3:80}) 80 80}) move G4/r3, r3 rem "eliminated" move G5/r5, r5 ld N2/r23, G5/r5, 4 asr N2/r23, N2/r23, 2 asl N3/r22, N2/r23, 2 sub r1, r1, N3/r22 add N1/r5, G5/r5, 8 copy-words-down-w r1, N1/r5, N2/r23 push N2/r23 push G4/r3 halt pop r3 #({tag 3:80}) [80->80] (level:0) is yellow with stack state with #({basic-block #({tag 3:80}, {tag 4:80}) 80 80}) #({tag 3:80}, {tag 4:80}) [80->80] (level:0) is green with stack state with #({basic-block #({tag 4:80}, {tag 3:80}, {tag 6:80}) 80 85}) #({tag 4:80}, {tag 3:80}, {tag 6:80}) [80->85] (level:0) is #f with stack state #f #({basic-block #({tag 1:75}, {tag 5:75}) 75 80}) preserve-registers-exit #({tag 1:75}, {tag 5:75}) [75->80] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:75}) [75->75] (level:0) is green with stack state before #({basic-block #({tag 1:75}, {tag 5:75}) 75 80}) +++ ending code for primitive_debug_message +++ +++ Live variable scopes for primitive_debug_message +++ Start scope at 16 with frame for no variables End scope at 51 +++ No Source Code Locators for primitive_debug_message +++ +++ Exported function definition primitive_invoke_debugger +++ +++ starting code for primitive_invoke_debugger +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:85}) 85 100}) rem "This is a dummy first basic block." #({tag 3:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}, {basic-block #({tag 1:25}) 25 75}) move G4/r3, r3 move G5/r4, r4 bne {tag 1:25}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0 #() [20->25] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 75}) rem "eliminated" #({tag 1:25}) [25->75] (level:0) is red with stack state with #({basic-block #({tag 2:80}) 80 85}) ld N1/r23, G5/r4, 4 asr N1/r23, N1/r23, 2 asl N2/r22, N1/r23, 2 sub r1, r1, N2/r22 add N0/r4, G5/r4, 8 copy-words-down-w r1, N0/r4, N1/r23 push N1/r23 push G4/r3 halt pop r3 #({tag 2:80}) [80->85] (level:0) is #f with stack state #f #({basic-block #() 75 80}) preserve-registers-exit #() [75->80] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_invoke_debugger +++ +++ Live variable scopes for primitive_invoke_debugger +++ Start scope at 8 with frame for no variables End scope at 51 +++ No Source Code Locators for primitive_invoke_debugger +++ +++ Exported function definition class_allocation_break +++ +++ starting code for class_allocation_break +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state before #({basic-block #({tag 8:65}) 65 80}, {basic-block #({tag 2:55}) 55 55}) beq {tag 2:55}, {indirect-constant "Tclass_profiling_enabledQTVKe"}, {constant "KPtrueVKi"} #({tag 8:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:10}) 60 60}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:10}) [60->60] (level:0) is brown with stack state with #({basic-block #({tag 3:10}) 10 35}) #({tag 3:10}) [10->35] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 55}, {basic-block #({tag 1:35}) 35 55}) rem "eliminated" move N1/r4, r4 rem "eliminated" move N3/r6, r6 bne {tag 1:35}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0 #({tag 1:35}) [35->55] (level:0) is red with stack state with #({basic-block #({tag 4:60}) 60 60}) push N3/r6 push N1/r4 halt pop r3 #({tag 4:60}) [60->60] (level:0) is yellow with stack state with #({basic-block #({tag 4:60}, {tag 5:60}) 60 60}) #({tag 4:60}, {tag 5:60}) [60->60] (level:0) is green with stack state with #({basic-block #({tag 5:60}, {tag 4:60}, {tag 7:60}) 60 65}) #({tag 5:60}, {tag 4:60}, {tag 7:60}) [60->65] (level:0) is #f with stack state #f #({basic-block #({tag 2:55}, {tag 6:55}) 55 60}) preserve-registers-exit #({tag 2:55}, {tag 6:55}) [55->60] (level:0) is green with stack state #f #() rts #({tag 2:55}) [55->55] (level:0) is green with stack state before #({basic-block #({tag 2:55}, {tag 6:55}) 55 60}) +++ ending code for class_allocation_break +++ +++ Live variable scopes for class_allocation_break +++ Start scope at 22 with frame for no variables End scope at 39 +++ No Source Code Locators for class_allocation_break +++ +++ Exported function definition primitive_inside_debuggerQ +++ +++ starting code for primitive_inside_debuggerQ +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:15}) 15 20}) beq {tag 1:15}, {indirect-constant "Prunning_under_dylan_debuggerQ"}, 0 #() [10->15] (level:0) is green with stack state #f #({basic-block #({tag 2:20}) 20 20}) move r3, {constant "KPtrueVKi"} #({tag 2:20}) [20->20] (level:0) is green with stack state #f #({basic-block #({tag 2:20}) 20 25}) #({tag 2:20}) [20->25] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:15}) [15->20] (level:0) is green with stack state #f #({basic-block #({tag 2:20}) 20 20}) move r3, {constant "KPfalseVKi"} #() [25->30] (level:0) is #f with stack state #f #() bra {tag 2:20} +++ ending code for primitive_inside_debuggerQ +++ +++ No Source Code Locators for primitive_inside_debuggerQ +++ +++ Exported function definition primitive_gc_state +++ +++ starting code for primitive_gc_state +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:40}) 40 55}) rem "This is a dummy first basic block." #({tag 2:40}) [40->55] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 30}) sub r1, r1, 24 call-alien {constant "MMCollectCount"}, 0 #() [15->30] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 40}) add r1, r1, 24 asl r3, r3, 2 add r3, r3, 1 #({tag 1:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 30 35}) preserve-registers-exit #() [30->35] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_gc_state +++ +++ Live variable scopes for primitive_gc_state +++ Start scope at 8 with frame for no variables End scope at 23 +++ No Source Code Locators for primitive_gc_state +++ +++ Exported function definition primitive_allocate +++ +++ starting code for primitive_allocate +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "primitive_error"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_allocate +++ +++ Live variable scopes for primitive_allocate +++ Start scope at 8 with frame for no variables End scope at 15 +++ No Source Code Locators for primitive_allocate +++ +++ Exported function definition primitive_allocate_filled +++ +++ starting code for primitive_allocate_filled +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:100}) 100 115}) rem "This is a dummy first basic block." #({tag 2:100}) [100->115] (level:0) is #f with stack state #f #({basic-block #() 5 80}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->80] (level:0) is red with stack state with #({basic-block #() 80 90}) move r3, r3 move N0/r4, r4 move N1/r5, r5 move N2/r6, r6 load-stack-arg-n #t, N3/r22, 0 load-stack-arg-n #t, N4/r23, 1 asl N5/r3, r3, 2 sub r1, r1, 24 move r3, N5/r3 move r4, N0/r4 move r5, N1/r5 move r6, N2/r6 move r7, N3/r22 move r8, N4/r23 call-alien {constant "primitive_alloc_s_r"}, 0 #() [80->90] (level:0) is red with stack state with #({basic-block #({tag 1:95}) 95 100}) add r1, r1, 24 move r3, r3 #({tag 1:95}) [95->100] (level:0) is #f with stack state #f #({basic-block #() 90 95}) preserve-registers-exit #() [90->95] (level:0) is red with stack state #f #() rts-and-drop 8 +++ ending code for primitive_allocate_filled +++ +++ Live variable scopes for primitive_allocate_filled +++ Start scope at 8 with frame for no variables End scope at 29 +++ No Source Code Locators for primitive_allocate_filled +++ +++ Exported function definition primitive_allocate_filled_in_leaf_pool +++ +++ starting code for primitive_allocate_filled_in_leaf_pool +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:100}) 100 115}) rem "This is a dummy first basic block." #({tag 2:100}) [100->115] (level:0) is #f with stack state #f #({basic-block #() 5 80}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->80] (level:0) is red with stack state with #({basic-block #() 80 90}) move r3, r3 move N0/r4, r4 move N1/r5, r5 move N2/r6, r6 load-stack-arg-n #t, N3/r22, 0 load-stack-arg-n #t, N4/r23, 1 asl N5/r3, r3, 2 sub r1, r1, 24 move r3, N5/r3 move r4, N0/r4 move r5, N1/r5 move r6, N2/r6 move r7, N3/r22 move r8, N4/r23 call-alien {constant "primitive_alloc_leaf_s_r"}, 0 #() [80->90] (level:0) is red with stack state with #({basic-block #({tag 1:95}) 95 100}) add r1, r1, 24 move r3, r3 #({tag 1:95}) [95->100] (level:0) is #f with stack state #f #({basic-block #() 90 95}) preserve-registers-exit #() [90->95] (level:0) is red with stack state #f #() rts-and-drop 8 +++ ending code for primitive_allocate_filled_in_leaf_pool +++ +++ Live variable scopes for primitive_allocate_filled_in_leaf_pool +++ Start scope at 8 with frame for no variables End scope at 29 +++ No Source Code Locators for primitive_allocate_filled_in_leaf_pool +++ +++ Exported function definition primitive_allocate_weak_in_awl_pool +++ +++ starting code for primitive_allocate_weak_in_awl_pool +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:110}) 110 125}) rem "This is a dummy first basic block." #({tag 2:110}) [110->125] (level:0) is #f with stack state #f #({basic-block #() 5 90}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->90] (level:0) is red with stack state with #({basic-block #() 90 100}) move r3, r3 move N0/r4, r4 move N1/r22, r5 move N2/r6, r6 load-stack-arg-n #t, N3/r23, 0 load-stack-arg-n #t, N4/r9, 1 load-stack-arg-n #t, N5/r5, 2 asl N6/r3, r3, 2 sub r1, r1, 24 move r3, N6/r3 move r4, N0/r4 move r5, N5/r5 move r6, N1/r22 move r7, N2/r6 move r8, N3/r23 move r9, N4/r9 call-alien {constant "primitive_alloc_weak_awl_s_r"}, 0 #() [90->100] (level:0) is red with stack state with #({basic-block #({tag 1:105}) 105 110}) add r1, r1, 24 move r3, r3 #({tag 1:105}) [105->110] (level:0) is #f with stack state #f #({basic-block #() 100 105}) preserve-registers-exit #() [100->105] (level:0) is red with stack state #f #() rts-and-drop 12 +++ ending code for primitive_allocate_weak_in_awl_pool +++ +++ Live variable scopes for primitive_allocate_weak_in_awl_pool +++ Start scope at 8 with frame for no variables End scope at 35 +++ No Source Code Locators for primitive_allocate_weak_in_awl_pool +++ +++ Exported function definition primitive_allocate_in_awl_pool +++ +++ starting code for primitive_allocate_in_awl_pool +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:110}) 110 125}) rem "This is a dummy first basic block." #({tag 2:110}) [110->125] (level:0) is #f with stack state #f #({basic-block #() 5 90}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->90] (level:0) is red with stack state with #({basic-block #() 90 100}) move r3, r3 move N0/r4, r4 move N1/r22, r5 move N2/r6, r6 load-stack-arg-n #t, N3/r23, 0 load-stack-arg-n #t, N4/r9, 1 load-stack-arg-n #t, N5/r5, 2 asl N6/r3, r3, 2 sub r1, r1, 24 move r3, N6/r3 move r4, N0/r4 move r5, N5/r5 move r6, N1/r22 move r7, N2/r6 move r8, N3/r23 move r9, N4/r9 call-alien {constant "primitive_alloc_exact_awl_s_r"}, 0 #() [90->100] (level:0) is red with stack state with #({basic-block #({tag 1:105}) 105 110}) add r1, r1, 24 move r3, r3 #({tag 1:105}) [105->110] (level:0) is #f with stack state #f #({basic-block #() 100 105}) preserve-registers-exit #() [100->105] (level:0) is red with stack state #f #() rts-and-drop 12 +++ ending code for primitive_allocate_in_awl_pool +++ +++ Live variable scopes for primitive_allocate_in_awl_pool +++ Start scope at 8 with frame for no variables End scope at 35 +++ No Source Code Locators for primitive_allocate_in_awl_pool +++ +++ Exported function definition primitive_allocate_wrapper +++ +++ starting code for primitive_allocate_wrapper +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:100}) 100 115}) rem "This is a dummy first basic block." #({tag 2:100}) [100->115] (level:0) is #f with stack state #f #({basic-block #() 5 80}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->80] (level:0) is red with stack state with #({basic-block #() 80 90}) move r3, r3 move N0/r4, r4 move N1/r5, r5 move N2/r6, r6 load-stack-arg-n #t, N3/r22, 0 load-stack-arg-n #t, N4/r23, 1 asl N5/r3, r3, 2 sub r1, r1, 24 move r3, N5/r3 move r4, N0/r4 move r5, N1/r5 move r6, N2/r6 move r7, N3/r22 move r8, N4/r23 call-alien {constant "primitive_alloc_wrapper_s_r"}, 0 #() [80->90] (level:0) is red with stack state with #({basic-block #({tag 1:95}) 95 100}) add r1, r1, 24 move r3, r3 #({tag 1:95}) [95->100] (level:0) is #f with stack state #f #({basic-block #() 90 95}) preserve-registers-exit #() [90->95] (level:0) is red with stack state #f #() rts-and-drop 8 +++ ending code for primitive_allocate_wrapper +++ +++ Live variable scopes for primitive_allocate_wrapper +++ Start scope at 8 with frame for no variables End scope at 29 +++ No Source Code Locators for primitive_allocate_wrapper +++ +++ Exported function definition primitive_untraced_allocate +++ +++ starting code for primitive_untraced_allocate +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:35}) 35 50}) rem "This is a dummy first basic block." #({tag 2:35}) [35->50] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}) sub r1, r1, 24 move r3, r3 call-alien {constant "dylan__malloc__misc"}, 0 #() [20->25] (level:0) is red with stack state with #({basic-block #({tag 1:30}) 30 35}) add r1, r1, 24 #({tag 1:30}) [30->35] (level:0) is #f with stack state #f #({basic-block #() 25 30}) preserve-registers-exit #() [25->30] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_untraced_allocate +++ +++ Live variable scopes for primitive_untraced_allocate +++ Start scope at 8 with frame for no variables End scope at 19 +++ No Source Code Locators for primitive_untraced_allocate +++ +++ Exported function definition primitive_byte_allocate +++ +++ starting code for primitive_byte_allocate +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "primitive_error"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_byte_allocate +++ +++ Live variable scopes for primitive_byte_allocate +++ Start scope at 8 with frame for no variables End scope at 15 +++ No Source Code Locators for primitive_byte_allocate +++ +++ Exported function definition primitive_byte_allocate_filled +++ +++ starting code for primitive_byte_allocate_filled +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:120}) 120 135}) rem "This is a dummy first basic block." #({tag 2:120}) [120->135] (level:0) is #f with stack state #f #({basic-block #() 5 100}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->100] (level:0) is red with stack state with #({basic-block #() 100 110}) move r3, r3 move N0/r21, r4 move N1/r4, r5 move N2/r5, r6 load-stack-arg-n #t, N3/r6, 0 load-stack-arg-n #t, N4/r22, 1 load-stack-arg-n #t, N5/r23, 2 asl r3, r3, 2 add r3, r3, N0/r21 add r3, r3, 3 and r3, r3, -4 sub r1, r1, 24 move r3, r3 move r4, N1/r4 move r5, N2/r5 move r6, N3/r6 move r7, N4/r22 move r8, N5/r23 call-alien {constant "primitive_alloc_leaf_s_rb"}, 0 #() [100->110] (level:0) is red with stack state with #({basic-block #({tag 1:115}) 115 120}) add r1, r1, 24 move r3, r3 #({tag 1:115}) [115->120] (level:0) is #f with stack state #f #({basic-block #() 110 115}) preserve-registers-exit #() [110->115] (level:0) is red with stack state #f #() rts-and-drop 12 +++ ending code for primitive_byte_allocate_filled +++ +++ Live variable scopes for primitive_byte_allocate_filled +++ Start scope at 8 with frame for no variables End scope at 43 +++ No Source Code Locators for primitive_byte_allocate_filled +++ +++ Exported function definition primitive_byte_allocate_filled_terminated +++ +++ starting code for primitive_byte_allocate_filled_terminated +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:125}) 125 140}) rem "This is a dummy first basic block." #({tag 2:125}) [125->140] (level:0) is #f with stack state #f #({basic-block #() 5 105}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->105] (level:0) is red with stack state with #({basic-block #() 105 115}) move r3, r3 move N0/r22, r4 move N1/r4, r5 rem "eliminated" load-stack-arg-n #t, N3/r23, 0 load-stack-arg-n #t, N4/r5, 1 load-stack-arg-n #t, N5/r6, 2 asl r3, r3, 2 add r3, r3, N0/r22 rem "eliminated" add r3, r3, 3 and r3, r3, -4 asr N7/r23, N3/r23, 2 sub r1, r1, 24 move r3, r3 move r4, N1/r4 move r5, N4/r5 move r6, N5/r6 move r7, N7/r23 call-alien {constant "primitive_alloc_leaf_rbfz"}, 0 #() [105->115] (level:0) is red with stack state with #({basic-block #({tag 1:120}) 120 125}) add r1, r1, 24 move r3, r3 #({tag 1:120}) [120->125] (level:0) is #f with stack state #f #({basic-block #() 115 120}) preserve-registers-exit #() [115->120] (level:0) is red with stack state #f #() rts-and-drop 12 +++ ending code for primitive_byte_allocate_filled_terminated +++ +++ Live variable scopes for primitive_byte_allocate_filled_terminated +++ Start scope at 8 with frame for no variables End scope at 41 +++ No Source Code Locators for primitive_byte_allocate_filled_terminated +++ +++ Exported function definition primitive_allocate_vector +++ +++ starting code for primitive_allocate_vector +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:80}) 80 95}) rem "This is a dummy first basic block." #({tag 2:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #() 5 55}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->55] (level:0) is red with stack state with #({basic-block #() 55 70}) move N1/r5, r3 asl N2/r3, N1/r5, 2 add N2/r3, N2/r3, 8 sub r1, r1, 24 move r3, N2/r3 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N1/r5 move r6, 1 move r7, {constant "KPunboundVKi"} call-alien {constant "primitive_alloc_rf"}, 0 #() [55->70] (level:0) is red with stack state with #({basic-block #({tag 1:75}) 75 80}) add r1, r1, 24 move G0/r3, r3 move r3, G0/r3 #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit #() [70->75] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_allocate_vector +++ +++ Live variable scopes for primitive_allocate_vector +++ Start scope at 8 with frame for no variables End scope at 35 +++ No Source Code Locators for primitive_allocate_vector +++ +++ Exported function definition primitive_vector +++ +++ starting code for primitive_vector +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state before #({basic-block #() 15 20}, {basic-block #({tag 1:25}) 25 30}) move N8/r3, r3 bgt {tag 1:25}, N8/r3, 2 #() [15->20] (level:0) is green with stack state before #({basic-block #() 20 25}, {basic-block #({tag 2:45}) 45 50}) bgt {tag 2:45}, N8/r3, 1 #() [20->25] (level:0) is green with stack state before #({basic-block #({tag 4:70}) 70 80}, {basic-block #({tag 3:60}) 60 65}) bgt {tag 3:60}, N8/r3, 0 #({tag 4:70}) [70->80] (level:0) is green with stack state before #({basic-block #() 80 85}, {basic-block #({tag 12:190}) 190 205}) load-address-of-stack-arg-n #f, N9/r23, 0 bne {tag 12:190}, N8/r3, 0 #() [80->85] (level:0) is green with stack state before #({basic-block #({tag 5:140}) 140 150}) move G10/r23, {constant "KPempty_vectorVKi"} #({tag 5:140}) [140->150] (level:0) is green with stack state before #({basic-block #({tag 10:150}) 150 155}) asl N0/r21, N8/r3, 2 move r3, G10/r23 #({tag 10:150}) [150->155] (level:0) is green with stack state #f #() rts-and-drop N0/r21 #({tag 1:25}) [25->30] (level:0) is green with stack state before #({basic-block #() 30 45}) adjust-stack 12 #() [30->45] (level:0) is green with stack state before #({basic-block #({tag 4:70}) 70 80}) store-stack-arg-n r4, 0 store-stack-arg-n r5, 1 store-stack-arg-n r6, 2 #() [205->210] (level:0) is #f with stack state #f #() bra {tag 4:70} #({tag 2:45}) [45->50] (level:0) is green with stack state before #({basic-block #() 50 60}) adjust-stack 8 #() [50->60] (level:0) is green with stack state before #({basic-block #({tag 4:70}) 70 80}) store-stack-arg-n r4, 0 store-stack-arg-n r5, 1 #() [210->215] (level:0) is #f with stack state #f #() bra {tag 4:70} #({tag 3:60}) [60->65] (level:0) is green with stack state before #({basic-block #() 65 70}) adjust-stack 4 #() [65->70] (level:0) is green with stack state before #({basic-block #({tag 4:70}) 70 80}) store-stack-arg-n r4, 0 #() [215->220] (level:0) is #f with stack state #f #() bra {tag 4:70} #({tag 12:190}) [190->205] (level:0) is #f with stack state #f #({basic-block #({tag 7:155}) 155 165}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 7:155}) [155->165] (level:0) is brown with stack state with #({basic-block #({tag 6:85}) 85 130}) move N1/NSPILL-0, N8/r3 move N4/r23, N9/r23 #({tag 6:85}) [85->130] (level:0) is red with stack state with #({basic-block #() 130 140}) asl N7/r3, N1/NSPILL-0, 2 add N7/r3, N7/r3, 8 sub r1, r1, 24 move r3, N7/r3 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N1/NSPILL-0 move r6, 1 move r7, N4/r23 call-alien {constant "primitive_alloc_rt"}, 0 #() [130->140] (level:0) is red with stack state with #({basic-block #({tag 8:165}) 165 175}) add r1, r1, 24 move G6/r23, r3 #({tag 8:165}) [165->175] (level:0) is yellow with stack state with #({basic-block #({tag 9:175}) 175 185}) move N8/r3, N1/NSPILL-0 move G10/r23, G6/r23 #({tag 9:175}) [175->185] (level:0) is green with stack state with #({basic-block #({tag 11:185}) 185 190}) asl N0/r21, N8/r3, 2 move r3, G10/r23 #({tag 11:185}) [185->190] (level:0) is #f with stack state #f #({basic-block #({tag 10:150}) 150 155}) preserve-registers-exit #() [220->225] (level:0) is #f with stack state #f #() bra {tag 10:150} +++ ending code for primitive_vector +++ +++ Frame sizes for primitive_vector: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_vector +++ Start scope at 62 with frame for no variables End scope at 101 +++ No Source Code Locators for primitive_vector +++ +++ Exported function definition primitive_copy_vector +++ +++ starting code for primitive_copy_vector +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state before #({basic-block #() 25 30}, {basic-block #({tag 8:100}) 100 115}) move G6/r4, r3 ld N5/r3, G6/r4, 4 sub N5/r3, N5/r3, 1 bne {tag 8:100}, N5/r3, 0 #() [25->30] (level:0) is green with stack state before #({basic-block #({tag 1:70}) 65 70}) move G7/r3, {constant "KPempty_vectorVKi"} #({tag 1:70}) [65->70] (level:0) is green with stack state before #({basic-block #({tag 1:70}, {tag 6:70}) 70 75}) move r3, G7/r3 #({tag 1:70}, {tag 6:70}) [70->75] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 8:100}) [100->115] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 75 85}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:30}) [75->85] (level:0) is brown with stack state with #({basic-block #({tag 3:30}, {tag 2:30}) 30 55}) move N1/r3, N5/r3 move G3/r4, G6/r4 #({tag 3:30}, {tag 2:30}) [30->55] (level:0) is red with stack state with #({basic-block #() 55 65}) add N1/r3, N1/r3, 8 sub r1, r1, 24 move r3, N1/r3 move r4, G3/r4 call-alien {constant "primitive_copy"}, 0 #() [55->65] (level:0) is red with stack state with #({basic-block #({tag 4:95}) 85 90}) add r1, r1, 24 move G4/r3, r3 #({tag 4:95}) [85->90] (level:0) is yellow with stack state with #({basic-block #({tag 4:95}, {tag 5:95}) 90 95}) move G7/r3, G4/r3 #({tag 4:95}, {tag 5:95}) [90->95] (level:0) is green with stack state with #({basic-block #({tag 5:95}, {tag 4:95}, {tag 7:95}) 95 100}) move r3, G7/r3 #({tag 5:95}, {tag 4:95}, {tag 7:95}) [95->100] (level:0) is #f with stack state #f #({basic-block #({tag 1:70}, {tag 6:70}) 70 75}) preserve-registers-exit #() [115->120] (level:0) is #f with stack state #f #() bra {tag 1:70} +++ ending code for primitive_copy_vector +++ +++ Live variable scopes for primitive_copy_vector +++ Start scope at 24 with frame for no variables End scope at 37 +++ No Source Code Locators for primitive_copy_vector +++ +++ Exported function definition primitive_make_box +++ +++ starting code for primitive_make_box +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:60}) 60 75}) rem "This is a dummy first basic block." #({tag 2:60}) [60->75] (level:0) is #f with stack state #f #({basic-block #() 5 35}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->35] (level:0) is red with stack state with #({basic-block #() 35 50}) move G0/r5, r3 sub r1, r1, 24 move r3, 8 move r4, {constant "KLtraceable_value_cellGVKiW"} move r5, G0/r5 call-alien {constant "primitive_alloc_s1"}, 0 #() [35->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add r1, r1, 24 move G1/r3, r3 move r3, G1/r3 #({tag 1:55}) [55->60] (level:0) is #f with stack state #f #({basic-block #() 50 55}) preserve-registers-exit #() [50->55] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_box +++ +++ Live variable scopes for primitive_make_box +++ Start scope at 8 with frame for no variables End scope at 27 +++ No Source Code Locators for primitive_make_box +++ +++ Exported function definition primitive_make_raw_box +++ +++ starting code for primitive_make_raw_box +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:60}) 60 75}) rem "This is a dummy first basic block." #({tag 2:60}) [60->75] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 50}) move N0/NSPILL-0, r3 sub r1, r1, 24 move r3, 8 move r4, {constant "KLuntraceable_value_cellGVKiW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [30->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add r1, r1, 24 move G1/r3, r3 st N0/NSPILL-0, G1/r3, 4 move r3, G1/r3 #({tag 1:55}) [55->60] (level:0) is #f with stack state #f #({basic-block #() 50 55}) preserve-registers-exit #() [50->55] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_raw_box +++ +++ Frame sizes for primitive_make_raw_box: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_make_raw_box +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for primitive_make_raw_box +++ +++ Exported function definition primitive_make_single_float_box +++ +++ starting code for primitive_make_single_float_box +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:60}) 60 75}) rem "This is a dummy first basic block." #({tag 2:60}) [60->75] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 50}) fmove SF0/SFSPILL-0, f1 sub r1, r1, 24 move r3, 8 move r4, {constant "KLuntraceable_value_cellGVKiW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [30->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add r1, r1, 24 move G1/r3, r3 fst SF0/SFSPILL-0, G1/r3, 4 move r3, G1/r3 #({tag 1:55}) [55->60] (level:0) is #f with stack state #f #({basic-block #() 50 55}) preserve-registers-exit #() [50->55] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_single_float_box +++ +++ Frame sizes for primitive_make_single_float_box: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_make_single_float_box +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for primitive_make_single_float_box +++ +++ Exported function definition primitive_make_double_float_box +++ +++ starting code for primitive_make_double_float_box +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:60}) 60 75}) rem "This is a dummy first basic block." #({tag 2:60}) [60->75] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 50}) dmove DF0/DFSPILL-0, f1 sub r1, r1, 24 move r3, 12 move r4, {constant "KLuntraceable_double_value_cellGVKiW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [30->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add r1, r1, 24 move G1/r3, r3 dst DF0/DFSPILL-0, G1/r3, 4 move r3, G1/r3 #({tag 1:55}) [55->60] (level:0) is #f with stack state #f #({basic-block #() 50 55}) preserve-registers-exit #() [50->55] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_double_float_box +++ +++ Frame sizes for primitive_make_double_float_box: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_make_double_float_box +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for primitive_make_double_float_box +++ +++ Exported function definition primitive_make_closure +++ +++ starting code for primitive_make_closure +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:80}) 80 95}) rem "This is a dummy first basic block." #({tag 2:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #() 5 55}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->55] (level:0) is red with stack state with #({basic-block #() 55 70}) move G1/r6, r3 move N0/r4, r4 asl N4/r3, N0/r4, 2 add N3/r3, N4/r3, 20 sub r1, r1, 24 move r3, N3/r3 move r4, N0/r4 move r5, 4 move r6, G1/r6 call-alien {constant "primitive_copy_r"}, 0 #() [55->70] (level:0) is red with stack state with #({basic-block #({tag 1:75}) 75 80}) add r1, r1, 24 move G2/r3, r3 move r3, G2/r3 #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit #() [70->75] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_closure +++ +++ Live variable scopes for primitive_make_closure +++ Start scope at 8 with frame for no variables End scope at 27 +++ No Source Code Locators for primitive_make_closure +++ +++ Exported function definition primitive_make_keyword_closure +++ +++ starting code for primitive_make_keyword_closure +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:80}) 80 95}) rem "This is a dummy first basic block." #({tag 2:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #() 5 55}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->55] (level:0) is red with stack state with #({basic-block #() 55 70}) move G1/r6, r3 move N0/r4, r4 asl N4/r3, N0/r4, 2 add N3/r3, N4/r3, 28 sub r1, r1, 24 move r3, N3/r3 move r4, N0/r4 move r5, 6 move r6, G1/r6 call-alien {constant "primitive_copy_r"}, 0 #() [55->70] (level:0) is red with stack state with #({basic-block #({tag 1:75}) 75 80}) add r1, r1, 24 move G2/r3, r3 move r3, G2/r3 #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit #() [70->75] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_keyword_closure +++ +++ Live variable scopes for primitive_make_keyword_closure +++ Start scope at 8 with frame for no variables End scope at 27 +++ No Source Code Locators for primitive_make_keyword_closure +++ +++ Exported function definition primitive_make_closure_with_signature +++ +++ starting code for primitive_make_closure_with_signature +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:90}) 90 105}) rem "This is a dummy first basic block." #({tag 2:90}) [90->105] (level:0) is #f with stack state #f #({basic-block #() 5 60}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->60] (level:0) is red with stack state with #({basic-block #() 60 80}) move G1/r6, r3 move G3/GSPILL-0, r4 move N0/r5, r5 asl N5/r3, N0/r5, 2 add N4/r3, N5/r3, 20 sub r1, r1, 24 move r3, N4/r3 move r4, N0/r5 move r5, 4 move r6, G1/r6 call-alien {constant "primitive_copy_r"}, 0 #() [60->80] (level:0) is red with stack state with #({basic-block #({tag 1:85}) 85 90}) add r1, r1, 24 move G2/r3, r3 move r3, G2/r3 st G3/GSPILL-0, r3, 8 #({tag 1:85}) [85->90] (level:0) is #f with stack state #f #({basic-block #() 80 85}) preserve-registers-exit #() [80->85] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_closure_with_signature +++ +++ Frame sizes for primitive_make_closure_with_signature: GC: 1, NC: 0 +++ +++ Live variable scopes for primitive_make_closure_with_signature +++ Start scope at 8 with frame for no variables End scope at 37 +++ No Source Code Locators for primitive_make_closure_with_signature +++ +++ Exported function definition primitive_make_keyword_closure_with_signature +++ +++ starting code for primitive_make_keyword_closure_with_signature +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:90}) 90 105}) rem "This is a dummy first basic block." #({tag 2:90}) [90->105] (level:0) is #f with stack state #f #({basic-block #() 5 60}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->60] (level:0) is red with stack state with #({basic-block #() 60 80}) move G1/r6, r3 move G3/GSPILL-0, r4 move N0/r5, r5 asl N5/r3, N0/r5, 2 add N4/r3, N5/r3, 28 sub r1, r1, 24 move r3, N4/r3 move r4, N0/r5 move r5, 6 move r6, G1/r6 call-alien {constant "primitive_copy_r"}, 0 #() [60->80] (level:0) is red with stack state with #({basic-block #({tag 1:85}) 85 90}) add r1, r1, 24 move G2/r3, r3 move r3, G2/r3 st G3/GSPILL-0, r3, 8 #({tag 1:85}) [85->90] (level:0) is #f with stack state #f #({basic-block #() 80 85}) preserve-registers-exit #() [80->85] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_keyword_closure_with_signature +++ +++ Frame sizes for primitive_make_keyword_closure_with_signature: GC: 1, NC: 0 +++ +++ Live variable scopes for primitive_make_keyword_closure_with_signature +++ Start scope at 8 with frame for no variables End scope at 37 +++ No Source Code Locators for primitive_make_keyword_closure_with_signature +++ +++ Exported function definition primitive_initialize_closure +++ +++ starting code for primitive_initialize_closure +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 45}, {basic-block #({tag 1:125}) 125 125}) move G2/r23, r3 move N0/r4, r4 move N1/r21, 0 beq {tag 1:125}, N0/r4, 0 #() [25->45] (level:0) is green with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 2:50}) 50 70}) move N6/r21, N1/r21 add N4/r23, G2/r23, 20 move N5/r22, N0/r4 bgt {tag 2:50}, N5/r22, 1 #() [45->50] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 90}, {basic-block #({tag 3:70}) 70 85}) bgt {tag 3:70}, N5/r22, 0 #({tag 4:85}) [85->90] (level:0) is green with stack state #f #({basic-block #() 90 125}, {basic-block #({tag 1:125}) 125 125}) ble {tag 1:125}, N0/r4, 2 #() [90->125] (level:0) is green with stack state #f #({basic-block #({tag 1:125}) 125 125}) load-address-of-stack-arg-n #f, N3/r20, 0 copy-words-down-w N4/r23, N3/r20, N5/r22 move N7/r4, N0/r4 sub N7/r4, N7/r4, 2 asl N7/r4, N7/r4, 2 move N1/r21, N6/r21 add N1/r21, N1/r21, N7/r4 #({tag 1:125}) [125->125] (level:0) is green with stack state #f #({basic-block #({tag 1:125}) 125 130}) #({tag 1:125}) [125->130] (level:0) is green with stack state #f #() rts-and-drop N1/r21 #({tag 2:50}) [50->70] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 90}) st r5, N4/r23, 0 st r6, N4/r23, 4 add N4/r23, N4/r23, 8 sub N5/r22, N5/r22, 2 #() [130->135] (level:0) is #f with stack state #f #() bra {tag 4:85} #({tag 3:70}) [70->85] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 90}) st r5, N4/r23, 0 add N4/r23, N4/r23, 4 sub N5/r22, N5/r22, 1 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 4:85} +++ ending code for primitive_initialize_closure +++ +++ No Source Code Locators for primitive_initialize_closure +++ +++ Exported function definition primitive_initialize_keyword_closure +++ +++ starting code for primitive_initialize_keyword_closure +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 45}, {basic-block #({tag 1:125}) 125 125}) move G2/r23, r3 move N0/r4, r4 move N1/r21, 0 beq {tag 1:125}, N0/r4, 0 #() [25->45] (level:0) is green with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 2:50}) 50 70}) move N6/r21, N1/r21 add N4/r23, G2/r23, 28 move N5/r22, N0/r4 bgt {tag 2:50}, N5/r22, 1 #() [45->50] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 90}, {basic-block #({tag 3:70}) 70 85}) bgt {tag 3:70}, N5/r22, 0 #({tag 4:85}) [85->90] (level:0) is green with stack state #f #({basic-block #() 90 125}, {basic-block #({tag 1:125}) 125 125}) ble {tag 1:125}, N0/r4, 2 #() [90->125] (level:0) is green with stack state #f #({basic-block #({tag 1:125}) 125 125}) load-address-of-stack-arg-n #f, N3/r20, 0 copy-words-down-w N4/r23, N3/r20, N5/r22 move N7/r4, N0/r4 sub N7/r4, N7/r4, 2 asl N7/r4, N7/r4, 2 move N1/r21, N6/r21 add N1/r21, N1/r21, N7/r4 #({tag 1:125}) [125->125] (level:0) is green with stack state #f #({basic-block #({tag 1:125}) 125 130}) #({tag 1:125}) [125->130] (level:0) is green with stack state #f #() rts-and-drop N1/r21 #({tag 2:50}) [50->70] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 90}) st r5, N4/r23, 0 st r6, N4/r23, 4 add N4/r23, N4/r23, 8 sub N5/r22, N5/r22, 2 #() [130->135] (level:0) is #f with stack state #f #() bra {tag 4:85} #({tag 3:70}) [70->85] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 90}) st r5, N4/r23, 0 add N4/r23, N4/r23, 4 sub N5/r22, N5/r22, 1 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 4:85} +++ ending code for primitive_initialize_keyword_closure +++ +++ No Source Code Locators for primitive_initialize_keyword_closure +++ +++ Exported function definition primitive_make_closure_with_environment +++ +++ starting code for primitive_make_closure_with_environment +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 6:210}) 210 225}) rem "This is a dummy first basic block." #({tag 6:210}) [210->225] (level:0) is #f with stack state #f #({basic-block #() 5 65}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->65] (level:0) is red with stack state with #({basic-block #() 65 95}) move G2/r23, r3 move N0/NSPILL-0, r4 push r5 push r6 asl N10/r3, N0/NSPILL-0, 2 add N9/r3, N10/r3, 20 sub r1, r1, 24 move r3, N9/r3 move r4, N0/NSPILL-0 move r5, 4 move r6, G2/r23 call-alien {constant "primitive_copy_r"}, 0 #() [65->95] (level:0) is red with stack state with #({basic-block #() 95 115}, {basic-block #({tag 1:205}) 195 200}) add r1, r1, 24 move G3/r3, r3 pop r6 pop r5 move N1/r21, 0 beq {tag 1:205}, N0/NSPILL-0, 0 #() [95->115] (level:0) is red with stack state with #({basic-block #() 115 120}, {basic-block #({tag 2:120}) 120 140}) move N7/r21, N1/r21 add N5/r23, G3/r3, 20 move N6/r22, N0/NSPILL-0 bgt {tag 2:120}, N6/r22, 1 #() [115->120] (level:0) is red with stack state with #({basic-block #({tag 4:155}) 155 160}, {basic-block #({tag 3:140}) 140 155}) bgt {tag 3:140}, N6/r22, 0 #({tag 4:155}) [155->160] (level:0) is red with stack state with #({basic-block #() 160 195}, {basic-block #({tag 1:205}) 195 200}) ble {tag 1:205}, N0/NSPILL-0, 2 #() [160->195] (level:0) is red with stack state with #({basic-block #({tag 1:205}) 195 200}) load-address-of-stack-arg-n #t, N4/r20, 0 copy-words-down-w N5/r23, N4/r20, N6/r22 move N8/r23, N0/NSPILL-0 sub N8/r23, N8/r23, 2 asl N8/r23, N8/r23, 2 move N1/r21, N7/r21 add N1/r21, N1/r21, N8/r23 #({tag 1:205}) [195->200] (level:0) is red with stack state with #({basic-block #({tag 1:205}, {tag 5:205}) 205 210}) move r3, G3/r3 #({tag 1:205}, {tag 5:205}) [205->210] (level:0) is #f with stack state #f #({basic-block #() 200 205}) preserve-registers-exit #() [200->205] (level:0) is red with stack state #f #() rts-and-drop N1/r21 #({tag 2:120}) [120->140] (level:0) is red with stack state with #({basic-block #({tag 4:155}) 155 160}) st r5, N5/r23, 0 st r6, N5/r23, 4 add N5/r23, N5/r23, 8 sub N6/r22, N6/r22, 2 #() [225->230] (level:0) is #f with stack state #f #() bra {tag 4:155} #({tag 3:140}) [140->155] (level:0) is red with stack state with #({basic-block #({tag 4:155}) 155 160}) st r5, N5/r23, 0 add N5/r23, N5/r23, 4 sub N6/r22, N6/r22, 1 #() [230->235] (level:0) is #f with stack state #f #() bra {tag 4:155} +++ ending code for primitive_make_closure_with_environment +++ +++ Frame sizes for primitive_make_closure_with_environment: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_make_closure_with_environment +++ Start scope at 8 with frame for no variables End scope at 101 +++ No Source Code Locators for primitive_make_closure_with_environment +++ +++ Exported function definition primitive_make_keyword_closure_with_environment +++ +++ starting code for primitive_make_keyword_closure_with_environment +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 6:210}) 210 225}) rem "This is a dummy first basic block." #({tag 6:210}) [210->225] (level:0) is #f with stack state #f #({basic-block #() 5 65}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->65] (level:0) is red with stack state with #({basic-block #() 65 95}) move G2/r23, r3 move N0/NSPILL-0, r4 push r5 push r6 asl N10/r3, N0/NSPILL-0, 2 add N9/r3, N10/r3, 28 sub r1, r1, 24 move r3, N9/r3 move r4, N0/NSPILL-0 move r5, 6 move r6, G2/r23 call-alien {constant "primitive_copy_r"}, 0 #() [65->95] (level:0) is red with stack state with #({basic-block #() 95 115}, {basic-block #({tag 1:205}) 195 200}) add r1, r1, 24 move G3/r3, r3 pop r6 pop r5 move N1/r21, 0 beq {tag 1:205}, N0/NSPILL-0, 0 #() [95->115] (level:0) is red with stack state with #({basic-block #() 115 120}, {basic-block #({tag 2:120}) 120 140}) move N7/r21, N1/r21 add N5/r23, G3/r3, 28 move N6/r22, N0/NSPILL-0 bgt {tag 2:120}, N6/r22, 1 #() [115->120] (level:0) is red with stack state with #({basic-block #({tag 4:155}) 155 160}, {basic-block #({tag 3:140}) 140 155}) bgt {tag 3:140}, N6/r22, 0 #({tag 4:155}) [155->160] (level:0) is red with stack state with #({basic-block #() 160 195}, {basic-block #({tag 1:205}) 195 200}) ble {tag 1:205}, N0/NSPILL-0, 2 #() [160->195] (level:0) is red with stack state with #({basic-block #({tag 1:205}) 195 200}) load-address-of-stack-arg-n #t, N4/r20, 0 copy-words-down-w N5/r23, N4/r20, N6/r22 move N8/r23, N0/NSPILL-0 sub N8/r23, N8/r23, 2 asl N8/r23, N8/r23, 2 move N1/r21, N7/r21 add N1/r21, N1/r21, N8/r23 #({tag 1:205}) [195->200] (level:0) is red with stack state with #({basic-block #({tag 1:205}, {tag 5:205}) 205 210}) move r3, G3/r3 #({tag 1:205}, {tag 5:205}) [205->210] (level:0) is #f with stack state #f #({basic-block #() 200 205}) preserve-registers-exit #() [200->205] (level:0) is red with stack state #f #() rts-and-drop N1/r21 #({tag 2:120}) [120->140] (level:0) is red with stack state with #({basic-block #({tag 4:155}) 155 160}) st r5, N5/r23, 0 st r6, N5/r23, 4 add N5/r23, N5/r23, 8 sub N6/r22, N6/r22, 2 #() [225->230] (level:0) is #f with stack state #f #() bra {tag 4:155} #({tag 3:140}) [140->155] (level:0) is red with stack state with #({basic-block #({tag 4:155}) 155 160}) st r5, N5/r23, 0 add N5/r23, N5/r23, 4 sub N6/r22, N6/r22, 1 #() [230->235] (level:0) is #f with stack state #f #() bra {tag 4:155} +++ ending code for primitive_make_keyword_closure_with_environment +++ +++ Frame sizes for primitive_make_keyword_closure_with_environment: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_make_keyword_closure_with_environment +++ Start scope at 8 with frame for no variables End scope at 101 +++ No Source Code Locators for primitive_make_keyword_closure_with_environment +++ +++ Exported function definition primitive_make_closure_with_environment_signature +++ +++ starting code for primitive_make_closure_with_environment_signature +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 5:185}) 185 200}) rem "This is a dummy first basic block." #({tag 5:185}) [185->200] (level:0) is #f with stack state #f #({basic-block #() 5 65}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->65] (level:0) is red with stack state with #({basic-block #() 65 90}) move G2/r23, r3 move G3/GSPILL-0, r4 move N0/NSPILL-0, r5 push r6 asl N11/r3, N0/NSPILL-0, 2 add N10/r3, N11/r3, 20 sub r1, r1, 24 move r3, N10/r3 move r4, N0/NSPILL-0 move r5, 4 move r6, G2/r23 call-alien {constant "primitive_copy_r"}, 0 #() [65->90] (level:0) is red with stack state with #({basic-block #() 90 110}, {basic-block #({tag 1:165}) 165 175}) add r1, r1, 24 move G4/r3, r3 pop r6 move N1/r21, 0 beq {tag 1:165}, N0/NSPILL-0, 0 #() [90->110] (level:0) is red with stack state with #({basic-block #({tag 3:125}) 125 130}, {basic-block #({tag 2:110}) 110 125}) move N8/r21, N1/r21 add N6/r22, G4/r3, 20 move N7/r23, N0/NSPILL-0 bgt {tag 2:110}, N7/r23, 0 #({tag 3:125}) [125->130] (level:0) is red with stack state with #({basic-block #() 130 165}, {basic-block #({tag 1:165}) 165 175}) ble {tag 1:165}, N0/NSPILL-0, 1 #() [130->165] (level:0) is red with stack state with #({basic-block #({tag 1:165}) 165 175}) load-address-of-stack-arg-n #t, N5/r20, 0 copy-words-down-w N6/r22, N5/r20, N7/r23 move N9/r23, N0/NSPILL-0 sub N9/r23, N9/r23, 1 asl N9/r23, N9/r23, 2 move N1/r21, N8/r21 add N1/r21, N1/r21, N9/r23 #({tag 1:165}) [165->175] (level:0) is red with stack state with #({basic-block #({tag 4:180}) 180 185}) move r3, G4/r3 st G3/GSPILL-0, r3, 8 #({tag 4:180}) [180->185] (level:0) is #f with stack state #f #({basic-block #() 175 180}) preserve-registers-exit #() [175->180] (level:0) is red with stack state #f #() rts-and-drop N1/r21 #({tag 2:110}) [110->125] (level:0) is red with stack state with #({basic-block #({tag 3:125}) 125 130}) st r6, N6/r22, 0 add N6/r22, N6/r22, 4 sub N7/r23, N7/r23, 1 #() [200->205] (level:0) is #f with stack state #f #() bra {tag 3:125} +++ ending code for primitive_make_closure_with_environment_signature +++ +++ Frame sizes for primitive_make_closure_with_environment_signature: GC: 1, NC: 1 +++ +++ Live variable scopes for primitive_make_closure_with_environment_signature +++ Start scope at 8 with frame for no variables End scope at 97 +++ No Source Code Locators for primitive_make_closure_with_environment_signature +++ +++ Exported function definition primitive_make_keyword_closure_with_environment_signature +++ +++ starting code for primitive_make_keyword_closure_with_environment_signature +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 5:185}) 185 200}) rem "This is a dummy first basic block." #({tag 5:185}) [185->200] (level:0) is #f with stack state #f #({basic-block #() 5 65}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->65] (level:0) is red with stack state with #({basic-block #() 65 90}) move G2/r23, r3 move G3/GSPILL-0, r4 move N0/NSPILL-0, r5 push r6 asl N11/r3, N0/NSPILL-0, 2 add N10/r3, N11/r3, 28 sub r1, r1, 24 move r3, N10/r3 move r4, N0/NSPILL-0 move r5, 6 move r6, G2/r23 call-alien {constant "primitive_copy_r"}, 0 #() [65->90] (level:0) is red with stack state with #({basic-block #() 90 110}, {basic-block #({tag 1:165}) 165 175}) add r1, r1, 24 move G4/r3, r3 pop r6 move N1/r21, 0 beq {tag 1:165}, N0/NSPILL-0, 0 #() [90->110] (level:0) is red with stack state with #({basic-block #({tag 3:125}) 125 130}, {basic-block #({tag 2:110}) 110 125}) move N8/r21, N1/r21 add N6/r22, G4/r3, 28 move N7/r23, N0/NSPILL-0 bgt {tag 2:110}, N7/r23, 0 #({tag 3:125}) [125->130] (level:0) is red with stack state with #({basic-block #() 130 165}, {basic-block #({tag 1:165}) 165 175}) ble {tag 1:165}, N0/NSPILL-0, 1 #() [130->165] (level:0) is red with stack state with #({basic-block #({tag 1:165}) 165 175}) load-address-of-stack-arg-n #t, N5/r20, 0 copy-words-down-w N6/r22, N5/r20, N7/r23 move N9/r23, N0/NSPILL-0 sub N9/r23, N9/r23, 1 asl N9/r23, N9/r23, 2 move N1/r21, N8/r21 add N1/r21, N1/r21, N9/r23 #({tag 1:165}) [165->175] (level:0) is red with stack state with #({basic-block #({tag 4:180}) 180 185}) move r3, G4/r3 st G3/GSPILL-0, r3, 8 #({tag 4:180}) [180->185] (level:0) is #f with stack state #f #({basic-block #() 175 180}) preserve-registers-exit #() [175->180] (level:0) is red with stack state #f #() rts-and-drop N1/r21 #({tag 2:110}) [110->125] (level:0) is red with stack state with #({basic-block #({tag 3:125}) 125 130}) st r6, N6/r22, 0 add N6/r22, N6/r22, 4 sub N7/r23, N7/r23, 1 #() [200->205] (level:0) is #f with stack state #f #() bra {tag 3:125} +++ ending code for primitive_make_keyword_closure_with_environment_signature +++ +++ Frame sizes for primitive_make_keyword_closure_with_environment_signature: GC: 1, NC: 1 +++ +++ Live variable scopes for primitive_make_keyword_closure_with_environment_signature +++ Start scope at 8 with frame for no variables End scope at 97 +++ No Source Code Locators for primitive_make_keyword_closure_with_environment_signature +++ +++ Exported function definition primitive_make_method_with_signature +++ +++ starting code for primitive_make_method_with_signature +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:65}) 65 80}) rem "This is a dummy first basic block." #({tag 2:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #() 5 35}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->35] (level:0) is red with stack state with #({basic-block #() 35 55}) move G0/r3, r3 move G1/GSPILL-0, r4 sub r1, r1, 24 move r3, 16 move r4, G0/r3 call-alien {constant "primitive_copy"}, 0 #() [35->55] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 65}) add r1, r1, 24 move G2/r3, r3 move r3, G2/r3 st G1/GSPILL-0, r3, 8 #({tag 1:60}) [60->65] (level:0) is #f with stack state #f #({basic-block #() 55 60}) preserve-registers-exit #() [55->60] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_method_with_signature +++ +++ Frame sizes for primitive_make_method_with_signature: GC: 1, NC: 0 +++ +++ Live variable scopes for primitive_make_method_with_signature +++ Start scope at 8 with frame for no variables End scope at 31 +++ No Source Code Locators for primitive_make_method_with_signature +++ +++ Exported function definition primitive_make_keyword_method_with_signature +++ +++ starting code for primitive_make_keyword_method_with_signature +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:65}) 65 80}) rem "This is a dummy first basic block." #({tag 2:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #() 5 35}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->35] (level:0) is red with stack state with #({basic-block #() 35 55}) move G0/r3, r3 move G1/GSPILL-0, r4 sub r1, r1, 24 move r3, 24 move r4, G0/r3 call-alien {constant "primitive_copy"}, 0 #() [35->55] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 65}) add r1, r1, 24 move G2/r3, r3 move r3, G2/r3 st G1/GSPILL-0, r3, 8 #({tag 1:60}) [60->65] (level:0) is #f with stack state #f #({basic-block #() 55 60}) preserve-registers-exit #() [55->60] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_keyword_method_with_signature +++ +++ Frame sizes for primitive_make_keyword_method_with_signature: GC: 1, NC: 0 +++ +++ Live variable scopes for primitive_make_keyword_method_with_signature +++ Start scope at 8 with frame for no variables End scope at 31 +++ No Source Code Locators for primitive_make_keyword_method_with_signature +++ +++ Exported function definition primitive_strlen +++ +++ starting code for primitive_strlen +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #({tag 5:15}) 15 25}) move N0/r22, r3 move N1/r3, r3 #({tag 5:15}) [15->25] (level:1) is green with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:60}) 60 65}) ld N2/r23, N1/r3, 0 bnand {tag 1:60}, N2/r23, #ex00000000FF000000 #() [25->30] (level:1) is green with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 2:55}) 55 60}) bnand {tag 2:55}, N2/r23, 16711680 #() [30->35] (level:1) is green with stack state #f #({basic-block #() 35 45}, {basic-block #({tag 3:50}) 50 55}) bnand {tag 3:50}, N2/r23, 65280 #() [35->45] (level:1) is green with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 5:15}) 15 25}) add N1/r3, N1/r3, 4 band {tag 5:15}, N2/r23, 255 #() [45->50] (level:0) is green with stack state #f #({basic-block #({tag 3:50}) 50 55}) sub N1/r3, N1/r3, 3 #({tag 3:50}) [50->55] (level:0) is green with stack state #f #({basic-block #({tag 2:55}) 55 60}) add N1/r3, N1/r3, 1 #({tag 2:55}) [55->60] (level:0) is green with stack state #f #({basic-block #({tag 1:60}) 60 65}) add N1/r3, N1/r3, 1 #({tag 1:60}) [60->65] (level:0) is green with stack state #f #({basic-block #() 65 70}) sub r3, N1/r3, N0/r22 #() [65->70] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_strlen +++ +++ No Source Code Locators for primitive_strlen +++ +++ Exported function definition primitive_raw_as_string +++ +++ starting code for primitive_raw_as_string +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:105}) 105 120}) rem "This is a dummy first basic block." #({tag 2:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 65}) move N0/NSPILL-1, r3 call {constant "primitive_strlen"}, 1 #() [15->65] (level:0) is red with stack state with #({basic-block #() 65 95}) move N1/NSPILL-0, r3 add N2/r3, N1/NSPILL-0, 12 and N2/r3, N2/r3, -4 move N3/r5, N1/NSPILL-0 sub r1, r1, 24 move r3, N2/r3 move r4, {constant "KLbyte_stringGVKdW"} move r5, N3/r5 move r6, 1 call-alien {constant "primitive_alloc_leaf_r"}, 0 #() [65->95] (level:0) is red with stack state with #({basic-block #({tag 1:100}) 100 105}) add r1, r1, 24 move G5/r3, r3 add N4/r23, G5/r3, 8 add N1/NSPILL-0, N1/NSPILL-0, 1 copy-bytes-down N4/r23, N0/NSPILL-1, N1/NSPILL-0 move r3, G5/r3 #({tag 1:100}) [100->105] (level:0) is #f with stack state #f #({basic-block #() 95 100}) preserve-registers-exit #() [95->100] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_raw_as_string +++ +++ Frame sizes for primitive_raw_as_string: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_raw_as_string +++ Start scope at 8 with frame for no variables End scope at 127 +++ No Source Code Locators for primitive_raw_as_string +++ +++ Exported function definition primitive_random +++ +++ starting code for primitive_random +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "primitive_error"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_random +++ +++ Live variable scopes for primitive_random +++ Start scope at 8 with frame for no variables End scope at 15 +++ No Source Code Locators for primitive_random +++ +++ Exported function definition primitive_arg_error +++ +++ starting code for primitive_arg_error +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "primitive_error"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_arg_error +++ +++ Live variable scopes for primitive_arg_error +++ Start scope at 8 with frame for no variables End scope at 15 +++ No Source Code Locators for primitive_arg_error +++ +++ Exported function definition primitive_raw_as_single_float +++ +++ starting code for primitive_raw_as_single_float +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:65}) 65 80}) rem "This is a dummy first basic block." #({tag 2:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 55}) fmove SF0/SFSPILL-0, f1 sub r1, r1, 24 move r3, 8 move r4, {constant "KLsingle_floatGVKdW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [30->55] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 65}) add r1, r1, 24 move G2/r3, r3 move r3, G2/r3 move-from-sfreg N1/r23, SF0/SFSPILL-0 st N1/r23, r3, 4 #({tag 1:60}) [60->65] (level:0) is #f with stack state #f #({basic-block #() 55 60}) preserve-registers-exit #() [55->60] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_raw_as_single_float +++ +++ Frame sizes for primitive_raw_as_single_float: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_raw_as_single_float +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for primitive_raw_as_single_float +++ +++ Exported function definition primitive_raw_as_double_float +++ +++ starting code for primitive_raw_as_double_float +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:70}) 70 85}) rem "This is a dummy first basic block." #({tag 2:70}) [70->85] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 60}) dmove DF0/DFSPILL-0, f1 sub r1, r1, 24 move r3, 12 move r4, {constant "KLdouble_floatGVKdW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [30->60] (level:0) is red with stack state with #({basic-block #({tag 1:65}) 65 70}) add r1, r1, 24 move G3/r3, r3 move r3, G3/r3 move-from-dfreg N1/r22, N2/r23, DF0/DFSPILL-0 st N2/r23, r3, 4 st N1/r22, r3, 8 #({tag 1:65}) [65->70] (level:0) is #f with stack state #f #({basic-block #() 60 65}) preserve-registers-exit #() [60->65] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_raw_as_double_float +++ +++ Frame sizes for primitive_raw_as_double_float: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_raw_as_double_float +++ Start scope at 8 with frame for no variables End scope at 41 +++ No Source Code Locators for primitive_raw_as_double_float +++ +++ Exported function definition primitive_wrap_machine_word +++ +++ starting code for primitive_wrap_machine_word +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:60}) 60 75}) rem "This is a dummy first basic block." #({tag 2:60}) [60->75] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 50}) move N1/NSPILL-0, r3 sub r1, r1, 24 move r3, 8 move r4, {constant "KLmachine_wordGVKeW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [30->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add r1, r1, 24 move G0/r3, r3 move r3, G0/r3 st N1/NSPILL-0, r3, 4 #({tag 1:55}) [55->60] (level:0) is #f with stack state #f #({basic-block #() 50 55}) preserve-registers-exit #() [50->55] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_wrap_machine_word +++ +++ Frame sizes for primitive_wrap_machine_word: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_wrap_machine_word +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for primitive_wrap_machine_word +++ +++ Exported function definition primitive_wrap_c_pointer +++ +++ starting code for primitive_wrap_c_pointer +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:65}) 65 80}) rem "This is a dummy first basic block." #({tag 2:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #() 5 35}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->35] (level:0) is red with stack state with #({basic-block #() 35 55}) move G2/r3, r3 move N0/NSPILL-0, r4 sub r1, r1, 24 move r3, 8 move r4, G2/r3 call-alien {constant "primitive_alloc_leaf"}, 0 #() [35->55] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 65}) add r1, r1, 24 move G1/r3, r3 move r3, G1/r3 st N0/NSPILL-0, r3, 4 #({tag 1:60}) [60->65] (level:0) is #f with stack state #f #({basic-block #() 55 60}) preserve-registers-exit #() [55->60] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_wrap_c_pointer +++ +++ Frame sizes for primitive_wrap_c_pointer: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_wrap_c_pointer +++ Start scope at 8 with frame for no variables End scope at 31 +++ No Source Code Locators for primitive_wrap_c_pointer +++ +++ Exported function definition primitive_wrap_abstract_integer +++ +++ starting code for primitive_wrap_abstract_integer +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state before #({basic-block #() 10 15}, {basic-block #({tag 8:75}) 75 90}) bgt {tag 8:75}, r3, 536870911 #() [10->15] (level:0) is green with stack state before #({basic-block #() 15 25}, {basic-block #({tag 8:75}) 75 90}) blt {tag 8:75}, r3, -536870912 #() [15->25] (level:0) is green with stack state before #({basic-block #({tag 2:25}) 25 25}) asl r3, r3, 2 add r3, r3, 1 #({tag 2:25}) [25->25] (level:0) is green with stack state before #({basic-block #({tag 2:25}, {tag 6:25}) 25 30}) #({tag 2:25}, {tag 6:25}) [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 8:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 70 70}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:30}) [70->70] (level:0) is brown with stack state with #({basic-block #({tag 3:30}, {tag 1:30}) 30 55}) #({tag 3:30}, {tag 1:30}) [30->55] (level:0) is red with stack state with #({basic-block #() 55 70}) move N0/NSPILL-0, r3 sub r1, r1, 24 move r3, 8 move r4, {constant "KLmachine_wordGVKeW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [55->70] (level:0) is red with stack state with #({basic-block #({tag 4:70}) 70 70}) add r1, r1, 24 move r3, r3 st N0/NSPILL-0, r3, 4 #({tag 4:70}) [70->70] (level:0) is yellow with stack state with #({basic-block #({tag 4:70}, {tag 5:70}) 70 70}) #({tag 4:70}, {tag 5:70}) [70->70] (level:0) is green with stack state with #({basic-block #({tag 5:70}, {tag 4:70}, {tag 7:70}) 70 75}) #({tag 5:70}, {tag 4:70}, {tag 7:70}) [70->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:25}, {tag 6:25}) 25 30}) preserve-registers-exit #() [90->95] (level:0) is #f with stack state #f #() bra {tag 2:25} +++ ending code for primitive_wrap_abstract_integer +++ +++ Frame sizes for primitive_wrap_abstract_integer: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_wrap_abstract_integer +++ Start scope at 28 with frame for no variables End scope at 53 +++ No Source Code Locators for primitive_wrap_abstract_integer +++ +++ Exported function definition primitive_wrap_unsigned_abstract_integer +++ +++ starting code for primitive_wrap_unsigned_abstract_integer +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state before #({basic-block #() 10 20}, {basic-block #({tag 8:70}) 70 85}) bhi {tag 8:70}, r3, 536870911 #() [10->20] (level:0) is green with stack state before #({basic-block #({tag 2:20}) 20 20}) asl r3, r3, 2 add r3, r3, 1 #({tag 2:20}) [20->20] (level:0) is green with stack state before #({basic-block #({tag 2:20}, {tag 6:20}) 20 25}) #({tag 2:20}, {tag 6:20}) [20->25] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 8:70}) [70->85] (level:0) is #f with stack state #f #({basic-block #({tag 3:25}) 65 65}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:25}) [65->65] (level:0) is brown with stack state with #({basic-block #({tag 3:25}, {tag 1:25}) 25 50}) #({tag 3:25}, {tag 1:25}) [25->50] (level:0) is red with stack state with #({basic-block #() 50 65}) move N0/NSPILL-0, r3 sub r1, r1, 24 move r3, 8 move r4, {constant "KLmachine_wordGVKeW"} call-alien {constant "primitive_alloc_leaf"}, 0 #() [50->65] (level:0) is red with stack state with #({basic-block #({tag 4:65}) 65 65}) add r1, r1, 24 move r3, r3 st N0/NSPILL-0, r3, 4 #({tag 4:65}) [65->65] (level:0) is yellow with stack state with #({basic-block #({tag 4:65}, {tag 5:65}) 65 65}) #({tag 4:65}, {tag 5:65}) [65->65] (level:0) is green with stack state with #({basic-block #({tag 5:65}, {tag 4:65}, {tag 7:65}) 65 70}) #({tag 5:65}, {tag 4:65}, {tag 7:65}) [65->70] (level:0) is #f with stack state #f #({basic-block #({tag 2:20}, {tag 6:20}) 20 25}) preserve-registers-exit #() [85->90] (level:0) is #f with stack state #f #() bra {tag 2:20} +++ ending code for primitive_wrap_unsigned_abstract_integer +++ +++ Frame sizes for primitive_wrap_unsigned_abstract_integer: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_wrap_unsigned_abstract_integer +++ Start scope at 22 with frame for no variables End scope at 47 +++ No Source Code Locators for primitive_wrap_unsigned_abstract_integer +++ +++ Exported function definition primitive_unwrap_abstract_integer +++ +++ starting code for primitive_unwrap_abstract_integer +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 1:25}) 25 30}) and N0/r23, r3, 3 beq {tag 1:25}, N0/r23, 0 #() [15->20] (level:0) is green with stack state #f #({basic-block #({tag 2:20}) 20 20}) asr r3, r3, 2 #({tag 2:20}) [20->20] (level:0) is green with stack state #f #({basic-block #({tag 2:20}) 20 25}) #({tag 2:20}) [20->25] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:25}) [25->30] (level:0) is green with stack state #f #({basic-block #({tag 2:20}) 20 20}) ld r3, r3, 4 #() [30->35] (level:0) is #f with stack state #f #() bra {tag 2:20} +++ ending code for primitive_unwrap_abstract_integer +++ +++ No Source Code Locators for primitive_unwrap_abstract_integer +++ +++ Exported function definition primitive_machine_word_count_low_zeros +++ +++ starting code for primitive_machine_word_count_low_zeros +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:20}) 20 35}) bne {tag 1:20}, r3, 0 #() [10->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move r3, 32 #() [15->20] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:20}) [20->35] (level:0) is green with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 2:75}) 75 80}) move N1/r3, r3 move N0/r23, 0 bne-byte {tag 2:75}, N1/r3, 0 #() [35->40] (level:0) is green with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 3:65}) 65 75}) band {tag 3:65}, N1/r3, 65280 #() [40->45] (level:0) is green with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 4:55}) 55 65}) band {tag 4:55}, N1/r3, 16711680 #() [45->55] (level:0) is green with stack state #f #({basic-block #({tag 4:55}) 55 65}) add N0/r23, N0/r23, 8 lsr N1/r3, N1/r3, 8 #({tag 4:55}) [55->65] (level:0) is green with stack state #f #({basic-block #({tag 3:65}) 65 75}) add N0/r23, N0/r23, 8 lsr N1/r3, N1/r3, 8 #({tag 3:65}) [65->75] (level:0) is green with stack state #f #({basic-block #({tag 2:75}) 75 80}) add N0/r23, N0/r23, 8 lsr N1/r3, N1/r3, 8 #({tag 2:75}) [75->80] (level:0) is green with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 5:90}) 90 105}) band {tag 5:90}, N1/r3, 15 #() [80->90] (level:0) is green with stack state #f #({basic-block #({tag 5:90}) 90 105}) add N0/r23, N0/r23, 4 lsr N1/r3, N1/r3, 4 #({tag 5:90}) [90->105] (level:0) is green with stack state #f #({basic-block #() 105 110}) and N1/r3, N1/r3, 15 ldb N1/r3, {constant "Klow_zeros_table"}, N1/r3 add r3, N0/r23, N1/r3 #() [105->110] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_machine_word_count_low_zeros +++ +++ No Source Code Locators for primitive_machine_word_count_low_zeros +++ +++ Exported function definition primitive_machine_word_count_high_zeros +++ +++ starting code for primitive_machine_word_count_high_zeros +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:20}) 20 35}) bne {tag 1:20}, r3, 0 #() [10->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move r3, 32 #() [15->20] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:20}) [20->35] (level:0) is green with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 2:75}) 75 80}) move N1/r3, r3 move N0/r23, 0 band {tag 2:75}, N1/r3, #ex00000000FF000000 #() [35->40] (level:0) is green with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 3:65}) 65 75}) band {tag 3:65}, N1/r3, 16711680 #() [40->45] (level:0) is green with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 4:55}) 55 65}) band {tag 4:55}, N1/r3, 65280 #() [45->55] (level:0) is green with stack state #f #({basic-block #({tag 4:55}) 55 65}) add N0/r23, N0/r23, 8 asl N1/r3, N1/r3, 8 #({tag 4:55}) [55->65] (level:0) is green with stack state #f #({basic-block #({tag 3:65}) 65 75}) add N0/r23, N0/r23, 8 asl N1/r3, N1/r3, 8 #({tag 3:65}) [65->75] (level:0) is green with stack state #f #({basic-block #({tag 2:75}) 75 80}) add N0/r23, N0/r23, 8 asl N1/r3, N1/r3, 8 #({tag 2:75}) [75->80] (level:0) is green with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 5:90}) 90 105}) band {tag 5:90}, N1/r3, #ex00000000F0000000 #() [80->90] (level:0) is green with stack state #f #({basic-block #({tag 5:90}) 90 105}) add N0/r23, N0/r23, 4 asl N1/r3, N1/r3, 4 #({tag 5:90}) [90->105] (level:0) is green with stack state #f #({basic-block #() 105 110}) lsr N1/r3, N1/r3, 28 ldb N1/r3, {constant "Khigh_zeros_table"}, N1/r3 add r3, N0/r23, N1/r3 #() [105->110] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_machine_word_count_high_zeros +++ +++ No Source Code Locators for primitive_machine_word_count_high_zeros +++ +++ Exported function definition primitive_type_check +++ +++ starting code for primitive_type_check +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state before #({basic-block #({tag 7:105}) 105 120}, {basic-block #({tag 1:70}) 65 70}) move N4/r3, r3 move N5/r4, r4 move G6/r4, N5/r4 beq {tag 1:70}, G6/r4, {constant "KLobjectGVKd"} #({tag 7:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #({tag 2:75}) 75 90}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 2:75}) [75->90] (level:0) is brown with stack state with #({basic-block #() 25 45}) move N0/r29, N4/r3 move N1/r28, N5/r4 move G3/r4, G6/r4 #() [25->45] (level:0) is red with stack state with #({basic-block #() 45 50}) ld N2/r23, G3/r4, 4 move r3, N0/r29 move r4, G3/r4 call N2/r23, 2 #() [45->50] (level:0) is red with stack state with #({basic-block #() 50 65}, {basic-block #({tag 3:90}) 90 95}) bne {tag 3:90}, r3, {constant "KPfalseVKi"} #() [50->65] (level:0) is red with stack state with #({basic-block #({tag 3:90}) 90 95}) move r3, N0/r29 move r4, N1/r28 call {constant "Ktype_check_errorVKiI"}, 2 #({tag 3:90}) [90->95] (level:0) is yellow with stack state with #({basic-block #({tag 4:100}) 95 100}) move N4/r3, N0/r29 #({tag 4:100}) [95->100] (level:0) is green with stack state with #({basic-block #({tag 4:100}, {tag 6:100}) 100 105}) move r3, N4/r3 #({tag 4:100}, {tag 6:100}) [100->105] (level:0) is #f with stack state #f #({basic-block #({tag 1:70}, {tag 5:70}) 70 75}) preserve-registers-exit #({tag 1:70}, {tag 5:70}) [70->75] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:70}) [65->70] (level:0) is green with stack state before #({basic-block #({tag 1:70}, {tag 5:70}) 70 75}) move r3, N4/r3 +++ ending code for primitive_type_check +++ +++ Live variable scopes for primitive_type_check +++ Start scope at 16 with frame for no variables End scope at 49 +++ No Source Code Locators for primitive_type_check +++ +++ Exported function definition primitive_type_check_values +++ +++ starting code for primitive_type_check_values +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 12:315}) 315 330}) rem "This is a dummy first basic block." #({tag 12:315}) [315->330] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 7:35}) 35 65}) rem "eliminated" move N1/r4, r4 move N2/r27, r5 push r3 bmvset {tag 7:35} #() [30->35] (level:0) is red with stack state with #({basic-block #({tag 8:65}) 65 100}) push 1 #({tag 8:65}) [65->100] (level:0) is red with stack state with #({basic-block #({tag 1:100}) 100 105}) ld N4/NSPILL-0, r1, 0 add N5/r26, r1, 4 add N9/NSPILL-4, N1/r4, 8 ld N8/NSPILL-3, N1/r4, 4 sub N8/NSPILL-3, N8/NSPILL-3, 1 move N6/r29, 0 move N10/NSPILL-1, 0 #({tag 1:100}) [100->105] (level:1) is green with stack state with #({basic-block #() 105 110}, {basic-block #({tag 3:185}) 185 190}) beq {tag 3:185}, N10/NSPILL-1, N8/NSPILL-3 #() [105->110] (level:1) is green with stack state with #({basic-block #() 110 125}, {basic-block #({tag 3:185}) 185 190}) bge {tag 3:185}, N10/NSPILL-1, N4/NSPILL-0 #() [110->125] (level:1) is green with stack state with #({basic-block #() 125 135}, {basic-block #({tag 2:175}) 175 185}) ld N3/r28, N5/r26, N6/r29 ld N7/NSPILL-2, N9/NSPILL-4, N10/NSPILL-1 beq {tag 2:175}, N7/NSPILL-2, {constant "KPfalseVKi"} #() [125->135] (level:1) is green with stack state with #({basic-block #() 135 155}, {basic-block #({tag 2:175}) 175 185}) move G15/r4, N7/NSPILL-2 beq {tag 2:175}, G15/r4, {constant "KLobjectGVKd"} #() [135->155] (level:1) is red with stack state with #({basic-block #() 155 160}) ld N14/r23, G15/r4, 4 move r3, N3/r28 move r4, G15/r4 call N14/r23, 2 #() [155->160] (level:1) is red with stack state with #({basic-block #() 160 175}, {basic-block #({tag 2:175}) 175 185}) bne {tag 2:175}, r3, {constant "KPfalseVKi"} #() [160->175] (level:1) is red with stack state with #({basic-block #({tag 2:175}) 175 185}) move r3, N3/r28 move r4, N7/NSPILL-2 call {constant "Ktype_check_errorVKiI"}, 2 #({tag 2:175}) [175->185] (level:1) is green with stack state with #({basic-block #({tag 1:100}) 100 105}) add N6/r29, N6/r29, 4 add N10/NSPILL-1, N10/NSPILL-1, 4 #() [330->335] (level:0) is #f with stack state #f #() bra {tag 1:100} #({tag 7:35}) [35->65] (level:0) is red with stack state with #({basic-block #({tag 8:65}) 65 100}) ld-teb N11/r22, 32 asl N13/r23, N11/r22, 2 sub r1, r1, N13/r23 ld-teb-address N12/r21, 40 copy-words-down-w r1, N12/r21, N11/r22 push N13/r23 #() [335->340] (level:0) is #f with stack state #f #() bra {tag 8:65} #({tag 3:185}) [185->190] (level:1) is green with stack state with #({basic-block #({tag 4:190}) 190 195}, {basic-block #({tag 6:255}) 255 265}) beq {tag 6:255}, N2/r27, {constant "KPfalseVKi"} #({tag 4:190}) [190->195] (level:2) is green with stack state with #({basic-block #() 195 210}, {basic-block #({tag 6:255}) 255 265}) bge {tag 6:255}, N6/r29, N4/NSPILL-0 #() [195->210] (level:2) is green with stack state with #({basic-block #() 210 230}, {basic-block #({tag 5:250}) 250 255}) ld N3/r28, N5/r26, N6/r29 move G17/r4, N2/r27 beq {tag 5:250}, G17/r4, {constant "KLobjectGVKd"} #() [210->230] (level:2) is red with stack state with #({basic-block #() 230 235}) ld N16/r23, G17/r4, 4 move r3, N3/r28 move r4, G17/r4 call N16/r23, 2 #() [230->235] (level:2) is red with stack state with #({basic-block #() 235 250}, {basic-block #({tag 5:250}) 250 255}) bne {tag 5:250}, r3, {constant "KPfalseVKi"} #() [235->250] (level:2) is red with stack state with #({basic-block #({tag 5:250}) 250 255}) move r3, N3/r28 move r4, N2/r27 call {constant "Ktype_check_errorVKiI"}, 2 #({tag 5:250}) [250->255] (level:2) is green with stack state with #({basic-block #({tag 4:190}) 190 195}) add N6/r29, N6/r29, 4 #() [340->345] (level:0) is #f with stack state #f #() bra {tag 4:190} #({tag 6:255}) [255->265] (level:2) is red with stack state with #({basic-block #() 265 270}, {basic-block #({tag 9:270}) 270 300}) pop N18/r23 bne {tag 9:270}, N18/r23, 1 #() [265->270] (level:2) is red with stack state with #({basic-block #({tag 10:300}) 300 305}) reset-values #({tag 10:300}) [300->305] (level:2) is red with stack state with #({basic-block #({tag 11:310}) 310 315}) pop r3 #({tag 11:310}) [310->315] (level:0) is #f with stack state #f #({basic-block #() 305 310}) preserve-registers-exit #() [305->310] (level:2) is red with stack state #f #() rts-and-drop 0 #({tag 9:270}) [270->300] (level:2) is red with stack state with #({basic-block #({tag 10:300}) 300 305}) asr N20/r22, N18/r23, 2 st-teb N20/r22, 32 ld-teb-address N19/r21, 40 copy-words-down-w N19/r21, r1, N20/r22 add r1, r1, N18/r23 set-values #() [345->350] (level:0) is #f with stack state #f #() bra {tag 10:300} +++ ending code for primitive_type_check_values +++ +++ Frame sizes for primitive_type_check_values: GC: 0, NC: 5 +++ +++ Live variable scopes for primitive_type_check_values +++ Start scope at 8 with frame for no variables End scope at 243 +++ No Source Code Locators for primitive_type_check_values +++ +++ Exported function definition primitive_type_check_rest_values +++ +++ starting code for primitive_type_check_rest_values +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 9:200}) 200 215}) rem "This is a dummy first basic block." #({tag 9:200}) [200->215] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 30}, {basic-block #({tag 4:30}) 30 60}) move N0/r29, r3 move N1/r27, r4 push r3 bmvset {tag 4:30} #() [25->30] (level:0) is red with stack state with #({basic-block #({tag 5:60}) 60 75}) push 1 #({tag 5:60}) [60->75] (level:0) is red with stack state with #({basic-block #({tag 1:75}) 75 80}) ld N3/NSPILL-0, r1, 0 add N4/r26, r1, 4 move N5/r29, N0/r29 #({tag 1:75}) [75->80] (level:1) is green with stack state with #({basic-block #() 80 95}, {basic-block #({tag 3:140}) 140 150}) bge {tag 3:140}, N5/r29, N3/NSPILL-0 #() [80->95] (level:1) is green with stack state with #({basic-block #() 95 115}, {basic-block #({tag 2:135}) 135 140}) ld N2/r28, N4/r26, N5/r29 move G10/r4, N1/r27 beq {tag 2:135}, G10/r4, {constant "KLobjectGVKd"} #() [95->115] (level:1) is red with stack state with #({basic-block #() 115 120}) ld N9/r23, G10/r4, 4 move r3, N2/r28 move r4, G10/r4 call N9/r23, 2 #() [115->120] (level:1) is red with stack state with #({basic-block #() 120 135}, {basic-block #({tag 2:135}) 135 140}) bne {tag 2:135}, r3, {constant "KPfalseVKi"} #() [120->135] (level:1) is red with stack state with #({basic-block #({tag 2:135}) 135 140}) move r3, N2/r28 move r4, N1/r27 call {constant "Ktype_check_errorVKiI"}, 2 #({tag 2:135}) [135->140] (level:1) is green with stack state with #({basic-block #({tag 1:75}) 75 80}) add N5/r29, N5/r29, 4 #() [215->220] (level:0) is #f with stack state #f #() bra {tag 1:75} #({tag 4:30}) [30->60] (level:0) is red with stack state with #({basic-block #({tag 5:60}) 60 75}) ld-teb N6/r22, 32 asl N8/r23, N6/r22, 2 sub r1, r1, N8/r23 ld-teb-address N7/r21, 40 copy-words-down-w r1, N7/r21, N6/r22 push N8/r23 #() [220->225] (level:0) is #f with stack state #f #() bra {tag 5:60} #({tag 3:140}) [140->150] (level:1) is red with stack state with #({basic-block #() 150 155}, {basic-block #({tag 6:155}) 155 185}) pop N11/r23 bne {tag 6:155}, N11/r23, 1 #() [150->155] (level:1) is red with stack state with #({basic-block #({tag 7:185}) 185 190}) reset-values #({tag 7:185}) [185->190] (level:1) is red with stack state with #({basic-block #({tag 8:195}) 195 200}) pop r3 #({tag 8:195}) [195->200] (level:0) is #f with stack state #f #({basic-block #() 190 195}) preserve-registers-exit #() [190->195] (level:1) is red with stack state #f #() rts-and-drop 0 #({tag 6:155}) [155->185] (level:1) is red with stack state with #({basic-block #({tag 7:185}) 185 190}) asr N13/r22, N11/r23, 2 st-teb N13/r22, 32 ld-teb-address N12/r21, 40 copy-words-down-w N12/r21, r1, N13/r22 add r1, r1, N11/r23 set-values #() [225->230] (level:0) is #f with stack state #f #() bra {tag 7:185} +++ ending code for primitive_type_check_rest_values +++ +++ Frame sizes for primitive_type_check_rest_values: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_type_check_rest_values +++ Start scope at 8 with frame for no variables End scope at 133 +++ No Source Code Locators for primitive_type_check_rest_values +++ +++ Exported function definition primitive_adjust_mv +++ +++ starting code for primitive_adjust_mv +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:45}) 45 55}) bmvset {tag 1:45} #() [10->15] (level:0) is green with stack state #f #({basic-block #() 15 25}, {basic-block #({tag 2:105}) 105 105}) beq {tag 2:105}, r23, 1 #() [15->25] (level:0) is green with stack state #f #({basic-block #() 25 40}, {basic-block #({tag 3:40}) 40 45}) st-teb r23, 32 beq {tag 3:40}, r23, 0 #() [25->40] (level:0) is green with stack state #f #({basic-block #({tag 3:40}) 40 45}) ld-teb-address N3/r21, 40 fill-words-w N3/r21, r23, {constant "KPfalseVKi"} st r3, N3/r21, 0 #({tag 3:40}) [40->45] (level:0) is green with stack state #f #({basic-block #({tag 2:105}) 105 105}) reset-values #({tag 2:105}) [105->105] (level:0) is green with stack state #f #({basic-block #({tag 2:105}) 105 110}) #({tag 2:105}) [105->110] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:45}) [45->55] (level:0) is green with stack state #f #({basic-block #() 55 60}, {basic-block #({tag 2:105}) 105 105}) ld-teb N0/r22, 32 beq {tag 2:105}, r23, N0/r22 #() [55->60] (level:0) is green with stack state #f #({basic-block #() 60 70}, {basic-block #({tag 3:40}) 40 45}) beq {tag 3:40}, r23, 1 #() [60->70] (level:0) is green with stack state #f #({basic-block #() 70 100}, {basic-block #({tag 4:100}) 100 105}) st-teb r23, 32 blt {tag 4:100}, r23, N0/r22 #() [70->100] (level:0) is green with stack state #f #({basic-block #({tag 4:100}) 100 105}) sub N1/r23, r23, N0/r22 move N2/r22, N0/r22 ld-teb-address N3/r21, 40 asl N2/r22, N2/r22, 2 add N2/r22, N2/r22, N3/r21 fill-words-w N2/r22, N1/r23, {constant "KPfalseVKi"} #({tag 4:100}) [100->105] (level:0) is green with stack state #f #({basic-block #({tag 2:105}) 105 105}) set-values #() [110->115] (level:0) is #f with stack state #f #() bra {tag 2:105} +++ ending code for primitive_adjust_mv +++ +++ No Source Code Locators for primitive_adjust_mv +++ +++ Exported function definition primitive_adjust_mv_rest +++ +++ starting code for primitive_adjust_mv_rest +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:40}) 40 50}) bmvset {tag 1:40} #() [10->15] (level:0) is green with stack state #f #({basic-block #() 15 35}, {basic-block #({tag 2:95}) 95 95}) ble {tag 2:95}, r23, 1 #() [15->35] (level:0) is green with stack state #f #({basic-block #({tag 3:35}) 35 40}) st-teb r23, 32 ld-teb-address N3/r21, 40 fill-words-w N3/r21, r23, {constant "KPfalseVKi"} st r3, N3/r21, 0 #({tag 3:35}) [35->40] (level:0) is green with stack state #f #({basic-block #({tag 2:95}) 95 95}) reset-values #({tag 2:95}) [95->95] (level:0) is green with stack state #f #({basic-block #({tag 2:95}) 95 100}) #({tag 2:95}) [95->100] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:40}) [40->50] (level:0) is green with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 2:95}) 95 95}) ld-teb N0/r22, 32 ble {tag 2:95}, r23, N0/r22 #() [50->55] (level:0) is green with stack state #f #({basic-block #() 55 85}, {basic-block #({tag 3:35}) 35 40}) beq {tag 3:35}, r23, 1 #() [55->85] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 95}) sub N1/r20, r23, N0/r22 move N2/r22, N0/r22 ld-teb-address N3/r21, 40 asl N2/r22, N2/r22, 2 add N2/r22, N2/r22, N3/r21 fill-words-w N2/r22, N1/r20, {constant "KPfalseVKi"} #({tag 4:85}) [85->95] (level:0) is green with stack state #f #({basic-block #({tag 2:95}) 95 95}) st-teb r23, 32 set-values #() [100->105] (level:0) is #f with stack state #f #() bra {tag 2:95} +++ ending code for primitive_adjust_mv_rest +++ +++ No Source Code Locators for primitive_adjust_mv_rest +++ +++ Exported function definition primitive_pad_mv +++ +++ starting code for primitive_pad_mv +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 35}) bmvset {tag 1:25} #() [10->15] (level:0) is green with stack state #f #({basic-block #() 15 25}, {basic-block #({tag 2:70}) 70 70}) ble {tag 2:70}, r23, 1 #() [15->25] (level:0) is green with stack state #f #({basic-block #({tag 2:70}) 70 70}) ld-teb-address N3/r21, 40 fill-words-w N3/r21, r23, {constant "KPfalseVKi"} #({tag 2:70}) [70->70] (level:0) is green with stack state #f #({basic-block #({tag 2:70}) 70 75}) #({tag 2:70}) [70->75] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:25}) [25->35] (level:0) is green with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 2:70}) 70 70}) ld-teb N0/r22, 32 beq {tag 2:70}, r23, 1 #() [35->40] (level:0) is green with stack state #f #({basic-block #() 40 70}, {basic-block #({tag 2:70}) 70 70}) ble {tag 2:70}, r23, N0/r22 #() [40->70] (level:0) is green with stack state #f #({basic-block #({tag 2:70}) 70 70}) sub N1/r23, r23, N0/r22 move N2/r22, N0/r22 ld-teb-address N3/r21, 40 asl N2/r22, N2/r22, 2 add N2/r22, N2/r22, N3/r21 fill-words-w N2/r22, N1/r23, {constant "KPfalseVKi"} #() [75->80] (level:0) is #f with stack state #f #() bra {tag 2:70} +++ ending code for primitive_pad_mv +++ +++ No Source Code Locators for primitive_pad_mv +++ +++ Exported function definition primitive_set_mv_from_vector +++ +++ starting code for primitive_set_mv_from_vector +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is green with stack state #f #({basic-block #({tag 1:30}) 30 40}, {basic-block #({tag 2:40}) 40 50}) move G0/r22, r22 move N4/r3, r3 ld N2/r23, N4/r3, 4 asr N2/r23, N2/r23, 2 bne {tag 2:40}, N2/r23, 1 #({tag 1:30}) [30->40] (level:0) is green with stack state #f #({basic-block #({tag 4:90}) 85 90}) ld r3, N4/r3, 8 reset-values #({tag 4:90}) [85->90] (level:0) is green with stack state #f #({basic-block #({tag 4:90}) 90 95}) move r22, G0/r22 #({tag 4:90}) [90->95] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 2:40}) [40->50] (level:0) is green with stack state #f #({basic-block #() 50 75}, {basic-block #({tag 3:75}) 75 85}) st-teb N2/r23, 32 beq {tag 3:75}, N2/r23, 0 #() [50->75] (level:0) is green with stack state #f #({basic-block #({tag 4:90}) 85 90}) add N1/r21, N4/r3, 8 ld r3, N1/r21, 0 ld-teb-address N3/r20, 40 copy-words-down-w N3/r20, N1/r21, N2/r23 set-values #() [95->100] (level:0) is #f with stack state #f #() bra {tag 4:90} #({tag 3:75}) [75->85] (level:0) is green with stack state #f #({basic-block #({tag 4:90}) 85 90}) move r3, {constant "KPfalseVKi"} set-values #() [100->105] (level:0) is #f with stack state #f #() bra {tag 4:90} +++ ending code for primitive_set_mv_from_vector +++ +++ No Source Code Locators for primitive_set_mv_from_vector +++ +++ Exported function definition primitive_build_bind_exit_frame +++ +++ starting code for primitive_build_bind_exit_frame +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) sub r1, r1, 56 st r3, r1, 52 ld-teb r3, 0 st r30, r1, 48 st r3, r1, 44 move r3, r1 #() [35->40] (level:0) is #f with stack state #f #() rts +++ ending code for primitive_build_bind_exit_frame +++ +++ No Source Code Locators for primitive_build_bind_exit_frame +++ +++ Exported function definition primitive_build_unwind_protect_frame +++ +++ starting code for primitive_build_unwind_protect_frame +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}) sub r1, r1, 12 st r3, r1, 8 ld-teb r3, 0 st r30, r1, 4 st r3, r1, 0 move r3, r1 st-teb r1, 0 #() [40->45] (level:0) is #f with stack state #f #() rts +++ ending code for primitive_build_unwind_protect_frame +++ +++ No Source Code Locators for primitive_build_unwind_protect_frame +++ +++ Exported function definition primitive_unwind_protect_cleanup +++ +++ starting code for primitive_unwind_protect_cleanup +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 1:35}) 35 65}) ld-teb N2/r23, 0 ld N0/r22, N2/r23, 0 st-teb N0/r22, 0 push r3 bmvset {tag 1:35} #() [30->35] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 80}) push 1 #({tag 2:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #() 80 95}) push N2/r23 ld N0/r22, N2/r23, 8 call N0/r22, 0 #() [80->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}, {basic-block #({tag 3:100}) 100 130}) pop N2/r23 pop N6/r22 bne {tag 3:100}, N6/r22, 1 #() [95->100] (level:0) is #f with stack state #f #({basic-block #({tag 4:130}) 130 140}) reset-values #({tag 4:130}) [130->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) pop r3 add r1, N2/r23, 12 #() [140->145] (level:0) is #f with stack state #f #() rts #({tag 1:35}) [35->65] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 80}) ld-teb N3/r21, 32 asl N5/r22, N3/r21, 2 sub r1, r1, N5/r22 ld-teb-address N4/r20, 40 copy-words-down-w r1, N4/r20, N3/r21 push N5/r22 #() [145->150] (level:0) is #f with stack state #f #() bra {tag 2:65} #({tag 3:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #({tag 4:130}) 130 140}) asr N8/r21, N6/r22, 2 st-teb N8/r21, 32 ld-teb-address N7/r20, 40 copy-words-down-w N7/r20, r1, N8/r21 add r1, r1, N6/r22 set-values #() [150->155] (level:0) is #f with stack state #f #() bra {tag 4:130} +++ ending code for primitive_unwind_protect_cleanup +++ +++ No Source Code Locators for primitive_unwind_protect_cleanup +++ +++ Exported function definition primitive_nlx +++ +++ starting code for primitive_nlx +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 50}, {basic-block #({tag 1:55}) 55 65}) ld-teb N1/r22, 0 ld N0/r21, r3, 44 move N2/r23, r3 move N3/r3, r4 bne {tag 1:55}, N1/r22, N0/r21 #() [30->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}) move r3, N3/r3 ld N4/r22, N2/r23, 52 ld r30, N2/r23, 48 add r1, N2/r23, 56 #() [50->55] (level:0) is #f with stack state #f #() jmp N4/r22, 4, 0, #f, #f #({tag 1:55}) [55->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 2:75}) 75 85}) add N5/r21, N2/r23, 4 bmvset {tag 2:75} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 3:165}) 165 170}) st N3/r3, N5/r21, 8 st 5, N5/r21, 4 #({tag 3:165}) [165->170] (level:0) is #f with stack state #f #({basic-block #({tag 5:170}) 170 175}) st N5/r21, N2/r23, 0 #({tag 5:170}) [170->175] (level:1) is #f with stack state #f #({basic-block #() 175 210}, {basic-block #({tag 6:330}) 330 330}) beq {tag 6:330}, N1/r22, 0 #() [175->210] (level:1) is #f with stack state #f #({basic-block #() 210 230}) move r1, N1/r22 ld N10/r22, r1, 0 ld N11/r3, r1, 8 st-teb N10/r22, 0 ld r30, r1, 4 push N2/r23 call N11/r3, 0 #() [210->230] (level:1) is #f with stack state #f #({basic-block #() 230 255}, {basic-block #({tag 5:170}) 170 175}) pop N2/r23 ld-teb N1/r22, 0 ld N12/r21, N2/r23, 44 bne {tag 5:170}, N12/r21, N1/r22 #() [230->255] (level:0) is #f with stack state #f #({basic-block #({tag 7:255}) 255 265}, {basic-block #({tag 8:265}) 265 275}) ld G13/r3, N2/r23, 0 move N17/r3, G13/r3 ld N15/r22, N17/r3, 4 asr N15/r22, N15/r22, 2 bne {tag 8:265}, N15/r22, 1 #({tag 7:255}) [255->265] (level:0) is #f with stack state #f #({basic-block #({tag 10:310}) 310 325}) ld r3, N17/r3, 8 reset-values #({tag 10:310}) [310->325] (level:0) is #f with stack state #f #({basic-block #() 325 330}) ld N18/r22, N2/r23, 52 ld r30, N2/r23, 48 add r1, N2/r23, 56 #() [325->330] (level:0) is #f with stack state #f #() jmp N18/r22, 4, 0, #f, #f #({tag 2:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #() 85 110}, {basic-block #({tag 4:135}) 135 165}) ld-teb r0, 32 ble {tag 4:135}, r0, 8 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 135}) push r0 push N2/r23 push N1/r22 move r3, r0 call {constant "primitive_allocate_vector"}, 1 #() [110->135] (level:0) is #f with stack state #f #({basic-block #({tag 4:135}) 135 165}) move G7/r3, r3 pop N1/r22 pop N2/r23 pop r0 move N5/r21, G7/r3 #({tag 4:135}) [135->165] (level:0) is #f with stack state #f #({basic-block #({tag 3:165}) 165 170}) asl N9/r20, r0, 2 add N9/r20, N9/r20, 1 st N9/r20, N5/r21, 4 add N8/r20, N5/r21, 8 ld-teb-address N6/r19, 40 copy-words-down-w N8/r20, N6/r19, r0 #() [335->340] (level:0) is #f with stack state #f #() bra {tag 3:165} #({tag 6:330}) [330->330] (level:1) is #f with stack state #f #({basic-block #({tag 6:330}) 330 335}) #({tag 8:265}) [265->275] (level:0) is #f with stack state #f #({basic-block #() 275 300}, {basic-block #({tag 9:300}) 300 310}) st-teb N15/r22, 32 beq {tag 9:300}, N15/r22, 0 #() [275->300] (level:0) is #f with stack state #f #({basic-block #({tag 10:310}) 310 325}) add N14/r21, N17/r3, 8 ld r3, N14/r21, 0 ld-teb-address N16/r20, 40 copy-words-down-w N16/r20, N14/r21, N15/r22 set-values #() [340->345] (level:0) is #f with stack state #f #() bra {tag 10:310} #({tag 6:330}) [330->335] (level:1) is #f with stack state #f #() jmp {constant "primitive_error"}, 0, 0, #f, #f #({tag 9:300}) [300->310] (level:0) is #f with stack state #f #({basic-block #({tag 10:310}) 310 325}) move r3, {constant "KPfalseVKi"} set-values #() [345->350] (level:0) is #f with stack state #f #() bra {tag 10:310} +++ ending code for primitive_nlx +++ +++ No Source Code Locators for primitive_nlx +++ +++ Exported function definition primitive_stack_allocate_vector +++ +++ starting code for primitive_stack_allocate_vector +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) move N1/r23, r3 asl N3/r22, N1/r23, 2 add N3/r22, N3/r22, 8 sub r1, r1, N3/r22 move N2/r3, r1 asl N4/r23, N1/r23, 2 add N4/r23, N4/r23, 1 st N4/r23, N2/r3, 4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r3, 0 move r3, N2/r3 #() [55->60] (level:0) is #f with stack state #f #() rts +++ ending code for primitive_stack_allocate_vector +++ +++ No Source Code Locators for primitive_stack_allocate_vector +++ +++ Exported function definition primitive_stack_allocate_vector_from_buffer +++ +++ starting code for primitive_stack_allocate_vector_from_buffer +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 80}) rem "This is a dummy first basic block." #() [5->80] (level:0) is #f with stack state #f #({basic-block #() 80 85}) move N0/r4, r4 add r1, r1, 4 move N2/r22, r3 asl N4/r23, N2/r22, 2 add N4/r23, N4/r23, 8 sub r1, r1, N4/r23 move N3/r3, r1 asl N5/r23, N2/r22, 2 add N5/r23, N5/r23, 1 st N5/r23, N3/r3, 4 st {constant "KLsimple_object_vectorGVKdW"}, N3/r3, 0 add N6/r23, N3/r3, 8 move r0, N2/r22 copy-words-down-w N6/r23, N0/r4, r0 move r3, N3/r3 #() [80->85] (level:0) is #f with stack state #f #() rts +++ ending code for primitive_stack_allocate_vector_from_buffer +++ +++ No Source Code Locators for primitive_stack_allocate_vector_from_buffer +++ +++ Exported function definition primitive_stack_allocate_vector_from_buffer_with_offset +++ +++ starting code for primitive_stack_allocate_vector_from_buffer_with_offset +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 95}) rem "This is a dummy first basic block." #() [5->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move N0/r4, r4 move N1/r5, r5 asl N1/r5, N1/r5, 2 add N0/r4, N0/r4, N1/r5 add r1, r1, 8 move N3/r22, r3 asl N5/r23, N3/r22, 2 add N5/r23, N5/r23, 8 sub r1, r1, N5/r23 move N4/r3, r1 asl N6/r23, N3/r22, 2 add N6/r23, N6/r23, 1 st N6/r23, N4/r3, 4 st {constant "KLsimple_object_vectorGVKdW"}, N4/r3, 0 add N7/r23, N4/r3, 8 move r0, N3/r22 copy-words-down-w N7/r23, N0/r4, r0 move r3, N4/r3 #() [95->100] (level:0) is #f with stack state #f #() rts +++ ending code for primitive_stack_allocate_vector_from_buffer_with_offset +++ +++ No Source Code Locators for primitive_stack_allocate_vector_from_buffer_with_offset +++ +++ Exported function definition primitive_heap_vector_remaining_values +++ +++ starting code for primitive_heap_vector_remaining_values +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state before #({basic-block #() 15 20}, {basic-block #({tag 1:35}) 35 45}) ld-teb-address N0/r22, 40 bmvset {tag 1:35} #() [15->20] (level:0) is green with stack state before #({basic-block #() 20 30}, {basic-block #({tag 3:30}) 30 35}) bne {tag 3:30}, r23, 0 #() [20->30] (level:0) is green with stack state before #({basic-block #({tag 2:75}) 75 90}) st r3, N0/r22, 0 move r3, 1 #({tag 2:75}) [75->90] (level:0) is green with stack state before #({basic-block #() 90 95}, {basic-block #({tag 12:185}) 185 200}) move N7/r22, N0/r22 move N6/r3, r3 bne {tag 12:185}, N6/r3, 0 #() [90->95] (level:0) is green with stack state before #({basic-block #({tag 5:155}) 150 155}) move G8/r3, {constant "KPempty_vectorVKi"} #({tag 5:155}) [150->155] (level:0) is green with stack state before #({basic-block #({tag 5:155}, {tag 10:155}) 155 160}) move r3, G8/r3 #({tag 5:155}, {tag 10:155}) [155->160] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:35}) [35->45] (level:0) is green with stack state before #({basic-block #() 45 50}, {basic-block #({tag 3:30}) 30 35}) ld-teb N3/r21, 32 bge {tag 3:30}, r23, N3/r21 #() [45->50] (level:0) is green with stack state before #({basic-block #() 50 55}, {basic-block #({tag 4:55}) 55 75}) bne {tag 4:55}, r23, 0 #() [50->55] (level:0) is green with stack state before #({basic-block #({tag 4:55}) 55 75}) st r3, N0/r22, 0 #({tag 4:55}) [55->75] (level:0) is green with stack state before #({basic-block #({tag 2:75}) 75 90}) sub N3/r21, N3/r21, r23 asl r23, r23, 2 add N0/r22, N0/r22, r23 move r3, N3/r21 #() [200->205] (level:0) is #f with stack state #f #() bra {tag 2:75} #({tag 3:30}) [30->35] (level:0) is green with stack state before #({basic-block #({tag 2:75}) 75 90}) move r3, 0 #() [205->210] (level:0) is #f with stack state #f #() bra {tag 2:75} #({tag 12:185}) [185->200] (level:0) is #f with stack state #f #({basic-block #({tag 7:160}) 160 170}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 7:160}) [160->170] (level:0) is brown with stack state with #({basic-block #({tag 6:95}) 95 140}) move N1/r5, N6/r3 move N2/r22, N7/r22 #({tag 6:95}) [95->140] (level:0) is red with stack state with #({basic-block #() 140 150}) asl N5/r3, N1/r5, 2 add N5/r3, N5/r3, 8 sub r1, r1, 24 move r3, N5/r3 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N1/r5 move r6, 1 move r7, N2/r22 call-alien {constant "primitive_alloc_rt"}, 0 #() [140->150] (level:0) is red with stack state with #({basic-block #({tag 8:180}) 170 175}) add r1, r1, 24 move G4/r3, r3 #({tag 8:180}) [170->175] (level:0) is yellow with stack state with #({basic-block #({tag 8:180}, {tag 9:180}) 175 180}) move G8/r3, G4/r3 #({tag 8:180}, {tag 9:180}) [175->180] (level:0) is green with stack state with #({basic-block #({tag 9:180}, {tag 8:180}, {tag 11:180}) 180 185}) move r3, G8/r3 #({tag 9:180}, {tag 8:180}, {tag 11:180}) [180->185] (level:0) is #f with stack state #f #({basic-block #({tag 5:155}, {tag 10:155}) 155 160}) preserve-registers-exit #() [210->215] (level:0) is #f with stack state #f #() bra {tag 5:155} +++ ending code for primitive_heap_vector_remaining_values +++ +++ Live variable scopes for primitive_heap_vector_remaining_values +++ Start scope at 66 with frame for no variables End scope at 91 +++ No Source Code Locators for primitive_heap_vector_remaining_values +++ +++ Exported function definition primitive_stack_vector_remaining_values +++ +++ starting code for primitive_stack_vector_remaining_values +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 1:35}) 35 45}) ld-teb-address N0/r22, 40 bmvset {tag 1:35} #() [15->20] (level:0) is #f with stack state #f #({basic-block #() 20 30}, {basic-block #({tag 3:30}) 30 35}) bne {tag 3:30}, r23, 0 #() [20->30] (level:0) is #f with stack state #f #({basic-block #({tag 2:75}) 75 140}) st r3, N0/r22, 0 move r3, 1 #({tag 2:75}) [75->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) move N3/r21, r3 asl N5/r23, N3/r21, 2 add N5/r23, N5/r23, 8 sub r1, r1, N5/r23 move N4/r3, r1 asl N6/r23, N3/r21, 2 add N6/r23, N6/r23, 1 st N6/r23, N4/r3, 4 st {constant "KLsimple_object_vectorGVKdW"}, N4/r3, 0 add N7/r23, N4/r3, 8 move r0, N3/r21 copy-words-down-w N7/r23, N0/r22, r0 move r3, N4/r3 #() [140->145] (level:0) is #f with stack state #f #() rts #({tag 1:35}) [35->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 3:30}) 30 35}) ld-teb N1/r21, 32 bge {tag 3:30}, r23, N1/r21 #() [45->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 4:55}) 55 75}) bne {tag 4:55}, r23, 0 #() [50->55] (level:0) is #f with stack state #f #({basic-block #({tag 4:55}) 55 75}) st r3, N0/r22, 0 #({tag 4:55}) [55->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:75}) 75 140}) sub N1/r21, N1/r21, r23 asl r23, r23, 2 add N0/r22, N0/r22, r23 move r3, N1/r21 #() [145->150] (level:0) is #f with stack state #f #() bra {tag 2:75} #({tag 3:30}) [30->35] (level:0) is #f with stack state #f #({basic-block #({tag 2:75}) 75 140}) move r3, 0 #() [150->155] (level:0) is #f with stack state #f #() bra {tag 2:75} +++ ending code for primitive_stack_vector_remaining_values +++ +++ No Source Code Locators for primitive_stack_vector_remaining_values +++ +++ Exported function definition primitive_mep_apply +++ +++ starting code for primitive_mep_apply +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 1:245}) 245 270}) move r22, r3 move N0/r23, r4 move N1/r20, r5 move N2/r20, N1/r20 ld r0, N2/r20, 4 asr r0, r0, 2 add N3/r20, N2/r20, 8 ld N4/r21, r22, 8 ld N4/r21, N4/r21, 4 and N4/r21, N4/r21, 1310720 bne {tag 1:245}, N4/r21, 0 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}, {basic-block #({tag 3:90}) 85 90}) beq {tag 3:90}, r0, 0 #() [65->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 4:95}) 95 105}) beq {tag 4:95}, r0, 1 #() [70->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}, {basic-block #({tag 5:110}) 110 125}) beq {tag 5:110}, r0, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 85}, {basic-block #({tag 6:130}) 130 150}) beq {tag 6:130}, r0, 3 #() [80->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:185}) 185 240}, {basic-block #({tag 7:155}) 155 180}) beq {tag 7:155}, r0, 4 #({tag 2:185}) [185->240] (level:0) is #f with stack state #f #({basic-block #() 240 245}) sub r0, r0, 4 asl N7/r21, r0, 2 sub r1, r1, N7/r21 move N6/r21, r1 add N3/r20, N3/r20, 16 copy-words-down-w N6/r21, N3/r20, r0 move r23, N0/r23 ld r3, N3/r20, -16 ld r4, N3/r20, -12 ld r5, N3/r20, -8 ld r6, N3/r20, -4 #() [240->245] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 1:245}) [245->270] (level:0) is #f with stack state #f #({basic-block #() 270 310}, {basic-block #({tag 8:845}) 845 860}) ld N8/r21, r22, 8 ld N8/r21, N8/r21, 4 asr N8/r21, N8/r21, 2 and N8/r21, N8/r21, 255 beq {tag 8:845}, N8/r21, 0 #() [270->310] (level:0) is #f with stack state #f #({basic-block #() 310 315}, {basic-block #({tag 9:325}) 325 350}) asl N9/r21, r0, 2 sub r1, r1, N9/r21 move N12/r21, r1 push r0 copy-words-down-w N12/r21, N3/r20, r0 pop r0 move N12/r21, r1 bgt {tag 9:325}, r0, 3 #() [310->315] (level:0) is #f with stack state #f #({basic-block #() 315 320}, {basic-block #({tag 10:350}) 350 370}) bgt {tag 10:350}, r0, 2 #() [315->320] (level:0) is #f with stack state #f #({basic-block #() 320 325}, {basic-block #({tag 11:370}) 370 385}) bgt {tag 11:370}, r0, 1 #() [320->325] (level:0) is #f with stack state #f #({basic-block #({tag 13:395}) 395 425}, {basic-block #({tag 12:385}) 385 395}) bgt {tag 12:385}, r0, 0 #({tag 13:395}) [395->425] (level:0) is #f with stack state #f #({basic-block #() 425 430}, {basic-block #({tag 16:435}) 435 440}) move r1, N12/r21 ld N14/r21, r22, 8 ld N14/r21, N14/r21, 4 asr N14/r21, N14/r21, 2 and N14/r21, N14/r21, 255 beq {tag 16:435}, N14/r21, 1 #() [425->430] (level:0) is #f with stack state #f #({basic-block #() 430 435}, {basic-block #({tag 17:550}) 550 555}) beq {tag 17:550}, N14/r21, 2 #() [430->435] (level:0) is #f with stack state #f #({basic-block #({tag 14:710}) 710 835}, {basic-block #({tag 18:640}) 640 645}) beq {tag 18:640}, N14/r21, 3 #({tag 14:710}) [710->835] (level:0) is #f with stack state #f #({basic-block #({tag 15:840}) 835 840}) ld N29/r21, r22, 8 ld N29/r21, N29/r21, 4 asr N29/r21, N29/r21, 2 and N29/r21, N29/r21, 255 add N29/r21, N29/r21, -4 move N30/r19, r1 sub r1, r1, 16 move N28/r20, r0 move r0, N29/r21 move N31/r21, r1 copy-words-down-w N31/r21, N30/r19, r0 add N27/r21, r9, 4 asl N28/r20, N28/r20, 2 move r0, N28/r20 ld r7, r22, 8 ld r7, r7, 4 and r7, r7, 1020 sub N28/r20, N28/r20, r7 add N28/r20, N28/r20, 1 st N28/r20, N27/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N27/r21, -8 add r0, r0, 0 st r0, N27/r21, -12 add N32/r20, N27/r21, -8 st N32/r20, N27/r21, -16 #({tag 15:840}) [835->840] (level:0) is #f with stack state #f #({basic-block #({tag 15:840}) 840 845}) move r23, N0/r23 #({tag 15:840}) [840->845] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 3:90}) [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:90}) 90 95}) move r23, N0/r23 #({tag 4:95}) [95->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) move r23, N0/r23 ld r3, N3/r20, 0 #() [105->110] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:110}) [110->125] (level:0) is #f with stack state #f #({basic-block #() 125 130}) move r23, N0/r23 ld r3, N3/r20, 0 ld r4, N3/r20, 4 #() [125->130] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 6:130}) [130->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) move r23, N0/r23 ld r3, N3/r20, 0 ld r4, N3/r20, 4 ld r5, N3/r20, 8 #() [150->155] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 7:155}) [155->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) move r23, N0/r23 ld r3, N3/r20, 0 ld r4, N3/r20, 4 ld r5, N3/r20, 8 ld r6, N3/r20, 12 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 8:845}) [845->860] (level:0) is #f with stack state #f #({basic-block #() 860 865}) sub r3, N3/r20, 8 push 4 move r23, N0/r23 #() [860->865] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 9:325}) [325->350] (level:0) is #f with stack state #f #({basic-block #({tag 13:395}) 395 425}) ld r3, N12/r21, 0 ld r4, N12/r21, 4 ld r5, N12/r21, 8 ld r6, N12/r21, 12 add N12/r21, N12/r21, 16 #() [865->870] (level:0) is #f with stack state #f #() bra {tag 13:395} #({tag 10:350}) [350->370] (level:0) is #f with stack state #f #({basic-block #({tag 13:395}) 395 425}) ld r3, N12/r21, 0 ld r4, N12/r21, 4 ld r5, N12/r21, 8 add N12/r21, N12/r21, 12 #() [870->875] (level:0) is #f with stack state #f #() bra {tag 13:395} #({tag 11:370}) [370->385] (level:0) is #f with stack state #f #({basic-block #({tag 13:395}) 395 425}) ld r3, N12/r21, 0 ld r4, N12/r21, 4 add N12/r21, N12/r21, 8 #() [875->880] (level:0) is #f with stack state #f #() bra {tag 13:395} #({tag 12:385}) [385->395] (level:0) is #f with stack state #f #({basic-block #({tag 13:395}) 395 425}) ld r3, N12/r21, 0 add N12/r21, N12/r21, 4 #() [880->885] (level:0) is #f with stack state #f #() bra {tag 13:395} #({tag 16:435}) [435->440] (level:0) is #f with stack state #f #({basic-block #() 440 445}, {basic-block #({tag 20:450}) 450 470}) bgt {tag 20:450}, r0, 3 #() [440->445] (level:0) is #f with stack state #f #({basic-block #() 445 450}, {basic-block #({tag 21:470}) 470 485}) bgt {tag 21:470}, r0, 2 #() [445->450] (level:0) is #f with stack state #f #({basic-block #({tag 23:495}) 495 550}, {basic-block #({tag 22:485}) 485 495}) bgt {tag 22:485}, r0, 1 #({tag 23:495}) [495->550] (level:0) is #f with stack state #f #({basic-block #({tag 15:840}) 835 840}) move N17/r4, r1 sub r1, r1, 12 asl r0, r0, 2 move N16/r21, r0 add r0, r0, -3 st r0, N17/r4, -4 st {constant "KLsimple_object_vectorGVKdW"}, N17/r4, -8 add N16/r21, N16/r21, 8 st N16/r21, N17/r4, -12 add N18/r4, N17/r4, -8 move r4, N18/r4 #() [885->890] (level:0) is #f with stack state #f #() bra {tag 15:840} #({tag 17:550}) [550->555] (level:0) is #f with stack state #f #({basic-block #() 555 560}, {basic-block #({tag 25:560}) 560 575}) bgt {tag 25:560}, r0, 3 #() [555->560] (level:0) is #f with stack state #f #({basic-block #({tag 27:585}) 585 640}, {basic-block #({tag 26:575}) 575 585}) bgt {tag 26:575}, r0, 2 #({tag 27:585}) [585->640] (level:0) is #f with stack state #f #({basic-block #({tag 15:840}) 835 840}) move N21/r5, r1 sub r1, r1, 12 asl r0, r0, 2 move N20/r21, r0 add r0, r0, -7 st r0, N21/r5, -4 st {constant "KLsimple_object_vectorGVKdW"}, N21/r5, -8 add N20/r21, N20/r21, 4 st N20/r21, N21/r5, -12 add N22/r5, N21/r5, -8 move r5, N22/r5 #() [890->895] (level:0) is #f with stack state #f #() bra {tag 15:840} #({tag 18:640}) [640->645] (level:0) is #f with stack state #f #({basic-block #({tag 30:655}) 655 710}, {basic-block #({tag 29:645}) 645 655}) bgt {tag 29:645}, r0, 3 #({tag 30:655}) [655->710] (level:0) is #f with stack state #f #({basic-block #({tag 15:840}) 835 840}) move N25/r6, r1 sub r1, r1, 12 asl r0, r0, 2 move N24/r21, r0 add r0, r0, -11 st r0, N25/r6, -4 st {constant "KLsimple_object_vectorGVKdW"}, N25/r6, -8 add N24/r21, N24/r21, 0 st N24/r21, N25/r6, -12 add N26/r6, N25/r6, -8 move r6, N26/r6 #() [895->900] (level:0) is #f with stack state #f #() bra {tag 15:840} #({tag 3:90}) [90->95] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 20:450}) [450->470] (level:0) is #f with stack state #f #({basic-block #({tag 23:495}) 495 550}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 sub r1, r1, 12 #() [900->905] (level:0) is #f with stack state #f #() bra {tag 23:495} #({tag 21:470}) [470->485] (level:0) is #f with stack state #f #({basic-block #({tag 23:495}) 495 550}) st r5, r1, -4 st r4, r1, -8 sub r1, r1, 8 #() [905->910] (level:0) is #f with stack state #f #() bra {tag 23:495} #({tag 22:485}) [485->495] (level:0) is #f with stack state #f #({basic-block #({tag 23:495}) 495 550}) st r4, r1, -4 sub r1, r1, 4 #() [910->915] (level:0) is #f with stack state #f #() bra {tag 23:495} #({tag 25:560}) [560->575] (level:0) is #f with stack state #f #({basic-block #({tag 27:585}) 585 640}) st r6, r1, -4 st r5, r1, -8 sub r1, r1, 8 #() [915->920] (level:0) is #f with stack state #f #() bra {tag 27:585} #({tag 26:575}) [575->585] (level:0) is #f with stack state #f #({basic-block #({tag 27:585}) 585 640}) st r5, r1, -4 sub r1, r1, 4 #() [920->925] (level:0) is #f with stack state #f #() bra {tag 27:585} #({tag 29:645}) [645->655] (level:0) is #f with stack state #f #({basic-block #({tag 30:655}) 655 710}) st r6, r1, -4 sub r1, r1, 4 #() [925->930] (level:0) is #f with stack state #f #() bra {tag 30:655} +++ ending code for primitive_mep_apply +++ +++ No Source Code Locators for primitive_mep_apply +++ +++ Exported function definition primitive_mep_apply_with_optionals +++ +++ starting code for primitive_mep_apply_with_optionals +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 1:245}) 245 250}) move r22, r3 move N0/r23, r4 move N1/r21, r5 move N2/r21, N1/r21 ld r0, N2/r21, 4 asr r0, r0, 2 add N3/r21, N2/r21, 8 ld N4/r20, r22, 8 ld N4/r20, N4/r20, 4 and N4/r20, N4/r20, 1310720 bne {tag 1:245}, N4/r20, 0 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}, {basic-block #({tag 3:90}) 85 90}) beq {tag 3:90}, r0, 0 #() [65->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 4:95}) 95 105}) beq {tag 4:95}, r0, 1 #() [70->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}, {basic-block #({tag 5:110}) 110 125}) beq {tag 5:110}, r0, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 85}, {basic-block #({tag 6:130}) 130 150}) beq {tag 6:130}, r0, 3 #() [80->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:185}) 185 240}, {basic-block #({tag 7:155}) 155 180}) beq {tag 7:155}, r0, 4 #({tag 2:185}) [185->240] (level:0) is #f with stack state #f #({basic-block #() 240 245}) sub r0, r0, 4 asl N7/r20, r0, 2 sub r1, r1, N7/r20 move N6/r20, r1 add N3/r21, N3/r21, 16 copy-words-down-w N6/r20, N3/r21, r0 move r23, N0/r23 ld r3, N3/r21, -16 ld r4, N3/r21, -12 ld r5, N3/r21, -8 ld r6, N3/r21, -4 #() [240->245] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 1:245}) [245->250] (level:0) is #f with stack state #f #({basic-block #() 250 255}, {basic-block #({tag 9:265}) 265 280}) beq {tag 9:265}, r0, 1 #() [250->255] (level:0) is #f with stack state #f #({basic-block #() 255 260}, {basic-block #({tag 10:285}) 285 305}) beq {tag 10:285}, r0, 2 #() [255->260] (level:0) is #f with stack state #f #({basic-block #() 260 265}, {basic-block #({tag 11:310}) 310 335}) beq {tag 11:310}, r0, 3 #() [260->265] (level:0) is #f with stack state #f #({basic-block #({tag 8:375}) 375 445}, {basic-block #({tag 12:340}) 340 370}) beq {tag 12:340}, r0, 4 #({tag 8:375}) [375->445] (level:0) is #f with stack state #f #({basic-block #() 445 450}) asl N10/r20, r0, 2 add N10/r20, N10/r20, -12 push N10/r20 sub r0, r0, 4 asl N11/r20, r0, 2 sub r1, r1, N11/r20 move N9/r20, r1 add N3/r21, N3/r21, 16 copy-words-down-w N9/r20, N3/r21, r0 move r23, N0/r23 ld r3, N3/r21, -16 ld r4, N3/r21, -12 ld r5, N3/r21, -8 ld r6, N3/r21, -4 #() [445->450] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 3:90}) [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:90}) 90 95}) move r23, N0/r23 #({tag 4:95}) [95->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) move r23, N0/r23 ld r3, N3/r21, 0 #() [105->110] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:110}) [110->125] (level:0) is #f with stack state #f #({basic-block #() 125 130}) move r23, N0/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 #() [125->130] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 6:130}) [130->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) move r23, N0/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 #() [150->155] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 7:155}) [155->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) move r23, N0/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 ld r6, N3/r21, 12 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 9:265}) [265->280] (level:0) is #f with stack state #f #({basic-block #() 280 285}) push 4 move r23, N0/r23 ld r3, N3/r21, 0 #() [280->285] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 10:285}) [285->305] (level:0) is #f with stack state #f #({basic-block #() 305 310}) push 4 move r23, N0/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 #() [305->310] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 11:310}) [310->335] (level:0) is #f with stack state #f #({basic-block #() 335 340}) push 4 move r23, N0/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 #() [335->340] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 12:340}) [340->370] (level:0) is #f with stack state #f #({basic-block #() 370 375}) push 4 move r23, N0/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 ld r6, N3/r21, 12 #() [370->375] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 3:90}) [90->95] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for primitive_mep_apply_with_optionals +++ +++ No Source Code Locators for primitive_mep_apply_with_optionals +++ +++ Exported function definition primitive_apply +++ +++ starting code for primitive_apply +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 2:45}) 45 50}) move r22, r3 move G7/r23, r4 ld N1/r21, G7/r23, 4 asr N1/r21, N1/r21, 2 beq {tag 2:45}, N1/r21, 1 #() [30->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 3:55}) 55 65}) beq {tag 3:55}, N1/r21, 2 #() [35->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 4:70}) 70 85}) beq {tag 4:70}, N1/r21, 3 #() [40->45] (level:0) is #f with stack state #f #({basic-block #({tag 1:115}) 115 190}, {basic-block #({tag 5:90}) 90 110}) beq {tag 5:90}, N1/r21, 4 #({tag 1:115}) [115->190] (level:0) is #f with stack state #f #({basic-block #() 190 195}) asl N3/r20, N1/r21, 2 sub r1, r1, N3/r20 sub N2/r21, N1/r21, 4 add r1, r1, 16 move N6/r20, r1 add N5/r19, G7/r23, 24 copy-words-down-w N6/r20, N5/r19, N2/r21 ld N1/r21, G7/r23, 4 asr N1/r21, N1/r21, 2 move r0, N1/r21 add G7/r23, G7/r23, 8 ld r3, G7/r23, 0 ld r4, G7/r23, 4 ld r5, G7/r23, 8 ld r6, G7/r23, 12 #() [190->195] (level:0) is #f with stack state #f #() jmp {constant "apply_xep"}, #[4, #"function", #"arg-count"], 0, #f, #f #({tag 2:45}) [45->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}) ld r3, G7/r23, 8 #() [50->55] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_0"}, #[4, #"function"], 0, #f, #f #({tag 3:55}) [55->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) ld r3, G7/r23, 8 ld r4, G7/r23, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_1"}, #[4, #"function"], 0, #f, #f #({tag 4:70}) [70->85] (level:0) is #f with stack state #f #({basic-block #() 85 90}) ld r3, G7/r23, 8 ld r4, G7/r23, 12 ld r5, G7/r23, 16 #() [85->90] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_2"}, #[4, #"function"], 0, #f, #f #({tag 5:90}) [90->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) ld r3, G7/r23, 8 ld r4, G7/r23, 12 ld r5, G7/r23, 16 ld r6, G7/r23, 20 #() [110->115] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_3"}, #[4, #"function"], 0, #f, #f +++ ending code for primitive_apply +++ +++ No Source Code Locators for primitive_apply +++ +++ Exported function definition primitive_remove_optionals +++ +++ starting code for primitive_remove_optionals +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 65}) rem "This is a dummy first basic block." #() [5->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) push r22 push r23 add N1/r21, r7, 8 ld N2/r21, r1, N1/r21 move N3/r23, r7 sub N2/r21, N2/r21, N3/r23 move N5/r22, r7 add N0/r23, r1, 8 add N4/r20, N0/r23, N2/r21 copy-words-up N4/r20, N0/r23, N5/r22 pop r23 pop r22 #() [65->70] (level:0) is #f with stack state #f #() rts-and-drop N2/r21 +++ ending code for primitive_remove_optionals +++ +++ No Source Code Locators for primitive_remove_optionals +++ +++ Exported function definition primitive_start_timer +++ +++ starting code for primitive_start_timer +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:30}) 30 45}) rem "This is a dummy first basic block." #({tag 2:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 20}) sub r1, r1, 24 call-alien {constant "c_primitive_start_timer"}, 0 #() [15->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) add r1, r1, 24 #({tag 1:25}) [25->30] (level:0) is #f with stack state #f #({basic-block #() 20 25}) preserve-registers-exit #() [20->25] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_start_timer +++ +++ Live variable scopes for primitive_start_timer +++ Start scope at 8 with frame for no variables End scope at 19 +++ No Source Code Locators for primitive_start_timer +++ +++ Exported function definition primitive_stop_timer +++ +++ starting code for primitive_stop_timer +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:30}) 30 45}) rem "This is a dummy first basic block." #({tag 2:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 20}) sub r1, r1, 24 call-alien {constant "c_primitive_stop_timer"}, 0 #() [15->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) add r1, r1, 24 #({tag 1:25}) [25->30] (level:0) is #f with stack state #f #({basic-block #() 20 25}) preserve-registers-exit #() [20->25] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_stop_timer +++ +++ Live variable scopes for primitive_stop_timer +++ Start scope at 8 with frame for no variables End scope at 19 +++ No Source Code Locators for primitive_stop_timer +++ +++ Exported function definition primitive_exit_application +++ +++ starting code for primitive_exit_application +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:35}) 35 50}) rem "This is a dummy first basic block." #({tag 2:35}) [35->50] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}) sub r1, r1, 24 move r3, r3 call-alien {constant "exit"}, 0 #() [20->25] (level:0) is red with stack state with #({basic-block #({tag 1:30}) 30 35}) add r1, r1, 24 #({tag 1:30}) [30->35] (level:0) is #f with stack state #f #({basic-block #() 25 30}) preserve-registers-exit #() [25->30] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_exit_application +++ +++ Live variable scopes for primitive_exit_application +++ Start scope at 8 with frame for no variables End scope at 19 +++ No Source Code Locators for primitive_exit_application +++ +++ Exported function definition primitive_run_application +++ +++ starting code for primitive_run_application +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:35}) 35 50}) rem "This is a dummy first basic block." #({tag 2:35}) [35->50] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}) sub r1, r1, 24 move r3, r3 call-alien {constant "system"}, 0 #() [20->25] (level:0) is red with stack state with #({basic-block #({tag 1:30}) 30 35}) add r1, r1, 24 #({tag 1:30}) [30->35] (level:0) is #f with stack state #f #({basic-block #() 25 30}) preserve-registers-exit #() [25->30] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_run_application +++ +++ Live variable scopes for primitive_run_application +++ Start scope at 8 with frame for no variables End scope at 19 +++ No Source Code Locators for primitive_run_application +++ +++ Exported function definition make_foreign_thread_internal +++ +++ starting code for make_foreign_thread_internal +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "Kmake_foreign_threadYthreads_primitivesVdylanI"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for make_foreign_thread_internal +++ +++ Live variable scopes for make_foreign_thread_internal +++ Start scope at 10 with frame for no variables End scope at 17 +++ No Source Code Locators for make_foreign_thread_internal +++ +++ Exported function definition primitive_ensure_valid_teb +++ +++ starting code for primitive_ensure_valid_teb +++ #() [0->5] (level:0) is green with stack state before #({basic-block #({tag 13:350}) 350 365}) rem "This is a dummy first basic block." #({tag 13:350}) [350->365] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is green with stack state with #({basic-block #() 15 30}, {basic-block #({tag 1:280}) 280 290}) ld N0/NSPILL-0, {indirect-constant "Pteb_tlv_index"}, 0 bne {tag 1:280}, N0/NSPILL-0, 0 #() [15->30] (level:0) is red with stack state with #({basic-block #() 30 75}) sub r1, r1, 24 move r3, 340 call-alien {constant "dylan__malloc__misc"}, 0 #() [30->75] (level:0) is red with stack state with #({basic-block #() 75 80}) add r1, r1, 24 move N1/NSPILL-0, r3 add N2/NSPILL-1, N1/NSPILL-0, 12 add N3/r5, N2/NSPILL-1, 328 sub r1, r1, 24 move r3, N1/NSPILL-0 move r4, N1/NSPILL-0 move r5, N3/r5 call-alien {constant "MMRegisterRootAmbig"}, 0 #() [75->80] (level:0) is red with stack state with #({basic-block #({tag 8:310}) 310 315}) add r1, r1, 24 #({tag 8:310}) [310->315] (level:1) is green with stack state with #({basic-block #({tag 9:85}) 85 90}, {basic-block #({tag 8:310}) 310 315}) conditional-move {tag 8:310}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 9:85}) [85->90] (level:0) is red with stack state with #({basic-block #() 90 95}, {basic-block #({tag 2:95}) 95 180}) beq {tag 2:95}, {indirect-constant "Pteb_chain"}, 0 #() [90->95] (level:0) is red with stack state with #({basic-block #({tag 2:95}) 95 180}) st N1/NSPILL-0, {indirect-constant "Pteb_chain"}, 8 #({tag 2:95}) [95->180] (level:0) is red with stack state with #({basic-block #() 180 190}) st {indirect-constant "Pteb_chain"}, N1/NSPILL-0, 4 st 0, N1/NSPILL-0, 8 move {indirect-constant "Pteb_chain"}, N1/NSPILL-0 move {indirect-constant "Pruntime_spin_lock"}, 0 add N0/NSPILL-0, N2/NSPILL-1, 32 st 0, N2/NSPILL-1, 0 st 0, N2/NSPILL-1, 4 st 0, N0/NSPILL-0, 0 st {constant "KPempty_listVKi"}, N0/NSPILL-0, 16 st {constant "KPunboundVKi"}, N0/NSPILL-0, 4 set-teb N0/NSPILL-0 st N0/NSPILL-0, {indirect-constant "Pteb_tlv_index"}, 0 st 0, N0/NSPILL-0, 20 or N4/r3, r1, 8188 sub r1, r1, 24 move r3, N4/r3 call-alien {constant "dylan_mm_register_thread"}, 0 #() [180->190] (level:0) is red with stack state with #({basic-block #() 190 200}, {basic-block #({tag 6:295}) 295 310}) add r1, r1, 24 beq {tag 6:295}, r3, 0 #() [190->200] (level:0) is red with stack state with #({basic-block #({tag 6:295}) 295 310}) st 0, {indirect-constant "Pteb_tlv_index"}, 0 halt #({tag 6:295}) [295->310] (level:1) is green with stack state with #({basic-block #({tag 7:215}) 215 265}, {basic-block #({tag 6:295}) 295 310}) move N5/r23, {indirect-constant "Pruntime_thread_count"} add N6/r22, N5/r23, 1 conditional-move {tag 6:295}, {indirect-constant "Pruntime_thread_count"}, N6/r22, N5/r23 #({tag 7:215}) [215->265] (level:0) is red with stack state with #({basic-block #() 265 280}) init-control-word push 0 move N7/r3, r1 st -1, N0/NSPILL-0, 20 sub r1, r1, 24 move r3, N7/r3 move r4, {constant "make_foreign_thread_internal"} move r5, 0 move r6, 0 call-alien {constant "dylan_init_thread"}, 0 #() [265->280] (level:0) is red with stack state with #({basic-block #({tag 1:280}) 280 290}) add r1, r1, 24 add r1, r1, 4 st 0, N0/NSPILL-0, 20 #({tag 1:280}) [280->290] (level:0) is green with stack state with #({basic-block #({tag 10:315}) 315 320}) set-teb N0/NSPILL-0 move r3, N0/NSPILL-0 #({tag 10:315}) [315->320] (level:0) is #f with stack state #f #({basic-block #() 290 295}) preserve-registers-exit #() [290->295] (level:0) is green with stack state #f #() rts +++ ending code for primitive_ensure_valid_teb +++ +++ Frame sizes for primitive_ensure_valid_teb: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_ensure_valid_teb +++ Start scope at 8 with frame for no variables End scope at 297 +++ No Source Code Locators for primitive_ensure_valid_teb +++ +++ Exported function definition dylan_call_in +++ +++ starting code for dylan_call_in +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:110}) 110 125}) rem "This is a dummy first basic block." #({tag 3:110}) [110->125] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 70}) move N4/NSPILL-0, r12 move N5/r29, r3 call {constant "primitive_ensure_valid_teb"}, 0 #() [20->70] (level:0) is red with stack state with #({basic-block #() 70 100}) move N0/NSPILL-1, r3 st -1, N0/NSPILL-1, 20 load-address-of-stack-arg-n #t, N2/r12, 0 push N2/r12 push N5/r29 move N3/r3, r1 sub r1, r1, 24 move r3, N3/r3 move r4, N4/NSPILL-0 call-alien {constant "dylan_callin_handler"}, 0 #() [70->100] (level:0) is red with stack state with #({basic-block #({tag 2:105}) 105 110}) add r1, r1, 24 add r1, r1, 8 move N1/r3, r3 st 0, N0/NSPILL-1, 20 move r3, N1/r3 asl r0, N4/NSPILL-0, 2 #({tag 2:105}) [105->110] (level:0) is #f with stack state #f #({basic-block #() 100 105}) preserve-registers-exit #() [100->105] (level:0) is red with stack state #f #() rts-and-drop r0 +++ ending code for dylan_call_in +++ +++ Frame sizes for dylan_call_in: GC: 0, NC: 2 +++ +++ Live variable scopes for dylan_call_in +++ Start scope at 10 with frame for no variables End scope at 65 +++ No Source Code Locators for dylan_call_in +++ +++ Exported function definition dylan_call_in_syscall +++ +++ starting code for dylan_call_in_syscall +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:105}) 105 120}) rem "This is a dummy first basic block." #({tag 3:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 70}) move N4/r28, r12 move N5/r29, r3 call {constant "primitive_ensure_valid_teb"}, 0 #() [20->70] (level:0) is red with stack state with #({basic-block #() 70 95}) move N0/NSPILL-0, r3 st -1, N0/NSPILL-0, 20 load-address-of-stack-arg-n #t, N2/r12, 0 push N2/r12 push N5/r29 move N3/r3, r1 sub r1, r1, 24 move r3, N3/r3 move r4, N4/r28 call-alien {constant "dylan_callin_handler"}, 0 #() [70->95] (level:0) is red with stack state with #({basic-block #({tag 2:100}) 100 105}) add r1, r1, 24 add r1, r1, 8 move N1/r3, r3 st 0, N0/NSPILL-0, 20 move r3, N1/r3 #({tag 2:100}) [100->105] (level:0) is #f with stack state #f #({basic-block #() 95 100}) preserve-registers-exit #() [95->100] (level:0) is red with stack state #f #() rts +++ ending code for dylan_call_in_syscall +++ +++ Frame sizes for dylan_call_in_syscall: GC: 0, NC: 1 +++ +++ Live variable scopes for dylan_call_in_syscall +++ Start scope at 10 with frame for no variables End scope at 61 +++ No Source Code Locators for dylan_call_in_syscall +++ +++ Exported function definition dylan_callin_internal +++ +++ starting code for dylan_callin_internal +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 12:365}) 365 380}) rem "This is a dummy first basic block." #({tag 12:365}) [365->380] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 3:65}) 65 120}) move N0/r3, r3 move N1/r4, r4 ld N2/r11, N0/r3, 0 ld N3/r3, N0/r3, 4 bgt {tag 3:65}, N1/r4, 7 #() [30->35] (level:0) is red with stack state with #({basic-block #() 35 40}, {basic-block #({tag 4:120}) 120 165}) bgt {tag 4:120}, N1/r4, 6 #() [35->40] (level:0) is red with stack state with #({basic-block #() 40 45}, {basic-block #({tag 5:165}) 165 205}) bgt {tag 5:165}, N1/r4, 5 #() [40->45] (level:0) is red with stack state with #({basic-block #() 45 50}, {basic-block #({tag 6:205}) 205 240}) bgt {tag 6:205}, N1/r4, 4 #() [45->50] (level:0) is red with stack state with #({basic-block #() 50 55}, {basic-block #({tag 7:240}) 240 270}) bgt {tag 7:240}, N1/r4, 3 #() [50->55] (level:0) is red with stack state with #({basic-block #() 55 60}, {basic-block #({tag 8:270}) 270 295}) bgt {tag 8:270}, N1/r4, 2 #() [55->60] (level:0) is red with stack state with #({basic-block #() 60 65}, {basic-block #({tag 9:295}) 295 315}) bgt {tag 9:295}, N1/r4, 1 #() [60->65] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}, {basic-block #({tag 10:315}) 315 330}) bgt {tag 10:315}, N1/r4, 0 #({tag 2:350}) [350->355] (level:0) is red with stack state with #({basic-block #() 355 355}) call-alien N2/r11, 0 #() [355->355] (level:0) is red with stack state with #({basic-block #({tag 11:360}) 360 365}) #({tag 11:360}) [360->365] (level:0) is #f with stack state #f #({basic-block #() 355 360}) preserve-registers-exit #() [355->360] (level:0) is red with stack state #f #() rts #({tag 3:65}) [65->120] (level:0) is red with stack state with #({basic-block #({tag 1:330}) 330 350}, {basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 ld r4, N3/r3, 4 ld r5, N3/r3, 8 ld r6, N3/r3, 12 ld r7, N3/r3, 16 ld r8, N3/r3, 20 ld r9, N3/r3, 24 ld r10, N3/r3, 28 add N3/r3, N3/r3, 32 sub N1/r4, N1/r4, 8 beq {tag 2:350}, N1/r4, 8 #({tag 1:330}) [330->350] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) asl N4/r12, N1/r4, 2 sub r1, r1, N4/r12 move N5/r12, r1 copy-words-down-w N5/r12, N3/r3, N1/r4 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 2:350} #({tag 4:120}) [120->165] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 ld r4, N3/r3, 4 ld r5, N3/r3, 8 ld r6, N3/r3, 12 ld r7, N3/r3, 16 ld r8, N3/r3, 20 ld r9, N3/r3, 24 rem "eliminated" rem "eliminated" #() [385->390] (level:0) is #f with stack state #f #() bra {tag 2:350} #({tag 5:165}) [165->205] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 ld r4, N3/r3, 4 ld r5, N3/r3, 8 ld r6, N3/r3, 12 ld r7, N3/r3, 16 ld r8, N3/r3, 20 rem "eliminated" rem "eliminated" #() [390->395] (level:0) is #f with stack state #f #() bra {tag 2:350} #({tag 6:205}) [205->240] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 ld r4, N3/r3, 4 ld r5, N3/r3, 8 ld r6, N3/r3, 12 ld r7, N3/r3, 16 rem "eliminated" rem "eliminated" #() [395->400] (level:0) is #f with stack state #f #() bra {tag 2:350} #({tag 7:240}) [240->270] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 ld r4, N3/r3, 4 ld r5, N3/r3, 8 ld r6, N3/r3, 12 rem "eliminated" rem "eliminated" #() [400->405] (level:0) is #f with stack state #f #() bra {tag 2:350} #({tag 8:270}) [270->295] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 ld r4, N3/r3, 4 ld r5, N3/r3, 8 rem "eliminated" rem "eliminated" #() [405->410] (level:0) is #f with stack state #f #() bra {tag 2:350} #({tag 9:295}) [295->315] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 ld r4, N3/r3, 4 rem "eliminated" rem "eliminated" #() [410->415] (level:0) is #f with stack state #f #() bra {tag 2:350} #({tag 10:315}) [315->330] (level:0) is red with stack state with #({basic-block #({tag 2:350}) 350 355}) ld r3, N3/r3, 0 rem "eliminated" rem "eliminated" #() [415->420] (level:0) is #f with stack state #f #() bra {tag 2:350} +++ ending code for dylan_callin_internal +++ +++ Live variable scopes for dylan_callin_internal +++ Start scope at 10 with frame for no variables End scope at 49 +++ No Source Code Locators for dylan_callin_internal +++ +++ Exported function definition inside_dylan_ffi_barrier +++ +++ starting code for inside_dylan_ffi_barrier +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is green with stack state #f #({basic-block #() 20 25}, {basic-block #({tag 1:30}) 25 30}) ld N0/r3, {indirect-constant "Pteb_tlv_index"}, 0 ld N1/r3, N0/r3, 20 beq {tag 1:30}, N1/r3, -1 #() [20->25] (level:0) is green with stack state #f #({basic-block #({tag 1:30}) 25 30}) move N1/r3, 0 #({tag 1:30}) [25->30] (level:0) is green with stack state #f #({basic-block #({tag 1:30}) 30 35}) move r3, N1/r3 #({tag 1:30}) [30->35] (level:0) is green with stack state #f #() rts +++ ending code for inside_dylan_ffi_barrier +++ +++ No Source Code Locators for inside_dylan_ffi_barrier +++ +++ Defining function primitive_register_traced_roots in section init-code +++ +++ Exported function definition primitive_register_traced_roots +++ +++ starting code for primitive_register_traced_roots +++ #() [0->5] (level:0) is green with stack state before #({basic-block #({tag 5:165}) 165 180}) rem "This is a dummy first basic block." #({tag 5:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 5 55}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->55] (level:0) is green with stack state with #({basic-block #() 55 80}, {basic-block #({tag 1:85}) 85 90}) move N0/r23, r3 move N1/r4, r4 move N2/r5, r5 move N3/NSPILL-0, r6 load-stack-arg-n #t, N4/NSPILL--1, 0 load-stack-arg-n #t, N5/NSPILL--2, 1 load-stack-arg-n #t, N6/NSPILL--3, 2 load-stack-arg-n #t, N7/NSPILL--4, 3 load-stack-arg-n #t, N8/NSPILL--5, 4 beq {tag 1:85}, N0/r23, N1/r4 #() [55->80] (level:0) is red with stack state with #({basic-block #() 80 85}) sub r1, r1, 24 move r3, N2/r5 move r4, N0/r23 move r5, N1/r4 call-alien {constant "MMRegisterRootAmbig"}, 0 #() [80->85] (level:0) is red with stack state with #({basic-block #({tag 1:85}) 85 90}) add r1, r1, 24 #({tag 1:85}) [85->90] (level:0) is green with stack state with #({basic-block #() 90 115}, {basic-block #({tag 2:120}) 120 125}) beq {tag 2:120}, N3/NSPILL-0, N4/NSPILL--1 #() [90->115] (level:0) is red with stack state with #({basic-block #() 115 120}) sub r1, r1, 24 move r3, N5/NSPILL--2 move r4, N3/NSPILL-0 move r5, N4/NSPILL--1 call-alien {constant "MMRegisterRootStatic"}, 0 #() [115->120] (level:0) is red with stack state with #({basic-block #({tag 2:120}) 120 125}) add r1, r1, 24 #({tag 2:120}) [120->125] (level:0) is green with stack state with #({basic-block #() 125 150}, {basic-block #({tag 3:160}) 155 155}) beq {tag 3:160}, N6/NSPILL--3, N7/NSPILL--4 #() [125->150] (level:0) is red with stack state with #({basic-block #() 150 155}) sub r1, r1, 24 move r3, N8/NSPILL--5 move r4, N6/NSPILL--3 move r5, N7/NSPILL--4 call-alien {constant "MMRegisterRootExact"}, 0 #() [150->155] (level:0) is red with stack state with #({basic-block #({tag 3:160}) 155 155}) add r1, r1, 24 #({tag 3:160}) [155->155] (level:0) is green with stack state with #({basic-block #({tag 3:160}, {tag 4:160}) 160 165}) #({tag 3:160}, {tag 4:160}) [160->165] (level:0) is #f with stack state #f #({basic-block #() 155 160}) preserve-registers-exit #() [155->160] (level:0) is green with stack state #f #() rts-and-drop 20 +++ ending code for primitive_register_traced_roots +++ +++ Frame sizes for primitive_register_traced_roots: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_register_traced_roots +++ Start scope at 8 with frame for no variables End scope at 87 +++ No Source Code Locators for primitive_register_traced_roots +++ +++ Exported function definition call_dylan_exit_functions_internal +++ +++ starting code for call_dylan_exit_functions_internal +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "Kcall_application_exit_functionsVKeI"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for call_dylan_exit_functions_internal +++ +++ Live variable scopes for call_dylan_exit_functions_internal +++ Start scope at 10 with frame for no variables End scope at 17 +++ No Source Code Locators for call_dylan_exit_functions_internal +++ +++ Exported function definition call_dylan_exit_functions +++ +++ starting code for call_dylan_exit_functions +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move r12, 0 move r3, {constant "call_dylan_exit_functions_internal"} #() [15->20] (level:0) is green with stack state #f #() jmp-alien {constant "dylan_call_in_syscall"}, #[1, #"arg-count"], 0, #f, #f +++ ending code for call_dylan_exit_functions +++ +++ No Source Code Locators for call_dylan_exit_functions +++ +++ Defining function primitive_deregister_traced_roots in section init-code +++ +++ Exported function definition primitive_deregister_traced_roots +++ +++ starting code for primitive_deregister_traced_roots +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:145}) 145 160}) rem "This is a dummy first basic block." #({tag 3:145}) [145->160] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 35}, {basic-block #({tag 1:60}) 60 80}) move N1/NSPILL-2, r3 move N2/NSPILL-1, r4 move N3/NSPILL-0, r5 bne {tag 1:60}, {indirect-constant "Pstarted_unloading"}, 0 #() [25->35] (level:0) is red with stack state with #({basic-block #() 35 55}) sub r1, r1, 24 call-alien {constant "call_dylan_exit_functions"}, 0 #() [35->55] (level:0) is red with stack state with #({basic-block #() 55 60}) add r1, r1, 24 move {indirect-constant "Pstarted_unloading"}, 1 sub r1, r1, 24 call-alien {constant "primitive_mps_park"}, 0 #() [55->60] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 80}) add r1, r1, 24 #({tag 1:60}) [60->80] (level:0) is red with stack state with #({basic-block #() 80 105}) ld N0/r3, N1/NSPILL-2, 0 sub r1, r1, 24 move r3, N0/r3 call-alien {constant "MMDeregisterRoot"}, 0 #() [80->105] (level:0) is red with stack state with #({basic-block #() 105 130}) add r1, r1, 24 ld N0/r3, N2/NSPILL-1, 0 sub r1, r1, 24 move r3, N0/r3 call-alien {constant "MMDeregisterRoot"}, 0 #() [105->130] (level:0) is red with stack state with #({basic-block #() 130 135}) add r1, r1, 24 ld N0/r3, N3/NSPILL-0, 0 sub r1, r1, 24 move r3, N0/r3 call-alien {constant "MMDeregisterRoot"}, 0 #() [130->135] (level:0) is red with stack state with #({basic-block #({tag 2:140}) 140 145}) add r1, r1, 24 #({tag 2:140}) [140->145] (level:0) is #f with stack state #f #({basic-block #() 135 140}) preserve-registers-exit #() [135->140] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_deregister_traced_roots +++ +++ Frame sizes for primitive_deregister_traced_roots: GC: 0, NC: 3 +++ +++ Live variable scopes for primitive_deregister_traced_roots +++ Start scope at 8 with frame for no variables End scope at 101 +++ No Source Code Locators for primitive_deregister_traced_roots +++ +++ Exported function definition dylan_init_thread_local +++ +++ starting code for dylan_init_thread_local +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 5}) rem "This is a dummy first basic block." #() [5->5] (level:0) is green with stack state #f #({basic-block #() 5 10}) #() [5->10] (level:0) is green with stack state #f #() jmp {constant "dylan_init_thread"}, 0, 0, #f, #f +++ ending code for dylan_init_thread_local +++ +++ No Source Code Locators for dylan_init_thread_local +++ +++ Defining function primitive_call_first_dylan_iep in section init-code +++ +++ Exported function definition primitive_call_first_dylan_iep +++ +++ starting code for primitive_call_first_dylan_iep +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) move N0/r3, r3 #() [10->15] (level:0) is green with stack state #f #() jmp N0/r3, 0, 0, #f, #f +++ ending code for primitive_call_first_dylan_iep +++ +++ No Source Code Locators for primitive_call_first_dylan_iep +++ +++ Defining function init_dylan_data in section init-code +++ +++ starting code for init_dylan_data +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:65}) 65 80}) rem "This is a dummy first basic block." #({tag 2:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #() 5 55}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->55] (level:0) is red with stack state with #({basic-block #() 55 55}) push {constant "Pexact_root"} push {constant "_dylan_vars_end"} push {constant "_dylan_vars_start"} push {constant "Pstatic_root"} push {constant "_dylan_objs_end"} move r3, {constant "_dylan_data_start"} move r4, {constant "_dylan_data_end"} move r5, {constant "Pambig_root"} move r6, {constant "_dylan_objs_start"} call {constant "primitive_register_traced_roots"}, 4 #() [55->55] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 65}) #({tag 1:60}) [60->65] (level:0) is #f with stack state #f #({basic-block #() 55 60}) preserve-registers-exit #() [55->60] (level:0) is red with stack state #f #() rts +++ ending code for init_dylan_data +++ +++ Live variable scopes for init_dylan_data +++ Start scope at 10 with frame for no variables End scope at 63 +++ No Source Code Locators for init_dylan_data +++ +++ Defining function call_init_dylan in section init-code +++ +++ starting code for call_init_dylan +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {indirect-constant "_init_dylan_library"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for call_init_dylan +++ +++ Live variable scopes for call_init_dylan +++ Start scope at 10 with frame for no variables End scope at 17 +++ No Source Code Locators for call_init_dylan +++ +++ Defining function dylan_initialize in section init-code +++ +++ starting code for dylan_initialize +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:95}) 95 110}) rem "This is a dummy first basic block." #({tag 2:95}) [95->110] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 70}) push 0 move N0/NSPILL-1, r1 sub r1, r1, 24 call-alien {constant "init_dylan_data"}, 0 #() [25->70] (level:0) is red with stack state with #({basic-block #() 70 85}) add r1, r1, 24 get-teb N1/NSPILL-0 st -1, N1/NSPILL-0, 20 sub r1, r1, 24 move r3, N0/NSPILL-1 move r4, {constant "call_init_dylan"} move r5, 0 move r6, 0 call-alien {constant "dylan_init_thread_local"}, 0 #() [70->85] (level:0) is red with stack state with #({basic-block #({tag 1:90}) 90 95}) add r1, r1, 24 st 0, N1/NSPILL-0, 20 move r3, 0 #({tag 1:90}) [90->95] (level:0) is #f with stack state #f #({basic-block #() 85 90}) preserve-registers-exit #() [85->90] (level:0) is red with stack state #f #() rts +++ ending code for dylan_initialize +++ +++ Frame sizes for dylan_initialize: GC: 0, NC: 2 +++ +++ Live variable scopes for dylan_initialize +++ Start scope at 10 with frame for no variables End scope at 69 +++ No Source Code Locators for dylan_initialize +++ +++ Defining function dylan_main in section init-code +++ +++ starting code for dylan_main +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:60}) 60 75}) rem "This is a dummy first basic block." #({tag 2:60}) [60->75] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 40}) sub r1, r1, 24 call-alien {constant "dylan_initialize"}, 0 #() [15->40] (level:0) is red with stack state with #({basic-block #() 40 50}) add r1, r1, 24 move r3, {constant "Pambig_root"} move r4, {constant "Pstatic_root"} move r5, {constant "Pexact_root"} call {constant "primitive_deregister_traced_roots"}, 3 #() [40->50] (level:0) is red with stack state with #({basic-block #() 50 50}) move r3, r3 call {constant "primitive_exit_application"}, 1 #() [50->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) #({tag 1:55}) [55->60] (level:0) is #f with stack state #f #({basic-block #() 50 55}) preserve-registers-exit #() [50->55] (level:0) is red with stack state #f #() rts +++ ending code for dylan_main +++ +++ Live variable scopes for dylan_main +++ Start scope at 10 with frame for no variables End scope at 49 +++ No Source Code Locators for dylan_main +++ +++ Defining function dylan_main_0 in section init-code +++ +++ Exported function definition dylan_main_0 +++ +++ starting code for dylan_main_0 +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 26:585}) 585 600}) rem "This is a dummy first basic block." #({tag 26:585}) [585->600] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 85}) move r25, {constant "Pthread_local_storage"} sub r1, r1, 24 move r3, 4 call-alien {constant "dylan__malloc__misc"}, 0 #() [25->85] (level:0) is red with stack state with #({basic-block #() 85 110}) add r1, r1, 24 move {indirect-constant "Pteb_tlv_index"}, r3 st 0, {constant "Pmaster_gc_teb"}, 0 st 0, {constant "Pmaster_gc_teb"}, 4 st 0, {constant "Pmaster_teb"}, 0 st {constant "KPempty_listVKi"}, {constant "Pmaster_teb"}, 16 st {constant "KPunboundVKi"}, {constant "Pmaster_teb"}, 4 set-teb {constant "Pmaster_teb"} st {constant "Pmaster_teb"}, {indirect-constant "Pteb_tlv_index"}, 0 st 0, {constant "Pmaster_teb"}, 20 sub r1, r1, 24 call-alien {constant "dylan_init_memory_manager"}, 0 #() [85->110] (level:0) is red with stack state with #({basic-block #() 110 120}) add r1, r1, 24 or N0/r3, r1, 8188 sub r1, r1, 24 move r3, N0/r3 call-alien {constant "dylan_mm_register_thread"}, 0 #() [110->120] (level:0) is red with stack state with #({basic-block #() 120 130}, {basic-block #({tag 19:505}) 505 520}) add r1, r1, 24 beq {tag 19:505}, r3, 0 #() [120->130] (level:0) is red with stack state with #({basic-block #({tag 19:505}) 505 520}) st 0, {indirect-constant "Pteb_tlv_index"}, 0 halt #({tag 19:505}) [505->520] (level:1) is green with stack state with #({basic-block #({tag 20:145}) 145 160}, {basic-block #({tag 19:505}) 505 520}) move N1/r12, {indirect-constant "Pruntime_thread_count"} add N2/r6, N1/r12, 1 conditional-move {tag 19:505}, {indirect-constant "Pruntime_thread_count"}, N2/r6, N1/r12 #({tag 20:145}) [145->160] (level:0) is red with stack state with #({basic-block #() 160 185}) init-control-word sub r1, r1, 24 call-alien {constant "dylan_initialize"}, 0 #() [160->185] (level:0) is red with stack state with #({basic-block #() 185 195}) add r1, r1, 24 move r3, {constant "Pambig_root"} move r4, {constant "Pstatic_root"} move r5, {constant "Pexact_root"} call {constant "primitive_deregister_traced_roots"}, 3 #() [185->195] (level:0) is red with stack state with #({basic-block #() 195 210}, {basic-block #({tag 5:235}) 235 240}) ld N3/r12, {constant "Pmaster_gc_teb"}, 4 beq {tag 5:235}, N3/r12, 0 #() [195->210] (level:0) is red with stack state with #({basic-block #() 210 220}) sub r1, r1, 24 move r3, {constant "Pmaster_gc_teb"} call-alien {constant "dylan_mm_deregister_thread_from_teb"}, 0 #() [210->220] (level:0) is red with stack state with #({basic-block #({tag 18:490}) 490 505}) add r1, r1, 24 st 0, {constant "Pmaster_gc_teb"}, 4 #({tag 18:490}) [490->505] (level:1) is green with stack state with #({basic-block #({tag 5:235}) 235 240}, {basic-block #({tag 18:490}) 490 505}) move N4/r12, {indirect-constant "Pruntime_thread_count"} sub N5/r6, N4/r12, 1 conditional-move {tag 18:490}, {indirect-constant "Pruntime_thread_count"}, N5/r6, N4/r12 #({tag 5:235}) [235->240] (level:0) is green with stack state with #({basic-block #({tag 8:240}) 240 245}) move N6/NSPILL-1, {indirect-constant "Pteb_chain"} #({tag 8:240}) [240->245] (level:1) is green with stack state with #({basic-block #() 245 260}, {basic-block #({tag 7:410}) 410 430}) beq {tag 7:410}, N6/NSPILL-1, 0 #() [245->260] (level:1) is green with stack state with #({basic-block #() 260 275}, {basic-block #({tag 9:300}) 300 310}) add N7/NSPILL-0, N6/NSPILL-1, 12 ld N8/r12, N7/NSPILL-0, 4 beq {tag 9:300}, N8/r12, 0 #() [260->275] (level:1) is red with stack state with #({basic-block #() 275 285}) sub r1, r1, 24 move r3, N7/NSPILL-0 call-alien {constant "dylan_mm_deregister_thread_from_teb"}, 0 #() [275->285] (level:1) is red with stack state with #({basic-block #({tag 17:475}) 475 490}) add r1, r1, 24 st 0, N7/NSPILL-0, 4 #({tag 17:475}) [475->490] (level:2) is green with stack state with #({basic-block #({tag 9:300}) 300 310}, {basic-block #({tag 17:475}) 475 490}) move N9/r12, {indirect-constant "Pruntime_thread_count"} sub N10/r6, N9/r12, 1 conditional-move {tag 17:475}, {indirect-constant "Pruntime_thread_count"}, N10/r6, N9/r12 #({tag 9:300}) [300->310] (level:1) is green with stack state with #({basic-block #({tag 15:470}) 470 475}) ld N6/NSPILL-1, N6/NSPILL-1, 4 sub N11/r3, N7/NSPILL-0, 12 #({tag 15:470}) [470->475] (level:2) is green with stack state with #({basic-block #({tag 16:315}) 315 330}, {basic-block #({tag 15:470}) 470 475}) conditional-move {tag 15:470}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 16:315}) [315->330] (level:1) is red with stack state with #({basic-block #() 330 335}, {basic-block #({tag 11:335}) 335 340}) ld N12/r12, N11/r3, 4 ld N13/r11, N11/r3, 8 bne {tag 11:335}, {indirect-constant "Pteb_chain"}, N11/r3 #() [330->335] (level:1) is red with stack state with #({basic-block #({tag 12:340}) 340 345}) move {indirect-constant "Pteb_chain"}, N12/r12 #({tag 12:340}) [340->345] (level:1) is red with stack state with #({basic-block #() 345 350}, {basic-block #({tag 13:350}) 350 375}) beq {tag 13:350}, N12/r12, 0 #() [345->350] (level:1) is red with stack state with #({basic-block #({tag 13:350}) 350 375}) st N13/r11, N12/r12, 8 #({tag 13:350}) [350->375] (level:1) is red with stack state with #({basic-block #() 375 405}) move {indirect-constant "Pruntime_spin_lock"}, 0 ld N11/r3, N7/NSPILL-0, -12 sub r1, r1, 24 move r3, N11/r3 call-alien {constant "MMDeregisterRoot"}, 0 #() [375->405] (level:1) is red with stack state with #({basic-block #() 405 410}) add r1, r1, 24 sub N11/r3, N7/NSPILL-0, 12 sub r1, r1, 24 move r3, N11/r3 move r4, 340 call-alien {constant "MMFreeMisc"}, 0 #() [405->410] (level:1) is red with stack state with #({basic-block #({tag 8:240}) 240 245}) add r1, r1, 24 #() [600->605] (level:0) is #f with stack state #f #() bra {tag 8:240} #({tag 7:410}) [410->430] (level:1) is red with stack state with #({basic-block #() 430 440}) sub r1, r1, 24 move r3, {indirect-constant "Pteb_tlv_index"} move r4, 4 call-alien {constant "MMFreeMisc"}, 0 #() [430->440] (level:1) is red with stack state with #({basic-block #() 440 450}, {basic-block #({tag 4:455}) 455 465}) add r1, r1, 24 bne {tag 4:455}, {indirect-constant "Pruntime_thread_count"}, 0 #() [440->450] (level:1) is red with stack state with #({basic-block #() 450 455}) sub r1, r1, 24 call-alien {constant "dylan_shut_down_memory_manager"}, 0 #() [450->455] (level:1) is red with stack state with #({basic-block #({tag 4:455}) 455 465}) add r1, r1, 24 #({tag 4:455}) [455->465] (level:1) is red with stack state with #({basic-block #() 465 465}) move r3, r3 call {constant "primitive_exit_application"}, 1 #() [465->465] (level:1) is red with stack state with #({basic-block #({tag 23:550}) 550 555}) #({tag 23:550}) [550->555] (level:0) is #f with stack state #f #({basic-block #() 465 470}) preserve-registers-exit #() [465->470] (level:1) is red with stack state #f #() rts #({tag 11:335}) [335->340] (level:1) is red with stack state with #({basic-block #({tag 12:340}) 340 345}) st N12/r12, N13/r11, 4 #() [605->610] (level:0) is #f with stack state #f #() bra {tag 12:340} +++ ending code for dylan_main_0 +++ +++ Frame sizes for dylan_main_0: GC: 0, NC: 2 +++ +++ Live variable scopes for dylan_main_0 +++ Start scope at 10 with frame for no variables End scope at 491 +++ No Source Code Locators for dylan_main_0 +++ +++ starting code for primitive_runtime_module_handle +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:30}) 30 45}) rem "This is a dummy first basic block." #({tag 2:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 20}) ld N0/r3, {constant "module_hInstance"}, 0 move r3, N0/r3 call {constant "primitive_wrap_machine_word"}, 1 #() [20->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) #({tag 1:25}) [25->30] (level:0) is #f with stack state #f #({basic-block #() 20 25}) preserve-registers-exit #() [20->25] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_runtime_module_handle +++ +++ Live variable scopes for primitive_runtime_module_handle +++ Start scope at 8 with frame for no variables End scope at 21 +++ No Source Code Locators for primitive_runtime_module_handle +++ +++ Exported function definition primitive_manual_allocate +++ +++ starting code for primitive_manual_allocate +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:55}) 55 70}) rem "This is a dummy first basic block." #({tag 2:55}) [55->70] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 30}) move r3, r3 call {constant "primitive_unwrap_abstract_integer"}, 1 #() [15->30] (level:0) is red with stack state with #({basic-block #() 30 45}) sub r1, r1, 24 move r3, r3 call-alien {constant "mps__malloc"}, 0 #() [30->45] (level:0) is red with stack state with #({basic-block #() 45 45}) add r1, r1, 24 move r3, r3 call {constant "primitive_wrap_machine_word"}, 1 #() [45->45] (level:0) is red with stack state with #({basic-block #({tag 1:50}) 50 55}) #({tag 1:50}) [50->55] (level:0) is #f with stack state #f #({basic-block #() 45 50}) preserve-registers-exit #() [45->50] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_manual_allocate +++ +++ Live variable scopes for primitive_manual_allocate +++ Start scope at 8 with frame for no variables End scope at 35 +++ No Source Code Locators for primitive_manual_allocate +++ +++ Exported function definition primitive_manual_free +++ +++ starting code for primitive_manual_free +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:45}) 45 60}) rem "This is a dummy first basic block." #({tag 2:45}) [45->60] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 35}) ld N0/r3, r3, 4 sub r1, r1, 24 move r3, N0/r3 call-alien {constant "mps__free"}, 0 #() [25->35] (level:0) is red with stack state with #({basic-block #({tag 1:40}) 40 45}) add r1, r1, 24 move r3, {constant "KPfalseVKi"} #({tag 1:40}) [40->45] (level:0) is #f with stack state #f #({basic-block #() 35 40}) preserve-registers-exit #() [35->40] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_manual_free +++ +++ Live variable scopes for primitive_manual_free +++ Start scope at 8 with frame for no variables End scope at 25 +++ No Source Code Locators for primitive_manual_free +++ +++ Exported function definition call_first_dylan_function +++ +++ starting code for call_first_dylan_function +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 14:185}) 185 200}) rem "This is a dummy first basic block." #({tag 14:185}) [185->200] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}, {basic-block #({tag 5:40}) 40 65}) move G0/r22, r3 move N1/r12, r4 bgt {tag 5:40}, N1/r12, 3 #() [20->25] (level:0) is red with stack state with #({basic-block #() 25 30}, {basic-block #({tag 6:65}) 65 80}) bgt {tag 6:65}, N1/r12, 2 #() [25->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 7:80}) 80 90}) bgt {tag 7:80}, N1/r12, 1 #() [30->35] (level:0) is red with stack state with #({basic-block #() 35 40}, {basic-block #({tag 8:90}) 90 95}) bgt {tag 8:90}, N1/r12, 0 #() [35->40] (level:0) is red with stack state with #({basic-block #({tag 5:40}) 40 65}, {basic-block #({tag 4:160}) 160 175}) beq {tag 4:160}, N1/r12, 0 #({tag 5:40}) [40->65] (level:0) is red with stack state with #({basic-block #({tag 1:95}) 95 100}, {basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 move r5, r7 move r6, r8 beq {tag 4:160}, N1/r12, 4 #({tag 1:95}) [95->100] (level:0) is red with stack state with #({basic-block #() 100 105}, {basic-block #({tag 11:105}) 105 125}) bgt {tag 11:105}, N1/r12, 5 #() [100->105] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}, {basic-block #({tag 12:125}) 125 135}) bgt {tag 12:125}, N1/r12, 4 #({tag 4:160}) [160->175] (level:0) is red with stack state with #({basic-block #() 175 175}) move r22, G0/r22 move r0, N1/r12 call-indirect r22, 4, 4 #() [175->175] (level:0) is red with stack state with #({basic-block #({tag 13:180}) 180 185}) #({tag 13:180}) [180->185] (level:0) is #f with stack state #f #({basic-block #() 175 180}) preserve-registers-exit #() [175->180] (level:0) is red with stack state #f #() rts #({tag 6:65}) [65->80] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 move r5, r7 #() [200->205] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 7:80}) [80->90] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 #() [205->210] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 8:90}) [90->95] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 #() [210->215] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 11:105}) [105->125] (level:0) is red with stack state with #({basic-block #({tag 3:135}) 135 160}, {basic-block #({tag 4:160}) 160 175}) st r10, r1, -4 st r9, r1, -8 sub r1, r1, 8 beq {tag 4:160}, N1/r12, 6 #({tag 3:135}) [135->160] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) load-address-of-stack-arg-n #t, N5/r10, 2 sub N2/r11, N1/r12, 6 asl N3/r9, N2/r11, 2 sub r1, r1, N3/r9 copy-words-down-w r1, N5/r10, N2/r11 #() [215->220] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 12:125}) [125->135] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) st r9, r1, -4 sub r1, r1, 4 #() [220->225] (level:0) is #f with stack state #f #() bra {tag 4:160} +++ ending code for call_first_dylan_function +++ +++ Live variable scopes for call_first_dylan_function +++ Start scope at 10 with frame for no variables End scope at 61 +++ No Source Code Locators for call_first_dylan_function +++ +++ Exported function definition call_dylan_function +++ +++ starting code for call_dylan_function +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 14:190}) 190 205}) rem "This is a dummy first basic block." #({tag 14:190}) [190->205] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}, {basic-block #({tag 5:40}) 40 65}) move G0/r22, r3 move N1/r12, r4 bgt {tag 5:40}, N1/r12, 3 #() [20->25] (level:0) is red with stack state with #({basic-block #() 25 30}, {basic-block #({tag 6:65}) 65 80}) bgt {tag 6:65}, N1/r12, 2 #() [25->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 7:80}) 80 90}) bgt {tag 7:80}, N1/r12, 1 #() [30->35] (level:0) is red with stack state with #({basic-block #() 35 40}, {basic-block #({tag 8:90}) 90 95}) bgt {tag 8:90}, N1/r12, 0 #() [35->40] (level:0) is red with stack state with #({basic-block #({tag 5:40}) 40 65}, {basic-block #({tag 4:160}) 160 175}) beq {tag 4:160}, N1/r12, 0 #({tag 5:40}) [40->65] (level:0) is red with stack state with #({basic-block #({tag 1:95}) 95 100}, {basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 move r5, r7 move r6, r8 beq {tag 4:160}, N1/r12, 4 #({tag 1:95}) [95->100] (level:0) is red with stack state with #({basic-block #() 100 105}, {basic-block #({tag 11:105}) 105 125}) bgt {tag 11:105}, N1/r12, 5 #() [100->105] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}, {basic-block #({tag 12:125}) 125 135}) bgt {tag 12:125}, N1/r12, 4 #({tag 4:160}) [160->175] (level:0) is red with stack state with #({basic-block #() 175 180}) move r22, G0/r22 move r0, N1/r12 call-indirect r22, 4, 4 #() [175->180] (level:0) is red with stack state with #({basic-block #({tag 13:185}) 185 190}) move r3, r3 #({tag 13:185}) [185->190] (level:0) is #f with stack state #f #({basic-block #() 180 185}) preserve-registers-exit #() [180->185] (level:0) is red with stack state #f #() rts #({tag 6:65}) [65->80] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 move r5, r7 #() [205->210] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 7:80}) [80->90] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 #() [210->215] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 8:90}) [90->95] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 #() [215->220] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 11:105}) [105->125] (level:0) is red with stack state with #({basic-block #({tag 3:135}) 135 160}, {basic-block #({tag 4:160}) 160 175}) st r10, r1, -4 st r9, r1, -8 sub r1, r1, 8 beq {tag 4:160}, N1/r12, 6 #({tag 3:135}) [135->160] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) load-address-of-stack-arg-n #t, N5/r10, 2 sub N2/r11, N1/r12, 6 asl N3/r9, N2/r11, 2 sub r1, r1, N3/r9 copy-words-down-w r1, N5/r10, N2/r11 #() [220->225] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 12:125}) [125->135] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) st r9, r1, -4 sub r1, r1, 4 #() [225->230] (level:0) is #f with stack state #f #() bra {tag 4:160} +++ ending code for call_dylan_function +++ +++ Live variable scopes for call_dylan_function +++ Start scope at 10 with frame for no variables End scope at 61 +++ No Source Code Locators for call_dylan_function +++ +++ Exported function definition spy_call_dylan_function +++ +++ starting code for spy_call_dylan_function +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 14:200}) 200 215}) rem "This is a dummy first basic block." #({tag 14:200}) [200->215] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 30}, {basic-block #({tag 5:45}) 45 70}) move G0/r22, r3 move N1/r12, r4 move {indirect-constant "Prunning_dylan_spy_functionQ"}, 1 bgt {tag 5:45}, N1/r12, 3 #() [25->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 6:70}) 70 85}) bgt {tag 6:70}, N1/r12, 2 #() [30->35] (level:0) is red with stack state with #({basic-block #() 35 40}, {basic-block #({tag 7:85}) 85 95}) bgt {tag 7:85}, N1/r12, 1 #() [35->40] (level:0) is red with stack state with #({basic-block #() 40 45}, {basic-block #({tag 8:95}) 95 100}) bgt {tag 8:95}, N1/r12, 0 #() [40->45] (level:0) is red with stack state with #({basic-block #({tag 5:45}) 45 70}, {basic-block #({tag 4:165}) 165 180}) beq {tag 4:165}, N1/r12, 0 #({tag 5:45}) [45->70] (level:0) is red with stack state with #({basic-block #({tag 1:100}) 100 105}, {basic-block #({tag 4:165}) 165 180}) move r3, r5 move r4, r6 move r5, r7 move r6, r8 beq {tag 4:165}, N1/r12, 4 #({tag 1:100}) [100->105] (level:0) is red with stack state with #({basic-block #() 105 110}, {basic-block #({tag 11:110}) 110 130}) bgt {tag 11:110}, N1/r12, 5 #() [105->110] (level:0) is red with stack state with #({basic-block #({tag 4:165}) 165 180}, {basic-block #({tag 12:130}) 130 140}) bgt {tag 12:130}, N1/r12, 4 #({tag 4:165}) [165->180] (level:0) is red with stack state with #({basic-block #() 180 190}) move r22, G0/r22 move r0, N1/r12 call-indirect r22, 4, 4 #() [180->190] (level:0) is red with stack state with #({basic-block #({tag 13:195}) 195 200}) move r3, r3 move {indirect-constant "Prunning_dylan_spy_functionQ"}, 0 #({tag 13:195}) [195->200] (level:0) is #f with stack state #f #({basic-block #() 190 195}) preserve-registers-exit #() [190->195] (level:0) is red with stack state #f #() rts #({tag 6:70}) [70->85] (level:0) is red with stack state with #({basic-block #({tag 4:165}) 165 180}) move r3, r5 move r4, r6 move r5, r7 #() [215->220] (level:0) is #f with stack state #f #() bra {tag 4:165} #({tag 7:85}) [85->95] (level:0) is red with stack state with #({basic-block #({tag 4:165}) 165 180}) move r3, r5 move r4, r6 #() [220->225] (level:0) is #f with stack state #f #() bra {tag 4:165} #({tag 8:95}) [95->100] (level:0) is red with stack state with #({basic-block #({tag 4:165}) 165 180}) move r3, r5 #() [225->230] (level:0) is #f with stack state #f #() bra {tag 4:165} #({tag 11:110}) [110->130] (level:0) is red with stack state with #({basic-block #({tag 3:140}) 140 165}, {basic-block #({tag 4:165}) 165 180}) st r10, r1, -4 st r9, r1, -8 sub r1, r1, 8 beq {tag 4:165}, N1/r12, 6 #({tag 3:140}) [140->165] (level:0) is red with stack state with #({basic-block #({tag 4:165}) 165 180}) load-address-of-stack-arg-n #t, N5/r10, 2 sub N2/r11, N1/r12, 6 asl N3/r9, N2/r11, 2 sub r1, r1, N3/r9 copy-words-down-w r1, N5/r10, N2/r11 #() [230->235] (level:0) is #f with stack state #f #() bra {tag 4:165} #({tag 12:130}) [130->140] (level:0) is red with stack state with #({basic-block #({tag 4:165}) 165 180}) st r9, r1, -4 sub r1, r1, 4 #() [235->240] (level:0) is #f with stack state #f #() bra {tag 4:165} +++ ending code for spy_call_dylan_function +++ +++ Live variable scopes for spy_call_dylan_function +++ Start scope at 10 with frame for no variables End scope at 73 +++ No Source Code Locators for spy_call_dylan_function +++ +++ Exported function definition call_dylan_function_returning_all_values +++ +++ starting code for call_dylan_function_returning_all_values +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 20:330}) 330 345}) rem "This is a dummy first basic block." #({tag 20:330}) [330->345] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}, {basic-block #({tag 5:40}) 40 65}) move G0/r22, r3 move N1/r12, r4 bgt {tag 5:40}, N1/r12, 3 #() [20->25] (level:0) is red with stack state with #({basic-block #() 25 30}, {basic-block #({tag 6:65}) 65 80}) bgt {tag 6:65}, N1/r12, 2 #() [25->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 7:80}) 80 90}) bgt {tag 7:80}, N1/r12, 1 #() [30->35] (level:0) is red with stack state with #({basic-block #() 35 40}, {basic-block #({tag 8:90}) 90 95}) bgt {tag 8:90}, N1/r12, 0 #() [35->40] (level:0) is red with stack state with #({basic-block #({tag 5:40}) 40 65}, {basic-block #({tag 4:160}) 160 175}) beq {tag 4:160}, N1/r12, 0 #({tag 5:40}) [40->65] (level:0) is red with stack state with #({basic-block #({tag 1:95}) 95 100}, {basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 move r5, r7 move r6, r8 beq {tag 4:160}, N1/r12, 4 #({tag 1:95}) [95->100] (level:0) is red with stack state with #({basic-block #() 100 105}, {basic-block #({tag 11:105}) 105 125}) bgt {tag 11:105}, N1/r12, 5 #() [100->105] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}, {basic-block #({tag 12:125}) 125 135}) bgt {tag 12:125}, N1/r12, 4 #({tag 4:160}) [160->175] (level:0) is red with stack state with #({basic-block #() 175 190}) move r22, G0/r22 move r0, N1/r12 call-indirect r22, 4, 4 #() [175->190] (level:0) is red with stack state with #({basic-block #() 190 195}, {basic-block #({tag 13:210}) 210 220}) move N8/r12, 0 ld-teb-address N7/r11, 40 bmvset {tag 13:210} #() [190->195] (level:0) is red with stack state with #({basic-block #() 195 205}, {basic-block #({tag 15:205}) 205 210}) bne {tag 15:205}, N8/r12, 0 #() [195->205] (level:0) is red with stack state with #({basic-block #({tag 14:250}) 250 255}) st r3, N7/r11, 0 move N6/r5, 1 #({tag 14:250}) [250->255] (level:0) is red with stack state with #({basic-block #() 255 260}, {basic-block #({tag 18:260}) 260 305}) bne {tag 18:260}, N6/r5, 0 #() [255->260] (level:0) is red with stack state with #({basic-block #({tag 17:325}) 315 320}) move G10/r3, {constant "KPempty_vectorVKi"} #({tag 17:325}) [315->320] (level:0) is red with stack state with #({basic-block #({tag 17:325}, {tag 19:325}) 325 330}) move r3, G10/r3 #({tag 17:325}, {tag 19:325}) [325->330] (level:0) is #f with stack state #f #({basic-block #() 320 325}) preserve-registers-exit #() [320->325] (level:0) is red with stack state #f #() rts #({tag 6:65}) [65->80] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 move r5, r7 #() [345->350] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 7:80}) [80->90] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 move r4, r6 #() [350->355] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 8:90}) [90->95] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) move r3, r5 #() [355->360] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 11:105}) [105->125] (level:0) is red with stack state with #({basic-block #({tag 3:135}) 135 160}, {basic-block #({tag 4:160}) 160 175}) st r10, r1, -4 st r9, r1, -8 sub r1, r1, 8 beq {tag 4:160}, N1/r12, 6 #({tag 3:135}) [135->160] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) load-address-of-stack-arg-n #t, N5/r10, 2 sub N2/r11, N1/r12, 6 asl N3/r9, N2/r11, 2 sub r1, r1, N3/r9 copy-words-down-w r1, N5/r10, N2/r11 #() [360->365] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 12:125}) [125->135] (level:0) is red with stack state with #({basic-block #({tag 4:160}) 160 175}) st r9, r1, -4 sub r1, r1, 4 #() [365->370] (level:0) is #f with stack state #f #() bra {tag 4:160} #({tag 13:210}) [210->220] (level:0) is red with stack state with #({basic-block #() 220 225}, {basic-block #({tag 15:205}) 205 210}) ld-teb N9/r5, 32 bge {tag 15:205}, N8/r12, N9/r5 #() [220->225] (level:0) is red with stack state with #({basic-block #() 225 230}, {basic-block #({tag 16:230}) 230 250}) bne {tag 16:230}, N8/r12, 0 #() [225->230] (level:0) is red with stack state with #({basic-block #({tag 16:230}) 230 250}) st r3, N7/r11, 0 #({tag 16:230}) [230->250] (level:0) is red with stack state with #({basic-block #({tag 14:250}) 250 255}) sub N9/r5, N9/r5, N8/r12 asl N8/r12, N8/r12, 2 add N7/r11, N7/r11, N8/r12 move N6/r5, N9/r5 #() [370->375] (level:0) is #f with stack state #f #() bra {tag 14:250} #({tag 15:205}) [205->210] (level:0) is red with stack state with #({basic-block #({tag 14:250}) 250 255}) move N6/r5, 0 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 14:250} #({tag 18:260}) [260->305] (level:0) is red with stack state with #({basic-block #() 305 315}) asl N11/r3, N6/r5, 2 add N11/r3, N11/r3, 8 sub r1, r1, 24 move r3, N11/r3 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N6/r5 move r6, 1 move r7, N7/r11 call-alien {constant "primitive_alloc_rt"}, 0 #() [305->315] (level:0) is red with stack state with #({basic-block #({tag 17:325}) 315 320}) add r1, r1, 24 move G10/r3, r3 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 17:325} +++ ending code for call_dylan_function_returning_all_values +++ +++ Live variable scopes for call_dylan_function_returning_all_values +++ Start scope at 10 with frame for no variables End scope at 91 +++ No Source Code Locators for call_dylan_function_returning_all_values +++ +++ Exported function definition make_dylan_vector +++ +++ starting code for make_dylan_vector +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:80}) 80 95}) rem "This is a dummy first basic block." #({tag 2:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #() 5 55}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->55] (level:0) is red with stack state with #({basic-block #() 55 70}) move N0/r5, r3 asl N2/r3, N0/r5, 2 add N2/r3, N2/r3, 8 sub r1, r1, 24 move r3, N2/r3 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N0/r5 move r6, 1 move r7, {constant "KPunboundVKi"} call-alien {constant "primitive_alloc_rf"}, 0 #() [55->70] (level:0) is red with stack state with #({basic-block #({tag 1:75}) 75 80}) add r1, r1, 24 move G1/r3, r3 move r3, G1/r3 #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit #() [70->75] (level:0) is red with stack state #f #() rts +++ ending code for make_dylan_vector +++ +++ Live variable scopes for make_dylan_vector +++ Start scope at 10 with frame for no variables End scope at 37 +++ No Source Code Locators for make_dylan_vector +++ +++ Exported function definition get_current_teb +++ +++ starting code for get_current_teb +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) get-teb r3 #() [10->15] (level:0) is green with stack state #f #() rts +++ ending code for get_current_teb +++ +++ No Source Code Locators for get_current_teb +++ +++ Exported function definition get_tlv_vector +++ +++ starting code for get_tlv_vector +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) ld-teb r3, 4 #() [10->15] (level:0) is green with stack state #f #() rts +++ ending code for get_tlv_vector +++ +++ No Source Code Locators for get_tlv_vector +++ +++ Exported function definition set_tlv_vector +++ +++ starting code for set_tlv_vector +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move G0/r12, r3 st-teb G0/r12, 4 #() [15->20] (level:0) is green with stack state #f #() rts +++ ending code for set_tlv_vector +++ +++ No Source Code Locators for set_tlv_vector +++ +++ Exported function definition get_current_thread +++ +++ starting code for get_current_thread +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) ld-teb r3, 8 #() [10->15] (level:0) is green with stack state #f #() rts +++ ending code for get_current_thread +++ +++ No Source Code Locators for get_current_thread +++ +++ Exported function definition set_current_thread +++ +++ starting code for set_current_thread +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move G0/r12, r3 st-teb G0/r12, 8 #() [15->20] (level:0) is green with stack state #f #() rts +++ ending code for set_current_thread +++ +++ No Source Code Locators for set_current_thread +++ +++ Exported function definition get_current_thread_handle +++ +++ starting code for get_current_thread_handle +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) ld-teb r3, 12 #() [10->15] (level:0) is green with stack state #f #() rts +++ ending code for get_current_thread_handle +++ +++ No Source Code Locators for get_current_thread_handle +++ +++ Exported function definition set_current_thread_handle +++ +++ starting code for set_current_thread_handle +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move G0/r12, r3 st-teb G0/r12, 12 #() [15->20] (level:0) is green with stack state #f #() rts +++ ending code for set_current_thread_handle +++ +++ No Source Code Locators for set_current_thread_handle +++ +++ Exported function definition spy_call_interactive_function +++ +++ starting code for spy_call_interactive_function +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:90}) 90 105}) rem "This is a dummy first basic block." #({tag 2:90}) [90->105] (level:0) is #f with stack state #f #({basic-block #() 5 35}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->35] (level:0) is red with stack state with #({basic-block #() 35 75}) move N0/NSPILL-0, r3 move G2/r4, {constant "Kmake_simple_lockYthreads_primitivesVdylan"} sub r1, r1, 24 move r3, 16 move r4, G2/r4 call-alien {constant "primitive_copy"}, 0 #() [35->75] (level:0) is red with stack state with #({basic-block #() 75 80}) add r1, r1, 24 move G1/r4, r3 st N0/NSPILL-0, G1/r4, 12 move r3, -3 move r4, G1/r4 move r22, {indirect-constant "spy_invoke_dylan_under_coded_restartVKi"} move r0, 2 call-indirect r22, 4, 2 #() [75->80] (level:0) is red with stack state with #({basic-block #({tag 1:85}) 85 90}) move r3, r3 #({tag 1:85}) [85->90] (level:0) is #f with stack state #f #({basic-block #() 80 85}) preserve-registers-exit #() [80->85] (level:0) is red with stack state #f #() rts +++ ending code for spy_call_interactive_function +++ +++ Frame sizes for spy_call_interactive_function: GC: 0, NC: 1 +++ +++ Live variable scopes for spy_call_interactive_function +++ Start scope at 10 with frame for no variables End scope at 51 +++ No Source Code Locators for spy_call_interactive_function +++ +++ Exported function definition spy_read_location_through_barrier +++ +++ starting code for spy_read_location_through_barrier +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move N0/r3, r3 ld r3, N0/r3, 0 #() [15->20] (level:0) is green with stack state #f #() rts +++ ending code for spy_read_location_through_barrier +++ +++ No Source Code Locators for spy_read_location_through_barrier +++ +++ Exported function definition spy_write_location_through_barrier +++ +++ starting code for spy_write_location_through_barrier +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is green with stack state #f #({basic-block #() 20 25}) move N0/r12, r3 move N1/r4, r4 st N1/r4, N0/r12, 0 #() [20->25] (level:0) is green with stack state #f #() rts +++ ending code for spy_write_location_through_barrier +++ +++ No Source Code Locators for spy_write_location_through_barrier +++ +++ Exported function definition spy_read_thread_variable_at_offset +++ +++ starting code for spy_read_thread_variable_at_offset +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is green with stack state #f #({basic-block #() 30 35}) move N0/r3, r3 ld-teb G1/r12, 4 asl N2/r3, N0/r3, 2 add N3/r3, N2/r3, 0 ld r3, G1/r12, N3/r3 #() [30->35] (level:0) is green with stack state #f #() rts +++ ending code for spy_read_thread_variable_at_offset +++ +++ No Source Code Locators for spy_read_thread_variable_at_offset +++ +++ Exported function definition spy_start_debugger_transaction +++ +++ starting code for spy_start_debugger_transaction +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 5}) rem "This is a dummy first basic block." #() [5->5] (level:0) is green with stack state #f #({basic-block #() 5 10}) #() [5->10] (level:0) is green with stack state #f #() jmp-alien {constant "primitive_mps_park"}, 0, 0, #f, #f +++ ending code for spy_start_debugger_transaction +++ +++ No Source Code Locators for spy_start_debugger_transaction +++ +++ Exported function definition spy_end_debugger_transaction +++ +++ starting code for spy_end_debugger_transaction +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 5}) rem "This is a dummy first basic block." #() [5->5] (level:0) is green with stack state #f #({basic-block #() 5 10}) #() [5->10] (level:0) is green with stack state #f #() jmp-alien {constant "primitive_mps_release"}, 0, 0, #f, #f +++ ending code for spy_end_debugger_transaction +++ +++ No Source Code Locators for spy_end_debugger_transaction +++ +++ Exported function definition spy_fixup_imported_dylan_data +++ +++ starting code for spy_fixup_imported_dylan_data +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 5}) rem "This is a dummy first basic block." #() [5->5] (level:0) is green with stack state #f #({basic-block #() 5 10}) #() [5->10] (level:0) is green with stack state #f #() rts +++ ending code for spy_fixup_imported_dylan_data +++ +++ No Source Code Locators for spy_fixup_imported_dylan_data +++ +++ Exported function definition spy_fixup_unimported_dylan_data +++ +++ starting code for spy_fixup_unimported_dylan_data +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 5}) rem "This is a dummy first basic block." #() [5->5] (level:0) is green with stack state #f #({basic-block #() 5 10}) #() [5->10] (level:0) is green with stack state #f #() rts +++ ending code for spy_fixup_unimported_dylan_data +++ +++ No Source Code Locators for spy_fixup_unimported_dylan_data +++ +++ Exported function definition spy_exit_application +++ +++ starting code for spy_exit_application +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:35}) 35 50}) rem "This is a dummy first basic block." #({tag 2:35}) [35->50] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 25}) sub r1, r1, 24 move r3, 0 call-alien {constant "exit"}, 0 #() [20->25] (level:0) is red with stack state with #({basic-block #({tag 1:30}) 30 35}) add r1, r1, 24 #({tag 1:30}) [30->35] (level:0) is #f with stack state #f #({basic-block #() 25 30}) preserve-registers-exit #() [25->30] (level:0) is red with stack state #f #() rts +++ ending code for spy_exit_application +++ +++ Live variable scopes for spy_exit_application +++ Start scope at 10 with frame for no variables End scope at 23 +++ No Source Code Locators for spy_exit_application +++ +++ Exported function definition c_primitive_raw_as_string +++ +++ starting code for c_primitive_raw_as_string +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:30}) 30 45}) rem "This is a dummy first basic block." #({tag 2:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 20}) move N0/r3, r3 move r3, N0/r3 call {constant "primitive_raw_as_string"}, 1 #() [20->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) #({tag 1:25}) [25->30] (level:0) is #f with stack state #f #({basic-block #() 20 25}) preserve-registers-exit #() [20->25] (level:0) is red with stack state #f #() rts +++ ending code for c_primitive_raw_as_string +++ +++ Live variable scopes for c_primitive_raw_as_string +++ Start scope at 10 with frame for no variables End scope at 17 +++ No Source Code Locators for c_primitive_raw_as_string +++ +++ Exported function definition primitive_check_specializers +++ +++ starting code for primitive_check_specializers +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 105}, {basic-block #({tag 4:140}) 140 145}) preserve-registers-entry move N2/r21, r0 ld G1/r20, r22, 8 ld G1/r20, G1/r20, 8 push G1/r20 push 0 push 0 push N2/r21 push r3 push r4 push r5 push r6 push r22 push r23 ld N3/r23, G1/r20, 8 beq {tag 4:140}, N3/r23, {constant "KLobjectGVKd"} #() [85->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 6:110}) 110 130}) store-frame-offset N3/r23, -3 store-frame-offset r3, -2 move G5/r4, N3/r23 bne {tag 6:110}, G5/r4, {constant "KLobjectGVKd"} #() [105->110] (level:0) is #f with stack state #f #({basic-block #({tag 5:130}) 130 140}) move r3, {constant "KPtrueVKi"} #({tag 5:130}) [130->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:140}) 140 145}, {basic-block #({tag 1:545}) 545 570}) load-frame-offset #t, G1/r20, -1 beq {tag 1:545}, r3, {constant "KPfalseVKi"} #({tag 4:140}) [140->145] (level:0) is #f with stack state #f #({basic-block #() 145 155}, {basic-block #({tag 3:475}) 475 535}) beq {tag 3:475}, 4, r0 #() [145->155] (level:0) is #f with stack state #f #({basic-block #() 155 180}, {basic-block #({tag 7:215}) 215 220}) ld N3/r23, G1/r20, 12 beq {tag 7:215}, N3/r23, {constant "KLobjectGVKd"} #() [155->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}, {basic-block #({tag 9:185}) 185 205}) load-frame-offset #t, r4, -6 store-frame-offset N3/r23, -3 store-frame-offset r4, -2 move G7/r23, N3/r23 bne {tag 9:185}, G7/r23, {constant "KLobjectGVKd"} #() [180->185] (level:0) is #f with stack state #f #({basic-block #({tag 8:205}) 205 215}) move r3, {constant "KPtrueVKi"} #({tag 8:205}) [205->215] (level:0) is #f with stack state #f #({basic-block #({tag 7:215}) 215 220}, {basic-block #({tag 1:545}) 545 570}) load-frame-offset #t, G1/r20, -1 beq {tag 1:545}, r3, {constant "KPfalseVKi"} #({tag 7:215}) [215->220] (level:0) is #f with stack state #f #({basic-block #() 220 230}, {basic-block #({tag 3:475}) 475 535}) beq {tag 3:475}, 8, r0 #() [220->230] (level:0) is #f with stack state #f #({basic-block #() 230 255}, {basic-block #({tag 10:290}) 290 295}) ld N3/r23, G1/r20, 16 beq {tag 10:290}, N3/r23, {constant "KLobjectGVKd"} #() [230->255] (level:0) is #f with stack state #f #({basic-block #() 255 260}, {basic-block #({tag 12:260}) 260 280}) load-frame-offset #t, r5, -7 store-frame-offset N3/r23, -3 store-frame-offset r5, -2 move G9/r4, N3/r23 bne {tag 12:260}, G9/r4, {constant "KLobjectGVKd"} #() [255->260] (level:0) is #f with stack state #f #({basic-block #({tag 11:280}) 280 290}) move r3, {constant "KPtrueVKi"} #({tag 11:280}) [280->290] (level:0) is #f with stack state #f #({basic-block #({tag 10:290}) 290 295}, {basic-block #({tag 1:545}) 545 570}) load-frame-offset #t, G1/r20, -1 beq {tag 1:545}, r3, {constant "KPfalseVKi"} #({tag 10:290}) [290->295] (level:0) is #f with stack state #f #({basic-block #() 295 305}, {basic-block #({tag 3:475}) 475 535}) beq {tag 3:475}, 12, r0 #() [295->305] (level:0) is #f with stack state #f #({basic-block #() 305 330}, {basic-block #({tag 13:365}) 365 370}) ld N3/r23, G1/r20, 20 beq {tag 13:365}, N3/r23, {constant "KLobjectGVKd"} #() [305->330] (level:0) is #f with stack state #f #({basic-block #() 330 335}, {basic-block #({tag 15:335}) 335 355}) load-frame-offset #t, r6, -8 store-frame-offset N3/r23, -3 store-frame-offset r6, -2 move G11/r4, N3/r23 bne {tag 15:335}, G11/r4, {constant "KLobjectGVKd"} #() [330->335] (level:0) is #f with stack state #f #({basic-block #({tag 14:355}) 355 365}) move r3, {constant "KPtrueVKi"} #({tag 14:355}) [355->365] (level:0) is #f with stack state #f #({basic-block #({tag 13:365}) 365 370}, {basic-block #({tag 1:545}) 545 570}) load-frame-offset #t, G1/r20, -1 beq {tag 1:545}, r3, {constant "KPfalseVKi"} #({tag 13:365}) [365->370] (level:0) is #f with stack state #f #({basic-block #() 370 375}, {basic-block #({tag 3:475}) 475 535}) beq {tag 3:475}, 16, r0 #() [370->375] (level:0) is #f with stack state #f #({basic-block #({tag 2:375}) 375 380}) load-frame-offset #t, N2/r21, -4 #({tag 2:375}) [375->380] (level:2) is #f with stack state #f #({basic-block #() 380 400}, {basic-block #({tag 3:475}) 475 535}) ble {tag 3:475}, N2/r21, 16 #() [380->400] (level:2) is #f with stack state #f #({basic-block #() 400 435}, {basic-block #({tag 2:375}) 375 380}) sub N2/r21, N2/r21, 4 add N12/r23, N2/r21, 8 ld N3/r23, G1/r20, N12/r23 beq {tag 2:375}, N3/r23, {constant "KLobjectGVKd"} #() [400->435] (level:1) is #f with stack state #f #({basic-block #() 435 440}, {basic-block #({tag 17:440}) 440 460}) add N13/r3, N2/r21, -8 ld G0/r3, r30, N13/r3 store-frame-offset N3/r23, -3 store-frame-offset G0/r3, -2 store-frame-offset N2/r21, -4 move G15/r4, N3/r23 bne {tag 17:440}, G15/r4, {constant "KLobjectGVKd"} #() [435->440] (level:1) is #f with stack state #f #({basic-block #({tag 16:460}) 460 475}) move r3, {constant "KPtrueVKi"} #({tag 16:460}) [460->475] (level:1) is #f with stack state #f #({basic-block #({tag 2:375}) 375 380}, {basic-block #({tag 1:545}) 545 570}) load-frame-offset #t, N2/r21, -4 load-frame-offset #t, G1/r20, -1 bne {tag 2:375}, r3, {constant "KPfalseVKi"} #({tag 1:545}) [545->570] (level:0) is #f with stack state #f #({basic-block #() 570 570}) load-frame-offset #t, G18/r4, -3 load-frame-offset #t, G17/r3, -2 move r3, G17/r3 move r4, G18/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [570->570] (level:0) is #f with stack state #f #({basic-block #() 570 575}) #() [570->575] (level:0) is #f with stack state #f #() rts #({tag 6:110}) [110->130] (level:0) is #f with stack state #f #({basic-block #({tag 5:130}) 130 140}) ld N4/r23, G5/r4, 4 move r3, r3 move r4, G5/r4 call N4/r23, 2 #() [575->580] (level:0) is #f with stack state #f #() bra {tag 5:130} #({tag 3:475}) [475->535] (level:2) is #f with stack state #f #({basic-block #() 535 535}, {basic-block #({tag 18:540}) 540 540}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit ld N16/r21, r22, 8 ld N16/r21, N16/r21, 4 and N16/r21, N16/r21, 262144 bne {tag 18:540}, N16/r21, 0 #() [535->535] (level:2) is #f with stack state #f #({basic-block #() 535 540}) #() [535->540] (level:2) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 9:185}) [185->205] (level:0) is #f with stack state #f #({basic-block #({tag 8:205}) 205 215}) ld N6/r22, G7/r23, 4 move r3, r4 move r4, G7/r23 call N6/r22, 2 #() [580->585] (level:0) is #f with stack state #f #() bra {tag 8:205} #({tag 12:260}) [260->280] (level:0) is #f with stack state #f #({basic-block #({tag 11:280}) 280 290}) ld N8/r23, G9/r4, 4 move r3, r5 move r4, G9/r4 call N8/r23, 2 #() [585->590] (level:0) is #f with stack state #f #() bra {tag 11:280} #({tag 15:335}) [335->355] (level:0) is #f with stack state #f #({basic-block #({tag 14:355}) 355 365}) ld N10/r23, G11/r4, 4 move r3, r6 move r4, G11/r4 call N10/r23, 2 #() [590->595] (level:0) is #f with stack state #f #() bra {tag 14:355} #({tag 17:440}) [440->460] (level:1) is #f with stack state #f #({basic-block #({tag 16:460}) 460 475}) ld N14/r23, G15/r4, 4 move r3, G0/r3 move r4, G15/r4 call N14/r23, 2 #() [595->600] (level:0) is #f with stack state #f #() bra {tag 16:460} #({tag 18:540}) [540->540] (level:2) is #f with stack state #f #({basic-block #({tag 18:540}) 540 545}) #({tag 18:540}) [540->545] (level:2) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for primitive_check_specializers +++ +++ Live variable scopes for primitive_check_specializers +++ Start scope at 8 with frame for no variables End scope at 339 +++ No Source Code Locators for primitive_check_specializers +++ +++ Exported function definition primitive_process_keys_0 +++ +++ starting code for primitive_process_keys_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 115}, {basic-block #({tag 5:140}) 140 155}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 ble {tag 5:140}, N12/r23, 0 #() [85->115] (level:0) is #f with stack state #f #({basic-block #({tag 4:115}) 115 120}) ld G15/r20, N14/r21, 0 move r6, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:115}) [115->120] (level:1) is #f with stack state #f #({basic-block #() 120 140}, {basic-block #({tag 5:140}) 140 155}) bhi {tag 5:140}, N13/r23, r0 #() [120->140] (level:1) is #f with stack state #f #({basic-block #({tag 4:115}) 115 120}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 4:115} #({tag 5:140}) [140->155] (level:1) is #f with stack state #f #({basic-block #() 155 195}, {basic-block #({tag 1:200}) 200 250}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:200}, N7/r20, 4, 0 #() [155->195] (level:1) is #f with stack state #f #({basic-block #() 195 195}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [195->195] (level:1) is #f with stack state #f #({basic-block #() 195 200}) #() [195->200] (level:1) is #f with stack state #f #() rts #({tag 1:200}) [200->250] (level:1) is #f with stack state #f #({basic-block #() 250 255}, {basic-block #({tag 6:255}) 255 270}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub N8/r19, N8/r19, 4 bge {tag 6:255}, N8/r19, 0 #() [250->255] (level:1) is #f with stack state #f #({basic-block #({tag 6:255}) 255 270}) move N8/r19, 0 #({tag 6:255}) [255->270] (level:1) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}) sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:330}, {tag 10:330}, {tag 12:330}) [330->345] (level:4) is #f with stack state #f #({basic-block #() 345 370}, {basic-block #({tag 3:270}) 270 280}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:270}, N5/r20, N4/r23 #() [345->370] (level:1) is #f with stack state #f #({basic-block #() 370 375}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [370->375] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:270}) [270->280] (level:4) is #f with stack state #f #({basic-block #({tag 8:290}) 290 295}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 8:290}) [290->295] (level:5) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}, {basic-block #({tag 7:280}) 280 285}) bhi {tag 2:330}, N19/r23, N10/r21 #({tag 7:280}) [280->285] (level:4) is #f with stack state #f #({basic-block #() 285 290}, {basic-block #({tag 9:295}) 295 315}) beq-mem {tag 9:295}, N19/r23, 0, G17/r19 #() [285->290] (level:2) is #f with stack state #f #({basic-block #({tag 8:290}) 290 295}) add N19/r23, N19/r23, 8 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 8:290} #({tag 9:295}) [295->315] (level:4) is #f with stack state #f #({basic-block #({tag 11:320}) 320 330}, {basic-block #({tag 13:315}) 315 320}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 beq {tag 13:315}, N18/r23, 0 #({tag 11:320}) [320->330] (level:3) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}) sub N21/r23, N18/r23, 4 st G16/r19, r0, N21/r23 #() [385->390] (level:0) is #f with stack state #f #() bra {tag 2:330} #({tag 13:315}) [315->320] (level:4) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}) move r6, G16/r19 #() [390->395] (level:0) is #f with stack state #f #() bra {tag 2:330} +++ ending code for primitive_process_keys_0 +++ +++ No Source Code Locators for primitive_process_keys_0 +++ +++ Exported function definition primitive_process_keys_1 +++ +++ starting code for primitive_process_keys_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 110}, {basic-block #({tag 5:165}) 165 180}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 ble {tag 5:165}, N12/r23, 0 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 140}, {basic-block #({tag 5:165}) 165 180}) ld G15/r20, N14/r21, 0 move r5, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 ble {tag 5:165}, N12/r23, 0 #() [110->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:140}) 140 145}) ld G15/r20, N14/r21, 0 move r6, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:140}) [140->145] (level:1) is #f with stack state #f #({basic-block #() 145 165}, {basic-block #({tag 5:165}) 165 180}) bhi {tag 5:165}, N13/r23, r0 #() [145->165] (level:1) is #f with stack state #f #({basic-block #({tag 4:140}) 140 145}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [410->415] (level:0) is #f with stack state #f #() bra {tag 4:140} #({tag 5:165}) [165->180] (level:1) is #f with stack state #f #({basic-block #() 180 220}, {basic-block #({tag 1:225}) 225 275}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:225}, N7/r20, 4, 0 #() [180->220] (level:1) is #f with stack state #f #({basic-block #() 220 220}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [220->220] (level:1) is #f with stack state #f #({basic-block #() 220 225}) #() [220->225] (level:1) is #f with stack state #f #() rts #({tag 1:225}) [225->275] (level:1) is #f with stack state #f #({basic-block #() 275 280}, {basic-block #({tag 6:280}) 280 295}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub N8/r19, N8/r19, 8 bge {tag 6:280}, N8/r19, 0 #() [275->280] (level:1) is #f with stack state #f #({basic-block #({tag 6:280}) 280 295}) move N8/r19, 0 #({tag 6:280}) [280->295] (level:1) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:365}, {tag 10:365}, {tag 12:365}) [365->380] (level:5) is #f with stack state #f #({basic-block #() 380 405}, {basic-block #({tag 3:295}) 295 305}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:295}, N5/r20, N4/r23 #() [380->405] (level:1) is #f with stack state #f #({basic-block #() 405 410}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [405->410] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:295}) [295->305] (level:5) is #f with stack state #f #({basic-block #({tag 8:315}) 315 320}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 8:315}) [315->320] (level:6) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}, {basic-block #({tag 7:305}) 305 310}) bhi {tag 2:365}, N19/r23, N10/r21 #({tag 7:305}) [305->310] (level:5) is #f with stack state #f #({basic-block #() 310 315}, {basic-block #({tag 9:320}) 320 340}) beq-mem {tag 9:320}, N19/r23, 0, G17/r19 #() [310->315] (level:2) is #f with stack state #f #({basic-block #({tag 8:315}) 315 320}) add N19/r23, N19/r23, 8 #() [415->420] (level:0) is #f with stack state #f #() bra {tag 8:315} #({tag 9:320}) [320->340] (level:5) is #f with stack state #f #({basic-block #() 340 345}, {basic-block #({tag 13:345}) 345 350}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 beq {tag 13:345}, N18/r23, 0 #() [340->345] (level:4) is #f with stack state #f #({basic-block #({tag 11:355}) 355 365}, {basic-block #({tag 14:350}) 350 355}) beq {tag 14:350}, N18/r23, 4 #({tag 11:355}) [355->365] (level:3) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) sub N21/r23, N18/r23, 8 st G16/r19, r0, N21/r23 #() [420->425] (level:0) is #f with stack state #f #() bra {tag 2:365} #({tag 13:345}) [345->350] (level:5) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) move r5, G16/r19 #() [425->430] (level:0) is #f with stack state #f #() bra {tag 2:365} #({tag 14:350}) [350->355] (level:4) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) move r6, G16/r19 #() [430->435] (level:0) is #f with stack state #f #() bra {tag 2:365} +++ ending code for primitive_process_keys_1 +++ +++ No Source Code Locators for primitive_process_keys_1 +++ +++ Exported function definition primitive_process_keys_2 +++ +++ starting code for primitive_process_keys_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 110}, {basic-block #({tag 5:190}) 190 205}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 ble {tag 5:190}, N12/r23, 0 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 135}, {basic-block #({tag 5:190}) 190 205}) ld G15/r20, N14/r21, 0 move r4, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 ble {tag 5:190}, N12/r23, 0 #() [110->135] (level:0) is #f with stack state #f #({basic-block #() 135 165}, {basic-block #({tag 5:190}) 190 205}) ld G15/r20, N14/r21, 0 move r5, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 ble {tag 5:190}, N12/r23, 0 #() [135->165] (level:0) is #f with stack state #f #({basic-block #({tag 4:165}) 165 170}) ld G15/r20, N14/r21, 0 move r6, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:165}) [165->170] (level:1) is #f with stack state #f #({basic-block #() 170 190}, {basic-block #({tag 5:190}) 190 205}) bhi {tag 5:190}, N13/r23, r0 #() [170->190] (level:1) is #f with stack state #f #({basic-block #({tag 4:165}) 165 170}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [445->450] (level:0) is #f with stack state #f #() bra {tag 4:165} #({tag 5:190}) [190->205] (level:1) is #f with stack state #f #({basic-block #() 205 245}, {basic-block #({tag 1:250}) 250 300}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:250}, N7/r20, 4, 0 #() [205->245] (level:1) is #f with stack state #f #({basic-block #() 245 245}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [245->245] (level:1) is #f with stack state #f #({basic-block #() 245 250}) #() [245->250] (level:1) is #f with stack state #f #() rts #({tag 1:250}) [250->300] (level:1) is #f with stack state #f #({basic-block #() 300 305}, {basic-block #({tag 6:305}) 305 320}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub N8/r19, N8/r19, 12 bge {tag 6:305}, N8/r19, 0 #() [300->305] (level:1) is #f with stack state #f #({basic-block #({tag 6:305}) 305 320}) move N8/r19, 0 #({tag 6:305}) [305->320] (level:1) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:400}, {tag 10:400}, {tag 12:400}) [400->415] (level:6) is #f with stack state #f #({basic-block #() 415 440}, {basic-block #({tag 3:320}) 320 330}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:320}, N5/r20, N4/r23 #() [415->440] (level:1) is #f with stack state #f #({basic-block #() 440 445}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [440->445] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:320}) [320->330] (level:6) is #f with stack state #f #({basic-block #({tag 8:340}) 340 345}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 8:340}) [340->345] (level:7) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}, {basic-block #({tag 7:330}) 330 335}) bhi {tag 2:400}, N19/r23, N10/r21 #({tag 7:330}) [330->335] (level:6) is #f with stack state #f #({basic-block #() 335 340}, {basic-block #({tag 9:345}) 345 365}) beq-mem {tag 9:345}, N19/r23, 0, G17/r19 #() [335->340] (level:2) is #f with stack state #f #({basic-block #({tag 8:340}) 340 345}) add N19/r23, N19/r23, 8 #() [450->455] (level:0) is #f with stack state #f #() bra {tag 8:340} #({tag 9:345}) [345->365] (level:6) is #f with stack state #f #({basic-block #() 365 370}, {basic-block #({tag 13:375}) 375 380}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 beq {tag 13:375}, N18/r23, 0 #() [365->370] (level:5) is #f with stack state #f #({basic-block #() 370 375}, {basic-block #({tag 14:380}) 380 385}) beq {tag 14:380}, N18/r23, 4 #() [370->375] (level:4) is #f with stack state #f #({basic-block #({tag 11:390}) 390 400}, {basic-block #({tag 15:385}) 385 390}) beq {tag 15:385}, N18/r23, 8 #({tag 11:390}) [390->400] (level:3) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) sub N21/r23, N18/r23, 12 st G16/r19, r0, N21/r23 #() [455->460] (level:0) is #f with stack state #f #() bra {tag 2:400} #({tag 13:375}) [375->380] (level:6) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) move r4, G16/r19 #() [460->465] (level:0) is #f with stack state #f #() bra {tag 2:400} #({tag 14:380}) [380->385] (level:5) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) move r5, G16/r19 #() [465->470] (level:0) is #f with stack state #f #() bra {tag 2:400} #({tag 15:385}) [385->390] (level:4) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) move r6, G16/r19 #() [470->475] (level:0) is #f with stack state #f #() bra {tag 2:400} +++ ending code for primitive_process_keys_2 +++ +++ No Source Code Locators for primitive_process_keys_2 +++ +++ Exported function definition primitive_process_keys +++ +++ starting code for primitive_process_keys +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 90}) rem "This is a dummy first basic block." #() [5->90] (level:0) is #f with stack state #f #({basic-block #({tag 4:90}) 90 95}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:90}) [90->95] (level:1) is #f with stack state #f #({basic-block #() 95 115}, {basic-block #({tag 5:115}) 115 130}) bhi {tag 5:115}, N13/r23, r0 #() [95->115] (level:1) is #f with stack state #f #({basic-block #({tag 4:90}) 90 95}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [320->325] (level:0) is #f with stack state #f #() bra {tag 4:90} #({tag 5:115}) [115->130] (level:1) is #f with stack state #f #({basic-block #() 130 170}, {basic-block #({tag 1:175}) 175 230}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:175}, N7/r20, 4, 0 #() [130->170] (level:1) is #f with stack state #f #({basic-block #() 170 170}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [170->170] (level:1) is #f with stack state #f #({basic-block #() 170 175}) #() [170->175] (level:1) is #f with stack state #f #() rts #({tag 1:175}) [175->230] (level:1) is #f with stack state #f #({basic-block #({tag 2:275}, {tag 9:275}) 275 290}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:275}, {tag 9:275}) [275->290] (level:3) is #f with stack state #f #({basic-block #() 290 315}, {basic-block #({tag 3:230}) 230 240}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:230}, N5/r20, N4/r23 #() [290->315] (level:1) is #f with stack state #f #({basic-block #() 315 320}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [315->320] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:230}) [230->240] (level:3) is #f with stack state #f #({basic-block #({tag 7:250}) 250 255}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 7:250}) [250->255] (level:4) is #f with stack state #f #({basic-block #({tag 2:275}, {tag 9:275}) 275 290}, {basic-block #({tag 6:240}) 240 245}) bhi {tag 2:275}, N19/r23, N10/r21 #({tag 6:240}) [240->245] (level:3) is #f with stack state #f #({basic-block #() 245 250}, {basic-block #({tag 8:255}) 255 275}) beq-mem {tag 8:255}, N19/r23, 0, G17/r19 #() [245->250] (level:2) is #f with stack state #f #({basic-block #({tag 7:250}) 250 255}) add N19/r23, N19/r23, 8 #() [325->330] (level:0) is #f with stack state #f #() bra {tag 7:250} #({tag 8:255}) [255->275] (level:3) is #f with stack state #f #({basic-block #({tag 2:275}, {tag 9:275}) 275 290}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 st G16/r19, r0, N18/r23 #() [330->335] (level:0) is #f with stack state #f #() bra {tag 2:275} +++ ending code for primitive_process_keys +++ +++ No Source Code Locators for primitive_process_keys +++ +++ Exported function definition primitive_process_keys_for_xep_0 +++ +++ starting code for primitive_process_keys_for_xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 115}, {basic-block #({tag 5:140}) 140 155}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 ble {tag 5:140}, N12/r23, 0 #() [85->115] (level:0) is #f with stack state #f #({basic-block #({tag 4:115}) 115 120}) ld G15/r20, N14/r21, 0 move r6, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:115}) [115->120] (level:1) is #f with stack state #f #({basic-block #() 120 140}, {basic-block #({tag 5:140}) 140 155}) bhi {tag 5:140}, N13/r23, r0 #() [120->140] (level:1) is #f with stack state #f #({basic-block #({tag 4:115}) 115 120}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 4:115} #({tag 5:140}) [140->155] (level:1) is #f with stack state #f #({basic-block #() 155 195}, {basic-block #({tag 1:200}) 200 250}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:200}, N7/r20, 4, 0 #() [155->195] (level:1) is #f with stack state #f #({basic-block #() 195 195}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [195->195] (level:1) is #f with stack state #f #({basic-block #() 195 200}) #() [195->200] (level:1) is #f with stack state #f #() rts #({tag 1:200}) [200->250] (level:1) is #f with stack state #f #({basic-block #() 250 255}, {basic-block #({tag 6:255}) 255 270}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub N8/r19, N8/r19, 4 bge {tag 6:255}, N8/r19, 0 #() [250->255] (level:1) is #f with stack state #f #({basic-block #({tag 6:255}) 255 270}) move N8/r19, 0 #({tag 6:255}) [255->270] (level:1) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}) sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:330}, {tag 10:330}, {tag 12:330}) [330->345] (level:4) is #f with stack state #f #({basic-block #() 345 370}, {basic-block #({tag 3:270}) 270 280}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:270}, N5/r20, N4/r23 #() [345->370] (level:1) is #f with stack state #f #({basic-block #() 370 375}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [370->375] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:270}) [270->280] (level:4) is #f with stack state #f #({basic-block #({tag 8:290}) 290 295}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 8:290}) [290->295] (level:5) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}, {basic-block #({tag 7:280}) 280 285}) bhi {tag 2:330}, N19/r23, N10/r21 #({tag 7:280}) [280->285] (level:4) is #f with stack state #f #({basic-block #() 285 290}, {basic-block #({tag 9:295}) 295 315}) beq-mem {tag 9:295}, N19/r23, 0, G17/r19 #() [285->290] (level:2) is #f with stack state #f #({basic-block #({tag 8:290}) 290 295}) add N19/r23, N19/r23, 8 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 8:290} #({tag 9:295}) [295->315] (level:4) is #f with stack state #f #({basic-block #({tag 11:320}) 320 330}, {basic-block #({tag 13:315}) 315 320}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 beq {tag 13:315}, N18/r23, 0 #({tag 11:320}) [320->330] (level:3) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}) sub N21/r23, N18/r23, 4 st G16/r19, r0, N21/r23 #() [385->390] (level:0) is #f with stack state #f #() bra {tag 2:330} #({tag 13:315}) [315->320] (level:4) is #f with stack state #f #({basic-block #({tag 2:330}, {tag 10:330}, {tag 12:330}) 330 345}) move r6, G16/r19 #() [390->395] (level:0) is #f with stack state #f #() bra {tag 2:330} +++ ending code for primitive_process_keys_for_xep_0 +++ +++ No Source Code Locators for primitive_process_keys_for_xep_0 +++ +++ Exported function definition primitive_process_keys_for_xep_1 +++ +++ starting code for primitive_process_keys_for_xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 110}, {basic-block #({tag 5:165}) 165 180}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 ble {tag 5:165}, N12/r23, 0 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 140}, {basic-block #({tag 5:165}) 165 180}) ld G15/r20, N14/r21, 0 move r5, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 ble {tag 5:165}, N12/r23, 0 #() [110->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:140}) 140 145}) ld G15/r20, N14/r21, 0 move r6, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:140}) [140->145] (level:1) is #f with stack state #f #({basic-block #() 145 165}, {basic-block #({tag 5:165}) 165 180}) bhi {tag 5:165}, N13/r23, r0 #() [145->165] (level:1) is #f with stack state #f #({basic-block #({tag 4:140}) 140 145}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [410->415] (level:0) is #f with stack state #f #() bra {tag 4:140} #({tag 5:165}) [165->180] (level:1) is #f with stack state #f #({basic-block #() 180 220}, {basic-block #({tag 1:225}) 225 275}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:225}, N7/r20, 4, 0 #() [180->220] (level:1) is #f with stack state #f #({basic-block #() 220 220}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [220->220] (level:1) is #f with stack state #f #({basic-block #() 220 225}) #() [220->225] (level:1) is #f with stack state #f #() rts #({tag 1:225}) [225->275] (level:1) is #f with stack state #f #({basic-block #() 275 280}, {basic-block #({tag 6:280}) 280 295}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub N8/r19, N8/r19, 8 bge {tag 6:280}, N8/r19, 0 #() [275->280] (level:1) is #f with stack state #f #({basic-block #({tag 6:280}) 280 295}) move N8/r19, 0 #({tag 6:280}) [280->295] (level:1) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:365}, {tag 10:365}, {tag 12:365}) [365->380] (level:5) is #f with stack state #f #({basic-block #() 380 405}, {basic-block #({tag 3:295}) 295 305}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:295}, N5/r20, N4/r23 #() [380->405] (level:1) is #f with stack state #f #({basic-block #() 405 410}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [405->410] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:295}) [295->305] (level:5) is #f with stack state #f #({basic-block #({tag 8:315}) 315 320}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 8:315}) [315->320] (level:6) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}, {basic-block #({tag 7:305}) 305 310}) bhi {tag 2:365}, N19/r23, N10/r21 #({tag 7:305}) [305->310] (level:5) is #f with stack state #f #({basic-block #() 310 315}, {basic-block #({tag 9:320}) 320 340}) beq-mem {tag 9:320}, N19/r23, 0, G17/r19 #() [310->315] (level:2) is #f with stack state #f #({basic-block #({tag 8:315}) 315 320}) add N19/r23, N19/r23, 8 #() [415->420] (level:0) is #f with stack state #f #() bra {tag 8:315} #({tag 9:320}) [320->340] (level:5) is #f with stack state #f #({basic-block #() 340 345}, {basic-block #({tag 13:345}) 345 350}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 beq {tag 13:345}, N18/r23, 0 #() [340->345] (level:4) is #f with stack state #f #({basic-block #({tag 11:355}) 355 365}, {basic-block #({tag 14:350}) 350 355}) beq {tag 14:350}, N18/r23, 4 #({tag 11:355}) [355->365] (level:3) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) sub N21/r23, N18/r23, 8 st G16/r19, r0, N21/r23 #() [420->425] (level:0) is #f with stack state #f #() bra {tag 2:365} #({tag 13:345}) [345->350] (level:5) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) move r5, G16/r19 #() [425->430] (level:0) is #f with stack state #f #() bra {tag 2:365} #({tag 14:350}) [350->355] (level:4) is #f with stack state #f #({basic-block #({tag 2:365}, {tag 10:365}, {tag 12:365}) 365 380}) move r6, G16/r19 #() [430->435] (level:0) is #f with stack state #f #() bra {tag 2:365} +++ ending code for primitive_process_keys_for_xep_1 +++ +++ No Source Code Locators for primitive_process_keys_for_xep_1 +++ +++ Exported function definition primitive_process_keys_for_xep_2 +++ +++ starting code for primitive_process_keys_for_xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 110}, {basic-block #({tag 5:190}) 190 205}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 ble {tag 5:190}, N12/r23, 0 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 135}, {basic-block #({tag 5:190}) 190 205}) ld G15/r20, N14/r21, 0 move r4, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 ble {tag 5:190}, N12/r23, 0 #() [110->135] (level:0) is #f with stack state #f #({basic-block #() 135 165}, {basic-block #({tag 5:190}) 190 205}) ld G15/r20, N14/r21, 0 move r5, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 ble {tag 5:190}, N12/r23, 0 #() [135->165] (level:0) is #f with stack state #f #({basic-block #({tag 4:165}) 165 170}) ld G15/r20, N14/r21, 0 move r6, G15/r20 add N14/r21, N14/r21, 8 sub N12/r23, N12/r23, 4 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:165}) [165->170] (level:1) is #f with stack state #f #({basic-block #() 170 190}, {basic-block #({tag 5:190}) 190 205}) bhi {tag 5:190}, N13/r23, r0 #() [170->190] (level:1) is #f with stack state #f #({basic-block #({tag 4:165}) 165 170}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [445->450] (level:0) is #f with stack state #f #() bra {tag 4:165} #({tag 5:190}) [190->205] (level:1) is #f with stack state #f #({basic-block #() 205 245}, {basic-block #({tag 1:250}) 250 300}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:250}, N7/r20, 4, 0 #() [205->245] (level:1) is #f with stack state #f #({basic-block #() 245 245}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [245->245] (level:1) is #f with stack state #f #({basic-block #() 245 250}) #() [245->250] (level:1) is #f with stack state #f #() rts #({tag 1:250}) [250->300] (level:1) is #f with stack state #f #({basic-block #() 300 305}, {basic-block #({tag 6:305}) 305 320}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub N8/r19, N8/r19, 12 bge {tag 6:305}, N8/r19, 0 #() [300->305] (level:1) is #f with stack state #f #({basic-block #({tag 6:305}) 305 320}) move N8/r19, 0 #({tag 6:305}) [305->320] (level:1) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:400}, {tag 10:400}, {tag 12:400}) [400->415] (level:6) is #f with stack state #f #({basic-block #() 415 440}, {basic-block #({tag 3:320}) 320 330}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:320}, N5/r20, N4/r23 #() [415->440] (level:1) is #f with stack state #f #({basic-block #() 440 445}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [440->445] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:320}) [320->330] (level:6) is #f with stack state #f #({basic-block #({tag 8:340}) 340 345}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 8:340}) [340->345] (level:7) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}, {basic-block #({tag 7:330}) 330 335}) bhi {tag 2:400}, N19/r23, N10/r21 #({tag 7:330}) [330->335] (level:6) is #f with stack state #f #({basic-block #() 335 340}, {basic-block #({tag 9:345}) 345 365}) beq-mem {tag 9:345}, N19/r23, 0, G17/r19 #() [335->340] (level:2) is #f with stack state #f #({basic-block #({tag 8:340}) 340 345}) add N19/r23, N19/r23, 8 #() [450->455] (level:0) is #f with stack state #f #() bra {tag 8:340} #({tag 9:345}) [345->365] (level:6) is #f with stack state #f #({basic-block #() 365 370}, {basic-block #({tag 13:375}) 375 380}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 beq {tag 13:375}, N18/r23, 0 #() [365->370] (level:5) is #f with stack state #f #({basic-block #() 370 375}, {basic-block #({tag 14:380}) 380 385}) beq {tag 14:380}, N18/r23, 4 #() [370->375] (level:4) is #f with stack state #f #({basic-block #({tag 11:390}) 390 400}, {basic-block #({tag 15:385}) 385 390}) beq {tag 15:385}, N18/r23, 8 #({tag 11:390}) [390->400] (level:3) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) sub N21/r23, N18/r23, 12 st G16/r19, r0, N21/r23 #() [455->460] (level:0) is #f with stack state #f #() bra {tag 2:400} #({tag 13:375}) [375->380] (level:6) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) move r4, G16/r19 #() [460->465] (level:0) is #f with stack state #f #() bra {tag 2:400} #({tag 14:380}) [380->385] (level:5) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) move r5, G16/r19 #() [465->470] (level:0) is #f with stack state #f #() bra {tag 2:400} #({tag 15:385}) [385->390] (level:4) is #f with stack state #f #({basic-block #({tag 2:400}, {tag 10:400}, {tag 12:400}) 400 415}) move r6, G16/r19 #() [470->475] (level:0) is #f with stack state #f #() bra {tag 2:400} +++ ending code for primitive_process_keys_for_xep_2 +++ +++ No Source Code Locators for primitive_process_keys_for_xep_2 +++ +++ Exported function definition primitive_process_keys_for_xep +++ +++ starting code for primitive_process_keys_for_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 90}) rem "This is a dummy first basic block." #() [5->90] (level:0) is #f with stack state #f #({basic-block #({tag 4:90}) 90 95}) pop N1/r19 ld G0/r21, r22, 20 push r3 push r22 push r23 push G0/r21 ld G3/r23, r22, 8 ld G3/r23, G3/r23, 4 and N6/r23, G3/r23, 524288 push N6/r23 ld G2/r22, r22, 20 ld N11/r23, G2/r22, 4 sub N11/r23, N11/r23, 1 lsr N12/r23, N11/r23, 1 add N14/r21, G2/r22, 12 sub N13/r23, r0, N12/r23 add N13/r23, N13/r23, 4 #({tag 4:90}) [90->95] (level:1) is #f with stack state #f #({basic-block #() 95 115}, {basic-block #({tag 5:115}) 115 130}) bhi {tag 5:115}, N13/r23, r0 #() [95->115] (level:1) is #f with stack state #f #({basic-block #({tag 4:90}) 90 95}) ld G15/r20, N14/r21, 0 st G15/r20, N13/r23, 0 add N14/r21, N14/r21, 8 add N13/r23, N13/r23, 4 #() [320->325] (level:0) is #f with stack state #f #() bra {tag 4:90} #({tag 5:115}) [115->130] (level:1) is #f with stack state #f #({basic-block #() 130 170}, {basic-block #({tag 1:175}) 175 230}) ld N7/r20, N1/r19, 4 sub N7/r20, N7/r20, 1 nbit {tag 1:175}, N7/r20, 4, 0 #() [130->170] (level:1) is #f with stack state #f #({basic-block #() 170 170}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [170->170] (level:1) is #f with stack state #f #({basic-block #() 170 175}) #() [170->175] (level:1) is #f with stack state #f #() rts #({tag 1:175}) [175->230] (level:1) is #f with stack state #f #({basic-block #({tag 2:275}, {tag 9:275}) 275 290}) add N4/r23, N1/r19, 8 add N5/r20, N7/r20, N4/r23 ld N8/r19, G2/r22, 4 sub N8/r19, N8/r19, 1 add N9/r22, G2/r22, 8 add N10/r21, N9/r22, N8/r19 sub N10/r21, N10/r21, 8 asr N8/r19, N8/r19, 1 sub r0, r0, N8/r19 add r0, r0, 4 push N4/r23 #({tag 2:275}, {tag 9:275}) [275->290] (level:3) is #f with stack state #f #({basic-block #() 290 315}, {basic-block #({tag 3:230}) 230 240}) sub N5/r20, N5/r20, 8 ld N4/r23, r1, 0 bhs {tag 3:230}, N5/r20, N4/r23 #() [290->315] (level:1) is #f with stack state #f #({basic-block #() 315 320}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 #() [315->320] (level:1) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 3:230}) [230->240] (level:3) is #f with stack state #f #({basic-block #({tag 7:250}) 250 255}) ld G17/r19, N5/r20, 0 move N19/r23, N9/r22 #({tag 7:250}) [250->255] (level:4) is #f with stack state #f #({basic-block #({tag 2:275}, {tag 9:275}) 275 290}, {basic-block #({tag 6:240}) 240 245}) bhi {tag 2:275}, N19/r23, N10/r21 #({tag 6:240}) [240->245] (level:3) is #f with stack state #f #({basic-block #() 245 250}, {basic-block #({tag 8:255}) 255 275}) beq-mem {tag 8:255}, N19/r23, 0, G17/r19 #() [245->250] (level:2) is #f with stack state #f #({basic-block #({tag 7:250}) 250 255}) add N19/r23, N19/r23, 8 #() [325->330] (level:0) is #f with stack state #f #() bra {tag 7:250} #({tag 8:255}) [255->275] (level:3) is #f with stack state #f #({basic-block #({tag 2:275}, {tag 9:275}) 275 290}) sub N18/r23, N19/r23, N9/r22 asr N18/r23, N18/r23, 1 ld G16/r19, N5/r20, 4 st G16/r19, r0, N18/r23 #() [330->335] (level:0) is #f with stack state #f #() bra {tag 2:275} +++ ending code for primitive_process_keys_for_xep +++ +++ No Source Code Locators for primitive_process_keys_for_xep +++ +++ Exported function definition primitive_process_keys_checking_args_for_xep_0 +++ +++ starting code for primitive_process_keys_checking_args_for_xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 115}, {basic-block #({tag 6:140}) 140 155}) pop N2/r19 ld G1/r21, r22, 20 push r3 push r22 push r23 push G1/r21 ld G4/r23, r22, 8 ld G4/r23, G4/r23, 4 and N7/r23, G4/r23, 524288 push N7/r23 ld G3/r22, r22, 20 ld N12/r23, G3/r22, 4 sub N12/r23, N12/r23, 1 lsr N13/r23, N12/r23, 1 add N15/r21, G3/r22, 12 ble {tag 6:140}, N13/r23, 0 #() [85->115] (level:0) is #f with stack state #f #({basic-block #({tag 5:115}) 115 120}) ld G16/r20, N15/r21, 0 move r6, G16/r20 add N15/r21, N15/r21, 8 sub N13/r23, N13/r23, 4 sub N14/r23, r0, N13/r23 add N14/r23, N14/r23, 4 #({tag 5:115}) [115->120] (level:1) is #f with stack state #f #({basic-block #() 120 140}, {basic-block #({tag 6:140}) 140 155}) bhi {tag 6:140}, N14/r23, r0 #() [120->140] (level:1) is #f with stack state #f #({basic-block #({tag 5:115}) 115 120}) ld G16/r20, N15/r21, 0 st G16/r20, N14/r23, 0 add N15/r21, N15/r21, 8 add N14/r23, N14/r23, 4 #() [930->935] (level:0) is #f with stack state #f #() bra {tag 5:115} #({tag 6:140}) [140->155] (level:1) is #f with stack state #f #({basic-block #() 155 195}, {basic-block #({tag 2:200}) 200 250}) ld N8/r21, N2/r19, 4 sub N8/r21, N8/r21, 1 nbit {tag 2:200}, N8/r21, 4, 0 #() [155->195] (level:1) is #f with stack state #f #({basic-block #() 195 195}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [195->195] (level:1) is #f with stack state #f #({basic-block #() 195 200}) #() [195->200] (level:1) is #f with stack state #f #() rts #({tag 2:200}) [200->250] (level:1) is #f with stack state #f #({basic-block #() 250 255}, {basic-block #({tag 7:255}) 255 270}) add N5/r23, N2/r19, 8 add N6/r21, N8/r21, N5/r23 ld N9/r20, G3/r22, 4 sub N9/r20, N9/r20, 1 add N10/r19, G3/r22, 8 add N11/r22, N10/r19, N9/r20 sub N11/r22, N11/r22, 8 asr N9/r20, N9/r20, 1 sub N9/r20, N9/r20, 4 bge {tag 7:255}, N9/r20, 0 #() [250->255] (level:1) is #f with stack state #f #({basic-block #({tag 7:255}) 255 270}) move N9/r20, 0 #({tag 7:255}) [255->270] (level:1) is #f with stack state #f #({basic-block #({tag 3:330}, {tag 11:330}, {tag 13:330}) 330 345}) sub r0, r0, N9/r20 add r0, r0, 4 push N5/r23 #({tag 3:330}, {tag 11:330}, {tag 13:330}) [330->345] (level:4) is #f with stack state #f #({basic-block #() 345 465}, {basic-block #({tag 4:270}) 270 280}) sub N6/r21, N6/r21, 8 ld N5/r23, r1, 0 bhs {tag 4:270}, N6/r21, N5/r23 #() [345->465] (level:1) is #f with stack state #f #({basic-block #() 465 485}, {basic-block #({tag 17:520}) 520 525}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry ld N0/r29, r22, 8 ld N0/r29, N0/r29, 4 and N0/r29, N0/r29, 1020 move N25/r21, N0/r29 ld G24/r20, r22, 8 ld G24/r20, G24/r20, 8 push G24/r20 push 0 push 0 push N25/r21 push r3 push r4 push r5 push r6 push r22 push r23 ld N26/r23, G24/r20, 8 beq {tag 17:520}, N26/r23, {constant "KLobjectGVKd"} #() [465->485] (level:1) is #f with stack state #f #({basic-block #() 485 490}, {basic-block #({tag 19:490}) 490 510}) store-frame-offset N26/r23, -3 store-frame-offset r3, -2 move G28/r4, N26/r23 bne {tag 19:490}, G28/r4, {constant "KLobjectGVKd"} #() [485->490] (level:1) is #f with stack state #f #({basic-block #({tag 18:510}) 510 520}) move r3, {constant "KPtrueVKi"} #({tag 18:510}) [510->520] (level:1) is #f with stack state #f #({basic-block #({tag 17:520}) 520 525}, {basic-block #({tag 1:900}) 900 925}) load-frame-offset #t, G24/r20, -1 beq {tag 1:900}, r3, {constant "KPfalseVKi"} #({tag 17:520}) [520->525] (level:1) is #f with stack state #f #({basic-block #() 525 535}, {basic-block #({tag 16:855}) 855 895}) beq {tag 16:855}, 4, N0/r29 #() [525->535] (level:1) is #f with stack state #f #({basic-block #() 535 560}, {basic-block #({tag 20:595}) 595 600}) ld N26/r23, G24/r20, 12 beq {tag 20:595}, N26/r23, {constant "KLobjectGVKd"} #() [535->560] (level:1) is #f with stack state #f #({basic-block #() 560 565}, {basic-block #({tag 22:565}) 565 585}) load-frame-offset #t, r4, -6 store-frame-offset N26/r23, -3 store-frame-offset r4, -2 move G30/r23, N26/r23 bne {tag 22:565}, G30/r23, {constant "KLobjectGVKd"} #() [560->565] (level:1) is #f with stack state #f #({basic-block #({tag 21:585}) 585 595}) move r3, {constant "KPtrueVKi"} #({tag 21:585}) [585->595] (level:1) is #f with stack state #f #({basic-block #({tag 20:595}) 595 600}, {basic-block #({tag 1:900}) 900 925}) load-frame-offset #t, G24/r20, -1 beq {tag 1:900}, r3, {constant "KPfalseVKi"} #({tag 20:595}) [595->600] (level:1) is #f with stack state #f #({basic-block #() 600 610}, {basic-block #({tag 16:855}) 855 895}) beq {tag 16:855}, 8, N0/r29 #() [600->610] (level:1) is #f with stack state #f #({basic-block #() 610 635}, {basic-block #({tag 23:670}) 670 675}) ld N26/r23, G24/r20, 16 beq {tag 23:670}, N26/r23, {constant "KLobjectGVKd"} #() [610->635] (level:1) is #f with stack state #f #({basic-block #() 635 640}, {basic-block #({tag 25:640}) 640 660}) load-frame-offset #t, r5, -7 store-frame-offset N26/r23, -3 store-frame-offset r5, -2 move G32/r4, N26/r23 bne {tag 25:640}, G32/r4, {constant "KLobjectGVKd"} #() [635->640] (level:1) is #f with stack state #f #({basic-block #({tag 24:660}) 660 670}) move r3, {constant "KPtrueVKi"} #({tag 24:660}) [660->670] (level:1) is #f with stack state #f #({basic-block #({tag 23:670}) 670 675}, {basic-block #({tag 1:900}) 900 925}) load-frame-offset #t, G24/r20, -1 beq {tag 1:900}, r3, {constant "KPfalseVKi"} #({tag 23:670}) [670->675] (level:1) is #f with stack state #f #({basic-block #() 675 685}, {basic-block #({tag 16:855}) 855 895}) beq {tag 16:855}, 12, N0/r29 #() [675->685] (level:1) is #f with stack state #f #({basic-block #() 685 710}, {basic-block #({tag 26:745}) 745 750}) ld N26/r23, G24/r20, 20 beq {tag 26:745}, N26/r23, {constant "KLobjectGVKd"} #() [685->710] (level:1) is #f with stack state #f #({basic-block #() 710 715}, {basic-block #({tag 28:715}) 715 735}) load-frame-offset #t, r6, -8 store-frame-offset N26/r23, -3 store-frame-offset r6, -2 move G34/r4, N26/r23 bne {tag 28:715}, G34/r4, {constant "KLobjectGVKd"} #() [710->715] (level:1) is #f with stack state #f #({basic-block #({tag 27:735}) 735 745}) move r3, {constant "KPtrueVKi"} #({tag 27:735}) [735->745] (level:1) is #f with stack state #f #({basic-block #({tag 26:745}) 745 750}, {basic-block #({tag 1:900}) 900 925}) load-frame-offset #t, G24/r20, -1 beq {tag 1:900}, r3, {constant "KPfalseVKi"} #({tag 26:745}) [745->750] (level:1) is #f with stack state #f #({basic-block #() 750 755}, {basic-block #({tag 16:855}) 855 895}) beq {tag 16:855}, 16, N0/r29 #() [750->755] (level:1) is #f with stack state #f #({basic-block #({tag 15:755}) 755 760}) load-frame-offset #t, N25/r21, -4 #({tag 15:755}) [755->760] (level:3) is #f with stack state #f #({basic-block #() 760 780}, {basic-block #({tag 16:855}) 855 895}) ble {tag 16:855}, N25/r21, 16 #() [760->780] (level:3) is #f with stack state #f #({basic-block #() 780 815}, {basic-block #({tag 15:755}) 755 760}) sub N25/r21, N25/r21, 4 add N35/r23, N25/r21, 8 ld N26/r23, G24/r20, N35/r23 beq {tag 15:755}, N26/r23, {constant "KLobjectGVKd"} #() [780->815] (level:2) is #f with stack state #f #({basic-block #() 815 820}, {basic-block #({tag 30:820}) 820 840}) add N36/r3, N25/r21, -8 ld G23/r3, r30, N36/r3 store-frame-offset N26/r23, -3 store-frame-offset G23/r3, -2 store-frame-offset N25/r21, -4 move G38/r4, N26/r23 bne {tag 30:820}, G38/r4, {constant "KLobjectGVKd"} #() [815->820] (level:2) is #f with stack state #f #({basic-block #({tag 29:840}) 840 855}) move r3, {constant "KPtrueVKi"} #({tag 29:840}) [840->855] (level:2) is #f with stack state #f #({basic-block #({tag 15:755}) 755 760}, {basic-block #({tag 1:900}) 900 925}) load-frame-offset #t, N25/r21, -4 load-frame-offset #t, G24/r20, -1 bne {tag 15:755}, r3, {constant "KPfalseVKi"} #({tag 1:900}) [900->925] (level:1) is #f with stack state #f #({basic-block #() 925 925}) load-frame-offset #t, G40/r4, -3 load-frame-offset #t, G39/r3, -2 move r3, G39/r3 move r4, G40/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [925->925] (level:1) is #f with stack state #f #({basic-block #() 925 930}) #() [925->930] (level:1) is #f with stack state #f #() rts #({tag 4:270}) [270->280] (level:4) is #f with stack state #f #({basic-block #({tag 9:290}) 290 295}) ld G18/r20, N6/r21, 0 move N20/r23, N10/r19 #({tag 9:290}) [290->295] (level:5) is #f with stack state #f #({basic-block #({tag 3:330}, {tag 11:330}, {tag 13:330}) 330 345}, {basic-block #({tag 8:280}) 280 285}) bhi {tag 3:330}, N20/r23, N11/r22 #({tag 8:280}) [280->285] (level:4) is #f with stack state #f #({basic-block #() 285 290}, {basic-block #({tag 10:295}) 295 315}) beq-mem {tag 10:295}, N20/r23, 0, G18/r20 #() [285->290] (level:2) is #f with stack state #f #({basic-block #({tag 9:290}) 290 295}) add N20/r23, N20/r23, 8 #() [935->940] (level:0) is #f with stack state #f #() bra {tag 9:290} #({tag 19:490}) [490->510] (level:1) is #f with stack state #f #({basic-block #({tag 18:510}) 510 520}) ld N27/r23, G28/r4, 4 move r3, r3 move r4, G28/r4 call N27/r23, 2 #() [940->945] (level:0) is #f with stack state #f #() bra {tag 18:510} #({tag 16:855}) [855->895] (level:3) is #f with stack state #f #({basic-block #() 895 900}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #() [895->900] (level:3) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 22:565}) [565->585] (level:1) is #f with stack state #f #({basic-block #({tag 21:585}) 585 595}) ld N29/r22, G30/r23, 4 move r3, r4 move r4, G30/r23 call N29/r22, 2 #() [945->950] (level:0) is #f with stack state #f #() bra {tag 21:585} #({tag 25:640}) [640->660] (level:1) is #f with stack state #f #({basic-block #({tag 24:660}) 660 670}) ld N31/r23, G32/r4, 4 move r3, r5 move r4, G32/r4 call N31/r23, 2 #() [950->955] (level:0) is #f with stack state #f #() bra {tag 24:660} #({tag 28:715}) [715->735] (level:1) is #f with stack state #f #({basic-block #({tag 27:735}) 735 745}) ld N33/r23, G34/r4, 4 move r3, r6 move r4, G34/r4 call N33/r23, 2 #() [955->960] (level:0) is #f with stack state #f #() bra {tag 27:735} #({tag 30:820}) [820->840] (level:2) is #f with stack state #f #({basic-block #({tag 29:840}) 840 855}) ld N37/r23, G38/r4, 4 move r3, G23/r3 move r4, G38/r4 call N37/r23, 2 #() [960->965] (level:0) is #f with stack state #f #() bra {tag 29:840} #({tag 10:295}) [295->315] (level:4) is #f with stack state #f #({basic-block #({tag 12:320}) 320 330}, {basic-block #({tag 14:315}) 315 320}) sub N19/r23, N20/r23, N10/r19 asr N19/r23, N19/r23, 1 ld G17/r20, N6/r21, 4 beq {tag 14:315}, N19/r23, 0 #({tag 12:320}) [320->330] (level:3) is #f with stack state #f #({basic-block #({tag 3:330}, {tag 11:330}, {tag 13:330}) 330 345}) sub N22/r23, N19/r23, 4 st G17/r20, r0, N22/r23 #() [965->970] (level:0) is #f with stack state #f #() bra {tag 3:330} #({tag 14:315}) [315->320] (level:4) is #f with stack state #f #({basic-block #({tag 3:330}, {tag 11:330}, {tag 13:330}) 330 345}) move r6, G17/r20 #() [970->975] (level:0) is #f with stack state #f #() bra {tag 3:330} +++ ending code for primitive_process_keys_checking_args_for_xep_0 +++ +++ Live variable scopes for primitive_process_keys_checking_args_for_xep_0 +++ Start scope at 98 with frame for no variables End scope at 533 +++ No Source Code Locators for primitive_process_keys_checking_args_for_xep_0 +++ +++ Exported function definition primitive_process_keys_checking_args_for_xep_1 +++ +++ starting code for primitive_process_keys_checking_args_for_xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 110}, {basic-block #({tag 6:165}) 165 180}) pop N2/r19 ld G1/r21, r22, 20 push r3 push r22 push r23 push G1/r21 ld G4/r23, r22, 8 ld G4/r23, G4/r23, 4 and N7/r23, G4/r23, 524288 push N7/r23 ld G3/r22, r22, 20 ld N12/r23, G3/r22, 4 sub N12/r23, N12/r23, 1 lsr N13/r23, N12/r23, 1 add N15/r21, G3/r22, 12 ble {tag 6:165}, N13/r23, 0 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 140}, {basic-block #({tag 6:165}) 165 180}) ld G16/r20, N15/r21, 0 move r5, G16/r20 add N15/r21, N15/r21, 8 sub N13/r23, N13/r23, 4 ble {tag 6:165}, N13/r23, 0 #() [110->140] (level:0) is #f with stack state #f #({basic-block #({tag 5:140}) 140 145}) ld G16/r20, N15/r21, 0 move r6, G16/r20 add N15/r21, N15/r21, 8 sub N13/r23, N13/r23, 4 sub N14/r23, r0, N13/r23 add N14/r23, N14/r23, 4 #({tag 5:140}) [140->145] (level:1) is #f with stack state #f #({basic-block #() 145 165}, {basic-block #({tag 6:165}) 165 180}) bhi {tag 6:165}, N14/r23, r0 #() [145->165] (level:1) is #f with stack state #f #({basic-block #({tag 5:140}) 140 145}) ld G16/r20, N15/r21, 0 st G16/r20, N14/r23, 0 add N15/r21, N15/r21, 8 add N14/r23, N14/r23, 4 #() [965->970] (level:0) is #f with stack state #f #() bra {tag 5:140} #({tag 6:165}) [165->180] (level:1) is #f with stack state #f #({basic-block #() 180 220}, {basic-block #({tag 2:225}) 225 275}) ld N8/r21, N2/r19, 4 sub N8/r21, N8/r21, 1 nbit {tag 2:225}, N8/r21, 4, 0 #() [180->220] (level:1) is #f with stack state #f #({basic-block #() 220 220}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [220->220] (level:1) is #f with stack state #f #({basic-block #() 220 225}) #() [220->225] (level:1) is #f with stack state #f #() rts #({tag 2:225}) [225->275] (level:1) is #f with stack state #f #({basic-block #() 275 280}, {basic-block #({tag 7:280}) 280 295}) add N5/r23, N2/r19, 8 add N6/r21, N8/r21, N5/r23 ld N9/r20, G3/r22, 4 sub N9/r20, N9/r20, 1 add N10/r19, G3/r22, 8 add N11/r22, N10/r19, N9/r20 sub N11/r22, N11/r22, 8 asr N9/r20, N9/r20, 1 sub N9/r20, N9/r20, 8 bge {tag 7:280}, N9/r20, 0 #() [275->280] (level:1) is #f with stack state #f #({basic-block #({tag 7:280}) 280 295}) move N9/r20, 0 #({tag 7:280}) [280->295] (level:1) is #f with stack state #f #({basic-block #({tag 3:365}, {tag 11:365}, {tag 13:365}) 365 380}) sub r0, r0, N9/r20 add r0, r0, 4 push N5/r23 #({tag 3:365}, {tag 11:365}, {tag 13:365}) [365->380] (level:5) is #f with stack state #f #({basic-block #() 380 500}, {basic-block #({tag 4:295}) 295 305}) sub N6/r21, N6/r21, 8 ld N5/r23, r1, 0 bhs {tag 4:295}, N6/r21, N5/r23 #() [380->500] (level:1) is #f with stack state #f #({basic-block #() 500 520}, {basic-block #({tag 18:555}) 555 560}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry ld N0/r29, r22, 8 ld N0/r29, N0/r29, 4 and N0/r29, N0/r29, 1020 move N25/r21, N0/r29 ld G24/r20, r22, 8 ld G24/r20, G24/r20, 8 push G24/r20 push 0 push 0 push N25/r21 push r3 push r4 push r5 push r6 push r22 push r23 ld N26/r23, G24/r20, 8 beq {tag 18:555}, N26/r23, {constant "KLobjectGVKd"} #() [500->520] (level:1) is #f with stack state #f #({basic-block #() 520 525}, {basic-block #({tag 20:525}) 525 545}) store-frame-offset N26/r23, -3 store-frame-offset r3, -2 move G28/r4, N26/r23 bne {tag 20:525}, G28/r4, {constant "KLobjectGVKd"} #() [520->525] (level:1) is #f with stack state #f #({basic-block #({tag 19:545}) 545 555}) move r3, {constant "KPtrueVKi"} #({tag 19:545}) [545->555] (level:1) is #f with stack state #f #({basic-block #({tag 18:555}) 555 560}, {basic-block #({tag 1:935}) 935 960}) load-frame-offset #t, G24/r20, -1 beq {tag 1:935}, r3, {constant "KPfalseVKi"} #({tag 18:555}) [555->560] (level:1) is #f with stack state #f #({basic-block #() 560 570}, {basic-block #({tag 17:890}) 890 930}) beq {tag 17:890}, 4, N0/r29 #() [560->570] (level:1) is #f with stack state #f #({basic-block #() 570 595}, {basic-block #({tag 21:630}) 630 635}) ld N26/r23, G24/r20, 12 beq {tag 21:630}, N26/r23, {constant "KLobjectGVKd"} #() [570->595] (level:1) is #f with stack state #f #({basic-block #() 595 600}, {basic-block #({tag 23:600}) 600 620}) load-frame-offset #t, r4, -6 store-frame-offset N26/r23, -3 store-frame-offset r4, -2 move G30/r23, N26/r23 bne {tag 23:600}, G30/r23, {constant "KLobjectGVKd"} #() [595->600] (level:1) is #f with stack state #f #({basic-block #({tag 22:620}) 620 630}) move r3, {constant "KPtrueVKi"} #({tag 22:620}) [620->630] (level:1) is #f with stack state #f #({basic-block #({tag 21:630}) 630 635}, {basic-block #({tag 1:935}) 935 960}) load-frame-offset #t, G24/r20, -1 beq {tag 1:935}, r3, {constant "KPfalseVKi"} #({tag 21:630}) [630->635] (level:1) is #f with stack state #f #({basic-block #() 635 645}, {basic-block #({tag 17:890}) 890 930}) beq {tag 17:890}, 8, N0/r29 #() [635->645] (level:1) is #f with stack state #f #({basic-block #() 645 670}, {basic-block #({tag 24:705}) 705 710}) ld N26/r23, G24/r20, 16 beq {tag 24:705}, N26/r23, {constant "KLobjectGVKd"} #() [645->670] (level:1) is #f with stack state #f #({basic-block #() 670 675}, {basic-block #({tag 26:675}) 675 695}) load-frame-offset #t, r5, -7 store-frame-offset N26/r23, -3 store-frame-offset r5, -2 move G32/r4, N26/r23 bne {tag 26:675}, G32/r4, {constant "KLobjectGVKd"} #() [670->675] (level:1) is #f with stack state #f #({basic-block #({tag 25:695}) 695 705}) move r3, {constant "KPtrueVKi"} #({tag 25:695}) [695->705] (level:1) is #f with stack state #f #({basic-block #({tag 24:705}) 705 710}, {basic-block #({tag 1:935}) 935 960}) load-frame-offset #t, G24/r20, -1 beq {tag 1:935}, r3, {constant "KPfalseVKi"} #({tag 24:705}) [705->710] (level:1) is #f with stack state #f #({basic-block #() 710 720}, {basic-block #({tag 17:890}) 890 930}) beq {tag 17:890}, 12, N0/r29 #() [710->720] (level:1) is #f with stack state #f #({basic-block #() 720 745}, {basic-block #({tag 27:780}) 780 785}) ld N26/r23, G24/r20, 20 beq {tag 27:780}, N26/r23, {constant "KLobjectGVKd"} #() [720->745] (level:1) is #f with stack state #f #({basic-block #() 745 750}, {basic-block #({tag 29:750}) 750 770}) load-frame-offset #t, r6, -8 store-frame-offset N26/r23, -3 store-frame-offset r6, -2 move G34/r4, N26/r23 bne {tag 29:750}, G34/r4, {constant "KLobjectGVKd"} #() [745->750] (level:1) is #f with stack state #f #({basic-block #({tag 28:770}) 770 780}) move r3, {constant "KPtrueVKi"} #({tag 28:770}) [770->780] (level:1) is #f with stack state #f #({basic-block #({tag 27:780}) 780 785}, {basic-block #({tag 1:935}) 935 960}) load-frame-offset #t, G24/r20, -1 beq {tag 1:935}, r3, {constant "KPfalseVKi"} #({tag 27:780}) [780->785] (level:1) is #f with stack state #f #({basic-block #() 785 790}, {basic-block #({tag 17:890}) 890 930}) beq {tag 17:890}, 16, N0/r29 #() [785->790] (level:1) is #f with stack state #f #({basic-block #({tag 16:790}) 790 795}) load-frame-offset #t, N25/r21, -4 #({tag 16:790}) [790->795] (level:3) is #f with stack state #f #({basic-block #() 795 815}, {basic-block #({tag 17:890}) 890 930}) ble {tag 17:890}, N25/r21, 16 #() [795->815] (level:3) is #f with stack state #f #({basic-block #() 815 850}, {basic-block #({tag 16:790}) 790 795}) sub N25/r21, N25/r21, 4 add N35/r23, N25/r21, 8 ld N26/r23, G24/r20, N35/r23 beq {tag 16:790}, N26/r23, {constant "KLobjectGVKd"} #() [815->850] (level:2) is #f with stack state #f #({basic-block #() 850 855}, {basic-block #({tag 31:855}) 855 875}) add N36/r3, N25/r21, -8 ld G23/r3, r30, N36/r3 store-frame-offset N26/r23, -3 store-frame-offset G23/r3, -2 store-frame-offset N25/r21, -4 move G38/r4, N26/r23 bne {tag 31:855}, G38/r4, {constant "KLobjectGVKd"} #() [850->855] (level:2) is #f with stack state #f #({basic-block #({tag 30:875}) 875 890}) move r3, {constant "KPtrueVKi"} #({tag 30:875}) [875->890] (level:2) is #f with stack state #f #({basic-block #({tag 16:790}) 790 795}, {basic-block #({tag 1:935}) 935 960}) load-frame-offset #t, N25/r21, -4 load-frame-offset #t, G24/r20, -1 bne {tag 16:790}, r3, {constant "KPfalseVKi"} #({tag 1:935}) [935->960] (level:1) is #f with stack state #f #({basic-block #() 960 960}) load-frame-offset #t, G40/r4, -3 load-frame-offset #t, G39/r3, -2 move r3, G39/r3 move r4, G40/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [960->960] (level:1) is #f with stack state #f #({basic-block #() 960 965}) #() [960->965] (level:1) is #f with stack state #f #() rts #({tag 4:295}) [295->305] (level:5) is #f with stack state #f #({basic-block #({tag 9:315}) 315 320}) ld G18/r20, N6/r21, 0 move N20/r23, N10/r19 #({tag 9:315}) [315->320] (level:6) is #f with stack state #f #({basic-block #({tag 3:365}, {tag 11:365}, {tag 13:365}) 365 380}, {basic-block #({tag 8:305}) 305 310}) bhi {tag 3:365}, N20/r23, N11/r22 #({tag 8:305}) [305->310] (level:5) is #f with stack state #f #({basic-block #() 310 315}, {basic-block #({tag 10:320}) 320 340}) beq-mem {tag 10:320}, N20/r23, 0, G18/r20 #() [310->315] (level:2) is #f with stack state #f #({basic-block #({tag 9:315}) 315 320}) add N20/r23, N20/r23, 8 #() [970->975] (level:0) is #f with stack state #f #() bra {tag 9:315} #({tag 20:525}) [525->545] (level:1) is #f with stack state #f #({basic-block #({tag 19:545}) 545 555}) ld N27/r23, G28/r4, 4 move r3, r3 move r4, G28/r4 call N27/r23, 2 #() [975->980] (level:0) is #f with stack state #f #() bra {tag 19:545} #({tag 17:890}) [890->930] (level:3) is #f with stack state #f #({basic-block #() 930 935}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #() [930->935] (level:3) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 23:600}) [600->620] (level:1) is #f with stack state #f #({basic-block #({tag 22:620}) 620 630}) ld N29/r22, G30/r23, 4 move r3, r4 move r4, G30/r23 call N29/r22, 2 #() [980->985] (level:0) is #f with stack state #f #() bra {tag 22:620} #({tag 26:675}) [675->695] (level:1) is #f with stack state #f #({basic-block #({tag 25:695}) 695 705}) ld N31/r23, G32/r4, 4 move r3, r5 move r4, G32/r4 call N31/r23, 2 #() [985->990] (level:0) is #f with stack state #f #() bra {tag 25:695} #({tag 29:750}) [750->770] (level:1) is #f with stack state #f #({basic-block #({tag 28:770}) 770 780}) ld N33/r23, G34/r4, 4 move r3, r6 move r4, G34/r4 call N33/r23, 2 #() [990->995] (level:0) is #f with stack state #f #() bra {tag 28:770} #({tag 31:855}) [855->875] (level:2) is #f with stack state #f #({basic-block #({tag 30:875}) 875 890}) ld N37/r23, G38/r4, 4 move r3, G23/r3 move r4, G38/r4 call N37/r23, 2 #() [995->1000] (level:0) is #f with stack state #f #() bra {tag 30:875} #({tag 10:320}) [320->340] (level:5) is #f with stack state #f #({basic-block #() 340 345}, {basic-block #({tag 14:345}) 345 350}) sub N19/r23, N20/r23, N10/r19 asr N19/r23, N19/r23, 1 ld G17/r20, N6/r21, 4 beq {tag 14:345}, N19/r23, 0 #() [340->345] (level:4) is #f with stack state #f #({basic-block #({tag 12:355}) 355 365}, {basic-block #({tag 15:350}) 350 355}) beq {tag 15:350}, N19/r23, 4 #({tag 12:355}) [355->365] (level:3) is #f with stack state #f #({basic-block #({tag 3:365}, {tag 11:365}, {tag 13:365}) 365 380}) sub N22/r23, N19/r23, 8 st G17/r20, r0, N22/r23 #() [1000->1005] (level:0) is #f with stack state #f #() bra {tag 3:365} #({tag 14:345}) [345->350] (level:5) is #f with stack state #f #({basic-block #({tag 3:365}, {tag 11:365}, {tag 13:365}) 365 380}) move r5, G17/r20 #() [1005->1010] (level:0) is #f with stack state #f #() bra {tag 3:365} #({tag 15:350}) [350->355] (level:4) is #f with stack state #f #({basic-block #({tag 3:365}, {tag 11:365}, {tag 13:365}) 365 380}) move r6, G17/r20 #() [1010->1015] (level:0) is #f with stack state #f #() bra {tag 3:365} +++ ending code for primitive_process_keys_checking_args_for_xep_1 +++ +++ Live variable scopes for primitive_process_keys_checking_args_for_xep_1 +++ Start scope at 110 with frame for no variables End scope at 545 +++ No Source Code Locators for primitive_process_keys_checking_args_for_xep_1 +++ +++ Exported function definition primitive_process_keys_checking_args_for_xep_2 +++ +++ starting code for primitive_process_keys_checking_args_for_xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 110}, {basic-block #({tag 6:190}) 190 205}) pop N2/r19 ld G1/r21, r22, 20 push r3 push r22 push r23 push G1/r21 ld G4/r23, r22, 8 ld G4/r23, G4/r23, 4 and N7/r23, G4/r23, 524288 push N7/r23 ld G3/r22, r22, 20 ld N12/r23, G3/r22, 4 sub N12/r23, N12/r23, 1 lsr N13/r23, N12/r23, 1 add N15/r21, G3/r22, 12 ble {tag 6:190}, N13/r23, 0 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 135}, {basic-block #({tag 6:190}) 190 205}) ld G16/r20, N15/r21, 0 move r4, G16/r20 add N15/r21, N15/r21, 8 sub N13/r23, N13/r23, 4 ble {tag 6:190}, N13/r23, 0 #() [110->135] (level:0) is #f with stack state #f #({basic-block #() 135 165}, {basic-block #({tag 6:190}) 190 205}) ld G16/r20, N15/r21, 0 move r5, G16/r20 add N15/r21, N15/r21, 8 sub N13/r23, N13/r23, 4 ble {tag 6:190}, N13/r23, 0 #() [135->165] (level:0) is #f with stack state #f #({basic-block #({tag 5:165}) 165 170}) ld G16/r20, N15/r21, 0 move r6, G16/r20 add N15/r21, N15/r21, 8 sub N13/r23, N13/r23, 4 sub N14/r23, r0, N13/r23 add N14/r23, N14/r23, 4 #({tag 5:165}) [165->170] (level:1) is #f with stack state #f #({basic-block #() 170 190}, {basic-block #({tag 6:190}) 190 205}) bhi {tag 6:190}, N14/r23, r0 #() [170->190] (level:1) is #f with stack state #f #({basic-block #({tag 5:165}) 165 170}) ld G16/r20, N15/r21, 0 st G16/r20, N14/r23, 0 add N15/r21, N15/r21, 8 add N14/r23, N14/r23, 4 #() [1000->1005] (level:0) is #f with stack state #f #() bra {tag 5:165} #({tag 6:190}) [190->205] (level:1) is #f with stack state #f #({basic-block #() 205 245}, {basic-block #({tag 2:250}) 250 300}) ld N8/r21, N2/r19, 4 sub N8/r21, N8/r21, 1 nbit {tag 2:250}, N8/r21, 4, 0 #() [205->245] (level:1) is #f with stack state #f #({basic-block #() 245 245}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [245->245] (level:1) is #f with stack state #f #({basic-block #() 245 250}) #() [245->250] (level:1) is #f with stack state #f #() rts #({tag 2:250}) [250->300] (level:1) is #f with stack state #f #({basic-block #() 300 305}, {basic-block #({tag 7:305}) 305 320}) add N5/r23, N2/r19, 8 add N6/r21, N8/r21, N5/r23 ld N9/r20, G3/r22, 4 sub N9/r20, N9/r20, 1 add N10/r19, G3/r22, 8 add N11/r22, N10/r19, N9/r20 sub N11/r22, N11/r22, 8 asr N9/r20, N9/r20, 1 sub N9/r20, N9/r20, 12 bge {tag 7:305}, N9/r20, 0 #() [300->305] (level:1) is #f with stack state #f #({basic-block #({tag 7:305}) 305 320}) move N9/r20, 0 #({tag 7:305}) [305->320] (level:1) is #f with stack state #f #({basic-block #({tag 3:400}, {tag 11:400}, {tag 13:400}) 400 415}) sub r0, r0, N9/r20 add r0, r0, 4 push N5/r23 #({tag 3:400}, {tag 11:400}, {tag 13:400}) [400->415] (level:6) is #f with stack state #f #({basic-block #() 415 535}, {basic-block #({tag 4:320}) 320 330}) sub N6/r21, N6/r21, 8 ld N5/r23, r1, 0 bhs {tag 4:320}, N6/r21, N5/r23 #() [415->535] (level:1) is #f with stack state #f #({basic-block #() 535 555}, {basic-block #({tag 19:590}) 590 595}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry ld N0/r29, r22, 8 ld N0/r29, N0/r29, 4 and N0/r29, N0/r29, 1020 move N25/r21, N0/r29 ld G24/r20, r22, 8 ld G24/r20, G24/r20, 8 push G24/r20 push 0 push 0 push N25/r21 push r3 push r4 push r5 push r6 push r22 push r23 ld N26/r23, G24/r20, 8 beq {tag 19:590}, N26/r23, {constant "KLobjectGVKd"} #() [535->555] (level:1) is #f with stack state #f #({basic-block #() 555 560}, {basic-block #({tag 21:560}) 560 580}) store-frame-offset N26/r23, -3 store-frame-offset r3, -2 move G28/r4, N26/r23 bne {tag 21:560}, G28/r4, {constant "KLobjectGVKd"} #() [555->560] (level:1) is #f with stack state #f #({basic-block #({tag 20:580}) 580 590}) move r3, {constant "KPtrueVKi"} #({tag 20:580}) [580->590] (level:1) is #f with stack state #f #({basic-block #({tag 19:590}) 590 595}, {basic-block #({tag 1:970}) 970 995}) load-frame-offset #t, G24/r20, -1 beq {tag 1:970}, r3, {constant "KPfalseVKi"} #({tag 19:590}) [590->595] (level:1) is #f with stack state #f #({basic-block #() 595 605}, {basic-block #({tag 18:925}) 925 965}) beq {tag 18:925}, 4, N0/r29 #() [595->605] (level:1) is #f with stack state #f #({basic-block #() 605 630}, {basic-block #({tag 22:665}) 665 670}) ld N26/r23, G24/r20, 12 beq {tag 22:665}, N26/r23, {constant "KLobjectGVKd"} #() [605->630] (level:1) is #f with stack state #f #({basic-block #() 630 635}, {basic-block #({tag 24:635}) 635 655}) load-frame-offset #t, r4, -6 store-frame-offset N26/r23, -3 store-frame-offset r4, -2 move G30/r23, N26/r23 bne {tag 24:635}, G30/r23, {constant "KLobjectGVKd"} #() [630->635] (level:1) is #f with stack state #f #({basic-block #({tag 23:655}) 655 665}) move r3, {constant "KPtrueVKi"} #({tag 23:655}) [655->665] (level:1) is #f with stack state #f #({basic-block #({tag 22:665}) 665 670}, {basic-block #({tag 1:970}) 970 995}) load-frame-offset #t, G24/r20, -1 beq {tag 1:970}, r3, {constant "KPfalseVKi"} #({tag 22:665}) [665->670] (level:1) is #f with stack state #f #({basic-block #() 670 680}, {basic-block #({tag 18:925}) 925 965}) beq {tag 18:925}, 8, N0/r29 #() [670->680] (level:1) is #f with stack state #f #({basic-block #() 680 705}, {basic-block #({tag 25:740}) 740 745}) ld N26/r23, G24/r20, 16 beq {tag 25:740}, N26/r23, {constant "KLobjectGVKd"} #() [680->705] (level:1) is #f with stack state #f #({basic-block #() 705 710}, {basic-block #({tag 27:710}) 710 730}) load-frame-offset #t, r5, -7 store-frame-offset N26/r23, -3 store-frame-offset r5, -2 move G32/r4, N26/r23 bne {tag 27:710}, G32/r4, {constant "KLobjectGVKd"} #() [705->710] (level:1) is #f with stack state #f #({basic-block #({tag 26:730}) 730 740}) move r3, {constant "KPtrueVKi"} #({tag 26:730}) [730->740] (level:1) is #f with stack state #f #({basic-block #({tag 25:740}) 740 745}, {basic-block #({tag 1:970}) 970 995}) load-frame-offset #t, G24/r20, -1 beq {tag 1:970}, r3, {constant "KPfalseVKi"} #({tag 25:740}) [740->745] (level:1) is #f with stack state #f #({basic-block #() 745 755}, {basic-block #({tag 18:925}) 925 965}) beq {tag 18:925}, 12, N0/r29 #() [745->755] (level:1) is #f with stack state #f #({basic-block #() 755 780}, {basic-block #({tag 28:815}) 815 820}) ld N26/r23, G24/r20, 20 beq {tag 28:815}, N26/r23, {constant "KLobjectGVKd"} #() [755->780] (level:1) is #f with stack state #f #({basic-block #() 780 785}, {basic-block #({tag 30:785}) 785 805}) load-frame-offset #t, r6, -8 store-frame-offset N26/r23, -3 store-frame-offset r6, -2 move G34/r4, N26/r23 bne {tag 30:785}, G34/r4, {constant "KLobjectGVKd"} #() [780->785] (level:1) is #f with stack state #f #({basic-block #({tag 29:805}) 805 815}) move r3, {constant "KPtrueVKi"} #({tag 29:805}) [805->815] (level:1) is #f with stack state #f #({basic-block #({tag 28:815}) 815 820}, {basic-block #({tag 1:970}) 970 995}) load-frame-offset #t, G24/r20, -1 beq {tag 1:970}, r3, {constant "KPfalseVKi"} #({tag 28:815}) [815->820] (level:1) is #f with stack state #f #({basic-block #() 820 825}, {basic-block #({tag 18:925}) 925 965}) beq {tag 18:925}, 16, N0/r29 #() [820->825] (level:1) is #f with stack state #f #({basic-block #({tag 17:825}) 825 830}) load-frame-offset #t, N25/r21, -4 #({tag 17:825}) [825->830] (level:3) is #f with stack state #f #({basic-block #() 830 850}, {basic-block #({tag 18:925}) 925 965}) ble {tag 18:925}, N25/r21, 16 #() [830->850] (level:3) is #f with stack state #f #({basic-block #() 850 885}, {basic-block #({tag 17:825}) 825 830}) sub N25/r21, N25/r21, 4 add N35/r23, N25/r21, 8 ld N26/r23, G24/r20, N35/r23 beq {tag 17:825}, N26/r23, {constant "KLobjectGVKd"} #() [850->885] (level:2) is #f with stack state #f #({basic-block #() 885 890}, {basic-block #({tag 32:890}) 890 910}) add N36/r3, N25/r21, -8 ld G23/r3, r30, N36/r3 store-frame-offset N26/r23, -3 store-frame-offset G23/r3, -2 store-frame-offset N25/r21, -4 move G38/r4, N26/r23 bne {tag 32:890}, G38/r4, {constant "KLobjectGVKd"} #() [885->890] (level:2) is #f with stack state #f #({basic-block #({tag 31:910}) 910 925}) move r3, {constant "KPtrueVKi"} #({tag 31:910}) [910->925] (level:2) is #f with stack state #f #({basic-block #({tag 17:825}) 825 830}, {basic-block #({tag 1:970}) 970 995}) load-frame-offset #t, N25/r21, -4 load-frame-offset #t, G24/r20, -1 bne {tag 17:825}, r3, {constant "KPfalseVKi"} #({tag 1:970}) [970->995] (level:1) is #f with stack state #f #({basic-block #() 995 995}) load-frame-offset #t, G40/r4, -3 load-frame-offset #t, G39/r3, -2 move r3, G39/r3 move r4, G40/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [995->995] (level:1) is #f with stack state #f #({basic-block #() 995 1000}) #() [995->1000] (level:1) is #f with stack state #f #() rts #({tag 4:320}) [320->330] (level:6) is #f with stack state #f #({basic-block #({tag 9:340}) 340 345}) ld G18/r20, N6/r21, 0 move N20/r23, N10/r19 #({tag 9:340}) [340->345] (level:7) is #f with stack state #f #({basic-block #({tag 3:400}, {tag 11:400}, {tag 13:400}) 400 415}, {basic-block #({tag 8:330}) 330 335}) bhi {tag 3:400}, N20/r23, N11/r22 #({tag 8:330}) [330->335] (level:6) is #f with stack state #f #({basic-block #() 335 340}, {basic-block #({tag 10:345}) 345 365}) beq-mem {tag 10:345}, N20/r23, 0, G18/r20 #() [335->340] (level:2) is #f with stack state #f #({basic-block #({tag 9:340}) 340 345}) add N20/r23, N20/r23, 8 #() [1005->1010] (level:0) is #f with stack state #f #() bra {tag 9:340} #({tag 21:560}) [560->580] (level:1) is #f with stack state #f #({basic-block #({tag 20:580}) 580 590}) ld N27/r23, G28/r4, 4 move r3, r3 move r4, G28/r4 call N27/r23, 2 #() [1010->1015] (level:0) is #f with stack state #f #() bra {tag 20:580} #({tag 18:925}) [925->965] (level:3) is #f with stack state #f #({basic-block #() 965 970}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #() [965->970] (level:3) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 24:635}) [635->655] (level:1) is #f with stack state #f #({basic-block #({tag 23:655}) 655 665}) ld N29/r22, G30/r23, 4 move r3, r4 move r4, G30/r23 call N29/r22, 2 #() [1015->1020] (level:0) is #f with stack state #f #() bra {tag 23:655} #({tag 27:710}) [710->730] (level:1) is #f with stack state #f #({basic-block #({tag 26:730}) 730 740}) ld N31/r23, G32/r4, 4 move r3, r5 move r4, G32/r4 call N31/r23, 2 #() [1020->1025] (level:0) is #f with stack state #f #() bra {tag 26:730} #({tag 30:785}) [785->805] (level:1) is #f with stack state #f #({basic-block #({tag 29:805}) 805 815}) ld N33/r23, G34/r4, 4 move r3, r6 move r4, G34/r4 call N33/r23, 2 #() [1025->1030] (level:0) is #f with stack state #f #() bra {tag 29:805} #({tag 32:890}) [890->910] (level:2) is #f with stack state #f #({basic-block #({tag 31:910}) 910 925}) ld N37/r23, G38/r4, 4 move r3, G23/r3 move r4, G38/r4 call N37/r23, 2 #() [1030->1035] (level:0) is #f with stack state #f #() bra {tag 31:910} #({tag 10:345}) [345->365] (level:6) is #f with stack state #f #({basic-block #() 365 370}, {basic-block #({tag 14:375}) 375 380}) sub N19/r23, N20/r23, N10/r19 asr N19/r23, N19/r23, 1 ld G17/r20, N6/r21, 4 beq {tag 14:375}, N19/r23, 0 #() [365->370] (level:5) is #f with stack state #f #({basic-block #() 370 375}, {basic-block #({tag 15:380}) 380 385}) beq {tag 15:380}, N19/r23, 4 #() [370->375] (level:4) is #f with stack state #f #({basic-block #({tag 12:390}) 390 400}, {basic-block #({tag 16:385}) 385 390}) beq {tag 16:385}, N19/r23, 8 #({tag 12:390}) [390->400] (level:3) is #f with stack state #f #({basic-block #({tag 3:400}, {tag 11:400}, {tag 13:400}) 400 415}) sub N22/r23, N19/r23, 12 st G17/r20, r0, N22/r23 #() [1035->1040] (level:0) is #f with stack state #f #() bra {tag 3:400} #({tag 14:375}) [375->380] (level:6) is #f with stack state #f #({basic-block #({tag 3:400}, {tag 11:400}, {tag 13:400}) 400 415}) move r4, G17/r20 #() [1040->1045] (level:0) is #f with stack state #f #() bra {tag 3:400} #({tag 15:380}) [380->385] (level:5) is #f with stack state #f #({basic-block #({tag 3:400}, {tag 11:400}, {tag 13:400}) 400 415}) move r5, G17/r20 #() [1045->1050] (level:0) is #f with stack state #f #() bra {tag 3:400} #({tag 16:385}) [385->390] (level:4) is #f with stack state #f #({basic-block #({tag 3:400}, {tag 11:400}, {tag 13:400}) 400 415}) move r6, G17/r20 #() [1050->1055] (level:0) is #f with stack state #f #() bra {tag 3:400} +++ ending code for primitive_process_keys_checking_args_for_xep_2 +++ +++ Live variable scopes for primitive_process_keys_checking_args_for_xep_2 +++ Start scope at 122 with frame for no variables End scope at 557 +++ No Source Code Locators for primitive_process_keys_checking_args_for_xep_2 +++ +++ Exported function definition primitive_process_keys_checking_args_for_xep +++ +++ starting code for primitive_process_keys_checking_args_for_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 90}) rem "This is a dummy first basic block." #() [5->90] (level:0) is #f with stack state #f #({basic-block #({tag 5:90}) 90 95}) pop N2/r20 ld G1/r21, r22, 20 push r3 push r22 push r23 push G1/r21 ld G4/r23, r22, 8 ld G4/r23, G4/r23, 4 and N7/r23, G4/r23, 524288 push N7/r23 ld G3/r22, r22, 20 ld N12/r23, G3/r22, 4 sub N12/r23, N12/r23, 1 lsr N13/r23, N12/r23, 1 add N15/r21, G3/r22, 12 sub N14/r23, r0, N13/r23 add N14/r23, N14/r23, 4 #({tag 5:90}) [90->95] (level:1) is #f with stack state #f #({basic-block #() 95 115}, {basic-block #({tag 6:115}) 115 130}) bhi {tag 6:115}, N14/r23, r0 #() [95->115] (level:1) is #f with stack state #f #({basic-block #({tag 5:90}) 90 95}) ld G16/r19, N15/r21, 0 st G16/r19, N14/r23, 0 add N15/r21, N15/r21, 8 add N14/r23, N14/r23, 4 #() [875->880] (level:0) is #f with stack state #f #() bra {tag 5:90} #({tag 6:115}) [115->130] (level:1) is #f with stack state #f #({basic-block #() 130 170}, {basic-block #({tag 2:175}) 175 230}) ld N8/r21, N2/r20, 4 sub N8/r21, N8/r21, 1 nbit {tag 2:175}, N8/r21, 4, 0 #() [130->170] (level:1) is #f with stack state #f #({basic-block #() 170 170}) add r1, r1, 4 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry move r3, r22 call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [170->170] (level:1) is #f with stack state #f #({basic-block #() 170 175}) #() [170->175] (level:1) is #f with stack state #f #() rts #({tag 2:175}) [175->230] (level:1) is #f with stack state #f #({basic-block #({tag 3:275}, {tag 10:275}) 275 290}) add N5/r23, N2/r20, 8 add N6/r21, N8/r21, N5/r23 ld N9/r19, G3/r22, 4 sub N9/r19, N9/r19, 1 add N10/r20, G3/r22, 8 add N11/r22, N10/r20, N9/r19 sub N11/r22, N11/r22, 8 asr N9/r19, N9/r19, 1 sub r0, r0, N9/r19 add r0, r0, 4 push N5/r23 #({tag 3:275}, {tag 10:275}) [275->290] (level:3) is #f with stack state #f #({basic-block #() 290 410}, {basic-block #({tag 4:230}) 230 240}) sub N6/r21, N6/r21, 8 ld N5/r23, r1, 0 bhs {tag 4:230}, N6/r21, N5/r23 #() [290->410] (level:1) is #f with stack state #f #({basic-block #() 410 430}, {basic-block #({tag 15:465}) 465 470}) add r1, r1, 8 add r1, r1, 4 pop r23 pop r22 pop r3 preserve-registers-entry ld N0/r29, r22, 8 ld N0/r29, N0/r29, 4 and N0/r29, N0/r29, 1020 move N25/r21, N0/r29 ld G24/r20, r22, 8 ld G24/r20, G24/r20, 8 push G24/r20 push 0 push 0 push N25/r21 push r3 push r4 push r5 push r6 push r22 push r23 ld N26/r23, G24/r20, 8 beq {tag 15:465}, N26/r23, {constant "KLobjectGVKd"} #() [410->430] (level:1) is #f with stack state #f #({basic-block #() 430 435}, {basic-block #({tag 17:435}) 435 455}) store-frame-offset N26/r23, -3 store-frame-offset r3, -2 move G28/r4, N26/r23 bne {tag 17:435}, G28/r4, {constant "KLobjectGVKd"} #() [430->435] (level:1) is #f with stack state #f #({basic-block #({tag 16:455}) 455 465}) move r3, {constant "KPtrueVKi"} #({tag 16:455}) [455->465] (level:1) is #f with stack state #f #({basic-block #({tag 15:465}) 465 470}, {basic-block #({tag 1:845}) 845 870}) load-frame-offset #t, G24/r20, -1 beq {tag 1:845}, r3, {constant "KPfalseVKi"} #({tag 15:465}) [465->470] (level:1) is #f with stack state #f #({basic-block #() 470 480}, {basic-block #({tag 14:800}) 800 840}) beq {tag 14:800}, 4, N0/r29 #() [470->480] (level:1) is #f with stack state #f #({basic-block #() 480 505}, {basic-block #({tag 18:540}) 540 545}) ld N26/r23, G24/r20, 12 beq {tag 18:540}, N26/r23, {constant "KLobjectGVKd"} #() [480->505] (level:1) is #f with stack state #f #({basic-block #() 505 510}, {basic-block #({tag 20:510}) 510 530}) load-frame-offset #t, r4, -6 store-frame-offset N26/r23, -3 store-frame-offset r4, -2 move G30/r23, N26/r23 bne {tag 20:510}, G30/r23, {constant "KLobjectGVKd"} #() [505->510] (level:1) is #f with stack state #f #({basic-block #({tag 19:530}) 530 540}) move r3, {constant "KPtrueVKi"} #({tag 19:530}) [530->540] (level:1) is #f with stack state #f #({basic-block #({tag 18:540}) 540 545}, {basic-block #({tag 1:845}) 845 870}) load-frame-offset #t, G24/r20, -1 beq {tag 1:845}, r3, {constant "KPfalseVKi"} #({tag 18:540}) [540->545] (level:1) is #f with stack state #f #({basic-block #() 545 555}, {basic-block #({tag 14:800}) 800 840}) beq {tag 14:800}, 8, N0/r29 #() [545->555] (level:1) is #f with stack state #f #({basic-block #() 555 580}, {basic-block #({tag 21:615}) 615 620}) ld N26/r23, G24/r20, 16 beq {tag 21:615}, N26/r23, {constant "KLobjectGVKd"} #() [555->580] (level:1) is #f with stack state #f #({basic-block #() 580 585}, {basic-block #({tag 23:585}) 585 605}) load-frame-offset #t, r5, -7 store-frame-offset N26/r23, -3 store-frame-offset r5, -2 move G32/r4, N26/r23 bne {tag 23:585}, G32/r4, {constant "KLobjectGVKd"} #() [580->585] (level:1) is #f with stack state #f #({basic-block #({tag 22:605}) 605 615}) move r3, {constant "KPtrueVKi"} #({tag 22:605}) [605->615] (level:1) is #f with stack state #f #({basic-block #({tag 21:615}) 615 620}, {basic-block #({tag 1:845}) 845 870}) load-frame-offset #t, G24/r20, -1 beq {tag 1:845}, r3, {constant "KPfalseVKi"} #({tag 21:615}) [615->620] (level:1) is #f with stack state #f #({basic-block #() 620 630}, {basic-block #({tag 14:800}) 800 840}) beq {tag 14:800}, 12, N0/r29 #() [620->630] (level:1) is #f with stack state #f #({basic-block #() 630 655}, {basic-block #({tag 24:690}) 690 695}) ld N26/r23, G24/r20, 20 beq {tag 24:690}, N26/r23, {constant "KLobjectGVKd"} #() [630->655] (level:1) is #f with stack state #f #({basic-block #() 655 660}, {basic-block #({tag 26:660}) 660 680}) load-frame-offset #t, r6, -8 store-frame-offset N26/r23, -3 store-frame-offset r6, -2 move G34/r4, N26/r23 bne {tag 26:660}, G34/r4, {constant "KLobjectGVKd"} #() [655->660] (level:1) is #f with stack state #f #({basic-block #({tag 25:680}) 680 690}) move r3, {constant "KPtrueVKi"} #({tag 25:680}) [680->690] (level:1) is #f with stack state #f #({basic-block #({tag 24:690}) 690 695}, {basic-block #({tag 1:845}) 845 870}) load-frame-offset #t, G24/r20, -1 beq {tag 1:845}, r3, {constant "KPfalseVKi"} #({tag 24:690}) [690->695] (level:1) is #f with stack state #f #({basic-block #() 695 700}, {basic-block #({tag 14:800}) 800 840}) beq {tag 14:800}, 16, N0/r29 #() [695->700] (level:1) is #f with stack state #f #({basic-block #({tag 13:700}) 700 705}) load-frame-offset #t, N25/r21, -4 #({tag 13:700}) [700->705] (level:3) is #f with stack state #f #({basic-block #() 705 725}, {basic-block #({tag 14:800}) 800 840}) ble {tag 14:800}, N25/r21, 16 #() [705->725] (level:3) is #f with stack state #f #({basic-block #() 725 760}, {basic-block #({tag 13:700}) 700 705}) sub N25/r21, N25/r21, 4 add N35/r23, N25/r21, 8 ld N26/r23, G24/r20, N35/r23 beq {tag 13:700}, N26/r23, {constant "KLobjectGVKd"} #() [725->760] (level:2) is #f with stack state #f #({basic-block #() 760 765}, {basic-block #({tag 28:765}) 765 785}) add N36/r3, N25/r21, -8 ld G23/r3, r30, N36/r3 store-frame-offset N26/r23, -3 store-frame-offset G23/r3, -2 store-frame-offset N25/r21, -4 move G38/r4, N26/r23 bne {tag 28:765}, G38/r4, {constant "KLobjectGVKd"} #() [760->765] (level:2) is #f with stack state #f #({basic-block #({tag 27:785}) 785 800}) move r3, {constant "KPtrueVKi"} #({tag 27:785}) [785->800] (level:2) is #f with stack state #f #({basic-block #({tag 13:700}) 700 705}, {basic-block #({tag 1:845}) 845 870}) load-frame-offset #t, N25/r21, -4 load-frame-offset #t, G24/r20, -1 bne {tag 13:700}, r3, {constant "KPfalseVKi"} #({tag 1:845}) [845->870] (level:1) is #f with stack state #f #({basic-block #() 870 870}) load-frame-offset #t, G40/r4, -3 load-frame-offset #t, G39/r3, -2 move r3, G39/r3 move r4, G40/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [870->870] (level:1) is #f with stack state #f #({basic-block #() 870 875}) #() [870->875] (level:1) is #f with stack state #f #() rts #({tag 4:230}) [230->240] (level:3) is #f with stack state #f #({basic-block #({tag 8:250}) 250 255}) ld G18/r19, N6/r21, 0 move N20/r23, N10/r20 #({tag 8:250}) [250->255] (level:4) is #f with stack state #f #({basic-block #({tag 3:275}, {tag 10:275}) 275 290}, {basic-block #({tag 7:240}) 240 245}) bhi {tag 3:275}, N20/r23, N11/r22 #({tag 7:240}) [240->245] (level:3) is #f with stack state #f #({basic-block #() 245 250}, {basic-block #({tag 9:255}) 255 275}) beq-mem {tag 9:255}, N20/r23, 0, G18/r19 #() [245->250] (level:2) is #f with stack state #f #({basic-block #({tag 8:250}) 250 255}) add N20/r23, N20/r23, 8 #() [880->885] (level:0) is #f with stack state #f #() bra {tag 8:250} #({tag 17:435}) [435->455] (level:1) is #f with stack state #f #({basic-block #({tag 16:455}) 455 465}) ld N27/r23, G28/r4, 4 move r3, r3 move r4, G28/r4 call N27/r23, 2 #() [885->890] (level:0) is #f with stack state #f #() bra {tag 16:455} #({tag 14:800}) [800->840] (level:3) is #f with stack state #f #({basic-block #() 840 845}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #() [840->845] (level:3) is #f with stack state #f #() jmp-indirect r22, 16, #[4, #"mlist", #"function"], 0, #f, #f #({tag 20:510}) [510->530] (level:1) is #f with stack state #f #({basic-block #({tag 19:530}) 530 540}) ld N29/r22, G30/r23, 4 move r3, r4 move r4, G30/r23 call N29/r22, 2 #() [890->895] (level:0) is #f with stack state #f #() bra {tag 19:530} #({tag 23:585}) [585->605] (level:1) is #f with stack state #f #({basic-block #({tag 22:605}) 605 615}) ld N31/r23, G32/r4, 4 move r3, r5 move r4, G32/r4 call N31/r23, 2 #() [895->900] (level:0) is #f with stack state #f #() bra {tag 22:605} #({tag 26:660}) [660->680] (level:1) is #f with stack state #f #({basic-block #({tag 25:680}) 680 690}) ld N33/r23, G34/r4, 4 move r3, r6 move r4, G34/r4 call N33/r23, 2 #() [900->905] (level:0) is #f with stack state #f #() bra {tag 25:680} #({tag 28:765}) [765->785] (level:2) is #f with stack state #f #({basic-block #({tag 27:785}) 785 800}) ld N37/r23, G38/r4, 4 move r3, G23/r3 move r4, G38/r4 call N37/r23, 2 #() [905->910] (level:0) is #f with stack state #f #() bra {tag 27:785} #({tag 9:255}) [255->275] (level:3) is #f with stack state #f #({basic-block #({tag 3:275}, {tag 10:275}) 275 290}) sub N19/r23, N20/r23, N10/r20 asr N19/r23, N19/r23, 1 ld G17/r19, N6/r21, 4 st G17/r19, r0, N19/r23 #() [910->915] (level:0) is #f with stack state #f #() bra {tag 3:275} +++ ending code for primitive_process_keys_checking_args_for_xep +++ +++ Live variable scopes for primitive_process_keys_checking_args_for_xep +++ Start scope at 86 with frame for no variables End scope at 513 +++ No Source Code Locators for primitive_process_keys_checking_args_for_xep +++ +++ Exported function definition slotacc_single_q_instance_getter_xep +++ +++ starting code for slotacc_single_q_instance_getter_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55}) bne {tag 1:25}, r0, 2 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move r23, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_instance_getterVKiI"}, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:25}) [25->55] (level:0) is #f with stack state #f #({basic-block #() 55 55}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [55->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) #() [55->60] (level:0) is #f with stack state #f #() rts +++ ending code for slotacc_single_q_instance_getter_xep +++ +++ No Source Code Locators for slotacc_single_q_instance_getter_xep +++ +++ Exported function definition slotacc_single_q_instance_setter_xep +++ +++ starting code for slotacc_single_q_instance_setter_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55}) bne {tag 1:25}, r0, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move r23, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_instance_setterVKiI"}, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:25}) [25->55] (level:0) is #f with stack state #f #({basic-block #() 55 55}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [55->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) #() [55->60] (level:0) is #f with stack state #f #() rts +++ ending code for slotacc_single_q_instance_setter_xep +++ +++ No Source Code Locators for slotacc_single_q_instance_setter_xep +++ +++ Exported function definition slotacc_single_q_class_getter_xep +++ +++ starting code for slotacc_single_q_class_getter_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55}) bne {tag 1:25}, r0, 2 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move r23, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_class_getterVKiI"}, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:25}) [25->55] (level:0) is #f with stack state #f #({basic-block #() 55 55}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [55->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) #() [55->60] (level:0) is #f with stack state #f #() rts +++ ending code for slotacc_single_q_class_getter_xep +++ +++ No Source Code Locators for slotacc_single_q_class_getter_xep +++ +++ Exported function definition slotacc_single_q_class_setter_xep +++ +++ starting code for slotacc_single_q_class_setter_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55}) bne {tag 1:25}, r0, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move r23, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_class_setterVKiI"}, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:25}) [25->55] (level:0) is #f with stack state #f #({basic-block #() 55 55}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [55->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) #() [55->60] (level:0) is #f with stack state #f #() rts +++ ending code for slotacc_single_q_class_setter_xep +++ +++ No Source Code Locators for slotacc_single_q_class_setter_xep +++ +++ Exported function definition slotacc_repeated_instance_getter_xep +++ +++ starting code for slotacc_repeated_instance_getter_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55}) bne {tag 1:25}, r0, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move r23, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_repeated_instance_getterVKiI"}, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:25}) [25->55] (level:0) is #f with stack state #f #({basic-block #() 55 55}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [55->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) #() [55->60] (level:0) is #f with stack state #f #() rts +++ ending code for slotacc_repeated_instance_getter_xep +++ +++ No Source Code Locators for slotacc_repeated_instance_getter_xep +++ +++ Exported function definition slotacc_repeated_instance_setter_xep +++ +++ starting code for slotacc_repeated_instance_setter_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:25}) 25 55}) bne {tag 1:25}, r0, 4 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move r23, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_repeated_instance_setterVKiI"}, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:25}) [25->55] (level:0) is #f with stack state #f #({basic-block #() 55 55}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [55->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) #() [55->60] (level:0) is #f with stack state #f #() rts +++ ending code for slotacc_repeated_instance_setter_xep +++ +++ No Source Code Locators for slotacc_repeated_instance_setter_xep +++ +++ Exported function definition primitive_set_accessor_method_xep +++ +++ starting code for primitive_set_accessor_method_xep +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:50}) 50 55}) move G0/r3, r3 move N2/r4, r4 asr N2/r4, N2/r4, 2 beq {tag 1:50}, N2/r4, 0 #() [25->30] (level:0) is green with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 2:55}) 55 60}) beq {tag 2:55}, N2/r4, 1 #() [30->35] (level:0) is green with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 3:60}) 60 65}) beq {tag 3:60}, N2/r4, 2 #() [35->40] (level:0) is green with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 4:65}) 65 70}) beq {tag 4:65}, N2/r4, 3 #() [40->45] (level:0) is green with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 5:70}) 70 75}) beq {tag 5:70}, N2/r4, 4 #() [45->50] (level:0) is green with stack state #f #({basic-block #({tag 1:50}) 50 55}, {basic-block #({tag 6:75}) 75 80}) beq {tag 6:75}, N2/r4, 5 #({tag 1:50}) [50->55] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/r23, {constant "slotacc_single_q_instance_getter_xep"} #({tag 7:80}) [80->90] (level:0) is green with stack state #f #({basic-block #() 90 95}) st N1/r23, G0/r3, 4 move r3, G0/r3 #() [90->95] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 2:55}) [55->60] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/r23, {constant "slotacc_single_q_instance_setter_xep"} #() [95->100] (level:0) is #f with stack state #f #() bra {tag 7:80} #({tag 3:60}) [60->65] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/r23, {constant "slotacc_single_q_class_getter_xep"} #() [100->105] (level:0) is #f with stack state #f #() bra {tag 7:80} #({tag 4:65}) [65->70] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/r23, {constant "slotacc_single_q_class_setter_xep"} #() [105->110] (level:0) is #f with stack state #f #() bra {tag 7:80} #({tag 5:70}) [70->75] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/r23, {constant "slotacc_repeated_instance_getter_xep"} #() [110->115] (level:0) is #f with stack state #f #() bra {tag 7:80} #({tag 6:75}) [75->80] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/r23, {constant "slotacc_repeated_instance_setter_xep"} #() [115->120] (level:0) is #f with stack state #f #() bra {tag 7:80} +++ ending code for primitive_set_accessor_method_xep +++ +++ No Source Code Locators for primitive_set_accessor_method_xep +++ +++ Exported function definition xep_0 +++ +++ starting code for xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:20}) 20 50}) bne {tag 1:20}, r0, 0 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move r23, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:20}) [20->50] (level:0) is #f with stack state #f #({basic-block #() 50 50}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [50->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}) #() [50->55] (level:0) is #f with stack state #f #() rts +++ ending code for xep_0 +++ +++ No Source Code Locators for xep_0 +++ +++ Exported function definition xep_1 +++ +++ starting code for xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:175}) 175 205}) bne {tag 1:175}, r0, 1 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 100}, {basic-block #({tag 4:170}) 170 170}) move r23, {constant "KPfalseVKi"} ld G1/r21, r22, 8 ld G1/r21, G1/r21, 8 ld N2/r20, G1/r21, 8 beq {tag 4:170}, N2/r20, {constant "KLobjectGVKd"} #() [35->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 6:105}) 105 125}) move G0/r19, r3 preserve-registers-entry push G1/r21 push G0/r19 push N2/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G4/r4, N2/r20 bne {tag 6:105}, G4/r4, {constant "KLobjectGVKd"} #() [100->105] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) move r3, {constant "KPtrueVKi"} #({tag 5:125}) [125->130] (level:0) is #f with stack state #f #({basic-block #() 130 170}, {basic-block #({tag 3:210}, {tag 2:210}) 210 235}) beq {tag 3:210}, r3, {constant "KPfalseVKi"} #() [130->170] (level:0) is #f with stack state #f #({basic-block #({tag 4:170}) 170 170}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 4:170}) [170->170] (level:0) is #f with stack state #f #({basic-block #({tag 4:170}) 170 175}) #({tag 4:170}) [170->175] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:175}) [175->205] (level:0) is #f with stack state #f #({basic-block #() 205 205}) preserve-registers-entry asl N5/r4, r0, 2 add N5/r4, N5/r4, 1 move r3, r22 move r4, N5/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [205->205] (level:0) is #f with stack state #f #({basic-block #() 205 210}) #() [205->210] (level:0) is #f with stack state #f #() rts #({tag 6:105}) [105->125] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) ld N3/r23, G4/r4, 4 move r3, G0/r19 move r4, G4/r4 call N3/r23, 2 #() [240->245] (level:0) is #f with stack state #f #() bra {tag 5:125} #({tag 3:210}, {tag 2:210}) [210->235] (level:0) is #f with stack state #f #({basic-block #() 235 235}) load-frame-offset #t, G7/r4, -3 load-frame-offset #t, G6/r3, -2 move r3, G6/r3 move r4, G7/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [235->235] (level:0) is #f with stack state #f #({basic-block #() 235 240}) #() [235->240] (level:0) is #f with stack state #f #() rts +++ ending code for xep_1 +++ +++ Live variable scopes for xep_1 +++ Start scope at 34 with frame for no variables End scope at 97 Start scope at 98 no frame for no variables End scope at 119 +++ No Source Code Locators for xep_1 +++ +++ Exported function definition xep_2 +++ +++ starting code for xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:330}) 330 360}) bne {tag 1:330}, r0, 2 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 100}, {basic-block #({tag 4:170}) 170 190}) move r23, {constant "KPfalseVKi"} ld G1/r21, r22, 8 ld G1/r21, G1/r21, 8 ld N2/r20, G1/r21, 8 beq {tag 4:170}, N2/r20, {constant "KLobjectGVKd"} #() [35->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 6:105}) 105 125}) move G0/r19, r3 preserve-registers-entry push G1/r21 push G0/r19 push N2/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G4/r4, N2/r20 bne {tag 6:105}, G4/r4, {constant "KLobjectGVKd"} #() [100->105] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) move r3, {constant "KPtrueVKi"} #({tag 5:125}) [125->130] (level:0) is #f with stack state #f #({basic-block #() 130 170}, {basic-block #({tag 3:365}, {tag 2:365}) 365 390}) beq {tag 3:365}, r3, {constant "KPfalseVKi"} #() [130->170] (level:0) is #f with stack state #f #({basic-block #({tag 4:170}) 170 190}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 4:170}) [170->190] (level:0) is #f with stack state #f #({basic-block #() 190 255}, {basic-block #({tag 7:325}) 325 325}) ld G6/r21, r22, 8 ld G6/r21, G6/r21, 8 ld N7/r20, G6/r21, 12 beq {tag 7:325}, N7/r20, {constant "KLobjectGVKd"} #() [190->255] (level:0) is #f with stack state #f #({basic-block #() 255 260}, {basic-block #({tag 9:260}) 260 280}) move G5/r19, r4 preserve-registers-entry push G6/r21 push G5/r19 push N7/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G9/r4, N7/r20 bne {tag 9:260}, G9/r4, {constant "KLobjectGVKd"} #() [255->260] (level:0) is #f with stack state #f #({basic-block #({tag 8:280}) 280 285}) move r3, {constant "KPtrueVKi"} #({tag 8:280}) [280->285] (level:0) is #f with stack state #f #({basic-block #() 285 325}, {basic-block #({tag 3:365}, {tag 2:365}) 365 390}) beq {tag 3:365}, r3, {constant "KPfalseVKi"} #() [285->325] (level:0) is #f with stack state #f #({basic-block #({tag 7:325}) 325 325}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 7:325}) [325->325] (level:0) is #f with stack state #f #({basic-block #({tag 7:325}) 325 330}) #({tag 7:325}) [325->330] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:330}) [330->360] (level:0) is #f with stack state #f #({basic-block #() 360 360}) preserve-registers-entry asl N10/r4, r0, 2 add N10/r4, N10/r4, 1 move r3, r22 move r4, N10/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [360->360] (level:0) is #f with stack state #f #({basic-block #() 360 365}) #() [360->365] (level:0) is #f with stack state #f #() rts #({tag 6:105}) [105->125] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) ld N3/r23, G4/r4, 4 move r3, G0/r19 move r4, G4/r4 call N3/r23, 2 #() [395->400] (level:0) is #f with stack state #f #() bra {tag 5:125} #({tag 3:365}, {tag 2:365}) [365->390] (level:0) is #f with stack state #f #({basic-block #() 390 390}) load-frame-offset #t, G12/r4, -3 load-frame-offset #t, G11/r3, -2 move r3, G11/r3 move r4, G12/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [390->390] (level:0) is #f with stack state #f #({basic-block #() 390 395}) #() [390->395] (level:0) is #f with stack state #f #() rts #({tag 9:260}) [260->280] (level:0) is #f with stack state #f #({basic-block #({tag 8:280}) 280 285}) ld N8/r23, G9/r4, 4 move r3, G5/r19 move r4, G9/r4 call N8/r23, 2 #() [400->405] (level:0) is #f with stack state #f #() bra {tag 8:280} +++ ending code for xep_2 +++ +++ Live variable scopes for xep_2 +++ Start scope at 34 with frame for no variables End scope at 97 Start scope at 98 no frame for no variables End scope at 129 Start scope at 130 with frame for no variables End scope at 193 Start scope at 194 no frame for no variables End scope at 215 +++ No Source Code Locators for xep_2 +++ +++ Exported function definition xep_3 +++ +++ starting code for xep_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:485}) 485 515}) bne {tag 1:485}, r0, 3 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 100}, {basic-block #({tag 4:170}) 170 190}) move r23, {constant "KPfalseVKi"} ld G1/r21, r22, 8 ld G1/r21, G1/r21, 8 ld N2/r20, G1/r21, 8 beq {tag 4:170}, N2/r20, {constant "KLobjectGVKd"} #() [35->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 6:105}) 105 125}) move G0/r19, r3 preserve-registers-entry push G1/r21 push G0/r19 push N2/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G4/r4, N2/r20 bne {tag 6:105}, G4/r4, {constant "KLobjectGVKd"} #() [100->105] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) move r3, {constant "KPtrueVKi"} #({tag 5:125}) [125->130] (level:0) is #f with stack state #f #({basic-block #() 130 170}, {basic-block #({tag 3:520}, {tag 2:520}) 520 545}) beq {tag 3:520}, r3, {constant "KPfalseVKi"} #() [130->170] (level:0) is #f with stack state #f #({basic-block #({tag 4:170}) 170 190}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 4:170}) [170->190] (level:0) is #f with stack state #f #({basic-block #() 190 255}, {basic-block #({tag 7:325}) 325 345}) ld G6/r21, r22, 8 ld G6/r21, G6/r21, 8 ld N7/r20, G6/r21, 12 beq {tag 7:325}, N7/r20, {constant "KLobjectGVKd"} #() [190->255] (level:0) is #f with stack state #f #({basic-block #() 255 260}, {basic-block #({tag 9:260}) 260 280}) move G5/r19, r4 preserve-registers-entry push G6/r21 push G5/r19 push N7/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G9/r4, N7/r20 bne {tag 9:260}, G9/r4, {constant "KLobjectGVKd"} #() [255->260] (level:0) is #f with stack state #f #({basic-block #({tag 8:280}) 280 285}) move r3, {constant "KPtrueVKi"} #({tag 8:280}) [280->285] (level:0) is #f with stack state #f #({basic-block #() 285 325}, {basic-block #({tag 3:520}, {tag 2:520}) 520 545}) beq {tag 3:520}, r3, {constant "KPfalseVKi"} #() [285->325] (level:0) is #f with stack state #f #({basic-block #({tag 7:325}) 325 345}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 7:325}) [325->345] (level:0) is #f with stack state #f #({basic-block #() 345 410}, {basic-block #({tag 10:480}) 480 480}) ld G11/r21, r22, 8 ld G11/r21, G11/r21, 8 ld N12/r20, G11/r21, 16 beq {tag 10:480}, N12/r20, {constant "KLobjectGVKd"} #() [345->410] (level:0) is #f with stack state #f #({basic-block #() 410 415}, {basic-block #({tag 12:415}) 415 435}) move G10/r19, r5 preserve-registers-entry push G11/r21 push G10/r19 push N12/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G14/r4, N12/r20 bne {tag 12:415}, G14/r4, {constant "KLobjectGVKd"} #() [410->415] (level:0) is #f with stack state #f #({basic-block #({tag 11:435}) 435 440}) move r3, {constant "KPtrueVKi"} #({tag 11:435}) [435->440] (level:0) is #f with stack state #f #({basic-block #() 440 480}, {basic-block #({tag 3:520}, {tag 2:520}) 520 545}) beq {tag 3:520}, r3, {constant "KPfalseVKi"} #() [440->480] (level:0) is #f with stack state #f #({basic-block #({tag 10:480}) 480 480}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 10:480}) [480->480] (level:0) is #f with stack state #f #({basic-block #({tag 10:480}) 480 485}) #({tag 10:480}) [480->485] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:485}) [485->515] (level:0) is #f with stack state #f #({basic-block #() 515 515}) preserve-registers-entry asl N15/r4, r0, 2 add N15/r4, N15/r4, 1 move r3, r22 move r4, N15/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [515->515] (level:0) is #f with stack state #f #({basic-block #() 515 520}) #() [515->520] (level:0) is #f with stack state #f #() rts #({tag 6:105}) [105->125] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) ld N3/r23, G4/r4, 4 move r3, G0/r19 move r4, G4/r4 call N3/r23, 2 #() [550->555] (level:0) is #f with stack state #f #() bra {tag 5:125} #({tag 3:520}, {tag 2:520}) [520->545] (level:0) is #f with stack state #f #({basic-block #() 545 545}) load-frame-offset #t, G17/r4, -3 load-frame-offset #t, G16/r3, -2 move r3, G16/r3 move r4, G17/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [545->545] (level:0) is #f with stack state #f #({basic-block #() 545 550}) #() [545->550] (level:0) is #f with stack state #f #() rts #({tag 9:260}) [260->280] (level:0) is #f with stack state #f #({basic-block #({tag 8:280}) 280 285}) ld N8/r23, G9/r4, 4 move r3, G5/r19 move r4, G9/r4 call N8/r23, 2 #() [555->560] (level:0) is #f with stack state #f #() bra {tag 8:280} #({tag 12:415}) [415->435] (level:0) is #f with stack state #f #({basic-block #({tag 11:435}) 435 440}) ld N13/r23, G14/r4, 4 move r3, G10/r19 move r4, G14/r4 call N13/r23, 2 #() [560->565] (level:0) is #f with stack state #f #() bra {tag 11:435} +++ ending code for xep_3 +++ +++ Live variable scopes for xep_3 +++ Start scope at 34 with frame for no variables End scope at 97 Start scope at 98 no frame for no variables End scope at 129 Start scope at 130 with frame for no variables End scope at 193 Start scope at 194 no frame for no variables End scope at 225 Start scope at 226 with frame for no variables End scope at 289 Start scope at 290 no frame for no variables End scope at 311 +++ No Source Code Locators for xep_3 +++ +++ Exported function definition xep_4 +++ +++ starting code for xep_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:640}) 640 670}) bne {tag 1:640}, r0, 4 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 100}, {basic-block #({tag 4:170}) 170 190}) move r23, {constant "KPfalseVKi"} ld G1/r21, r22, 8 ld G1/r21, G1/r21, 8 ld N2/r20, G1/r21, 8 beq {tag 4:170}, N2/r20, {constant "KLobjectGVKd"} #() [35->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 6:105}) 105 125}) move G0/r19, r3 preserve-registers-entry push G1/r21 push G0/r19 push N2/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G4/r4, N2/r20 bne {tag 6:105}, G4/r4, {constant "KLobjectGVKd"} #() [100->105] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) move r3, {constant "KPtrueVKi"} #({tag 5:125}) [125->130] (level:0) is #f with stack state #f #({basic-block #() 130 170}, {basic-block #({tag 3:675}, {tag 2:675}) 675 700}) beq {tag 3:675}, r3, {constant "KPfalseVKi"} #() [130->170] (level:0) is #f with stack state #f #({basic-block #({tag 4:170}) 170 190}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 4:170}) [170->190] (level:0) is #f with stack state #f #({basic-block #() 190 255}, {basic-block #({tag 7:325}) 325 345}) ld G6/r21, r22, 8 ld G6/r21, G6/r21, 8 ld N7/r20, G6/r21, 12 beq {tag 7:325}, N7/r20, {constant "KLobjectGVKd"} #() [190->255] (level:0) is #f with stack state #f #({basic-block #() 255 260}, {basic-block #({tag 9:260}) 260 280}) move G5/r19, r4 preserve-registers-entry push G6/r21 push G5/r19 push N7/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G9/r4, N7/r20 bne {tag 9:260}, G9/r4, {constant "KLobjectGVKd"} #() [255->260] (level:0) is #f with stack state #f #({basic-block #({tag 8:280}) 280 285}) move r3, {constant "KPtrueVKi"} #({tag 8:280}) [280->285] (level:0) is #f with stack state #f #({basic-block #() 285 325}, {basic-block #({tag 3:675}, {tag 2:675}) 675 700}) beq {tag 3:675}, r3, {constant "KPfalseVKi"} #() [285->325] (level:0) is #f with stack state #f #({basic-block #({tag 7:325}) 325 345}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 7:325}) [325->345] (level:0) is #f with stack state #f #({basic-block #() 345 410}, {basic-block #({tag 10:480}) 480 500}) ld G11/r21, r22, 8 ld G11/r21, G11/r21, 8 ld N12/r20, G11/r21, 16 beq {tag 10:480}, N12/r20, {constant "KLobjectGVKd"} #() [345->410] (level:0) is #f with stack state #f #({basic-block #() 410 415}, {basic-block #({tag 12:415}) 415 435}) move G10/r19, r5 preserve-registers-entry push G11/r21 push G10/r19 push N12/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G14/r4, N12/r20 bne {tag 12:415}, G14/r4, {constant "KLobjectGVKd"} #() [410->415] (level:0) is #f with stack state #f #({basic-block #({tag 11:435}) 435 440}) move r3, {constant "KPtrueVKi"} #({tag 11:435}) [435->440] (level:0) is #f with stack state #f #({basic-block #() 440 480}, {basic-block #({tag 3:675}, {tag 2:675}) 675 700}) beq {tag 3:675}, r3, {constant "KPfalseVKi"} #() [440->480] (level:0) is #f with stack state #f #({basic-block #({tag 10:480}) 480 500}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 10:480}) [480->500] (level:0) is #f with stack state #f #({basic-block #() 500 565}, {basic-block #({tag 13:635}) 635 635}) ld G16/r21, r22, 8 ld G16/r21, G16/r21, 8 ld N17/r20, G16/r21, 20 beq {tag 13:635}, N17/r20, {constant "KLobjectGVKd"} #() [500->565] (level:0) is #f with stack state #f #({basic-block #() 565 570}, {basic-block #({tag 15:570}) 570 590}) move G15/r19, r6 preserve-registers-entry push G16/r21 push G15/r19 push N17/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G19/r4, N17/r20 bne {tag 15:570}, G19/r4, {constant "KLobjectGVKd"} #() [565->570] (level:0) is #f with stack state #f #({basic-block #({tag 14:590}) 590 595}) move r3, {constant "KPtrueVKi"} #({tag 14:590}) [590->595] (level:0) is #f with stack state #f #({basic-block #() 595 635}, {basic-block #({tag 3:675}, {tag 2:675}) 675 700}) beq {tag 3:675}, r3, {constant "KPfalseVKi"} #() [595->635] (level:0) is #f with stack state #f #({basic-block #({tag 13:635}) 635 635}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 13:635}) [635->635] (level:0) is #f with stack state #f #({basic-block #({tag 13:635}) 635 640}) #({tag 13:635}) [635->640] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:640}) [640->670] (level:0) is #f with stack state #f #({basic-block #() 670 670}) preserve-registers-entry asl N20/r4, r0, 2 add N20/r4, N20/r4, 1 move r3, r22 move r4, N20/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [670->670] (level:0) is #f with stack state #f #({basic-block #() 670 675}) #() [670->675] (level:0) is #f with stack state #f #() rts #({tag 6:105}) [105->125] (level:0) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) ld N3/r23, G4/r4, 4 move r3, G0/r19 move r4, G4/r4 call N3/r23, 2 #() [705->710] (level:0) is #f with stack state #f #() bra {tag 5:125} #({tag 3:675}, {tag 2:675}) [675->700] (level:0) is #f with stack state #f #({basic-block #() 700 700}) load-frame-offset #t, G22/r4, -3 load-frame-offset #t, G21/r3, -2 move r3, G21/r3 move r4, G22/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [700->700] (level:0) is #f with stack state #f #({basic-block #() 700 705}) #() [700->705] (level:0) is #f with stack state #f #() rts #({tag 9:260}) [260->280] (level:0) is #f with stack state #f #({basic-block #({tag 8:280}) 280 285}) ld N8/r23, G9/r4, 4 move r3, G5/r19 move r4, G9/r4 call N8/r23, 2 #() [710->715] (level:0) is #f with stack state #f #() bra {tag 8:280} #({tag 12:415}) [415->435] (level:0) is #f with stack state #f #({basic-block #({tag 11:435}) 435 440}) ld N13/r23, G14/r4, 4 move r3, G10/r19 move r4, G14/r4 call N13/r23, 2 #() [715->720] (level:0) is #f with stack state #f #() bra {tag 11:435} #({tag 15:570}) [570->590] (level:0) is #f with stack state #f #({basic-block #({tag 14:590}) 590 595}) ld N18/r23, G19/r4, 4 move r3, G15/r19 move r4, G19/r4 call N18/r23, 2 #() [720->725] (level:0) is #f with stack state #f #() bra {tag 14:590} +++ ending code for xep_4 +++ +++ Live variable scopes for xep_4 +++ Start scope at 34 with frame for no variables End scope at 97 Start scope at 98 no frame for no variables End scope at 129 Start scope at 130 with frame for no variables End scope at 193 Start scope at 194 no frame for no variables End scope at 225 Start scope at 226 with frame for no variables End scope at 289 Start scope at 290 no frame for no variables End scope at 321 Start scope at 322 with frame for no variables End scope at 385 Start scope at 386 no frame for no variables End scope at 407 +++ No Source Code Locators for xep_4 +++ +++ Exported function definition xep_5 +++ +++ starting code for xep_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65}) bne {tag 1:35}, r0, 5 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move r23, {constant "KPfalseVKi"} move r0, 20 move r0, r0 #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:35}) [35->65] (level:0) is #f with stack state #f #({basic-block #() 65 65}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [65->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) #() [65->70] (level:0) is #f with stack state #f #() rts +++ ending code for xep_5 +++ +++ No Source Code Locators for xep_5 +++ +++ Exported function definition xep_6 +++ +++ starting code for xep_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65}) bne {tag 1:35}, r0, 6 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move r23, {constant "KPfalseVKi"} move r0, 24 move r0, r0 #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:35}) [35->65] (level:0) is #f with stack state #f #({basic-block #() 65 65}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [65->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) #() [65->70] (level:0) is #f with stack state #f #() rts +++ ending code for xep_6 +++ +++ No Source Code Locators for xep_6 +++ +++ Exported function definition xep_7 +++ +++ starting code for xep_7 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65}) bne {tag 1:35}, r0, 7 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move r23, {constant "KPfalseVKi"} move r0, 28 move r0, r0 #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:35}) [35->65] (level:0) is #f with stack state #f #({basic-block #() 65 65}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [65->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) #() [65->70] (level:0) is #f with stack state #f #() rts +++ ending code for xep_7 +++ +++ No Source Code Locators for xep_7 +++ +++ Exported function definition xep_8 +++ +++ starting code for xep_8 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65}) bne {tag 1:35}, r0, 8 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move r23, {constant "KPfalseVKi"} move r0, 32 move r0, r0 #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:35}) [35->65] (level:0) is #f with stack state #f #({basic-block #() 65 65}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [65->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) #() [65->70] (level:0) is #f with stack state #f #() rts +++ ending code for xep_8 +++ +++ No Source Code Locators for xep_8 +++ +++ Exported function definition xep_9 +++ +++ starting code for xep_9 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 25}, {basic-block #({tag 1:35}) 35 65}) bne {tag 1:35}, r0, 9 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move r23, {constant "KPfalseVKi"} move r0, 36 move r0, r0 #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:35}) [35->65] (level:0) is #f with stack state #f #({basic-block #() 65 65}) preserve-registers-entry asl N0/r4, r0, 2 add N0/r4, N0/r4, 1 move r3, r22 move r4, N0/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [65->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) #() [65->70] (level:0) is #f with stack state #f #() rts +++ ending code for xep_9 +++ +++ No Source Code Locators for xep_9 +++ +++ Exported function definition xep +++ +++ starting code for xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 55}, {basic-block #({tag 1:65}) 65 95}) ld N0/r23, r22, 8 ld N0/r23, N0/r23, 4 asr N0/r23, N0/r23, 2 and N0/r23, N0/r23, 255 bne {tag 1:65}, r0, N0/r23 #() [30->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) move r23, {constant "KPfalseVKi"} ld N1/r21, r22, 8 ld N1/r21, N1/r21, 4 and N1/r21, N1/r21, 1020 move r0, N1/r21 #() [55->60] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:65}) [65->95] (level:0) is #f with stack state #f #({basic-block #() 95 95}) preserve-registers-entry asl N2/r4, r0, 2 add N2/r4, N2/r4, 1 move r3, r22 move r4, N2/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [95->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) #() [95->100] (level:0) is #f with stack state #f #() rts +++ ending code for xep +++ +++ No Source Code Locators for xep +++ +++ Exported function definition rest_xep_0 +++ +++ starting code for rest_xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 5:25}) 25 50}) bgt {tag 5:25}, r0, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 6:50}) 50 70}) bgt {tag 6:50}, r0, 2 #() [15->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}, {basic-block #({tag 7:70}) 70 85}) bgt {tag 7:70}, r0, 1 #() [20->25] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 155}, {basic-block #({tag 8:85}) 85 95}) bgt {tag 8:85}, r0, 0 #({tag 9:95}) [95->155] (level:0) is #f with stack state #f #({basic-block #() 155 160}) move N2/r3, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, 1 st r0, N2/r3, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r3, -8 add N1/r23, N1/r23, 12 st N1/r23, N2/r3, -12 add N3/r3, N2/r3, -8 move r3, N3/r3 move r23, {constant "KPfalseVKi"} #() [155->160] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 5:25}) [25->50] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 155}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 st r3, r1, -16 sub r1, r1, 16 #() [225->230] (level:0) is #f with stack state #f #() bra {tag 9:95} #({tag 6:50}) [50->70] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 155}) st r5, r1, -4 st r4, r1, -8 st r3, r1, -12 sub r1, r1, 12 #() [230->235] (level:0) is #f with stack state #f #() bra {tag 9:95} #({tag 7:70}) [70->85] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 155}) st r4, r1, -4 st r3, r1, -8 sub r1, r1, 8 #() [235->240] (level:0) is #f with stack state #f #() bra {tag 9:95} #({tag 8:85}) [85->95] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 155}) st r3, r1, -4 sub r1, r1, 4 #() [240->245] (level:0) is #f with stack state #f #() bra {tag 9:95} +++ ending code for rest_xep_0 +++ +++ No Source Code Locators for rest_xep_0 +++ +++ Exported function definition rest_xep_1 +++ +++ starting code for rest_xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:290}) 290 320}) blo {tag 1:290}, r0, 1 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 5:25}) 25 45}) bgt {tag 5:25}, r0, 3 #() [15->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}, {basic-block #({tag 6:45}) 45 60}) bgt {tag 6:45}, r0, 2 #() [20->25] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}, {basic-block #({tag 7:60}) 60 70}) bgt {tag 7:60}, r0, 1 #({tag 8:70}) [70->150] (level:0) is #f with stack state #f #({basic-block #() 150 215}, {basic-block #({tag 9:285}) 285 285}) move N2/r4, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, -3 st r0, N2/r4, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r4, -8 add N1/r23, N1/r23, 8 st N1/r23, N2/r4, -12 add N3/r4, N2/r4, -8 move r4, N3/r4 move r23, {constant "KPfalseVKi"} ld G5/r21, r22, 8 ld G5/r21, G5/r21, 8 ld N6/r20, G5/r21, 8 beq {tag 9:285}, N6/r20, {constant "KLobjectGVKd"} #() [150->215] (level:0) is #f with stack state #f #({basic-block #() 215 220}, {basic-block #({tag 11:220}) 220 240}) move G4/r19, r3 preserve-registers-entry push G5/r21 push G4/r19 push N6/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G8/r4, N6/r20 bne {tag 11:220}, G8/r4, {constant "KLobjectGVKd"} #() [215->220] (level:0) is #f with stack state #f #({basic-block #({tag 10:240}) 240 245}) move r3, {constant "KPtrueVKi"} #({tag 10:240}) [240->245] (level:0) is #f with stack state #f #({basic-block #() 245 285}, {basic-block #({tag 3:325}, {tag 2:325}) 325 350}) beq {tag 3:325}, r3, {constant "KPfalseVKi"} #() [245->285] (level:0) is #f with stack state #f #({basic-block #({tag 9:285}) 285 285}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 9:285}) [285->285] (level:0) is #f with stack state #f #({basic-block #({tag 9:285}) 285 290}) #({tag 9:285}) [285->290] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:290}) [290->320] (level:0) is #f with stack state #f #({basic-block #() 320 320}) preserve-registers-entry asl N9/r4, r0, 2 add N9/r4, N9/r4, 1 move r3, r22 move r4, N9/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [320->320] (level:0) is #f with stack state #f #({basic-block #() 320 325}) #() [320->325] (level:0) is #f with stack state #f #() rts #({tag 5:25}) [25->45] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 sub r1, r1, 12 #() [355->360] (level:0) is #f with stack state #f #() bra {tag 8:70} #({tag 6:45}) [45->60] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}) st r5, r1, -4 st r4, r1, -8 sub r1, r1, 8 #() [360->365] (level:0) is #f with stack state #f #() bra {tag 8:70} #({tag 7:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}) st r4, r1, -4 sub r1, r1, 4 #() [365->370] (level:0) is #f with stack state #f #() bra {tag 8:70} #({tag 11:220}) [220->240] (level:0) is #f with stack state #f #({basic-block #({tag 10:240}) 240 245}) ld N7/r23, G8/r4, 4 move r3, G4/r19 move r4, G8/r4 call N7/r23, 2 #() [370->375] (level:0) is #f with stack state #f #() bra {tag 10:240} #({tag 3:325}, {tag 2:325}) [325->350] (level:0) is #f with stack state #f #({basic-block #() 350 350}) load-frame-offset #t, G11/r4, -3 load-frame-offset #t, G10/r3, -2 move r3, G10/r3 move r4, G11/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [350->350] (level:0) is #f with stack state #f #({basic-block #() 350 355}) #() [350->355] (level:0) is #f with stack state #f #() rts +++ ending code for rest_xep_1 +++ +++ Live variable scopes for rest_xep_1 +++ Start scope at 82 with frame for no variables End scope at 145 Start scope at 146 no frame for no variables End scope at 167 +++ No Source Code Locators for rest_xep_1 +++ +++ Exported function definition rest_xep_2 +++ +++ starting code for rest_xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:420}) 420 450}) blo {tag 1:420}, r0, 2 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 5:20}) 20 35}) bgt {tag 5:20}, r0, 3 #() [15->20] (level:0) is #f with stack state #f #({basic-block #({tag 7:45}) 45 125}, {basic-block #({tag 6:35}) 35 45}) bgt {tag 6:35}, r0, 2 #({tag 7:45}) [45->125] (level:0) is #f with stack state #f #({basic-block #() 125 190}, {basic-block #({tag 8:260}) 260 280}) move N2/r5, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, -7 st r0, N2/r5, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r5, -8 add N1/r23, N1/r23, 4 st N1/r23, N2/r5, -12 add N3/r5, N2/r5, -8 move r5, N3/r5 move r23, {constant "KPfalseVKi"} ld G5/r21, r22, 8 ld G5/r21, G5/r21, 8 ld N6/r20, G5/r21, 8 beq {tag 8:260}, N6/r20, {constant "KLobjectGVKd"} #() [125->190] (level:0) is #f with stack state #f #({basic-block #() 190 195}, {basic-block #({tag 10:195}) 195 215}) move G4/r19, r3 preserve-registers-entry push G5/r21 push G4/r19 push N6/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G8/r4, N6/r20 bne {tag 10:195}, G8/r4, {constant "KLobjectGVKd"} #() [190->195] (level:0) is #f with stack state #f #({basic-block #({tag 9:215}) 215 220}) move r3, {constant "KPtrueVKi"} #({tag 9:215}) [215->220] (level:0) is #f with stack state #f #({basic-block #() 220 260}, {basic-block #({tag 3:455}, {tag 2:455}) 455 480}) beq {tag 3:455}, r3, {constant "KPfalseVKi"} #() [220->260] (level:0) is #f with stack state #f #({basic-block #({tag 8:260}) 260 280}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 8:260}) [260->280] (level:0) is #f with stack state #f #({basic-block #() 280 345}, {basic-block #({tag 11:415}) 415 415}) ld G10/r21, r22, 8 ld G10/r21, G10/r21, 8 ld N11/r20, G10/r21, 12 beq {tag 11:415}, N11/r20, {constant "KLobjectGVKd"} #() [280->345] (level:0) is #f with stack state #f #({basic-block #() 345 350}, {basic-block #({tag 13:350}) 350 370}) move G9/r19, r4 preserve-registers-entry push G10/r21 push G9/r19 push N11/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G13/r4, N11/r20 bne {tag 13:350}, G13/r4, {constant "KLobjectGVKd"} #() [345->350] (level:0) is #f with stack state #f #({basic-block #({tag 12:370}) 370 375}) move r3, {constant "KPtrueVKi"} #({tag 12:370}) [370->375] (level:0) is #f with stack state #f #({basic-block #() 375 415}, {basic-block #({tag 3:455}, {tag 2:455}) 455 480}) beq {tag 3:455}, r3, {constant "KPfalseVKi"} #() [375->415] (level:0) is #f with stack state #f #({basic-block #({tag 11:415}) 415 415}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 11:415}) [415->415] (level:0) is #f with stack state #f #({basic-block #({tag 11:415}) 415 420}) #({tag 11:415}) [415->420] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:420}) [420->450] (level:0) is #f with stack state #f #({basic-block #() 450 450}) preserve-registers-entry asl N14/r4, r0, 2 add N14/r4, N14/r4, 1 move r3, r22 move r4, N14/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [450->450] (level:0) is #f with stack state #f #({basic-block #() 450 455}) #() [450->455] (level:0) is #f with stack state #f #() rts #({tag 5:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #({tag 7:45}) 45 125}) st r6, r1, -4 st r5, r1, -8 sub r1, r1, 8 #() [485->490] (level:0) is #f with stack state #f #() bra {tag 7:45} #({tag 6:35}) [35->45] (level:0) is #f with stack state #f #({basic-block #({tag 7:45}) 45 125}) st r5, r1, -4 sub r1, r1, 4 #() [490->495] (level:0) is #f with stack state #f #() bra {tag 7:45} #({tag 10:195}) [195->215] (level:0) is #f with stack state #f #({basic-block #({tag 9:215}) 215 220}) ld N7/r23, G8/r4, 4 move r3, G4/r19 move r4, G8/r4 call N7/r23, 2 #() [495->500] (level:0) is #f with stack state #f #() bra {tag 9:215} #({tag 3:455}, {tag 2:455}) [455->480] (level:0) is #f with stack state #f #({basic-block #() 480 480}) load-frame-offset #t, G16/r4, -3 load-frame-offset #t, G15/r3, -2 move r3, G15/r3 move r4, G16/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [480->480] (level:0) is #f with stack state #f #({basic-block #() 480 485}) #() [480->485] (level:0) is #f with stack state #f #() rts #({tag 13:350}) [350->370] (level:0) is #f with stack state #f #({basic-block #({tag 12:370}) 370 375}) ld N12/r23, G13/r4, 4 move r3, G9/r19 move r4, G13/r4 call N12/r23, 2 #() [500->505] (level:0) is #f with stack state #f #() bra {tag 12:370} +++ ending code for rest_xep_2 +++ +++ Live variable scopes for rest_xep_2 +++ Start scope at 76 with frame for no variables End scope at 139 Start scope at 140 no frame for no variables End scope at 171 Start scope at 172 with frame for no variables End scope at 235 Start scope at 236 no frame for no variables End scope at 257 +++ No Source Code Locators for rest_xep_2 +++ +++ Exported function definition rest_xep_3 +++ +++ starting code for rest_xep_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:555}) 555 585}) blo {tag 1:555}, r0, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 105}, {basic-block #({tag 5:15}) 15 25}) bgt {tag 5:15}, r0, 3 #({tag 6:25}) [25->105] (level:0) is #f with stack state #f #({basic-block #() 105 170}, {basic-block #({tag 7:240}) 240 260}) move N2/r6, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, -11 st r0, N2/r6, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r6, -8 add N1/r23, N1/r23, 0 st N1/r23, N2/r6, -12 add N3/r6, N2/r6, -8 move r6, N3/r6 move r23, {constant "KPfalseVKi"} ld G5/r21, r22, 8 ld G5/r21, G5/r21, 8 ld N6/r20, G5/r21, 8 beq {tag 7:240}, N6/r20, {constant "KLobjectGVKd"} #() [105->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}, {basic-block #({tag 9:175}) 175 195}) move G4/r19, r3 preserve-registers-entry push G5/r21 push G4/r19 push N6/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G8/r4, N6/r20 bne {tag 9:175}, G8/r4, {constant "KLobjectGVKd"} #() [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 8:195}) 195 200}) move r3, {constant "KPtrueVKi"} #({tag 8:195}) [195->200] (level:0) is #f with stack state #f #({basic-block #() 200 240}, {basic-block #({tag 3:590}, {tag 2:590}) 590 615}) beq {tag 3:590}, r3, {constant "KPfalseVKi"} #() [200->240] (level:0) is #f with stack state #f #({basic-block #({tag 7:240}) 240 260}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 7:240}) [240->260] (level:0) is #f with stack state #f #({basic-block #() 260 325}, {basic-block #({tag 10:395}) 395 415}) ld G10/r21, r22, 8 ld G10/r21, G10/r21, 8 ld N11/r20, G10/r21, 12 beq {tag 10:395}, N11/r20, {constant "KLobjectGVKd"} #() [260->325] (level:0) is #f with stack state #f #({basic-block #() 325 330}, {basic-block #({tag 12:330}) 330 350}) move G9/r19, r4 preserve-registers-entry push G10/r21 push G9/r19 push N11/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G13/r4, N11/r20 bne {tag 12:330}, G13/r4, {constant "KLobjectGVKd"} #() [325->330] (level:0) is #f with stack state #f #({basic-block #({tag 11:350}) 350 355}) move r3, {constant "KPtrueVKi"} #({tag 11:350}) [350->355] (level:0) is #f with stack state #f #({basic-block #() 355 395}, {basic-block #({tag 3:590}, {tag 2:590}) 590 615}) beq {tag 3:590}, r3, {constant "KPfalseVKi"} #() [355->395] (level:0) is #f with stack state #f #({basic-block #({tag 10:395}) 395 415}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 10:395}) [395->415] (level:0) is #f with stack state #f #({basic-block #() 415 480}, {basic-block #({tag 13:550}) 550 550}) ld G15/r21, r22, 8 ld G15/r21, G15/r21, 8 ld N16/r20, G15/r21, 16 beq {tag 13:550}, N16/r20, {constant "KLobjectGVKd"} #() [415->480] (level:0) is #f with stack state #f #({basic-block #() 480 485}, {basic-block #({tag 15:485}) 485 505}) move G14/r19, r5 preserve-registers-entry push G15/r21 push G14/r19 push N16/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G18/r4, N16/r20 bne {tag 15:485}, G18/r4, {constant "KLobjectGVKd"} #() [480->485] (level:0) is #f with stack state #f #({basic-block #({tag 14:505}) 505 510}) move r3, {constant "KPtrueVKi"} #({tag 14:505}) [505->510] (level:0) is #f with stack state #f #({basic-block #() 510 550}, {basic-block #({tag 3:590}, {tag 2:590}) 590 615}) beq {tag 3:590}, r3, {constant "KPfalseVKi"} #() [510->550] (level:0) is #f with stack state #f #({basic-block #({tag 13:550}) 550 550}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 13:550}) [550->550] (level:0) is #f with stack state #f #({basic-block #({tag 13:550}) 550 555}) #({tag 13:550}) [550->555] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:555}) [555->585] (level:0) is #f with stack state #f #({basic-block #() 585 585}) preserve-registers-entry asl N19/r4, r0, 2 add N19/r4, N19/r4, 1 move r3, r22 move r4, N19/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [585->585] (level:0) is #f with stack state #f #({basic-block #() 585 590}) #() [585->590] (level:0) is #f with stack state #f #() rts #({tag 5:15}) [15->25] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 105}) st r6, r1, -4 sub r1, r1, 4 #() [620->625] (level:0) is #f with stack state #f #() bra {tag 6:25} #({tag 9:175}) [175->195] (level:0) is #f with stack state #f #({basic-block #({tag 8:195}) 195 200}) ld N7/r23, G8/r4, 4 move r3, G4/r19 move r4, G8/r4 call N7/r23, 2 #() [625->630] (level:0) is #f with stack state #f #() bra {tag 8:195} #({tag 3:590}, {tag 2:590}) [590->615] (level:0) is #f with stack state #f #({basic-block #() 615 615}) load-frame-offset #t, G21/r4, -3 load-frame-offset #t, G20/r3, -2 move r3, G20/r3 move r4, G21/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [615->615] (level:0) is #f with stack state #f #({basic-block #() 615 620}) #() [615->620] (level:0) is #f with stack state #f #() rts #({tag 12:330}) [330->350] (level:0) is #f with stack state #f #({basic-block #({tag 11:350}) 350 355}) ld N12/r23, G13/r4, 4 move r3, G9/r19 move r4, G13/r4 call N12/r23, 2 #() [630->635] (level:0) is #f with stack state #f #() bra {tag 11:350} #({tag 15:485}) [485->505] (level:0) is #f with stack state #f #({basic-block #({tag 14:505}) 505 510}) ld N17/r23, G18/r4, 4 move r3, G14/r19 move r4, G18/r4 call N17/r23, 2 #() [635->640] (level:0) is #f with stack state #f #() bra {tag 14:505} +++ ending code for rest_xep_3 +++ +++ Live variable scopes for rest_xep_3 +++ Start scope at 68 with frame for no variables End scope at 131 Start scope at 132 no frame for no variables End scope at 163 Start scope at 164 with frame for no variables End scope at 227 Start scope at 228 no frame for no variables End scope at 259 Start scope at 260 with frame for no variables End scope at 323 Start scope at 324 no frame for no variables End scope at 345 +++ No Source Code Locators for rest_xep_3 +++ +++ Exported function definition rest_xep_4 +++ +++ starting code for rest_xep_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 100}, {basic-block #({tag 1:705}) 705 735}) blo {tag 1:705}, r0, 4 #() [10->100] (level:0) is #f with stack state #f #({basic-block #() 100 165}, {basic-block #({tag 4:235}) 235 255}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 add N0/r21, N4/r21, 0 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -15 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move r23, {constant "KPfalseVKi"} ld G7/r21, r22, 8 ld G7/r21, G7/r21, 8 ld N8/r20, G7/r21, 8 beq {tag 4:235}, N8/r20, {constant "KLobjectGVKd"} #() [100->165] (level:0) is #f with stack state #f #({basic-block #() 165 170}, {basic-block #({tag 6:170}) 170 190}) move G6/r19, r3 preserve-registers-entry push G7/r21 push G6/r19 push N8/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G10/r4, N8/r20 bne {tag 6:170}, G10/r4, {constant "KLobjectGVKd"} #() [165->170] (level:0) is #f with stack state #f #({basic-block #({tag 5:190}) 190 195}) move r3, {constant "KPtrueVKi"} #({tag 5:190}) [190->195] (level:0) is #f with stack state #f #({basic-block #() 195 235}, {basic-block #({tag 3:740}, {tag 2:740}) 740 765}) beq {tag 3:740}, r3, {constant "KPfalseVKi"} #() [195->235] (level:0) is #f with stack state #f #({basic-block #({tag 4:235}) 235 255}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 4:235}) [235->255] (level:0) is #f with stack state #f #({basic-block #() 255 320}, {basic-block #({tag 7:390}) 390 410}) ld G12/r21, r22, 8 ld G12/r21, G12/r21, 8 ld N13/r20, G12/r21, 12 beq {tag 7:390}, N13/r20, {constant "KLobjectGVKd"} #() [255->320] (level:0) is #f with stack state #f #({basic-block #() 320 325}, {basic-block #({tag 9:325}) 325 345}) move G11/r19, r4 preserve-registers-entry push G12/r21 push G11/r19 push N13/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G15/r4, N13/r20 bne {tag 9:325}, G15/r4, {constant "KLobjectGVKd"} #() [320->325] (level:0) is #f with stack state #f #({basic-block #({tag 8:345}) 345 350}) move r3, {constant "KPtrueVKi"} #({tag 8:345}) [345->350] (level:0) is #f with stack state #f #({basic-block #() 350 390}, {basic-block #({tag 3:740}, {tag 2:740}) 740 765}) beq {tag 3:740}, r3, {constant "KPfalseVKi"} #() [350->390] (level:0) is #f with stack state #f #({basic-block #({tag 7:390}) 390 410}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 7:390}) [390->410] (level:0) is #f with stack state #f #({basic-block #() 410 475}, {basic-block #({tag 10:545}) 545 565}) ld G17/r21, r22, 8 ld G17/r21, G17/r21, 8 ld N18/r20, G17/r21, 16 beq {tag 10:545}, N18/r20, {constant "KLobjectGVKd"} #() [410->475] (level:0) is #f with stack state #f #({basic-block #() 475 480}, {basic-block #({tag 12:480}) 480 500}) move G16/r19, r5 preserve-registers-entry push G17/r21 push G16/r19 push N18/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G20/r4, N18/r20 bne {tag 12:480}, G20/r4, {constant "KLobjectGVKd"} #() [475->480] (level:0) is #f with stack state #f #({basic-block #({tag 11:500}) 500 505}) move r3, {constant "KPtrueVKi"} #({tag 11:500}) [500->505] (level:0) is #f with stack state #f #({basic-block #() 505 545}, {basic-block #({tag 3:740}, {tag 2:740}) 740 765}) beq {tag 3:740}, r3, {constant "KPfalseVKi"} #() [505->545] (level:0) is #f with stack state #f #({basic-block #({tag 10:545}) 545 565}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 10:545}) [545->565] (level:0) is #f with stack state #f #({basic-block #() 565 630}, {basic-block #({tag 13:700}) 700 700}) ld G22/r21, r22, 8 ld G22/r21, G22/r21, 8 ld N23/r20, G22/r21, 20 beq {tag 13:700}, N23/r20, {constant "KLobjectGVKd"} #() [565->630] (level:0) is #f with stack state #f #({basic-block #() 630 635}, {basic-block #({tag 15:635}) 635 655}) move G21/r19, r6 preserve-registers-entry push G22/r21 push G21/r19 push N23/r20 push r3 push r4 push r5 push r6 push r22 push r23 move G25/r4, N23/r20 bne {tag 15:635}, G25/r4, {constant "KLobjectGVKd"} #() [630->635] (level:0) is #f with stack state #f #({basic-block #({tag 14:655}) 655 660}) move r3, {constant "KPtrueVKi"} #({tag 14:655}) [655->660] (level:0) is #f with stack state #f #({basic-block #() 660 700}, {basic-block #({tag 3:740}, {tag 2:740}) 740 765}) beq {tag 3:740}, r3, {constant "KPfalseVKi"} #() [660->700] (level:0) is #f with stack state #f #({basic-block #({tag 13:700}) 700 700}) pop r23 pop r22 pop r6 pop r5 pop r4 pop r3 rem "eliminated" preserve-registers-exit #({tag 13:700}) [700->700] (level:0) is #f with stack state #f #({basic-block #({tag 13:700}) 700 705}) #({tag 13:700}) [700->705] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:705}) [705->735] (level:0) is #f with stack state #f #({basic-block #() 735 735}) preserve-registers-entry asl N26/r4, r0, 2 add N26/r4, N26/r4, 1 move r3, r22 move r4, N26/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [735->735] (level:0) is #f with stack state #f #({basic-block #() 735 740}) #() [735->740] (level:0) is #f with stack state #f #() rts #({tag 6:170}) [170->190] (level:0) is #f with stack state #f #({basic-block #({tag 5:190}) 190 195}) ld N9/r23, G10/r4, 4 move r3, G6/r19 move r4, G10/r4 call N9/r23, 2 #() [770->775] (level:0) is #f with stack state #f #() bra {tag 5:190} #({tag 3:740}, {tag 2:740}) [740->765] (level:0) is #f with stack state #f #({basic-block #() 765 765}) load-frame-offset #t, G28/r4, -3 load-frame-offset #t, G27/r3, -2 move r3, G27/r3 move r4, G28/r4 call {constant "Ktype_check_errorVKiI"}, 2 #() [765->765] (level:0) is #f with stack state #f #({basic-block #() 765 770}) #() [765->770] (level:0) is #f with stack state #f #() rts #({tag 9:325}) [325->345] (level:0) is #f with stack state #f #({basic-block #({tag 8:345}) 345 350}) ld N14/r23, G15/r4, 4 move r3, G11/r19 move r4, G15/r4 call N14/r23, 2 #() [775->780] (level:0) is #f with stack state #f #() bra {tag 8:345} #({tag 12:480}) [480->500] (level:0) is #f with stack state #f #({basic-block #({tag 11:500}) 500 505}) ld N19/r23, G20/r4, 4 move r3, G16/r19 move r4, G20/r4 call N19/r23, 2 #() [780->785] (level:0) is #f with stack state #f #() bra {tag 11:500} #({tag 15:635}) [635->655] (level:0) is #f with stack state #f #({basic-block #({tag 14:655}) 655 660}) ld N24/r23, G25/r4, 4 move r3, G21/r19 move r4, G25/r4 call N24/r23, 2 #() [785->790] (level:0) is #f with stack state #f #() bra {tag 14:655} +++ ending code for rest_xep_4 +++ +++ Live variable scopes for rest_xep_4 +++ Start scope at 66 with frame for no variables End scope at 129 Start scope at 130 no frame for no variables End scope at 161 Start scope at 162 with frame for no variables End scope at 225 Start scope at 226 no frame for no variables End scope at 257 Start scope at 258 with frame for no variables End scope at 321 Start scope at 322 no frame for no variables End scope at 353 Start scope at 354 with frame for no variables End scope at 417 Start scope at 418 no frame for no variables End scope at 439 +++ No Source Code Locators for rest_xep_4 +++ +++ Exported function definition rest_xep_5 +++ +++ starting code for rest_xep_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 100}, {basic-block #({tag 1:110}) 110 140}) blo {tag 1:110}, r0, 5 #() [10->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 ld N2/r20, N4/r21, 0 st N2/r20, r1, 0 add N0/r21, N4/r21, 4 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -19 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move r23, {constant "KPfalseVKi"} move r0, 20 move r0, r0 #() [100->105] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:110}) [110->140] (level:0) is #f with stack state #f #({basic-block #() 140 140}) preserve-registers-entry asl N6/r4, r0, 2 add N6/r4, N6/r4, 1 move r3, r22 move r4, N6/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [140->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) #() [140->145] (level:0) is #f with stack state #f #() rts +++ ending code for rest_xep_5 +++ +++ No Source Code Locators for rest_xep_5 +++ +++ Exported function definition rest_xep_6 +++ +++ starting code for rest_xep_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 110}, {basic-block #({tag 1:120}) 120 150}) blo {tag 1:120}, r0, 6 #() [10->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 ld N2/r19, N4/r21, 0 ld N3/r20, N4/r21, 4 st N2/r19, r1, 0 st N3/r20, r1, 4 add N0/r21, N4/r21, 8 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -23 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move r23, {constant "KPfalseVKi"} move r0, 24 move r0, r0 #() [110->115] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:120}) [120->150] (level:0) is #f with stack state #f #({basic-block #() 150 150}) preserve-registers-entry asl N6/r4, r0, 2 add N6/r4, N6/r4, 1 move r3, r22 move r4, N6/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [150->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) #() [150->155] (level:0) is #f with stack state #f #() rts +++ ending code for rest_xep_6 +++ +++ No Source Code Locators for rest_xep_6 +++ +++ Exported function definition rest_xep_7 +++ +++ starting code for rest_xep_7 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 120}, {basic-block #({tag 1:130}) 130 160}) blo {tag 1:130}, r0, 7 #() [10->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 ld N2/r20, N4/r21, 0 ld N3/r19, N4/r21, 4 st N2/r20, r1, 0 st N3/r19, r1, 4 ld N2/r20, N4/r21, 8 st N2/r20, r1, 8 add N0/r21, N4/r21, 12 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -27 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move r23, {constant "KPfalseVKi"} move r0, 28 move r0, r0 #() [120->125] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:130}) [130->160] (level:0) is #f with stack state #f #({basic-block #() 160 160}) preserve-registers-entry asl N6/r4, r0, 2 add N6/r4, N6/r4, 1 move r3, r22 move r4, N6/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [160->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) #() [160->165] (level:0) is #f with stack state #f #() rts +++ ending code for rest_xep_7 +++ +++ No Source Code Locators for rest_xep_7 +++ +++ Exported function definition rest_xep_8 +++ +++ starting code for rest_xep_8 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 130}, {basic-block #({tag 1:140}) 140 170}) blo {tag 1:140}, r0, 8 #() [10->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 ld N2/r19, N4/r21, 0 ld N3/r20, N4/r21, 4 st N2/r19, r1, 0 st N3/r20, r1, 4 ld N2/r19, N4/r21, 8 ld N3/r20, N4/r21, 12 st N2/r19, r1, 8 st N3/r20, r1, 12 add N0/r21, N4/r21, 16 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -31 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move r23, {constant "KPfalseVKi"} move r0, 32 move r0, r0 #() [130->135] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:140}) [140->170] (level:0) is #f with stack state #f #({basic-block #() 170 170}) preserve-registers-entry asl N6/r4, r0, 2 add N6/r4, N6/r4, 1 move r3, r22 move r4, N6/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [170->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}) #() [170->175] (level:0) is #f with stack state #f #() rts +++ ending code for rest_xep_8 +++ +++ No Source Code Locators for rest_xep_8 +++ +++ Exported function definition rest_xep_9 +++ +++ starting code for rest_xep_9 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 140}, {basic-block #({tag 1:150}) 150 180}) blo {tag 1:150}, r0, 9 #() [10->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) sub r1, r1, 16 add N4/r23, r1, 16 move N1/r21, r0 ld N2/r20, N4/r23, 0 ld N3/r19, N4/r23, 4 st N2/r20, r1, 0 st N3/r19, r1, 4 ld N2/r20, N4/r23, 8 ld N3/r19, N4/r23, 12 st N2/r20, r1, 8 st N3/r19, r1, 12 ld N2/r20, N4/r23, 16 st N2/r20, r1, 16 add N0/r23, N4/r23, 20 asl N1/r21, N1/r21, 2 move r0, N1/r21 add N1/r21, N1/r21, -35 st N1/r21, N0/r23, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r23, -8 add r0, r0, 0 st r0, N0/r23, -12 add N5/r21, N0/r23, -8 st N5/r21, N0/r23, -16 move r23, {constant "KPfalseVKi"} move r0, 36 move r0, r0 #() [140->145] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:150}) [150->180] (level:0) is #f with stack state #f #({basic-block #() 180 180}) preserve-registers-entry asl N6/r4, r0, 2 add N6/r4, N6/r4, 1 move r3, r22 move r4, N6/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [180->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) #() [180->185] (level:0) is #f with stack state #f #() rts +++ ending code for rest_xep_9 +++ +++ No Source Code Locators for rest_xep_9 +++ +++ Exported function definition rest_xep +++ +++ starting code for rest_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 180}, {basic-block #({tag 1:190}) 190 220}) ld N0/r23, r22, 8 ld N0/r23, N0/r23, 4 asr N0/r23, N0/r23, 2 and N0/r23, N0/r23, 255 blo {tag 1:190}, r0, N0/r23 #() [30->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N3/r23, r22, 8 ld N3/r23, N3/r23, 4 asr N3/r23, N3/r23, 2 and N3/r23, N3/r23, 255 add N3/r23, N3/r23, -4 move N4/r20, r1 sub r1, r1, 16 move N2/r21, r0 move r0, N3/r23 move N5/r23, r1 copy-words-down-w N5/r23, N4/r20, r0 add N1/r23, r9, 4 asl N2/r21, N2/r21, 2 move r0, N2/r21 ld r7, r22, 8 ld r7, r7, 4 and r7, r7, 1020 sub N2/r21, N2/r21, r7 add N2/r21, N2/r21, 1 st N2/r21, N1/r23, -4 st {constant "KLsimple_object_vectorGVKdW"}, N1/r23, -8 add r0, r0, 0 st r0, N1/r23, -12 add N6/r21, N1/r23, -8 st N6/r21, N1/r23, -16 move r23, {constant "KPfalseVKi"} ld N7/r21, r22, 8 ld N7/r21, N7/r21, 4 and N7/r21, N7/r21, 1020 move r0, N7/r21 #() [180->185] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[4, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:190}) [190->220] (level:0) is #f with stack state #f #({basic-block #() 220 220}) preserve-registers-entry asl N8/r4, r0, 2 add N8/r4, N8/r4, 1 move r3, r22 move r4, N8/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [220->220] (level:0) is #f with stack state #f #({basic-block #() 220 225}) #() [220->225] (level:0) is #f with stack state #f #() rts +++ ending code for rest_xep +++ +++ No Source Code Locators for rest_xep +++ +++ Exported function definition rest_key_xep_0 +++ +++ starting code for rest_key_xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 4:35}) 35 40}) ld N2/r23, r22, 20 ld N0/r23, N2/r23, 4 asr N0/r23, N0/r23, 3 sub N0/r23, N0/r23, 3 bge {tag 4:35}, N0/r23, 0 #() [30->35] (level:0) is #f with stack state #f #({basic-block #({tag 4:35}) 35 40}) move N0/r23, 0 #({tag 4:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 6:55}) 55 80}) bgt {tag 6:55}, r0, 3 #() [40->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 7:80}) 80 100}) bgt {tag 7:80}, r0, 2 #() [45->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 8:100}) 100 115}) bgt {tag 8:100}, r0, 1 #() [50->55] (level:0) is #f with stack state #f #({basic-block #({tag 10:125}) 125 225}, {basic-block #({tag 9:115}) 115 125}) bgt {tag 9:115}, r0, 0 #({tag 10:125}) [125->225] (level:0) is #f with stack state #f #({basic-block #() 225 230}) add N6/r20, N0/r23, 3 asl N6/r20, N6/r20, 2 move N5/r21, r1 sub r1, r1, N6/r20 asl r0, r0, 2 move N4/r20, r0 add r0, r0, 1 st r0, N5/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N5/r21, -8 add N7/r23, N0/r23, 3 asl N7/r23, N7/r23, 2 add N4/r20, N4/r20, N7/r23 st N4/r20, N5/r21, -12 add N8/r21, N5/r21, -8 move r3, N8/r21 sub N1/r23, N8/r21, 8 move r0, N1/r23 push N8/r21 move r23, {constant "KPfalseVKi"} move r22, r22 #() [225->230] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_for_xep_2"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 6:55}) [55->80] (level:0) is #f with stack state #f #({basic-block #({tag 10:125}) 125 225}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 st r3, r1, -16 sub r1, r1, 16 #() [305->310] (level:0) is #f with stack state #f #() bra {tag 10:125} #({tag 7:80}) [80->100] (level:0) is #f with stack state #f #({basic-block #({tag 10:125}) 125 225}) st r5, r1, -4 st r4, r1, -8 st r3, r1, -12 sub r1, r1, 12 #() [310->315] (level:0) is #f with stack state #f #() bra {tag 10:125} #({tag 8:100}) [100->115] (level:0) is #f with stack state #f #({basic-block #({tag 10:125}) 125 225}) st r4, r1, -4 st r3, r1, -8 sub r1, r1, 8 #() [315->320] (level:0) is #f with stack state #f #() bra {tag 10:125} #({tag 9:115}) [115->125] (level:0) is #f with stack state #f #({basic-block #({tag 10:125}) 125 225}) st r3, r1, -4 sub r1, r1, 4 #() [320->325] (level:0) is #f with stack state #f #() bra {tag 10:125} +++ ending code for rest_key_xep_0 +++ +++ No Source Code Locators for rest_key_xep_0 +++ +++ Exported function definition rest_key_xep_1 +++ +++ starting code for rest_key_xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:375}) 375 405}) blo {tag 1:375}, r0, 1 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 4:40}) 40 45}) ld N2/r23, r22, 20 ld N0/r23, N2/r23, 4 asr N0/r23, N0/r23, 3 sub N0/r23, N0/r23, 2 bge {tag 4:40}, N0/r23, 0 #() [35->40] (level:0) is #f with stack state #f #({basic-block #({tag 4:40}) 40 45}) move N0/r23, 0 #({tag 4:40}) [40->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 6:55}) 55 75}) bgt {tag 6:55}, r0, 3 #() [45->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 7:75}) 75 90}) bgt {tag 7:75}, r0, 2 #() [50->55] (level:0) is #f with stack state #f #({basic-block #({tag 9:100}) 100 205}, {basic-block #({tag 8:90}) 90 100}) bgt {tag 8:90}, r0, 1 #({tag 9:100}) [100->205] (level:0) is #f with stack state #f #({basic-block #() 205 210}) add N6/r21, N0/r23, 3 asl N6/r21, N6/r21, 2 move N5/r20, r1 sub r1, r1, N6/r21 asl r0, r0, 2 move N4/r21, r0 add r0, r0, -3 st r0, N5/r20, -4 st {constant "KLsimple_object_vectorGVKdW"}, N5/r20, -8 add N7/r23, N0/r23, 3 asl N7/r23, N7/r23, 2 add N4/r21, N4/r21, N7/r23 sub N4/r21, N4/r21, 4 st N4/r21, N5/r20, -12 add N8/r20, N5/r20, -8 move r4, N8/r20 sub N1/r23, N8/r20, 8 move r0, N1/r23 push N8/r20 move r23, {constant "KPfalseVKi"} move r22, r22 #() [205->210] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep_1"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:375}) [375->405] (level:0) is #f with stack state #f #({basic-block #() 405 405}) preserve-registers-entry asl N15/r4, r0, 2 add N15/r4, N15/r4, 1 move r3, r22 move r4, N15/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [405->405] (level:0) is #f with stack state #f #({basic-block #() 405 410}) #() [405->410] (level:0) is #f with stack state #f #() rts #({tag 6:55}) [55->75] (level:0) is #f with stack state #f #({basic-block #({tag 9:100}) 100 205}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 sub r1, r1, 12 #() [440->445] (level:0) is #f with stack state #f #() bra {tag 9:100} #({tag 7:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 9:100}) 100 205}) st r5, r1, -4 st r4, r1, -8 sub r1, r1, 8 #() [445->450] (level:0) is #f with stack state #f #() bra {tag 9:100} #({tag 8:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 9:100}) 100 205}) st r4, r1, -4 sub r1, r1, 4 #() [450->455] (level:0) is #f with stack state #f #() bra {tag 9:100} +++ ending code for rest_key_xep_1 +++ +++ No Source Code Locators for rest_key_xep_1 +++ +++ Exported function definition rest_key_xep_2 +++ +++ starting code for rest_key_xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:505}) 505 535}) blo {tag 1:505}, r0, 2 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 4:40}) 40 45}) ld N2/r23, r22, 20 ld N0/r23, N2/r23, 4 asr N0/r23, N0/r23, 3 sub N0/r23, N0/r23, 1 bge {tag 4:40}, N0/r23, 0 #() [35->40] (level:0) is #f with stack state #f #({basic-block #({tag 4:40}) 40 45}) move N0/r23, 0 #({tag 4:40}) [40->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 6:50}) 50 65}) bgt {tag 6:50}, r0, 3 #() [45->50] (level:0) is #f with stack state #f #({basic-block #({tag 8:75}) 75 180}, {basic-block #({tag 7:65}) 65 75}) bgt {tag 7:65}, r0, 2 #({tag 8:75}) [75->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) add N6/r21, N0/r23, 3 asl N6/r21, N6/r21, 2 move N5/r20, r1 sub r1, r1, N6/r21 asl r0, r0, 2 move N4/r21, r0 add r0, r0, -7 st r0, N5/r20, -4 st {constant "KLsimple_object_vectorGVKdW"}, N5/r20, -8 add N7/r23, N0/r23, 3 asl N7/r23, N7/r23, 2 add N4/r21, N4/r21, N7/r23 sub N4/r21, N4/r21, 8 st N4/r21, N5/r20, -12 add N8/r20, N5/r20, -8 move r5, N8/r20 sub N1/r23, N8/r20, 8 move r0, N1/r23 push N8/r20 move r23, {constant "KPfalseVKi"} move r22, r22 #() [180->185] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep_0"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:505}) [505->535] (level:0) is #f with stack state #f #({basic-block #() 535 535}) preserve-registers-entry asl N20/r4, r0, 2 add N20/r4, N20/r4, 1 move r3, r22 move r4, N20/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [535->535] (level:0) is #f with stack state #f #({basic-block #() 535 540}) #() [535->540] (level:0) is #f with stack state #f #() rts #({tag 6:50}) [50->65] (level:0) is #f with stack state #f #({basic-block #({tag 8:75}) 75 180}) st r6, r1, -4 st r5, r1, -8 sub r1, r1, 8 #() [570->575] (level:0) is #f with stack state #f #() bra {tag 8:75} #({tag 7:65}) [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 8:75}) 75 180}) st r5, r1, -4 sub r1, r1, 4 #() [575->580] (level:0) is #f with stack state #f #() bra {tag 8:75} +++ ending code for rest_key_xep_2 +++ +++ No Source Code Locators for rest_key_xep_2 +++ +++ Exported function definition rest_key_xep_3 +++ +++ starting code for rest_key_xep_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 30}, {basic-block #({tag 1:625}) 625 655}) blo {tag 1:625}, r0, 3 #() [10->30] (level:0) is #f with stack state #f #({basic-block #({tag 6:40}) 40 145}, {basic-block #({tag 5:30}) 30 40}) ld N2/r20, r22, 20 ld N0/r20, N2/r20, 4 asr N0/r20, N0/r20, 3 bgt {tag 5:30}, r0, 3 #({tag 6:40}) [40->145] (level:0) is #f with stack state #f #({basic-block #() 145 150}) add N6/r23, N0/r20, 3 asl N6/r23, N6/r23, 2 move N5/r21, r1 sub r1, r1, N6/r23 asl r0, r0, 2 move N4/r23, r0 add r0, r0, -11 st r0, N5/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N5/r21, -8 add N7/r20, N0/r20, 3 asl N7/r20, N7/r20, 2 add N4/r23, N4/r23, N7/r20 sub N4/r23, N4/r23, 12 st N4/r23, N5/r21, -12 add N8/r21, N5/r21, -8 move r6, N8/r21 sub N1/r23, N8/r21, 8 move r0, N1/r23 push N8/r21 move r23, {constant "KPfalseVKi"} move r22, r22 #() [145->150] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:625}) [625->655] (level:0) is #f with stack state #f #({basic-block #() 655 655}) preserve-registers-entry asl N25/r4, r0, 2 add N25/r4, N25/r4, 1 move r3, r22 move r4, N25/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [655->655] (level:0) is #f with stack state #f #({basic-block #() 655 660}) #() [655->660] (level:0) is #f with stack state #f #() rts #({tag 5:30}) [30->40] (level:0) is #f with stack state #f #({basic-block #({tag 6:40}) 40 145}) st r6, r1, -4 sub r1, r1, 4 #() [690->695] (level:0) is #f with stack state #f #() bra {tag 6:40} +++ ending code for rest_key_xep_3 +++ +++ No Source Code Locators for rest_key_xep_3 +++ +++ Exported function definition rest_key_xep_4 +++ +++ starting code for rest_key_xep_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 145}, {basic-block #({tag 1:780}) 780 810}) blo {tag 1:780}, r0, 4 #() [10->145] (level:0) is #f with stack state #f #({basic-block #() 145 150}) ld N2/r20, r22, 20 ld N0/r20, N2/r20, 4 asr N0/r20, N0/r20, 3 add N8/r21, N0/r20, 4 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 move N4/r23, r0 add N3/r21, N7/r21, 0 asl N4/r23, N4/r23, 2 move r0, N4/r23 add N4/r23, N4/r23, -15 st N4/r23, N3/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/r21, -8 add N9/r23, N0/r20, 4 asl N9/r23, N9/r23, 2 add r0, r0, N9/r23 sub r0, r0, 16 st r0, N3/r21, -12 sub N10/r23, N3/r21, N9/r23 add N11/r21, N3/r21, -8 st N11/r21, N10/r23, 0 sub N1/r23, N11/r21, 8 move r0, N1/r23 push N11/r21 move r23, {constant "KPfalseVKi"} move r22, r22 #() [145->150] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:780}) [780->810] (level:0) is #f with stack state #f #({basic-block #() 810 810}) preserve-registers-entry asl N33/r4, r0, 2 add N33/r4, N33/r4, 1 move r3, r22 move r4, N33/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [810->810] (level:0) is #f with stack state #f #({basic-block #() 810 815}) #() [810->815] (level:0) is #f with stack state #f #() rts +++ ending code for rest_key_xep_4 +++ +++ No Source Code Locators for rest_key_xep_4 +++ +++ Exported function definition rest_key_xep_5 +++ +++ starting code for rest_key_xep_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 155}, {basic-block #({tag 1:185}) 185 215}) blo {tag 1:185}, r0, 5 #() [10->155] (level:0) is #f with stack state #f #({basic-block #() 155 160}) ld N2/r20, r22, 20 ld N0/r20, N2/r20, 4 asr N0/r20, N0/r20, 3 add N8/r21, N0/r20, 4 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 move N4/r23, r0 ld N5/r19, N7/r21, 0 st N5/r19, r1, 0 add N3/r21, N7/r21, 4 asl N4/r23, N4/r23, 2 move r0, N4/r23 add N4/r23, N4/r23, -19 st N4/r23, N3/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/r21, -8 add N9/r23, N0/r20, 4 asl N9/r23, N9/r23, 2 add r0, r0, N9/r23 sub r0, r0, 16 st r0, N3/r21, -12 sub N10/r23, N3/r21, N9/r23 add N11/r21, N3/r21, -8 st N11/r21, N10/r23, 0 sub N1/r23, N11/r21, 8 move r0, N1/r23 push N11/r21 move r23, {constant "KPfalseVKi"} move r22, r22 #() [155->160] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:185}) [185->215] (level:0) is #f with stack state #f #({basic-block #() 215 215}) preserve-registers-entry asl N13/r4, r0, 2 add N13/r4, N13/r4, 1 move r3, r22 move r4, N13/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [215->215] (level:0) is #f with stack state #f #({basic-block #() 215 220}) #() [215->220] (level:0) is #f with stack state #f #() rts +++ ending code for rest_key_xep_5 +++ +++ No Source Code Locators for rest_key_xep_5 +++ +++ Exported function definition rest_key_xep_6 +++ +++ starting code for rest_key_xep_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 165}, {basic-block #({tag 1:195}) 195 225}) blo {tag 1:195}, r0, 6 #() [10->165] (level:0) is #f with stack state #f #({basic-block #() 165 170}) ld N2/r20, r22, 20 ld N0/r20, N2/r20, 4 asr N0/r20, N0/r20, 3 add N8/r21, N0/r20, 4 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 move N4/r23, r0 ld N5/r18, N7/r21, 0 ld N6/r19, N7/r21, 4 st N5/r18, r1, 0 st N6/r19, r1, 4 add N3/r21, N7/r21, 8 asl N4/r23, N4/r23, 2 move r0, N4/r23 add N4/r23, N4/r23, -23 st N4/r23, N3/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/r21, -8 add N9/r23, N0/r20, 4 asl N9/r23, N9/r23, 2 add r0, r0, N9/r23 sub r0, r0, 16 st r0, N3/r21, -12 sub N10/r23, N3/r21, N9/r23 add N11/r21, N3/r21, -8 st N11/r21, N10/r23, 0 sub N1/r23, N11/r21, 8 move r0, N1/r23 push N11/r21 move r23, {constant "KPfalseVKi"} move r22, r22 #() [165->170] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:195}) [195->225] (level:0) is #f with stack state #f #({basic-block #() 225 225}) preserve-registers-entry asl N13/r4, r0, 2 add N13/r4, N13/r4, 1 move r3, r22 move r4, N13/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [225->225] (level:0) is #f with stack state #f #({basic-block #() 225 230}) #() [225->230] (level:0) is #f with stack state #f #() rts +++ ending code for rest_key_xep_6 +++ +++ No Source Code Locators for rest_key_xep_6 +++ +++ Exported function definition rest_key_xep_7 +++ +++ starting code for rest_key_xep_7 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 175}, {basic-block #({tag 1:205}) 205 235}) blo {tag 1:205}, r0, 7 #() [10->175] (level:0) is #f with stack state #f #({basic-block #() 175 180}) ld N2/r20, r22, 20 ld N0/r20, N2/r20, 4 asr N0/r20, N0/r20, 3 add N8/r21, N0/r20, 4 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 move N4/r23, r0 ld N5/r19, N7/r21, 0 ld N6/r18, N7/r21, 4 st N5/r19, r1, 0 st N6/r18, r1, 4 ld N5/r19, N7/r21, 8 st N5/r19, r1, 8 add N3/r21, N7/r21, 12 asl N4/r23, N4/r23, 2 move r0, N4/r23 add N4/r23, N4/r23, -27 st N4/r23, N3/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/r21, -8 add N9/r23, N0/r20, 4 asl N9/r23, N9/r23, 2 add r0, r0, N9/r23 sub r0, r0, 16 st r0, N3/r21, -12 sub N10/r23, N3/r21, N9/r23 add N11/r21, N3/r21, -8 st N11/r21, N10/r23, 0 sub N1/r23, N11/r21, 8 move r0, N1/r23 push N11/r21 move r23, {constant "KPfalseVKi"} move r22, r22 #() [175->180] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:205}) [205->235] (level:0) is #f with stack state #f #({basic-block #() 235 235}) preserve-registers-entry asl N13/r4, r0, 2 add N13/r4, N13/r4, 1 move r3, r22 move r4, N13/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [235->235] (level:0) is #f with stack state #f #({basic-block #() 235 240}) #() [235->240] (level:0) is #f with stack state #f #() rts +++ ending code for rest_key_xep_7 +++ +++ No Source Code Locators for rest_key_xep_7 +++ +++ Exported function definition rest_key_xep_8 +++ +++ starting code for rest_key_xep_8 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 185}, {basic-block #({tag 1:215}) 215 245}) blo {tag 1:215}, r0, 8 #() [10->185] (level:0) is #f with stack state #f #({basic-block #() 185 190}) ld N2/r20, r22, 20 ld N0/r20, N2/r20, 4 asr N0/r20, N0/r20, 3 add N8/r21, N0/r20, 4 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 move N4/r23, r0 ld N5/r18, N7/r21, 0 ld N6/r19, N7/r21, 4 st N5/r18, r1, 0 st N6/r19, r1, 4 ld N5/r18, N7/r21, 8 ld N6/r19, N7/r21, 12 st N5/r18, r1, 8 st N6/r19, r1, 12 add N3/r21, N7/r21, 16 asl N4/r23, N4/r23, 2 move r0, N4/r23 add N4/r23, N4/r23, -31 st N4/r23, N3/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/r21, -8 add N9/r23, N0/r20, 4 asl N9/r23, N9/r23, 2 add r0, r0, N9/r23 sub r0, r0, 16 st r0, N3/r21, -12 sub N10/r23, N3/r21, N9/r23 add N11/r21, N3/r21, -8 st N11/r21, N10/r23, 0 sub N1/r23, N11/r21, 8 move r0, N1/r23 push N11/r21 move r23, {constant "KPfalseVKi"} move r22, r22 #() [185->190] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:215}) [215->245] (level:0) is #f with stack state #f #({basic-block #() 245 245}) preserve-registers-entry asl N13/r4, r0, 2 add N13/r4, N13/r4, 1 move r3, r22 move r4, N13/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [245->245] (level:0) is #f with stack state #f #({basic-block #() 245 250}) #() [245->250] (level:0) is #f with stack state #f #() rts +++ ending code for rest_key_xep_8 +++ +++ No Source Code Locators for rest_key_xep_8 +++ +++ Exported function definition rest_key_xep_9 +++ +++ starting code for rest_key_xep_9 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 195}, {basic-block #({tag 1:225}) 225 255}) blo {tag 1:225}, r0, 9 #() [10->195] (level:0) is #f with stack state #f #({basic-block #() 195 200}) ld N2/r19, r22, 20 ld N0/r19, N2/r19, 4 asr N0/r19, N0/r19, 3 add N8/r23, N0/r19, 4 asl N8/r23, N8/r23, 2 sub r1, r1, N8/r23 add N7/r23, r1, N8/r23 move N4/r21, r0 ld N5/r20, N7/r23, 0 ld N6/r18, N7/r23, 4 st N5/r20, r1, 0 st N6/r18, r1, 4 ld N5/r20, N7/r23, 8 ld N6/r18, N7/r23, 12 st N5/r20, r1, 8 st N6/r18, r1, 12 ld N5/r20, N7/r23, 16 st N5/r20, r1, 16 add N3/r23, N7/r23, 20 asl N4/r21, N4/r21, 2 move r0, N4/r21 add N4/r21, N4/r21, -35 st N4/r21, N3/r23, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/r23, -8 add N9/r21, N0/r19, 4 asl N9/r21, N9/r21, 2 add r0, r0, N9/r21 sub r0, r0, 16 st r0, N3/r23, -12 sub N10/r21, N3/r23, N9/r21 add N11/r23, N3/r23, -8 st N11/r23, N10/r21, 0 sub N1/r21, N11/r23, 8 move r0, N1/r21 push N11/r23 move r23, {constant "KPfalseVKi"} move r22, r22 #() [195->200] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:225}) [225->255] (level:0) is #f with stack state #f #({basic-block #() 255 255}) preserve-registers-entry asl N13/r4, r0, 2 add N13/r4, N13/r4, 1 move r3, r22 move r4, N13/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [255->255] (level:0) is #f with stack state #f #({basic-block #() 255 260}) #() [255->260] (level:0) is #f with stack state #f #() rts +++ ending code for rest_key_xep_9 +++ +++ No Source Code Locators for rest_key_xep_9 +++ +++ Exported function definition rest_key_xep +++ +++ starting code for rest_key_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 225}, {basic-block #({tag 1:265}) 265 295}) ld N0/r23, r22, 8 ld N0/r23, N0/r23, 4 asr N0/r23, N0/r23, 2 and N0/r23, N0/r23, 255 blo {tag 1:265}, r0, N0/r23 #() [30->225] (level:0) is #f with stack state #f #({basic-block #() 225 230}) ld N3/r20, r22, 20 ld N1/r20, N3/r20, 4 asr N1/r20, N1/r20, 3 ld N6/r23, r22, 8 ld N6/r23, N6/r23, 4 asr N6/r23, N6/r23, 2 and N6/r23, N6/r23, 255 add N6/r23, N6/r23, -4 add N9/r21, N1/r20, 4 asl N9/r21, N9/r21, 2 move N7/r19, r1 sub r1, r1, N9/r21 move N5/r21, r0 move r0, N6/r23 move N8/r23, r1 copy-words-down-w N8/r23, N7/r19, r0 add N4/r23, r9, 4 asl N5/r21, N5/r21, 2 move r0, N5/r21 ld r7, r22, 8 ld r7, r7, 4 and r7, r7, 1020 sub N5/r21, N5/r21, r7 add N5/r21, N5/r21, 1 st N5/r21, N4/r23, -4 st {constant "KLsimple_object_vectorGVKdW"}, N4/r23, -8 add N10/r21, N1/r20, 4 asl N10/r21, N10/r21, 2 add r0, r0, N10/r21 sub r0, r0, 16 st r0, N4/r23, -12 sub N11/r21, N4/r23, N10/r21 add N12/r23, N4/r23, -8 st N12/r23, N11/r21, 0 sub N2/r21, N12/r23, 8 move r0, N2/r21 push N12/r23 move r23, {constant "KPfalseVKi"} move r22, r22 #() [225->230] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[4, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:265}) [265->295] (level:0) is #f with stack state #f #({basic-block #() 295 295}) preserve-registers-entry asl N15/r4, r0, 2 add N15/r4, N15/r4, 1 move r3, r22 move r4, N15/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [295->295] (level:0) is #f with stack state #f #({basic-block #() 295 300}) #() [295->300] (level:0) is #f with stack state #f #() rts +++ ending code for rest_key_xep +++ +++ No Source Code Locators for rest_key_xep +++ +++ Exported function definition rest_key_mep_0 +++ +++ starting code for rest_key_mep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 1:40}) 40 105}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 sub r0, r0, 3 bge {tag 1:40}, r0, 0 #() [35->40] (level:0) is #f with stack state #f #({basic-block #({tag 1:40}) 40 105}) move r0, 0 #({tag 1:40}) [40->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) asl r7, r0, 2 add2-mem r1, 0, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 add N1/r21, N7/r21, 0 sub N3/r21, N1/r21, 4 move N2/r20, r3 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [105->110] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_2"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_0 +++ +++ No Source Code Locators for rest_key_mep_0 +++ +++ Exported function definition rest_key_mep_1 +++ +++ starting code for rest_key_mep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 1:40}) 40 105}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 sub r0, r0, 2 bge {tag 1:40}, r0, 0 #() [35->40] (level:0) is #f with stack state #f #({basic-block #({tag 1:40}) 40 105}) move r0, 0 #({tag 1:40}) [40->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) asl r7, r0, 2 add2-mem r1, 0, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 add N1/r21, N7/r21, 0 sub N3/r21, N1/r21, 4 move N2/r20, r4 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [105->110] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_1"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_1 +++ +++ No Source Code Locators for rest_key_mep_1 +++ +++ Exported function definition rest_key_mep_2 +++ +++ starting code for rest_key_mep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 1:40}) 40 105}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 sub r0, r0, 1 bge {tag 1:40}, r0, 0 #() [35->40] (level:0) is #f with stack state #f #({basic-block #({tag 1:40}) 40 105}) move r0, 0 #({tag 1:40}) [40->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) asl r7, r0, 2 add2-mem r1, 0, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 add N1/r21, N7/r21, 0 sub N3/r21, N1/r21, 4 move N2/r20, r5 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [105->110] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_0"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_2 +++ +++ No Source Code Locators for rest_key_mep_2 +++ +++ Exported function definition rest_key_mep_3 +++ +++ starting code for rest_key_mep_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 90}) rem "This is a dummy first basic block." #() [5->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 asl r7, r0, 2 add2-mem r1, 0, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 add N1/r21, N7/r21, 0 sub N3/r21, N1/r21, 4 move N2/r20, r6 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [90->95] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_3 +++ +++ No Source Code Locators for rest_key_mep_3 +++ +++ Exported function definition rest_key_mep_4 +++ +++ starting code for rest_key_mep_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 100}) rem "This is a dummy first basic block." #() [5->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 asl r7, r0, 2 add2-mem r1, 4, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 ld N5/r20, N7/r21, 0 st N5/r20, r1, 0 add N1/r21, N7/r21, 4 sub N3/r21, N1/r21, 4 ld N2/r20, r1, 0 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [100->105] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_4 +++ +++ No Source Code Locators for rest_key_mep_4 +++ +++ Exported function definition rest_key_mep_5 +++ +++ starting code for rest_key_mep_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 110}) rem "This is a dummy first basic block." #() [5->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 asl r7, r0, 2 add2-mem r1, 8, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 ld N5/r19, N7/r21, 0 ld N6/r20, N7/r21, 4 st N5/r19, r1, 0 st N6/r20, r1, 4 add N1/r21, N7/r21, 8 sub N3/r21, N1/r21, 4 ld N2/r20, r1, 4 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [110->115] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_5 +++ +++ No Source Code Locators for rest_key_mep_5 +++ +++ Exported function definition rest_key_mep_6 +++ +++ starting code for rest_key_mep_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 120}) rem "This is a dummy first basic block." #() [5->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 asl r7, r0, 2 add2-mem r1, 12, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 ld N5/r20, N7/r21, 0 ld N6/r19, N7/r21, 4 st N5/r20, r1, 0 st N6/r19, r1, 4 ld N5/r20, N7/r21, 8 st N5/r20, r1, 8 add N1/r21, N7/r21, 12 sub N3/r21, N1/r21, 4 ld N2/r20, r1, 8 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [120->125] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_6 +++ +++ No Source Code Locators for rest_key_mep_6 +++ +++ Exported function definition rest_key_mep_7 +++ +++ starting code for rest_key_mep_7 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 130}) rem "This is a dummy first basic block." #() [5->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 asl r7, r0, 2 add2-mem r1, 16, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 ld N5/r19, N7/r21, 0 ld N6/r20, N7/r21, 4 st N5/r19, r1, 0 st N6/r20, r1, 4 ld N5/r19, N7/r21, 8 ld N6/r20, N7/r21, 12 st N5/r19, r1, 8 st N6/r20, r1, 12 add N1/r21, N7/r21, 16 sub N3/r21, N1/r21, 4 ld N2/r20, r1, 12 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [130->135] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_7 +++ +++ No Source Code Locators for rest_key_mep_7 +++ +++ Exported function definition rest_key_mep_8 +++ +++ starting code for rest_key_mep_8 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 140}) rem "This is a dummy first basic block." #() [5->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 asl r7, r0, 2 add2-mem r1, 20, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 ld N5/r20, N7/r21, 0 ld N6/r19, N7/r21, 4 st N5/r20, r1, 0 st N6/r19, r1, 4 ld N5/r20, N7/r21, 8 ld N6/r19, N7/r21, 12 st N5/r20, r1, 8 st N6/r19, r1, 12 ld N5/r20, N7/r21, 16 st N5/r20, r1, 16 add N1/r21, N7/r21, 20 sub N3/r21, N1/r21, 4 ld N2/r20, r1, 16 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [140->145] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_8 +++ +++ No Source Code Locators for rest_key_mep_8 +++ +++ Exported function definition rest_key_mep_9 +++ +++ starting code for rest_key_mep_9 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 150}) rem "This is a dummy first basic block." #() [5->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) move N0/r23, r23 ld N4/r21, r22, 20 ld r0, N4/r21, 4 asr r0, r0, 3 asl r7, r0, 2 add2-mem r1, 24, 0, r7 move N8/r21, r0 asl N8/r21, N8/r21, 2 sub r1, r1, N8/r21 add N7/r21, r1, N8/r21 ld N5/r19, N7/r21, 0 ld N6/r20, N7/r21, 4 st N5/r19, r1, 0 st N6/r20, r1, 4 ld N5/r19, N7/r21, 8 ld N6/r20, N7/r21, 12 st N5/r19, r1, 8 st N6/r20, r1, 12 ld N5/r19, N7/r21, 16 ld N6/r20, N7/r21, 20 st N5/r19, r1, 16 st N6/r20, r1, 20 add N1/r21, N7/r21, 24 sub N3/r21, N1/r21, 4 ld N2/r20, r1, 20 move r0, N3/r21 push N2/r20 move r23, N0/r23 move r22, r22 #() [150->155] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep_9 +++ +++ No Source Code Locators for rest_key_mep_9 +++ +++ Exported function definition rest_key_mep +++ +++ starting code for rest_key_mep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 145}) rem "This is a dummy first basic block." #() [5->145] (level:0) is #f with stack state #f #({basic-block #() 145 150}) push r23 push r22 ld N3/r23, r22, 8 ld N3/r23, N3/r23, 4 asr N3/r23, N3/r23, 2 and N3/r23, N3/r23, 255 add N3/r23, N3/r23, -1 ld N4/r22, r22, 20 ld r0, N4/r22, 4 asr r0, r0, 3 asl r7, r0, 2 asl N5/r21, N3/r23, 2 add2-mem r1, N5/r21, 0, r7 move N8/r22, r0 asl N8/r22, N8/r22, 2 move N6/r20, r1 sub r1, r1, N8/r22 move r0, N3/r23 move N7/r23, r1 copy-words-down-w N7/r23, N6/r20, r0 add N0/r9, r9, 4 sub N2/r9, N0/r9, 4 sub N9/r21, N5/r21, 4 ld N1/r21, r1, N9/r21 pop r22 pop r23 move r0, N2/r9 push N1/r21 #() [145->150] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[4, #"mlist", #"arg-count"], 0, #f, #f +++ ending code for rest_key_mep +++ +++ No Source Code Locators for rest_key_mep +++ +++ Exported function definition new_gf_xep_0 +++ +++ starting code for new_gf_xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75}) bne {tag 1:45}, r0, 0 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/r23, r22 ld G0/r22, G1/r23, 24 ld N2/r21, G0/r22, 12 move r23, G1/r23 move r22, G0/r22 #() [35->40] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:45}) [45->75] (level:0) is #f with stack state #f #({basic-block #() 75 75}) preserve-registers-entry asl N3/r4, r0, 2 add N3/r4, N3/r4, 1 move r3, r22 move r4, N3/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [75->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) #() [75->80] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep_0 +++ +++ No Source Code Locators for new_gf_xep_0 +++ +++ Exported function definition new_gf_xep_1 +++ +++ starting code for new_gf_xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75}) bne {tag 1:45}, r0, 1 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/r23, r22 ld G0/r22, G1/r23, 24 ld N2/r21, G0/r22, 12 move r23, G1/r23 move r22, G0/r22 #() [35->40] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:45}) [45->75] (level:0) is #f with stack state #f #({basic-block #() 75 75}) preserve-registers-entry asl N3/r4, r0, 2 add N3/r4, N3/r4, 1 move r3, r22 move r4, N3/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [75->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) #() [75->80] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep_1 +++ +++ No Source Code Locators for new_gf_xep_1 +++ +++ Exported function definition new_gf_xep_2 +++ +++ starting code for new_gf_xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75}) bne {tag 1:45}, r0, 2 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/r23, r22 ld G0/r22, G1/r23, 24 ld N2/r21, G0/r22, 12 move r23, G1/r23 move r22, G0/r22 #() [35->40] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:45}) [45->75] (level:0) is #f with stack state #f #({basic-block #() 75 75}) preserve-registers-entry asl N3/r4, r0, 2 add N3/r4, N3/r4, 1 move r3, r22 move r4, N3/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [75->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) #() [75->80] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep_2 +++ +++ No Source Code Locators for new_gf_xep_2 +++ +++ Exported function definition new_gf_xep_3 +++ +++ starting code for new_gf_xep_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75}) bne {tag 1:45}, r0, 3 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/r23, r22 ld G0/r22, G1/r23, 24 ld N2/r21, G0/r22, 12 move r23, G1/r23 move r22, G0/r22 #() [35->40] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:45}) [45->75] (level:0) is #f with stack state #f #({basic-block #() 75 75}) preserve-registers-entry asl N3/r4, r0, 2 add N3/r4, N3/r4, 1 move r3, r22 move r4, N3/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [75->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) #() [75->80] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep_3 +++ +++ No Source Code Locators for new_gf_xep_3 +++ +++ Exported function definition new_gf_xep_4 +++ +++ starting code for new_gf_xep_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75}) bne {tag 1:45}, r0, 4 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/r23, r22 ld G0/r22, G1/r23, 24 ld N2/r21, G0/r22, 12 move r23, G1/r23 move r22, G0/r22 #() [35->40] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:45}) [45->75] (level:0) is #f with stack state #f #({basic-block #() 75 75}) preserve-registers-entry asl N3/r4, r0, 2 add N3/r4, N3/r4, 1 move r3, r22 move r4, N3/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [75->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) #() [75->80] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep_4 +++ +++ No Source Code Locators for new_gf_xep_4 +++ +++ Exported function definition new_gf_xep_5 +++ +++ starting code for new_gf_xep_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75}) bne {tag 1:45}, r0, 5 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/r23, r22 ld G0/r22, G1/r23, 24 ld N2/r21, G0/r22, 12 move r23, G1/r23 move r22, G0/r22 #() [35->40] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:45}) [45->75] (level:0) is #f with stack state #f #({basic-block #() 75 75}) preserve-registers-entry asl N3/r4, r0, 2 add N3/r4, N3/r4, 1 move r3, r22 move r4, N3/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [75->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) #() [75->80] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep_5 +++ +++ No Source Code Locators for new_gf_xep_5 +++ +++ Exported function definition new_gf_xep_6 +++ +++ starting code for new_gf_xep_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 35}, {basic-block #({tag 1:45}) 45 75}) bne {tag 1:45}, r0, 6 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/r23, r22 ld G0/r22, G1/r23, 24 ld N2/r21, G0/r22, 12 move r23, G1/r23 move r22, G0/r22 #() [35->40] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:45}) [45->75] (level:0) is #f with stack state #f #({basic-block #() 75 75}) preserve-registers-entry asl N3/r4, r0, 2 add N3/r4, N3/r4, 1 move r3, r22 move r4, N3/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [75->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) #() [75->80] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep_6 +++ +++ No Source Code Locators for new_gf_xep_6 +++ +++ Exported function definition new_gf_xep +++ +++ starting code for new_gf_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 55}, {basic-block #({tag 1:65}) 65 95}) ld N0/r23, r22, 8 ld N0/r23, N0/r23, 4 asr N0/r23, N0/r23, 2 and N0/r23, N0/r23, 255 bne {tag 1:65}, r0, N0/r23 #() [30->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) move G2/r23, r22 ld G1/r22, G2/r23, 24 ld N3/r21, G1/r22, 12 move r23, G2/r23 move r22, G1/r22 #() [55->60] (level:0) is #f with stack state #f #() jmp N3/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:65}) [65->95] (level:0) is #f with stack state #f #({basic-block #() 95 95}) preserve-registers-entry asl N4/r4, r0, 2 add N4/r4, N4/r4, 1 move r3, r22 move r4, N4/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [95->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) #() [95->100] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_xep +++ +++ No Source Code Locators for new_gf_xep +++ +++ Exported function definition new_gf_optional_xep_0 +++ +++ starting code for new_gf_optional_xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 5:25}) 25 50}) bgt {tag 5:25}, r0, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 6:50}) 50 70}) bgt {tag 6:50}, r0, 2 #() [15->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}, {basic-block #({tag 7:70}) 70 85}) bgt {tag 7:70}, r0, 1 #() [20->25] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 175}, {basic-block #({tag 8:85}) 85 95}) bgt {tag 8:85}, r0, 0 #({tag 9:95}) [95->175] (level:0) is #f with stack state #f #({basic-block #() 175 180}) move N2/r3, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, 1 st r0, N2/r3, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r3, -8 add N1/r23, N1/r23, 12 st N1/r23, N2/r3, -12 add N3/r3, N2/r3, -8 move r3, N3/r3 move G5/r23, r22 ld G4/r22, G5/r23, 24 ld N6/r21, G4/r22, 12 move r23, G5/r23 move r22, G4/r22 #() [175->180] (level:0) is #f with stack state #f #() jmp N6/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 5:25}) [25->50] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 175}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 st r3, r1, -16 sub r1, r1, 16 #() [220->225] (level:0) is #f with stack state #f #() bra {tag 9:95} #({tag 6:50}) [50->70] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 175}) st r5, r1, -4 st r4, r1, -8 st r3, r1, -12 sub r1, r1, 12 #() [225->230] (level:0) is #f with stack state #f #() bra {tag 9:95} #({tag 7:70}) [70->85] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 175}) st r4, r1, -4 st r3, r1, -8 sub r1, r1, 8 #() [230->235] (level:0) is #f with stack state #f #() bra {tag 9:95} #({tag 8:85}) [85->95] (level:0) is #f with stack state #f #({basic-block #({tag 9:95}) 95 175}) st r3, r1, -4 sub r1, r1, 4 #() [235->240] (level:0) is #f with stack state #f #() bra {tag 9:95} +++ ending code for new_gf_optional_xep_0 +++ +++ No Source Code Locators for new_gf_optional_xep_0 +++ +++ Exported function definition new_gf_optional_xep_1 +++ +++ starting code for new_gf_optional_xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:160}) 160 190}) blo {tag 1:160}, r0, 1 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 5:25}) 25 45}) bgt {tag 5:25}, r0, 3 #() [15->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}, {basic-block #({tag 6:45}) 45 60}) bgt {tag 6:45}, r0, 2 #() [20->25] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}, {basic-block #({tag 7:60}) 60 70}) bgt {tag 7:60}, r0, 1 #({tag 8:70}) [70->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) move N2/r4, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, -3 st r0, N2/r4, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r4, -8 add N1/r23, N1/r23, 8 st N1/r23, N2/r4, -12 add N3/r4, N2/r4, -8 move r4, N3/r4 move G5/r23, r22 ld G4/r22, G5/r23, 24 ld N6/r21, G4/r22, 12 move r23, G5/r23 move r22, G4/r22 #() [150->155] (level:0) is #f with stack state #f #() jmp N6/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:160}) [160->190] (level:0) is #f with stack state #f #({basic-block #() 190 190}) preserve-registers-entry asl N7/r4, r0, 2 add N7/r4, N7/r4, 1 move r3, r22 move r4, N7/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [190->190] (level:0) is #f with stack state #f #({basic-block #() 190 195}) #() [190->195] (level:0) is #f with stack state #f #() rts #({tag 5:25}) [25->45] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 sub r1, r1, 12 #() [195->200] (level:0) is #f with stack state #f #() bra {tag 8:70} #({tag 6:45}) [45->60] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}) st r5, r1, -4 st r4, r1, -8 sub r1, r1, 8 #() [200->205] (level:0) is #f with stack state #f #() bra {tag 8:70} #({tag 7:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #({tag 8:70}) 70 150}) st r4, r1, -4 sub r1, r1, 4 #() [205->210] (level:0) is #f with stack state #f #() bra {tag 8:70} +++ ending code for new_gf_optional_xep_1 +++ +++ No Source Code Locators for new_gf_optional_xep_1 +++ +++ Exported function definition new_gf_optional_xep_2 +++ +++ starting code for new_gf_optional_xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:135}) 135 165}) blo {tag 1:135}, r0, 2 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}, {basic-block #({tag 5:20}) 20 35}) bgt {tag 5:20}, r0, 3 #() [15->20] (level:0) is #f with stack state #f #({basic-block #({tag 7:45}) 45 125}, {basic-block #({tag 6:35}) 35 45}) bgt {tag 6:35}, r0, 2 #({tag 7:45}) [45->125] (level:0) is #f with stack state #f #({basic-block #() 125 130}) move N2/r5, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, -7 st r0, N2/r5, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r5, -8 add N1/r23, N1/r23, 4 st N1/r23, N2/r5, -12 add N3/r5, N2/r5, -8 move r5, N3/r5 move G5/r23, r22 ld G4/r22, G5/r23, 24 ld N6/r21, G4/r22, 12 move r23, G5/r23 move r22, G4/r22 #() [125->130] (level:0) is #f with stack state #f #() jmp N6/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:135}) [135->165] (level:0) is #f with stack state #f #({basic-block #() 165 165}) preserve-registers-entry asl N7/r4, r0, 2 add N7/r4, N7/r4, 1 move r3, r22 move r4, N7/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [165->165] (level:0) is #f with stack state #f #({basic-block #() 165 170}) #() [165->170] (level:0) is #f with stack state #f #() rts #({tag 5:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #({tag 7:45}) 45 125}) st r6, r1, -4 st r5, r1, -8 sub r1, r1, 8 #() [170->175] (level:0) is #f with stack state #f #() bra {tag 7:45} #({tag 6:35}) [35->45] (level:0) is #f with stack state #f #({basic-block #({tag 7:45}) 45 125}) st r5, r1, -4 sub r1, r1, 4 #() [175->180] (level:0) is #f with stack state #f #() bra {tag 7:45} +++ ending code for new_gf_optional_xep_2 +++ +++ No Source Code Locators for new_gf_optional_xep_2 +++ +++ Exported function definition new_gf_optional_xep_3 +++ +++ starting code for new_gf_optional_xep_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}, {basic-block #({tag 1:115}) 115 145}) blo {tag 1:115}, r0, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 105}, {basic-block #({tag 5:15}) 15 25}) bgt {tag 5:15}, r0, 3 #({tag 6:25}) [25->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) move N2/r6, r1 sub r1, r1, 12 asl r0, r0, 2 move N1/r23, r0 add r0, r0, -11 st r0, N2/r6, -4 st {constant "KLsimple_object_vectorGVKdW"}, N2/r6, -8 add N1/r23, N1/r23, 0 st N1/r23, N2/r6, -12 add N3/r6, N2/r6, -8 move r6, N3/r6 move G5/r23, r22 ld G4/r22, G5/r23, 24 ld N6/r21, G4/r22, 12 move r23, G5/r23 move r22, G4/r22 #() [105->110] (level:0) is #f with stack state #f #() jmp N6/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:115}) [115->145] (level:0) is #f with stack state #f #({basic-block #() 145 145}) preserve-registers-entry asl N7/r4, r0, 2 add N7/r4, N7/r4, 1 move r3, r22 move r4, N7/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [145->145] (level:0) is #f with stack state #f #({basic-block #() 145 150}) #() [145->150] (level:0) is #f with stack state #f #() rts #({tag 5:15}) [15->25] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 105}) st r6, r1, -4 sub r1, r1, 4 #() [150->155] (level:0) is #f with stack state #f #() bra {tag 6:25} +++ ending code for new_gf_optional_xep_3 +++ +++ No Source Code Locators for new_gf_optional_xep_3 +++ +++ Exported function definition new_gf_optional_xep_4 +++ +++ starting code for new_gf_optional_xep_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 100}, {basic-block #({tag 1:110}) 110 140}) blo {tag 1:110}, r0, 4 #() [10->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 add N0/r21, N4/r21, 0 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -15 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move G7/r23, r22 ld G6/r22, G7/r23, 24 ld N8/r21, G6/r22, 12 move r23, G7/r23 move r22, G6/r22 #() [100->105] (level:0) is #f with stack state #f #() jmp N8/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:110}) [110->140] (level:0) is #f with stack state #f #({basic-block #() 140 140}) preserve-registers-entry asl N9/r4, r0, 2 add N9/r4, N9/r4, 1 move r3, r22 move r4, N9/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [140->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) #() [140->145] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_optional_xep_4 +++ +++ No Source Code Locators for new_gf_optional_xep_4 +++ +++ Exported function definition new_gf_optional_xep_5 +++ +++ starting code for new_gf_optional_xep_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 110}, {basic-block #({tag 1:120}) 120 150}) blo {tag 1:120}, r0, 5 #() [10->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 ld N2/r20, N4/r21, 0 st N2/r20, r1, 0 add N0/r21, N4/r21, 4 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -19 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move G7/r23, r22 ld G6/r22, G7/r23, 24 ld N8/r21, G6/r22, 12 move r23, G7/r23 move r22, G6/r22 #() [110->115] (level:0) is #f with stack state #f #() jmp N8/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:120}) [120->150] (level:0) is #f with stack state #f #({basic-block #() 150 150}) preserve-registers-entry asl N9/r4, r0, 2 add N9/r4, N9/r4, 1 move r3, r22 move r4, N9/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [150->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) #() [150->155] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_optional_xep_5 +++ +++ No Source Code Locators for new_gf_optional_xep_5 +++ +++ Exported function definition new_gf_optional_xep_6 +++ +++ starting code for new_gf_optional_xep_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 120}, {basic-block #({tag 1:130}) 130 160}) blo {tag 1:130}, r0, 6 #() [10->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) sub r1, r1, 16 add N4/r21, r1, 16 move N1/r23, r0 ld N2/r19, N4/r21, 0 ld N3/r20, N4/r21, 4 st N2/r19, r1, 0 st N3/r20, r1, 4 add N0/r21, N4/r21, 8 asl N1/r23, N1/r23, 2 move r0, N1/r23 add N1/r23, N1/r23, -23 st N1/r23, N0/r21, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/r21, -8 add r0, r0, 0 st r0, N0/r21, -12 add N5/r23, N0/r21, -8 st N5/r23, N0/r21, -16 move G7/r23, r22 ld G6/r22, G7/r23, 24 ld N8/r21, G6/r22, 12 move r23, G7/r23 move r22, G6/r22 #() [120->125] (level:0) is #f with stack state #f #() jmp N8/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:130}) [130->160] (level:0) is #f with stack state #f #({basic-block #() 160 160}) preserve-registers-entry asl N9/r4, r0, 2 add N9/r4, N9/r4, 1 move r3, r22 move r4, N9/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [160->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) #() [160->165] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_optional_xep_6 +++ +++ No Source Code Locators for new_gf_optional_xep_6 +++ +++ Exported function definition new_gf_optional_xep +++ +++ starting code for new_gf_optional_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 180}, {basic-block #({tag 1:190}) 190 220}) ld N0/r23, r22, 8 ld N0/r23, N0/r23, 4 asr N0/r23, N0/r23, 2 and N0/r23, N0/r23, 255 blo {tag 1:190}, r0, N0/r23 #() [30->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N3/r23, r22, 8 ld N3/r23, N3/r23, 4 asr N3/r23, N3/r23, 2 and N3/r23, N3/r23, 255 add N3/r23, N3/r23, -4 move N4/r20, r1 sub r1, r1, 16 move N2/r21, r0 move r0, N3/r23 move N5/r23, r1 copy-words-down-w N5/r23, N4/r20, r0 add N1/r23, r9, 4 asl N2/r21, N2/r21, 2 move r0, N2/r21 ld r7, r22, 8 ld r7, r7, 4 and r7, r7, 1020 sub N2/r21, N2/r21, r7 add N2/r21, N2/r21, 1 st N2/r21, N1/r23, -4 st {constant "KLsimple_object_vectorGVKdW"}, N1/r23, -8 add r0, r0, 0 st r0, N1/r23, -12 add N6/r21, N1/r23, -8 st N6/r21, N1/r23, -16 move G8/r23, r22 ld G7/r22, G8/r23, 24 ld N9/r21, G7/r22, 12 move r23, G8/r23 move r22, G7/r22 #() [180->185] (level:0) is #f with stack state #f #() jmp N9/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:190}) [190->220] (level:0) is #f with stack state #f #({basic-block #() 220 220}) preserve-registers-entry asl N10/r4, r0, 2 add N10/r4, N10/r4, 1 move r3, r22 move r4, N10/r4 call {constant "Kargument_count_errorVKiI"}, 2 #() [220->220] (level:0) is #f with stack state #f #({basic-block #() 220 225}) #() [220->225] (level:0) is #f with stack state #f #() rts +++ ending code for new_gf_optional_xep +++ +++ No Source Code Locators for new_gf_optional_xep +++ +++ Exported function definition apply_xep_0 +++ +++ starting code for apply_xep_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 80}, {basic-block #({tag 1:85}) 85 100}) move N0/r23, r3 ld N3/r21, N0/r23, 4 asr N3/r21, N3/r21, 2 ble {tag 1:85}, N3/r21, 4 #() [25->80] (level:0) is #f with stack state #f #({basic-block #() 80 85}) sub N3/r21, N3/r21, 4 asl N4/r20, N3/r21, 2 sub r1, r1, N4/r20 move N5/r20, r1 add N1/r19, N0/r23, 24 copy-words-down-w N5/r20, N1/r19, N3/r21 add r0, N3/r21, 4 ld r3, N0/r23, 8 ld r4, N0/r23, 12 ld r5, N0/r23, 16 ld r6, N0/r23, 20 #() [80->85] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 2:115}) 115 135}) add r0, N3/r21, 0 add N0/r23, N0/r23, 8 bgt {tag 2:115}, N3/r21, 3 #() [100->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 3:135}) 135 150}) bgt {tag 3:135}, N3/r21, 2 #() [105->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}, {basic-block #({tag 4:150}) 150 160}) bgt {tag 4:150}, N3/r21, 1 #() [110->115] (level:0) is #f with stack state #f #({basic-block #({tag 6:165}) 165 165}, {basic-block #({tag 5:160}) 160 165}) bgt {tag 5:160}, N3/r21, 0 #({tag 6:165}) [165->165] (level:0) is #f with stack state #f #({basic-block #({tag 6:165}) 165 170}) #({tag 6:165}) [165->170] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 2:115}) [115->135] (level:0) is #f with stack state #f #({basic-block #({tag 6:165}) 165 165}) ld r3, N0/r23, 0 ld r4, N0/r23, 4 ld r5, N0/r23, 8 ld r6, N0/r23, 12 #() [170->175] (level:0) is #f with stack state #f #() bra {tag 6:165} #({tag 3:135}) [135->150] (level:0) is #f with stack state #f #({basic-block #({tag 6:165}) 165 165}) ld r3, N0/r23, 0 ld r4, N0/r23, 4 ld r5, N0/r23, 8 #() [175->180] (level:0) is #f with stack state #f #() bra {tag 6:165} #({tag 4:150}) [150->160] (level:0) is #f with stack state #f #({basic-block #({tag 6:165}) 165 165}) ld r3, N0/r23, 0 ld r4, N0/r23, 4 #() [180->185] (level:0) is #f with stack state #f #() bra {tag 6:165} #({tag 5:160}) [160->165] (level:0) is #f with stack state #f #({basic-block #({tag 6:165}) 165 165}) ld r3, N0/r23, 0 #() [185->190] (level:0) is #f with stack state #f #() bra {tag 6:165} +++ ending code for apply_xep_0 +++ +++ No Source Code Locators for apply_xep_0 +++ +++ Exported function definition apply_xep_1 +++ +++ starting code for apply_xep_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 75}, {basic-block #({tag 1:80}) 80 95}) move N0/r23, r4 ld N3/r21, N0/r23, 4 asr N3/r21, N3/r21, 2 ble {tag 1:80}, N3/r21, 3 #() [25->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) sub N3/r21, N3/r21, 3 asl N4/r20, N3/r21, 2 sub r1, r1, N4/r20 move N5/r20, r1 add N1/r19, N0/r23, 20 copy-words-down-w N5/r20, N1/r19, N3/r21 add r0, N3/r21, 4 ld r4, N0/r23, 8 ld r5, N0/r23, 12 ld r6, N0/r23, 16 #() [75->80] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}, {basic-block #({tag 2:105}) 105 120}) add r0, N3/r21, 1 add N0/r23, N0/r23, 8 bgt {tag 2:105}, N3/r21, 2 #() [95->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 3:120}) 120 130}) bgt {tag 3:120}, N3/r21, 1 #() [100->105] (level:0) is #f with stack state #f #({basic-block #({tag 5:135}) 135 135}, {basic-block #({tag 4:130}) 130 135}) bgt {tag 4:130}, N3/r21, 0 #({tag 5:135}) [135->135] (level:0) is #f with stack state #f #({basic-block #({tag 5:135}) 135 140}) #({tag 5:135}) [135->140] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 2:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #({tag 5:135}) 135 135}) ld r4, N0/r23, 0 ld r5, N0/r23, 4 ld r6, N0/r23, 8 #() [140->145] (level:0) is #f with stack state #f #() bra {tag 5:135} #({tag 3:120}) [120->130] (level:0) is #f with stack state #f #({basic-block #({tag 5:135}) 135 135}) ld r4, N0/r23, 0 ld r5, N0/r23, 4 #() [145->150] (level:0) is #f with stack state #f #() bra {tag 5:135} #({tag 4:130}) [130->135] (level:0) is #f with stack state #f #({basic-block #({tag 5:135}) 135 135}) ld r4, N0/r23, 0 #() [150->155] (level:0) is #f with stack state #f #() bra {tag 5:135} +++ ending code for apply_xep_1 +++ +++ No Source Code Locators for apply_xep_1 +++ +++ Exported function definition apply_xep_2 +++ +++ starting code for apply_xep_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 70}, {basic-block #({tag 1:75}) 75 90}) move N0/r21, r5 ld N3/r23, N0/r21, 4 asr N3/r23, N3/r23, 2 ble {tag 1:75}, N3/r23, 2 #() [25->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) sub N3/r23, N3/r23, 2 asl N4/r20, N3/r23, 2 sub r1, r1, N4/r20 move N5/r20, r1 add N1/r19, N0/r21, 16 copy-words-down-w N5/r20, N1/r19, N3/r23 add r0, N3/r23, 4 ld r5, N0/r21, 8 ld r6, N0/r21, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 2:95}) 95 105}) add r0, N3/r23, 2 add N0/r21, N0/r21, 8 bgt {tag 2:95}, N3/r23, 1 #() [90->95] (level:0) is #f with stack state #f #({basic-block #({tag 4:110}) 110 110}, {basic-block #({tag 3:105}) 105 110}) bgt {tag 3:105}, N3/r23, 0 #({tag 4:110}) [110->110] (level:0) is #f with stack state #f #({basic-block #({tag 4:110}) 110 115}) #({tag 4:110}) [110->115] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 2:95}) [95->105] (level:0) is #f with stack state #f #({basic-block #({tag 4:110}) 110 110}) ld r5, N0/r21, 0 ld r6, N0/r21, 4 #() [115->120] (level:0) is #f with stack state #f #() bra {tag 4:110} #({tag 3:105}) [105->110] (level:0) is #f with stack state #f #({basic-block #({tag 4:110}) 110 110}) ld r5, N0/r21, 0 #() [120->125] (level:0) is #f with stack state #f #() bra {tag 4:110} +++ ending code for apply_xep_2 +++ +++ No Source Code Locators for apply_xep_2 +++ +++ Exported function definition apply_xep_3 +++ +++ starting code for apply_xep_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 65}, {basic-block #({tag 1:70}) 70 85}) move N0/r21, r6 ld N3/r23, N0/r21, 4 asr N3/r23, N3/r23, 2 ble {tag 1:70}, N3/r23, 1 #() [25->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) sub N3/r23, N3/r23, 1 asl N4/r20, N3/r23, 2 sub r1, r1, N4/r20 move N5/r20, r1 add N1/r19, N0/r21, 12 copy-words-down-w N5/r20, N1/r19, N3/r23 add r0, N3/r23, 4 ld r6, N0/r21, 8 #() [65->70] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:70}) [70->85] (level:0) is #f with stack state #f #({basic-block #({tag 3:90}) 90 90}, {basic-block #({tag 2:85}) 85 90}) add r0, N3/r23, 3 add N0/r21, N0/r21, 8 bgt {tag 2:85}, N3/r23, 0 #({tag 3:90}) [90->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:90}) 90 95}) #({tag 3:90}) [90->95] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 2:85}) [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:90}) 90 90}) ld r6, N0/r21, 0 #() [95->100] (level:0) is #f with stack state #f #() bra {tag 3:90} +++ ending code for apply_xep_3 +++ +++ No Source Code Locators for apply_xep_3 +++ +++ Exported function definition apply_xep_4 +++ +++ starting code for apply_xep_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:115}) 115 130}) ld N1/r21, r1, 0 ld N2/r23, N1/r21, 4 asr N2/r23, N2/r23, 2 beq {tag 1:115}, N2/r23, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 90}, {basic-block #({tag 2:95}) 95 110}) beq {tag 2:95}, N2/r23, 1 #() [30->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}) sub N2/r23, N2/r23, 1 move N10/r23, N2/r23 asl N10/r23, N10/r23, 2 sub r1, r1, N10/r23 rem "eliminated" rem "eliminated" ld N4/r23, N1/r21, 4 asr N4/r23, N4/r23, 2 add N1/r21, N1/r21, 8 add r0, N4/r23, 4 add N6/r20, r1, 0 copy-words-down-w N6/r20, N1/r21, N4/r23 #() [90->95] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:115}) [115->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) move r0, 4 save-return-address 0 call-indirect r22, 4, 4 #() [130->135] (level:0) is #f with stack state #f #({basic-block #() 135 140}) restore-return-address #f #() [135->140] (level:0) is #f with stack state #f #() rts #({tag 2:95}) [95->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) ld N3/r21, N1/r21, 8 st N3/r21, r1, 0 move r0, 5 #() [110->115] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f +++ ending code for apply_xep_4 +++ +++ No Source Code Locators for apply_xep_4 +++ +++ Exported function definition apply_xep_5 +++ +++ starting code for apply_xep_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:125}) 125 140}) ld N1/r21, r1, 4 ld N2/r23, N1/r21, 4 asr N2/r23, N2/r23, 2 beq {tag 1:125}, N2/r23, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 100}, {basic-block #({tag 2:105}) 105 120}) beq {tag 2:105}, N2/r23, 1 #() [30->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) sub N2/r23, N2/r23, 1 move N10/r23, N2/r23 asl N10/r23, N10/r23, 2 sub r1, r1, N10/r23 add N9/r23, r1, N10/r23 ld N7/r23, N9/r23, 0 st N7/r23, r1, 0 rem "eliminated" ld N4/r23, N1/r21, 4 asr N4/r23, N4/r23, 2 add N1/r21, N1/r21, 8 add r0, N4/r23, 5 add N6/r20, r1, 4 copy-words-down-w N6/r20, N1/r21, N4/r23 #() [100->105] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:125}) [125->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) move r0, 5 save-return-address 4 call-indirect r22, 4, 4 #() [140->145] (level:0) is #f with stack state #f #({basic-block #() 145 150}) restore-return-address #f #() [145->150] (level:0) is #f with stack state #f #() rts #({tag 2:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) ld N3/r21, N1/r21, 8 st N3/r21, r1, 4 move r0, 6 #() [120->125] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f +++ ending code for apply_xep_5 +++ +++ No Source Code Locators for apply_xep_5 +++ +++ Exported function definition apply_xep_6 +++ +++ starting code for apply_xep_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:135}) 135 150}) ld N1/r21, r1, 8 ld N2/r23, N1/r21, 4 asr N2/r23, N2/r23, 2 beq {tag 1:135}, N2/r23, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 110}, {basic-block #({tag 2:115}) 115 130}) beq {tag 2:115}, N2/r23, 1 #() [30->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) sub N2/r23, N2/r23, 1 move N10/r23, N2/r23 asl N10/r23, N10/r23, 2 sub r1, r1, N10/r23 add N9/r23, r1, N10/r23 ld N7/r20, N9/r23, 0 ld N8/r23, N9/r23, 4 st N7/r20, r1, 0 st N8/r23, r1, 4 rem "eliminated" ld N4/r23, N1/r21, 4 asr N4/r23, N4/r23, 2 add N1/r21, N1/r21, 8 add r0, N4/r23, 6 add N6/r20, r1, 8 copy-words-down-w N6/r20, N1/r21, N4/r23 #() [110->115] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:135}) [135->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) move r0, 6 save-return-address 8 call-indirect r22, 4, 4 #() [150->155] (level:0) is #f with stack state #f #({basic-block #() 155 160}) restore-return-address #f #() [155->160] (level:0) is #f with stack state #f #() rts #({tag 2:115}) [115->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) ld N3/r21, N1/r21, 8 st N3/r21, r1, 8 move r0, 7 #() [130->135] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f +++ ending code for apply_xep_6 +++ +++ No Source Code Locators for apply_xep_6 +++ +++ Exported function definition apply_xep_7 +++ +++ starting code for apply_xep_7 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:145}) 145 160}) ld N1/r21, r1, 12 ld N2/r23, N1/r21, 4 asr N2/r23, N2/r23, 2 beq {tag 1:145}, N2/r23, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 120}, {basic-block #({tag 2:125}) 125 140}) beq {tag 2:125}, N2/r23, 1 #() [30->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) sub N2/r23, N2/r23, 1 move N10/r23, N2/r23 asl N10/r23, N10/r23, 2 sub r1, r1, N10/r23 add N9/r23, r1, N10/r23 ld N7/r20, N9/r23, 0 ld N8/r19, N9/r23, 4 st N7/r20, r1, 0 st N8/r19, r1, 4 ld N7/r20, N9/r23, 8 st N7/r20, r1, 8 rem "eliminated" ld N4/r23, N1/r21, 4 asr N4/r23, N4/r23, 2 add N1/r21, N1/r21, 8 add r0, N4/r23, 7 add N6/r20, r1, 12 copy-words-down-w N6/r20, N1/r21, N4/r23 #() [120->125] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:145}) [145->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) move r0, 7 save-return-address 12 call-indirect r22, 4, 4 #() [160->165] (level:0) is #f with stack state #f #({basic-block #() 165 170}) restore-return-address #f #() [165->170] (level:0) is #f with stack state #f #() rts #({tag 2:125}) [125->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) ld N3/r21, N1/r21, 8 st N3/r21, r1, 12 move r0, 8 #() [140->145] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f +++ ending code for apply_xep_7 +++ +++ No Source Code Locators for apply_xep_7 +++ +++ Exported function definition apply_xep_8 +++ +++ starting code for apply_xep_8 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:155}) 155 170}) ld N1/r21, r1, 16 ld N2/r23, N1/r21, 4 asr N2/r23, N2/r23, 2 beq {tag 1:155}, N2/r23, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 130}, {basic-block #({tag 2:135}) 135 150}) beq {tag 2:135}, N2/r23, 1 #() [30->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) sub N2/r23, N2/r23, 1 move N10/r23, N2/r23 asl N10/r23, N10/r23, 2 sub r1, r1, N10/r23 add N9/r23, r1, N10/r23 ld N7/r19, N9/r23, 0 ld N8/r20, N9/r23, 4 st N7/r19, r1, 0 st N8/r20, r1, 4 ld N7/r19, N9/r23, 8 ld N8/r20, N9/r23, 12 st N7/r19, r1, 8 st N8/r20, r1, 12 rem "eliminated" ld N4/r23, N1/r21, 4 asr N4/r23, N4/r23, 2 add N1/r21, N1/r21, 8 add r0, N4/r23, 8 add N6/r20, r1, 16 copy-words-down-w N6/r20, N1/r21, N4/r23 #() [130->135] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:155}) [155->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}) move r0, 8 save-return-address 16 call-indirect r22, 4, 4 #() [170->175] (level:0) is #f with stack state #f #({basic-block #() 175 180}) restore-return-address #f #() [175->180] (level:0) is #f with stack state #f #() rts #({tag 2:135}) [135->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) ld N3/r21, N1/r21, 8 st N3/r21, r1, 16 move r0, 9 #() [150->155] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f +++ ending code for apply_xep_8 +++ +++ No Source Code Locators for apply_xep_8 +++ +++ Exported function definition apply_xep_9 +++ +++ starting code for apply_xep_9 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:165}) 165 180}) ld N1/r21, r1, 20 ld N2/r23, N1/r21, 4 asr N2/r23, N2/r23, 2 beq {tag 1:165}, N2/r23, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 140}, {basic-block #({tag 2:145}) 145 160}) beq {tag 2:145}, N2/r23, 1 #() [30->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) sub N2/r23, N2/r23, 1 move N10/r23, N2/r23 asl N10/r23, N10/r23, 2 sub r1, r1, N10/r23 add N9/r23, r1, N10/r23 ld N7/r20, N9/r23, 0 ld N8/r19, N9/r23, 4 st N7/r20, r1, 0 st N8/r19, r1, 4 ld N7/r20, N9/r23, 8 ld N8/r19, N9/r23, 12 st N7/r20, r1, 8 st N8/r19, r1, 12 ld N7/r20, N9/r23, 16 st N7/r20, r1, 16 rem "eliminated" ld N4/r23, N1/r21, 4 asr N4/r23, N4/r23, 2 add N1/r21, N1/r21, 8 add r0, N4/r23, 9 add N6/r20, r1, 20 copy-words-down-w N6/r20, N1/r21, N4/r23 #() [140->145] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 1:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) move r0, 9 save-return-address 20 call-indirect r22, 4, 4 #() [180->185] (level:0) is #f with stack state #f #({basic-block #() 185 190}) restore-return-address #f #() [185->190] (level:0) is #f with stack state #f #() rts #({tag 2:145}) [145->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) ld N3/r21, N1/r21, 8 st N3/r21, r1, 20 move r0, 10 #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f +++ ending code for apply_xep_9 +++ +++ No Source Code Locators for apply_xep_9 +++ +++ Exported function definition apply_xep +++ +++ starting code for apply_xep +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #() 10 10}, {basic-block #({tag 1:15}) 15 20}) bne {tag 1:15}, r0, 1 #() [10->10] (level:0) is #f with stack state #f #({basic-block #() 10 15}) #() [10->15] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_0"}, 1, 0, #f, #f #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 20 20}, {basic-block #({tag 2:25}) 25 30}) bne {tag 2:25}, r0, 2 #() [20->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}) #() [20->25] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_1"}, 2, 0, #f, #f #({tag 2:25}) [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 30}, {basic-block #({tag 3:35}) 35 40}) bne {tag 3:35}, r0, 3 #() [30->30] (level:0) is #f with stack state #f #({basic-block #() 30 35}) #() [30->35] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_2"}, 3, 0, #f, #f #({tag 3:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 40 40}, {basic-block #({tag 4:45}) 45 80}) bne {tag 4:45}, r0, 4 #() [40->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}) #() [40->45] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_3"}, 4, 0, #f, #f #({tag 4:45}) [45->80] (level:0) is #f with stack state #f #({basic-block #() 80 85}, {basic-block #({tag 5:200}) 200 215}) sub N4/r21, r0, 1 add N4/r21, N4/r21, -4 asl N5/r21, N4/r21, 2 ld N1/r20, r1, N5/r21 ld N2/r23, N1/r20, 4 asr N2/r23, N2/r23, 2 beq {tag 5:200}, N2/r23, 0 #() [80->85] (level:0) is #f with stack state #f #({basic-block #() 85 175}, {basic-block #({tag 6:180}) 180 195}) beq {tag 6:180}, N2/r23, 1 #() [85->175] (level:0) is #f with stack state #f #({basic-block #() 175 180}) sub N2/r23, N2/r23, 1 asr N9/r18, N5/r21, 2 move N12/r23, N2/r23 asl N12/r23, N12/r23, 2 move N10/r19, r1 sub r1, r1, N12/r23 move r0, N9/r18 move N11/r23, r1 copy-words-down-w N11/r23, N10/r19, r0 rem "eliminated" ld N6/r23, N1/r20, 4 asr N6/r23, N6/r23, 2 add N1/r20, N1/r20, 8 asr N13/r19, N5/r21, 2 add r0, N6/r23, N13/r19 add r0, r0, 4 add N8/r21, r1, N5/r21 copy-words-down-w N8/r21, N1/r20, N6/r23 #() [175->180] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f #({tag 5:200}) [200->215] (level:0) is #f with stack state #f #({basic-block #() 215 220}) sub r0, r0, 1 save-return-address N5/r21 call-indirect r22, 4, 4 #() [215->220] (level:0) is #f with stack state #f #({basic-block #() 220 225}) restore-return-address #f #() [220->225] (level:0) is #f with stack state #f #() rts #({tag 6:180}) [180->195] (level:0) is #f with stack state #f #({basic-block #() 195 200}) ld N3/r20, N1/r20, 8 st N3/r20, r1, N5/r21 move r0, r0 #() [195->200] (level:0) is #f with stack state #f #() jmp-indirect r22, 4, 4, 0, #f, #f +++ ending code for apply_xep +++ +++ No Source Code Locators for apply_xep +++ +++ Exported function definition primitive_engine_node_apply_with_optionals +++ +++ starting code for primitive_engine_node_apply_with_optionals +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #({tag 3:45}) 45 65}) move r22, r3 move G2/r23, r4 move N0/r21, r5 move N1/r21, N0/r21 ld r0, N1/r21, 4 asr r0, r0, 2 add N3/r21, N1/r21, 8 push G2/r23 #({tag 3:45}) [45->65] (level:1) is #f with stack state #f #({basic-block #() 65 70}, {basic-block #({tag 2:70}) 70 95}) ld N4/r20, G2/r23, 0 ld N4/r20, N4/r20, 8 and N4/r20, N4/r20, 8192 beq {tag 2:70}, N4/r20, 0 #() [65->70] (level:1) is #f with stack state #f #({basic-block #({tag 3:45}) 45 65}) ld G2/r23, G2/r23, 20 #() [485->490] (level:0) is #f with stack state #f #() bra {tag 3:45} #({tag 2:70}) [70->95] (level:1) is #f with stack state #f #({basic-block #() 95 100}, {basic-block #({tag 1:280}) 280 285}) ld N4/r20, G2/r23, 8 ld N4/r20, N4/r20, 4 pop G2/r23 and N4/r20, N4/r20, 1310720 bne {tag 1:280}, N4/r20, 0 #() [95->100] (level:1) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 5:125}) 120 125}) beq {tag 5:125}, r0, 0 #() [100->105] (level:1) is #f with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 6:130}) 130 140}) beq {tag 6:130}, r0, 1 #() [105->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}, {basic-block #({tag 7:145}) 145 160}) beq {tag 7:145}, r0, 2 #() [110->115] (level:1) is #f with stack state #f #({basic-block #() 115 120}, {basic-block #({tag 8:165}) 165 185}) beq {tag 8:165}, r0, 3 #() [115->120] (level:1) is #f with stack state #f #({basic-block #({tag 4:220}) 220 275}, {basic-block #({tag 9:190}) 190 215}) beq {tag 9:190}, r0, 4 #({tag 4:220}) [220->275] (level:1) is #f with stack state #f #({basic-block #() 275 280}) sub r0, r0, 4 asl N7/r20, r0, 2 sub r1, r1, N7/r20 move N6/r20, r1 add N3/r21, N3/r21, 16 copy-words-down-w N6/r20, N3/r21, r0 move r23, G2/r23 ld r3, N3/r21, -16 ld r4, N3/r21, -12 ld r5, N3/r21, -8 ld r6, N3/r21, -4 #() [275->280] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 1:280}) [280->285] (level:1) is #f with stack state #f #({basic-block #() 285 290}, {basic-block #({tag 11:300}) 300 315}) beq {tag 11:300}, r0, 1 #() [285->290] (level:1) is #f with stack state #f #({basic-block #() 290 295}, {basic-block #({tag 12:320}) 320 340}) beq {tag 12:320}, r0, 2 #() [290->295] (level:1) is #f with stack state #f #({basic-block #() 295 300}, {basic-block #({tag 13:345}) 345 370}) beq {tag 13:345}, r0, 3 #() [295->300] (level:1) is #f with stack state #f #({basic-block #({tag 10:410}) 410 480}, {basic-block #({tag 14:375}) 375 405}) beq {tag 14:375}, r0, 4 #({tag 10:410}) [410->480] (level:1) is #f with stack state #f #({basic-block #() 480 485}) asl N10/r20, r0, 2 add N10/r20, N10/r20, -12 push N10/r20 sub r0, r0, 4 asl N11/r20, r0, 2 sub r1, r1, N11/r20 move N9/r20, r1 add N3/r21, N3/r21, 16 copy-words-down-w N9/r20, N3/r21, r0 move r23, G2/r23 ld r3, N3/r21, -16 ld r4, N3/r21, -12 ld r5, N3/r21, -8 ld r6, N3/r21, -4 #() [480->485] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:125}) [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 5:125}) 125 130}) move r23, G2/r23 #({tag 6:130}) [130->140] (level:1) is #f with stack state #f #({basic-block #() 140 145}) move r23, G2/r23 ld r3, N3/r21, 0 #() [140->145] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 7:145}) [145->160] (level:1) is #f with stack state #f #({basic-block #() 160 165}) move r23, G2/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 #() [160->165] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 8:165}) [165->185] (level:1) is #f with stack state #f #({basic-block #() 185 190}) move r23, G2/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 #() [185->190] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 9:190}) [190->215] (level:1) is #f with stack state #f #({basic-block #() 215 220}) move r23, G2/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 ld r6, N3/r21, 12 #() [215->220] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 11:300}) [300->315] (level:1) is #f with stack state #f #({basic-block #() 315 320}) push 4 move r23, G2/r23 ld r3, N3/r21, 0 #() [315->320] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 12:320}) [320->340] (level:1) is #f with stack state #f #({basic-block #() 340 345}) push 4 move r23, G2/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 #() [340->345] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 13:345}) [345->370] (level:1) is #f with stack state #f #({basic-block #() 370 375}) push 4 move r23, G2/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 #() [370->375] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 14:375}) [375->405] (level:1) is #f with stack state #f #({basic-block #() 405 410}) push 4 move r23, G2/r23 ld r3, N3/r21, 0 ld r4, N3/r21, 4 ld r5, N3/r21, 8 ld r6, N3/r21, 12 #() [405->410] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:125}) [125->130] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for primitive_engine_node_apply_with_optionals +++ +++ No Source Code Locators for primitive_engine_node_apply_with_optionals +++ +++ Exported function definition general_engine_node_1_entry +++ +++ starting code for general_engine_node_1_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}) move r4, r22 move r5, r23 ld N1/r22, r22, 8 #() [20->25] (level:0) is #f with stack state #f #() jmp N1/r22, 4, 0, #f, #f +++ ending code for general_engine_node_1_entry +++ +++ No Source Code Locators for general_engine_node_1_entry +++ +++ Exported function definition general_engine_node_2_entry +++ +++ starting code for general_engine_node_2_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}) move r5, r22 move r6, r23 ld N1/r22, r22, 8 #() [20->25] (level:0) is #f with stack state #f #() jmp N1/r22, 4, 0, #f, #f +++ ending code for general_engine_node_2_entry +++ +++ No Source Code Locators for general_engine_node_2_entry +++ +++ Exported function definition general_engine_node_3_entry +++ +++ starting code for general_engine_node_3_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move r6, r22 sub r1, r1, 4 st r23, r1, 0 ld N1/r22, r22, 8 #() [25->30] (level:0) is #f with stack state #f #() jmp N1/r22, 4, 0, #f, #f +++ ending code for general_engine_node_3_entry +++ +++ No Source Code Locators for general_engine_node_3_entry +++ +++ Exported function definition general_engine_node_n_0 +++ +++ starting code for general_engine_node_n_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) move G2/r22, r22 move G1/r23, r23 move G0/r3, G1/r23 #({tag 2:20}) [20->40] (level:1) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 90}) ld N3/r21, G0/r3, 0 ld N3/r21, N3/r21, 8 and N3/r21, N3/r21, 8192 beq {tag 1:45}, N3/r21, 0 #() [40->45] (level:1) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) ld G0/r3, G0/r3, 20 #() [100->105] (level:0) is #f with stack state #f #() bra {tag 2:20} #({tag 1:45}) [45->90] (level:1) is #f with stack state #f #({basic-block #() 90 95}) push 1 push {constant "KLsimple_object_vectorGVKdW"} move G0/r3, r1 preserve-registers-entry ld N6/r21, G2/r22, 8 move r3, G0/r3 move r4, G2/r22 move r5, G1/r23 call N6/r21, 3 #() [90->95] (level:1) is #f with stack state #f #({basic-block #() 95 100}) preserve-registers-exit #() [95->100] (level:1) is #f with stack state #f #() rts-and-drop 8 +++ ending code for general_engine_node_n_0 +++ +++ Live variable scopes for general_engine_node_n_0 +++ Start scope at 36 with frame for no variables End scope at 55 +++ No Source Code Locators for general_engine_node_n_0 +++ +++ Exported function definition general_engine_node_n_1 +++ +++ starting code for general_engine_node_n_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) move G2/r22, r22 move G1/r23, r23 move G0/r20, G1/r23 #({tag 2:20}) [20->40] (level:1) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 100}) ld N3/r21, G0/r20, 0 ld N3/r21, N3/r21, 8 and N3/r21, N3/r21, 8192 beq {tag 1:45}, N3/r21, 0 #() [40->45] (level:1) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) ld G0/r20, G0/r20, 20 #() [110->115] (level:0) is #f with stack state #f #() bra {tag 2:20} #({tag 1:45}) [45->100] (level:1) is #f with stack state #f #({basic-block #() 100 105}) st r3, r1, -4 sub r1, r1, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G0/r20, r1 preserve-registers-entry ld N6/r21, G2/r22, 8 move r3, G0/r20 move r4, G2/r22 move r5, G1/r23 call N6/r21, 3 #() [100->105] (level:1) is #f with stack state #f #({basic-block #() 105 110}) preserve-registers-exit #() [105->110] (level:1) is #f with stack state #f #() rts-and-drop 12 +++ ending code for general_engine_node_n_1 +++ +++ Live variable scopes for general_engine_node_n_1 +++ Start scope at 40 with frame for no variables End scope at 61 +++ No Source Code Locators for general_engine_node_n_1 +++ +++ Exported function definition general_engine_node_n_2 +++ +++ starting code for general_engine_node_n_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) move G2/r22, r22 move G1/r23, r23 move G0/r20, G1/r23 #({tag 2:20}) [20->40] (level:1) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 105}) ld N3/r21, G0/r20, 0 ld N3/r21, N3/r21, 8 and N3/r21, N3/r21, 8192 beq {tag 1:45}, N3/r21, 0 #() [40->45] (level:1) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) ld G0/r20, G0/r20, 20 #() [115->120] (level:0) is #f with stack state #f #() bra {tag 2:20} #({tag 1:45}) [45->105] (level:1) is #f with stack state #f #({basic-block #() 105 110}) st r4, r1, -4 st r3, r1, -8 sub r1, r1, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G0/r20, r1 preserve-registers-entry ld N6/r21, G2/r22, 8 move r3, G0/r20 move r4, G2/r22 move r5, G1/r23 call N6/r21, 3 #() [105->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}) preserve-registers-exit #() [110->115] (level:1) is #f with stack state #f #() rts-and-drop 16 +++ ending code for general_engine_node_n_2 +++ +++ Live variable scopes for general_engine_node_n_2 +++ Start scope at 42 with frame for no variables End scope at 63 +++ No Source Code Locators for general_engine_node_n_2 +++ +++ Exported function definition general_engine_node_n_3 +++ +++ starting code for general_engine_node_n_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) move G2/r22, r22 move G1/r23, r23 move G0/r20, G1/r23 #({tag 2:20}) [20->40] (level:1) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 110}) ld N3/r21, G0/r20, 0 ld N3/r21, N3/r21, 8 and N3/r21, N3/r21, 8192 beq {tag 1:45}, N3/r21, 0 #() [40->45] (level:1) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) ld G0/r20, G0/r20, 20 #() [120->125] (level:0) is #f with stack state #f #() bra {tag 2:20} #({tag 1:45}) [45->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}) st r5, r1, -4 st r4, r1, -8 st r3, r1, -12 sub r1, r1, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G0/r20, r1 preserve-registers-entry ld N6/r21, G2/r22, 8 move r3, G0/r20 move r4, G2/r22 move r5, G1/r23 call N6/r21, 3 #() [110->115] (level:1) is #f with stack state #f #({basic-block #() 115 120}) preserve-registers-exit #() [115->120] (level:1) is #f with stack state #f #() rts-and-drop 20 +++ ending code for general_engine_node_n_3 +++ +++ Live variable scopes for general_engine_node_n_3 +++ Start scope at 44 with frame for no variables End scope at 65 +++ No Source Code Locators for general_engine_node_n_3 +++ +++ Exported function definition general_engine_node_n +++ +++ starting code for general_engine_node_n +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) move G2/r22, r22 move G1/r23, r23 move G0/r21, G1/r23 #({tag 2:20}) [20->40] (level:1) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 70}) ld N3/r20, G0/r21, 0 ld N3/r20, N3/r20, 8 and N3/r20, N3/r20, 8192 beq {tag 1:45}, N3/r20, 0 #() [40->45] (level:1) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) ld G0/r21, G0/r21, 20 #() [225->230] (level:0) is #f with stack state #f #() bra {tag 2:20} #({tag 1:45}) [45->70] (level:1) is #f with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 3:85}) 85 110}) ld N4/r21, G0/r21, 8 ld N4/r21, N4/r21, 4 and N4/r21, N4/r21, 1020 asr N6/r20, N4/r21, 2 bgt {tag 3:85}, N6/r20, 3 #() [70->75] (level:1) is #f with stack state #f #({basic-block #() 75 80}, {basic-block #({tag 4:110}) 110 130}) bgt {tag 4:110}, N6/r20, 2 #() [75->80] (level:1) is #f with stack state #f #({basic-block #() 80 85}, {basic-block #({tag 5:130}) 130 145}) bgt {tag 5:130}, N6/r20, 1 #() [80->85] (level:1) is #f with stack state #f #({basic-block #({tag 7:155}) 155 205}, {basic-block #({tag 6:145}) 145 155}) bgt {tag 6:145}, N6/r20, 0 #({tag 7:155}) [155->205] (level:1) is #f with stack state #f #({basic-block #() 205 220}) add G7/r21, N4/r21, 1 push G7/r21 push {constant "KLsimple_object_vectorGVKdW"} move G0/r21, r1 preserve-registers-entry ld N8/r20, G2/r22, 8 move r3, G0/r21 move r4, G2/r22 move r5, G1/r23 call N8/r20, 3 #() [205->220] (level:1) is #f with stack state #f #({basic-block #() 220 225}) preserve-registers-exit ld G9/r21, r1, 4 add N10/r21, G9/r21, 7 #() [220->225] (level:1) is #f with stack state #f #() rts-and-drop N10/r21 #({tag 3:85}) [85->110] (level:1) is #f with stack state #f #({basic-block #({tag 7:155}) 155 205}) st r6, r1, -4 st r5, r1, -8 st r4, r1, -12 st r3, r1, -16 sub r1, r1, 16 #() [230->235] (level:0) is #f with stack state #f #() bra {tag 7:155} #({tag 4:110}) [110->130] (level:1) is #f with stack state #f #({basic-block #({tag 7:155}) 155 205}) st r5, r1, -4 st r4, r1, -8 st r3, r1, -12 sub r1, r1, 12 #() [235->240] (level:0) is #f with stack state #f #() bra {tag 7:155} #({tag 5:130}) [130->145] (level:1) is #f with stack state #f #({basic-block #({tag 7:155}) 155 205}) st r4, r1, -4 st r3, r1, -8 sub r1, r1, 8 #() [240->245] (level:0) is #f with stack state #f #() bra {tag 7:155} #({tag 6:145}) [145->155] (level:1) is #f with stack state #f #({basic-block #({tag 7:155}) 155 205}) st r3, r1, -4 sub r1, r1, 4 #() [245->250] (level:0) is #f with stack state #f #() bra {tag 7:155} +++ ending code for general_engine_node_n +++ +++ Live variable scopes for general_engine_node_n +++ Start scope at 60 with frame for no variables End scope at 81 +++ No Source Code Locators for general_engine_node_n +++ +++ Exported function definition general_engine_node_n_optionals_0 +++ +++ starting code for general_engine_node_n_optionals_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #() 85 95}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 sub r1, r1, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G3/r3, r3 st G3/r3, r1, 8 move G2/r3, r1 ld G0/r23, r30, -4 ld N4/r21, G1/r22, 8 move r3, G2/r3 move r4, G1/r22 move r5, G0/r23 call N4/r21, 3 #() [85->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) preserve-registers-exit load-stack-arg-n #t, N5/r21, 0 #() [95->100] (level:0) is #f with stack state #f #() rts-and-drop N5/r21 +++ ending code for general_engine_node_n_optionals_0 +++ +++ Live variable scopes for general_engine_node_n_optionals_0 +++ Start scope at 8 with frame for no variables End scope at 47 +++ No Source Code Locators for general_engine_node_n_optionals_0 +++ +++ Exported function definition general_engine_node_n_optionals_1 +++ +++ starting code for general_engine_node_n_optionals_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 95}) rem "This is a dummy first basic block." #() [5->95] (level:0) is #f with stack state #f #({basic-block #() 95 105}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 sub r1, r1, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G3/r3, r3 st G3/r3, r1, 8 move G4/r4, r4 st G4/r4, r1, 12 move G2/r3, r1 ld G0/r23, r30, -4 ld N5/r21, G1/r22, 8 move r3, G2/r3 move r4, G1/r22 move r5, G0/r23 call N5/r21, 3 #() [95->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) preserve-registers-exit load-stack-arg-n #t, N6/r21, 0 #() [105->110] (level:0) is #f with stack state #f #() rts-and-drop N6/r21 +++ ending code for general_engine_node_n_optionals_1 +++ +++ Live variable scopes for general_engine_node_n_optionals_1 +++ Start scope at 8 with frame for no variables End scope at 49 +++ No Source Code Locators for general_engine_node_n_optionals_1 +++ +++ Exported function definition general_engine_node_n_optionals_2 +++ +++ starting code for general_engine_node_n_optionals_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 105}) rem "This is a dummy first basic block." #() [5->105] (level:0) is #f with stack state #f #({basic-block #() 105 115}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 sub r1, r1, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G3/r3, r3 st G3/r3, r1, 8 move G4/r4, r4 st G4/r4, r1, 12 move G5/r5, r5 st G5/r5, r1, 16 move G2/r3, r1 ld G0/r23, r30, -4 ld N6/r21, G1/r22, 8 move r3, G2/r3 move r4, G1/r22 move r5, G0/r23 call N6/r21, 3 #() [105->115] (level:0) is #f with stack state #f #({basic-block #() 115 120}) preserve-registers-exit load-stack-arg-n #t, N7/r21, 0 #() [115->120] (level:0) is #f with stack state #f #() rts-and-drop N7/r21 +++ ending code for general_engine_node_n_optionals_2 +++ +++ Live variable scopes for general_engine_node_n_optionals_2 +++ Start scope at 8 with frame for no variables End scope at 51 +++ No Source Code Locators for general_engine_node_n_optionals_2 +++ +++ Exported function definition general_engine_node_n_optionals_3 +++ +++ starting code for general_engine_node_n_optionals_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 115}) rem "This is a dummy first basic block." #() [5->115] (level:0) is #f with stack state #f #({basic-block #() 115 125}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 sub r1, r1, 16 push 17 push {constant "KLsimple_object_vectorGVKdW"} move G3/r3, r3 st G3/r3, r1, 8 move G4/r4, r4 st G4/r4, r1, 12 move G5/r5, r5 st G5/r5, r1, 16 move G6/r6, r6 st G6/r6, r1, 20 move G2/r3, r1 ld G0/r23, r30, -4 ld N7/r21, G1/r22, 8 move r3, G2/r3 move r4, G1/r22 move r5, G0/r23 call N7/r21, 3 #() [115->125] (level:0) is #f with stack state #f #({basic-block #() 125 130}) preserve-registers-exit load-stack-arg-n #t, N8/r21, 0 #() [125->130] (level:0) is #f with stack state #f #() rts-and-drop N8/r21 +++ ending code for general_engine_node_n_optionals_3 +++ +++ Live variable scopes for general_engine_node_n_optionals_3 +++ Start scope at 8 with frame for no variables End scope at 53 +++ No Source Code Locators for general_engine_node_n_optionals_3 +++ +++ Exported function definition general_engine_node_n_optionals +++ +++ starting code for general_engine_node_n_optionals +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #({tag 2:30}) 30 50}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 move G0/r23, G0/r23 #({tag 2:30}) [30->50] (level:1) is #f with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 1:55}) 55 250}) ld N4/r21, G0/r23, 0 ld N4/r21, N4/r21, 8 and N4/r21, N4/r21, 8192 beq {tag 1:55}, N4/r21, 0 #() [50->55] (level:1) is #f with stack state #f #({basic-block #({tag 2:30}) 30 50}) ld G0/r23, G0/r23, 20 #() [275->280] (level:0) is #f with stack state #f #() bra {tag 2:30} #({tag 1:55}) [55->250] (level:1) is #f with stack state #f #({basic-block #() 250 270}) ld N3/r21, G0/r23, 8 ld N3/r21, N3/r21, 4 and N3/r21, N3/r21, 1020 pop G0/r23 preserve-registers-exit preserve-registers-entry push G0/r23 push G1/r22 add N5/r23, N3/r21, 4 sub r1, r1, N5/r23 add G6/r23, N5/r23, 1 push G6/r23 push {constant "KLsimple_object_vectorGVKdW"} move G7/r3, r3 st G7/r3, r1, 8 move G8/r4, r4 st G8/r4, r1, 12 move G9/r5, r5 st G9/r5, r1, 16 move G10/r6, r6 st G10/r6, r1, 20 add N11/r20, r30, 8 add N12/r22, r1, 24 asr N13/r23, N3/r21, 2 sub N13/r23, N13/r23, 4 copy-words-down-w N12/r22, N11/r20, N13/r23 add N15/r23, N3/r21, -8 ld G14/r22, r30, N15/r23 add N16/r23, N3/r21, 8 st G14/r22, r1, N16/r23 move G2/r3, r1 push N3/r21 ld G1/r22, r30, -8 ld G0/r23, r30, -4 ld N17/r21, G1/r22, 8 move r3, G2/r3 move r4, G1/r22 move r5, G0/r23 call N17/r21, 3 #() [250->270] (level:1) is #f with stack state #f #({basic-block #() 270 275}) pop N3/r21 preserve-registers-exit add N19/r21, N3/r21, -12 ld N18/r21, r1, N19/r21 #() [270->275] (level:1) is #f with stack state #f #() rts-and-drop N18/r21 +++ ending code for general_engine_node_n_optionals +++ +++ Live variable scopes for general_engine_node_n_optionals +++ Start scope at 8 with frame for no variables End scope at 33 Start scope at 34 no frame for no variables End scope at 49 Start scope at 50 with frame for no variables End scope at 139 +++ No Source Code Locators for general_engine_node_n_optionals +++ +++ Exported function definition general_engine_node_spread_optionals_0 +++ +++ starting code for general_engine_node_spread_optionals_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 70}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 move G2/r3, r3 ld G0/r23, r30, -4 ld N3/r21, G1/r22, 8 move r3, G2/r3 move r4, G1/r22 move r5, G0/r23 call N3/r21, 3 #() [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit load-stack-arg-n #t, N4/r21, 0 #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop N4/r21 +++ ending code for general_engine_node_spread_optionals_0 +++ +++ Live variable scopes for general_engine_node_spread_optionals_0 +++ Start scope at 8 with frame for no variables End scope at 31 +++ No Source Code Locators for general_engine_node_spread_optionals_0 +++ +++ Exported function definition general_engine_node_spread_optionals_1 +++ +++ starting code for general_engine_node_spread_optionals_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 70}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 move G2/r4, r4 ld G0/r23, r30, -4 ld N3/r21, G1/r22, 8 move r3, G2/r4 move r4, G1/r22 move r5, G0/r23 call N3/r21, 3 #() [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit load-stack-arg-n #t, N4/r21, 0 #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop N4/r21 +++ ending code for general_engine_node_spread_optionals_1 +++ +++ Live variable scopes for general_engine_node_spread_optionals_1 +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for general_engine_node_spread_optionals_1 +++ +++ Exported function definition general_engine_node_spread_optionals_2 +++ +++ starting code for general_engine_node_spread_optionals_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 70}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 move G2/r5, r5 ld G0/r23, r30, -4 ld N3/r21, G1/r22, 8 move r3, G2/r5 move r4, G1/r22 move r5, G0/r23 call N3/r21, 3 #() [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit load-stack-arg-n #t, N4/r21, 0 #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop N4/r21 +++ ending code for general_engine_node_spread_optionals_2 +++ +++ Live variable scopes for general_engine_node_spread_optionals_2 +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for general_engine_node_spread_optionals_2 +++ +++ Exported function definition general_engine_node_spread_optionals_3 +++ +++ starting code for general_engine_node_spread_optionals_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 70}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 move G2/r6, r6 ld G0/r23, r30, -4 ld N3/r21, G1/r22, 8 move r3, G2/r6 move r4, G1/r22 move r5, G0/r23 call N3/r21, 3 #() [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit load-stack-arg-n #t, N4/r21, 0 #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop N4/r21 +++ ending code for general_engine_node_spread_optionals_3 +++ +++ Live variable scopes for general_engine_node_spread_optionals_3 +++ Start scope at 8 with frame for no variables End scope at 33 +++ No Source Code Locators for general_engine_node_spread_optionals_3 +++ +++ Exported function definition general_engine_node_spread_optionals +++ +++ starting code for general_engine_node_spread_optionals +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #({tag 2:30}) 30 50}) move G1/r22, r22 move G0/r23, r23 preserve-registers-entry push G0/r23 move G0/r23, G0/r23 #({tag 2:30}) [30->50] (level:1) is #f with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 1:55}) 55 295}) ld N4/r21, G0/r23, 0 ld N4/r21, N4/r21, 8 and N4/r21, N4/r21, 8192 beq {tag 1:55}, N4/r21, 0 #() [50->55] (level:1) is #f with stack state #f #({basic-block #({tag 2:30}) 30 50}) ld G0/r23, G0/r23, 20 #() [320->325] (level:0) is #f with stack state #f #() bra {tag 2:30} #({tag 1:55}) [55->295] (level:1) is #f with stack state #f #({basic-block #() 295 315}) ld N3/r21, G0/r23, 8 ld N3/r21, N3/r21, 4 and N3/r21, N3/r21, 1020 pop G0/r23 preserve-registers-exit preserve-registers-entry push G0/r23 push G1/r22 add N8/r23, N3/r21, -8 ld G5/r23, r30, N8/r23 ld N6/r23, G5/r23, 4 sub N6/r23, N6/r23, 1 sub r1, r1, N6/r23 add N7/r23, N6/r23, N3/r21 sub r1, r1, N3/r21 add G9/r23, N7/r23, 1 push G9/r23 push {constant "KLsimple_object_vectorGVKdW"} move G10/r3, r3 st G10/r3, r1, 8 move G11/r4, r4 st G11/r4, r1, 12 move G12/r5, r5 st G12/r5, r1, 16 move G13/r6, r6 st G13/r6, r1, 20 add N14/r20, r30, 8 add N15/r22, r1, 24 asr N16/r23, N3/r21, 2 sub N16/r23, N16/r23, 4 copy-words-down-w N15/r22, N14/r20, N16/r23 add N21/r22, N3/r21, -8 ld G17/r22, r30, N21/r22 ld N19/r23, G17/r22, 4 asr N19/r23, N19/r23, 2 add N20/r20, G17/r22, 8 add N18/r22, r1, 8 add N18/r22, N18/r22, N3/r21 copy-words-down-w N18/r22, N20/r20, N19/r23 move G2/r3, r1 push N3/r21 ld G1/r22, r30, -8 ld G0/r23, r30, -4 ld N22/r21, G1/r22, 8 move r3, G2/r3 move r4, G1/r22 move r5, G0/r23 call N22/r21, 3 #() [295->315] (level:1) is #f with stack state #f #({basic-block #() 315 320}) pop N3/r21 preserve-registers-exit add N24/r21, N3/r21, -12 ld N23/r21, r1, N24/r21 #() [315->320] (level:1) is #f with stack state #f #() rts-and-drop N23/r21 +++ ending code for general_engine_node_spread_optionals +++ +++ Live variable scopes for general_engine_node_spread_optionals +++ Start scope at 8 with frame for no variables End scope at 33 Start scope at 34 no frame for no variables End scope at 49 Start scope at 50 with frame for no variables End scope at 171 +++ No Source Code Locators for general_engine_node_spread_optionals +++ +++ Exported function definition boxed_instance_slot_getter_entry +++ +++ starting code for boxed_instance_slot_getter_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 1:45}) 45 80}) move G2/r3, r3 ld N3/r22, r22, 8 add N3/r22, N3/r22, 3 ld G0/r23, G2/r3, N3/r22 beq {tag 1:45}, G0/r23, {constant "KPunboundVKi"} #() [30->35] (level:0) is #f with stack state #f #({basic-block #({tag 2:35}) 35 40}) move r3, G0/r23 #({tag 2:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}) reset-values #() [40->45] (level:0) is #f with stack state #f #() rts-and-drop 0 #({tag 1:45}) [45->80] (level:0) is #f with stack state #f #({basic-block #({tag 2:35}) 35 40}) asr N4/r22, N3/r22, 2 sub N4/r22, N4/r22, 1 asl G1/r4, N4/r22, 2 add G1/r4, G1/r4, 1 move r3, G2/r3 move r4, G1/r4 call {constant "Kunbound_instance_slotVKeI"}, 2 #() [80->85] (level:0) is #f with stack state #f #() bra {tag 2:35} +++ ending code for boxed_instance_slot_getter_entry +++ +++ No Source Code Locators for boxed_instance_slot_getter_entry +++ +++ Exported function definition boxed_instance_slot_setter_entry +++ +++ starting code for boxed_instance_slot_setter_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}) move G0/r3, r3 move G1/r4, r4 ld N2/r22, r22, 8 add N2/r22, N2/r22, 3 st G0/r3, G1/r4, N2/r22 move r3, G0/r3 reset-values #() [40->45] (level:0) is #f with stack state #f #() rts-and-drop 0 +++ ending code for boxed_instance_slot_setter_entry +++ +++ No Source Code Locators for boxed_instance_slot_setter_entry +++ +++ Exported function definition boxed_repeated_instance_slot_getter_entry +++ +++ starting code for boxed_repeated_instance_slot_getter_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:75}) 75 90}) move G2/r3, r3 move G3/r4, r4 ld N4/r22, r22, 8 add N4/r22, N4/r22, 3 add N6/r22, G2/r3, N4/r22 ld G0/r23, N6/r22, -4 blt {tag 1:75}, G3/r4, 0 #() [40->45] (level:0) is #f with stack state #f #({basic-block #() 45 60}, {basic-block #({tag 1:75}) 75 90}) bge {tag 1:75}, G3/r4, G0/r23 #() [45->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 2:90}) 90 105}) and N5/r23, G3/r4, -4 ld G1/r22, N6/r22, N5/r23 beq {tag 2:90}, G1/r22, {constant "KPunboundVKi"} #() [60->65] (level:0) is #f with stack state #f #({basic-block #({tag 3:65}) 65 70}) move r3, G1/r22 #({tag 3:65}) [65->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) reset-values #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop 0 #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:65}) 65 70}) move r3, G2/r3 move r4, G3/r4 call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 2 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 3:65} #({tag 2:90}) [90->105] (level:0) is #f with stack state #f #({basic-block #({tag 3:65}) 65 70}) move r3, G2/r3 move r4, G3/r4 call {constant "Kunbound_repeated_slotVKeI"}, 2 #() [110->115] (level:0) is #f with stack state #f #() bra {tag 3:65} +++ ending code for boxed_repeated_instance_slot_getter_entry +++ +++ No Source Code Locators for boxed_repeated_instance_slot_getter_entry +++ +++ Exported function definition boxed_repeated_instance_slot_setter_entry +++ +++ starting code for boxed_repeated_instance_slot_setter_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 1:75}) 75 90}) move G1/r3, r3 move G2/r4, r4 move G3/r5, r5 ld N4/r22, r22, 8 add N4/r22, N4/r22, 3 add N6/r22, G2/r4, N4/r22 ld G0/r23, N6/r22, -4 blt {tag 1:75}, G3/r5, 0 #() [45->50] (level:0) is #f with stack state #f #({basic-block #() 50 65}, {basic-block #({tag 1:75}) 75 90}) bge {tag 1:75}, G3/r5, G0/r23 #() [50->65] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) and N5/r5, G3/r5, -4 st G1/r3, N6/r22, N5/r5 move r3, G1/r3 #({tag 2:65}) [65->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) reset-values #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop 0 #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) move r3, G2/r4 move r4, G3/r5 call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 2 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 2:65} +++ ending code for boxed_repeated_instance_slot_setter_entry +++ +++ No Source Code Locators for boxed_repeated_instance_slot_setter_entry +++ +++ Exported function definition raw_byte_repeated_instance_slot_getter_entry +++ +++ starting code for raw_byte_repeated_instance_slot_getter_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:75}) 75 90}) move G1/r3, r3 move G2/r4, r4 ld N3/r22, r22, 8 add N3/r22, N3/r22, 3 add N6/r22, G1/r3, N3/r22 ld G0/r23, N6/r22, -4 blt {tag 1:75}, G2/r4, 0 #() [40->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}, {basic-block #({tag 1:75}) 75 90}) bge {tag 1:75}, G2/r4, G0/r23 #() [45->65] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) asr N5/r4, G2/r4, 2 ldb N4/r3, N6/r22, N5/r4 asl r3, N4/r3, 2 add r3, r3, 2 #({tag 2:65}) [65->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) reset-values #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop 0 #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) move r3, G1/r3 move r4, G2/r4 call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 2 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 2:65} +++ ending code for raw_byte_repeated_instance_slot_getter_entry +++ +++ No Source Code Locators for raw_byte_repeated_instance_slot_getter_entry +++ +++ Exported function definition raw_byte_repeated_instance_slot_setter_entry +++ +++ starting code for raw_byte_repeated_instance_slot_setter_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 1:80}) 80 95}) move G1/r3, r3 move G2/r4, r4 move G3/r5, r5 ld N4/r22, r22, 8 add N4/r22, N4/r22, 3 add N7/r22, G2/r4, N4/r22 ld G0/r23, N7/r22, -4 blt {tag 1:80}, G3/r5, 0 #() [45->50] (level:0) is #f with stack state #f #({basic-block #() 50 70}, {basic-block #({tag 1:80}) 80 95}) bge {tag 1:80}, G3/r5, G0/r23 #() [50->70] (level:0) is #f with stack state #f #({basic-block #({tag 2:70}) 70 75}) asr N5/r23, G1/r3, 2 asr N6/r5, G3/r5, 2 stb N5/r23, N7/r22, N6/r5 move r3, G1/r3 #({tag 2:70}) [70->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) reset-values #() [75->80] (level:0) is #f with stack state #f #() rts-and-drop 0 #({tag 1:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #({tag 2:70}) 70 75}) move r3, G2/r4 move r4, G3/r5 call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 2 #() [95->100] (level:0) is #f with stack state #f #() bra {tag 2:70} +++ ending code for raw_byte_repeated_instance_slot_setter_entry +++ +++ No Source Code Locators for raw_byte_repeated_instance_slot_setter_entry +++ +++ Exported function definition single_method_entry +++ +++ starting code for single_method_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G0/r22, r22 rem "eliminated" ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [35->40] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for single_method_entry +++ +++ No Source Code Locators for single_method_entry +++ +++ Exported function definition unrestricted_keyed_single_method_entry_0 +++ +++ starting code for unrestricted_keyed_single_method_entry_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 95}, {basic-block #({tag 1:110}) 110 130}) move G0/r22, r22 move G1/r23, r23 move N2/r21, r3 ld N3/r21, N2/r21, 4 nbit {tag 1:110}, N3/r21, 4, 0 #() [30->95] (level:0) is #f with stack state #f #({basic-block #() 95 105}) preserve-registers-entry push G1/r23 sub r1, r1, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G5/r3, r3 st G5/r3, r1, 8 move G4/r3, r1 ld G1/r23, r30, -4 move r3, G4/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [95->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) preserve-registers-exit load-stack-arg-n #t, N6/r21, 0 #() [105->110] (level:0) is #f with stack state #f #() rts-and-drop N6/r21 #({tag 1:110}) [110->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [130->135] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry_0 +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry_0 +++ Start scope at 16 with frame for no variables End scope at 57 +++ No Source Code Locators for unrestricted_keyed_single_method_entry_0 +++ +++ Exported function definition unrestricted_keyed_single_method_entry_1 +++ +++ starting code for unrestricted_keyed_single_method_entry_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 105}, {basic-block #({tag 1:120}) 120 140}) move G0/r22, r22 move G1/r23, r23 move N2/r21, r4 ld N3/r21, N2/r21, 4 nbit {tag 1:120}, N3/r21, 4, 0 #() [30->105] (level:0) is #f with stack state #f #({basic-block #() 105 115}) preserve-registers-entry push G1/r23 sub r1, r1, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G5/r3, r3 st G5/r3, r1, 8 move G6/r4, r4 st G6/r4, r1, 12 move G4/r3, r1 ld G1/r23, r30, -4 move r3, G4/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [105->115] (level:0) is #f with stack state #f #({basic-block #() 115 120}) preserve-registers-exit load-stack-arg-n #t, N7/r21, 0 #() [115->120] (level:0) is #f with stack state #f #() rts-and-drop N7/r21 #({tag 1:120}) [120->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [140->145] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry_1 +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry_1 +++ Start scope at 16 with frame for no variables End scope at 59 +++ No Source Code Locators for unrestricted_keyed_single_method_entry_1 +++ +++ Exported function definition unrestricted_keyed_single_method_entry_2 +++ +++ starting code for unrestricted_keyed_single_method_entry_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 115}, {basic-block #({tag 1:130}) 130 150}) move G0/r22, r22 move G1/r23, r23 move N2/r21, r5 ld N3/r21, N2/r21, 4 nbit {tag 1:130}, N3/r21, 4, 0 #() [30->115] (level:0) is #f with stack state #f #({basic-block #() 115 125}) preserve-registers-entry push G1/r23 sub r1, r1, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G5/r3, r3 st G5/r3, r1, 8 move G6/r4, r4 st G6/r4, r1, 12 move G7/r5, r5 st G7/r5, r1, 16 move G4/r3, r1 ld G1/r23, r30, -4 move r3, G4/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [115->125] (level:0) is #f with stack state #f #({basic-block #() 125 130}) preserve-registers-exit load-stack-arg-n #t, N8/r21, 0 #() [125->130] (level:0) is #f with stack state #f #() rts-and-drop N8/r21 #({tag 1:130}) [130->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [150->155] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry_2 +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry_2 +++ Start scope at 16 with frame for no variables End scope at 61 +++ No Source Code Locators for unrestricted_keyed_single_method_entry_2 +++ +++ Exported function definition unrestricted_keyed_single_method_entry_3 +++ +++ starting code for unrestricted_keyed_single_method_entry_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 125}, {basic-block #({tag 1:140}) 140 160}) move G0/r22, r22 move G1/r23, r23 move N2/r21, r6 ld N3/r21, N2/r21, 4 nbit {tag 1:140}, N3/r21, 4, 0 #() [30->125] (level:0) is #f with stack state #f #({basic-block #() 125 135}) preserve-registers-entry push G1/r23 sub r1, r1, 16 push 17 push {constant "KLsimple_object_vectorGVKdW"} move G5/r3, r3 st G5/r3, r1, 8 move G6/r4, r4 st G6/r4, r1, 12 move G7/r5, r5 st G7/r5, r1, 16 move G8/r6, r6 st G8/r6, r1, 20 move G4/r3, r1 ld G1/r23, r30, -4 move r3, G4/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [125->135] (level:0) is #f with stack state #f #({basic-block #() 135 140}) preserve-registers-exit load-stack-arg-n #t, N9/r21, 0 #() [135->140] (level:0) is #f with stack state #f #() rts-and-drop N9/r21 #({tag 1:140}) [140->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry_3 +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry_3 +++ Start scope at 16 with frame for no variables End scope at 63 +++ No Source Code Locators for unrestricted_keyed_single_method_entry_3 +++ +++ Exported function definition unrestricted_keyed_single_method_entry_4 +++ +++ starting code for unrestricted_keyed_single_method_entry_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 135}, {basic-block #({tag 1:150}) 150 170}) move G0/r22, r22 move G1/r23, r23 load-stack-arg-n #t, N2/r21, 0 ld N3/r21, N2/r21, 4 nbit {tag 1:150}, N3/r21, 4, 0 #() [30->135] (level:0) is #f with stack state #f #({basic-block #() 135 145}) preserve-registers-entry push G1/r23 sub r1, r1, 20 push 21 push {constant "KLsimple_object_vectorGVKdW"} move G5/r3, r3 st G5/r3, r1, 8 move G6/r4, r4 st G6/r4, r1, 12 move G7/r5, r5 st G7/r5, r1, 16 move G8/r6, r6 st G8/r6, r1, 20 ld G9/r23, r30, 8 st G9/r23, r1, 24 move G4/r3, r1 ld G1/r23, r30, -4 move r3, G4/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [135->145] (level:0) is #f with stack state #f #({basic-block #() 145 150}) preserve-registers-exit load-stack-arg-n #t, N10/r21, 1 #() [145->150] (level:0) is #f with stack state #f #() rts-and-drop N10/r21 #({tag 1:150}) [150->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [170->175] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry_4 +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry_4 +++ Start scope at 16 with frame for no variables End scope at 67 +++ No Source Code Locators for unrestricted_keyed_single_method_entry_4 +++ +++ Exported function definition unrestricted_keyed_single_method_entry_5 +++ +++ starting code for unrestricted_keyed_single_method_entry_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 145}, {basic-block #({tag 1:160}) 160 180}) move G0/r22, r22 move G1/r23, r23 load-stack-arg-n #t, N2/r21, 1 ld N3/r21, N2/r21, 4 nbit {tag 1:160}, N3/r21, 4, 0 #() [30->145] (level:0) is #f with stack state #f #({basic-block #() 145 155}) preserve-registers-entry push G1/r23 sub r1, r1, 24 push 25 push {constant "KLsimple_object_vectorGVKdW"} move G5/r3, r3 st G5/r3, r1, 8 move G6/r4, r4 st G6/r4, r1, 12 move G7/r5, r5 st G7/r5, r1, 16 move G8/r6, r6 st G8/r6, r1, 20 ld G9/r23, r30, 8 st G9/r23, r1, 24 ld G10/r23, r30, 12 st G10/r23, r1, 28 move G4/r3, r1 ld G1/r23, r30, -4 move r3, G4/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [145->155] (level:0) is #f with stack state #f #({basic-block #() 155 160}) preserve-registers-exit load-stack-arg-n #t, N11/r21, 2 #() [155->160] (level:0) is #f with stack state #f #() rts-and-drop N11/r21 #({tag 1:160}) [160->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry_5 +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry_5 +++ Start scope at 16 with frame for no variables End scope at 71 +++ No Source Code Locators for unrestricted_keyed_single_method_entry_5 +++ +++ Exported function definition unrestricted_keyed_single_method_entry +++ +++ starting code for unrestricted_keyed_single_method_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 50}) rem "This is a dummy first basic block." #() [5->50] (level:0) is #f with stack state #f #({basic-block #() 50 230}, {basic-block #({tag 1:255}) 255 275}) move G0/r22, r22 move G1/r23, r23 ld N4/r21, G0/r22, 4 asr N4/r21, N4/r21, 6 and N4/r21, N4/r21, 1020 add N5/r21, N4/r21, -16 ld N2/r21, r1, N5/r21 ld N3/r21, N2/r21, 4 nbit {tag 1:255}, N3/r21, 4, 0 #() [50->230] (level:0) is #f with stack state #f #({basic-block #() 230 250}) ld N7/r21, G0/r22, 4 asr N7/r21, N7/r21, 6 and N7/r21, N7/r21, 1020 preserve-registers-entry push G1/r23 push G0/r22 add N8/r23, N7/r21, 4 sub r1, r1, N8/r23 add G9/r23, N8/r23, 1 push G9/r23 push {constant "KLsimple_object_vectorGVKdW"} move G10/r3, r3 st G10/r3, r1, 8 move G11/r4, r4 st G11/r4, r1, 12 move G12/r5, r5 st G12/r5, r1, 16 move G13/r6, r6 st G13/r6, r1, 20 add N14/r20, r30, 8 add N15/r22, r1, 24 asr N16/r23, N7/r21, 2 sub N16/r23, N16/r23, 4 copy-words-down-w N15/r22, N14/r20, N16/r23 add N18/r23, N7/r21, -8 ld G17/r22, r30, N18/r23 add N19/r23, N7/r21, 8 st G17/r22, r1, N19/r23 move G6/r3, r1 push N7/r21 ld G0/r22, r30, -8 ld G1/r23, r30, -4 move r3, G6/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [230->250] (level:0) is #f with stack state #f #({basic-block #() 250 255}) pop N7/r21 preserve-registers-exit add N21/r21, N7/r21, -12 ld N20/r21, r1, N21/r21 #() [250->255] (level:0) is #f with stack state #f #() rts-and-drop N20/r21 #({tag 1:255}) [255->275] (level:0) is #f with stack state #f #({basic-block #() 275 280}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [275->280] (level:0) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry +++ Start scope at 30 with frame for no variables End scope at 121 +++ No Source Code Locators for unrestricted_keyed_single_method_entry +++ +++ Exported function definition explicit_keyed_single_method_entry_0 +++ +++ starting code for explicit_keyed_single_method_entry_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r3 ld G4/r21, G2/r21, 4 bit {tag 2:170}, G4/r21, 4, 0 #() [30->80] (level:0) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) move G3/r21, r3 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G7/r22, G0/r22, 24 ld N8/r23, r3, 4 sub N8/r23, N8/r23, 1 add N8/r23, N8/r23, r3 #({tag 6:80}) [80->85] (level:1) is #f with stack state #f #({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170}) ble {tag 7:150}, N8/r23, r3 #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld N6/r21, N8/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:105}) [105->110] (level:2) is #f with stack state #f #({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150}) ble {tag 5:130}, r30, G7/r22 #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N9/r20, r30, 4 beq {tag 9:125}, N9/r20, N6/r21 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub r30, r30, 4 #() [335->340] (level:0) is #f with stack state #f #() bra {tag 8:105} #({tag 2:170}) [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 3:175}) 175 235}) move N6/r21, 0 #({tag 3:175}) [175->235] (level:2) is #f with stack state #f #({basic-block #() 235 275}, {basic-block #({tag 11:275}) 275 295}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G11/r3, r3 st G11/r3, r1, 8 move G10/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:275}, N6/r21, 0 #() [235->275] (level:2) is #f with stack state #f #({basic-block #({tag 10:295}) 295 305}) ld G12/r20, G0/r22, 24 push {constant "KPfalseVKi"} push G12/r20 move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:295}) [295->305] (level:2) is #f with stack state #f #({basic-block #() 305 310}) preserve-registers-exit load-stack-arg-n #t, N13/r21, 0 #() [305->310] (level:2) is #f with stack state #f #() rts-and-drop N13/r21 #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:310}) 310 330}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:310}) [310->330] (level:1) is #f with stack state #f #({basic-block #() 330 335}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [330->335] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:130}) [130->150] (level:2) is #f with stack state #f #({basic-block #({tag 3:175}) 175 235}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [340->345] (level:0) is #f with stack state #f #() bra {tag 3:175} #({tag 9:125}) [125->130] (level:2) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) sub N8/r23, N8/r23, 8 #() [345->350] (level:0) is #f with stack state #f #() bra {tag 6:80} #({tag 11:275}) [275->295] (level:2) is #f with stack state #f #({basic-block #({tag 10:295}) 295 305}) move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [350->355] (level:0) is #f with stack state #f #() bra {tag 10:295} +++ ending code for explicit_keyed_single_method_entry_0 +++ +++ Live variable scopes for explicit_keyed_single_method_entry_0 +++ Start scope at 64 with frame for no variables End scope at 125 +++ No Source Code Locators for explicit_keyed_single_method_entry_0 +++ +++ Exported function definition explicit_keyed_single_method_entry_1 +++ +++ starting code for explicit_keyed_single_method_entry_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r4 ld G4/r21, G2/r21, 4 bit {tag 2:170}, G4/r21, 4, 0 #() [30->80] (level:0) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) move G3/r21, r4 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G7/r22, G0/r22, 24 ld N8/r23, r3, 4 sub N8/r23, N8/r23, 1 add N8/r23, N8/r23, r3 #({tag 6:80}) [80->85] (level:1) is #f with stack state #f #({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170}) ble {tag 7:150}, N8/r23, r3 #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld N6/r21, N8/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:105}) [105->110] (level:2) is #f with stack state #f #({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150}) ble {tag 5:130}, r30, G7/r22 #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N9/r20, r30, 4 beq {tag 9:125}, N9/r20, N6/r21 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub r30, r30, 4 #() [345->350] (level:0) is #f with stack state #f #() bra {tag 8:105} #({tag 2:170}) [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 3:175}) 175 245}) move N6/r21, 0 #({tag 3:175}) [175->245] (level:2) is #f with stack state #f #({basic-block #() 245 285}, {basic-block #({tag 11:285}) 285 305}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G11/r3, r3 st G11/r3, r1, 8 move G12/r4, r4 st G12/r4, r1, 12 move G10/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:285}, N6/r21, 0 #() [245->285] (level:2) is #f with stack state #f #({basic-block #({tag 10:305}) 305 315}) ld G13/r20, G0/r22, 24 push {constant "KPfalseVKi"} push G13/r20 move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:305}) [305->315] (level:2) is #f with stack state #f #({basic-block #() 315 320}) preserve-registers-exit load-stack-arg-n #t, N14/r21, 0 #() [315->320] (level:2) is #f with stack state #f #() rts-and-drop N14/r21 #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:320}) 320 340}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:320}) [320->340] (level:1) is #f with stack state #f #({basic-block #() 340 345}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [340->345] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:130}) [130->150] (level:2) is #f with stack state #f #({basic-block #({tag 3:175}) 175 245}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [350->355] (level:0) is #f with stack state #f #() bra {tag 3:175} #({tag 9:125}) [125->130] (level:2) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) sub N8/r23, N8/r23, 8 #() [355->360] (level:0) is #f with stack state #f #() bra {tag 6:80} #({tag 11:285}) [285->305] (level:2) is #f with stack state #f #({basic-block #({tag 10:305}) 305 315}) move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [360->365] (level:0) is #f with stack state #f #() bra {tag 10:305} +++ ending code for explicit_keyed_single_method_entry_1 +++ +++ Live variable scopes for explicit_keyed_single_method_entry_1 +++ Start scope at 64 with frame for no variables End scope at 127 +++ No Source Code Locators for explicit_keyed_single_method_entry_1 +++ +++ Exported function definition explicit_keyed_single_method_entry_2 +++ +++ starting code for explicit_keyed_single_method_entry_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r5 ld G4/r21, G2/r21, 4 bit {tag 2:170}, G4/r21, 4, 0 #() [30->80] (level:0) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) move G3/r21, r5 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G7/r22, G0/r22, 24 ld N8/r23, r3, 4 sub N8/r23, N8/r23, 1 add N8/r23, N8/r23, r3 #({tag 6:80}) [80->85] (level:1) is #f with stack state #f #({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170}) ble {tag 7:150}, N8/r23, r3 #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld N6/r21, N8/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:105}) [105->110] (level:2) is #f with stack state #f #({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150}) ble {tag 5:130}, r30, G7/r22 #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N9/r20, r30, 4 beq {tag 9:125}, N9/r20, N6/r21 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub r30, r30, 4 #() [355->360] (level:0) is #f with stack state #f #() bra {tag 8:105} #({tag 2:170}) [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 3:175}) 175 255}) move N6/r21, 0 #({tag 3:175}) [175->255] (level:2) is #f with stack state #f #({basic-block #() 255 295}, {basic-block #({tag 11:295}) 295 315}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G11/r3, r3 st G11/r3, r1, 8 move G12/r4, r4 st G12/r4, r1, 12 move G13/r5, r5 st G13/r5, r1, 16 move G10/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:295}, N6/r21, 0 #() [255->295] (level:2) is #f with stack state #f #({basic-block #({tag 10:315}) 315 325}) ld G14/r20, G0/r22, 24 push {constant "KPfalseVKi"} push G14/r20 move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:315}) [315->325] (level:2) is #f with stack state #f #({basic-block #() 325 330}) preserve-registers-exit load-stack-arg-n #t, N15/r21, 0 #() [325->330] (level:2) is #f with stack state #f #() rts-and-drop N15/r21 #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:330}) 330 350}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:330}) [330->350] (level:1) is #f with stack state #f #({basic-block #() 350 355}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [350->355] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:130}) [130->150] (level:2) is #f with stack state #f #({basic-block #({tag 3:175}) 175 255}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [360->365] (level:0) is #f with stack state #f #() bra {tag 3:175} #({tag 9:125}) [125->130] (level:2) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) sub N8/r23, N8/r23, 8 #() [365->370] (level:0) is #f with stack state #f #() bra {tag 6:80} #({tag 11:295}) [295->315] (level:2) is #f with stack state #f #({basic-block #({tag 10:315}) 315 325}) move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [370->375] (level:0) is #f with stack state #f #() bra {tag 10:315} +++ ending code for explicit_keyed_single_method_entry_2 +++ +++ Live variable scopes for explicit_keyed_single_method_entry_2 +++ Start scope at 64 with frame for no variables End scope at 129 +++ No Source Code Locators for explicit_keyed_single_method_entry_2 +++ +++ Exported function definition explicit_keyed_single_method_entry_3 +++ +++ starting code for explicit_keyed_single_method_entry_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r6 ld G4/r21, G2/r21, 4 bit {tag 2:170}, G4/r21, 4, 0 #() [30->80] (level:0) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) move G3/r21, r6 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G7/r22, G0/r22, 24 ld N8/r23, r3, 4 sub N8/r23, N8/r23, 1 add N8/r23, N8/r23, r3 #({tag 6:80}) [80->85] (level:1) is #f with stack state #f #({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170}) ble {tag 7:150}, N8/r23, r3 #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld N6/r21, N8/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:105}) [105->110] (level:2) is #f with stack state #f #({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150}) ble {tag 5:130}, r30, G7/r22 #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N9/r20, r30, 4 beq {tag 9:125}, N9/r20, N6/r21 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub r30, r30, 4 #() [365->370] (level:0) is #f with stack state #f #() bra {tag 8:105} #({tag 2:170}) [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 3:175}) 175 265}) move N6/r21, 0 #({tag 3:175}) [175->265] (level:2) is #f with stack state #f #({basic-block #() 265 305}, {basic-block #({tag 11:305}) 305 325}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 16 push 17 push {constant "KLsimple_object_vectorGVKdW"} move G11/r3, r3 st G11/r3, r1, 8 move G12/r4, r4 st G12/r4, r1, 12 move G13/r5, r5 st G13/r5, r1, 16 move G14/r6, r6 st G14/r6, r1, 20 move G10/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:305}, N6/r21, 0 #() [265->305] (level:2) is #f with stack state #f #({basic-block #({tag 10:325}) 325 335}) ld G15/r20, G0/r22, 24 push {constant "KPfalseVKi"} push G15/r20 move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:325}) [325->335] (level:2) is #f with stack state #f #({basic-block #() 335 340}) preserve-registers-exit load-stack-arg-n #t, N16/r21, 0 #() [335->340] (level:2) is #f with stack state #f #() rts-and-drop N16/r21 #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:340}) 340 360}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:340}) [340->360] (level:1) is #f with stack state #f #({basic-block #() 360 365}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [360->365] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:130}) [130->150] (level:2) is #f with stack state #f #({basic-block #({tag 3:175}) 175 265}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [370->375] (level:0) is #f with stack state #f #() bra {tag 3:175} #({tag 9:125}) [125->130] (level:2) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) sub N8/r23, N8/r23, 8 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 6:80} #({tag 11:305}) [305->325] (level:2) is #f with stack state #f #({basic-block #({tag 10:325}) 325 335}) move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 10:325} +++ ending code for explicit_keyed_single_method_entry_3 +++ +++ Live variable scopes for explicit_keyed_single_method_entry_3 +++ Start scope at 64 with frame for no variables End scope at 131 +++ No Source Code Locators for explicit_keyed_single_method_entry_3 +++ +++ Exported function definition explicit_keyed_single_method_entry_4 +++ +++ starting code for explicit_keyed_single_method_entry_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175}) move G0/r22, r22 move G1/r23, r23 load-stack-arg-n #t, G2/r21, 0 ld G4/r21, G2/r21, 4 bit {tag 2:170}, G4/r21, 4, 0 #() [30->80] (level:0) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) load-stack-arg-n #t, G3/r21, 0 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G7/r22, G0/r22, 24 ld N8/r23, r3, 4 sub N8/r23, N8/r23, 1 add N8/r23, N8/r23, r3 #({tag 6:80}) [80->85] (level:1) is #f with stack state #f #({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170}) ble {tag 7:150}, N8/r23, r3 #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld N6/r21, N8/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:105}) [105->110] (level:2) is #f with stack state #f #({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150}) ble {tag 5:130}, r30, G7/r22 #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N9/r20, r30, 4 beq {tag 9:125}, N9/r20, N6/r21 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub r30, r30, 4 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 8:105} #({tag 2:170}) [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 3:175}) 175 275}) move N6/r21, 0 #({tag 3:175}) [175->275] (level:2) is #f with stack state #f #({basic-block #() 275 315}, {basic-block #({tag 11:315}) 315 335}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 20 push 21 push {constant "KLsimple_object_vectorGVKdW"} move G11/r3, r3 st G11/r3, r1, 8 move G12/r4, r4 st G12/r4, r1, 12 move G13/r5, r5 st G13/r5, r1, 16 move G14/r6, r6 st G14/r6, r1, 20 ld G15/r23, r30, 8 st G15/r23, r1, 24 move G10/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:315}, N6/r21, 0 #() [275->315] (level:2) is #f with stack state #f #({basic-block #({tag 10:335}) 335 345}) ld G16/r20, G0/r22, 24 push {constant "KPfalseVKi"} push G16/r20 move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:335}) [335->345] (level:2) is #f with stack state #f #({basic-block #() 345 350}) preserve-registers-exit load-stack-arg-n #t, N17/r21, 1 #() [345->350] (level:2) is #f with stack state #f #() rts-and-drop N17/r21 #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:350}) 350 370}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:350}) [350->370] (level:1) is #f with stack state #f #({basic-block #() 370 375}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [370->375] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:130}) [130->150] (level:2) is #f with stack state #f #({basic-block #({tag 3:175}) 175 275}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 3:175} #({tag 9:125}) [125->130] (level:2) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) sub N8/r23, N8/r23, 8 #() [385->390] (level:0) is #f with stack state #f #() bra {tag 6:80} #({tag 11:315}) [315->335] (level:2) is #f with stack state #f #({basic-block #({tag 10:335}) 335 345}) move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [390->395] (level:0) is #f with stack state #f #() bra {tag 10:335} +++ ending code for explicit_keyed_single_method_entry_4 +++ +++ Live variable scopes for explicit_keyed_single_method_entry_4 +++ Start scope at 64 with frame for no variables End scope at 135 +++ No Source Code Locators for explicit_keyed_single_method_entry_4 +++ +++ Exported function definition explicit_keyed_single_method_entry_5 +++ +++ starting code for explicit_keyed_single_method_entry_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 80}, {basic-block #({tag 2:170}) 170 175}) move G0/r22, r22 move G1/r23, r23 load-stack-arg-n #t, G2/r21, 1 ld G4/r21, G2/r21, 4 bit {tag 2:170}, G4/r21, 4, 0 #() [30->80] (level:0) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) load-stack-arg-n #t, G3/r21, 1 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G7/r22, G0/r22, 24 ld N8/r23, r3, 4 sub N8/r23, N8/r23, 1 add N8/r23, N8/r23, r3 #({tag 6:80}) [80->85] (level:1) is #f with stack state #f #({basic-block #() 85 105}, {basic-block #({tag 4:150}, {tag 7:150}) 150 170}) ble {tag 7:150}, N8/r23, r3 #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld N6/r21, N8/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:105}) [105->110] (level:2) is #f with stack state #f #({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 150}) ble {tag 5:130}, r30, G7/r22 #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N9/r20, r30, 4 beq {tag 9:125}, N9/r20, N6/r21 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub r30, r30, 4 #() [385->390] (level:0) is #f with stack state #f #() bra {tag 8:105} #({tag 2:170}) [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 3:175}) 175 285}) move N6/r21, 0 #({tag 3:175}) [175->285] (level:2) is #f with stack state #f #({basic-block #() 285 325}, {basic-block #({tag 11:325}) 325 345}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 24 push 25 push {constant "KLsimple_object_vectorGVKdW"} move G11/r3, r3 st G11/r3, r1, 8 move G12/r4, r4 st G12/r4, r1, 12 move G13/r5, r5 st G13/r5, r1, 16 move G14/r6, r6 st G14/r6, r1, 20 ld G15/r23, r30, 8 st G15/r23, r1, 24 ld G16/r23, r30, 12 st G16/r23, r1, 28 move G10/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:325}, N6/r21, 0 #() [285->325] (level:2) is #f with stack state #f #({basic-block #({tag 10:345}) 345 355}) ld G17/r20, G0/r22, 24 push {constant "KPfalseVKi"} push G17/r20 move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:345}) [345->355] (level:2) is #f with stack state #f #({basic-block #() 355 360}) preserve-registers-exit load-stack-arg-n #t, N18/r21, 2 #() [355->360] (level:2) is #f with stack state #f #() rts-and-drop N18/r21 #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:360}) 360 380}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:360}) [360->380] (level:1) is #f with stack state #f #({basic-block #() 380 385}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [380->385] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:130}) [130->150] (level:2) is #f with stack state #f #({basic-block #({tag 3:175}) 175 285}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [390->395] (level:0) is #f with stack state #f #() bra {tag 3:175} #({tag 9:125}) [125->130] (level:2) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) sub N8/r23, N8/r23, 8 #() [395->400] (level:0) is #f with stack state #f #() bra {tag 6:80} #({tag 11:325}) [325->345] (level:2) is #f with stack state #f #({basic-block #({tag 10:345}) 345 355}) move r3, G10/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [400->405] (level:0) is #f with stack state #f #() bra {tag 10:345} +++ ending code for explicit_keyed_single_method_entry_5 +++ +++ Live variable scopes for explicit_keyed_single_method_entry_5 +++ Start scope at 64 with frame for no variables End scope at 139 +++ No Source Code Locators for explicit_keyed_single_method_entry_5 +++ +++ Exported function definition explicit_keyed_single_method_entry +++ +++ starting code for explicit_keyed_single_method_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 130}, {basic-block #({tag 2:220}) 220 230}) move G0/r22, r22 move G1/r23, r23 move N5/r21, G0/r22 ld N7/r22, G0/r22, 4 asr N7/r22, N7/r22, 6 and N7/r22, N7/r22, 1020 add N8/r22, N7/r22, -16 ld G2/r22, r1, N8/r22 ld G4/r22, G2/r22, 4 bit {tag 2:220}, G4/r22, 4, 0 #() [55->130] (level:0) is #f with stack state #f #({basic-block #({tag 6:130}) 130 135}) move G0/r22, N5/r21 ld N9/r21, G0/r22, 4 asr N9/r21, N9/r21, 6 and N9/r21, N9/r21, 1020 add N10/r21, N9/r21, -16 ld G3/r21, r1, N10/r21 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G11/r22, G0/r22, 24 ld N12/r23, r3, 4 sub N12/r23, N12/r23, 1 add N12/r23, N12/r23, r3 #({tag 6:130}) [130->135] (level:1) is #f with stack state #f #({basic-block #() 135 155}, {basic-block #({tag 4:200}, {tag 7:200}) 200 220}) ble {tag 7:200}, N12/r23, r3 #() [135->155] (level:1) is #f with stack state #f #({basic-block #({tag 8:155}) 155 160}) ld N6/r20, N12/r23, 0 ld r30, G11/r22, 4 sub r30, r30, 1 add r30, r30, G11/r22 #({tag 8:155}) [155->160] (level:2) is #f with stack state #f #({basic-block #() 160 170}, {basic-block #({tag 5:180}) 180 200}) ble {tag 5:180}, r30, G11/r22 #() [160->170] (level:2) is #f with stack state #f #({basic-block #() 170 175}, {basic-block #({tag 9:175}) 175 180}) ld N13/r21, r30, 4 beq {tag 9:175}, N13/r21, N6/r20 #() [170->175] (level:1) is #f with stack state #f #({basic-block #({tag 8:155}) 155 160}) sub r30, r30, 4 #() [515->520] (level:0) is #f with stack state #f #() bra {tag 8:155} #({tag 2:220}) [220->230] (level:0) is #f with stack state #f #({basic-block #({tag 3:230}) 230 405}) move G0/r22, N5/r21 move N6/r20, 0 #({tag 3:230}) [230->405] (level:2) is #f with stack state #f #({basic-block #() 405 445}, {basic-block #({tag 11:445}) 445 465}) ld N15/r21, G0/r22, 4 asr N15/r21, N15/r21, 6 and N15/r21, N15/r21, 1020 preserve-registers-entry push G1/r23 push G0/r22 push N6/r20 add N16/r23, N15/r21, 4 sub r1, r1, N16/r23 add G17/r23, N16/r23, 1 push G17/r23 push {constant "KLsimple_object_vectorGVKdW"} move G18/r3, r3 st G18/r3, r1, 8 move G19/r4, r4 st G19/r4, r1, 12 move G20/r5, r5 st G20/r5, r1, 16 move G21/r6, r6 st G21/r6, r1, 20 add N22/r20, r30, 8 add N23/r22, r1, 24 asr N24/r23, N15/r21, 2 sub N24/r23, N24/r23, 4 copy-words-down-w N23/r22, N22/r20, N24/r23 add N26/r23, N15/r21, -8 ld G25/r22, r30, N26/r23 add N27/r23, N15/r21, 8 st G25/r22, r1, N27/r23 move G14/r3, r1 ld N6/r20, r30, -12 push N15/r21 ld G0/r22, r30, -8 ld G1/r23, r30, -4 beq {tag 11:445}, N6/r20, 0 #() [405->445] (level:2) is #f with stack state #f #({basic-block #({tag 10:465}) 465 485}) ld G28/r21, G0/r22, 24 push {constant "KPfalseVKi"} push G28/r21 move r3, G14/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r20 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:465}) [465->485] (level:2) is #f with stack state #f #({basic-block #() 485 490}) pop N15/r21 preserve-registers-exit add N30/r21, N15/r21, -12 ld N29/r21, r1, N30/r21 #() [485->490] (level:2) is #f with stack state #f #() rts-and-drop N29/r21 #({tag 4:200}, {tag 7:200}) [200->220] (level:1) is #f with stack state #f #({basic-block #({tag 1:490}) 490 510}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:490}) [490->510] (level:1) is #f with stack state #f #({basic-block #() 510 515}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [510->515] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:180}) [180->200] (level:2) is #f with stack state #f #({basic-block #({tag 3:230}) 230 405}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [520->525] (level:0) is #f with stack state #f #() bra {tag 3:230} #({tag 9:175}) [175->180] (level:2) is #f with stack state #f #({basic-block #({tag 6:130}) 130 135}) sub N12/r23, N12/r23, 8 #() [525->530] (level:0) is #f with stack state #f #() bra {tag 6:130} #({tag 11:445}) [445->465] (level:2) is #f with stack state #f #({basic-block #({tag 10:465}) 465 485}) move r3, G14/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [530->535] (level:0) is #f with stack state #f #() bra {tag 10:465} +++ ending code for explicit_keyed_single_method_entry +++ +++ Live variable scopes for explicit_keyed_single_method_entry +++ Start scope at 92 with frame for no variables End scope at 203 +++ No Source Code Locators for explicit_keyed_single_method_entry +++ +++ Exported function definition implicit_keyed_single_method_entry_0 +++ +++ starting code for implicit_keyed_single_method_entry_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r3 ld G4/r21, G2/r21, 4 bit {tag 2:175}, G4/r21, 4, 0 #() [30->85] (level:0) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) move G3/r21, r3 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G8/r22, G0/r22, 16 ld G7/r22, G8/r22, 20 ld N9/r23, r3, 4 sub N9/r23, N9/r23, 1 add N9/r23, N9/r23, r3 #({tag 6:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175}) ble {tag 7:155}, N9/r23, r3 #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld N6/r21, N9/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:110}) [110->115] (level:2) is #f with stack state #f #({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155}) ble {tag 5:135}, r30, G7/r22 #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N10/r20, r30, 0 beq {tag 9:130}, N10/r20, N6/r21 #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub r30, r30, 8 #() [345->350] (level:0) is #f with stack state #f #() bra {tag 8:110} #({tag 2:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #({tag 3:180}) 180 240}) move N6/r21, 0 #({tag 3:180}) [180->240] (level:2) is #f with stack state #f #({basic-block #() 240 285}, {basic-block #({tag 11:285}) 285 305}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G12/r3, r3 st G12/r3, r1, 8 move G11/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:285}, N6/r21, 0 #() [240->285] (level:2) is #f with stack state #f #({basic-block #({tag 10:305}) 305 315}) ld G14/r20, G0/r22, 16 ld G13/r20, G14/r20, 20 push {constant "KPtrueVKi"} push G13/r20 move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:305}) [305->315] (level:2) is #f with stack state #f #({basic-block #() 315 320}) preserve-registers-exit load-stack-arg-n #t, N15/r21, 0 #() [315->320] (level:2) is #f with stack state #f #() rts-and-drop N15/r21 #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:320}) 320 340}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:320}) [320->340] (level:1) is #f with stack state #f #({basic-block #() 340 345}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [340->345] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:135}) [135->155] (level:2) is #f with stack state #f #({basic-block #({tag 3:180}) 180 240}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [350->355] (level:0) is #f with stack state #f #() bra {tag 3:180} #({tag 9:130}) [130->135] (level:2) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) sub N9/r23, N9/r23, 8 #() [355->360] (level:0) is #f with stack state #f #() bra {tag 6:85} #({tag 11:285}) [285->305] (level:2) is #f with stack state #f #({basic-block #({tag 10:305}) 305 315}) move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [360->365] (level:0) is #f with stack state #f #() bra {tag 10:305} +++ ending code for implicit_keyed_single_method_entry_0 +++ +++ Live variable scopes for implicit_keyed_single_method_entry_0 +++ Start scope at 66 with frame for no variables End scope at 129 +++ No Source Code Locators for implicit_keyed_single_method_entry_0 +++ +++ Exported function definition implicit_keyed_single_method_entry_1 +++ +++ starting code for implicit_keyed_single_method_entry_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r4 ld G4/r21, G2/r21, 4 bit {tag 2:175}, G4/r21, 4, 0 #() [30->85] (level:0) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) move G3/r21, r4 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G8/r22, G0/r22, 16 ld G7/r22, G8/r22, 20 ld N9/r23, r3, 4 sub N9/r23, N9/r23, 1 add N9/r23, N9/r23, r3 #({tag 6:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175}) ble {tag 7:155}, N9/r23, r3 #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld N6/r21, N9/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:110}) [110->115] (level:2) is #f with stack state #f #({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155}) ble {tag 5:135}, r30, G7/r22 #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N10/r20, r30, 0 beq {tag 9:130}, N10/r20, N6/r21 #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub r30, r30, 8 #() [355->360] (level:0) is #f with stack state #f #() bra {tag 8:110} #({tag 2:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #({tag 3:180}) 180 250}) move N6/r21, 0 #({tag 3:180}) [180->250] (level:2) is #f with stack state #f #({basic-block #() 250 295}, {basic-block #({tag 11:295}) 295 315}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G12/r3, r3 st G12/r3, r1, 8 move G13/r4, r4 st G13/r4, r1, 12 move G11/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:295}, N6/r21, 0 #() [250->295] (level:2) is #f with stack state #f #({basic-block #({tag 10:315}) 315 325}) ld G15/r20, G0/r22, 16 ld G14/r20, G15/r20, 20 push {constant "KPtrueVKi"} push G14/r20 move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:315}) [315->325] (level:2) is #f with stack state #f #({basic-block #() 325 330}) preserve-registers-exit load-stack-arg-n #t, N16/r21, 0 #() [325->330] (level:2) is #f with stack state #f #() rts-and-drop N16/r21 #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:330}) 330 350}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:330}) [330->350] (level:1) is #f with stack state #f #({basic-block #() 350 355}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [350->355] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:135}) [135->155] (level:2) is #f with stack state #f #({basic-block #({tag 3:180}) 180 250}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [360->365] (level:0) is #f with stack state #f #() bra {tag 3:180} #({tag 9:130}) [130->135] (level:2) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) sub N9/r23, N9/r23, 8 #() [365->370] (level:0) is #f with stack state #f #() bra {tag 6:85} #({tag 11:295}) [295->315] (level:2) is #f with stack state #f #({basic-block #({tag 10:315}) 315 325}) move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [370->375] (level:0) is #f with stack state #f #() bra {tag 10:315} +++ ending code for implicit_keyed_single_method_entry_1 +++ +++ Live variable scopes for implicit_keyed_single_method_entry_1 +++ Start scope at 66 with frame for no variables End scope at 131 +++ No Source Code Locators for implicit_keyed_single_method_entry_1 +++ +++ Exported function definition implicit_keyed_single_method_entry_2 +++ +++ starting code for implicit_keyed_single_method_entry_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r5 ld G4/r21, G2/r21, 4 bit {tag 2:175}, G4/r21, 4, 0 #() [30->85] (level:0) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) move G3/r21, r5 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G8/r22, G0/r22, 16 ld G7/r22, G8/r22, 20 ld N9/r23, r3, 4 sub N9/r23, N9/r23, 1 add N9/r23, N9/r23, r3 #({tag 6:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175}) ble {tag 7:155}, N9/r23, r3 #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld N6/r21, N9/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:110}) [110->115] (level:2) is #f with stack state #f #({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155}) ble {tag 5:135}, r30, G7/r22 #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N10/r20, r30, 0 beq {tag 9:130}, N10/r20, N6/r21 #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub r30, r30, 8 #() [365->370] (level:0) is #f with stack state #f #() bra {tag 8:110} #({tag 2:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #({tag 3:180}) 180 260}) move N6/r21, 0 #({tag 3:180}) [180->260] (level:2) is #f with stack state #f #({basic-block #() 260 305}, {basic-block #({tag 11:305}) 305 325}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G12/r3, r3 st G12/r3, r1, 8 move G13/r4, r4 st G13/r4, r1, 12 move G14/r5, r5 st G14/r5, r1, 16 move G11/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:305}, N6/r21, 0 #() [260->305] (level:2) is #f with stack state #f #({basic-block #({tag 10:325}) 325 335}) ld G16/r20, G0/r22, 16 ld G15/r20, G16/r20, 20 push {constant "KPtrueVKi"} push G15/r20 move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:325}) [325->335] (level:2) is #f with stack state #f #({basic-block #() 335 340}) preserve-registers-exit load-stack-arg-n #t, N17/r21, 0 #() [335->340] (level:2) is #f with stack state #f #() rts-and-drop N17/r21 #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:340}) 340 360}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:340}) [340->360] (level:1) is #f with stack state #f #({basic-block #() 360 365}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [360->365] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:135}) [135->155] (level:2) is #f with stack state #f #({basic-block #({tag 3:180}) 180 260}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [370->375] (level:0) is #f with stack state #f #() bra {tag 3:180} #({tag 9:130}) [130->135] (level:2) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) sub N9/r23, N9/r23, 8 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 6:85} #({tag 11:305}) [305->325] (level:2) is #f with stack state #f #({basic-block #({tag 10:325}) 325 335}) move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 10:325} +++ ending code for implicit_keyed_single_method_entry_2 +++ +++ Live variable scopes for implicit_keyed_single_method_entry_2 +++ Start scope at 66 with frame for no variables End scope at 133 +++ No Source Code Locators for implicit_keyed_single_method_entry_2 +++ +++ Exported function definition implicit_keyed_single_method_entry_3 +++ +++ starting code for implicit_keyed_single_method_entry_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180}) move G0/r22, r22 move G1/r23, r23 move G2/r21, r6 ld G4/r21, G2/r21, 4 bit {tag 2:175}, G4/r21, 4, 0 #() [30->85] (level:0) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) move G3/r21, r6 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G8/r22, G0/r22, 16 ld G7/r22, G8/r22, 20 ld N9/r23, r3, 4 sub N9/r23, N9/r23, 1 add N9/r23, N9/r23, r3 #({tag 6:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175}) ble {tag 7:155}, N9/r23, r3 #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld N6/r21, N9/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:110}) [110->115] (level:2) is #f with stack state #f #({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155}) ble {tag 5:135}, r30, G7/r22 #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N10/r20, r30, 0 beq {tag 9:130}, N10/r20, N6/r21 #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub r30, r30, 8 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 8:110} #({tag 2:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #({tag 3:180}) 180 270}) move N6/r21, 0 #({tag 3:180}) [180->270] (level:2) is #f with stack state #f #({basic-block #() 270 315}, {basic-block #({tag 11:315}) 315 335}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 16 push 17 push {constant "KLsimple_object_vectorGVKdW"} move G12/r3, r3 st G12/r3, r1, 8 move G13/r4, r4 st G13/r4, r1, 12 move G14/r5, r5 st G14/r5, r1, 16 move G15/r6, r6 st G15/r6, r1, 20 move G11/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:315}, N6/r21, 0 #() [270->315] (level:2) is #f with stack state #f #({basic-block #({tag 10:335}) 335 345}) ld G17/r20, G0/r22, 16 ld G16/r20, G17/r20, 20 push {constant "KPtrueVKi"} push G16/r20 move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:335}) [335->345] (level:2) is #f with stack state #f #({basic-block #() 345 350}) preserve-registers-exit load-stack-arg-n #t, N18/r21, 0 #() [345->350] (level:2) is #f with stack state #f #() rts-and-drop N18/r21 #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:350}) 350 370}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:350}) [350->370] (level:1) is #f with stack state #f #({basic-block #() 370 375}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [370->375] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:135}) [135->155] (level:2) is #f with stack state #f #({basic-block #({tag 3:180}) 180 270}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 3:180} #({tag 9:130}) [130->135] (level:2) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) sub N9/r23, N9/r23, 8 #() [385->390] (level:0) is #f with stack state #f #() bra {tag 6:85} #({tag 11:315}) [315->335] (level:2) is #f with stack state #f #({basic-block #({tag 10:335}) 335 345}) move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [390->395] (level:0) is #f with stack state #f #() bra {tag 10:335} +++ ending code for implicit_keyed_single_method_entry_3 +++ +++ Live variable scopes for implicit_keyed_single_method_entry_3 +++ Start scope at 66 with frame for no variables End scope at 135 +++ No Source Code Locators for implicit_keyed_single_method_entry_3 +++ +++ Exported function definition implicit_keyed_single_method_entry_4 +++ +++ starting code for implicit_keyed_single_method_entry_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180}) move G0/r22, r22 move G1/r23, r23 load-stack-arg-n #t, G2/r21, 0 ld G4/r21, G2/r21, 4 bit {tag 2:175}, G4/r21, 4, 0 #() [30->85] (level:0) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) load-stack-arg-n #t, G3/r21, 0 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G8/r22, G0/r22, 16 ld G7/r22, G8/r22, 20 ld N9/r23, r3, 4 sub N9/r23, N9/r23, 1 add N9/r23, N9/r23, r3 #({tag 6:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175}) ble {tag 7:155}, N9/r23, r3 #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld N6/r21, N9/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:110}) [110->115] (level:2) is #f with stack state #f #({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155}) ble {tag 5:135}, r30, G7/r22 #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N10/r20, r30, 0 beq {tag 9:130}, N10/r20, N6/r21 #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub r30, r30, 8 #() [385->390] (level:0) is #f with stack state #f #() bra {tag 8:110} #({tag 2:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #({tag 3:180}) 180 280}) move N6/r21, 0 #({tag 3:180}) [180->280] (level:2) is #f with stack state #f #({basic-block #() 280 325}, {basic-block #({tag 11:325}) 325 345}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 20 push 21 push {constant "KLsimple_object_vectorGVKdW"} move G12/r3, r3 st G12/r3, r1, 8 move G13/r4, r4 st G13/r4, r1, 12 move G14/r5, r5 st G14/r5, r1, 16 move G15/r6, r6 st G15/r6, r1, 20 ld G16/r23, r30, 8 st G16/r23, r1, 24 move G11/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:325}, N6/r21, 0 #() [280->325] (level:2) is #f with stack state #f #({basic-block #({tag 10:345}) 345 355}) ld G18/r20, G0/r22, 16 ld G17/r20, G18/r20, 20 push {constant "KPtrueVKi"} push G17/r20 move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:345}) [345->355] (level:2) is #f with stack state #f #({basic-block #() 355 360}) preserve-registers-exit load-stack-arg-n #t, N19/r21, 1 #() [355->360] (level:2) is #f with stack state #f #() rts-and-drop N19/r21 #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:360}) 360 380}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:360}) [360->380] (level:1) is #f with stack state #f #({basic-block #() 380 385}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [380->385] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:135}) [135->155] (level:2) is #f with stack state #f #({basic-block #({tag 3:180}) 180 280}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [390->395] (level:0) is #f with stack state #f #() bra {tag 3:180} #({tag 9:130}) [130->135] (level:2) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) sub N9/r23, N9/r23, 8 #() [395->400] (level:0) is #f with stack state #f #() bra {tag 6:85} #({tag 11:325}) [325->345] (level:2) is #f with stack state #f #({basic-block #({tag 10:345}) 345 355}) move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [400->405] (level:0) is #f with stack state #f #() bra {tag 10:345} +++ ending code for implicit_keyed_single_method_entry_4 +++ +++ Live variable scopes for implicit_keyed_single_method_entry_4 +++ Start scope at 66 with frame for no variables End scope at 139 +++ No Source Code Locators for implicit_keyed_single_method_entry_4 +++ +++ Exported function definition implicit_keyed_single_method_entry_5 +++ +++ starting code for implicit_keyed_single_method_entry_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is #f with stack state #f #({basic-block #() 30 85}, {basic-block #({tag 2:175}) 175 180}) move G0/r22, r22 move G1/r23, r23 load-stack-arg-n #t, G2/r21, 1 ld G4/r21, G2/r21, 4 bit {tag 2:175}, G4/r21, 4, 0 #() [30->85] (level:0) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) load-stack-arg-n #t, G3/r21, 1 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G8/r22, G0/r22, 16 ld G7/r22, G8/r22, 20 ld N9/r23, r3, 4 sub N9/r23, N9/r23, 1 add N9/r23, N9/r23, r3 #({tag 6:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 4:155}, {tag 7:155}) 155 175}) ble {tag 7:155}, N9/r23, r3 #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld N6/r21, N9/r23, 0 ld r30, G7/r22, 4 sub r30, r30, 1 add r30, r30, G7/r22 #({tag 8:110}) [110->115] (level:2) is #f with stack state #f #({basic-block #() 115 125}, {basic-block #({tag 5:135}) 135 155}) ble {tag 5:135}, r30, G7/r22 #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N10/r20, r30, 0 beq {tag 9:130}, N10/r20, N6/r21 #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub r30, r30, 8 #() [395->400] (level:0) is #f with stack state #f #() bra {tag 8:110} #({tag 2:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #({tag 3:180}) 180 290}) move N6/r21, 0 #({tag 3:180}) [180->290] (level:2) is #f with stack state #f #({basic-block #() 290 335}, {basic-block #({tag 11:335}) 335 355}) preserve-registers-entry push G1/r23 push N6/r21 sub r1, r1, 24 push 25 push {constant "KLsimple_object_vectorGVKdW"} move G12/r3, r3 st G12/r3, r1, 8 move G13/r4, r4 st G13/r4, r1, 12 move G14/r5, r5 st G14/r5, r1, 16 move G15/r6, r6 st G15/r6, r1, 20 ld G16/r23, r30, 8 st G16/r23, r1, 24 ld G17/r23, r30, 12 st G17/r23, r1, 28 move G11/r3, r1 ld N6/r21, r30, -8 ld G1/r23, r30, -4 beq {tag 11:335}, N6/r21, 0 #() [290->335] (level:2) is #f with stack state #f #({basic-block #({tag 10:355}) 355 365}) ld G19/r20, G0/r22, 16 ld G18/r20, G19/r20, 20 push {constant "KPtrueVKi"} push G18/r20 move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r21 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:355}) [355->365] (level:2) is #f with stack state #f #({basic-block #() 365 370}) preserve-registers-exit load-stack-arg-n #t, N20/r21, 2 #() [365->370] (level:2) is #f with stack state #f #() rts-and-drop N20/r21 #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:370}) 370 390}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:370}) [370->390] (level:1) is #f with stack state #f #({basic-block #() 390 395}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [390->395] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:135}) [135->155] (level:2) is #f with stack state #f #({basic-block #({tag 3:180}) 180 290}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [400->405] (level:0) is #f with stack state #f #() bra {tag 3:180} #({tag 9:130}) [130->135] (level:2) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) sub N9/r23, N9/r23, 8 #() [405->410] (level:0) is #f with stack state #f #() bra {tag 6:85} #({tag 11:335}) [335->355] (level:2) is #f with stack state #f #({basic-block #({tag 10:355}) 355 365}) move r3, G11/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [410->415] (level:0) is #f with stack state #f #() bra {tag 10:355} +++ ending code for implicit_keyed_single_method_entry_5 +++ +++ Live variable scopes for implicit_keyed_single_method_entry_5 +++ Start scope at 66 with frame for no variables End scope at 143 +++ No Source Code Locators for implicit_keyed_single_method_entry_5 +++ +++ Exported function definition implicit_keyed_single_method_entry +++ +++ starting code for implicit_keyed_single_method_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 135}, {basic-block #({tag 2:225}) 225 235}) move G0/r22, r22 move G1/r23, r23 move N5/r21, G0/r22 ld N7/r22, G0/r22, 4 asr N7/r22, N7/r22, 6 and N7/r22, N7/r22, 1020 add N8/r22, N7/r22, -16 ld G2/r22, r1, N8/r22 ld G4/r22, G2/r22, 4 bit {tag 2:225}, G4/r22, 4, 0 #() [55->135] (level:0) is #f with stack state #f #({basic-block #({tag 6:135}) 135 140}) move G0/r22, N5/r21 ld N9/r21, G0/r22, 4 asr N9/r21, N9/r21, 6 and N9/r21, N9/r21, 1020 add N10/r21, N9/r21, -16 ld G3/r21, r1, N10/r21 push r3 push r30 push G0/r22 push G1/r23 move r3, G3/r21 ld G12/r22, G0/r22, 16 ld G11/r22, G12/r22, 20 ld N13/r23, r3, 4 sub N13/r23, N13/r23, 1 add N13/r23, N13/r23, r3 #({tag 6:135}) [135->140] (level:1) is #f with stack state #f #({basic-block #() 140 160}, {basic-block #({tag 4:205}, {tag 7:205}) 205 225}) ble {tag 7:205}, N13/r23, r3 #() [140->160] (level:1) is #f with stack state #f #({basic-block #({tag 8:160}) 160 165}) ld N6/r20, N13/r23, 0 ld r30, G11/r22, 4 sub r30, r30, 1 add r30, r30, G11/r22 #({tag 8:160}) [160->165] (level:2) is #f with stack state #f #({basic-block #() 165 175}, {basic-block #({tag 5:185}) 185 205}) ble {tag 5:185}, r30, G11/r22 #() [165->175] (level:2) is #f with stack state #f #({basic-block #() 175 180}, {basic-block #({tag 9:180}) 180 185}) ld N14/r21, r30, 0 beq {tag 9:180}, N14/r21, N6/r20 #() [175->180] (level:1) is #f with stack state #f #({basic-block #({tag 8:160}) 160 165}) sub r30, r30, 8 #() [525->530] (level:0) is #f with stack state #f #() bra {tag 8:160} #({tag 2:225}) [225->235] (level:0) is #f with stack state #f #({basic-block #({tag 3:235}) 235 410}) move G0/r22, N5/r21 move N6/r20, 0 #({tag 3:235}) [235->410] (level:2) is #f with stack state #f #({basic-block #() 410 455}, {basic-block #({tag 11:455}) 455 475}) ld N16/r21, G0/r22, 4 asr N16/r21, N16/r21, 6 and N16/r21, N16/r21, 1020 preserve-registers-entry push G1/r23 push G0/r22 push N6/r20 add N17/r23, N16/r21, 4 sub r1, r1, N17/r23 add G18/r23, N17/r23, 1 push G18/r23 push {constant "KLsimple_object_vectorGVKdW"} move G19/r3, r3 st G19/r3, r1, 8 move G20/r4, r4 st G20/r4, r1, 12 move G21/r5, r5 st G21/r5, r1, 16 move G22/r6, r6 st G22/r6, r1, 20 add N23/r20, r30, 8 add N24/r22, r1, 24 asr N25/r23, N16/r21, 2 sub N25/r23, N25/r23, 4 copy-words-down-w N24/r22, N23/r20, N25/r23 add N27/r23, N16/r21, -8 ld G26/r22, r30, N27/r23 add N28/r23, N16/r21, 8 st G26/r22, r1, N28/r23 move G15/r3, r1 ld N6/r20, r30, -12 push N16/r21 ld G0/r22, r30, -8 ld G1/r23, r30, -4 beq {tag 11:455}, N6/r20, 0 #() [410->455] (level:2) is #f with stack state #f #({basic-block #({tag 10:475}) 475 495}) ld G30/r21, G0/r22, 16 ld G29/r21, G30/r21, 20 push {constant "KPtrueVKi"} push G29/r21 move r3, G15/r3 move r4, G1/r23 move r5, G0/r22 move r6, N6/r20 call {constant "Kinvalid_keyword_trapVKeI"}, 4 #({tag 10:475}) [475->495] (level:2) is #f with stack state #f #({basic-block #() 495 500}) pop N16/r21 preserve-registers-exit add N32/r21, N16/r21, -12 ld N31/r21, r1, N32/r21 #() [495->500] (level:2) is #f with stack state #f #() rts-and-drop N31/r21 #({tag 4:205}, {tag 7:205}) [205->225] (level:1) is #f with stack state #f #({basic-block #({tag 1:500}) 500 520}) add r1, r1, 4 pop G0/r22 pop r30 pop r3 #({tag 1:500}) [500->520] (level:1) is #f with stack state #f #({basic-block #() 520 525}) ld G1/r23, G0/r22, 20 ld G0/r22, G0/r22, 16 move r22, G0/r22 move r23, G1/r23 #() [520->525] (level:1) is #f with stack state #f #() jmp-indirect r22, 12, 4, 0, #f, #f #({tag 5:185}) [185->205] (level:2) is #f with stack state #f #({basic-block #({tag 3:235}) 235 410}) pop G1/r23 pop G0/r22 pop r30 pop r3 #() [530->535] (level:0) is #f with stack state #f #() bra {tag 3:235} #({tag 9:180}) [180->185] (level:2) is #f with stack state #f #({basic-block #({tag 6:135}) 135 140}) sub N13/r23, N13/r23, 8 #() [535->540] (level:0) is #f with stack state #f #() bra {tag 6:135} #({tag 11:455}) [455->475] (level:2) is #f with stack state #f #({basic-block #({tag 10:475}) 475 495}) move r3, G15/r3 move r4, G1/r23 move r5, G0/r22 call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 3 #() [540->545] (level:0) is #f with stack state #f #() bra {tag 10:475} +++ ending code for implicit_keyed_single_method_entry +++ +++ Live variable scopes for implicit_keyed_single_method_entry +++ Start scope at 94 with frame for no variables End scope at 207 +++ No Source Code Locators for implicit_keyed_single_method_entry +++ +++ Exported function definition discriminate_on_argument_entry_0 +++ +++ starting code for discriminate_on_argument_entry_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 95}) move G0/r20, r3 push r3 push r4 push r5 push r6 push r23 ld N1/r21, r22, 8 move r3, G0/r20 move r4, r23 move r5, r22 call N1/r21, 3 #() [60->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [95->100] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry_0 +++ +++ No Source Code Locators for discriminate_on_argument_entry_0 +++ +++ Exported function definition discriminate_on_argument_entry_1 +++ +++ starting code for discriminate_on_argument_entry_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 95}) move G0/r20, r4 push r3 push r4 push r5 push r6 push r23 ld N1/r21, r22, 8 move r3, G0/r20 move r4, r23 move r5, r22 call N1/r21, 3 #() [60->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [95->100] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry_1 +++ +++ No Source Code Locators for discriminate_on_argument_entry_1 +++ +++ Exported function definition discriminate_on_argument_entry_2 +++ +++ starting code for discriminate_on_argument_entry_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 95}) move G0/r20, r5 push r3 push r4 push r5 push r6 push r23 ld N1/r21, r22, 8 move r3, G0/r20 move r4, r23 move r5, r22 call N1/r21, 3 #() [60->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [95->100] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry_2 +++ +++ No Source Code Locators for discriminate_on_argument_entry_2 +++ +++ Exported function definition discriminate_on_argument_entry_3 +++ +++ starting code for discriminate_on_argument_entry_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 95}) move G0/r20, r6 push r3 push r4 push r5 push r6 push r23 ld N1/r21, r22, 8 move r3, G0/r20 move r4, r23 move r5, r22 call N1/r21, 3 #() [60->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [95->100] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry_3 +++ +++ No Source Code Locators for discriminate_on_argument_entry_3 +++ +++ Exported function definition discriminate_on_argument_entry_4 +++ +++ starting code for discriminate_on_argument_entry_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 95}) load-stack-arg-n #t, G0/r20, 0 push r3 push r4 push r5 push r6 push r23 ld N1/r21, r22, 8 move r3, G0/r20 move r4, r23 move r5, r22 call N1/r21, 3 #() [60->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [95->100] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry_4 +++ +++ No Source Code Locators for discriminate_on_argument_entry_4 +++ +++ Exported function definition discriminate_on_argument_entry_5 +++ +++ starting code for discriminate_on_argument_entry_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 95}) load-stack-arg-n #t, G0/r20, 1 push r3 push r4 push r5 push r6 push r23 ld N1/r21, r22, 8 move r3, G0/r20 move r4, r23 move r5, r22 call N1/r21, 3 #() [60->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [95->100] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry_5 +++ +++ No Source Code Locators for discriminate_on_argument_entry_5 +++ +++ Exported function definition discriminate_on_argument_entry_6 +++ +++ starting code for discriminate_on_argument_entry_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 95}) load-stack-arg-n #t, G0/r20, 2 push r3 push r4 push r5 push r6 push r23 ld N1/r21, r22, 8 move r3, G0/r20 move r4, r23 move r5, r22 call N1/r21, 3 #() [60->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [95->100] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry_6 +++ +++ No Source Code Locators for discriminate_on_argument_entry_6 +++ +++ Exported function definition discriminate_on_argument_entry +++ +++ starting code for discriminate_on_argument_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 80}) rem "This is a dummy first basic block." #() [5->80] (level:0) is #f with stack state #f #({basic-block #() 80 115}) ld N3/r21, r22, 4 asr N3/r21, N3/r21, 6 and N3/r21, N3/r21, 1020 add N4/r21, N3/r21, -16 ld G0/r21, r1, N4/r21 push r3 push r4 push r5 push r6 push r23 ld N1/r20, r22, 8 move r3, G0/r21 move r4, r23 move r5, r22 call N1/r20, 3 #() [80->115] (level:0) is #f with stack state #f #({basic-block #() 115 120}) move r22, r3 pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [115->120] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for discriminate_on_argument_entry +++ +++ No Source Code Locators for discriminate_on_argument_entry +++ +++ Exported function definition if_type_discriminator_engine_0 +++ +++ starting code for if_type_discriminator_engine_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r3 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 24 #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for if_type_discriminator_engine_0 +++ +++ No Source Code Locators for if_type_discriminator_engine_0 +++ +++ Exported function definition if_type_discriminator_engine_1 +++ +++ starting code for if_type_discriminator_engine_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r4 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 24 #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for if_type_discriminator_engine_1 +++ +++ No Source Code Locators for if_type_discriminator_engine_1 +++ +++ Exported function definition if_type_discriminator_engine_2 +++ +++ starting code for if_type_discriminator_engine_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r5 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 24 #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for if_type_discriminator_engine_2 +++ +++ No Source Code Locators for if_type_discriminator_engine_2 +++ +++ Exported function definition if_type_discriminator_engine_3 +++ +++ starting code for if_type_discriminator_engine_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r6 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 24 #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for if_type_discriminator_engine_3 +++ +++ No Source Code Locators for if_type_discriminator_engine_3 +++ +++ Exported function definition if_type_discriminator_engine_4 +++ +++ starting code for if_type_discriminator_engine_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) load-stack-arg-n #t, G0/r21, 0 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 24 #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for if_type_discriminator_engine_4 +++ +++ No Source Code Locators for if_type_discriminator_engine_4 +++ +++ Exported function definition if_type_discriminator_engine_5 +++ +++ starting code for if_type_discriminator_engine_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) load-stack-arg-n #t, G0/r21, 1 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 24 #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for if_type_discriminator_engine_5 +++ +++ No Source Code Locators for if_type_discriminator_engine_5 +++ +++ Exported function definition if_type_discriminator_engine_6 +++ +++ starting code for if_type_discriminator_engine_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) load-stack-arg-n #t, G0/r21, 2 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 24 #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for if_type_discriminator_engine_6 +++ +++ No Source Code Locators for if_type_discriminator_engine_6 +++ +++ Exported function definition if_type_discriminator_engine +++ +++ starting code for if_type_discriminator_engine +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 75}) rem "This is a dummy first basic block." #() [5->75] (level:0) is #f with stack state #f #({basic-block #() 75 95}, {basic-block #({tag 1:110}) 110 120}) ld N3/r21, r22, 4 asr N3/r21, N3/r21, 6 and N3/r21, N3/r21, 1020 add N4/r21, N3/r21, -16 ld G0/r21, r1, N4/r21 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G6/r4, N1/r4 beq {tag 1:110}, G6/r4, {constant "KLobjectGVKd"} #() [75->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) ld N5/r23, G6/r4, 4 move r3, G0/r21 move r4, G6/r4 call N5/r23, 2 #() [95->100] (level:0) is #f with stack state #f #({basic-block #() 100 110}, {basic-block #({tag 1:110}) 110 120}) bne {tag 1:110}, r3, {constant "KPfalseVKi"} #() [100->110] (level:0) is #f with stack state #f #({basic-block #({tag 2:120}) 120 150}) pop r22 ld r22, r22, 24 #({tag 2:120}) [120->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [150->155] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:110}) [110->120] (level:0) is #f with stack state #f #({basic-block #({tag 2:120}) 120 150}) pop r22 ld r22, r22, 20 #() [155->160] (level:0) is #f with stack state #f #() bra {tag 2:120} +++ ending code for if_type_discriminator_engine +++ +++ No Source Code Locators for if_type_discriminator_engine +++ +++ Exported function definition typecheck_discriminator_engine_0 +++ +++ starting code for typecheck_discriminator_engine_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r3 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for typecheck_discriminator_engine_0 +++ +++ No Source Code Locators for typecheck_discriminator_engine_0 +++ +++ Exported function definition typecheck_discriminator_engine_1 +++ +++ starting code for typecheck_discriminator_engine_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r4 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for typecheck_discriminator_engine_1 +++ +++ No Source Code Locators for typecheck_discriminator_engine_1 +++ +++ Exported function definition typecheck_discriminator_engine_2 +++ +++ starting code for typecheck_discriminator_engine_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r5 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for typecheck_discriminator_engine_2 +++ +++ No Source Code Locators for typecheck_discriminator_engine_2 +++ +++ Exported function definition typecheck_discriminator_engine_3 +++ +++ starting code for typecheck_discriminator_engine_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) move G0/r21, r6 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for typecheck_discriminator_engine_3 +++ +++ No Source Code Locators for typecheck_discriminator_engine_3 +++ +++ Exported function definition typecheck_discriminator_engine_4 +++ +++ starting code for typecheck_discriminator_engine_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) load-stack-arg-n #t, G0/r21, 0 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for typecheck_discriminator_engine_4 +++ +++ No Source Code Locators for typecheck_discriminator_engine_4 +++ +++ Exported function definition typecheck_discriminator_engine_5 +++ +++ starting code for typecheck_discriminator_engine_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) load-stack-arg-n #t, G0/r21, 1 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for typecheck_discriminator_engine_5 +++ +++ No Source Code Locators for typecheck_discriminator_engine_5 +++ +++ Exported function definition typecheck_discriminator_engine_6 +++ +++ starting code for typecheck_discriminator_engine_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 75}, {basic-block #({tag 1:90}) 90 100}) load-stack-arg-n #t, G0/r21, 2 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G4/r4, N1/r4 beq {tag 1:90}, G4/r4, {constant "KLobjectGVKd"} #() [55->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld N3/r23, G4/r4, 4 move r3, G0/r21 move r4, G4/r4 call N3/r23, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #() 80 90}, {basic-block #({tag 1:90}) 90 100}) bne {tag 1:90}, r3, {constant "KPfalseVKi"} #() [80->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:100}) [100->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [130->135] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #({tag 2:100}) 100 130}) pop r22 ld r22, r22, 20 #() [135->140] (level:0) is #f with stack state #f #() bra {tag 2:100} +++ ending code for typecheck_discriminator_engine_6 +++ +++ No Source Code Locators for typecheck_discriminator_engine_6 +++ +++ Exported function definition typecheck_discriminator_engine +++ +++ starting code for typecheck_discriminator_engine +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 75}) rem "This is a dummy first basic block." #() [5->75] (level:0) is #f with stack state #f #({basic-block #() 75 95}, {basic-block #({tag 1:110}) 110 120}) ld N3/r21, r22, 4 asr N3/r21, N3/r21, 6 and N3/r21, N3/r21, 1020 add N4/r21, N3/r21, -16 ld G0/r21, r1, N4/r21 push r3 push r4 push r5 push r6 push r23 ld N1/r4, r22, 16 push r22 move G6/r4, N1/r4 beq {tag 1:110}, G6/r4, {constant "KLobjectGVKd"} #() [75->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) ld N5/r23, G6/r4, 4 move r3, G0/r21 move r4, G6/r4 call N5/r23, 2 #() [95->100] (level:0) is #f with stack state #f #({basic-block #() 100 110}, {basic-block #({tag 1:110}) 110 120}) bne {tag 1:110}, r3, {constant "KPfalseVKi"} #() [100->110] (level:0) is #f with stack state #f #({basic-block #({tag 2:120}) 120 150}) pop r22 move r22, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:120}) [120->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) pop r23 pop r6 pop r5 pop r4 pop r3 ld N2/r21, r22, 12 #() [150->155] (level:0) is #f with stack state #f #() jmp N2/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:110}) [110->120] (level:0) is #f with stack state #f #({basic-block #({tag 2:120}) 120 150}) pop r22 ld r22, r22, 20 #() [155->160] (level:0) is #f with stack state #f #() bra {tag 2:120} +++ ending code for typecheck_discriminator_engine +++ +++ No Source Code Locators for typecheck_discriminator_engine +++ +++ Exported function definition monomorphic_by_class_discriminator_engine_0 +++ +++ starting code for monomorphic_by_class_discriminator_engine_0 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 90}) move G0/r20, r3 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:75}, N1/r21, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/r20, G0/r20, 0 #({tag 3:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:60}, N1/r21, G0/r20 #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) asl N2/r21, N1/r21, 2 add N3/r21, N2/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N3/r21 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 2:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine_0 +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine_0 +++ +++ Exported function definition monomorphic_by_class_discriminator_engine_1 +++ +++ starting code for monomorphic_by_class_discriminator_engine_1 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 90}) move G0/r20, r4 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:75}, N1/r21, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/r20, G0/r20, 0 #({tag 3:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:60}, N1/r21, G0/r20 #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) asl N2/r21, N1/r21, 2 add N3/r21, N2/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N3/r21 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 2:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine_1 +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine_1 +++ +++ Exported function definition monomorphic_by_class_discriminator_engine_2 +++ +++ starting code for monomorphic_by_class_discriminator_engine_2 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 90}) move G0/r20, r5 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:75}, N1/r21, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/r20, G0/r20, 0 #({tag 3:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:60}, N1/r21, G0/r20 #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) asl N2/r21, N1/r21, 2 add N3/r21, N2/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N3/r21 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 2:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine_2 +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine_2 +++ +++ Exported function definition monomorphic_by_class_discriminator_engine_3 +++ +++ starting code for monomorphic_by_class_discriminator_engine_3 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 90}) move G0/r20, r6 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:75}, N1/r21, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/r20, G0/r20, 0 #({tag 3:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:60}, N1/r21, G0/r20 #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) asl N2/r21, N1/r21, 2 add N3/r21, N2/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N3/r21 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 2:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine_3 +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine_3 +++ +++ Exported function definition monomorphic_by_class_discriminator_engine_4 +++ +++ starting code for monomorphic_by_class_discriminator_engine_4 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 90}) load-stack-arg-n #t, G0/r20, 0 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:75}, N1/r21, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/r20, G0/r20, 0 #({tag 3:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:60}, N1/r21, G0/r20 #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) asl N2/r21, N1/r21, 2 add N3/r21, N2/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N3/r21 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 2:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine_4 +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine_4 +++ +++ Exported function definition monomorphic_by_class_discriminator_engine_5 +++ +++ starting code for monomorphic_by_class_discriminator_engine_5 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 90}) load-stack-arg-n #t, G0/r20, 1 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:75}, N1/r21, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/r20, G0/r20, 0 #({tag 3:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:60}, N1/r21, G0/r20 #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) asl N2/r21, N1/r21, 2 add N3/r21, N2/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N3/r21 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 2:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine_5 +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine_5 +++ +++ Exported function definition monomorphic_by_class_discriminator_engine_6 +++ +++ starting code for monomorphic_by_class_discriminator_engine_6 +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 1:75}) 75 90}) load-stack-arg-n #t, G0/r20, 2 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:75}, N1/r21, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/r20, G0/r20, 0 #({tag 3:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:60}) 60 70}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:60}, N1/r21, G0/r20 #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) asl N2/r21, N1/r21, 2 add N3/r21, N2/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N3/r21 #() [90->95] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 2:60}) [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine_6 +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine_6 +++ +++ Exported function definition monomorphic_by_class_discriminator_engine +++ +++ starting code for monomorphic_by_class_discriminator_engine +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 1:95}) 95 110}) ld N2/r20, r22, 4 asr N2/r20, N2/r20, 6 and N2/r20, N2/r20, 1020 add N3/r20, N2/r20, -16 ld G0/r20, r1, N3/r20 move N1/r21, G0/r20 and N1/r21, N1/r21, 3 bne {tag 1:95}, N1/r21, 0 #() [45->50] (level:0) is #f with stack state #f #({basic-block #({tag 3:50}) 50 65}) ld G0/r20, G0/r20, 0 #({tag 3:50}) [50->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 2:80}) 80 90}) or G0/r20, G0/r20, 1 ld N1/r21, r22, 16 bne {tag 2:80}, N1/r21, G0/r20 #() [65->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld r22, r22, 20 ld N1/r21, r22, 12 #() [75->80] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:95}) [95->110] (level:0) is #f with stack state #f #({basic-block #({tag 3:50}) 50 65}) asl N4/r21, N1/r21, 2 add N5/r21, N4/r21, 0 ld G0/r20, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N5/r21 #() [110->115] (level:0) is #f with stack state #f #() bra {tag 3:50} #({tag 2:80}) [80->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}) move r22, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/r21, r22, 12 #() [90->95] (level:0) is #f with stack state #f #() jmp N1/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for monomorphic_by_class_discriminator_engine +++ +++ No Source Code Locators for monomorphic_by_class_discriminator_engine +++ +++ Exported function definition general_engine_node_spread_entry +++ +++ starting code for general_engine_node_spread_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #({tag 4:10}) 10 30}) move G2/r20, r23 #({tag 4:10}) [10->30] (level:1) is #f with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 3:35}) 35 75}) ld N3/r21, G2/r20, 0 ld N3/r21, N3/r21, 8 and N3/r21, N3/r21, 8192 beq {tag 3:35}, N3/r21, 0 #() [30->35] (level:1) is #f with stack state #f #({basic-block #({tag 4:10}) 10 30}) ld G2/r20, G2/r20, 20 #() [180->185] (level:0) is #f with stack state #f #() bra {tag 4:10} #({tag 3:35}) [35->75] (level:1) is #f with stack state #f #({basic-block #() 75 85}, {basic-block #({tag 1:125}) 125 135}) ld N1/r21, G2/r20, 8 ld N1/r21, N1/r21, 4 asr N1/r21, N1/r21, 2 and N1/r21, N1/r21, 255 ld N4/r20, G2/r20, 8 ld N4/r20, N4/r20, 4 and N4/r20, N4/r20, 1310720 bne {tag 1:125}, N4/r20, 0 #() [75->85] (level:1) is #f with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n"} bge {tag 5:175}, N1/r21, 4 #() [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 6:95}) 95 100}) bne {tag 6:95}, N1/r21, 0 #() [90->95] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_0"} #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) [175->175] (level:1) is #f with stack state #f #({basic-block #({tag 14:175}, {tag 10:175}, {tag 9:175}, {tag 5:175}, {tag 2:175}) 175 180}) #({tag 14:175}, {tag 10:175}, {tag 9:175}, {tag 5:175}, {tag 2:175}) [175->180] (level:1) is #f with stack state #f #() jmp N0/r20, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:125}) [125->135] (level:1) is #f with stack state #f #({basic-block #() 135 140}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_spread_optionals"} bge {tag 10:175}, N1/r21, 4 #() [135->140] (level:1) is #f with stack state #f #({basic-block #() 140 145}, {basic-block #({tag 11:145}) 145 150}) bne {tag 11:145}, N1/r21, 0 #() [140->145] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_spread_optionals_0"} #() [185->190] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 6:95}) [95->100] (level:1) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 7:105}) 105 110}) bne {tag 7:105}, N1/r21, 1 #() [100->105] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_1"} #() [190->195] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 11:145}) [145->150] (level:1) is #f with stack state #f #({basic-block #() 150 155}, {basic-block #({tag 12:155}) 155 160}) bne {tag 12:155}, N1/r21, 1 #() [150->155] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_spread_optionals_1"} #() [195->200] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 7:105}) [105->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}, {basic-block #({tag 8:115}) 115 120}) bne {tag 8:115}, N1/r21, 2 #() [110->115] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_2"} #() [200->205] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 12:155}) [155->160] (level:1) is #f with stack state #f #({basic-block #() 160 165}, {basic-block #({tag 13:165}) 165 170}) bne {tag 13:165}, N1/r21, 2 #() [160->165] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_spread_optionals_2"} #() [205->210] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 8:115}) [115->120] (level:1) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) bne {tag 9:175}, N1/r21, 3 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_3"} #() [210->215] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 13:165}) [165->170] (level:1) is #f with stack state #f #({basic-block #() 170 175}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) bne {tag 14:175}, N1/r21, 3 #() [170->175] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_spread_optionals_3"} #() [215->220] (level:0) is #f with stack state #f #() bra {tag 2:175} +++ ending code for general_engine_node_spread_entry +++ +++ No Source Code Locators for general_engine_node_spread_entry +++ +++ Exported function definition general_engine_node_n_entry +++ +++ starting code for general_engine_node_n_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is #f with stack state #f #({basic-block #({tag 4:10}) 10 30}) move G2/r20, r23 #({tag 4:10}) [10->30] (level:1) is #f with stack state #f #({basic-block #() 30 35}, {basic-block #({tag 3:35}) 35 75}) ld N3/r21, G2/r20, 0 ld N3/r21, N3/r21, 8 and N3/r21, N3/r21, 8192 beq {tag 3:35}, N3/r21, 0 #() [30->35] (level:1) is #f with stack state #f #({basic-block #({tag 4:10}) 10 30}) ld G2/r20, G2/r20, 20 #() [180->185] (level:0) is #f with stack state #f #() bra {tag 4:10} #({tag 3:35}) [35->75] (level:1) is #f with stack state #f #({basic-block #() 75 85}, {basic-block #({tag 1:125}) 125 135}) ld N1/r21, G2/r20, 8 ld N1/r21, N1/r21, 4 asr N1/r21, N1/r21, 2 and N1/r21, N1/r21, 255 ld N4/r20, G2/r20, 8 ld N4/r20, N4/r20, 4 and N4/r20, N4/r20, 1310720 bne {tag 1:125}, N4/r20, 0 #() [75->85] (level:1) is #f with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n"} bge {tag 5:175}, N1/r21, 4 #() [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 6:95}) 95 100}) bne {tag 6:95}, N1/r21, 0 #() [90->95] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_0"} #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) [175->175] (level:1) is #f with stack state #f #({basic-block #({tag 14:175}, {tag 10:175}, {tag 9:175}, {tag 5:175}, {tag 2:175}) 175 180}) #({tag 14:175}, {tag 10:175}, {tag 9:175}, {tag 5:175}, {tag 2:175}) [175->180] (level:1) is #f with stack state #f #() jmp N0/r20, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:125}) [125->135] (level:1) is #f with stack state #f #({basic-block #() 135 140}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_optionals"} bge {tag 10:175}, N1/r21, 4 #() [135->140] (level:1) is #f with stack state #f #({basic-block #() 140 145}, {basic-block #({tag 11:145}) 145 150}) bne {tag 11:145}, N1/r21, 0 #() [140->145] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_optionals_0"} #() [185->190] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 6:95}) [95->100] (level:1) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 7:105}) 105 110}) bne {tag 7:105}, N1/r21, 1 #() [100->105] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_1"} #() [190->195] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 11:145}) [145->150] (level:1) is #f with stack state #f #({basic-block #() 150 155}, {basic-block #({tag 12:155}) 155 160}) bne {tag 12:155}, N1/r21, 1 #() [150->155] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_optionals_1"} #() [195->200] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 7:105}) [105->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}, {basic-block #({tag 8:115}) 115 120}) bne {tag 8:115}, N1/r21, 2 #() [110->115] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_2"} #() [200->205] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 12:155}) [155->160] (level:1) is #f with stack state #f #({basic-block #() 160 165}, {basic-block #({tag 13:165}) 165 170}) bne {tag 13:165}, N1/r21, 2 #() [160->165] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_optionals_2"} #() [205->210] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 8:115}) [115->120] (level:1) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) bne {tag 9:175}, N1/r21, 3 #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_3"} #() [210->215] (level:0) is #f with stack state #f #() bra {tag 2:175} #({tag 13:165}) [165->170] (level:1) is #f with stack state #f #({basic-block #() 170 175}, {basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) bne {tag 14:175}, N1/r21, 3 #() [170->175] (level:1) is #f with stack state #f #({basic-block #({tag 2:175}, {tag 5:175}, {tag 9:175}, {tag 10:175}, {tag 14:175}) 175 175}) move N0/r20, {constant "general_engine_node_n_optionals_3"} #() [215->220] (level:0) is #f with stack state #f #() bra {tag 2:175} +++ ending code for general_engine_node_n_entry +++ +++ No Source Code Locators for general_engine_node_n_entry +++ +++ Exported function definition cache_header_entry +++ +++ starting code for cache_header_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is #f with stack state #f #({basic-block #() 20 25}) move r23, r22 ld r22, r23, 16 ld N0/r21, r22, 12 #() [20->25] (level:0) is #f with stack state #f #() jmp N0/r21, #[4, #"mlist", #"function"], 0, #f, #f +++ ending code for cache_header_entry +++ +++ No Source Code Locators for cache_header_entry +++ +++ Exported function definition profiling_cache_header_entry +++ +++ starting code for profiling_cache_header_entry +++ #() [0->5] (level:0) is #f with stack state #f #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is #f with stack state #f #({basic-block #() 15 25}, {basic-block #({tag 2:25}) 25 35}) move r23, r22 beq {tag 2:25}, {indirect-constant "Tdispatch_profiling_enabledQTVKe"}, {constant "KPfalseVKi"} #() [15->25] (level:0) is #f with stack state #f #({basic-block #({tag 2:25}) 25 35}, {basic-block #({tag 1:40}) 40 45}) xadd-mem-locked N0/r21, r22, 24, 1 beq {tag 1:40}, N0/r21, 0 #({tag 2:25}) [25->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) ld r22, r22, 16 ld N0/r21, r22, 12 #() [35->40] (level:0) is #f with stack state #f #() jmp N0/r21, #[4, #"mlist", #"function"], 0, #f, #f #({tag 1:40}) [40->45] (level:0) is #f with stack state #f #({basic-block #({tag 2:25}) 25 35}) add2-mem-locked r22, r22, 28, 1 #() [45->50] (level:0) is #f with stack state #f #() bra {tag 2:25} +++ ending code for profiling_cache_header_entry +++ +++ No Source Code Locators for profiling_cache_header_entry +++ +++ Exported function definition primitive_enable_cache_header_engine_node +++ +++ starting code for primitive_enable_cache_header_engine_node +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N1/r23, {constant "cache_header_entry"} st N1/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_enable_cache_header_engine_node +++ +++ No Source Code Locators for primitive_enable_cache_header_engine_node +++ +++ Exported function definition primitive_invalidate_cache_header_engine_node +++ +++ starting code for primitive_invalidate_cache_header_engine_node +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N1/r23, {constant "general_engine_node_n_entry"} st N1/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_invalidate_cache_header_engine_node +++ +++ No Source Code Locators for primitive_invalidate_cache_header_engine_node +++ +++ Exported function definition initialize_engine_node_table_entries_1 +++ +++ starting code for initialize_engine_node_table_entries_1 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "general_engine_node_spread_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_1 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_1 +++ +++ Exported function definition initialize_engine_node_table_entries_2 +++ +++ starting code for initialize_engine_node_table_entries_2 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "single_method_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_2 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_2 +++ +++ Exported function definition initialize_engine_node_table_entries_3 +++ +++ starting code for initialize_engine_node_table_entries_3 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is green with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move G0/r3, r3 ld N1/r23, G0/r3, 4 asr N1/r23, N1/r23, 8 and N1/r23, N1/r23, 255 move N2/r22, {constant "implicit_keyed_single_method_entry"} bge {tag 1:95}, N1/r23, 6 #() [35->40] (level:0) is green with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 2:45}) 45 50}) bne {tag 2:45}, N1/r23, 0 #() [40->45] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "implicit_keyed_single_method_entry_0"} #({tag 1:95}, {tag 7:95}) [95->105] (level:0) is green with stack state #f #({basic-block #() 105 110}) st N2/r22, G0/r3, 12 move r3, G0/r3 #() [105->110] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 2:45}) [45->50] (level:0) is green with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 3:55}) 55 60}) bne {tag 3:55}, N1/r23, 1 #() [50->55] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "implicit_keyed_single_method_entry_1"} #() [110->115] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 3:55}) [55->60] (level:0) is green with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 4:65}) 65 70}) bne {tag 4:65}, N1/r23, 2 #() [60->65] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "implicit_keyed_single_method_entry_2"} #() [115->120] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 4:65}) [65->70] (level:0) is green with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 5:75}) 75 80}) bne {tag 5:75}, N1/r23, 3 #() [70->75] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "implicit_keyed_single_method_entry_3"} #() [120->125] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 5:75}) [75->80] (level:0) is green with stack state #f #({basic-block #() 80 85}, {basic-block #({tag 6:85}) 85 90}) bne {tag 6:85}, N1/r23, 4 #() [80->85] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "implicit_keyed_single_method_entry_4"} #() [125->130] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 6:85}) [85->90] (level:0) is green with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 1:95}, {tag 7:95}) 95 105}) bne {tag 7:95}, N1/r23, 5 #() [90->95] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "implicit_keyed_single_method_entry_5"} #() [130->135] (level:0) is #f with stack state #f #() bra {tag 1:95} +++ ending code for initialize_engine_node_table_entries_3 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_3 +++ +++ Exported function definition initialize_engine_node_table_entries_4 +++ +++ starting code for initialize_engine_node_table_entries_4 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is green with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move G0/r3, r3 ld N1/r23, G0/r3, 4 asr N1/r23, N1/r23, 8 and N1/r23, N1/r23, 255 move N2/r22, {constant "explicit_keyed_single_method_entry"} bge {tag 1:95}, N1/r23, 6 #() [35->40] (level:0) is green with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 2:45}) 45 50}) bne {tag 2:45}, N1/r23, 0 #() [40->45] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "explicit_keyed_single_method_entry_0"} #({tag 1:95}, {tag 7:95}) [95->105] (level:0) is green with stack state #f #({basic-block #() 105 110}) st N2/r22, G0/r3, 12 move r3, G0/r3 #() [105->110] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 2:45}) [45->50] (level:0) is green with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 3:55}) 55 60}) bne {tag 3:55}, N1/r23, 1 #() [50->55] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "explicit_keyed_single_method_entry_1"} #() [110->115] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 3:55}) [55->60] (level:0) is green with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 4:65}) 65 70}) bne {tag 4:65}, N1/r23, 2 #() [60->65] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "explicit_keyed_single_method_entry_2"} #() [115->120] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 4:65}) [65->70] (level:0) is green with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 5:75}) 75 80}) bne {tag 5:75}, N1/r23, 3 #() [70->75] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "explicit_keyed_single_method_entry_3"} #() [120->125] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 5:75}) [75->80] (level:0) is green with stack state #f #({basic-block #() 80 85}, {basic-block #({tag 6:85}) 85 90}) bne {tag 6:85}, N1/r23, 4 #() [80->85] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "explicit_keyed_single_method_entry_4"} #() [125->130] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 6:85}) [85->90] (level:0) is green with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 1:95}, {tag 7:95}) 95 105}) bne {tag 7:95}, N1/r23, 5 #() [90->95] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "explicit_keyed_single_method_entry_5"} #() [130->135] (level:0) is #f with stack state #f #() bra {tag 1:95} +++ ending code for initialize_engine_node_table_entries_4 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_4 +++ +++ Exported function definition initialize_engine_node_table_entries_5 +++ +++ starting code for initialize_engine_node_table_entries_5 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is green with stack state #f #({basic-block #() 35 40}, {basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move G0/r3, r3 ld N1/r23, G0/r3, 4 asr N1/r23, N1/r23, 8 and N1/r23, N1/r23, 255 move N2/r22, {constant "unrestricted_keyed_single_method_entry"} bge {tag 1:95}, N1/r23, 6 #() [35->40] (level:0) is green with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 2:45}) 45 50}) bne {tag 2:45}, N1/r23, 0 #() [40->45] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "unrestricted_keyed_single_method_entry_0"} #({tag 1:95}, {tag 7:95}) [95->105] (level:0) is green with stack state #f #({basic-block #() 105 110}) st N2/r22, G0/r3, 12 move r3, G0/r3 #() [105->110] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 2:45}) [45->50] (level:0) is green with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 3:55}) 55 60}) bne {tag 3:55}, N1/r23, 1 #() [50->55] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "unrestricted_keyed_single_method_entry_1"} #() [110->115] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 3:55}) [55->60] (level:0) is green with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 4:65}) 65 70}) bne {tag 4:65}, N1/r23, 2 #() [60->65] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "unrestricted_keyed_single_method_entry_2"} #() [115->120] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 4:65}) [65->70] (level:0) is green with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 5:75}) 75 80}) bne {tag 5:75}, N1/r23, 3 #() [70->75] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "unrestricted_keyed_single_method_entry_3"} #() [120->125] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 5:75}) [75->80] (level:0) is green with stack state #f #({basic-block #() 80 85}, {basic-block #({tag 6:85}) 85 90}) bne {tag 6:85}, N1/r23, 4 #() [80->85] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "unrestricted_keyed_single_method_entry_4"} #() [125->130] (level:0) is #f with stack state #f #() bra {tag 1:95} #({tag 6:85}) [85->90] (level:0) is green with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 1:95}, {tag 7:95}) 95 105}) bne {tag 7:95}, N1/r23, 5 #() [90->95] (level:0) is green with stack state #f #({basic-block #({tag 1:95}, {tag 7:95}) 95 105}) move N2/r22, {constant "unrestricted_keyed_single_method_entry_5"} #() [130->135] (level:0) is #f with stack state #f #() bra {tag 1:95} +++ ending code for initialize_engine_node_table_entries_5 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_5 +++ +++ Exported function definition initialize_engine_node_table_entries_13 +++ +++ starting code for initialize_engine_node_table_entries_13 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "profiling_cache_header_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_13 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_13 +++ +++ Exported function definition initialize_engine_node_table_entries_14 +++ +++ starting code for initialize_engine_node_table_entries_14 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "cache_header_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_14 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_14 +++ +++ Exported function definition initialize_engine_node_table_entries_16 +++ +++ starting code for initialize_engine_node_table_entries_16 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "boxed_instance_slot_getter_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_16 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_16 +++ +++ Exported function definition initialize_engine_node_table_entries_17 +++ +++ starting code for initialize_engine_node_table_entries_17 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "boxed_instance_slot_setter_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_17 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_17 +++ +++ Exported function definition initialize_engine_node_table_entries_18 +++ +++ starting code for initialize_engine_node_table_entries_18 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "boxed_repeated_instance_slot_getter_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_18 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_18 +++ +++ Exported function definition initialize_engine_node_table_entries_19 +++ +++ starting code for initialize_engine_node_table_entries_19 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "boxed_repeated_instance_slot_setter_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_19 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_19 +++ +++ Exported function definition initialize_engine_node_table_entries_22 +++ +++ starting code for initialize_engine_node_table_entries_22 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "raw_byte_repeated_instance_slot_getter_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_22 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_22 +++ +++ Exported function definition initialize_engine_node_table_entries_23 +++ +++ starting code for initialize_engine_node_table_entries_23 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "raw_byte_repeated_instance_slot_setter_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_23 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_23 +++ +++ Exported function definition initialize_engine_node_table_entries_20 +++ +++ starting code for initialize_engine_node_table_entries_20 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "general_engine_node_1_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_20 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_20 +++ +++ Exported function definition initialize_engine_node_table_entries_21 +++ +++ starting code for initialize_engine_node_table_entries_21 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "general_engine_node_2_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_21 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_21 +++ +++ Exported function definition initialize_engine_node_table_entries_29 +++ +++ starting code for initialize_engine_node_table_entries_29 +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "general_engine_node_3_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_29 +++ +++ No Source Code Locators for initialize_engine_node_table_entries_29 +++ +++ Exported function definition initialize_engine_node_table_entries_default +++ +++ starting code for initialize_engine_node_table_entries_default +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state #f #({basic-block #() 25 30}) move G0/r3, r3 move N2/r23, {constant "general_engine_node_n_entry"} st N2/r23, G0/r3, 12 move r3, G0/r3 #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for initialize_engine_node_table_entries_default +++ +++ No Source Code Locators for initialize_engine_node_table_entries_default +++ +++ Exported function definition primitive_initialize_engine_node +++ +++ starting code for primitive_initialize_engine_node +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is green with stack state #f #({basic-block #() 20 25}) ld N0/r23, r3, 4 and N0/r23, N0/r23, 252 ld N1/r23, {constant "Kinitialize_engine_node_table"}, N0/r23 #() [20->25] (level:0) is green with stack state #f #() jmp N1/r23, 4, 0, #f, #f +++ ending code for primitive_initialize_engine_node +++ +++ No Source Code Locators for primitive_initialize_engine_node +++ +++ Exported function definition primitive_initialize_discriminator +++ +++ starting code for primitive_initialize_discriminator +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is green with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 1:140}) 140 150}) move G0/r3, r3 ld N1/r23, G0/r3, 4 asr N1/r23, N1/r23, 8 and N1/r23, N1/r23, 255 ld N3/r22, G0/r3, 4 asr N3/r22, N3/r22, 2 and N3/r22, N3/r22, 63 beq {tag 1:140}, N3/r22, 33 #() [45->50] (level:0) is green with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 2:220}) 220 230}) beq {tag 2:220}, N3/r22, 32 #() [50->55] (level:0) is green with stack state #f #({basic-block #() 55 60}, {basic-block #({tag 3:300}) 300 310}) beq {tag 3:300}, N3/r22, 42 #() [55->60] (level:0) is green with stack state #f #({basic-block #() 60 70}, {basic-block #({tag 4:380}) 380 385}) beq {tag 4:380}, N3/r22, 13 #() [60->70] (level:0) is green with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry"} bge {tag 6:385}, N1/r23, 7 #() [70->75] (level:0) is green with stack state #f #({basic-block #() 75 80}, {basic-block #({tag 7:80}) 80 85}) bne {tag 7:80}, N1/r23, 0 #() [75->80] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry_0"} #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) [385->395] (level:0) is green with stack state #f #({basic-block #() 395 400}) st N2/r22, G0/r3, 12 move r3, G0/r3 #() [395->400] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:140}) [140->150] (level:0) is green with stack state #f #({basic-block #() 150 155}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine"} bge {tag 14:385}, N1/r23, 7 #() [150->155] (level:0) is green with stack state #f #({basic-block #() 155 160}, {basic-block #({tag 15:160}) 160 165}) bne {tag 15:160}, N1/r23, 0 #() [155->160] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine_0"} #() [400->405] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 2:220}) [220->230] (level:0) is green with stack state #f #({basic-block #() 230 235}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine"} bge {tag 22:385}, N1/r23, 7 #() [230->235] (level:0) is green with stack state #f #({basic-block #() 235 240}, {basic-block #({tag 23:240}) 240 245}) bne {tag 23:240}, N1/r23, 0 #() [235->240] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine_0"} #() [405->410] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 3:300}) [300->310] (level:0) is green with stack state #f #({basic-block #() 310 315}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine"} bge {tag 30:385}, N1/r23, 7 #() [310->315] (level:0) is green with stack state #f #({basic-block #() 315 320}, {basic-block #({tag 31:320}) 320 325}) bne {tag 31:320}, N1/r23, 0 #() [315->320] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine_0"} #() [410->415] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 4:380}) [380->385] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "profiling_cache_header_entry"} #() [415->420] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 7:80}) [80->85] (level:0) is green with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 8:90}) 90 95}) bne {tag 8:90}, N1/r23, 1 #() [85->90] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry_1"} #() [420->425] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 15:160}) [160->165] (level:0) is green with stack state #f #({basic-block #() 165 170}, {basic-block #({tag 16:170}) 170 175}) bne {tag 16:170}, N1/r23, 1 #() [165->170] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine_1"} #() [425->430] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 23:240}) [240->245] (level:0) is green with stack state #f #({basic-block #() 245 250}, {basic-block #({tag 24:250}) 250 255}) bne {tag 24:250}, N1/r23, 1 #() [245->250] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine_1"} #() [430->435] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 31:320}) [320->325] (level:0) is green with stack state #f #({basic-block #() 325 330}, {basic-block #({tag 32:330}) 330 335}) bne {tag 32:330}, N1/r23, 1 #() [325->330] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine_1"} #() [435->440] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 8:90}) [90->95] (level:0) is green with stack state #f #({basic-block #() 95 100}, {basic-block #({tag 9:100}) 100 105}) bne {tag 9:100}, N1/r23, 2 #() [95->100] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry_2"} #() [440->445] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 16:170}) [170->175] (level:0) is green with stack state #f #({basic-block #() 175 180}, {basic-block #({tag 17:180}) 180 185}) bne {tag 17:180}, N1/r23, 2 #() [175->180] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine_2"} #() [445->450] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 24:250}) [250->255] (level:0) is green with stack state #f #({basic-block #() 255 260}, {basic-block #({tag 25:260}) 260 265}) bne {tag 25:260}, N1/r23, 2 #() [255->260] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine_2"} #() [450->455] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 32:330}) [330->335] (level:0) is green with stack state #f #({basic-block #() 335 340}, {basic-block #({tag 33:340}) 340 345}) bne {tag 33:340}, N1/r23, 2 #() [335->340] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine_2"} #() [455->460] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 9:100}) [100->105] (level:0) is green with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 10:110}) 110 115}) bne {tag 10:110}, N1/r23, 3 #() [105->110] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry_3"} #() [460->465] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 17:180}) [180->185] (level:0) is green with stack state #f #({basic-block #() 185 190}, {basic-block #({tag 18:190}) 190 195}) bne {tag 18:190}, N1/r23, 3 #() [185->190] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine_3"} #() [465->470] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 25:260}) [260->265] (level:0) is green with stack state #f #({basic-block #() 265 270}, {basic-block #({tag 26:270}) 270 275}) bne {tag 26:270}, N1/r23, 3 #() [265->270] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine_3"} #() [470->475] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 33:340}) [340->345] (level:0) is green with stack state #f #({basic-block #() 345 350}, {basic-block #({tag 34:350}) 350 355}) bne {tag 34:350}, N1/r23, 3 #() [345->350] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine_3"} #() [475->480] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 10:110}) [110->115] (level:0) is green with stack state #f #({basic-block #() 115 120}, {basic-block #({tag 11:120}) 120 125}) bne {tag 11:120}, N1/r23, 4 #() [115->120] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry_4"} #() [480->485] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 18:190}) [190->195] (level:0) is green with stack state #f #({basic-block #() 195 200}, {basic-block #({tag 19:200}) 200 205}) bne {tag 19:200}, N1/r23, 4 #() [195->200] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine_4"} #() [485->490] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 26:270}) [270->275] (level:0) is green with stack state #f #({basic-block #() 275 280}, {basic-block #({tag 27:280}) 280 285}) bne {tag 27:280}, N1/r23, 4 #() [275->280] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine_4"} #() [490->495] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 34:350}) [350->355] (level:0) is green with stack state #f #({basic-block #() 355 360}, {basic-block #({tag 35:360}) 360 365}) bne {tag 35:360}, N1/r23, 4 #() [355->360] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine_4"} #() [495->500] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 11:120}) [120->125] (level:0) is green with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 12:130}) 130 135}) bne {tag 12:130}, N1/r23, 5 #() [125->130] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry_5"} #() [500->505] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 19:200}) [200->205] (level:0) is green with stack state #f #({basic-block #() 205 210}, {basic-block #({tag 20:210}) 210 215}) bne {tag 20:210}, N1/r23, 5 #() [205->210] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine_5"} #() [505->510] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 27:280}) [280->285] (level:0) is green with stack state #f #({basic-block #() 285 290}, {basic-block #({tag 28:290}) 290 295}) bne {tag 28:290}, N1/r23, 5 #() [285->290] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine_5"} #() [510->515] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 35:360}) [360->365] (level:0) is green with stack state #f #({basic-block #() 365 370}, {basic-block #({tag 36:370}) 370 375}) bne {tag 36:370}, N1/r23, 5 #() [365->370] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine_5"} #() [515->520] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 12:130}) [130->135] (level:0) is green with stack state #f #({basic-block #() 135 140}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) bne {tag 13:385}, N1/r23, 6 #() [135->140] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "discriminate_on_argument_entry_6"} #() [520->525] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 20:210}) [210->215] (level:0) is green with stack state #f #({basic-block #() 215 220}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) bne {tag 21:385}, N1/r23, 6 #() [215->220] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "if_type_discriminator_engine_6"} #() [525->530] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 28:290}) [290->295] (level:0) is green with stack state #f #({basic-block #() 295 300}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) bne {tag 29:385}, N1/r23, 6 #() [295->300] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "typecheck_discriminator_engine_6"} #() [530->535] (level:0) is #f with stack state #f #() bra {tag 5:385} #({tag 36:370}) [370->375] (level:0) is green with stack state #f #({basic-block #() 375 380}, {basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) bne {tag 37:385}, N1/r23, 6 #() [375->380] (level:0) is green with stack state #f #({basic-block #({tag 5:385}, {tag 6:385}, {tag 13:385}, {tag 14:385}, {tag 21:385}, {tag 22:385}, {tag 29:385}, {tag 30:385}, {tag 37:385}) 385 395}) move N2/r22, {constant "monomorphic_by_class_discriminator_engine_6"} #() [535->540] (level:0) is #f with stack state #f #() bra {tag 5:385} +++ ending code for primitive_initialize_discriminator +++ +++ No Source Code Locators for primitive_initialize_discriminator +++ +++ Exported function definition primitive_set_generic_function_entrypoints +++ +++ starting code for primitive_set_generic_function_entrypoints +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 50}) rem "This is a dummy first basic block." #() [5->50] (level:0) is green with stack state #f #({basic-block #() 50 60}, {basic-block #({tag 1:135}) 135 145}) move G0/r3, r3 ld N3/r23, G0/r3, 8 ld N3/r23, N3/r23, 4 asr N3/r23, N3/r23, 2 and N3/r23, N3/r23, 255 ld N4/r22, G0/r3, 8 ld N4/r22, N4/r22, 4 and N4/r22, N4/r22, 1310720 bne {tag 1:135}, N4/r22, 0 #() [50->60] (level:0) is green with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep"} bge {tag 3:130}, N3/r23, 7 #() [60->65] (level:0) is green with stack state #f #({basic-block #() 65 70}, {basic-block #({tag 4:70}) 70 75}) bne {tag 4:70}, N3/r23, 0 #() [65->70] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep_0"} #({tag 3:130}, {tag 10:130}) [130->135] (level:0) is green with stack state #f #({basic-block #({tag 2:225}) 220 225}) st N2/r22, G0/r3, 4 #({tag 2:225}) [220->225] (level:0) is green with stack state #f #({basic-block #({tag 2:225}) 225 230}) move r3, G0/r3 #({tag 2:225}) [225->230] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 1:135}) [135->145] (level:0) is green with stack state #f #({basic-block #() 145 150}, {basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep"} bge {tag 11:215}, N3/r23, 7 #() [145->150] (level:0) is green with stack state #f #({basic-block #() 150 155}, {basic-block #({tag 12:155}) 155 160}) bne {tag 12:155}, N3/r23, 0 #() [150->155] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep_0"} #({tag 11:215}, {tag 18:215}) [215->220] (level:0) is green with stack state #f #({basic-block #({tag 2:225}) 220 225}) st N2/r22, G0/r3, 4 #() [230->235] (level:0) is #f with stack state #f #() bra {tag 2:225} #({tag 4:70}) [70->75] (level:0) is green with stack state #f #({basic-block #() 75 80}, {basic-block #({tag 5:80}) 80 85}) bne {tag 5:80}, N3/r23, 1 #() [75->80] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep_1"} #() [235->240] (level:0) is #f with stack state #f #() bra {tag 3:130} #({tag 12:155}) [155->160] (level:0) is green with stack state #f #({basic-block #() 160 165}, {basic-block #({tag 13:165}) 165 170}) bne {tag 13:165}, N3/r23, 1 #() [160->165] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep_1"} #() [240->245] (level:0) is #f with stack state #f #() bra {tag 11:215} #({tag 5:80}) [80->85] (level:0) is green with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 95}) bne {tag 6:90}, N3/r23, 2 #() [85->90] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep_2"} #() [245->250] (level:0) is #f with stack state #f #() bra {tag 3:130} #({tag 13:165}) [165->170] (level:0) is green with stack state #f #({basic-block #() 170 175}, {basic-block #({tag 14:175}) 175 180}) bne {tag 14:175}, N3/r23, 2 #() [170->175] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep_2"} #() [250->255] (level:0) is #f with stack state #f #() bra {tag 11:215} #({tag 6:90}) [90->95] (level:0) is green with stack state #f #({basic-block #() 95 100}, {basic-block #({tag 7:100}) 100 105}) bne {tag 7:100}, N3/r23, 3 #() [95->100] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep_3"} #() [255->260] (level:0) is #f with stack state #f #() bra {tag 3:130} #({tag 14:175}) [175->180] (level:0) is green with stack state #f #({basic-block #() 180 185}, {basic-block #({tag 15:185}) 185 190}) bne {tag 15:185}, N3/r23, 3 #() [180->185] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep_3"} #() [260->265] (level:0) is #f with stack state #f #() bra {tag 11:215} #({tag 7:100}) [100->105] (level:0) is green with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 8:110}) 110 115}) bne {tag 8:110}, N3/r23, 4 #() [105->110] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep_4"} #() [265->270] (level:0) is #f with stack state #f #() bra {tag 3:130} #({tag 15:185}) [185->190] (level:0) is green with stack state #f #({basic-block #() 190 195}, {basic-block #({tag 16:195}) 195 200}) bne {tag 16:195}, N3/r23, 4 #() [190->195] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep_4"} #() [270->275] (level:0) is #f with stack state #f #() bra {tag 11:215} #({tag 8:110}) [110->115] (level:0) is green with stack state #f #({basic-block #() 115 120}, {basic-block #({tag 9:120}) 120 125}) bne {tag 9:120}, N3/r23, 5 #() [115->120] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep_5"} #() [275->280] (level:0) is #f with stack state #f #() bra {tag 3:130} #({tag 16:195}) [195->200] (level:0) is green with stack state #f #({basic-block #() 200 205}, {basic-block #({tag 17:205}) 205 210}) bne {tag 17:205}, N3/r23, 5 #() [200->205] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep_5"} #() [280->285] (level:0) is #f with stack state #f #() bra {tag 11:215} #({tag 9:120}) [120->125] (level:0) is green with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 3:130}, {tag 10:130}) 130 135}) bne {tag 10:130}, N3/r23, 6 #() [125->130] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/r22, {constant "new_gf_xep_6"} #() [285->290] (level:0) is #f with stack state #f #() bra {tag 3:130} #({tag 17:205}) [205->210] (level:0) is green with stack state #f #({basic-block #() 210 215}, {basic-block #({tag 11:215}, {tag 18:215}) 215 220}) bne {tag 18:215}, N3/r23, 6 #() [210->215] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/r22, {constant "new_gf_optional_xep_6"} #() [290->295] (level:0) is #f with stack state #f #() bra {tag 11:215} +++ ending code for primitive_set_generic_function_entrypoints +++ +++ No Source Code Locators for primitive_set_generic_function_entrypoints +++ +++ Defining function primitive_preboot_symbols in section init-code +++ +++ Exported function definition primitive_preboot_symbols +++ +++ starting code for primitive_preboot_symbols +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state before #({basic-block #() 25 30}, {basic-block #({tag 8:150}) 150 165}) add N4/r23, {indirect-constant "Poblist"}, 8 sub N5/r5, {indirect-constant "PoblistUcursor"}, 8 asr N5/r5, N5/r5, 2 bne {tag 8:150}, N5/r5, 0 #() [25->30] (level:0) is green with stack state before #({basic-block #({tag 1:85}) 85 105}) move G6/r3, {constant "KPempty_vectorVKi"} #({tag 1:85}) [85->105] (level:0) is green with stack state before #({basic-block #({tag 6:105}) 105 110}) move {indirect-constant "PoblistUsize"}, 8 move {indirect-constant "PoblistUcursor"}, 8 move {indirect-constant "Poblist"}, 0 move r3, G6/r3 #({tag 6:105}) [105->110] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 8:150}) [150->165] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 110 120}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:30}) [110->120] (level:0) is brown with stack state with #({basic-block #({tag 3:30}, {tag 2:30}) 30 75}) move N0/r23, N4/r23 move N1/r5, N5/r5 #({tag 3:30}, {tag 2:30}) [30->75] (level:0) is red with stack state with #({basic-block #() 75 85}) asl N3/r3, N1/r5, 2 add N3/r3, N3/r3, 8 sub r1, r1, 24 move r3, N3/r3 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N1/r5 move r6, 1 move r7, N0/r23 call-alien {constant "primitive_alloc_rt"}, 0 #() [75->85] (level:0) is red with stack state with #({basic-block #({tag 4:125}) 120 125}) add r1, r1, 24 move G2/r3, r3 #({tag 4:125}) [120->125] (level:0) is yellow with stack state with #({basic-block #({tag 4:125}, {tag 5:125}) 125 145}) move G6/r3, G2/r3 #({tag 4:125}, {tag 5:125}) [125->145] (level:0) is green with stack state with #({basic-block #({tag 7:145}) 145 150}) move {indirect-constant "PoblistUsize"}, 8 move {indirect-constant "PoblistUcursor"}, 8 move {indirect-constant "Poblist"}, 0 move r3, G6/r3 #({tag 7:145}) [145->150] (level:0) is #f with stack state #f #({basic-block #({tag 6:105}) 105 110}) preserve-registers-exit #() [165->170] (level:0) is #f with stack state #f #() bra {tag 6:105} +++ ending code for primitive_preboot_symbols +++ +++ Live variable scopes for primitive_preboot_symbols +++ Start scope at 50 with frame for no variables End scope at 91 +++ No Source Code Locators for primitive_preboot_symbols +++ +++ Defining function primitive_make_symbol in section init-code +++ +++ Exported function definition primitive_make_symbol +++ +++ starting code for primitive_make_symbol +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:55}) 55 70}) rem "This is a dummy first basic block." #({tag 2:55}) [55->70] (level:0) is #f with stack state #f #({basic-block #() 5 35}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->35] (level:0) is red with stack state with #({basic-block #() 35 45}) move G0/r5, r3 sub r1, r1, 24 move r3, 8 move r4, {constant "KLsymbolGVKdW"} move r5, G0/r5 call-alien {constant "primitive_alloc_s1"}, 0 #() [35->45] (level:0) is red with stack state with #({basic-block #({tag 1:50}) 50 55}) add r1, r1, 24 move r3, r3 #({tag 1:50}) [50->55] (level:0) is #f with stack state #f #({basic-block #() 45 50}) preserve-registers-exit #() [45->50] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_make_symbol +++ +++ Live variable scopes for primitive_make_symbol +++ Start scope at 8 with frame for no variables End scope at 27 +++ No Source Code Locators for primitive_make_symbol +++ +++ Defining function primitive_string_as_symbol in section init-code +++ +++ Exported function definition primitive_string_as_symbol +++ +++ starting code for primitive_string_as_symbol +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 25}) rem "This is a dummy first basic block." #() [5->25] (level:0) is green with stack state before #({basic-block #({tag 3:25}) 25 30}) move G20/r5, r3 move N3/r17, {indirect-constant "PoblistUcursor"} move N4/r18, {indirect-constant "Poblist"} move N5/r20, 8 #({tag 3:25}) [25->30] (level:1) is green with stack state before #({basic-block #() 30 55}, {basic-block #({tag 2:130}) 130 135}) bge {tag 2:130}, N5/r20, N3/r17 #() [30->55] (level:1) is green with stack state before #({basic-block #() 55 65}, {basic-block #({tag 5:125}) 125 130}) ld G21/r3, N4/r18, N5/r20 ld G2/r19, G21/r3, 4 ld N7/r21, G20/r5, 4 ld N8/r23, G2/r19, 4 bne {tag 5:125}, N7/r21, N8/r23 #() [55->65] (level:1) is green with stack state before #({basic-block #({tag 7:65}) 65 70}) asr N6/r21, N7/r21, 2 sub N6/r21, N6/r21, 1 #({tag 7:65}) [65->70] (level:2) is green with stack state before #({basic-block #() 70 95}, {basic-block #({tag 4:135}) 135 140}) blt {tag 4:135}, N6/r21, 0 #() [70->95] (level:2) is green with stack state before #({basic-block #() 95 105}, {basic-block #({tag 6:120}) 120 125}) add N11/r22, N6/r21, 8 ldb N9/r22, G20/r5, N11/r22 add N12/r23, N6/r21, 8 ldb N10/r23, G2/r19, N12/r23 beq {tag 6:120}, N9/r22, N10/r23 #() [95->105] (level:2) is green with stack state before #({basic-block #() 105 115}, {basic-block #({tag 5:125}) 125 130}) eor N9/r22, N9/r22, N10/r23 bne {tag 5:125}, N9/r22, 32 #() [105->115] (level:2) is green with stack state before #({basic-block #() 115 120}, {basic-block #({tag 5:125}) 125 130}) or N10/r23, N10/r23, 32 blt {tag 5:125}, N10/r23, 97 #() [115->120] (level:2) is green with stack state before #({basic-block #({tag 6:120}) 120 125}, {basic-block #({tag 5:125}) 125 130}) bgt {tag 5:125}, N10/r23, 122 #({tag 6:120}) [120->125] (level:1) is green with stack state before #({basic-block #({tag 7:65}) 65 70}) sub N6/r21, N6/r21, 1 #() [350->355] (level:0) is #f with stack state #f #() bra {tag 7:65} #({tag 2:130}) [130->135] (level:1) is green with stack state before #({basic-block #({tag 4:135}) 135 140}) move G21/r3, {constant "KPfalseVKi"} #({tag 4:135}) [135->140] (level:2) is green with stack state before #({basic-block #({tag 14:335}) 335 350}, {basic-block #({tag 1:310}) 305 310}) bne {tag 1:310}, G21/r3, {constant "KPfalseVKi"} #({tag 14:335}) [335->350] (level:0) is #f with stack state #f #({basic-block #({tag 9:140}) 315 320}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 9:140}) [315->320] (level:2) is brown with stack state with #({basic-block #({tag 9:140}) 140 165}) move G0/r5, G20/r5 #({tag 9:140}) [140->165] (level:2) is red with stack state with #({basic-block #() 165 195}) sub r1, r1, 24 move r3, 8 move r4, {constant "KLsymbolGVKdW"} move r5, G0/r5 call-alien {constant "primitive_alloc_s1"}, 0 #() [165->195] (level:2) is red with stack state with #({basic-block #() 195 255}, {basic-block #({tag 8:290}) 290 305}) add r1, r1, 24 move G1/GSPILL-0, r3 move N14/NSPILL-0, {indirect-constant "PoblistUsize"} move N17/NSPILL-1, {indirect-constant "PoblistUcursor"} move G13/r23, {indirect-constant "Poblist"} blt {tag 8:290}, N17/NSPILL-1, N14/NSPILL-0 #() [195->255] (level:2) is red with stack state with #({basic-block #() 255 290}) sub N15/NSPILL-2, N14/NSPILL-0, 8 add N14/NSPILL-0, N14/NSPILL-0, 1024 add N19/NSPILL-3, G13/r23, 8 sub N16/r5, N14/NSPILL-0, 8 asr N16/r5, N16/r5, 2 sub r1, r1, 24 move r3, N14/NSPILL-0 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N16/r5 move r6, 1 move r7, {constant "KPunboundVKi"} call-alien {constant "primitive_alloc_rf"}, 0 #() [255->290] (level:2) is red with stack state with #({basic-block #({tag 8:290}) 290 305}) add r1, r1, 24 move {indirect-constant "Poblist"}, r3 move G13/r23, r3 add N18/r3, r3, 8 move {indirect-constant "PoblistUsize"}, N14/NSPILL-0 asr N15/NSPILL-2, N15/NSPILL-2, 2 copy-words-down-w N18/r3, N19/NSPILL-3, N15/NSPILL-2 #({tag 8:290}) [290->305] (level:2) is red with stack state with #({basic-block #({tag 10:320}) 320 325}) st G1/GSPILL-0, G13/r23, N17/NSPILL-1 add N17/NSPILL-1, N17/NSPILL-1, 4 move {indirect-constant "PoblistUcursor"}, N17/NSPILL-1 #({tag 10:320}) [320->325] (level:2) is yellow with stack state with #({basic-block #({tag 11:330}) 325 330}) move G21/r3, G1/GSPILL-0 #({tag 11:330}) [325->330] (level:2) is green with stack state with #({basic-block #({tag 11:330}, {tag 13:330}) 330 335}) move r3, G21/r3 #({tag 11:330}, {tag 13:330}) [330->335] (level:0) is #f with stack state #f #({basic-block #({tag 1:310}, {tag 12:310}) 310 315}) preserve-registers-exit #({tag 1:310}, {tag 12:310}) [310->315] (level:2) is green with stack state #f #() rts-and-drop 0 #({tag 5:125}) [125->130] (level:2) is green with stack state before #({basic-block #({tag 3:25}) 25 30}) add N5/r20, N5/r20, 4 #() [355->360] (level:0) is #f with stack state #f #() bra {tag 3:25} #({tag 1:310}) [305->310] (level:2) is green with stack state before #({basic-block #({tag 1:310}, {tag 12:310}) 310 315}) move r3, G21/r3 +++ ending code for primitive_string_as_symbol +++ +++ Frame sizes for primitive_string_as_symbol: GC: 1, NC: 4 +++ +++ Live variable scopes for primitive_string_as_symbol +++ Start scope at 88 with frame for no variables End scope at 239 +++ No Source Code Locators for primitive_string_as_symbol +++ +++ Defining function primitive_resolve_symbol in section init-code +++ +++ Exported function definition primitive_resolve_symbol +++ +++ starting code for primitive_resolve_symbol +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 30}) rem "This is a dummy first basic block." #() [5->30] (level:0) is green with stack state before #({basic-block #({tag 3:30}) 30 35}) move G21/r3, r3 ld G0/r17, G21/r3, 4 move N4/r15, {indirect-constant "PoblistUcursor"} move N5/r16, {indirect-constant "Poblist"} move N6/r19, 8 #({tag 3:30}) [30->35] (level:1) is green with stack state before #({basic-block #() 35 60}, {basic-block #({tag 2:135}) 135 140}) bge {tag 2:135}, N6/r19, N4/r15 #() [35->60] (level:1) is green with stack state before #({basic-block #() 60 70}, {basic-block #({tag 5:130}) 130 135}) ld G2/r20, N5/r16, N6/r19 ld G3/r18, G2/r20, 4 ld N8/r21, G0/r17, 4 ld N9/r23, G3/r18, 4 bne {tag 5:130}, N8/r21, N9/r23 #() [60->70] (level:1) is green with stack state before #({basic-block #({tag 7:70}) 70 75}) asr N7/r21, N8/r21, 2 sub N7/r21, N7/r21, 1 #({tag 7:70}) [70->75] (level:2) is green with stack state before #({basic-block #() 75 100}, {basic-block #({tag 4:140}) 140 145}) blt {tag 4:140}, N7/r21, 0 #() [75->100] (level:2) is green with stack state before #({basic-block #() 100 110}, {basic-block #({tag 6:125}) 125 130}) add N12/r22, N7/r21, 8 ldb N10/r22, G0/r17, N12/r22 add N13/r23, N7/r21, 8 ldb N11/r23, G3/r18, N13/r23 beq {tag 6:125}, N10/r22, N11/r23 #() [100->110] (level:2) is green with stack state before #({basic-block #() 110 120}, {basic-block #({tag 5:130}) 130 135}) eor N10/r22, N10/r22, N11/r23 bne {tag 5:130}, N10/r22, 32 #() [110->120] (level:2) is green with stack state before #({basic-block #() 120 125}, {basic-block #({tag 5:130}) 130 135}) or N11/r23, N11/r23, 32 blt {tag 5:130}, N11/r23, 97 #() [120->125] (level:2) is green with stack state before #({basic-block #({tag 6:125}) 125 130}, {basic-block #({tag 5:130}) 130 135}) bgt {tag 5:130}, N11/r23, 122 #({tag 6:125}) [125->130] (level:1) is green with stack state before #({basic-block #({tag 7:70}) 70 75}) sub N7/r21, N7/r21, 1 #() [370->375] (level:0) is #f with stack state #f #() bra {tag 7:70} #({tag 2:135}) [135->140] (level:1) is green with stack state before #({basic-block #({tag 4:140}) 140 145}) move G2/r20, {constant "KPfalseVKi"} #({tag 4:140}) [140->145] (level:2) is green with stack state before #({basic-block #() 145 165}, {basic-block #({tag 1:280}) 280 285}) bne {tag 1:280}, G2/r20, {constant "KPfalseVKi"} #() [145->165] (level:2) is green with stack state before #({basic-block #({tag 15:355}) 355 370}, {basic-block #({tag 8:260}) 260 280}) move N23/r21, {indirect-constant "PoblistUsize"} move N24/r23, {indirect-constant "PoblistUcursor"} move G22/r22, {indirect-constant "Poblist"} blt {tag 8:260}, N24/r23, N23/r21 #({tag 15:355}) [355->370] (level:0) is #f with stack state #f #({basic-block #({tag 9:290}) 290 310}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 9:290}) [290->310] (level:2) is brown with stack state with #({basic-block #() 165 225}) move G1/GSPILL-0, G21/r3 move G14/r22, G22/r22 move N15/NSPILL-0, N23/r21 move N18/NSPILL-3, N24/r23 #() [165->225] (level:2) is red with stack state with #({basic-block #() 225 260}) sub N16/NSPILL-1, N15/NSPILL-0, 8 add N15/NSPILL-0, N15/NSPILL-0, 1024 add N20/NSPILL-2, G14/r22, 8 sub N17/r5, N15/NSPILL-0, 8 asr N17/r5, N17/r5, 2 sub r1, r1, 24 move r3, N15/NSPILL-0 move r4, {constant "KLsimple_object_vectorGVKdW"} move r5, N17/r5 move r6, 1 move r7, {constant "KPunboundVKi"} call-alien {constant "primitive_alloc_rf"}, 0 #() [225->260] (level:2) is red with stack state with #({basic-block #({tag 10:310}) 310 325}) add r1, r1, 24 move {indirect-constant "Poblist"}, r3 move G14/r22, r3 add N19/r3, r3, 8 move {indirect-constant "PoblistUsize"}, N15/NSPILL-0 asr N16/NSPILL-1, N16/NSPILL-1, 2 copy-words-down-w N19/r3, N20/NSPILL-2, N16/NSPILL-1 #({tag 10:310}) [310->325] (level:2) is yellow with stack state with #({basic-block #({tag 11:325}) 325 345}) move G21/r3, G1/GSPILL-0 move G22/r22, G14/r22 move N24/r23, N18/NSPILL-3 #({tag 11:325}) [325->345] (level:2) is green with stack state with #({basic-block #({tag 12:345}) 345 350}) st G21/r3, G22/r22, N24/r23 add N24/r23, N24/r23, 4 move {indirect-constant "PoblistUcursor"}, N24/r23 move G2/r20, G21/r3 #({tag 12:345}) [345->350] (level:2) is green with stack state with #({basic-block #({tag 14:350}) 350 355}) move r3, G2/r20 #({tag 14:350}) [350->355] (level:0) is #f with stack state #f #({basic-block #({tag 13:285}) 285 290}) preserve-registers-exit #({tag 13:285}) [285->290] (level:2) is green with stack state #f #() rts-and-drop 0 #({tag 5:130}) [130->135] (level:2) is green with stack state before #({basic-block #({tag 3:30}) 30 35}) add N6/r19, N6/r19, 4 #() [375->380] (level:0) is #f with stack state #f #() bra {tag 3:30} #({tag 1:280}) [280->285] (level:2) is green with stack state before #({basic-block #({tag 13:285}) 285 290}) move r3, G2/r20 #() [380->385] (level:0) is #f with stack state #f #() bra {tag 13:285} #({tag 8:260}) [260->280] (level:2) is green with stack state before #({basic-block #({tag 1:280}) 280 285}) st G21/r3, G22/r22, N24/r23 add N24/r23, N24/r23, 4 move {indirect-constant "PoblistUcursor"}, N24/r23 move G2/r20, G21/r3 #() [385->390] (level:0) is #f with stack state #f #() bra {tag 1:280} +++ ending code for primitive_resolve_symbol +++ +++ Frame sizes for primitive_resolve_symbol: GC: 1, NC: 4 +++ +++ Live variable scopes for primitive_resolve_symbol +++ Start scope at 104 with frame for no variables End scope at 213 +++ No Source Code Locators for primitive_resolve_symbol +++ +++ Exported function definition dylan_stack_overflow_handler +++ +++ starting code for dylan_stack_overflow_handler +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 4:60}) 60 75}) rem "This is a dummy first basic block." #({tag 4:60}) [60->75] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 30}, {basic-block #({tag 1:45}) 45 50}) rem "eliminated" rem "eliminated" rem "eliminated" load-nlx-address {tag 1:45}, r3 #() [25->30] (level:0) is red with stack state with #({basic-block #() 30 35}) call {constant "primitive_build_unwind_protect_frame"}, 1 #() [30->35] (level:0) is red with stack state with #({basic-block #() 35 40}) call {constant "Kstack_overflow_errorVKiI"}, 0 #() [35->40] (level:0) is red with stack state with #({basic-block #() 40 45}) call {constant "primitive_unwind_protect_cleanup"}, 1 #() [40->45] (level:0) is red with stack state with #({basic-block #({tag 2:55}) 50 50}, {basic-block #({tag 1:45}) 45 50}) control-flow-link {tag 1:45} #({tag 2:55}) [50->50] (level:0) is red with stack state with #({basic-block #({tag 2:55}, {tag 3:55}) 55 60}) #({tag 2:55}, {tag 3:55}) [55->60] (level:0) is #f with stack state #f #({basic-block #() 50 55}) preserve-registers-exit #() [50->55] (level:0) is red with stack state #f #() rts #({tag 1:45}) [45->50] (level:1) is red with stack state with #({basic-block #() 50 50}, {basic-block #({tag 1:45}) 45 50}) end-cleanup {tag 1:45}, #[] #() [50->50] (level:0) is red with stack state #f #() +++ ending code for dylan_stack_overflow_handler +++ +++ Live variable scopes for dylan_stack_overflow_handler +++ Start scope at 10 with frame for no variables End scope at 37 +++ No Source Code Locators for dylan_stack_overflow_handler +++ +++ Exported function definition dylan_integer_overflow_handler +++ +++ starting code for dylan_integer_overflow_handler +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "Kmachine_word_overflowVKmI"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for dylan_integer_overflow_handler +++ +++ Live variable scopes for dylan_integer_overflow_handler +++ Start scope at 10 with frame for no variables End scope at 17 +++ No Source Code Locators for dylan_integer_overflow_handler +++ +++ Exported function definition dylan_integer_divide_0_handler +++ +++ starting code for dylan_integer_divide_0_handler +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "Kmachine_word_overflowVKmI"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for dylan_integer_divide_0_handler +++ +++ Live variable scopes for dylan_integer_divide_0_handler +++ Start scope at 10 with frame for no variables End scope at 17 +++ No Source Code Locators for dylan_integer_divide_0_handler +++ +++ Exported function definition dylan_float_divide_0_handler +++ +++ starting code for dylan_float_divide_0_handler +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:40}) 40 55}) rem "This is a dummy first basic block." #({tag 2:40}) [40->55] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 30}) clear-float-exceptions move r3, {constant "Kfloat_divide_0_error_string"} move r22, {constant "KerrorVKd"} move r0, 1 call-indirect r22, 4, 1 #() [30->30] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 40}) #({tag 1:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 30 35}) preserve-registers-exit #() [30->35] (level:0) is red with stack state #f #() rts +++ ending code for dylan_float_divide_0_handler +++ +++ Live variable scopes for dylan_float_divide_0_handler +++ Start scope at 10 with frame for no variables End scope at 25 +++ No Source Code Locators for dylan_float_divide_0_handler +++ +++ Exported function definition dylan_float_overflow_handler +++ +++ starting code for dylan_float_overflow_handler +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:40}) 40 55}) rem "This is a dummy first basic block." #({tag 2:40}) [40->55] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 30}) clear-float-exceptions move r3, {constant "Kfloat_overflow_error_string"} move r22, {constant "KerrorVKd"} move r0, 1 call-indirect r22, 4, 1 #() [30->30] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 40}) #({tag 1:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 30 35}) preserve-registers-exit #() [30->35] (level:0) is red with stack state #f #() rts +++ ending code for dylan_float_overflow_handler +++ +++ Live variable scopes for dylan_float_overflow_handler +++ Start scope at 10 with frame for no variables End scope at 25 +++ No Source Code Locators for dylan_float_overflow_handler +++ +++ Exported function definition dylan_float_underflow_handler +++ +++ starting code for dylan_float_underflow_handler +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:40}) 40 55}) rem "This is a dummy first basic block." #({tag 2:40}) [40->55] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 30}) clear-float-exceptions move r3, {constant "Kfloat_underflow_error_string"} move r22, {constant "KerrorVKd"} move r0, 1 call-indirect r22, 4, 1 #() [30->30] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 40}) #({tag 1:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 30 35}) preserve-registers-exit #() [30->35] (level:0) is red with stack state #f #() rts +++ ending code for dylan_float_underflow_handler +++ +++ Live variable scopes for dylan_float_underflow_handler +++ Start scope at 10 with frame for no variables End scope at 25 +++ No Source Code Locators for dylan_float_underflow_handler +++ +++ Exported function definition primitive_float_class +++ +++ starting code for primitive_float_class +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #({tag 1:15}) 15 25}) classify-float N1/r22, f1 move N0/r3, 0 #({tag 1:15}) [15->25] (level:1) is green with stack state #f #({basic-block #() 25 30}, {basic-block #({tag 2:30}) 30 40}) ld N2/r23, {constant "Kfloating_point_classes"}, N0/r3 beq {tag 2:30}, N1/r22, N2/r23 #() [25->30] (level:1) is green with stack state #f #({basic-block #({tag 1:15}) 15 25}) add N0/r3, N0/r3, 8 #() [45->50] (level:0) is #f with stack state #f #() bra {tag 1:15} #({tag 2:30}) [30->40] (level:1) is green with stack state #f #({basic-block #() 40 45}) add N0/r3, N0/r3, 4 ld r3, {constant "Kfloating_point_classes"}, N0/r3 #() [40->45] (level:1) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_float_class +++ +++ No Source Code Locators for primitive_float_class +++ +++ starting code for dylan_thread_trampoline +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 23:565}) 565 580}) rem "This is a dummy first basic block." #({tag 23:565}) [565->580] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 70}) move N0/NSPILL-2, r3 sub r1, r1, 24 move r3, 340 call-alien {constant "dylan__malloc__misc"}, 0 #() [25->70] (level:0) is red with stack state with #({basic-block #() 70 75}) add r1, r1, 24 move N6/NSPILL-0, r3 add N7/NSPILL-1, N6/NSPILL-0, 12 add N8/r5, N7/NSPILL-1, 328 sub r1, r1, 24 move r3, N6/NSPILL-0 move r4, N6/NSPILL-0 move r5, N8/r5 call-alien {constant "MMRegisterRootAmbig"}, 0 #() [70->75] (level:0) is red with stack state with #({basic-block #({tag 16:495}) 495 500}) add r1, r1, 24 #({tag 16:495}) [495->500] (level:1) is green with stack state with #({basic-block #({tag 17:80}) 80 85}, {basic-block #({tag 16:495}) 495 500}) conditional-move {tag 16:495}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 17:80}) [80->85] (level:0) is red with stack state with #({basic-block #() 85 90}, {basic-block #({tag 1:90}) 90 185}) beq {tag 1:90}, {indirect-constant "Pteb_chain"}, 0 #() [85->90] (level:0) is red with stack state with #({basic-block #({tag 1:90}) 90 185}) st N6/NSPILL-0, {indirect-constant "Pteb_chain"}, 8 #({tag 1:90}) [90->185] (level:0) is red with stack state with #({basic-block #() 185 195}) st {indirect-constant "Pteb_chain"}, N6/NSPILL-0, 4 st 0, N6/NSPILL-0, 8 move {indirect-constant "Pteb_chain"}, N6/NSPILL-0 move {indirect-constant "Pruntime_spin_lock"}, 0 add N3/r12, N7/NSPILL-1, 32 st 0, N7/NSPILL-1, 0 st 0, N7/NSPILL-1, 4 st 0, N3/r12, 0 st {constant "KPempty_listVKi"}, N3/r12, 16 st {constant "KPunboundVKi"}, N3/r12, 4 set-teb N3/r12 st N3/r12, {indirect-constant "Pteb_tlv_index"}, 0 st 0, N3/r12, 20 st -1, N3/r12, 20 sub N5/NSPILL-0, N3/r12, 32 or N9/r3, r1, 8188 sub r1, r1, 24 move r3, N9/r3 call-alien {constant "dylan_mm_register_thread"}, 0 #() [185->195] (level:0) is red with stack state with #({basic-block #() 195 205}, {basic-block #({tag 14:480}) 480 495}) add r1, r1, 24 beq {tag 14:480}, r3, 0 #() [195->205] (level:0) is red with stack state with #({basic-block #({tag 14:480}) 480 495}) st 0, {indirect-constant "Pteb_tlv_index"}, 0 halt #({tag 14:480}) [480->495] (level:1) is green with stack state with #({basic-block #({tag 15:220}) 220 260}, {basic-block #({tag 14:480}) 480 495}) move N10/r12, {indirect-constant "Pruntime_thread_count"} add N11/r6, N10/r12, 1 conditional-move {tag 14:480}, {indirect-constant "Pruntime_thread_count"}, N11/r6, N10/r12 #({tag 15:220}) [220->260] (level:0) is red with stack state with #({basic-block #() 260 295}) init-control-word push 0 move N2/NSPILL-1, r1 ld G1/GSPILL-0, N0/NSPILL-2, 0 sub r1, r1, 24 move r3, N0/NSPILL-2 move r4, 4 call-alien {constant "dylan__free__root"}, 0 #() [260->295] (level:0) is red with stack state with #({basic-block #() 295 315}) add r1, r1, 24 sub r1, r1, 24 move r3, N2/NSPILL-1 move r4, {constant "trampoline_body"} move r5, G1/GSPILL-0 move r6, 0 call-alien {constant "dylan_init_thread"}, 0 #() [295->315] (level:0) is red with stack state with #({basic-block #() 315 325}) add r1, r1, 24 sub r1, r1, 24 move r3, N5/NSPILL-0 call-alien {constant "dylan_mm_deregister_thread_from_teb"}, 0 #() [315->325] (level:0) is red with stack state with #({basic-block #({tag 12:465}) 465 480}) add r1, r1, 24 st 0, N5/NSPILL-0, 4 #({tag 12:465}) [465->480] (level:1) is green with stack state with #({basic-block #({tag 13:340}) 340 350}, {basic-block #({tag 12:465}) 465 480}) move N12/r12, {indirect-constant "Pruntime_thread_count"} sub N13/r6, N12/r12, 1 conditional-move {tag 12:465}, {indirect-constant "Pruntime_thread_count"}, N13/r6, N12/r12 #({tag 13:340}) [340->350] (level:0) is green with stack state with #({basic-block #({tag 10:460}) 460 465}) st 0, {indirect-constant "Pteb_tlv_index"}, 0 sub N14/r3, N5/NSPILL-0, 12 #({tag 10:460}) [460->465] (level:1) is green with stack state with #({basic-block #({tag 11:355}) 355 370}, {basic-block #({tag 10:460}) 460 465}) conditional-move {tag 10:460}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 11:355}) [355->370] (level:0) is red with stack state with #({basic-block #() 370 375}, {basic-block #({tag 6:375}) 375 380}) ld N15/r12, N14/r3, 4 ld N16/r11, N14/r3, 8 bne {tag 6:375}, {indirect-constant "Pteb_chain"}, N14/r3 #() [370->375] (level:0) is red with stack state with #({basic-block #({tag 7:380}) 380 385}) move {indirect-constant "Pteb_chain"}, N15/r12 #({tag 7:380}) [380->385] (level:0) is red with stack state with #({basic-block #() 385 390}, {basic-block #({tag 8:390}) 390 415}) beq {tag 8:390}, N15/r12, 0 #() [385->390] (level:0) is red with stack state with #({basic-block #({tag 8:390}) 390 415}) st N16/r11, N15/r12, 8 #({tag 8:390}) [390->415] (level:0) is red with stack state with #({basic-block #() 415 445}) move {indirect-constant "Pruntime_spin_lock"}, 0 ld N14/r3, N5/NSPILL-0, -12 sub r1, r1, 24 move r3, N14/r3 call-alien {constant "MMDeregisterRoot"}, 0 #() [415->445] (level:0) is red with stack state with #({basic-block #() 445 455}) add r1, r1, 24 sub N14/r3, N5/NSPILL-0, 12 sub r1, r1, 24 move r3, N14/r3 move r4, 340 call-alien {constant "MMFreeMisc"}, 0 #() [445->455] (level:0) is red with stack state with #({basic-block #({tag 18:500}) 500 505}) add r1, r1, 24 move r3, 0 #({tag 18:500}) [500->505] (level:0) is #f with stack state #f #({basic-block #() 455 460}) preserve-registers-exit #() [455->460] (level:0) is red with stack state #f #() rts #({tag 6:375}) [375->380] (level:0) is red with stack state with #({basic-block #({tag 7:380}) 380 385}) st N15/r12, N16/r11, 4 #() [580->585] (level:0) is #f with stack state #f #() bra {tag 7:380} +++ ending code for dylan_thread_trampoline +++ +++ Frame sizes for dylan_thread_trampoline: GC: 1, NC: 3 +++ +++ Live variable scopes for dylan_thread_trampoline +++ Start scope at 10 with frame for no variables End scope at 439 +++ No Source Code Locators for dylan_thread_trampoline +++ +++ Defining function DylanSOEntry in section init-code +++ +++ starting code for DylanSOEntry +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 9:195}) 195 210}) rem "This is a dummy first basic block." #({tag 9:195}) [195->210] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 80}) sub r1, r1, 24 move r3, 4 call-alien {constant "dylan__malloc__misc"}, 0 #() [20->80] (level:0) is red with stack state with #({basic-block #() 80 105}) add r1, r1, 24 move {indirect-constant "Pteb_tlv_index"}, r3 st 0, {constant "Pmaster_gc_teb"}, 0 st 0, {constant "Pmaster_gc_teb"}, 4 st 0, {constant "Pmaster_teb"}, 0 st {constant "KPempty_listVKi"}, {constant "Pmaster_teb"}, 16 st {constant "KPunboundVKi"}, {constant "Pmaster_teb"}, 4 set-teb {constant "Pmaster_teb"} st {constant "Pmaster_teb"}, {indirect-constant "Pteb_tlv_index"}, 0 st 0, {constant "Pmaster_teb"}, 20 sub r1, r1, 24 call-alien {constant "dylan_init_memory_manager"}, 0 #() [80->105] (level:0) is red with stack state with #({basic-block #() 105 115}) add r1, r1, 24 or N0/r3, r1, 8188 sub r1, r1, 24 move r3, N0/r3 call-alien {constant "dylan_mm_register_thread"}, 0 #() [105->115] (level:0) is red with stack state with #({basic-block #() 115 125}, {basic-block #({tag 5:160}) 160 160}) add r1, r1, 24 beq {tag 5:160}, r3, 0 #() [115->125] (level:0) is red with stack state with #({basic-block #({tag 5:160}) 160 160}) st 0, {indirect-constant "Pteb_tlv_index"}, 0 halt #({tag 5:160}) [160->160] (level:0) is yellow with stack state with #({basic-block #({tag 5:160}, {tag 6:160}) 160 175}) #({tag 5:160}, {tag 6:160}) [160->175] (level:1) is green with stack state with #({basic-block #({tag 4:140}) 160 160}, {basic-block #({tag 5:160}, {tag 6:160}) 160 175}) move N1/r12, {indirect-constant "Pruntime_thread_count"} add N2/r6, N1/r12, 1 conditional-move {tag 6:160}, {indirect-constant "Pruntime_thread_count"}, N2/r6, N1/r12 #({tag 4:140}) [160->160] (level:0) is brown with stack state with #({basic-block #({tag 4:140}) 140 150}) #({tag 4:140}) [140->150] (level:0) is red with stack state with #({basic-block #() 150 155}) init-control-word call-alien {constant "dylan_initialize"}, 0 #() [150->155] (level:0) is red with stack state with #({basic-block #({tag 7:175}) 175 180}) move r3, 0 #({tag 7:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #() 155 160}) preserve-registers-exit #() [155->160] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for DylanSOEntry +++ +++ Live variable scopes for DylanSOEntry +++ Start scope at 10 with frame for no variables End scope at 175 +++ No Source Code Locators for DylanSOEntry +++ +++ Defining function DylanSOExit in section init-code +++ +++ starting code for DylanSOExit +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 20:390}) 390 405}) rem "This is a dummy first basic block." #({tag 20:390}) [390->405] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 35}) move r3, {constant "Pambig_root"} move r4, {constant "Pstatic_root"} move r5, {constant "Pexact_root"} call {constant "primitive_deregister_traced_roots"}, 3 #() [25->35] (level:0) is red with stack state with #({basic-block #() 35 50}, {basic-block #({tag 2:75}) 75 80}) ld N0/r12, {constant "Pmaster_gc_teb"}, 4 beq {tag 2:75}, N0/r12, 0 #() [35->50] (level:0) is red with stack state with #({basic-block #() 50 60}) sub r1, r1, 24 move r3, {constant "Pmaster_gc_teb"} call-alien {constant "dylan_mm_deregister_thread_from_teb"}, 0 #() [50->60] (level:0) is red with stack state with #({basic-block #({tag 15:325}) 325 340}) add r1, r1, 24 st 0, {constant "Pmaster_gc_teb"}, 4 #({tag 15:325}) [325->340] (level:1) is green with stack state with #({basic-block #({tag 2:75}) 75 80}, {basic-block #({tag 15:325}) 325 340}) move N1/r12, {indirect-constant "Pruntime_thread_count"} sub N2/r6, N1/r12, 1 conditional-move {tag 15:325}, {indirect-constant "Pruntime_thread_count"}, N2/r6, N1/r12 #({tag 2:75}) [75->80] (level:0) is green with stack state with #({basic-block #({tag 5:80}) 80 85}) move N3/NSPILL-1, {indirect-constant "Pteb_chain"} #({tag 5:80}) [80->85] (level:1) is green with stack state with #({basic-block #() 85 100}, {basic-block #({tag 4:250}) 250 270}) beq {tag 4:250}, N3/NSPILL-1, 0 #() [85->100] (level:1) is green with stack state with #({basic-block #() 100 115}, {basic-block #({tag 6:140}) 140 150}) add N4/NSPILL-0, N3/NSPILL-1, 12 ld N5/r12, N4/NSPILL-0, 4 beq {tag 6:140}, N5/r12, 0 #() [100->115] (level:1) is red with stack state with #({basic-block #() 115 125}) sub r1, r1, 24 move r3, N4/NSPILL-0 call-alien {constant "dylan_mm_deregister_thread_from_teb"}, 0 #() [115->125] (level:1) is red with stack state with #({basic-block #({tag 14:310}) 310 325}) add r1, r1, 24 st 0, N4/NSPILL-0, 4 #({tag 14:310}) [310->325] (level:2) is green with stack state with #({basic-block #({tag 6:140}) 140 150}, {basic-block #({tag 14:310}) 310 325}) move N6/r12, {indirect-constant "Pruntime_thread_count"} sub N7/r6, N6/r12, 1 conditional-move {tag 14:310}, {indirect-constant "Pruntime_thread_count"}, N7/r6, N6/r12 #({tag 6:140}) [140->150] (level:1) is green with stack state with #({basic-block #({tag 12:305}) 305 310}) ld N3/NSPILL-1, N3/NSPILL-1, 4 sub N8/r3, N4/NSPILL-0, 12 #({tag 12:305}) [305->310] (level:2) is green with stack state with #({basic-block #({tag 13:155}) 155 170}, {basic-block #({tag 12:305}) 305 310}) conditional-move {tag 12:305}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 13:155}) [155->170] (level:1) is red with stack state with #({basic-block #() 170 175}, {basic-block #({tag 8:175}) 175 180}) ld N9/r12, N8/r3, 4 ld N10/r11, N8/r3, 8 bne {tag 8:175}, {indirect-constant "Pteb_chain"}, N8/r3 #() [170->175] (level:1) is red with stack state with #({basic-block #({tag 9:180}) 180 185}) move {indirect-constant "Pteb_chain"}, N9/r12 #({tag 9:180}) [180->185] (level:1) is red with stack state with #({basic-block #() 185 190}, {basic-block #({tag 10:190}) 190 215}) beq {tag 10:190}, N9/r12, 0 #() [185->190] (level:1) is red with stack state with #({basic-block #({tag 10:190}) 190 215}) st N10/r11, N9/r12, 8 #({tag 10:190}) [190->215] (level:1) is red with stack state with #({basic-block #() 215 245}) move {indirect-constant "Pruntime_spin_lock"}, 0 ld N8/r3, N4/NSPILL-0, -12 sub r1, r1, 24 move r3, N8/r3 call-alien {constant "MMDeregisterRoot"}, 0 #() [215->245] (level:1) is red with stack state with #({basic-block #() 245 250}) add r1, r1, 24 sub N8/r3, N4/NSPILL-0, 12 sub r1, r1, 24 move r3, N8/r3 move r4, 340 call-alien {constant "MMFreeMisc"}, 0 #() [245->250] (level:1) is red with stack state with #({basic-block #({tag 5:80}) 80 85}) add r1, r1, 24 #() [405->410] (level:0) is #f with stack state #f #() bra {tag 5:80} #({tag 4:250}) [250->270] (level:1) is red with stack state with #({basic-block #() 270 280}) sub r1, r1, 24 move r3, {indirect-constant "Pteb_tlv_index"} move r4, 4 call-alien {constant "MMFreeMisc"}, 0 #() [270->280] (level:1) is red with stack state with #({basic-block #() 280 290}, {basic-block #({tag 1:295}) 295 300}) add r1, r1, 24 bne {tag 1:295}, {indirect-constant "Pruntime_thread_count"}, 0 #() [280->290] (level:1) is red with stack state with #({basic-block #() 290 295}) sub r1, r1, 24 call-alien {constant "dylan_shut_down_memory_manager"}, 0 #() [290->295] (level:1) is red with stack state with #({basic-block #({tag 1:295}) 295 300}) add r1, r1, 24 #({tag 1:295}) [295->300] (level:1) is red with stack state with #({basic-block #({tag 18:370}) 370 375}) move r3, 0 #({tag 18:370}) [370->375] (level:0) is #f with stack state #f #({basic-block #() 300 305}) preserve-registers-exit #() [300->305] (level:1) is red with stack state #f #() rts-and-drop 0 #({tag 8:175}) [175->180] (level:1) is red with stack state with #({basic-block #({tag 9:180}) 180 185}) st N9/r12, N10/r11, 4 #() [410->415] (level:0) is #f with stack state #f #() bra {tag 9:180} +++ ending code for DylanSOExit +++ +++ Frame sizes for DylanSOExit: GC: 0, NC: 2 +++ +++ Live variable scopes for DylanSOExit +++ Start scope at 10 with frame for no variables End scope at 313 +++ No Source Code Locators for DylanSOExit +++