+++ 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{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{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 +++ +++ (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 +++ +++ 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" +++ +++ external: "Kinteger_divide_by_0VKeI" +++ +++ external: "Kfloat_divide_by_0VKeI" +++ +++ external: "Kfloat_overflowVKeI" +++ +++ external: "Kfloat_underflowVKeI" +++ +++ 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" +++ +++ 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 eax, {constant "Kprimitive_error_string"} move ebx, {constant "KerrorVKd"} move ecx, 1 call-indirect ebx, 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 3 with frame for no variables End scope at 20 +++ 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/eax, eax rem "eliminated" load-stack-arg-n #t, G5/edi, 1 ld N2/ebx, G5/edi, 4 asr N2/ebx, N2/ebx, 2 asl N3/edx, N2/ebx, 2 sub esp, esp, N3/edx add N1/edx, G5/edi, 8 copy-words-down-w esp, N1/edx, N2/ebx push N2/ebx push G4/eax halt pop eax #({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 8 #({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 12 with frame for no variables End scope at 43 +++ 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/eax, eax load-stack-arg-n #t, G5/edi, 0 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/ebx, G5/edi, 4 asr N1/ebx, N1/ebx, 2 asl N2/edx, N1/ebx, 2 sub esp, esp, N2/edx add N0/edx, G5/edi, 8 copy-words-down-w esp, N0/edx, N1/ebx push N1/ebx push G4/eax halt pop eax #({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 4 +++ ending code for primitive_invoke_debugger +++ +++ Live variable scopes for primitive_invoke_debugger +++ Start scope at 3 with frame for no variables End scope at 43 +++ 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" load-stack-arg-n #t, N1/ecx, 1 rem "eliminated" load-stack-arg-n #t, N3/edx, 3 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/edx push N1/ecx halt pop eax #({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 15 with frame for no variables End scope at 33 +++ 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 eax, {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 eax, {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: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 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 20}) call-alien {constant "MMCollectCount"}, 0 #() [10->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) asl eax, eax, 2 add eax, eax, 1 #({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_gc_state +++ +++ Live variable scopes for primitive_gc_state +++ Start scope at 3 with frame for no variables End scope at 14 +++ 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 3 with frame for no variables End scope at 7 +++ 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: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 75}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->75] (level:0) is red with stack state with #({basic-block #() 75 85}) move eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/ecx, 1 load-stack-arg-n #t, N2/edx, 2 load-stack-arg-n #t, N3/ebx, 3 load-stack-arg-n #t, N4/edi, 4 asl N5/eax, eax, 2 push N4/edi push N3/ebx push N2/edx push N1/ecx push N0/NSPILL--1 push N5/eax call-alien {constant "primitive_alloc_s_r"}, 0 #() [75->85] (level:0) is red with stack state with #({basic-block #({tag 1:90}) 90 95}) add esp, esp, 24 move eax, eax #({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-and-drop 20 +++ ending code for primitive_allocate_filled +++ +++ Live variable scopes for primitive_allocate_filled +++ Start scope at 3 with frame for no variables End scope at 34 +++ 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: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 75}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->75] (level:0) is red with stack state with #({basic-block #() 75 85}) move eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/ecx, 1 load-stack-arg-n #t, N2/edx, 2 load-stack-arg-n #t, N3/ebx, 3 load-stack-arg-n #t, N4/edi, 4 asl N5/eax, eax, 2 push N4/edi push N3/ebx push N2/edx push N1/ecx push N0/NSPILL--1 push N5/eax call-alien {constant "primitive_alloc_leaf_s_r"}, 0 #() [75->85] (level:0) is red with stack state with #({basic-block #({tag 1:90}) 90 95}) add esp, esp, 24 move eax, eax #({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-and-drop 20 +++ ending code for primitive_allocate_filled_in_leaf_pool +++ +++ Live variable scopes for primitive_allocate_filled_in_leaf_pool +++ Start scope at 3 with frame for no variables End scope at 34 +++ 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: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 85}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->85] (level:0) is red with stack state with #({basic-block #() 85 95}) move eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/NSPILL--2, 1 load-stack-arg-n #t, N2/ecx, 2 load-stack-arg-n #t, N3/edx, 3 load-stack-arg-n #t, N4/ebx, 4 load-stack-arg-n #t, N5/edi, 5 asl N6/eax, eax, 2 push N4/ebx push N3/edx push N2/ecx push N1/NSPILL--2 push N5/edi push N0/NSPILL--1 push N6/eax call-alien {constant "primitive_alloc_weak_awl_s_r"}, 0 #() [85->95] (level:0) is red with stack state with #({basic-block #({tag 1:100}) 100 105}) add esp, esp, 28 move eax, eax #({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 24 +++ ending code for primitive_allocate_weak_in_awl_pool +++ +++ Live variable scopes for primitive_allocate_weak_in_awl_pool +++ Start scope at 3 with frame for no variables End scope at 37 +++ 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: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 85}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->85] (level:0) is red with stack state with #({basic-block #() 85 95}) move eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/NSPILL--2, 1 load-stack-arg-n #t, N2/ecx, 2 load-stack-arg-n #t, N3/edx, 3 load-stack-arg-n #t, N4/ebx, 4 load-stack-arg-n #t, N5/edi, 5 asl N6/eax, eax, 2 push N4/ebx push N3/edx push N2/ecx push N1/NSPILL--2 push N5/edi push N0/NSPILL--1 push N6/eax call-alien {constant "primitive_alloc_exact_awl_s_r"}, 0 #() [85->95] (level:0) is red with stack state with #({basic-block #({tag 1:100}) 100 105}) add esp, esp, 28 move eax, eax #({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 24 +++ ending code for primitive_allocate_in_awl_pool +++ +++ Live variable scopes for primitive_allocate_in_awl_pool +++ Start scope at 3 with frame for no variables End scope at 37 +++ 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: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 75}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->75] (level:0) is red with stack state with #({basic-block #() 75 85}) move eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/ecx, 1 load-stack-arg-n #t, N2/edx, 2 load-stack-arg-n #t, N3/ebx, 3 load-stack-arg-n #t, N4/edi, 4 asl N5/eax, eax, 2 push N4/edi push N3/ebx push N2/edx push N1/ecx push N0/NSPILL--1 push N5/eax call-alien {constant "primitive_alloc_wrapper_s_r"}, 0 #() [75->85] (level:0) is red with stack state with #({basic-block #({tag 1:90}) 90 95}) add esp, esp, 24 move eax, eax #({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-and-drop 20 +++ ending code for primitive_allocate_wrapper +++ +++ Live variable scopes for primitive_allocate_wrapper +++ Start scope at 3 with frame for no variables End scope at 34 +++ 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: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}) push eax call-alien {constant "dylan__malloc__misc"}, 0 #() [15->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) add esp, esp, 4 #({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_untraced_allocate +++ +++ Live variable scopes for primitive_untraced_allocate +++ Start scope at 3 with frame for no variables End scope at 12 +++ 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 3 with frame for no variables End scope at 7 +++ 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:115}) 115 130}) rem "This is a dummy first basic block." #({tag 2:115}) [115->130] (level:0) is #f with stack state #f #({basic-block #() 5 95}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->95] (level:0) is red with stack state with #({basic-block #() 95 105}) move eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/NSPILL--2, 1 load-stack-arg-n #t, N2/ecx, 2 load-stack-arg-n #t, N3/edx, 3 load-stack-arg-n #t, N4/ebx, 4 load-stack-arg-n #t, N5/edi, 5 asl eax, eax, 2 add eax, eax, N0/NSPILL--1 add eax, eax, 3 and eax, eax, -4 push N5/edi push N4/ebx push N3/edx push N2/ecx push N1/NSPILL--2 push eax call-alien {constant "primitive_alloc_leaf_s_rb"}, 0 #() [95->105] (level:0) is red with stack state with #({basic-block #({tag 1:110}) 110 115}) add esp, esp, 24 move eax, eax #({tag 1:110}) [110->115] (level:0) is #f with stack state #f #({basic-block #() 105 110}) preserve-registers-exit #() [105->110] (level:0) is red with stack state #f #() rts-and-drop 24 +++ ending code for primitive_byte_allocate_filled +++ +++ Live variable scopes for primitive_byte_allocate_filled +++ Start scope at 3 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: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 eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/ecx, 1 rem "eliminated" load-stack-arg-n #t, N3/edi, 3 load-stack-arg-n #t, N4/edx, 4 load-stack-arg-n #t, N5/ebx, 5 asl eax, eax, 2 add eax, eax, N0/NSPILL--1 rem "eliminated" add eax, eax, 3 and eax, eax, -4 asr N7/edi, N3/edi, 2 push N7/edi push N5/ebx push N4/edx push N1/ecx push eax call-alien {constant "primitive_alloc_leaf_rbfz"}, 0 #() [100->110] (level:0) is red with stack state with #({basic-block #({tag 1:115}) 115 120}) add esp, esp, 20 move eax, eax #({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 24 +++ ending code for primitive_byte_allocate_filled_terminated +++ +++ Live variable scopes for primitive_byte_allocate_filled_terminated +++ Start scope at 3 with frame for no variables End scope at 43 +++ 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:75}) 75 90}) rem "This is a dummy first basic block." #({tag 2:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #() 5 50}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->50] (level:0) is red with stack state with #({basic-block #() 50 65}) move N1/eax, eax asl N2/edi, N1/eax, 2 add N2/edi, N2/edi, 8 push {constant "KPunboundVKi"} push 1 push N1/eax push {constant "KLsimple_object_vectorGVKdW"} push N2/edi call-alien {constant "primitive_alloc_rf"}, 0 #() [50->65] (level:0) is red with stack state with #({basic-block #({tag 1:70}) 70 75}) add esp, esp, 20 move G0/eax, eax move eax, G0/eax #({tag 1:70}) [70->75] (level:0) is #f with stack state #f #({basic-block #() 65 70}) preserve-registers-exit #() [65->70] (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 3 with frame for no variables End scope at 33 +++ 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 20}) rem "This is a dummy first basic block." #() [5->20] (level:0) is green with stack state before #({basic-block #() 20 25}, {basic-block #({tag 9:125}) 125 140}) move N8/eax, eax load-address-of-stack-arg-n #f, N9/edi, 0 bne {tag 9:125}, N8/eax, 0 #() [20->25] (level:0) is green with stack state before #({basic-block #({tag 2:75}) 75 85}) move G10/edi, {constant "KPempty_vectorVKi"} #({tag 2:75}) [75->85] (level:0) is green with stack state before #({basic-block #({tag 7:85}) 85 90}) asl N0/edx, N8/eax, 2 move eax, G10/edi #({tag 7:85}) [85->90] (level:0) is green with stack state #f #() rts-and-drop N0/edx #({tag 9:125}) [125->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:90}) 90 100}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 4:90}) [90->100] (level:0) is brown with stack state with #({basic-block #({tag 3:25}) 25 65}) move N1/NSPILL-0, N8/eax move N4/ebx, N9/edi #({tag 3:25}) [25->65] (level:0) is red with stack state with #({basic-block #() 65 75}) asl N7/edi, N1/NSPILL-0, 2 add N7/edi, N7/edi, 8 push N4/ebx push 1 push N1/NSPILL-0 push {constant "KLsimple_object_vectorGVKdW"} push N7/edi call-alien {constant "primitive_alloc_rt"}, 0 #() [65->75] (level:0) is red with stack state with #({basic-block #({tag 5:100}) 100 110}) add esp, esp, 20 move G6/edi, eax #({tag 5:100}) [100->110] (level:0) is yellow with stack state with #({basic-block #({tag 6:110}) 110 120}) move N8/eax, N1/NSPILL-0 move G10/edi, G6/edi #({tag 6:110}) [110->120] (level:0) is green with stack state with #({basic-block #({tag 8:120}) 120 125}) asl N0/edx, N8/eax, 2 move eax, G10/edi #({tag 8:120}) [120->125] (level:0) is #f with stack state #f #({basic-block #({tag 7:85}) 85 90}) preserve-registers-exit #() [140->145] (level:0) is #f with stack state #f #() bra {tag 7:85} +++ ending code for primitive_vector +++ +++ Frame sizes for primitive_vector: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_vector +++ Start scope at 29 with frame for no variables End scope at 78 +++ 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:95}) 95 110}) move G6/eax, eax ld N5/edi, G6/eax, 4 sub N5/edi, N5/edi, 1 bne {tag 8:95}, N5/edi, 0 #() [25->30] (level:0) is green with stack state before #({basic-block #({tag 1:65}) 60 65}) move G7/eax, {constant "KPempty_vectorVKi"} #({tag 1:65}) [60->65] (level:0) is green with stack state before #({basic-block #({tag 1:65}, {tag 6:65}) 65 70}) move eax, G7/eax #({tag 1:65}, {tag 6:65}) [65->70] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 8:95}) [95->110] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 70 80}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:30}) [70->80] (level:0) is brown with stack state with #({basic-block #({tag 3:30}, {tag 2:30}) 30 50}) move N1/edi, N5/edi move G3/eax, G6/eax #({tag 3:30}, {tag 2:30}) [30->50] (level:0) is red with stack state with #({basic-block #() 50 60}) add N1/edi, N1/edi, 8 push G3/eax push N1/edi call-alien {constant "primitive_copy"}, 0 #() [50->60] (level:0) is red with stack state with #({basic-block #({tag 4:90}) 80 85}) add esp, esp, 8 move G4/eax, eax #({tag 4:90}) [80->85] (level:0) is yellow with stack state with #({basic-block #({tag 4:90}, {tag 5:90}) 85 90}) move G7/eax, G4/eax #({tag 4:90}, {tag 5:90}) [85->90] (level:0) is green with stack state with #({basic-block #({tag 5:90}, {tag 4:90}, {tag 7:90}) 90 95}) move eax, G7/eax #({tag 5:90}, {tag 4:90}, {tag 7:90}) [90->95] (level:0) is #f with stack state #f #({basic-block #({tag 1:65}, {tag 6:65}) 65 70}) preserve-registers-exit #() [110->115] (level:0) is #f with stack state #f #() bra {tag 1:65} +++ ending code for primitive_copy_vector +++ +++ Live variable scopes for primitive_copy_vector +++ Start scope at 20 with frame for no variables End scope at 33 +++ 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: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 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 45}) move G0/eax, eax push G0/eax push {constant "KLtraceable_value_cellGVKiW"} push 8 call-alien {constant "primitive_alloc_s1"}, 0 #() [30->45] (level:0) is red with stack state with #({basic-block #({tag 1:50}) 50 55}) add esp, esp, 12 move G1/eax, eax move eax, G1/eax #({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_box +++ +++ Live variable scopes for primitive_make_box +++ Start scope at 3 with frame for no variables End scope at 19 +++ 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: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 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 45}) move N0/edi, eax push {constant "KLuntraceable_value_cellGVKiW"} push 8 call-alien {constant "primitive_alloc_leaf"}, 0 #() [25->45] (level:0) is red with stack state with #({basic-block #({tag 1:50}) 50 55}) add esp, esp, 8 move G1/eax, eax st N0/edi, G1/eax, 4 move eax, G1/eax #({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_raw_box +++ +++ Live variable scopes for primitive_make_raw_box +++ Start scope at 3 with frame for no variables End scope at 23 +++ 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: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 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 45}) fmove SF0/SFSPILL-0, ST push {constant "KLuntraceable_value_cellGVKiW"} push 8 call-alien {constant "primitive_alloc_leaf"}, 0 #() [25->45] (level:0) is red with stack state with #({basic-block #({tag 1:50}) 50 55}) add esp, esp, 8 move G1/eax, eax fst SF0/SFSPILL-0, G1/eax, 4 move eax, G1/eax #({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_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 3 with frame for no variables End scope at 30 +++ 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: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 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 45}) dmove DF0/DFSPILL-0, ST push {constant "KLuntraceable_double_value_cellGVKiW"} push 12 call-alien {constant "primitive_alloc_leaf"}, 0 #() [25->45] (level:0) is red with stack state with #({basic-block #({tag 1:50}) 50 55}) add esp, esp, 8 move G1/eax, eax dst DF0/DFSPILL-0, G1/eax, 4 move eax, G1/eax #({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_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 3 with frame for no variables End scope at 30 +++ 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:75}) 75 90}) rem "This is a dummy first basic block." #({tag 2:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #() 5 50}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->50] (level:0) is red with stack state with #({basic-block #() 50 65}) move G1/eax, eax load-stack-arg-n #t, N0/edi, 0 asl N4/ebx, N0/edi, 2 add N3/ebx, N4/ebx, 20 push G1/eax push 4 push N0/edi push N3/ebx call-alien {constant "primitive_copy_r"}, 0 #() [50->65] (level:0) is red with stack state with #({basic-block #({tag 1:70}) 70 75}) add esp, esp, 16 move G2/eax, eax move eax, G2/eax #({tag 1:70}) [70->75] (level:0) is #f with stack state #f #({basic-block #() 65 70}) preserve-registers-exit #() [65->70] (level:0) is red with stack state #f #() rts-and-drop 4 +++ ending code for primitive_make_closure +++ +++ Live variable scopes for primitive_make_closure +++ Start scope at 3 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:75}) 75 90}) rem "This is a dummy first basic block." #({tag 2:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #() 5 50}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->50] (level:0) is red with stack state with #({basic-block #() 50 65}) move G1/eax, eax load-stack-arg-n #t, N0/edi, 0 asl N4/ebx, N0/edi, 2 add N3/ebx, N4/ebx, 28 push G1/eax push 6 push N0/edi push N3/ebx call-alien {constant "primitive_copy_r"}, 0 #() [50->65] (level:0) is red with stack state with #({basic-block #({tag 1:70}) 70 75}) add esp, esp, 16 move G2/eax, eax move eax, G2/eax #({tag 1:70}) [70->75] (level:0) is #f with stack state #f #({basic-block #() 65 70}) preserve-registers-exit #() [65->70] (level:0) is red with stack state #f #() rts-and-drop 4 +++ ending code for primitive_make_keyword_closure +++ +++ Live variable scopes for primitive_make_keyword_closure +++ Start scope at 3 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:85}) 85 100}) rem "This is a dummy first basic block." #({tag 2:85}) [85->100] (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 75}) move G1/eax, eax load-stack-arg-n #t, G3/GSPILL--1, 0 load-stack-arg-n #t, N0/edi, 1 asl N5/ebx, N0/edi, 2 add N4/ebx, N5/ebx, 20 push G1/eax push 4 push N0/edi push N4/ebx call-alien {constant "primitive_copy_r"}, 0 #() [55->75] (level:0) is red with stack state with #({basic-block #({tag 1:80}) 80 85}) add esp, esp, 16 move G2/eax, eax move eax, G2/eax st G3/GSPILL--1, eax, 8 #({tag 1: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 8 +++ ending code for primitive_make_closure_with_signature +++ +++ Live variable scopes for primitive_make_closure_with_signature +++ Start scope at 3 with frame for no variables End scope at 33 +++ 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:85}) 85 100}) rem "This is a dummy first basic block." #({tag 2:85}) [85->100] (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 75}) move G1/eax, eax load-stack-arg-n #t, G3/GSPILL--1, 0 load-stack-arg-n #t, N0/edi, 1 asl N5/ebx, N0/edi, 2 add N4/ebx, N5/ebx, 28 push G1/eax push 6 push N0/edi push N4/ebx call-alien {constant "primitive_copy_r"}, 0 #() [55->75] (level:0) is red with stack state with #({basic-block #({tag 1:80}) 80 85}) add esp, esp, 16 move G2/eax, eax move eax, G2/eax st G3/GSPILL--1, eax, 8 #({tag 1: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 8 +++ ending code for primitive_make_keyword_closure_with_signature +++ +++ Live variable scopes for primitive_make_keyword_closure_with_signature +++ Start scope at 3 with frame for no variables End scope at 33 +++ 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 before #({basic-block #({tag 6:90}) 90 105}, {basic-block #({tag 1:80}) 80 80}) move G2/ecx, eax load-stack-arg-n #f, N0/ebx, 0 move N1/edi, 4 beq {tag 1:80}, N0/ebx, 0 #({tag 6:90}) [90->105] (level:0) is #f with stack state #f #({basic-block #() 25 80}) preserve-registers-entry allocate-local-area allocate-raw-area #() [25->80] (level:0) is green with stack state with #({basic-block #({tag 3:85}) 85 85}) move N6/edx, N1/edi add N4/edi, G2/ecx, 20 move N5/ecx, N0/ebx load-address-of-stack-arg-n #t, N3/NSPILL-0, 1 move edi, N4/edi move esi, N3/NSPILL-0 copy-words-down-w edi, esi, N5/ecx move N7/ebx, N0/ebx asl N7/ebx, N7/ebx, 2 move N1/edi, N6/edx add N1/edi, N1/edi, N7/ebx #({tag 3:85}) [85->85] (level:0) is green with stack state with #({basic-block #({tag 3:85}, {tag 5:85}) 85 90}) #({tag 3:85}, {tag 5:85}) [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 1:80}, {tag 4:80}) 80 85}) preserve-registers-exit #({tag 1:80}, {tag 4:80}) [80->85] (level:0) is green with stack state #f #() rts-and-drop N1/edi #({tag 1:80}) [80->80] (level:0) is green with stack state before #({basic-block #({tag 1:80}, {tag 4:80}) 80 85}) +++ ending code for primitive_initialize_closure +++ +++ Frame sizes for primitive_initialize_closure: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_initialize_closure +++ Start scope at 19 with frame for no variables End scope at 47 +++ 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 before #({basic-block #({tag 6:90}) 90 105}, {basic-block #({tag 1:80}) 80 80}) move G2/ecx, eax load-stack-arg-n #f, N0/ebx, 0 move N1/edi, 4 beq {tag 1:80}, N0/ebx, 0 #({tag 6:90}) [90->105] (level:0) is #f with stack state #f #({basic-block #() 25 80}) preserve-registers-entry allocate-local-area allocate-raw-area #() [25->80] (level:0) is green with stack state with #({basic-block #({tag 3:85}) 85 85}) move N6/edx, N1/edi add N4/edi, G2/ecx, 28 move N5/ecx, N0/ebx load-address-of-stack-arg-n #t, N3/NSPILL-0, 1 move edi, N4/edi move esi, N3/NSPILL-0 copy-words-down-w edi, esi, N5/ecx move N7/ebx, N0/ebx asl N7/ebx, N7/ebx, 2 move N1/edi, N6/edx add N1/edi, N1/edi, N7/ebx #({tag 3:85}) [85->85] (level:0) is green with stack state with #({basic-block #({tag 3:85}, {tag 5:85}) 85 90}) #({tag 3:85}, {tag 5:85}) [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 1:80}, {tag 4:80}) 80 85}) preserve-registers-exit #({tag 1:80}, {tag 4:80}) [80->85] (level:0) is green with stack state #f #() rts-and-drop N1/edi #({tag 1:80}) [80->80] (level:0) is green with stack state before #({basic-block #({tag 1:80}, {tag 4:80}) 80 85}) +++ ending code for primitive_initialize_keyword_closure +++ +++ Frame sizes for primitive_initialize_keyword_closure: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_initialize_keyword_closure +++ Start scope at 19 with frame for no variables End scope at 47 +++ 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 4:140}) 140 155}) rem "This is a dummy first basic block." #({tag 4:140}) [140->155] (level:0) is #f with stack state #f #({basic-block #() 5 50}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->50] (level:0) is red with stack state with #({basic-block #() 50 70}) move G2/eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 asl N10/edi, N0/NSPILL--1, 2 add N9/edi, N10/edi, 20 push G2/eax push 4 push N0/NSPILL--1 push N9/edi call-alien {constant "primitive_copy_r"}, 0 #() [50->70] (level:0) is red with stack state with #({basic-block #() 70 125}, {basic-block #({tag 1:135}) 125 130}) add esp, esp, 16 move G3/eax, eax move N1/edi, 4 beq {tag 1:135}, N0/NSPILL--1, 0 #() [70->125] (level:0) is red with stack state with #({basic-block #({tag 1:135}) 125 130}) move N7/edx, N1/edi add N5/edi, G3/eax, 20 move N6/ecx, N0/NSPILL--1 load-address-of-stack-arg-n #t, N4/ebx, 1 move edi, N5/edi move esi, N4/ebx copy-words-down-w edi, esi, N6/ecx move N8/ebx, N0/NSPILL--1 asl N8/ebx, N8/ebx, 2 move N1/edi, N7/edx add N1/edi, N1/edi, N8/ebx #({tag 1:135}) [125->130] (level:0) is red with stack state with #({basic-block #({tag 1:135}, {tag 3:135}) 135 140}) move eax, G3/eax #({tag 1:135}, {tag 3:135}) [135->140] (level:0) is #f with stack state #f #({basic-block #() 130 135}) preserve-registers-exit #() [130->135] (level:0) is red with stack state #f #() rts-and-drop N1/edi +++ ending code for primitive_make_closure_with_environment +++ +++ Live variable scopes for primitive_make_closure_with_environment +++ Start scope at 3 with frame for no variables End scope at 64 +++ 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 4:140}) 140 155}) rem "This is a dummy first basic block." #({tag 4:140}) [140->155] (level:0) is #f with stack state #f #({basic-block #() 5 50}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->50] (level:0) is red with stack state with #({basic-block #() 50 70}) move G2/eax, eax load-stack-arg-n #t, N0/NSPILL--1, 0 asl N10/edi, N0/NSPILL--1, 2 add N9/edi, N10/edi, 28 push G2/eax push 6 push N0/NSPILL--1 push N9/edi call-alien {constant "primitive_copy_r"}, 0 #() [50->70] (level:0) is red with stack state with #({basic-block #() 70 125}, {basic-block #({tag 1:135}) 125 130}) add esp, esp, 16 move G3/eax, eax move N1/edi, 4 beq {tag 1:135}, N0/NSPILL--1, 0 #() [70->125] (level:0) is red with stack state with #({basic-block #({tag 1:135}) 125 130}) move N7/edx, N1/edi add N5/edi, G3/eax, 28 move N6/ecx, N0/NSPILL--1 load-address-of-stack-arg-n #t, N4/ebx, 1 move edi, N5/edi move esi, N4/ebx copy-words-down-w edi, esi, N6/ecx move N8/ebx, N0/NSPILL--1 asl N8/ebx, N8/ebx, 2 move N1/edi, N7/edx add N1/edi, N1/edi, N8/ebx #({tag 1:135}) [125->130] (level:0) is red with stack state with #({basic-block #({tag 1:135}, {tag 3:135}) 135 140}) move eax, G3/eax #({tag 1:135}, {tag 3:135}) [135->140] (level:0) is #f with stack state #f #({basic-block #() 130 135}) preserve-registers-exit #() [130->135] (level:0) is red with stack state #f #() rts-and-drop N1/edi +++ ending code for primitive_make_keyword_closure_with_environment +++ +++ Live variable scopes for primitive_make_keyword_closure_with_environment +++ Start scope at 3 with frame for no variables End scope at 64 +++ 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 4:150}) 150 165}) rem "This is a dummy first basic block." #({tag 4:150}) [150->165] (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 75}) move G2/eax, eax load-stack-arg-n #t, G3/GSPILL--1, 0 load-stack-arg-n #t, N0/NSPILL--2, 1 asl N11/edi, N0/NSPILL--2, 2 add N10/edi, N11/edi, 20 push G2/eax push 4 push N0/NSPILL--2 push N10/edi call-alien {constant "primitive_copy_r"}, 0 #() [55->75] (level:0) is red with stack state with #({basic-block #() 75 130}, {basic-block #({tag 1:130}) 130 140}) add esp, esp, 16 move G4/eax, eax move N1/edi, 8 beq {tag 1:130}, N0/NSPILL--2, 0 #() [75->130] (level:0) is red with stack state with #({basic-block #({tag 1:130}) 130 140}) move N8/edx, N1/edi add N6/edi, G4/eax, 20 move N7/ecx, N0/NSPILL--2 load-address-of-stack-arg-n #t, N5/ebx, 2 move edi, N6/edi move esi, N5/ebx copy-words-down-w edi, esi, N7/ecx move N9/ebx, N0/NSPILL--2 asl N9/ebx, N9/ebx, 2 move N1/edi, N8/edx add N1/edi, N1/edi, N9/ebx #({tag 1:130}) [130->140] (level:0) is red with stack state with #({basic-block #({tag 3:145}) 145 150}) move eax, G4/eax st G3/GSPILL--1, eax, 8 #({tag 3:145}) [145->150] (level:0) is #f with stack state #f #({basic-block #() 140 145}) preserve-registers-exit #() [140->145] (level:0) is red with stack state #f #() rts-and-drop N1/edi +++ ending code for primitive_make_closure_with_environment_signature +++ +++ Live variable scopes for primitive_make_closure_with_environment_signature +++ Start scope at 3 with frame for no variables End scope at 70 +++ 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 4:150}) 150 165}) rem "This is a dummy first basic block." #({tag 4:150}) [150->165] (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 75}) move G2/eax, eax load-stack-arg-n #t, G3/GSPILL--1, 0 load-stack-arg-n #t, N0/NSPILL--2, 1 asl N11/edi, N0/NSPILL--2, 2 add N10/edi, N11/edi, 28 push G2/eax push 6 push N0/NSPILL--2 push N10/edi call-alien {constant "primitive_copy_r"}, 0 #() [55->75] (level:0) is red with stack state with #({basic-block #() 75 130}, {basic-block #({tag 1:130}) 130 140}) add esp, esp, 16 move G4/eax, eax move N1/edi, 8 beq {tag 1:130}, N0/NSPILL--2, 0 #() [75->130] (level:0) is red with stack state with #({basic-block #({tag 1:130}) 130 140}) move N8/edx, N1/edi add N6/edi, G4/eax, 28 move N7/ecx, N0/NSPILL--2 load-address-of-stack-arg-n #t, N5/ebx, 2 move edi, N6/edi move esi, N5/ebx copy-words-down-w edi, esi, N7/ecx move N9/ebx, N0/NSPILL--2 asl N9/ebx, N9/ebx, 2 move N1/edi, N8/edx add N1/edi, N1/edi, N9/ebx #({tag 1:130}) [130->140] (level:0) is red with stack state with #({basic-block #({tag 3:145}) 145 150}) move eax, G4/eax st G3/GSPILL--1, eax, 8 #({tag 3:145}) [145->150] (level:0) is #f with stack state #f #({basic-block #() 140 145}) preserve-registers-exit #() [140->145] (level:0) is red with stack state #f #() rts-and-drop N1/edi +++ ending code for primitive_make_keyword_closure_with_environment_signature +++ +++ Live variable scopes for primitive_make_keyword_closure_with_environment_signature +++ Start scope at 3 with frame for no variables End scope at 70 +++ 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: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 G0/eax, eax load-stack-arg-n #t, G1/edi, 0 push G0/eax push 16 call-alien {constant "primitive_copy"}, 0 #() [30->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add esp, esp, 8 move G2/eax, eax move eax, G2/eax st G1/edi, eax, 8 #({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 4 +++ ending code for primitive_make_method_with_signature +++ +++ Live variable scopes for primitive_make_method_with_signature +++ Start scope at 3 with frame for no variables End scope at 20 +++ 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: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 G0/eax, eax load-stack-arg-n #t, G1/edi, 0 push G0/eax push 24 call-alien {constant "primitive_copy"}, 0 #() [30->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add esp, esp, 8 move G2/eax, eax move eax, G2/eax st G1/edi, eax, 8 #({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 4 +++ ending code for primitive_make_keyword_method_with_signature +++ +++ Live variable scopes for primitive_make_keyword_method_with_signature +++ Start scope at 3 with frame for no variables End scope at 20 +++ 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/edi, eax move N1/eax, eax #({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/ebx, N1/eax, 0 beq-byte {tag 1:60}, N2/ebx, 0 #() [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/ebx, 65280 #() [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/ebx, 16711680 #() [35->45] (level:1) is green with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 5:15}) 15 25}) add N1/eax, N1/eax, 4 band {tag 5:15}, N2/ebx, #ex00000000FF000000 #() [45->50] (level:0) is green with stack state #f #({basic-block #({tag 3:50}) 50 55}) sub N1/eax, N1/eax, 3 #({tag 3:50}) [50->55] (level:0) is green with stack state #f #({basic-block #({tag 2:55}) 55 60}) add N1/eax, N1/eax, 1 #({tag 2:55}) [55->60] (level:0) is green with stack state #f #({basic-block #({tag 1:60}) 60 65}) add N1/eax, N1/eax, 1 #({tag 1:60}) [60->65] (level:0) is green with stack state #f #({basic-block #() 65 70}) sub eax, N1/eax, N0/edi #() [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: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 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 60}) move N0/NSPILL-1, eax call {constant "primitive_strlen"}, 1 #() [15->60] (level:0) is red with stack state with #({basic-block #() 60 90}) move N1/NSPILL-0, eax add N2/edi, N1/NSPILL-0, 12 and N2/edi, N2/edi, -4 move N3/ebx, N1/NSPILL-0 push 1 push N3/ebx push {constant "KLbyte_stringGVKdW"} push N2/edi call-alien {constant "primitive_alloc_leaf_r"}, 0 #() [60->90] (level:0) is red with stack state with #({basic-block #({tag 1:95}) 95 100}) add esp, esp, 16 move G5/eax, eax add N4/edi, G5/eax, 8 add N1/NSPILL-0, N1/NSPILL-0, 1 copy-bytes-down N4/edi, N0/NSPILL-1, N1/NSPILL-0 move eax, G5/eax #({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 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 3 with frame for no variables End scope at 73 +++ 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 3 with frame for no variables End scope at 7 +++ 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 3 with frame for no variables End scope at 7 +++ 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: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 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 50}) fmove SF0/SFSPILL-0, ST push {constant "KLsingle_floatGVKdW"} push 8 call-alien {constant "primitive_alloc_leaf"}, 0 #() [25->50] (level:0) is red with stack state with #({basic-block #({tag 1:55}) 55 60}) add esp, esp, 8 move G2/eax, eax move eax, G2/eax move-from-sfreg N1/edi, SF0/SFSPILL-0 st N1/edi, eax, 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_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 3 with frame for no variables End scope at 30 +++ 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: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 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 55}) dmove DF0/DFSPILL-0, ST push {constant "KLdouble_floatGVKdW"} push 12 call-alien {constant "primitive_alloc_leaf"}, 0 #() [25->55] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 65}) add esp, esp, 8 move G3/eax, eax move eax, G3/eax move-from-dfreg N1/ebx, N2/edi, DF0/DFSPILL-0 st N1/ebx, eax, 4 st N2/edi, eax, 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_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 3 with frame for no variables End scope at 36 +++ 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: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 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 45}) move N1/edi, eax push {constant "KLmachine_wordGVKeW"} push 8 call-alien {constant "primitive_alloc_leaf"}, 0 #() [25->45] (level:0) is red with stack state with #({basic-block #({tag 1:50}) 50 55}) add esp, esp, 8 move G0/eax, eax move eax, G0/eax st N1/edi, eax, 4 #({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_wrap_machine_word +++ +++ Live variable scopes for primitive_wrap_machine_word +++ Start scope at 3 with frame for no variables End scope at 23 +++ 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: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 G2/eax, eax load-stack-arg-n #t, N0/edi, 0 push G2/eax push 8 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 esp, esp, 8 move G1/eax, eax move eax, G1/eax st N0/edi, eax, 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 4 +++ ending code for primitive_wrap_c_pointer +++ +++ Live variable scopes for primitive_wrap_c_pointer +++ Start scope at 3 with frame for no variables End scope at 20 +++ 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:70}) 70 85}) bgt {tag 8:70}, eax, 536870911 #() [10->15] (level:0) is green with stack state before #({basic-block #() 15 25}, {basic-block #({tag 8:70}) 70 85}) blt {tag 8:70}, eax, -536870912 #() [15->25] (level:0) is green with stack state before #({basic-block #({tag 2:25}) 25 25}) asl eax, eax, 2 add eax, eax, 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:70}) [70->85] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 65 65}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:30}) [65->65] (level:0) is brown with stack state with #({basic-block #({tag 3:30}, {tag 1:30}) 30 50}) #({tag 3:30}, {tag 1:30}) [30->50] (level:0) is red with stack state with #({basic-block #() 50 65}) move N0/edi, eax push {constant "KLmachine_wordGVKeW"} push 8 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 esp, esp, 8 move eax, eax st N0/edi, eax, 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:25}, {tag 6:25}) 25 30}) preserve-registers-exit #() [85->90] (level:0) is #f with stack state #f #() bra {tag 2:25} +++ ending code for primitive_wrap_abstract_integer +++ +++ Live variable scopes for primitive_wrap_abstract_integer +++ Start scope at 24 with frame for no variables End scope at 44 +++ 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:65}) 65 80}) bhi {tag 8:65}, eax, 536870911 #() [10->20] (level:0) is green with stack state before #({basic-block #({tag 2:20}) 20 20}) asl eax, eax, 2 add eax, eax, 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:65}) [65->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:25}) 60 60}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:25}) [60->60] (level:0) is brown with stack state with #({basic-block #({tag 3:25}, {tag 1:25}) 25 45}) #({tag 3:25}, {tag 1:25}) [25->45] (level:0) is red with stack state with #({basic-block #() 45 60}) move N0/edi, eax push {constant "KLmachine_wordGVKeW"} push 8 call-alien {constant "primitive_alloc_leaf"}, 0 #() [45->60] (level:0) is red with stack state with #({basic-block #({tag 4:60}) 60 60}) add esp, esp, 8 move eax, eax st N0/edi, eax, 4 #({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:20}, {tag 6:20}) 20 25}) preserve-registers-exit #() [80->85] (level:0) is #f with stack state #f #() bra {tag 2:20} +++ ending code for primitive_wrap_unsigned_abstract_integer +++ +++ Live variable scopes for primitive_wrap_unsigned_abstract_integer +++ Start scope at 17 with frame for no variables End scope at 37 +++ 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/edi, eax, 3 beq {tag 1:25}, N0/edi, 0 #() [15->20] (level:0) is green with stack state #f #({basic-block #({tag 2:20}) 20 20}) asr eax, eax, 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 eax, eax, 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}, eax, 0 #() [10->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move eax, 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/eax, eax move N0/edi, 0 bne-byte {tag 2:75}, N1/eax, 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/eax, 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/eax, 16711680 #() [45->55] (level:0) is green with stack state #f #({basic-block #({tag 4:55}) 55 65}) add N0/edi, N0/edi, 8 lsr N1/eax, N1/eax, 8 #({tag 4:55}) [55->65] (level:0) is green with stack state #f #({basic-block #({tag 3:65}) 65 75}) add N0/edi, N0/edi, 8 lsr N1/eax, N1/eax, 8 #({tag 3:65}) [65->75] (level:0) is green with stack state #f #({basic-block #({tag 2:75}) 75 80}) add N0/edi, N0/edi, 8 lsr N1/eax, N1/eax, 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/eax, 15 #() [80->90] (level:0) is green with stack state #f #({basic-block #({tag 5:90}) 90 105}) add N0/edi, N0/edi, 4 lsr N1/eax, N1/eax, 4 #({tag 5:90}) [90->105] (level:0) is green with stack state #f #({basic-block #() 105 110}) and N1/eax, N1/eax, 15 ldb N1/eax, {constant "Klow_zeros_table"}, N1/eax add eax, N0/edi, N1/eax #() [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}, eax, 0 #() [10->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move eax, 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/eax, eax move N0/edi, 0 band {tag 2:75}, N1/eax, #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/eax, 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/eax, 65280 #() [45->55] (level:0) is green with stack state #f #({basic-block #({tag 4:55}) 55 65}) add N0/edi, N0/edi, 8 asl N1/eax, N1/eax, 8 #({tag 4:55}) [55->65] (level:0) is green with stack state #f #({basic-block #({tag 3:65}) 65 75}) add N0/edi, N0/edi, 8 asl N1/eax, N1/eax, 8 #({tag 3:65}) [65->75] (level:0) is green with stack state #f #({basic-block #({tag 2:75}) 75 80}) add N0/edi, N0/edi, 8 asl N1/eax, N1/eax, 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/eax, #ex00000000F0000000 #() [80->90] (level:0) is green with stack state #f #({basic-block #({tag 5:90}) 90 105}) add N0/edi, N0/edi, 4 asl N1/eax, N1/eax, 4 #({tag 5:90}) [90->105] (level:0) is green with stack state #f #({basic-block #() 105 110}) lsr N1/eax, N1/eax, 28 ldb N1/eax, {constant "Khigh_zeros_table"}, N1/eax add eax, N0/edi, N1/eax #() [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:100}) 100 115}, {basic-block #({tag 1:70}) 65 70}) move N4/eax, eax load-stack-arg-n #f, N1/NSPILL--1, 0 move G5/edi, N1/NSPILL--1 beq {tag 1:70}, G5/edi, {constant "KLobjectGVKd"} #({tag 7:100}) [100->115] (level:0) is #f with stack state #f #({basic-block #({tag 2:75}) 75 85}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 2:75}) [75->85] (level:0) is brown with stack state with #({basic-block #() 25 45}) move N0/NSPILL-0, N4/eax move G3/edi, G5/edi #() [25->45] (level:0) is red with stack state with #({basic-block #() 45 50}) ld N2/ebx, G3/edi, 4 push G3/edi move eax, N0/NSPILL-0 call N2/ebx, 1 #() [45->50] (level:0) is red with stack state with #({basic-block #() 50 65}, {basic-block #({tag 3:85}) 85 90}) bne {tag 3:85}, eax, {constant "KPfalseVKi"} #() [50->65] (level:0) is red with stack state with #({basic-block #({tag 3:85}) 85 90}) push N1/NSPILL--1 move eax, N0/NSPILL-0 call {constant "Ktype_check_errorVKiI"}, 1 #({tag 3:85}) [85->90] (level:0) is yellow with stack state with #({basic-block #({tag 4:95}) 90 95}) move N4/eax, N0/NSPILL-0 #({tag 4:95}) [90->95] (level:0) is green with stack state with #({basic-block #({tag 4:95}, {tag 6:95}) 95 100}) move eax, N4/eax #({tag 4:95}, {tag 6:95}) [95->100] (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 4 #({tag 1:70}) [65->70] (level:0) is green with stack state before #({basic-block #({tag 1:70}, {tag 5:70}) 70 75}) move eax, N4/eax +++ ending code for primitive_type_check +++ +++ Frame sizes for primitive_type_check: GC: 0, NC: 1 +++ +++ Live variable scopes for primitive_type_check +++ Start scope at 15 with frame for no variables End scope at 50 +++ 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" load-stack-arg-n #t, N1/edx, 0 load-stack-arg-n #t, N2/NSPILL--2, 1 push eax 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-3, esp, 0 add N5/NSPILL-2, esp, 4 add N9/NSPILL-7, N1/edx, 8 ld N8/NSPILL-6, N1/edx, 4 sub N8/NSPILL-6, N8/NSPILL-6, 1 move N6/NSPILL-0, 0 move N10/NSPILL-4, 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-4, N8/NSPILL-6 #() [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-4, N4/NSPILL-3 #() [110->125] (level:1) is green with stack state with #({basic-block #() 125 135}, {basic-block #({tag 2:175}) 175 185}) ld N3/NSPILL-1, N5/NSPILL-2, N6/NSPILL-0 ld N7/NSPILL-5, N9/NSPILL-7, N10/NSPILL-4 beq {tag 2:175}, N7/NSPILL-5, {constant "KPfalseVKi"} #() [125->135] (level:1) is green with stack state with #({basic-block #() 135 155}, {basic-block #({tag 2:175}) 175 185}) move G14/edi, N7/NSPILL-5 beq {tag 2:175}, G14/edi, {constant "KLobjectGVKd"} #() [135->155] (level:1) is red with stack state with #({basic-block #() 155 160}) ld N13/ebx, G14/edi, 4 push G14/edi move eax, N3/NSPILL-1 call N13/ebx, 1 #() [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}, eax, {constant "KPfalseVKi"} #() [160->175] (level:1) is red with stack state with #({basic-block #({tag 2:175}) 175 185}) push N7/NSPILL-5 move eax, N3/NSPILL-1 call {constant "Ktype_check_errorVKiI"}, 1 #({tag 2:175}) [175->185] (level:1) is green with stack state with #({basic-block #({tag 1:100}) 100 105}) add N6/NSPILL-0, N6/NSPILL-0, 4 add N10/NSPILL-4, N10/NSPILL-4, 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/ecx, 32 asl N12/ebx, N11/ecx, 2 sub esp, esp, N12/ebx ld-teb-address esi, 36 copy-words-down-w esp, esi, N11/ecx push N12/ebx #() [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/NSPILL--2, {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/NSPILL-0, N4/NSPILL-3 #() [195->210] (level:2) is green with stack state with #({basic-block #() 210 230}, {basic-block #({tag 5:250}) 250 255}) ld N3/NSPILL-1, N5/NSPILL-2, N6/NSPILL-0 move G16/edi, N2/NSPILL--2 beq {tag 5:250}, G16/edi, {constant "KLobjectGVKd"} #() [210->230] (level:2) is red with stack state with #({basic-block #() 230 235}) ld N15/ebx, G16/edi, 4 push G16/edi move eax, N3/NSPILL-1 call N15/ebx, 1 #() [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}, eax, {constant "KPfalseVKi"} #() [235->250] (level:2) is red with stack state with #({basic-block #({tag 5:250}) 250 255}) push N2/NSPILL--2 move eax, N3/NSPILL-1 call {constant "Ktype_check_errorVKiI"}, 1 #({tag 5:250}) [250->255] (level:2) is green with stack state with #({basic-block #({tag 4:190}) 190 195}) add N6/NSPILL-0, N6/NSPILL-0, 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 N17/ebx bne {tag 9:270}, N17/ebx, 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 eax #({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 8 #({tag 9:270}) [270->300] (level:2) is red with stack state with #({basic-block #({tag 10:300}) 300 305}) asr N19/edx, N17/ebx, 2 st-teb N19/edx, 32 ld-teb-address N18/edi, 36 copy-words-down-w N18/edi, esp, N19/edx add esp, esp, N17/ebx 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: 8 +++ +++ Live variable scopes for primitive_type_check_values +++ Start scope at 3 with frame for no variables End scope at 278 +++ 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/edx, eax load-stack-arg-n #t, N1/NSPILL--1, 0 push eax 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-3, esp, 0 add N4/NSPILL-2, esp, 4 move N5/NSPILL-0, N0/edx #({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/NSPILL-0, N3/NSPILL-3 #() [80->95] (level:1) is green with stack state with #({basic-block #() 95 115}, {basic-block #({tag 2:135}) 135 140}) ld N2/NSPILL-1, N4/NSPILL-2, N5/NSPILL-0 move G9/edi, N1/NSPILL--1 beq {tag 2:135}, G9/edi, {constant "KLobjectGVKd"} #() [95->115] (level:1) is red with stack state with #({basic-block #() 115 120}) ld N8/ebx, G9/edi, 4 push G9/edi move eax, N2/NSPILL-1 call N8/ebx, 1 #() [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}, eax, {constant "KPfalseVKi"} #() [120->135] (level:1) is red with stack state with #({basic-block #({tag 2:135}) 135 140}) push N1/NSPILL--1 move eax, N2/NSPILL-1 call {constant "Ktype_check_errorVKiI"}, 1 #({tag 2:135}) [135->140] (level:1) is green with stack state with #({basic-block #({tag 1:75}) 75 80}) add N5/NSPILL-0, N5/NSPILL-0, 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/ecx, 32 asl N7/ebx, N6/ecx, 2 sub esp, esp, N7/ebx ld-teb-address esi, 36 copy-words-down-w esp, esi, N6/ecx push N7/ebx #() [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 N10/ebx bne {tag 6:155}, N10/ebx, 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 eax #({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 4 #({tag 6:155}) [155->185] (level:1) is red with stack state with #({basic-block #({tag 7:185}) 185 190}) asr N12/edx, N10/ebx, 2 st-teb N12/edx, 32 ld-teb-address N11/edi, 36 copy-words-down-w N11/edi, esp, N12/edx add esp, esp, N10/ebx 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: 4 +++ +++ Live variable scopes for primitive_type_check_rest_values +++ Start scope at 3 with frame for no variables End scope at 139 +++ 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}, edi, 1 #() [15->25] (level:0) is green with stack state #f #({basic-block #() 25 40}, {basic-block #({tag 3:40}) 40 45}) st-teb edi, 32 beq {tag 3:40}, edi, 0 #() [25->40] (level:0) is green with stack state #f #({basic-block #({tag 3:40}) 40 45}) ld-teb-address N3/ebx, 36 fill-words-w N3/ebx, edi, {constant "KPfalseVKi"} st eax, N3/ebx, 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/ebx, 32 beq {tag 2:105}, edi, N0/ebx #() [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}, edi, 1 #() [60->70] (level:0) is green with stack state #f #({basic-block #() 70 100}, {basic-block #({tag 4:100}) 100 105}) st-teb edi, 32 blt {tag 4:100}, edi, N0/ebx #() [70->100] (level:0) is green with stack state #f #({basic-block #({tag 4:100}) 100 105}) sub N1/ecx, edi, N0/ebx move N2/edi, N0/ebx ld-teb-address N3/ebx, 36 asl N2/edi, N2/edi, 2 add N2/edi, N2/edi, N3/ebx fill-words-w N2/edi, N1/ecx, {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}, edi, 1 #() [15->35] (level:0) is green with stack state #f #({basic-block #({tag 3:35}) 35 40}) st-teb edi, 32 ld-teb-address N3/edx, 36 fill-words-w N3/edx, edi, {constant "KPfalseVKi"} st eax, N3/edx, 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/ebx, 32 ble {tag 2:95}, edi, N0/ebx #() [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}, edi, 1 #() [55->85] (level:0) is green with stack state #f #({basic-block #({tag 4:85}) 85 95}) sub N1/ecx, edi, N0/ebx move N2/ebx, N0/ebx ld-teb-address N3/edx, 36 asl N2/ebx, N2/ebx, 2 add N2/ebx, N2/ebx, N3/edx fill-words-w N2/ebx, N1/ecx, {constant "KPfalseVKi"} #({tag 4:85}) [85->95] (level:0) is green with stack state #f #({basic-block #({tag 2:95}) 95 95}) st-teb edi, 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}, edi, 1 #() [15->25] (level:0) is green with stack state #f #({basic-block #({tag 2:70}) 70 70}) ld-teb-address N3/ebx, 36 fill-words-w N3/ebx, edi, {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/ebx, 32 beq {tag 2:70}, edi, 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}, edi, N0/ebx #() [40->70] (level:0) is green with stack state #f #({basic-block #({tag 2:70}) 70 70}) sub N1/ecx, edi, N0/ebx move N2/edi, N0/ebx ld-teb-address N3/ebx, 36 asl N2/edi, N2/edi, 2 add N2/edi, N2/edi, N3/ebx fill-words-w N2/edi, N1/ecx, {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/ebx, ebx move N3/eax, eax ld N1/edx, N3/eax, 4 asr N1/edx, N1/edx, 2 bne {tag 2:40}, N1/edx, 1 #({tag 1:30}) [30->40] (level:0) is green with stack state #f #({basic-block #({tag 4:90}) 85 90}) ld eax, N3/eax, 8 reset-values #({tag 4:90}) [85->90] (level:0) is green with stack state #f #({basic-block #({tag 4:90}) 90 95}) move ebx, G0/ebx #({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 N1/edx, 32 beq {tag 3:75}, N1/edx, 0 #() [50->75] (level:0) is green with stack state #f #({basic-block #({tag 4:90}) 85 90}) add esi, N3/eax, 8 ld eax, esi, 0 ld-teb-address N2/edi, 36 copy-words-down-w N2/edi, esi, N1/edx 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 eax, {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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 45}) pop esi sub esp, esp, 56 st eax, esp, 52 ld-teb eax, 0 st ebp, esp, 48 st eax, esp, 44 move eax, esp #() [40->45] (level:0) is #f with stack state #f #() jmp esi, 0, 0, #f, #f +++ 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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}) pop N0/edi sub esp, esp, 12 st eax, esp, 8 ld-teb eax, 0 st ebp, esp, 4 st eax, esp, 0 move eax, esp st-teb esp, 0 #() [45->50] (level:0) is #f with stack state #f #() jmp N0/edi, 0, 0, #f, #f +++ 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 N1/ebx, 0 ld N0/edi, N1/ebx, 0 st-teb N0/edi, 0 push eax 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 N1/ebx ld N0/edi, N1/ebx, 8 call N0/edi, 0 #() [80->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}, {basic-block #({tag 3:100}) 100 130}) pop N1/ebx pop N4/edx bne {tag 3:100}, N4/edx, 1 #() [95->100] (level:0) is #f with stack state #f #({basic-block #({tag 4:130}) 130 145}) reset-values #({tag 4:130}) [130->145] (level:0) is #f with stack state #f #({basic-block #() 145 150}) pop eax ld esi, esp, 0 add esp, N1/ebx, 12 #() [145->150] (level:0) is #f with stack state #f #() jmp esi, 0, 0, #f, #f #({tag 1:35}) [35->65] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 80}) ld-teb N2/ecx, 32 asl N3/edx, N2/ecx, 2 sub esp, esp, N3/edx ld-teb-address esi, 36 copy-words-down-w esp, esi, N2/ecx push N3/edx #() [150->155] (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 145}) asr N6/eax, N4/edx, 2 st-teb N6/eax, 32 ld-teb-address N5/edi, 36 copy-words-down-w N5/edi, esp, N6/eax add esp, esp, N4/edx set-values #() [155->160] (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/edx, 0 ld N0/ecx, eax, 44 move N2/ebx, eax load-stack-arg-n #t, N3/edi, 0 bne {tag 1:55}, N1/edx, N0/ecx #() [30->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}) move eax, N3/edi ld N4/edi, N2/ebx, 52 ld ebp, N2/ebx, 48 add esp, N2/ebx, 56 #() [50->55] (level:0) is #f with stack state #f #() jmp N4/edi, 1, 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/eax, N2/ebx, 4 bmvset {tag 2:75} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 3:165}) 165 170}) st N3/edi, N5/eax, 8 st 5, N5/eax, 4 #({tag 3:165}) [165->170] (level:0) is #f with stack state #f #({basic-block #({tag 5:170}) 170 175}) st N5/eax, N2/ebx, 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/edx, 0 #() [175->210] (level:1) is #f with stack state #f #({basic-block #() 210 230}) move esp, N1/edx ld N9/edi, esp, 0 ld N10/eax, esp, 8 st-teb N9/edi, 0 ld ebp, esp, 4 push N2/ebx call N10/eax, 0 #() [210->230] (level:1) is #f with stack state #f #({basic-block #() 230 255}, {basic-block #({tag 5:170}) 170 175}) pop N2/ebx ld-teb N1/edx, 0 ld N11/edi, N2/ebx, 44 bne {tag 5:170}, N11/edi, N1/edx #() [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 G12/eax, N2/ebx, 0 move N15/eax, G12/eax ld N13/edx, N15/eax, 4 asr N13/edx, N13/edx, 2 bne {tag 8:265}, N13/edx, 1 #({tag 7:255}) [255->265] (level:0) is #f with stack state #f #({basic-block #({tag 10:310}) 310 325}) ld eax, N15/eax, 8 reset-values #({tag 10:310}) [310->325] (level:0) is #f with stack state #f #({basic-block #() 325 330}) ld N16/edi, N2/ebx, 52 ld ebp, N2/ebx, 48 add esp, N2/ebx, 56 #() [325->330] (level:0) is #f with stack state #f #() jmp N16/edi, 1, 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 ecx, 32 ble {tag 4:135}, ecx, 8 #() [85->110] (level:0) is #f with stack state #f #({basic-block #() 110 135}) push ecx push N2/ebx push N1/edx move eax, ecx call {constant "primitive_allocate_vector"}, 1 #() [110->135] (level:0) is #f with stack state #f #({basic-block #({tag 4:135}) 135 165}) move G6/eax, eax pop N1/edx pop N2/ebx pop ecx move N5/eax, G6/eax #({tag 4:135}) [135->165] (level:0) is #f with stack state #f #({basic-block #({tag 3:165}) 165 170}) asl N8/edi, ecx, 2 add N8/edi, N8/edi, 1 st N8/edi, N5/eax, 4 add N7/edi, N5/eax, 8 ld-teb-address esi, 36 copy-words-down-w N7/edi, esi, ecx #() [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 N13/edx, 32 beq {tag 9:300}, N13/edx, 0 #() [275->300] (level:0) is #f with stack state #f #({basic-block #({tag 10:310}) 310 325}) add esi, N15/eax, 8 ld eax, esi, 0 ld-teb-address N14/edi, 36 copy-words-down-w N14/edi, esi, N13/edx 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 eax, {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 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) pop N0/edx move N1/edi, eax asl N3/ebx, N1/edi, 2 add N3/ebx, N3/ebx, 8 sub esp, esp, N3/ebx move N2/eax, esp asl N4/edi, N1/edi, 2 add N4/edi, N4/edi, 1 st N4/edi, N2/eax, 4 st {constant "KLsimple_object_vectorGVKdW"}, N2/eax, 0 move eax, N2/eax #() [60->65] (level:0) is #f with stack state #f #() jmp N0/edx, 0, 0, #f, #f +++ 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 95}) rem "This is a dummy first basic block." #() [5->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) ld esi, esp, 4 pop N0/edx add esp, esp, 4 move N1/ebx, eax asl N3/edi, N1/ebx, 2 add N3/edi, N3/edi, 8 sub esp, esp, N3/edi move N2/eax, esp asl N4/edi, N1/ebx, 2 add N4/edi, N4/edi, 1 st N4/edi, N2/eax, 4 st {constant "KLsimple_object_vectorGVKdW"}, N2/eax, 0 add N5/edi, N2/eax, 8 move ecx, N1/ebx move edi, N5/edi move esi, esi copy-words-down-w edi, esi, ecx move eax, N2/eax #() [95->100] (level:0) is #f with stack state #f #() jmp N0/edx, 0, 0, #f, #f +++ 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 110}) rem "This is a dummy first basic block." #() [5->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) ld esi, esp, 4 ld N0/edi, esp, 8 asl N0/edi, N0/edi, 2 add esi, esi, N0/edi pop N1/edx add esp, esp, 8 move N2/ebx, eax asl N4/edi, N2/ebx, 2 add N4/edi, N4/edi, 8 sub esp, esp, N4/edi move N3/eax, esp asl N5/edi, N2/ebx, 2 add N5/edi, N5/edi, 1 st N5/edi, N3/eax, 4 st {constant "KLsimple_object_vectorGVKdW"}, N3/eax, 0 add N6/edi, N3/eax, 8 move ecx, N2/ebx move edi, N6/edi move esi, esi copy-words-down-w edi, esi, ecx move eax, N3/eax #() [110->115] (level:0) is #f with stack state #f #() jmp N1/edx, 0, 0, #f, #f +++ 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 esi, 36 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}, edi, 0 #() [20->30] (level:0) is green with stack state before #({basic-block #({tag 2:75}) 75 90}) st eax, esi, 0 move eax, 1 #({tag 2:75}) [75->90] (level:0) is green with stack state before #({basic-block #() 90 95}, {basic-block #({tag 12:180}) 180 195}) move N6/edi, esi move N5/eax, eax bne {tag 12:180}, N5/eax, 0 #() [90->95] (level:0) is green with stack state before #({basic-block #({tag 5:150}) 145 150}) move G7/eax, {constant "KPempty_vectorVKi"} #({tag 5:150}) [145->150] (level:0) is green with stack state before #({basic-block #({tag 5:150}, {tag 10:150}) 150 155}) move eax, G7/eax #({tag 5:150}, {tag 10:150}) [150->155] (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 N2/ebx, 32 bge {tag 3:30}, edi, N2/ebx #() [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}, edi, 0 #() [50->55] (level:0) is green with stack state before #({basic-block #({tag 4:55}) 55 75}) st eax, esi, 0 #({tag 4:55}) [55->75] (level:0) is green with stack state before #({basic-block #({tag 2:75}) 75 90}) sub N2/ebx, N2/ebx, edi asl edi, edi, 2 add esi, esi, edi move eax, N2/ebx #() [195->200] (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 eax, 0 #() [200->205] (level:0) is #f with stack state #f #() bra {tag 2:75} #({tag 12:180}) [180->195] (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:95}) 95 135}) move N0/eax, N5/eax move N1/ebx, N6/edi #({tag 6:95}) [95->135] (level:0) is red with stack state with #({basic-block #() 135 145}) asl N4/edi, N0/eax, 2 add N4/edi, N4/edi, 8 push N1/ebx push 1 push N0/eax push {constant "KLsimple_object_vectorGVKdW"} push N4/edi call-alien {constant "primitive_alloc_rt"}, 0 #() [135->145] (level:0) is red with stack state with #({basic-block #({tag 8:175}) 165 170}) add esp, esp, 20 move G3/eax, eax #({tag 8:175}) [165->170] (level:0) is yellow with stack state with #({basic-block #({tag 8:175}, {tag 9:175}) 170 175}) move G7/eax, G3/eax #({tag 8:175}, {tag 9:175}) [170->175] (level:0) is green with stack state with #({basic-block #({tag 9:175}, {tag 8:175}, {tag 11:175}) 175 180}) move eax, G7/eax #({tag 9:175}, {tag 8:175}, {tag 11:175}) [175->180] (level:0) is #f with stack state #f #({basic-block #({tag 5:150}, {tag 10:150}) 150 155}) preserve-registers-exit #() [205->210] (level:0) is #f with stack state #f #() bra {tag 5:150} +++ ending code for primitive_heap_vector_remaining_values +++ +++ Live variable scopes for primitive_heap_vector_remaining_values +++ Start scope at 81 with frame for no variables End scope at 109 +++ 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 esi, 36 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}, edi, 0 #() [20->30] (level:0) is #f with stack state #f #({basic-block #({tag 2:75}) 75 155}) st eax, esi, 0 move eax, 1 #({tag 2:75}) [75->155] (level:0) is #f with stack state #f #({basic-block #() 155 160}) pop N1/edx move N2/ebx, eax asl N4/edi, N2/ebx, 2 add N4/edi, N4/edi, 8 sub esp, esp, N4/edi move N3/eax, esp asl N5/edi, N2/ebx, 2 add N5/edi, N5/edi, 1 st N5/edi, N3/eax, 4 st {constant "KLsimple_object_vectorGVKdW"}, N3/eax, 0 add N6/edi, N3/eax, 8 move ecx, N2/ebx move edi, N6/edi move esi, esi copy-words-down-w edi, esi, ecx move eax, N3/eax #() [155->160] (level:0) is #f with stack state #f #() jmp N1/edx, 0, 0, #f, #f #({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 N0/ebx, 32 bge {tag 3:30}, edi, N0/ebx #() [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}, edi, 0 #() [50->55] (level:0) is #f with stack state #f #({basic-block #({tag 4:55}) 55 75}) st eax, esi, 0 #({tag 4:55}) [55->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:75}) 75 155}) sub N0/ebx, N0/ebx, edi asl edi, edi, 2 add esi, esi, edi move eax, N0/ebx #() [160->165] (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 155}) move eax, 0 #() [165->170] (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:250}) 250 275}) move ebx, eax load-stack-arg-n #t, N0/edx, 0 load-stack-arg-n #t, N1/eax, 1 move N2/eax, N1/eax ld ecx, N2/eax, 4 asr ecx, ecx, 2 add eax, N2/eax, 8 ld N3/edi, ebx, 8 ld N3/edi, N3/edi, 4 and N3/edi, N3/edi, 1310720 bne {tag 1:250}, N3/edi, 0 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}, {basic-block #({tag 3:80}) 80 90}) beq {tag 3:80}, ecx, 0 #() [65->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 4:95}) 95 110}) beq {tag 4:95}, ecx, 1 #() [70->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}, {basic-block #({tag 5:115}) 115 140}) beq {tag 5:115}, ecx, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 2:180}) 180 245}, {basic-block #({tag 6:145}) 145 175}) beq {tag 6:145}, ecx, 3 #({tag 2:180}) [180->245] (level:0) is #f with stack state #f #({basic-block #() 245 250}) sub ecx, ecx, 1 pop esi add esp, esp, 8 asl N5/edi, ecx, 2 sub esp, esp, N5/edi move N4/edi, esp push esi add eax, eax, 4 move edi, N4/edi move esi, eax copy-words-down-w edi, esi, ecx move edi, N0/edx ld eax, eax, -4 #() [245->250] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 1:250}) [250->275] (level:0) is #f with stack state #f #({basic-block #() 275 535}, {basic-block #({tag 7:540}) 540 560}) ld N6/edi, ebx, 8 ld N6/edi, N6/edi, 4 asr N6/edi, N6/edi, 2 and N6/edi, N6/edi, 255 beq {tag 7:540}, N6/edi, 0 #() [275->535] (level:0) is #f with stack state #f #({basic-block #() 535 540}) pop N7/edi add esp, esp, 4 st N0/edx, esp, 0 asl esi, ecx, 2 sub esp, esp, esi push N7/edi add N9/edi, esp, 4 push ecx move edi, N9/edi move esi, eax copy-words-down-w edi, esi, ecx pop ecx ld eax, esp, 4 move-return-address #f, 4, #f ld N14/edi, ebx, 8 ld N14/edi, N14/edi, 4 asr N14/edi, N14/edi, 2 and N14/edi, N14/edi, 255 move esi, esp sub esp, esp, 16 move N13/edx, ecx move ecx, N14/edi move N15/edi, esp move edi, N15/edi move esi, esi copy-words-down-w edi, esi, ecx move N12/edi, esi asl N13/edx, N13/edx, 2 move ecx, N13/edx ld esi, ebx, 8 ld esi, esi, 4 and esi, esi, 1020 sub N13/edx, N13/edx, esi add N13/edx, N13/edx, 1 st N13/edx, N12/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N12/edi, -8 add ecx, ecx, 12 st ecx, N12/edi, -12 add N16/edx, N12/edi, -8 st N16/edx, N12/edi, -16 ld N17/edi, ebx, 8 ld N17/edi, N17/edi, 4 asr N17/edi, N17/edi, 2 and N17/edi, N17/edi, 255 asl N17/edi, N17/edi, 2 add N18/edi, esp, N17/edi add N18/edi, N18/edi, 4 ld N19/edx, N18/edi, 0 add N19/edx, N19/edx, 4 st N19/edx, N18/edi, 0 ld N0/edx, esp, N19/edx move edi, N0/edx #() [535->540] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 3:80}) [80->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}) move-return-address #f, 8, #f move edi, N0/edx #() [90->95] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 4:95}) [95->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) move-return-address #f, 8, #f move edi, N0/edx ld eax, eax, 0 #() [110->115] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 5:115}) [115->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) ld esi, eax, 4 store-stack-arg-n esi, 1 move-return-address #f, 4, #f move edi, N0/edx ld eax, eax, 0 #() [140->145] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 6:145}) [145->175] (level:0) is #f with stack state #f #({basic-block #() 175 180}) ld esi, eax, 4 store-stack-arg-n esi, 0 ld esi, eax, 8 store-stack-arg-n esi, 1 move edi, N0/edx ld eax, eax, 0 #() [175->180] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 7:540}) [540->560] (level:0) is #f with stack state #f #({basic-block #() 560 565}) sub eax, eax, 8 store-stack-arg-n 4, 1 move-return-address #f, 4, #f move edi, N0/edx #() [560->565] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f +++ 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:250}) 250 255}) move ebx, eax load-stack-arg-n #t, N0/edx, 0 load-stack-arg-n #t, N1/eax, 1 move N2/eax, N1/eax ld ecx, N2/eax, 4 asr ecx, ecx, 2 add eax, N2/eax, 8 ld N3/edi, ebx, 8 ld N3/edi, N3/edi, 4 and N3/edi, N3/edi, 1310720 bne {tag 1:250}, N3/edi, 0 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}, {basic-block #({tag 3:80}) 80 90}) beq {tag 3:80}, ecx, 0 #() [65->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}, {basic-block #({tag 4:95}) 95 110}) beq {tag 4:95}, ecx, 1 #() [70->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}, {basic-block #({tag 5:115}) 115 140}) beq {tag 5:115}, ecx, 2 #() [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 2:180}) 180 245}, {basic-block #({tag 6:145}) 145 175}) beq {tag 6:145}, ecx, 3 #({tag 2:180}) [180->245] (level:0) is #f with stack state #f #({basic-block #() 245 250}) sub ecx, ecx, 1 pop esi add esp, esp, 8 asl N5/edi, ecx, 2 sub esp, esp, N5/edi move N4/edi, esp push esi add eax, eax, 4 move edi, N4/edi move esi, eax copy-words-down-w edi, esi, ecx move edi, N0/edx ld eax, eax, -4 #() [245->250] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 1:250}) [250->255] (level:0) is #f with stack state #f #({basic-block #() 255 260}, {basic-block #({tag 8:260}) 260 280}) beq {tag 8:260}, ecx, 1 #() [255->260] (level:0) is #f with stack state #f #({basic-block #({tag 7:315}) 315 390}, {basic-block #({tag 9:285}) 285 310}) beq {tag 9:285}, ecx, 2 #({tag 7:315}) [315->390] (level:0) is #f with stack state #f #({basic-block #() 390 395}) asl N7/edi, ecx, 2 store-stack-arg-n N7/edi, 1 pop esi sub ecx, ecx, 1 add esp, esp, 4 asl N8/edi, ecx, 2 sub esp, esp, N8/edi move N6/edi, esp push esi add eax, eax, 4 move edi, N6/edi move esi, eax copy-words-down-w edi, esi, ecx move edi, N0/edx ld eax, eax, -4 #() [390->395] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 3:80}) [80->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}) move-return-address #f, 8, #f move edi, N0/edx #() [90->95] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 4:95}) [95->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) move-return-address #f, 8, #f move edi, N0/edx ld eax, eax, 0 #() [110->115] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 5:115}) [115->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) ld esi, eax, 4 store-stack-arg-n esi, 1 move-return-address #f, 4, #f move edi, N0/edx ld eax, eax, 0 #() [140->145] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 6:145}) [145->175] (level:0) is #f with stack state #f #({basic-block #() 175 180}) ld esi, eax, 4 store-stack-arg-n esi, 0 ld esi, eax, 8 store-stack-arg-n esi, 1 move edi, N0/edx ld eax, eax, 0 #() [175->180] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 8:260}) [260->280] (level:0) is #f with stack state #f #({basic-block #() 280 285}) store-stack-arg-n 4, 1 move-return-address #f, 4, #f move edi, N0/edx ld eax, eax, 0 #() [280->285] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 9:285}) [285->310] (level:0) is #f with stack state #f #({basic-block #() 310 315}) ld esi, eax, 4 store-stack-arg-n esi, 0 store-stack-arg-n 8, 1 move edi, N0/edx ld eax, eax, 0 #() [310->315] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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:35}) 35 50}) move ebx, eax ld G6/edx, esp, 4 ld N0/ecx, G6/edx, 4 asr N0/ecx, N0/ecx, 2 beq {tag 2:35}, N0/ecx, 1 #() [30->35] (level:0) is #f with stack state #f #({basic-block #({tag 1:75}) 75 155}, {basic-block #({tag 3:55}) 55 70}) beq {tag 3:55}, N0/ecx, 2 #({tag 1:75}) [75->155] (level:0) is #f with stack state #f #({basic-block #() 155 160}) pop N3/edi asl N2/eax, N0/ecx, 2 sub esp, esp, N2/eax sub N1/eax, N0/ecx, 1 add esp, esp, 8 push N3/edi add N5/edi, esp, 4 add N4/ecx, G6/edx, 12 move edi, N5/edi move esi, N4/ecx copy-words-down-w edi, esi, N1/eax ld N0/ecx, G6/edx, 4 asr N0/ecx, N0/ecx, 2 move ecx, N0/ecx add G6/edx, G6/edx, 8 ld eax, G6/edx, 0 #() [155->160] (level:0) is #f with stack state #f #() jmp {constant "apply_xep"}, #[1, #"function", #"arg-count"], 0, #f, #f #({tag 2:35}) [35->50] (level:0) is #f with stack state #f #({basic-block #() 50 55}) ld eax, G6/edx, 8 pop esi st esi, esp, 0 #() [50->55] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_0"}, #[1, #"function"], 0, #f, #f #({tag 3:55}) [55->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) ld eax, G6/edx, 8 ld esi, G6/edx, 12 st esi, esp, 4 #() [70->75] (level:0) is #f with stack state #f #() jmp {constant "apply_xep_1"}, #[1, #"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 ecx push edi add N0/edx, esi, 12 ld N1/edx, esp, N0/edx sub N2/edi, esi, 4 sub N1/edx, N1/edx, N2/edi move N4/ecx, esi add esi, esp, 12 add N3/edi, esi, N1/edx copy-words-up N3/edi, esi, N4/ecx pop edi pop ecx #() [65->70] (level:0) is #f with stack state #f #() rts-and-drop N1/edx +++ 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: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-alien {constant "c_primitive_start_timer"}, 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_start_timer +++ +++ Live variable scopes for primitive_start_timer +++ Start scope at 3 with frame for no variables End scope at 8 +++ 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: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-alien {constant "c_primitive_stop_timer"}, 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_stop_timer +++ +++ Live variable scopes for primitive_stop_timer +++ Start scope at 3 with frame for no variables End scope at 8 +++ 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: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}) push eax call-alien {constant "exit"}, 0 #() [15->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) add esp, esp, 4 #({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_exit_application +++ +++ Live variable scopes for primitive_exit_application +++ Start scope at 3 with frame for no variables End scope at 12 +++ 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: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}) push eax call-alien {constant "system"}, 0 #() [15->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) add esp, esp, 4 #({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_run_application +++ +++ Live variable scopes for primitive_run_application +++ Start scope at 3 with frame for no variables End scope at 12 +++ No Source Code Locators for primitive_run_application +++ +++ 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 8:105}) 105 120}) rem "This is a dummy first basic block." #({tag 8: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 #({tag 2:20}) 20 30}, {basic-block #({tag 4:80}) 80 95}) load-stack-arg-n #t, G0/GSPILL--1, 0 load-stack-arg-n #t, N1/edx, 1 beq {tag 4:80}, N1/edx, 0 #({tag 2:20}) [20->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 6:35}) 35 50}) load-address-of-stack-arg-n #t, N4/ecx, 2 bgt {tag 6:35}, N1/edx, 0 #() [30->35] (level:0) is red with stack state with #({basic-block #({tag 4:80}) 80 95}) rem "eliminated" #({tag 4:80}) [80->95] (level:0) is red with stack state with #({basic-block #() 95 95}) move ebx, G0/GSPILL--1 move ecx, N1/edx call-indirect ebx, 4, 1 #() [95->95] (level:0) is red with stack state with #({basic-block #({tag 7:100}) 100 105}) #({tag 7: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 #({tag 6:35}) [35->50] (level:0) is red with stack state with #({basic-block #({tag 3:50}) 50 80}, {basic-block #({tag 4:80}) 80 95}) ld eax, N4/ecx, 0 add N5/ebx, N4/ecx, 4 beq {tag 4:80}, N1/edx, 1 #({tag 3:50}) [50->80] (level:0) is red with stack state with #({basic-block #({tag 4:80}) 80 95}) sub N2/ecx, N1/edx, 1 asl N3/edi, N2/ecx, 2 sub esp, esp, N3/edi move edi, esp move esi, N5/ebx copy-words-down-w edi, esi, N2/ecx #() [120->125] (level:0) is #f with stack state #f #() bra {tag 4:80} +++ ending code for call_first_dylan_function +++ +++ Live variable scopes for call_first_dylan_function +++ Start scope at 7 with frame for no variables End scope at 30 +++ 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 8:110}) 110 125}) rem "This is a dummy first basic block." #({tag 8: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 #({tag 2:20}) 20 30}, {basic-block #({tag 4:80}) 80 95}) load-stack-arg-n #t, G0/GSPILL--1, 0 load-stack-arg-n #t, N1/edx, 1 beq {tag 4:80}, N1/edx, 0 #({tag 2:20}) [20->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 6:35}) 35 50}) load-address-of-stack-arg-n #t, N4/ecx, 2 bgt {tag 6:35}, N1/edx, 0 #() [30->35] (level:0) is red with stack state with #({basic-block #({tag 4:80}) 80 95}) rem "eliminated" #({tag 4:80}) [80->95] (level:0) is red with stack state with #({basic-block #() 95 100}) move ebx, G0/GSPILL--1 move ecx, N1/edx call-indirect ebx, 4, 1 #() [95->100] (level:0) is red with stack state with #({basic-block #({tag 7:105}) 105 110}) move eax, eax #({tag 7: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 #({tag 6:35}) [35->50] (level:0) is red with stack state with #({basic-block #({tag 3:50}) 50 80}, {basic-block #({tag 4:80}) 80 95}) ld eax, N4/ecx, 0 add N5/ebx, N4/ecx, 4 beq {tag 4:80}, N1/edx, 1 #({tag 3:50}) [50->80] (level:0) is red with stack state with #({basic-block #({tag 4:80}) 80 95}) sub N2/ecx, N1/edx, 1 asl N3/edi, N2/ecx, 2 sub esp, esp, N3/edi move edi, esp move esi, N5/ebx copy-words-down-w edi, esi, N2/ecx #() [125->130] (level:0) is #f with stack state #f #() bra {tag 4:80} +++ ending code for call_dylan_function +++ +++ Live variable scopes for call_dylan_function +++ Start scope at 7 with frame for no variables End scope at 30 +++ 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 8:120}) 120 135}) rem "This is a dummy first basic block." #({tag 8:120}) [120->135] (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 #({tag 2:25}) 25 35}, {basic-block #({tag 4:85}) 85 100}) load-stack-arg-n #t, G0/GSPILL--1, 0 load-stack-arg-n #t, N1/edx, 1 move {indirect-constant "Prunning_dylan_spy_functionQ"}, 1 beq {tag 4:85}, N1/edx, 0 #({tag 2:25}) [25->35] (level:0) is red with stack state with #({basic-block #() 35 40}, {basic-block #({tag 6:40}) 40 55}) load-address-of-stack-arg-n #t, N4/ecx, 2 bgt {tag 6:40}, N1/edx, 0 #() [35->40] (level:0) is red with stack state with #({basic-block #({tag 4:85}) 85 100}) rem "eliminated" #({tag 4:85}) [85->100] (level:0) is red with stack state with #({basic-block #() 100 110}) move ebx, G0/GSPILL--1 move ecx, N1/edx call-indirect ebx, 4, 1 #() [100->110] (level:0) is red with stack state with #({basic-block #({tag 7:115}) 115 120}) move eax, eax move {indirect-constant "Prunning_dylan_spy_functionQ"}, 0 #({tag 7: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 #({tag 6:40}) [40->55] (level:0) is red with stack state with #({basic-block #({tag 3:55}) 55 85}, {basic-block #({tag 4:85}) 85 100}) ld eax, N4/ecx, 0 add N5/ebx, N4/ecx, 4 beq {tag 4:85}, N1/edx, 1 #({tag 3:55}) [55->85] (level:0) is red with stack state with #({basic-block #({tag 4:85}) 85 100}) sub N2/ecx, N1/edx, 1 asl N3/edi, N2/ecx, 2 sub esp, esp, N3/edi move edi, esp move esi, N5/ebx copy-words-down-w edi, esi, N2/ecx #() [135->140] (level:0) is #f with stack state #f #() bra {tag 4:85} +++ ending code for spy_call_dylan_function +++ +++ Live variable scopes for spy_call_dylan_function +++ Start scope at 7 with frame for no variables End scope at 50 +++ 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 14:245}) 245 260}) rem "This is a dummy first basic block." #({tag 14:245}) [245->260] (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 #({tag 2:20}) 20 30}, {basic-block #({tag 4:80}) 80 95}) load-stack-arg-n #t, G0/GSPILL--1, 0 load-stack-arg-n #t, N1/edx, 1 beq {tag 4:80}, N1/edx, 0 #({tag 2:20}) [20->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 6:35}) 35 50}) load-address-of-stack-arg-n #t, N4/ecx, 2 bgt {tag 6:35}, N1/edx, 0 #() [30->35] (level:0) is red with stack state with #({basic-block #({tag 4:80}) 80 95}) rem "eliminated" #({tag 4:80}) [80->95] (level:0) is red with stack state with #({basic-block #() 95 110}) move ebx, G0/GSPILL--1 move ecx, N1/edx call-indirect ebx, 4, 1 #() [95->110] (level:0) is red with stack state with #({basic-block #() 110 115}, {basic-block #({tag 7:130}) 130 140}) move N8/edx, 0 ld-teb-address N7/edi, 36 bmvset {tag 7:130} #() [110->115] (level:0) is red with stack state with #({basic-block #() 115 125}, {basic-block #({tag 9:125}) 125 130}) bne {tag 9:125}, N8/edx, 0 #() [115->125] (level:0) is red with stack state with #({basic-block #({tag 8:170}) 170 175}) st eax, N7/edi, 0 move N6/edx, 1 #({tag 8:170}) [170->175] (level:0) is red with stack state with #({basic-block #() 175 180}, {basic-block #({tag 12:180}) 180 220}) bne {tag 12:180}, N6/edx, 0 #() [175->180] (level:0) is red with stack state with #({basic-block #({tag 11:240}) 230 235}) move G10/eax, {constant "KPempty_vectorVKi"} #({tag 11:240}) [230->235] (level:0) is red with stack state with #({basic-block #({tag 11:240}, {tag 13:240}) 240 245}) move eax, G10/eax #({tag 11:240}, {tag 13:240}) [240->245] (level:0) is #f with stack state #f #({basic-block #() 235 240}) preserve-registers-exit #() [235->240] (level:0) is red with stack state #f #() rts #({tag 6:35}) [35->50] (level:0) is red with stack state with #({basic-block #({tag 3:50}) 50 80}, {basic-block #({tag 4:80}) 80 95}) ld eax, N4/ecx, 0 add N5/ebx, N4/ecx, 4 beq {tag 4:80}, N1/edx, 1 #({tag 3:50}) [50->80] (level:0) is red with stack state with #({basic-block #({tag 4:80}) 80 95}) sub N2/ecx, N1/edx, 1 asl N3/edi, N2/ecx, 2 sub esp, esp, N3/edi move edi, esp move esi, N5/ebx copy-words-down-w edi, esi, N2/ecx #() [260->265] (level:0) is #f with stack state #f #() bra {tag 4:80} #({tag 7:130}) [130->140] (level:0) is red with stack state with #({basic-block #() 140 145}, {basic-block #({tag 9:125}) 125 130}) ld-teb N9/ebx, 32 bge {tag 9:125}, N8/edx, N9/ebx #() [140->145] (level:0) is red with stack state with #({basic-block #() 145 150}, {basic-block #({tag 10:150}) 150 170}) bne {tag 10:150}, N8/edx, 0 #() [145->150] (level:0) is red with stack state with #({basic-block #({tag 10:150}) 150 170}) st eax, N7/edi, 0 #({tag 10:150}) [150->170] (level:0) is red with stack state with #({basic-block #({tag 8:170}) 170 175}) sub N9/ebx, N9/ebx, N8/edx asl N8/edx, N8/edx, 2 add N7/edi, N7/edi, N8/edx move N6/edx, N9/ebx #() [265->270] (level:0) is #f with stack state #f #() bra {tag 8:170} #({tag 9:125}) [125->130] (level:0) is red with stack state with #({basic-block #({tag 8:170}) 170 175}) move N6/edx, 0 #() [270->275] (level:0) is #f with stack state #f #() bra {tag 8:170} #({tag 12:180}) [180->220] (level:0) is red with stack state with #({basic-block #() 220 230}) asl N11/ecx, N6/edx, 2 add N11/ecx, N11/ecx, 8 push N7/edi push 1 push N6/edx push {constant "KLsimple_object_vectorGVKdW"} push N11/ecx call-alien {constant "primitive_alloc_rt"}, 0 #() [220->230] (level:0) is red with stack state with #({basic-block #({tag 11:240}) 230 235}) add esp, esp, 20 move G10/eax, eax #() [275->280] (level:0) is #f with stack state #f #() bra {tag 11:240} +++ ending code for call_dylan_function_returning_all_values +++ +++ Live variable scopes for call_dylan_function_returning_all_values +++ Start scope at 7 with frame for no variables End scope at 71 +++ 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:75}) 75 90}) rem "This is a dummy first basic block." #({tag 2:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #() 5 50}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->50] (level:0) is red with stack state with #({basic-block #() 50 65}) load-stack-arg-n #t, N0/ecx, 0 asl N2/edx, N0/ecx, 2 add N2/edx, N2/edx, 8 push {constant "KPunboundVKi"} push 1 push N0/ecx push {constant "KLsimple_object_vectorGVKdW"} push N2/edx call-alien {constant "primitive_alloc_rf"}, 0 #() [50->65] (level:0) is red with stack state with #({basic-block #({tag 1:70}) 70 75}) add esp, esp, 20 move G1/eax, eax move eax, G1/eax #({tag 1:70}) [70->75] (level:0) is #f with stack state #f #({basic-block #() 65 70}) preserve-registers-exit #() [65->70] (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 3 with frame for no variables End scope at 36 +++ 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 eax #() [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 #({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 green with stack state with #({basic-block #({tag 1:15}) 15 20}) ld-teb eax, 4 #({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 green with stack state #f #() rts +++ ending code for get_tlv_vector +++ +++ Live variable scopes for get_tlv_vector +++ Start scope at 4 with frame for no variables End scope at 13 +++ 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 #({tag 2:25}) 25 40}) rem "This is a dummy first basic block." #({tag 2:25}) [25->40] (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 #({tag 1:20}) 20 25}) load-stack-arg-n #t, G0/edx, 0 st-teb G0/edx, 4 #({tag 1:20}) [20->25] (level:0) is #f with stack state #f #({basic-block #() 15 20}) preserve-registers-exit #() [15->20] (level:0) is green with stack state #f #() rts +++ ending code for set_tlv_vector +++ +++ Live variable scopes for set_tlv_vector +++ Start scope at 4 with frame for no variables End scope at 16 +++ 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 #({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 green with stack state with #({basic-block #({tag 1:15}) 15 20}) ld-teb eax, 8 #({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 green with stack state #f #() rts +++ ending code for get_current_thread +++ +++ Live variable scopes for get_current_thread +++ Start scope at 4 with frame for no variables End scope at 13 +++ 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 #({tag 2:25}) 25 40}) rem "This is a dummy first basic block." #({tag 2:25}) [25->40] (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 #({tag 1:20}) 20 25}) load-stack-arg-n #t, G0/edx, 0 st-teb G0/edx, 8 #({tag 1:20}) [20->25] (level:0) is #f with stack state #f #({basic-block #() 15 20}) preserve-registers-exit #() [15->20] (level:0) is green with stack state #f #() rts +++ ending code for set_current_thread +++ +++ Live variable scopes for set_current_thread +++ Start scope at 4 with frame for no variables End scope at 16 +++ 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 #({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 green with stack state with #({basic-block #({tag 1:15}) 15 20}) ld-teb eax, 12 #({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 green with stack state #f #() rts +++ ending code for get_current_thread_handle +++ +++ Live variable scopes for get_current_thread_handle +++ Start scope at 4 with frame for no variables End scope at 13 +++ 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 #({tag 2:25}) 25 40}) rem "This is a dummy first basic block." #({tag 2:25}) [25->40] (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 #({tag 1:20}) 20 25}) load-stack-arg-n #t, G0/edx, 0 st-teb G0/edx, 12 #({tag 1:20}) [20->25] (level:0) is #f with stack state #f #({basic-block #() 15 20}) preserve-registers-exit #() [15->20] (level:0) is green with stack state #f #() rts +++ ending code for set_current_thread_handle +++ +++ Live variable scopes for set_current_thread_handle +++ Start scope at 4 with frame for no variables End scope at 16 +++ 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:85}) 85 100}) rem "This is a dummy first basic block." #({tag 2:85}) [85->100] (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 70}) load-stack-arg-n #t, N0/edi, 0 move G2/edx, {constant "Kmake_simple_lockYthreads_primitivesVdylan"} push G2/edx push 16 call-alien {constant "primitive_copy"}, 0 #() [30->70] (level:0) is red with stack state with #({basic-block #() 70 75}) add esp, esp, 8 move G1/eax, eax st N0/edi, G1/eax, 12 push G1/eax move eax, -3 move ebx, {indirect-constant "spy_invoke_dylan_under_coded_restartVKi"} move ecx, 2 call-indirect ebx, 4, 1 #() [70->75] (level:0) is red with stack state with #({basic-block #({tag 1:80}) 80 85}) move eax, eax #({tag 1: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 +++ ending code for spy_call_interactive_function +++ +++ Live variable scopes for spy_call_interactive_function +++ Start scope at 7 with frame for no variables End scope at 49 +++ 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}) load-stack-arg-n #f, N0/eax, 0 ld eax, N0/eax, 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 #({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 green with stack state with #({basic-block #({tag 1:25}) 25 30}) load-stack-arg-n #t, N0/edi, 0 load-stack-arg-n #t, N1/edx, 1 st N1/edx, N0/edi, 0 #({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 green with stack state #f #() rts +++ ending code for spy_write_location_through_barrier +++ +++ Live variable scopes for spy_write_location_through_barrier +++ Start scope at 5 with frame for no variables End scope at 12 +++ 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 #({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 green with stack state with #({basic-block #({tag 1:25}) 25 30}) load-stack-arg-n #t, N0/edx, 0 ld-teb G1/eax, 4 ld-index-scaled eax, G1/eax, N0/edx, 0 #({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 green with stack state #f #() rts +++ ending code for spy_read_thread_variable_at_offset +++ +++ Live variable scopes for spy_read_thread_variable_at_offset +++ Start scope at 4 with frame for no variables End scope at 19 +++ 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: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}) push 0 call-alien {constant "exit"}, 0 #() [15->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) add esp, esp, 4 #({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 spy_exit_application +++ +++ Live variable scopes for spy_exit_application +++ Start scope at 3 with frame for no variables End scope at 13 +++ 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}) load-stack-arg-n #t, N0/eax, 0 move eax, N0/eax 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 7 with frame for no variables End scope at 14 +++ 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 70}) rem "This is a dummy first basic block." #() [5->70] (level:0) is #f with stack state #f #({basic-block #() 70 90}, {basic-block #({tag 4:125}) 125 130}) preserve-registers-entry move N2/ecx, ecx ld G1/edx, ebx, 8 ld G1/edx, G1/edx, 8 push G1/edx push 0 push 0 push N2/ecx push eax push ebx push edi ld esi, G1/edx, 8 beq {tag 4:125}, esi, {constant "KLobjectGVKd"} #() [70->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 6:95}) 95 115}) store-frame-offset esi, -3 store-frame-offset eax, -2 move G4/edi, esi bne {tag 6:95}, G4/edi, {constant "KLobjectGVKd"} #() [90->95] (level:0) is #f with stack state #f #({basic-block #({tag 5:115}) 115 125}) move eax, {constant "KPtrueVKi"} #({tag 5:115}) [115->125] (level:0) is #f with stack state #f #({basic-block #({tag 4:125}) 125 130}, {basic-block #({tag 1:280}) 280 305}) load-frame-offset #t, G1/edx, -1 beq {tag 1:280}, eax, {constant "KPfalseVKi"} #({tag 4:125}) [125->130] (level:0) is #f with stack state #f #({basic-block #({tag 2:130}) 130 135}) load-frame-offset #t, N2/ecx, -4 #({tag 2:130}) [130->135] (level:2) is #f with stack state #f #({basic-block #() 135 150}, {basic-block #({tag 3:225}) 225 270}) ble {tag 3:225}, N2/ecx, 4 #() [135->150] (level:2) is #f with stack state #f #({basic-block #() 150 185}, {basic-block #({tag 2:130}) 130 135}) sub N2/ecx, N2/ecx, 4 ld-index esi, G1/edx, N2/ecx, 8 beq {tag 2:130}, esi, {constant "KLobjectGVKd"} #() [150->185] (level:1) is #f with stack state #f #({basic-block #() 185 190}, {basic-block #({tag 8:190}) 190 210}) add N5/eax, N2/ecx, 4 ld G0/eax, ebp, N5/eax store-frame-offset esi, -3 store-frame-offset G0/eax, -2 store-frame-offset N2/ecx, -4 move G7/edi, esi bne {tag 8:190}, G7/edi, {constant "KLobjectGVKd"} #() [185->190] (level:1) is #f with stack state #f #({basic-block #({tag 7:210}) 210 225}) move eax, {constant "KPtrueVKi"} #({tag 7:210}) [210->225] (level:1) is #f with stack state #f #({basic-block #({tag 2:130}) 130 135}, {basic-block #({tag 1:280}) 280 305}) load-frame-offset #t, N2/ecx, -4 load-frame-offset #t, G1/edx, -1 bne {tag 2:130}, eax, {constant "KPfalseVKi"} #({tag 1:280}) [280->305] (level:0) is #f with stack state #f #({basic-block #() 305 305}) load-frame-offset #t, G10/edi, -3 load-frame-offset #t, G9/eax, -2 push G10/edi move eax, G9/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [305->305] (level:0) is #f with stack state #f #({basic-block #() 305 310}) #() [305->310] (level:0) is #f with stack state #f #() rts #({tag 6:95}) [95->115] (level:0) is #f with stack state #f #({basic-block #({tag 5:115}) 115 125}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, eax call N3/ebx, 1 #() [310->315] (level:0) is #f with stack state #f #() bra {tag 5:115} #({tag 3:225}) [225->270] (level:2) is #f with stack state #f #({basic-block #() 270 270}, {basic-block #({tag 9:275}) 275 275}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit ld N8/edx, ebx, 8 ld N8/edx, N8/edx, 4 and N8/edx, N8/edx, 262144 bne {tag 9:275}, N8/edx, 0 #() [270->270] (level:2) is #f with stack state #f #({basic-block #() 270 275}) #() [270->275] (level:2) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 8:190}) [190->210] (level:1) is #f with stack state #f #({basic-block #({tag 7:210}) 210 225}) ld N6/ebx, G7/edi, 4 push G7/edi move eax, G0/eax call N6/ebx, 1 #() [315->320] (level:0) is #f with stack state #f #() bra {tag 7:210} #({tag 9:275}) [275->275] (level:2) is #f with stack state #f #({basic-block #({tag 9:275}) 275 280}) #({tag 9:275}) [275->280] (level:2) is #f with stack state #f #() jmp-indirect ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f +++ ending code for primitive_check_specializers +++ +++ Live variable scopes for primitive_check_specializers +++ Start scope at 3 with frame for no variables End scope at 149 +++ No Source Code Locators for primitive_check_specializers +++ +++ 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 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #({tag 4:85}) 85 90}) ld G0/edx, ebx, 20 push eax push ebx push edi push G0/edx ld G2/edi, ebx, 8 ld G2/edi, G2/edi, 4 and N4/edi, G2/edi, 524288 push N4/edi ld G1/edx, ebx, 20 ld N9/edi, G1/edx, 4 sub N9/edi, N9/edi, 1 lsr N10/eax, N9/edi, 1 add N12/ebx, G1/edx, 12 sub N11/edi, ecx, N10/eax add N11/edi, N11/edi, 4 #({tag 4:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 5:110}) 110 125}) bhi {tag 5:110}, N11/edi, ecx #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 4:85}) 85 90}) ld G13/eax, N12/ebx, 0 st G13/eax, N11/edi, 0 add N12/ebx, N12/ebx, 8 add N11/edi, N11/edi, 4 #() [315->320] (level:0) is #f with stack state #f #() bra {tag 4:85} #({tag 5:110}) [110->125] (level:1) is #f with stack state #f #({basic-block #() 125 165}, {basic-block #({tag 1:170}) 170 225}) ld N5/ebx, esi, 4 sub N5/ebx, N5/ebx, 1 nbit {tag 1:170}, N5/ebx, 4, 0 #() [125->165] (level:1) is #f with stack state #f #({basic-block #() 165 165}) add esp, esp, 4 add esp, esp, 4 pop edi pop ebx pop eax preserve-registers-entry move eax, ebx call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [165->165] (level:1) is #f with stack state #f #({basic-block #() 165 170}) #() [165->170] (level:1) is #f with stack state #f #() rts #({tag 1:170}) [170->225] (level:1) is #f with stack state #f #({basic-block #({tag 2:270}, {tag 9:270}) 270 285}) add N3/edi, esi, 8 add esi, N5/ebx, N3/edi ld N6/eax, G1/edx, 4 sub N6/eax, N6/eax, 1 add N7/edx, G1/edx, 8 add N8/ebx, N7/edx, N6/eax sub N8/ebx, N8/ebx, 8 asr N6/eax, N6/eax, 1 sub ecx, ecx, N6/eax add ecx, ecx, 4 push N3/edi #({tag 2:270}, {tag 9:270}) [270->285] (level:3) is #f with stack state #f #({basic-block #() 285 310}, {basic-block #({tag 3:225}) 225 235}) sub esi, esi, 8 ld N3/edi, esp, 0 bhs {tag 3:225}, esi, N3/edi #() [285->310] (level:1) is #f with stack state #f #({basic-block #() 310 315}) add esp, esp, 8 add esp, esp, 4 pop edi pop ebx pop eax #() [310->315] (level:1) is #f with stack state #f #() jmp-indirect ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f #({tag 3:225}) [225->235] (level:3) is #f with stack state #f #({basic-block #({tag 7:245}) 245 250}) ld G15/eax, esi, 0 move N17/edi, N7/edx #({tag 7:245}) [245->250] (level:4) is #f with stack state #f #({basic-block #({tag 2:270}, {tag 9:270}) 270 285}, {basic-block #({tag 6:235}) 235 240}) bhi {tag 2:270}, N17/edi, N8/ebx #({tag 6:235}) [235->240] (level:3) is #f with stack state #f #({basic-block #() 240 245}, {basic-block #({tag 8:250}) 250 270}) beq-mem {tag 8:250}, N17/edi, 0, G15/eax #() [240->245] (level:2) is #f with stack state #f #({basic-block #({tag 7:245}) 245 250}) add N17/edi, N17/edi, 8 #() [320->325] (level:0) is #f with stack state #f #() bra {tag 7:245} #({tag 8:250}) [250->270] (level:3) is #f with stack state #f #({basic-block #({tag 2:270}, {tag 9:270}) 270 285}) sub N16/edi, N17/edi, N7/edx asr N16/edi, N16/edi, 1 ld G14/eax, esi, 4 st G14/eax, ecx, N16/edi #() [325->330] (level:0) is #f with stack state #f #() bra {tag 2:270} +++ ending code for primitive_process_keys +++ +++ No Source Code Locators for primitive_process_keys +++ +++ 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 85}) rem "This is a dummy first basic block." #() [5->85] (level:0) is #f with stack state #f #({basic-block #({tag 4:85}) 85 90}) ld G0/edx, ebx, 20 push eax push ebx push edi push G0/edx ld G2/edi, ebx, 8 ld G2/edi, G2/edi, 4 and N4/edi, G2/edi, 524288 push N4/edi ld G1/edx, ebx, 20 ld N9/edi, G1/edx, 4 sub N9/edi, N9/edi, 1 lsr N10/eax, N9/edi, 1 add N12/ebx, G1/edx, 12 sub N11/edi, ecx, N10/eax add N11/edi, N11/edi, 4 #({tag 4:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 5:110}) 110 125}) bhi {tag 5:110}, N11/edi, ecx #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 4:85}) 85 90}) ld G13/eax, N12/ebx, 0 st G13/eax, N11/edi, 0 add N12/ebx, N12/ebx, 8 add N11/edi, N11/edi, 4 #() [315->320] (level:0) is #f with stack state #f #() bra {tag 4:85} #({tag 5:110}) [110->125] (level:1) is #f with stack state #f #({basic-block #() 125 165}, {basic-block #({tag 1:170}) 170 225}) ld N5/ebx, esi, 4 sub N5/ebx, N5/ebx, 1 nbit {tag 1:170}, N5/ebx, 4, 0 #() [125->165] (level:1) is #f with stack state #f #({basic-block #() 165 165}) add esp, esp, 4 add esp, esp, 4 pop edi pop ebx pop eax preserve-registers-entry move eax, ebx call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [165->165] (level:1) is #f with stack state #f #({basic-block #() 165 170}) #() [165->170] (level:1) is #f with stack state #f #() rts #({tag 1:170}) [170->225] (level:1) is #f with stack state #f #({basic-block #({tag 2:270}, {tag 9:270}) 270 285}) add N3/edi, esi, 8 add esi, N5/ebx, N3/edi ld N6/eax, G1/edx, 4 sub N6/eax, N6/eax, 1 add N7/edx, G1/edx, 8 add N8/ebx, N7/edx, N6/eax sub N8/ebx, N8/ebx, 8 asr N6/eax, N6/eax, 1 sub ecx, ecx, N6/eax add ecx, ecx, 4 push N3/edi #({tag 2:270}, {tag 9:270}) [270->285] (level:3) is #f with stack state #f #({basic-block #() 285 310}, {basic-block #({tag 3:225}) 225 235}) sub esi, esi, 8 ld N3/edi, esp, 0 bhs {tag 3:225}, esi, N3/edi #() [285->310] (level:1) is #f with stack state #f #({basic-block #() 310 315}) add esp, esp, 8 add esp, esp, 4 pop edi pop ebx pop eax #() [310->315] (level:1) is #f with stack state #f #() jmp-indirect ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f #({tag 3:225}) [225->235] (level:3) is #f with stack state #f #({basic-block #({tag 7:245}) 245 250}) ld G15/eax, esi, 0 move N17/edi, N7/edx #({tag 7:245}) [245->250] (level:4) is #f with stack state #f #({basic-block #({tag 2:270}, {tag 9:270}) 270 285}, {basic-block #({tag 6:235}) 235 240}) bhi {tag 2:270}, N17/edi, N8/ebx #({tag 6:235}) [235->240] (level:3) is #f with stack state #f #({basic-block #() 240 245}, {basic-block #({tag 8:250}) 250 270}) beq-mem {tag 8:250}, N17/edi, 0, G15/eax #() [240->245] (level:2) is #f with stack state #f #({basic-block #({tag 7:245}) 245 250}) add N17/edi, N17/edi, 8 #() [320->325] (level:0) is #f with stack state #f #() bra {tag 7:245} #({tag 8:250}) [250->270] (level:3) is #f with stack state #f #({basic-block #({tag 2:270}, {tag 9:270}) 270 285}) sub N16/edi, N17/edi, N7/edx asr N16/edi, N16/edi, 1 ld G14/eax, esi, 4 st G14/eax, ecx, N16/edi #() [325->330] (level:0) is #f with stack state #f #() bra {tag 2:270} +++ 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 +++ +++ starting code for primitive_process_keys_checking_args_for_xep +++ #() [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 #({tag 5:85}) 85 90}) ld G1/edx, ebx, 20 push eax push ebx push edi push G1/edx ld G3/edi, ebx, 8 ld G3/edi, G3/edi, 4 and N5/edi, G3/edi, 524288 push N5/edi ld G2/edx, ebx, 20 ld N10/edi, G2/edx, 4 sub N10/edi, N10/edi, 1 lsr N11/eax, N10/edi, 1 add N13/ebx, G2/edx, 12 sub N12/edi, ecx, N11/eax add N12/edi, N12/edi, 4 #({tag 5:85}) [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 110}, {basic-block #({tag 6:110}) 110 125}) bhi {tag 6:110}, N12/edi, ecx #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 5:85}) 85 90}) ld G14/eax, N13/ebx, 0 st G14/eax, N12/edi, 0 add N13/ebx, N13/ebx, 8 add N12/edi, N12/edi, 4 #() [605->610] (level:0) is #f with stack state #f #() bra {tag 5:85} #({tag 6:110}) [110->125] (level:1) is #f with stack state #f #({basic-block #() 125 165}, {basic-block #({tag 2:170}) 170 225}) ld N6/ebx, esi, 4 sub N6/ebx, N6/ebx, 1 nbit {tag 2:170}, N6/ebx, 4, 0 #() [125->165] (level:1) is #f with stack state #f #({basic-block #() 165 165}) add esp, esp, 4 add esp, esp, 4 pop edi pop ebx pop eax preserve-registers-entry move eax, ebx call {constant "Kodd_keyword_arguments_errorVKiI"}, 1 #() [165->165] (level:1) is #f with stack state #f #({basic-block #() 165 170}) #() [165->170] (level:1) is #f with stack state #f #() rts #({tag 2:170}) [170->225] (level:1) is #f with stack state #f #({basic-block #({tag 3:270}, {tag 10:270}) 270 285}) add N4/edi, esi, 8 add esi, N6/ebx, N4/edi ld N7/eax, G2/edx, 4 sub N7/eax, N7/eax, 1 add N8/edx, G2/edx, 8 add N9/ebx, N8/edx, N7/eax sub N9/ebx, N9/ebx, 8 asr N7/eax, N7/eax, 1 sub ecx, ecx, N7/eax add ecx, ecx, 4 push N4/edi #({tag 3:270}, {tag 10:270}) [270->285] (level:3) is #f with stack state #f #({basic-block #() 285 390}, {basic-block #({tag 4:225}) 225 235}) sub esi, esi, 8 ld N4/edi, esp, 0 bhs {tag 4:225}, esi, N4/edi #() [285->390] (level:1) is #f with stack state #f #({basic-block #() 390 410}, {basic-block #({tag 15:445}) 445 450}) add esp, esp, 8 add esp, esp, 4 pop edi pop ebx pop eax preserve-registers-entry ld N0/edx, ebx, 8 ld N0/edx, N0/edx, 4 and N0/edx, N0/edx, 1020 move N23/edx, N0/edx ld G22/ecx, ebx, 8 ld G22/ecx, G22/ecx, 8 push G22/ecx push 0 push 0 push N23/edx push eax push ebx push edi ld esi, G22/ecx, 8 beq {tag 15:445}, esi, {constant "KLobjectGVKd"} #() [390->410] (level:1) is #f with stack state #f #({basic-block #() 410 415}, {basic-block #({tag 17:415}) 415 435}) store-frame-offset esi, -3 store-frame-offset eax, -2 move G25/edi, esi bne {tag 17:415}, G25/edi, {constant "KLobjectGVKd"} #() [410->415] (level:1) is #f with stack state #f #({basic-block #({tag 16:435}) 435 445}) move eax, {constant "KPtrueVKi"} #({tag 16:435}) [435->445] (level:1) is #f with stack state #f #({basic-block #({tag 15:445}) 445 450}, {basic-block #({tag 1:575}) 575 600}) load-frame-offset #t, G22/ecx, -1 beq {tag 1:575}, eax, {constant "KPfalseVKi"} #({tag 15:445}) [445->450] (level:1) is #f with stack state #f #({basic-block #({tag 13:450}) 450 455}) load-frame-offset #t, N23/edx, -4 #({tag 13:450}) [450->455] (level:3) is #f with stack state #f #({basic-block #() 455 470}, {basic-block #({tag 14:545}) 545 570}) ble {tag 14:545}, N23/edx, 4 #() [455->470] (level:3) is #f with stack state #f #({basic-block #() 470 505}, {basic-block #({tag 13:450}) 450 455}) sub N23/edx, N23/edx, 4 ld-index esi, G22/ecx, N23/edx, 8 beq {tag 13:450}, esi, {constant "KLobjectGVKd"} #() [470->505] (level:2) is #f with stack state #f #({basic-block #() 505 510}, {basic-block #({tag 19:510}) 510 530}) add N26/eax, N23/edx, 4 ld G21/eax, ebp, N26/eax store-frame-offset esi, -3 store-frame-offset G21/eax, -2 store-frame-offset N23/edx, -4 move G28/edi, esi bne {tag 19:510}, G28/edi, {constant "KLobjectGVKd"} #() [505->510] (level:2) is #f with stack state #f #({basic-block #({tag 18:530}) 530 545}) move eax, {constant "KPtrueVKi"} #({tag 18:530}) [530->545] (level:2) is #f with stack state #f #({basic-block #({tag 13:450}) 450 455}, {basic-block #({tag 1:575}) 575 600}) load-frame-offset #t, N23/edx, -4 load-frame-offset #t, G22/ecx, -1 bne {tag 13:450}, eax, {constant "KPfalseVKi"} #({tag 1:575}) [575->600] (level:1) is #f with stack state #f #({basic-block #() 600 600}) load-frame-offset #t, G30/edi, -3 load-frame-offset #t, G29/eax, -2 push G30/edi move eax, G29/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [600->600] (level:1) is #f with stack state #f #({basic-block #() 600 605}) #() [600->605] (level:1) is #f with stack state #f #() rts #({tag 4:225}) [225->235] (level:3) is #f with stack state #f #({basic-block #({tag 8:245}) 245 250}) ld G16/eax, esi, 0 move N18/edi, N8/edx #({tag 8:245}) [245->250] (level:4) is #f with stack state #f #({basic-block #({tag 3:270}, {tag 10:270}) 270 285}, {basic-block #({tag 7:235}) 235 240}) bhi {tag 3:270}, N18/edi, N9/ebx #({tag 7:235}) [235->240] (level:3) is #f with stack state #f #({basic-block #() 240 245}, {basic-block #({tag 9:250}) 250 270}) beq-mem {tag 9:250}, N18/edi, 0, G16/eax #() [240->245] (level:2) is #f with stack state #f #({basic-block #({tag 8:245}) 245 250}) add N18/edi, N18/edi, 8 #() [610->615] (level:0) is #f with stack state #f #() bra {tag 8:245} #({tag 17:415}) [415->435] (level:1) is #f with stack state #f #({basic-block #({tag 16:435}) 435 445}) ld N24/ebx, G25/edi, 4 push G25/edi move eax, eax call N24/ebx, 1 #() [615->620] (level:0) is #f with stack state #f #() bra {tag 16:435} #({tag 14:545}) [545->570] (level:3) is #f with stack state #f #({basic-block #() 570 575}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #() [570->575] (level:3) is #f with stack state #f #() jmp-indirect ebx, 16, #[1, #"mlist", #"function"], 0, #f, #f #({tag 19:510}) [510->530] (level:2) is #f with stack state #f #({basic-block #({tag 18:530}) 530 545}) ld N27/ebx, G28/edi, 4 push G28/edi move eax, G21/eax call N27/ebx, 1 #() [620->625] (level:0) is #f with stack state #f #() bra {tag 18:530} #({tag 9:250}) [250->270] (level:3) is #f with stack state #f #({basic-block #({tag 3:270}, {tag 10:270}) 270 285}) sub N17/edi, N18/edi, N8/edx asr N17/edi, N17/edi, 1 ld G15/eax, esi, 4 st G15/eax, ecx, N17/edi #() [625->630] (level:0) is #f with stack state #f #() bra {tag 3:270} +++ ending code for primitive_process_keys_checking_args_for_xep +++ +++ Live variable scopes for primitive_process_keys_checking_args_for_xep +++ Start scope at 83 with frame for no variables End scope at 326 +++ 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}, ecx, 2 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move edi, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_instance_getterVKiI"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move edi, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_instance_setterVKiI"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 2 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move edi, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_class_getterVKiI"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move edi, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_single_q_class_setterVKiI"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 3 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move edi, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_repeated_instance_getterVKiI"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 4 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move edi, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp {constant "KPslotacc_repeated_instance_setterVKiI"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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/eax, eax load-stack-arg-n #f, N2/edi, 0 asr N2/edi, N2/edi, 2 beq {tag 1:50}, N2/edi, 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/edi, 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/edi, 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/edi, 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/edi, 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/edi, 5 #({tag 1:50}) [50->55] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/edi, {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/edi, G0/eax, 4 move eax, G0/eax #() [90->95] (level:0) is green with stack state #f #() rts-and-drop 4 #({tag 2:55}) [55->60] (level:0) is green with stack state #f #({basic-block #({tag 7:80}) 80 90}) move N1/edi, {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/edi, {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/edi, {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/edi, {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/edi, {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}, ecx, 0 #() [10->15] (level:0) is #f with stack state #f #({basic-block #() 15 20}) move edi, {constant "KPfalseVKi"} #() [15->20] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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:145}) 145 175}) bne {tag 1:145}, ecx, 1 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 85}, {basic-block #({tag 4:140}) 140 140}) move edi, {constant "KPfalseVKi"} ld G1/edx, ebx, 8 ld G1/edx, G1/edx, 8 ld-index-scaled esi, G1/edx, 0, 8 beq {tag 4:140}, esi, {constant "KLobjectGVKd"} #() [35->85] (level:0) is #f with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 110}) move G0/ecx, eax preserve-registers-entry push G1/edx push G0/ecx push esi push eax push ebx push edi move G3/edi, esi bne {tag 6:90}, G3/edi, {constant "KLobjectGVKd"} #() [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 5:110}) 110 115}) move eax, {constant "KPtrueVKi"} #({tag 5:110}) [110->115] (level:0) is #f with stack state #f #({basic-block #() 115 140}, {basic-block #({tag 3:180}, {tag 2:180}) 180 205}) beq {tag 3:180}, eax, {constant "KPfalseVKi"} #() [115->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:140}) 140 140}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 4:140}) [140->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:140}) 140 145}) #({tag 4:140}) [140->145] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:145}) [145->175] (level:0) is #f with stack state #f #({basic-block #() 175 175}) preserve-registers-entry asl N4/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [175->175] (level:0) is #f with stack state #f #({basic-block #() 175 180}) #() [175->180] (level:0) is #f with stack state #f #() rts #({tag 6:90}) [90->110] (level:0) is #f with stack state #f #({basic-block #({tag 5:110}) 110 115}) ld N2/ebx, G3/edi, 4 push G3/edi move eax, G0/ecx call N2/ebx, 1 #() [210->215] (level:0) is #f with stack state #f #() bra {tag 5:110} #({tag 3:180}, {tag 2:180}) [180->205] (level:0) is #f with stack state #f #({basic-block #() 205 205}) load-frame-offset #t, G6/edi, -3 load-frame-offset #t, G5/eax, -2 push G6/edi move eax, G5/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [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 +++ ending code for xep_1 +++ +++ Live variable scopes for xep_1 +++ Start scope at 32 with frame for no variables End scope at 62 Start scope at 63 no frame for no variables End scope at 69 +++ 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:270}) 270 300}) bne {tag 1:270}, ecx, 2 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 85}, {basic-block #({tag 4:140}) 140 160}) move edi, {constant "KPfalseVKi"} ld G1/edx, ebx, 8 ld G1/edx, G1/edx, 8 ld-index-scaled esi, G1/edx, 0, 8 beq {tag 4:140}, esi, {constant "KLobjectGVKd"} #() [35->85] (level:0) is #f with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 110}) move G0/ecx, eax preserve-registers-entry push G1/edx push G0/ecx push esi push eax push ebx push edi move G3/edi, esi bne {tag 6:90}, G3/edi, {constant "KLobjectGVKd"} #() [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 5:110}) 110 115}) move eax, {constant "KPtrueVKi"} #({tag 5:110}) [110->115] (level:0) is #f with stack state #f #({basic-block #() 115 140}, {basic-block #({tag 3:305}, {tag 2:305}) 305 330}) beq {tag 3:305}, eax, {constant "KPfalseVKi"} #() [115->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:140}) 140 160}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 4:140}) [140->160] (level:0) is #f with stack state #f #({basic-block #() 160 210}, {basic-block #({tag 7:265}) 265 265}) ld G5/edx, ebx, 8 ld G5/edx, G5/edx, 8 ld-index-scaled esi, G5/edx, 1, 8 beq {tag 7:265}, esi, {constant "KLobjectGVKd"} #() [160->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}, {basic-block #({tag 9:215}) 215 235}) load-stack-arg-n #t, G4/ecx, 0 preserve-registers-entry push G5/edx push G4/ecx push esi push eax push ebx push edi move G7/edi, esi bne {tag 9:215}, G7/edi, {constant "KLobjectGVKd"} #() [210->215] (level:0) is #f with stack state #f #({basic-block #({tag 8:235}) 235 240}) move eax, {constant "KPtrueVKi"} #({tag 8:235}) [235->240] (level:0) is #f with stack state #f #({basic-block #() 240 265}, {basic-block #({tag 3:305}, {tag 2:305}) 305 330}) beq {tag 3:305}, eax, {constant "KPfalseVKi"} #() [240->265] (level:0) is #f with stack state #f #({basic-block #({tag 7:265}) 265 265}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 7:265}) [265->265] (level:0) is #f with stack state #f #({basic-block #({tag 7:265}) 265 270}) #({tag 7:265}) [265->270] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:270}) [270->300] (level:0) is #f with stack state #f #({basic-block #() 300 300}) preserve-registers-entry asl N8/ecx, ecx, 2 add N8/ecx, N8/ecx, 1 push N8/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [300->300] (level:0) is #f with stack state #f #({basic-block #() 300 305}) #() [300->305] (level:0) is #f with stack state #f #() rts #({tag 6:90}) [90->110] (level:0) is #f with stack state #f #({basic-block #({tag 5:110}) 110 115}) ld N2/ebx, G3/edi, 4 push G3/edi move eax, G0/ecx call N2/ebx, 1 #() [335->340] (level:0) is #f with stack state #f #() bra {tag 5:110} #({tag 3:305}, {tag 2:305}) [305->330] (level:0) is #f with stack state #f #({basic-block #() 330 330}) load-frame-offset #t, G10/edi, -3 load-frame-offset #t, G9/eax, -2 push G10/edi move eax, G9/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [330->330] (level:0) is #f with stack state #f #({basic-block #() 330 335}) #() [330->335] (level:0) is #f with stack state #f #() rts #({tag 9:215}) [215->235] (level:0) is #f with stack state #f #({basic-block #({tag 8:235}) 235 240}) ld N6/ebx, G7/edi, 4 push G7/edi move eax, G4/ecx call N6/ebx, 1 #() [340->345] (level:0) is #f with stack state #f #() bra {tag 8:235} +++ ending code for xep_2 +++ +++ Live variable scopes for xep_2 +++ Start scope at 32 with frame for no variables End scope at 62 Start scope at 63 no frame for no variables End scope at 87 Start scope at 88 with frame for no variables End scope at 118 Start scope at 119 no frame for no variables End scope at 125 +++ 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:395}) 395 425}) bne {tag 1:395}, ecx, 3 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 85}, {basic-block #({tag 4:140}) 140 160}) move edi, {constant "KPfalseVKi"} ld G1/edx, ebx, 8 ld G1/edx, G1/edx, 8 ld-index-scaled esi, G1/edx, 0, 8 beq {tag 4:140}, esi, {constant "KLobjectGVKd"} #() [35->85] (level:0) is #f with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 6:90}) 90 110}) move G0/ecx, eax preserve-registers-entry push G1/edx push G0/ecx push esi push eax push ebx push edi move G3/edi, esi bne {tag 6:90}, G3/edi, {constant "KLobjectGVKd"} #() [85->90] (level:0) is #f with stack state #f #({basic-block #({tag 5:110}) 110 115}) move eax, {constant "KPtrueVKi"} #({tag 5:110}) [110->115] (level:0) is #f with stack state #f #({basic-block #() 115 140}, {basic-block #({tag 3:430}, {tag 2:430}) 430 455}) beq {tag 3:430}, eax, {constant "KPfalseVKi"} #() [115->140] (level:0) is #f with stack state #f #({basic-block #({tag 4:140}) 140 160}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 4:140}) [140->160] (level:0) is #f with stack state #f #({basic-block #() 160 210}, {basic-block #({tag 7:265}) 265 285}) ld G5/edx, ebx, 8 ld G5/edx, G5/edx, 8 ld-index-scaled esi, G5/edx, 1, 8 beq {tag 7:265}, esi, {constant "KLobjectGVKd"} #() [160->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}, {basic-block #({tag 9:215}) 215 235}) load-stack-arg-n #t, G4/ecx, 0 preserve-registers-entry push G5/edx push G4/ecx push esi push eax push ebx push edi move G7/edi, esi bne {tag 9:215}, G7/edi, {constant "KLobjectGVKd"} #() [210->215] (level:0) is #f with stack state #f #({basic-block #({tag 8:235}) 235 240}) move eax, {constant "KPtrueVKi"} #({tag 8:235}) [235->240] (level:0) is #f with stack state #f #({basic-block #() 240 265}, {basic-block #({tag 3:430}, {tag 2:430}) 430 455}) beq {tag 3:430}, eax, {constant "KPfalseVKi"} #() [240->265] (level:0) is #f with stack state #f #({basic-block #({tag 7:265}) 265 285}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 7:265}) [265->285] (level:0) is #f with stack state #f #({basic-block #() 285 335}, {basic-block #({tag 10:390}) 390 390}) ld G9/edx, ebx, 8 ld G9/edx, G9/edx, 8 ld-index-scaled esi, G9/edx, 2, 8 beq {tag 10:390}, esi, {constant "KLobjectGVKd"} #() [285->335] (level:0) is #f with stack state #f #({basic-block #() 335 340}, {basic-block #({tag 12:340}) 340 360}) load-stack-arg-n #t, G8/ecx, 1 preserve-registers-entry push G9/edx push G8/ecx push esi push eax push ebx push edi move G11/edi, esi bne {tag 12:340}, G11/edi, {constant "KLobjectGVKd"} #() [335->340] (level:0) is #f with stack state #f #({basic-block #({tag 11:360}) 360 365}) move eax, {constant "KPtrueVKi"} #({tag 11:360}) [360->365] (level:0) is #f with stack state #f #({basic-block #() 365 390}, {basic-block #({tag 3:430}, {tag 2:430}) 430 455}) beq {tag 3:430}, eax, {constant "KPfalseVKi"} #() [365->390] (level:0) is #f with stack state #f #({basic-block #({tag 10:390}) 390 390}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 10:390}) [390->390] (level:0) is #f with stack state #f #({basic-block #({tag 10:390}) 390 395}) #({tag 10:390}) [390->395] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:395}) [395->425] (level:0) is #f with stack state #f #({basic-block #() 425 425}) preserve-registers-entry asl N12/ecx, ecx, 2 add N12/ecx, N12/ecx, 1 push N12/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [425->425] (level:0) is #f with stack state #f #({basic-block #() 425 430}) #() [425->430] (level:0) is #f with stack state #f #() rts #({tag 6:90}) [90->110] (level:0) is #f with stack state #f #({basic-block #({tag 5:110}) 110 115}) ld N2/ebx, G3/edi, 4 push G3/edi move eax, G0/ecx call N2/ebx, 1 #() [460->465] (level:0) is #f with stack state #f #() bra {tag 5:110} #({tag 3:430}, {tag 2:430}) [430->455] (level:0) is #f with stack state #f #({basic-block #() 455 455}) load-frame-offset #t, G14/edi, -3 load-frame-offset #t, G13/eax, -2 push G14/edi move eax, G13/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [455->455] (level:0) is #f with stack state #f #({basic-block #() 455 460}) #() [455->460] (level:0) is #f with stack state #f #() rts #({tag 9:215}) [215->235] (level:0) is #f with stack state #f #({basic-block #({tag 8:235}) 235 240}) ld N6/ebx, G7/edi, 4 push G7/edi move eax, G4/ecx call N6/ebx, 1 #() [465->470] (level:0) is #f with stack state #f #() bra {tag 8:235} #({tag 12:340}) [340->360] (level:0) is #f with stack state #f #({basic-block #({tag 11:360}) 360 365}) ld N10/ebx, G11/edi, 4 push G11/edi move eax, G8/ecx call N10/ebx, 1 #() [470->475] (level:0) is #f with stack state #f #() bra {tag 11:360} +++ ending code for xep_3 +++ +++ Live variable scopes for xep_3 +++ Start scope at 36 with frame for no variables End scope at 74 Start scope at 75 no frame for no variables End scope at 99 Start scope at 100 with frame for no variables End scope at 130 Start scope at 131 no frame for no variables End scope at 155 Start scope at 156 with frame for no variables End scope at 186 Start scope at 187 no frame for no variables End scope at 193 +++ 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 25}, {basic-block #({tag 1:35}) 35 65}) bne {tag 1:35}, ecx, 4 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move edi, {constant "KPfalseVKi"} move ecx, 16 move ecx, ecx #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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_4 +++ +++ 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}, ecx, 5 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move edi, {constant "KPfalseVKi"} move ecx, 20 move ecx, ecx #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 6 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move edi, {constant "KPfalseVKi"} move ecx, 24 move ecx, ecx #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 7 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move edi, {constant "KPfalseVKi"} move ecx, 28 move ecx, ecx #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 8 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move edi, {constant "KPfalseVKi"} move ecx, 32 move ecx, ecx #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 9 #() [10->25] (level:0) is #f with stack state #f #({basic-block #() 25 30}) move edi, {constant "KPfalseVKi"} move ecx, 36 move ecx, ecx #() [25->30] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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/ecx, ecx, 2 add N0/ecx, N0/ecx, 1 push N0/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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/edi, ebx, 8 ld N0/edi, N0/edi, 4 asr N0/edi, N0/edi, 2 and N0/edi, N0/edi, 255 bne {tag 1:65}, ecx, N0/edi #() [30->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) move edi, {constant "KPfalseVKi"} ld N1/ecx, ebx, 8 ld N1/ecx, N1/ecx, 4 and N1/ecx, N1/ecx, 1020 move ecx, N1/ecx #() [55->60] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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/ecx, ecx, 2 add N2/ecx, N2/ecx, 1 push N2/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 90}, {basic-block #({tag 5:15}) 15 25}) pop esi bgt {tag 5:15}, ecx, 0 #({tag 6:25}) [25->90] (level:0) is #f with stack state #f #({basic-block #() 90 95}) move N1/eax, esp sub esp, esp, 12 push esi asl ecx, ecx, 2 move N0/edi, ecx add ecx, ecx, 1 st ecx, N1/eax, -4 st {constant "KLsimple_object_vectorGVKdW"}, N1/eax, -8 add N0/edi, N0/edi, 12 st N0/edi, N1/eax, -12 add N2/eax, N1/eax, -8 move eax, N2/eax move edi, {constant "KPfalseVKi"} #() [90->95] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 5:15}) [15->25] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 90}) st eax, esp, -4 sub esp, esp, 4 #() [160->165] (level:0) is #f with stack state #f #() bra {tag 6:25} +++ 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 110}, {basic-block #({tag 1:220}) 220 250}) blo {tag 1:220}, ecx, 1 #() [10->110] (level:0) is #f with stack state #f #({basic-block #() 110 160}, {basic-block #({tag 4:215}) 215 215}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 st esi, esp, 0 add N0/edx, N2/edx, 4 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -3 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move edi, {constant "KPfalseVKi"} ld G5/edx, ebx, 8 ld G5/edx, G5/edx, 8 ld-index-scaled esi, G5/edx, 0, 8 beq {tag 4:215}, esi, {constant "KLobjectGVKd"} #() [110->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}, {basic-block #({tag 6:165}) 165 185}) move G4/ecx, eax preserve-registers-entry push G5/edx push G4/ecx push esi push eax push ebx push edi move G7/edi, esi bne {tag 6:165}, G7/edi, {constant "KLobjectGVKd"} #() [160->165] (level:0) is #f with stack state #f #({basic-block #({tag 5:185}) 185 190}) move eax, {constant "KPtrueVKi"} #({tag 5:185}) [185->190] (level:0) is #f with stack state #f #({basic-block #() 190 215}, {basic-block #({tag 3:255}, {tag 2:255}) 255 280}) beq {tag 3:255}, eax, {constant "KPfalseVKi"} #() [190->215] (level:0) is #f with stack state #f #({basic-block #({tag 4:215}) 215 215}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 4:215}) [215->215] (level:0) is #f with stack state #f #({basic-block #({tag 4:215}) 215 220}) #({tag 4:215}) [215->220] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:220}) [220->250] (level:0) is #f with stack state #f #({basic-block #() 250 250}) preserve-registers-entry asl N8/ecx, ecx, 2 add N8/ecx, N8/ecx, 1 push N8/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [250->250] (level:0) is #f with stack state #f #({basic-block #() 250 255}) #() [250->255] (level:0) is #f with stack state #f #() rts #({tag 6:165}) [165->185] (level:0) is #f with stack state #f #({basic-block #({tag 5:185}) 185 190}) ld N6/ebx, G7/edi, 4 push G7/edi move eax, G4/ecx call N6/ebx, 1 #() [285->290] (level:0) is #f with stack state #f #() bra {tag 5:185} #({tag 3:255}, {tag 2:255}) [255->280] (level:0) is #f with stack state #f #({basic-block #() 280 280}) load-frame-offset #t, G10/edi, -3 load-frame-offset #t, G9/eax, -2 push G10/edi move eax, G9/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [280->280] (level:0) is #f with stack state #f #({basic-block #() 280 285}) #() [280->285] (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 79 with frame for no variables End scope at 109 Start scope at 110 no frame for no variables End scope at 116 +++ 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 120}, {basic-block #({tag 1:355}) 355 385}) blo {tag 1:355}, ecx, 2 #() [10->120] (level:0) is #f with stack state #f #({basic-block #() 120 170}, {basic-block #({tag 4:225}) 225 245}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 ld ecx, N2/edx, 4 st esi, esp, 0 st ecx, esp, 4 add N0/edx, N2/edx, 8 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -7 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move edi, {constant "KPfalseVKi"} ld G5/edx, ebx, 8 ld G5/edx, G5/edx, 8 ld-index-scaled esi, G5/edx, 0, 8 beq {tag 4:225}, esi, {constant "KLobjectGVKd"} #() [120->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}, {basic-block #({tag 6:175}) 175 195}) move G4/ecx, eax preserve-registers-entry push G5/edx push G4/ecx push esi push eax push ebx push edi move G7/edi, esi bne {tag 6:175}, G7/edi, {constant "KLobjectGVKd"} #() [170->175] (level:0) is #f with stack state #f #({basic-block #({tag 5:195}) 195 200}) move eax, {constant "KPtrueVKi"} #({tag 5:195}) [195->200] (level:0) is #f with stack state #f #({basic-block #() 200 225}, {basic-block #({tag 3:390}, {tag 2:390}) 390 415}) beq {tag 3:390}, eax, {constant "KPfalseVKi"} #() [200->225] (level:0) is #f with stack state #f #({basic-block #({tag 4:225}) 225 245}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 4:225}) [225->245] (level:0) is #f with stack state #f #({basic-block #() 245 295}, {basic-block #({tag 7:350}) 350 350}) ld G9/edx, ebx, 8 ld G9/edx, G9/edx, 8 ld-index-scaled esi, G9/edx, 1, 8 beq {tag 7:350}, esi, {constant "KLobjectGVKd"} #() [245->295] (level:0) is #f with stack state #f #({basic-block #() 295 300}, {basic-block #({tag 9:300}) 300 320}) load-stack-arg-n #t, G8/ecx, 0 preserve-registers-entry push G9/edx push G8/ecx push esi push eax push ebx push edi move G11/edi, esi bne {tag 9:300}, G11/edi, {constant "KLobjectGVKd"} #() [295->300] (level:0) is #f with stack state #f #({basic-block #({tag 8:320}) 320 325}) move eax, {constant "KPtrueVKi"} #({tag 8:320}) [320->325] (level:0) is #f with stack state #f #({basic-block #() 325 350}, {basic-block #({tag 3:390}, {tag 2:390}) 390 415}) beq {tag 3:390}, eax, {constant "KPfalseVKi"} #() [325->350] (level:0) is #f with stack state #f #({basic-block #({tag 7:350}) 350 350}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 7:350}) [350->350] (level:0) is #f with stack state #f #({basic-block #({tag 7:350}) 350 355}) #({tag 7:350}) [350->355] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:355}) [355->385] (level:0) is #f with stack state #f #({basic-block #() 385 385}) preserve-registers-entry asl N12/ecx, ecx, 2 add N12/ecx, N12/ecx, 1 push N12/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [385->385] (level:0) is #f with stack state #f #({basic-block #() 385 390}) #() [385->390] (level:0) is #f with stack state #f #() rts #({tag 6:175}) [175->195] (level:0) is #f with stack state #f #({basic-block #({tag 5:195}) 195 200}) ld N6/ebx, G7/edi, 4 push G7/edi move eax, G4/ecx call N6/ebx, 1 #() [420->425] (level:0) is #f with stack state #f #() bra {tag 5:195} #({tag 3:390}, {tag 2:390}) [390->415] (level:0) is #f with stack state #f #({basic-block #() 415 415}) load-frame-offset #t, G14/edi, -3 load-frame-offset #t, G13/eax, -2 push G14/edi move eax, G13/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [415->415] (level:0) is #f with stack state #f #({basic-block #() 415 420}) #() [415->420] (level:0) is #f with stack state #f #() rts #({tag 9:300}) [300->320] (level:0) is #f with stack state #f #({basic-block #({tag 8:320}) 320 325}) ld N10/ebx, G11/edi, 4 push G11/edi move eax, G8/ecx call N10/ebx, 1 #() [425->430] (level:0) is #f with stack state #f #() bra {tag 8:320} +++ ending code for rest_xep_2 +++ +++ Live variable scopes for rest_xep_2 +++ Start scope at 90 with frame for no variables End scope at 120 Start scope at 121 no frame for no variables End scope at 145 Start scope at 146 with frame for no variables End scope at 176 Start scope at 177 no frame for no variables End scope at 183 +++ 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 130}, {basic-block #({tag 1:490}) 490 520}) blo {tag 1:490}, ecx, 3 #() [10->130] (level:0) is #f with stack state #f #({basic-block #() 130 180}, {basic-block #({tag 4:235}) 235 255}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 ld ecx, N2/edx, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edx, 8 st esi, esp, 8 add N0/edx, N2/edx, 12 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -11 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move edi, {constant "KPfalseVKi"} ld G5/edx, ebx, 8 ld G5/edx, G5/edx, 8 ld-index-scaled esi, G5/edx, 0, 8 beq {tag 4:235}, esi, {constant "KLobjectGVKd"} #() [130->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}, {basic-block #({tag 6:185}) 185 205}) move G4/ecx, eax preserve-registers-entry push G5/edx push G4/ecx push esi push eax push ebx push edi move G7/edi, esi bne {tag 6:185}, G7/edi, {constant "KLobjectGVKd"} #() [180->185] (level:0) is #f with stack state #f #({basic-block #({tag 5:205}) 205 210}) move eax, {constant "KPtrueVKi"} #({tag 5:205}) [205->210] (level:0) is #f with stack state #f #({basic-block #() 210 235}, {basic-block #({tag 3:525}, {tag 2:525}) 525 550}) beq {tag 3:525}, eax, {constant "KPfalseVKi"} #() [210->235] (level:0) is #f with stack state #f #({basic-block #({tag 4:235}) 235 255}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 4:235}) [235->255] (level:0) is #f with stack state #f #({basic-block #() 255 305}, {basic-block #({tag 7:360}) 360 380}) ld G9/edx, ebx, 8 ld G9/edx, G9/edx, 8 ld-index-scaled esi, G9/edx, 1, 8 beq {tag 7:360}, esi, {constant "KLobjectGVKd"} #() [255->305] (level:0) is #f with stack state #f #({basic-block #() 305 310}, {basic-block #({tag 9:310}) 310 330}) load-stack-arg-n #t, G8/ecx, 0 preserve-registers-entry push G9/edx push G8/ecx push esi push eax push ebx push edi move G11/edi, esi bne {tag 9:310}, G11/edi, {constant "KLobjectGVKd"} #() [305->310] (level:0) is #f with stack state #f #({basic-block #({tag 8:330}) 330 335}) move eax, {constant "KPtrueVKi"} #({tag 8:330}) [330->335] (level:0) is #f with stack state #f #({basic-block #() 335 360}, {basic-block #({tag 3:525}, {tag 2:525}) 525 550}) beq {tag 3:525}, eax, {constant "KPfalseVKi"} #() [335->360] (level:0) is #f with stack state #f #({basic-block #({tag 7:360}) 360 380}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 7:360}) [360->380] (level:0) is #f with stack state #f #({basic-block #() 380 430}, {basic-block #({tag 10:485}) 485 485}) ld G13/edx, ebx, 8 ld G13/edx, G13/edx, 8 ld-index-scaled esi, G13/edx, 2, 8 beq {tag 10:485}, esi, {constant "KLobjectGVKd"} #() [380->430] (level:0) is #f with stack state #f #({basic-block #() 430 435}, {basic-block #({tag 12:435}) 435 455}) load-stack-arg-n #t, G12/ecx, 1 preserve-registers-entry push G13/edx push G12/ecx push esi push eax push ebx push edi move G15/edi, esi bne {tag 12:435}, G15/edi, {constant "KLobjectGVKd"} #() [430->435] (level:0) is #f with stack state #f #({basic-block #({tag 11:455}) 455 460}) move eax, {constant "KPtrueVKi"} #({tag 11:455}) [455->460] (level:0) is #f with stack state #f #({basic-block #() 460 485}, {basic-block #({tag 3:525}, {tag 2:525}) 525 550}) beq {tag 3:525}, eax, {constant "KPfalseVKi"} #() [460->485] (level:0) is #f with stack state #f #({basic-block #({tag 10:485}) 485 485}) pop edi pop ebx pop eax rem "eliminated" preserve-registers-exit #({tag 10:485}) [485->485] (level:0) is #f with stack state #f #({basic-block #({tag 10:485}) 485 490}) #({tag 10:485}) [485->490] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:490}) [490->520] (level:0) is #f with stack state #f #({basic-block #() 520 520}) preserve-registers-entry asl N16/ecx, ecx, 2 add N16/ecx, N16/ecx, 1 push N16/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [520->520] (level:0) is #f with stack state #f #({basic-block #() 520 525}) #() [520->525] (level:0) is #f with stack state #f #() rts #({tag 6:185}) [185->205] (level:0) is #f with stack state #f #({basic-block #({tag 5:205}) 205 210}) ld N6/ebx, G7/edi, 4 push G7/edi move eax, G4/ecx call N6/ebx, 1 #() [555->560] (level:0) is #f with stack state #f #() bra {tag 5:205} #({tag 3:525}, {tag 2:525}) [525->550] (level:0) is #f with stack state #f #({basic-block #() 550 550}) load-frame-offset #t, G18/edi, -3 load-frame-offset #t, G17/eax, -2 push G18/edi move eax, G17/eax call {constant "Ktype_check_errorVKiI"}, 1 #() [550->550] (level:0) is #f with stack state #f #({basic-block #() 550 555}) #() [550->555] (level:0) is #f with stack state #f #() rts #({tag 9:310}) [310->330] (level:0) is #f with stack state #f #({basic-block #({tag 8:330}) 330 335}) ld N10/ebx, G11/edi, 4 push G11/edi move eax, G8/ecx call N10/ebx, 1 #() [560->565] (level:0) is #f with stack state #f #() bra {tag 8:330} #({tag 12:435}) [435->455] (level:0) is #f with stack state #f #({basic-block #({tag 11:455}) 455 460}) ld N14/ebx, G15/edi, 4 push G15/edi move eax, G12/ecx call N14/ebx, 1 #() [565->570] (level:0) is #f with stack state #f #() bra {tag 11:455} +++ ending code for rest_xep_3 +++ +++ Live variable scopes for rest_xep_3 +++ Start scope at 97 with frame for no variables End scope at 135 Start scope at 136 no frame for no variables End scope at 160 Start scope at 161 with frame for no variables End scope at 191 Start scope at 192 no frame for no variables End scope at 216 Start scope at 217 with frame for no variables End scope at 247 Start scope at 248 no frame for no variables End scope at 254 +++ 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 130}, {basic-block #({tag 1:140}) 140 170}) blo {tag 1:140}, ecx, 4 #() [10->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 ld ecx, N2/edx, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edx, 8 ld ecx, N2/edx, 12 st esi, esp, 8 st ecx, esp, 12 add N0/edx, N2/edx, 16 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -15 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move edi, {constant "KPfalseVKi"} move ecx, 16 move ecx, ecx #() [130->135] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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 N4/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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_4 +++ +++ 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 140}, {basic-block #({tag 1:150}) 150 180}) blo {tag 1:150}, ecx, 5 #() [10->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) sub esp, esp, 16 add N2/edi, esp, 16 move N1/edx, ecx ld esi, N2/edi, 0 ld ecx, N2/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edi, 8 ld ecx, N2/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N2/edi, 16 st esi, esp, 16 add N0/edi, N2/edi, 20 asl N1/edx, N1/edx, 2 move ecx, N1/edx add N1/edx, N1/edx, -19 st N1/edx, N0/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8 add ecx, ecx, 12 st ecx, N0/edi, -12 add N3/edx, N0/edi, -8 st N3/edx, N0/edi, -16 move edi, {constant "KPfalseVKi"} move ecx, 20 move ecx, ecx #() [140->145] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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 N4/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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_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 150}, {basic-block #({tag 1:160}) 160 190}) blo {tag 1:160}, ecx, 6 #() [10->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) sub esp, esp, 16 add N2/edi, esp, 16 move N1/edx, ecx ld esi, N2/edi, 0 ld ecx, N2/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edi, 8 ld ecx, N2/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N2/edi, 16 ld ecx, N2/edi, 20 st esi, esp, 16 st ecx, esp, 20 add N0/edi, N2/edi, 24 asl N1/edx, N1/edx, 2 move ecx, N1/edx add N1/edx, N1/edx, -23 st N1/edx, N0/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8 add ecx, ecx, 12 st ecx, N0/edi, -12 add N3/edx, N0/edi, -8 st N3/edx, N0/edi, -16 move edi, {constant "KPfalseVKi"} move ecx, 24 move ecx, ecx #() [150->155] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:160}) [160->190] (level:0) is #f with stack state #f #({basic-block #() 190 190}) preserve-registers-entry asl N4/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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 +++ 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 160}, {basic-block #({tag 1:170}) 170 200}) blo {tag 1:170}, ecx, 7 #() [10->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub esp, esp, 16 add N2/edi, esp, 16 move N1/edx, ecx ld esi, N2/edi, 0 ld ecx, N2/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edi, 8 ld ecx, N2/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N2/edi, 16 ld ecx, N2/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N2/edi, 24 st esi, esp, 24 add N0/edi, N2/edi, 28 asl N1/edx, N1/edx, 2 move ecx, N1/edx add N1/edx, N1/edx, -27 st N1/edx, N0/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8 add ecx, ecx, 12 st ecx, N0/edi, -12 add N3/edx, N0/edi, -8 st N3/edx, N0/edi, -16 move edi, {constant "KPfalseVKi"} move ecx, 28 move ecx, ecx #() [160->165] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:170}) [170->200] (level:0) is #f with stack state #f #({basic-block #() 200 200}) preserve-registers-entry asl N4/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [200->200] (level:0) is #f with stack state #f #({basic-block #() 200 205}) #() [200->205] (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 170}, {basic-block #({tag 1:180}) 180 210}) blo {tag 1:180}, ecx, 8 #() [10->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}) sub esp, esp, 16 add N2/edi, esp, 16 move N1/edx, ecx ld esi, N2/edi, 0 ld ecx, N2/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edi, 8 ld ecx, N2/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N2/edi, 16 ld ecx, N2/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N2/edi, 24 ld ecx, N2/edi, 28 st esi, esp, 24 st ecx, esp, 28 add N0/edi, N2/edi, 32 asl N1/edx, N1/edx, 2 move ecx, N1/edx add N1/edx, N1/edx, -31 st N1/edx, N0/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8 add ecx, ecx, 12 st ecx, N0/edi, -12 add N3/edx, N0/edi, -8 st N3/edx, N0/edi, -16 move edi, {constant "KPfalseVKi"} move ecx, 32 move ecx, ecx #() [170->175] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"arg-count"], 0, #f, #f #({tag 1:180}) [180->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) preserve-registers-entry asl N4/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (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 180}, {basic-block #({tag 1:190}) 190 220}) blo {tag 1:190}, ecx, 9 #() [10->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) sub esp, esp, 16 add N2/edi, esp, 16 move N1/edx, ecx ld esi, N2/edi, 0 ld ecx, N2/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edi, 8 ld ecx, N2/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N2/edi, 16 ld ecx, N2/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N2/edi, 24 ld ecx, N2/edi, 28 st esi, esp, 24 st ecx, esp, 28 ld esi, N2/edi, 32 st esi, esp, 32 add N0/edi, N2/edi, 36 asl N1/edx, N1/edx, 2 move ecx, N1/edx add N1/edx, N1/edx, -35 st N1/edx, N0/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8 add ecx, ecx, 12 st ecx, N0/edi, -12 add N3/edx, N0/edi, -8 st N3/edx, N0/edi, -16 move edi, {constant "KPfalseVKi"} move ecx, 36 move ecx, ecx #() [180->185] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"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 N4/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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_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 185}, {basic-block #({tag 1:195}) 195 225}) ld N0/edi, ebx, 8 ld N0/edi, N0/edi, 4 asr N0/edi, N0/edi, 2 and N0/edi, N0/edi, 255 blo {tag 1:195}, ecx, N0/edi #() [30->185] (level:0) is #f with stack state #f #({basic-block #() 185 190}) ld N3/edi, ebx, 8 ld N3/edi, N3/edi, 4 asr N3/edi, N3/edi, 2 and N3/edi, N3/edi, 255 move esi, esp sub esp, esp, 16 move N2/edx, ecx move ecx, N3/edi move N4/edi, esp move edi, N4/edi move esi, esi copy-words-down-w edi, esi, ecx move N1/edi, esi asl N2/edx, N2/edx, 2 move ecx, N2/edx ld esi, ebx, 8 ld esi, esi, 4 and esi, esi, 1020 sub N2/edx, N2/edx, esi add N2/edx, N2/edx, 1 st N2/edx, N1/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N1/edi, -8 add ecx, ecx, 12 st ecx, N1/edi, -12 add N5/edx, N1/edi, -8 st N5/edx, N1/edi, -16 move edi, {constant "KPfalseVKi"} ld N6/ecx, ebx, 8 ld N6/ecx, N6/ecx, 4 and N6/ecx, N6/ecx, 1020 move ecx, N6/ecx #() [185->190] (level:0) is #f with stack state #f #() jmp {constant "primitive_check_specializers"}, #[1, #"mlist", #"function", #"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 N7/ecx, ecx, 2 add N7/ecx, N7/ecx, 1 push N7/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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_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 #({tag 6:40}) 40 160}, {basic-block #({tag 5:30}) 30 40}) ld N2/edx, ebx, 20 ld N0/edx, N2/edx, 4 asr N0/edx, N0/edx, 3 pop esi bgt {tag 5:30}, ecx, 0 #({tag 6:40}) [40->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) add N5/edx, N0/edx, 3 asl N5/edx, N5/edx, 2 move N4/edi, esp sub esp, esp, N5/edx push esi asl ecx, ecx, 2 move N3/eax, ecx add ecx, ecx, 1 st ecx, N4/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N4/edi, -8 ld N7/edx, ebx, 20 ld N6/edx, N7/edx, 4 asr N6/edx, N6/edx, 3 add N8/edx, N6/edx, 3 asl N8/edx, N8/edx, 2 add N3/eax, N3/eax, N8/edx st N3/eax, N4/edi, -12 add N9/edi, N4/edi, -8 move eax, N9/edi sub N1/ecx, N9/edi, 8 move ecx, N1/ecx move esi, N9/edi move edi, {constant "KPfalseVKi"} move ebx, ebx #() [160->165] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 5:30}) [30->40] (level:0) is #f with stack state #f #({basic-block #({tag 6:40}) 40 160}) st eax, esp, -4 sub esp, esp, 4 #() [240->245] (level:0) is #f with stack state #f #() bra {tag 6:40} +++ 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 170}, {basic-block #({tag 1:310}) 310 340}) blo {tag 1:310}, ecx, 1 #() [10->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}) ld N2/edi, ebx, 20 ld N0/edi, N2/edi, 4 asr N0/edi, N0/edi, 3 add N6/edi, N0/edi, 4 asl N6/edi, N6/edi, 2 sub esp, esp, N6/edi add N5/edx, esp, N6/edi move N4/edi, ecx ld esi, N5/edx, 0 st esi, esp, 0 add N3/edx, N5/edx, 4 asl N4/edi, N4/edi, 2 move ecx, N4/edi add N4/edi, N4/edi, -3 st N4/edi, N3/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8 ld N8/edi, ebx, 20 ld N7/edi, N8/edi, 4 asr N7/edi, N7/edi, 3 add N9/edi, N7/edi, 4 asl N9/edi, N9/edi, 2 add ecx, ecx, N9/edi sub ecx, ecx, 4 st ecx, N3/edx, -12 sub esi, N3/edx, N9/edi add N10/edx, N3/edx, -8 st N10/edx, esi, 0 sub N1/ecx, N10/edx, 8 move ecx, N1/ecx move esi, N10/edx move edi, {constant "KPfalseVKi"} move ebx, ebx #() [170->175] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:310}) [310->340] (level:0) is #f with stack state #f #({basic-block #() 340 340}) preserve-registers-entry asl N15/ecx, ecx, 2 add N15/ecx, N15/ecx, 1 push N15/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [340->340] (level:0) is #f with stack state #f #({basic-block #() 340 345}) #() [340->345] (level:0) is #f with stack state #f #() rts +++ 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 180}, {basic-block #({tag 1:445}) 445 475}) blo {tag 1:445}, ecx, 2 #() [10->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N2/edx, ebx, 20 ld N0/edx, N2/edx, 4 asr N0/edx, N0/edx, 3 add N6/edx, N0/edx, 4 asl N6/edx, N6/edx, 2 sub esp, esp, N6/edx add N5/edx, esp, N6/edx move N4/edi, ecx ld esi, N5/edx, 0 ld ecx, N5/edx, 4 st esi, esp, 0 st ecx, esp, 4 add N3/edx, N5/edx, 8 asl N4/edi, N4/edi, 2 move ecx, N4/edi add N4/edi, N4/edi, -7 st N4/edi, N3/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8 ld N8/edi, ebx, 20 ld N7/edi, N8/edi, 4 asr N7/edi, N7/edi, 3 add N9/edi, N7/edi, 4 asl N9/edi, N9/edi, 2 add ecx, ecx, N9/edi sub ecx, ecx, 4 st ecx, N3/edx, -12 sub esi, N3/edx, N9/edi add N10/edx, N3/edx, -8 st N10/edx, esi, 0 sub N1/ecx, N10/edx, 8 move ecx, N1/ecx move esi, N10/edx move edi, {constant "KPfalseVKi"} move ebx, ebx #() [180->185] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:445}) [445->475] (level:0) is #f with stack state #f #({basic-block #() 475 475}) preserve-registers-entry asl N19/ecx, ecx, 2 add N19/ecx, N19/ecx, 1 push N19/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [475->475] (level:0) is #f with stack state #f #({basic-block #() 475 480}) #() [475->480] (level:0) is #f with stack state #f #() rts +++ 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 190}, {basic-block #({tag 1:580}) 580 610}) blo {tag 1:580}, ecx, 3 #() [10->190] (level:0) is #f with stack state #f #({basic-block #() 190 195}) ld N2/edx, ebx, 20 ld N0/edx, N2/edx, 4 asr N0/edx, N0/edx, 3 add N6/edx, N0/edx, 4 asl N6/edx, N6/edx, 2 sub esp, esp, N6/edx add N5/edx, esp, N6/edx move N4/edi, ecx ld esi, N5/edx, 0 ld ecx, N5/edx, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edx, 8 st esi, esp, 8 add N3/edx, N5/edx, 12 asl N4/edi, N4/edi, 2 move ecx, N4/edi add N4/edi, N4/edi, -11 st N4/edi, N3/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8 ld N8/edi, ebx, 20 ld N7/edi, N8/edi, 4 asr N7/edi, N7/edi, 3 add N9/edi, N7/edi, 4 asl N9/edi, N9/edi, 2 add ecx, ecx, N9/edi sub ecx, ecx, 4 st ecx, N3/edx, -12 sub esi, N3/edx, N9/edi add N10/edx, N3/edx, -8 st N10/edx, esi, 0 sub N1/ecx, N10/edx, 8 move ecx, N1/ecx move esi, N10/edx move edi, {constant "KPfalseVKi"} move ebx, ebx #() [190->195] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:580}) [580->610] (level:0) is #f with stack state #f #({basic-block #() 610 610}) preserve-registers-entry asl N23/ecx, ecx, 2 add N23/ecx, N23/ecx, 1 push N23/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [610->610] (level:0) is #f with stack state #f #({basic-block #() 610 615}) #() [610->615] (level:0) is #f with stack state #f #() rts +++ 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 200}, {basic-block #({tag 1:230}) 230 260}) blo {tag 1:230}, ecx, 4 #() [10->200] (level:0) is #f with stack state #f #({basic-block #() 200 205}) ld N2/edx, ebx, 20 ld N0/edx, N2/edx, 4 asr N0/edx, N0/edx, 3 add N6/edx, N0/edx, 4 asl N6/edx, N6/edx, 2 sub esp, esp, N6/edx add N5/edx, esp, N6/edx move N4/edi, ecx ld esi, N5/edx, 0 ld ecx, N5/edx, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edx, 8 ld ecx, N5/edx, 12 st esi, esp, 8 st ecx, esp, 12 add N3/edx, N5/edx, 16 asl N4/edi, N4/edi, 2 move ecx, N4/edi add N4/edi, N4/edi, -15 st N4/edi, N3/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edx, -8 ld N8/edi, ebx, 20 ld N7/edi, N8/edi, 4 asr N7/edi, N7/edi, 3 add N9/edi, N7/edi, 4 asl N9/edi, N9/edi, 2 add ecx, ecx, N9/edi sub ecx, ecx, 4 st ecx, N3/edx, -12 sub esi, N3/edx, N9/edi add N10/edx, N3/edx, -8 st N10/edx, esi, 0 sub N1/ecx, N10/edx, 8 move ecx, N1/ecx move esi, N10/edx move edi, {constant "KPfalseVKi"} move ebx, ebx #() [200->205] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:230}) [230->260] (level:0) is #f with stack state #f #({basic-block #() 260 260}) preserve-registers-entry asl N11/ecx, ecx, 2 add N11/ecx, N11/ecx, 1 push N11/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [260->260] (level:0) is #f with stack state #f #({basic-block #() 260 265}) #() [260->265] (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 210}, {basic-block #({tag 1:240}) 240 270}) blo {tag 1:240}, ecx, 5 #() [10->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) ld N2/edi, ebx, 20 ld N0/edi, N2/edi, 4 asr N0/edi, N0/edi, 3 add N6/edi, N0/edi, 4 asl N6/edi, N6/edi, 2 sub esp, esp, N6/edi add N5/edi, esp, N6/edi move N4/edx, ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 st esi, esp, 16 add N3/edi, N5/edi, 20 asl N4/edx, N4/edx, 2 move ecx, N4/edx add N4/edx, N4/edx, -19 st N4/edx, N3/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8 ld N8/edx, ebx, 20 ld N7/edx, N8/edx, 4 asr N7/edx, N7/edx, 3 add N9/edx, N7/edx, 4 asl N9/edx, N9/edx, 2 add ecx, ecx, N9/edx sub ecx, ecx, 4 st ecx, N3/edi, -12 sub esi, N3/edi, N9/edx add N10/edi, N3/edi, -8 st N10/edi, esi, 0 sub N1/ecx, N10/edi, 8 move ecx, N1/ecx move esi, N10/edi move edi, {constant "KPfalseVKi"} move ebx, ebx #() [210->215] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:240}) [240->270] (level:0) is #f with stack state #f #({basic-block #() 270 270}) preserve-registers-entry asl N11/ecx, ecx, 2 add N11/ecx, N11/ecx, 1 push N11/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [270->270] (level:0) is #f with stack state #f #({basic-block #() 270 275}) #() [270->275] (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 220}, {basic-block #({tag 1:250}) 250 280}) blo {tag 1:250}, ecx, 6 #() [10->220] (level:0) is #f with stack state #f #({basic-block #() 220 225}) ld N2/edi, ebx, 20 ld N0/edi, N2/edi, 4 asr N0/edi, N0/edi, 3 add N6/edi, N0/edi, 4 asl N6/edi, N6/edi, 2 sub esp, esp, N6/edi add N5/edi, esp, N6/edi move N4/edx, ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 add N3/edi, N5/edi, 24 asl N4/edx, N4/edx, 2 move ecx, N4/edx add N4/edx, N4/edx, -23 st N4/edx, N3/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8 ld N8/edx, ebx, 20 ld N7/edx, N8/edx, 4 asr N7/edx, N7/edx, 3 add N9/edx, N7/edx, 4 asl N9/edx, N9/edx, 2 add ecx, ecx, N9/edx sub ecx, ecx, 4 st ecx, N3/edi, -12 sub esi, N3/edi, N9/edx add N10/edi, N3/edi, -8 st N10/edi, esi, 0 sub N1/ecx, N10/edi, 8 move ecx, N1/ecx move esi, N10/edi move edi, {constant "KPfalseVKi"} move ebx, ebx #() [220->225] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:250}) [250->280] (level:0) is #f with stack state #f #({basic-block #() 280 280}) preserve-registers-entry asl N11/ecx, ecx, 2 add N11/ecx, N11/ecx, 1 push N11/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [280->280] (level:0) is #f with stack state #f #({basic-block #() 280 285}) #() [280->285] (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 230}, {basic-block #({tag 1:260}) 260 290}) blo {tag 1:260}, ecx, 7 #() [10->230] (level:0) is #f with stack state #f #({basic-block #() 230 235}) ld N2/edi, ebx, 20 ld N0/edi, N2/edi, 4 asr N0/edi, N0/edi, 3 add N6/edi, N0/edi, 4 asl N6/edi, N6/edi, 2 sub esp, esp, N6/edi add N5/edi, esp, N6/edi move N4/edx, ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N5/edi, 24 st esi, esp, 24 add N3/edi, N5/edi, 28 asl N4/edx, N4/edx, 2 move ecx, N4/edx add N4/edx, N4/edx, -27 st N4/edx, N3/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8 ld N8/edx, ebx, 20 ld N7/edx, N8/edx, 4 asr N7/edx, N7/edx, 3 add N9/edx, N7/edx, 4 asl N9/edx, N9/edx, 2 add ecx, ecx, N9/edx sub ecx, ecx, 4 st ecx, N3/edi, -12 sub esi, N3/edi, N9/edx add N10/edi, N3/edi, -8 st N10/edi, esi, 0 sub N1/ecx, N10/edi, 8 move ecx, N1/ecx move esi, N10/edi move edi, {constant "KPfalseVKi"} move ebx, ebx #() [230->235] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:260}) [260->290] (level:0) is #f with stack state #f #({basic-block #() 290 290}) preserve-registers-entry asl N11/ecx, ecx, 2 add N11/ecx, N11/ecx, 1 push N11/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [290->290] (level:0) is #f with stack state #f #({basic-block #() 290 295}) #() [290->295] (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 240}, {basic-block #({tag 1:270}) 270 300}) blo {tag 1:270}, ecx, 8 #() [10->240] (level:0) is #f with stack state #f #({basic-block #() 240 245}) ld N2/edi, ebx, 20 ld N0/edi, N2/edi, 4 asr N0/edi, N0/edi, 3 add N6/edi, N0/edi, 4 asl N6/edi, N6/edi, 2 sub esp, esp, N6/edi add N5/edi, esp, N6/edi move N4/edx, ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N5/edi, 24 ld ecx, N5/edi, 28 st esi, esp, 24 st ecx, esp, 28 add N3/edi, N5/edi, 32 asl N4/edx, N4/edx, 2 move ecx, N4/edx add N4/edx, N4/edx, -31 st N4/edx, N3/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8 ld N8/edx, ebx, 20 ld N7/edx, N8/edx, 4 asr N7/edx, N7/edx, 3 add N9/edx, N7/edx, 4 asl N9/edx, N9/edx, 2 add ecx, ecx, N9/edx sub ecx, ecx, 4 st ecx, N3/edi, -12 sub esi, N3/edi, N9/edx add N10/edi, N3/edi, -8 st N10/edi, esi, 0 sub N1/ecx, N10/edi, 8 move ecx, N1/ecx move esi, N10/edi move edi, {constant "KPfalseVKi"} move ebx, ebx #() [240->245] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:270}) [270->300] (level:0) is #f with stack state #f #({basic-block #() 300 300}) preserve-registers-entry asl N11/ecx, ecx, 2 add N11/ecx, N11/ecx, 1 push N11/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [300->300] (level:0) is #f with stack state #f #({basic-block #() 300 305}) #() [300->305] (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 250}, {basic-block #({tag 1:280}) 280 310}) blo {tag 1:280}, ecx, 9 #() [10->250] (level:0) is #f with stack state #f #({basic-block #() 250 255}) ld N2/edi, ebx, 20 ld N0/edi, N2/edi, 4 asr N0/edi, N0/edi, 3 add N6/edi, N0/edi, 4 asl N6/edi, N6/edi, 2 sub esp, esp, N6/edi add N5/edi, esp, N6/edi move N4/edx, ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N5/edi, 24 ld ecx, N5/edi, 28 st esi, esp, 24 st ecx, esp, 28 ld esi, N5/edi, 32 st esi, esp, 32 add N3/edi, N5/edi, 36 asl N4/edx, N4/edx, 2 move ecx, N4/edx add N4/edx, N4/edx, -35 st N4/edx, N3/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N3/edi, -8 ld N8/edx, ebx, 20 ld N7/edx, N8/edx, 4 asr N7/edx, N7/edx, 3 add N9/edx, N7/edx, 4 asl N9/edx, N9/edx, 2 add ecx, ecx, N9/edx sub ecx, ecx, 4 st ecx, N3/edi, -12 sub esi, N3/edi, N9/edx add N10/edi, N3/edi, -8 st N10/edi, esi, 0 sub N1/ecx, N10/edi, 8 move ecx, N1/ecx move esi, N10/edi move edi, {constant "KPfalseVKi"} move ebx, ebx #() [250->255] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:280}) [280->310] (level:0) is #f with stack state #f #({basic-block #() 310 310}) preserve-registers-entry asl N11/ecx, ecx, 2 add N11/ecx, N11/ecx, 1 push N11/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [310->310] (level:0) is #f with stack state #f #({basic-block #() 310 315}) #() [310->315] (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 245}, {basic-block #({tag 1:285}) 285 315}) ld N0/edi, ebx, 8 ld N0/edi, N0/edi, 4 asr N0/edi, N0/edi, 2 and N0/edi, N0/edi, 255 blo {tag 1:285}, ecx, N0/edi #() [30->245] (level:0) is #f with stack state #f #({basic-block #() 245 250}) ld N3/edx, ebx, 20 ld N1/edx, N3/edx, 4 asr N1/edx, N1/edx, 3 ld N6/edi, ebx, 8 ld N6/edi, N6/edi, 4 asr N6/edi, N6/edi, 2 and N6/edi, N6/edi, 255 add N8/edx, N1/edx, 4 asl N8/edx, N8/edx, 2 move esi, esp sub esp, esp, N8/edx move N5/edx, ecx move ecx, N6/edi move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N4/edi, esi asl N5/edx, N5/edx, 2 move ecx, N5/edx ld esi, ebx, 8 ld esi, esi, 4 and esi, esi, 1020 sub N5/edx, N5/edx, esi add N5/edx, N5/edx, 1 st N5/edx, N4/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N4/edi, -8 ld N10/edx, ebx, 20 ld N9/edx, N10/edx, 4 asr N9/edx, N9/edx, 3 add N11/edx, N9/edx, 4 asl N11/edx, N11/edx, 2 add ecx, ecx, N11/edx sub ecx, ecx, 4 st ecx, N4/edi, -12 sub esi, N4/edi, N11/edx add N12/edi, N4/edi, -8 st N12/edi, esi, 0 sub N2/ecx, N12/edi, 8 move ecx, N2/ecx move esi, N12/edi move edi, {constant "KPfalseVKi"} move ebx, ebx #() [245->250] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys_checking_args_for_xep"}, #[1, #"mlist", #"arg-count"], 0, #f, #f #({tag 1:285}) [285->315] (level:0) is #f with stack state #f #({basic-block #() 315 315}) preserve-registers-entry asl N14/ecx, ecx, 2 add N14/ecx, N14/ecx, 1 push N14/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [315->315] (level:0) is #f with stack state #f #({basic-block #() 315 320}) #() [315->320] (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 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/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 4, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 st esi, esp, 0 add N1/edi, N5/edi, 4 sub N3/ecx, N1/edi, 4 move N2/edi, eax move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [100->105] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 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/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 8, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 add N1/edi, N5/edi, 8 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 4 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [110->115] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 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/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 12, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 st esi, esp, 8 add N1/edi, N5/edi, 12 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 8 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [120->125] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 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/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 16, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 add N1/edi, N5/edi, 16 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 12 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [130->135] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 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/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 20, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 st esi, esp, 16 add N1/edi, N5/edi, 20 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 16 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [140->145] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 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/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 24, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 add N1/edi, N5/edi, 24 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 20 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [150->155] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 160}) rem "This is a dummy first basic block." #() [5->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) move N0/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 28, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N5/edi, 24 st esi, esp, 24 add N1/edi, N5/edi, 28 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 24 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [160->165] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 170}) rem "This is a dummy first basic block." #() [5->170] (level:0) is #f with stack state #f #({basic-block #() 170 175}) move N0/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 32, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N5/edi, 24 ld ecx, N5/edi, 28 st esi, esp, 24 st ecx, esp, 28 add N1/edi, N5/edi, 32 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 28 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [170->175] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 180}) rem "This is a dummy first basic block." #() [5->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) move N0/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 36, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N5/edi, 24 ld ecx, N5/edi, 28 st esi, esp, 24 st ecx, esp, 28 ld esi, N5/edi, 32 st esi, esp, 32 add N1/edi, N5/edi, 36 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 32 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [180->185] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 190}) rem "This is a dummy first basic block." #() [5->190] (level:0) is #f with stack state #f #({basic-block #() 190 195}) move N0/edx, edi ld N4/ecx, ebx, 20 ld ecx, N4/ecx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 add2-mem esp, 40, 0, esi move N6/ecx, ecx asl N6/ecx, N6/ecx, 2 sub esp, esp, N6/ecx add N5/edi, esp, N6/ecx ld esi, N5/edi, 0 ld ecx, N5/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N5/edi, 8 ld ecx, N5/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N5/edi, 16 ld ecx, N5/edi, 20 st esi, esp, 16 st ecx, esp, 20 ld esi, N5/edi, 24 ld ecx, N5/edi, 28 st esi, esp, 24 st ecx, esp, 28 ld esi, N5/edi, 32 ld ecx, N5/edi, 36 st esi, esp, 32 st ecx, esp, 36 add N1/edi, N5/edi, 40 sub N3/ecx, N1/edi, 4 ld N2/edi, esp, 36 move ecx, N3/ecx move esi, N2/edi move edi, N0/edx move ebx, ebx #() [190->195] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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 155}) rem "This is a dummy first basic block." #() [5->155] (level:0) is #f with stack state #f #({basic-block #() 155 160}) push edi push ebx ld N3/edi, ebx, 8 ld N3/edi, N3/edi, 4 asr N3/edi, N3/edi, 2 and N3/edi, N3/edi, 255 add N3/edi, N3/edi, 3 ld N4/ebx, ebx, 20 ld ecx, N4/ebx, 4 asr ecx, ecx, 3 asl esi, ecx, 2 asl N5/ebx, N3/edi, 2 add2-mem esp, N5/ebx, 0, esi move N7/ecx, ecx asl N7/ecx, N7/ecx, 2 move esi, esp sub esp, esp, N7/ecx move ecx, N3/edi move N6/edi, esp move edi, N6/edi move esi, esi copy-words-down-w edi, esi, ecx move N0/ecx, esi sub N2/ecx, N0/ecx, 4 sub N8/ebx, N5/ebx, 4 ld N1/ebx, esp, N8/ebx pop ebx pop edi move ecx, N2/ecx move esi, N1/ebx #() [155->160] (level:0) is #f with stack state #f #() jmp {constant "primitive_process_keys"}, #[1, #"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}, ecx, 0 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/edi, ebx ld G0/ebx, G1/edi, 24 ld N2/edx, G0/ebx, 12 move edi, G1/edi move ebx, G0/ebx #() [35->40] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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/ecx, ecx, 2 add N3/ecx, N3/ecx, 1 push N3/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 1 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/edi, ebx ld G0/ebx, G1/edi, 24 ld N2/edx, G0/ebx, 12 move edi, G1/edi move ebx, G0/ebx #() [35->40] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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/ecx, ecx, 2 add N3/ecx, N3/ecx, 1 push N3/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 2 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/edi, ebx ld G0/ebx, G1/edi, 24 ld N2/edx, G0/ebx, 12 move edi, G1/edi move ebx, G0/ebx #() [35->40] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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/ecx, ecx, 2 add N3/ecx, N3/ecx, 1 push N3/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 3 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/edi, ebx ld G0/ebx, G1/edi, 24 ld N2/edx, G0/ebx, 12 move edi, G1/edi move ebx, G0/ebx #() [35->40] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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/ecx, ecx, 2 add N3/ecx, N3/ecx, 1 push N3/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 4 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/edi, ebx ld G0/ebx, G1/edi, 24 ld N2/edx, G0/ebx, 12 move edi, G1/edi move ebx, G0/ebx #() [35->40] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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/ecx, ecx, 2 add N3/ecx, N3/ecx, 1 push N3/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 5 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/edi, ebx ld G0/ebx, G1/edi, 24 ld N2/edx, G0/ebx, 12 move edi, G1/edi move ebx, G0/ebx #() [35->40] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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/ecx, ecx, 2 add N3/ecx, N3/ecx, 1 push N3/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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}, ecx, 6 #() [10->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) move G1/edi, ebx ld G0/ebx, G1/edi, 24 ld N2/edx, G0/ebx, 12 move edi, G1/edi move ebx, G0/ebx #() [35->40] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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/ecx, ecx, 2 add N3/ecx, N3/ecx, 1 push N3/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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/edi, ebx, 8 ld N0/edi, N0/edi, 4 asr N0/edi, N0/edi, 2 and N0/edi, N0/edi, 255 bne {tag 1:65}, ecx, N0/edi #() [30->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) move G2/edi, ebx ld G1/ebx, G2/edi, 24 ld N3/edx, G1/ebx, 12 move edi, G2/edi move ebx, G1/ebx #() [55->60] (level:0) is #f with stack state #f #() jmp N3/edx, #[1, #"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/ecx, ecx, 2 add N4/ecx, N4/ecx, 1 push N4/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 110}, {basic-block #({tag 5:15}) 15 25}) pop esi bgt {tag 5:15}, ecx, 0 #({tag 6:25}) [25->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) move N1/edi, esp sub esp, esp, 12 push esi asl ecx, ecx, 2 move N0/edx, ecx add ecx, ecx, 1 st ecx, N1/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N1/edi, -8 add N0/edx, N0/edx, 12 st N0/edx, N1/edi, -12 add N2/eax, N1/edi, -8 move eax, N2/eax move G4/edi, ebx ld G3/ebx, G4/edi, 24 ld N5/edx, G3/ebx, 12 move edi, G4/edi move ebx, G3/ebx #() [110->115] (level:0) is #f with stack state #f #() jmp N5/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 5:15}) [15->25] (level:0) is #f with stack state #f #({basic-block #({tag 6:25}) 25 110}) st eax, esp, -4 sub esp, esp, 4 #() [155->160] (level:0) is #f with stack state #f #() bra {tag 6:25} +++ 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 110}, {basic-block #({tag 1:120}) 120 150}) blo {tag 1:120}, ecx, 1 #() [10->110] (level:0) is #f with stack state #f #({basic-block #() 110 115}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 st esi, esp, 0 add N0/edx, N2/edx, 4 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -3 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move G5/edi, ebx ld G4/ebx, G5/edi, 24 ld N6/edx, G4/ebx, 12 move edi, G5/edi move ebx, G4/ebx #() [110->115] (level:0) is #f with stack state #f #() jmp N6/edx, #[1, #"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 N7/ecx, ecx, 2 add N7/ecx, N7/ecx, 1 push N7/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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_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 120}, {basic-block #({tag 1:130}) 130 160}) blo {tag 1:130}, ecx, 2 #() [10->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 ld ecx, N2/edx, 4 st esi, esp, 0 st ecx, esp, 4 add N0/edx, N2/edx, 8 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -7 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move G5/edi, ebx ld G4/ebx, G5/edi, 24 ld N6/edx, G4/ebx, 12 move edi, G5/edi move ebx, G4/ebx #() [120->125] (level:0) is #f with stack state #f #() jmp N6/edx, #[1, #"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 N7/ecx, ecx, 2 add N7/ecx, N7/ecx, 1 push N7/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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_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 130}, {basic-block #({tag 1:140}) 140 170}) blo {tag 1:140}, ecx, 3 #() [10->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 ld ecx, N2/edx, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edx, 8 st esi, esp, 8 add N0/edx, N2/edx, 12 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -11 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move G5/edi, ebx ld G4/ebx, G5/edi, 24 ld N6/edx, G4/ebx, 12 move edi, G5/edi move ebx, G4/ebx #() [130->135] (level:0) is #f with stack state #f #() jmp N6/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:140}) [140->170] (level:0) is #f with stack state #f #({basic-block #() 170 170}) preserve-registers-entry asl N7/ecx, ecx, 2 add N7/ecx, N7/ecx, 1 push N7/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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 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 140}, {basic-block #({tag 1:150}) 150 180}) blo {tag 1:150}, ecx, 4 #() [10->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) sub esp, esp, 16 add N2/edx, esp, 16 move N1/edi, ecx ld esi, N2/edx, 0 ld ecx, N2/edx, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edx, 8 ld ecx, N2/edx, 12 st esi, esp, 8 st ecx, esp, 12 add N0/edx, N2/edx, 16 asl N1/edi, N1/edi, 2 move ecx, N1/edi add N1/edi, N1/edi, -15 st N1/edi, N0/edx, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edx, -8 add ecx, ecx, 12 st ecx, N0/edx, -12 add N3/edi, N0/edx, -8 st N3/edi, N0/edx, -16 move G5/edi, ebx ld G4/ebx, G5/edi, 24 ld N6/edx, G4/ebx, 12 move edi, G5/edi move ebx, G4/ebx #() [140->145] (level:0) is #f with stack state #f #() jmp N6/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:150}) [150->180] (level:0) is #f with stack state #f #({basic-block #() 180 180}) preserve-registers-entry asl N7/ecx, ecx, 2 add N7/ecx, N7/ecx, 1 push N7/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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 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 150}, {basic-block #({tag 1:160}) 160 190}) blo {tag 1:160}, ecx, 5 #() [10->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) sub esp, esp, 16 add N2/edi, esp, 16 move N1/edx, ecx ld esi, N2/edi, 0 ld ecx, N2/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edi, 8 ld ecx, N2/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N2/edi, 16 st esi, esp, 16 add N0/edi, N2/edi, 20 asl N1/edx, N1/edx, 2 move ecx, N1/edx add N1/edx, N1/edx, -19 st N1/edx, N0/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8 add ecx, ecx, 12 st ecx, N0/edi, -12 add N3/edx, N0/edi, -8 st N3/edx, N0/edi, -16 move G5/edi, ebx ld G4/ebx, G5/edi, 24 ld N6/edx, G4/ebx, 12 move edi, G5/edi move ebx, G4/ebx #() [150->155] (level:0) is #f with stack state #f #() jmp N6/edx, #[1, #"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/ecx, ecx, 2 add N7/ecx, N7/ecx, 1 push N7/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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 +++ 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 160}, {basic-block #({tag 1:170}) 170 200}) blo {tag 1:170}, ecx, 6 #() [10->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub esp, esp, 16 add N2/edi, esp, 16 move N1/edx, ecx ld esi, N2/edi, 0 ld ecx, N2/edi, 4 st esi, esp, 0 st ecx, esp, 4 ld esi, N2/edi, 8 ld ecx, N2/edi, 12 st esi, esp, 8 st ecx, esp, 12 ld esi, N2/edi, 16 ld ecx, N2/edi, 20 st esi, esp, 16 st ecx, esp, 20 add N0/edi, N2/edi, 24 asl N1/edx, N1/edx, 2 move ecx, N1/edx add N1/edx, N1/edx, -23 st N1/edx, N0/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N0/edi, -8 add ecx, ecx, 12 st ecx, N0/edi, -12 add N3/edx, N0/edi, -8 st N3/edx, N0/edi, -16 move G5/edi, ebx ld G4/ebx, G5/edi, 24 ld N6/edx, G4/ebx, 12 move edi, G5/edi move ebx, G4/ebx #() [160->165] (level:0) is #f with stack state #f #() jmp N6/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:170}) [170->200] (level:0) is #f with stack state #f #({basic-block #() 200 200}) preserve-registers-entry asl N7/ecx, ecx, 2 add N7/ecx, N7/ecx, 1 push N7/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [200->200] (level:0) is #f with stack state #f #({basic-block #() 200 205}) #() [200->205] (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 185}, {basic-block #({tag 1:195}) 195 225}) ld N0/edi, ebx, 8 ld N0/edi, N0/edi, 4 asr N0/edi, N0/edi, 2 and N0/edi, N0/edi, 255 blo {tag 1:195}, ecx, N0/edi #() [30->185] (level:0) is #f with stack state #f #({basic-block #() 185 190}) ld N3/edi, ebx, 8 ld N3/edi, N3/edi, 4 asr N3/edi, N3/edi, 2 and N3/edi, N3/edi, 255 move esi, esp sub esp, esp, 16 move N2/edx, ecx move ecx, N3/edi move N4/edi, esp move edi, N4/edi move esi, esi copy-words-down-w edi, esi, ecx move N1/edi, esi asl N2/edx, N2/edx, 2 move ecx, N2/edx ld esi, ebx, 8 ld esi, esi, 4 and esi, esi, 1020 sub N2/edx, N2/edx, esi add N2/edx, N2/edx, 1 st N2/edx, N1/edi, -4 st {constant "KLsimple_object_vectorGVKdW"}, N1/edi, -8 add ecx, ecx, 12 st ecx, N1/edi, -12 add N5/edx, N1/edi, -8 st N5/edx, N1/edi, -16 move G7/edi, ebx ld G6/ebx, G7/edi, 24 ld N8/edx, G6/ebx, 12 move edi, G7/edi move ebx, G6/ebx #() [185->190] (level:0) is #f with stack state #f #() jmp N8/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:195}) [195->225] (level:0) is #f with stack state #f #({basic-block #() 225 225}) preserve-registers-entry asl N9/ecx, ecx, 2 add N9/ecx, N9/ecx, 1 push N9/ecx move eax, ebx call {constant "Kargument_count_errorVKiI"}, 1 #() [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 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 85}, {basic-block #({tag 1:90}) 90 100}) move N0/eax, eax ld N1/edx, N0/eax, 4 asr N1/edx, N1/edx, 2 ble {tag 1:90}, N1/edx, 1 #() [25->85] (level:0) is #f with stack state #f #({basic-block #() 85 90}) sub N1/edx, N1/edx, 1 asl N2/edi, N1/edx, 2 ld esi, esp, 0 sub esp, esp, N2/edi st esi, esp, 0 add N3/edi, esp, 4 add esi, N0/eax, 12 move edi, N3/edi move esi, esi copy-words-down-w edi, esi, N1/edx add ecx, N1/edx, 1 ld eax, N0/eax, 8 #() [85->90] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:90}) [90->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) move ecx, N1/edx ld eax, N0/eax, 8 #() [100->105] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f +++ 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 30}, {basic-block #({tag 1:185}) 185 210}) ld esi, esp, 4 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 1 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 1 push N5/edi move N9/ecx, ecx add N4/edi, esp, 4 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 1 ld esi, esp, 0 st esi, esp, 4 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 4 move ecx, 2 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f +++ 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 30}, {basic-block #({tag 1:185}) 185 210}) ld esi, esp, 8 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 2 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 2 push N5/edi move N9/ecx, ecx add N4/edi, esp, 8 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 2 ld esi, esp, 0 st esi, esp, 8 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 8 move ecx, 3 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f +++ 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 30}, {basic-block #({tag 1:185}) 185 210}) ld esi, esp, 12 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 3 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 3 push N5/edi move N9/ecx, ecx add N4/edi, esp, 12 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 3 ld esi, esp, 0 st esi, esp, 12 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 12 move ecx, 4 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f +++ 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:185}) 185 210}) ld esi, esp, 16 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 4 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 4 push N5/edi move N9/ecx, ecx add N4/edi, esp, 16 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 4 ld esi, esp, 0 st esi, esp, 16 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 16 move ecx, 5 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 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:185}) 185 210}) ld esi, esp, 20 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 5 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 5 push N5/edi move N9/ecx, ecx add N4/edi, esp, 20 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 5 ld esi, esp, 0 st esi, esp, 20 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 20 move ecx, 6 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 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:185}) 185 210}) ld esi, esp, 24 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 6 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 6 push N5/edi move N9/ecx, ecx add N4/edi, esp, 24 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 6 ld esi, esp, 0 st esi, esp, 24 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 24 move ecx, 7 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 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:185}) 185 210}) ld esi, esp, 28 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 7 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 7 push N5/edi move N9/ecx, ecx add N4/edi, esp, 28 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 7 ld esi, esp, 0 st esi, esp, 28 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 28 move ecx, 8 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 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:185}) 185 210}) ld esi, esp, 32 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 8 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 8 push N5/edi move N9/ecx, ecx add N4/edi, esp, 32 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 8 ld esi, esp, 0 st esi, esp, 32 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 32 move ecx, 9 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 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:185}) 185 210}) ld esi, esp, 36 ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 1:185}, N0/edi, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #() 30 160}, {basic-block #({tag 2:165}) 165 180}) beq {tag 2:165}, N0/edi, 1 #() [30->160] (level:0) is #f with stack state #f #({basic-block #() 160 165}) sub N0/edi, N0/edi, 1 move ecx, 9 move N8/edi, N0/edi asl N8/edi, N8/edi, 2 move esi, esp sub esp, esp, N8/edi move ecx, ecx move N7/edi, esp move edi, N7/edi move esi, esi copy-words-down-w edi, esi, ecx move N3/edi, esi ld esi, N3/edi, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 add N5/edi, ecx, 9 push N5/edi move N9/ecx, ecx add N4/edi, esp, 36 add N4/edi, N4/edi, 4 pop N6/edx move edi, N4/edi move esi, esi copy-words-down-w edi, esi, N9/ecx move ecx, N6/edx #() [160->165] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 1:185}) [185->210] (level:0) is #f with stack state #f #({basic-block #() 210 210}) move ecx, 9 ld esi, esp, 0 st esi, esp, 36 add esp, esp, 4 call-indirect ebx, 4, 1 #() [210->210] (level:0) is #f with stack state #f #({basic-block #() 210 215}) #() [210->215] (level:0) is #f with stack state #f #() rts #({tag 2:165}) [165->180] (level:0) is #f with stack state #f #({basic-block #() 180 185}) ld N1/edi, esi, 8 st N1/edi, esp, 36 move ecx, 10 #() [180->185] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 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 45}) bne {tag 1:15}, ecx, 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->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}, {basic-block #({tag 2:220}) 220 245}) sub N2/edx, ecx, 1 asl N3/edx, N2/edx, 2 ld esi, esp, N3/edx ld N0/edi, esi, 4 asr N0/edi, N0/edi, 2 beq {tag 2:220}, N0/edi, 0 #() [45->50] (level:0) is #f with stack state #f #({basic-block #() 50 195}, {basic-block #({tag 3:200}) 200 215}) beq {tag 3:200}, N0/edi, 1 #() [50->195] (level:0) is #f with stack state #f #({basic-block #() 195 200}) sub N0/edi, N0/edi, 1 asr N9/ecx, N3/edx, 2 move ecx, N9/ecx move N11/edi, N0/edi asl N11/edi, N11/edi, 2 move esi, esp sub esp, esp, N11/edi move ecx, ecx move N10/edi, esp move edi, N10/edi move esi, esi copy-words-down-w edi, esi, ecx move N5/ecx, esi move N12/edi, N3/edx ld esi, N5/ecx, 0 ld ecx, esi, 4 asr ecx, ecx, 2 add esi, esi, 8 asr N13/edx, N12/edi, 2 add N7/edx, ecx, N13/edx push N7/edx move N14/ecx, ecx add N6/edi, esp, N12/edi add N6/edi, N6/edi, 4 pop N8/edx move edi, N6/edi move esi, esi copy-words-down-w edi, esi, N14/ecx move ecx, N8/edx #() [195->200] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 0, #f, #f #({tag 2:220}) [220->245] (level:0) is #f with stack state #f #({basic-block #() 245 245}) sub ecx, ecx, 1 ld esi, esp, 0 st esi, esp, N3/edx add esp, esp, 4 call-indirect ebx, 4, 1 #() [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 #({tag 3:200}) [200->215] (level:0) is #f with stack state #f #({basic-block #() 215 220}) ld N1/edi, esi, 8 st N1/edi, esp, N3/edx move ecx, ecx #() [215->220] (level:0) is #f with stack state #f #() jmp-indirect ebx, 4, 1, 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 ebx, eax load-stack-arg-n #t, G2/edx, 0 load-stack-arg-n #t, N0/eax, 1 move N1/eax, N0/eax ld ecx, N1/eax, 4 asr ecx, ecx, 2 add eax, N1/eax, 8 push G2/edx #({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 N3/edi, G2/edx, 0 ld N3/edi, N3/edi, 8 and N3/edi, N3/edi, 8192 beq {tag 2:70}, N3/edi, 0 #() [65->70] (level:1) is #f with stack state #f #({basic-block #({tag 3:45}) 45 65}) ld G2/edx, G2/edx, 20 #() [430->435] (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:285}) 285 290}) ld N3/edi, G2/edx, 8 ld N3/edi, N3/edi, 4 pop G2/edx and N3/edi, N3/edi, 1310720 bne {tag 1:285}, N3/edi, 0 #() [95->100] (level:1) is #f with stack state #f #({basic-block #() 100 105}, {basic-block #({tag 5:115}) 115 125}) beq {tag 5:115}, ecx, 0 #() [100->105] (level:1) is #f with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 6:130}) 130 145}) beq {tag 6:130}, ecx, 1 #() [105->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}, {basic-block #({tag 7:150}) 150 175}) beq {tag 7:150}, ecx, 2 #() [110->115] (level:1) is #f with stack state #f #({basic-block #({tag 4:215}) 215 280}, {basic-block #({tag 8:180}) 180 210}) beq {tag 8:180}, ecx, 3 #({tag 4:215}) [215->280] (level:1) is #f with stack state #f #({basic-block #() 280 285}) sub ecx, ecx, 1 pop esi add esp, esp, 8 asl N5/edi, ecx, 2 sub esp, esp, N5/edi move N4/edi, esp push esi add eax, eax, 4 move edi, N4/edi move esi, eax copy-words-down-w edi, esi, ecx move edi, G2/edx ld eax, eax, -4 #() [280->285] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 1:285}) [285->290] (level:1) is #f with stack state #f #({basic-block #() 290 295}, {basic-block #({tag 10:295}) 295 315}) beq {tag 10:295}, ecx, 1 #() [290->295] (level:1) is #f with stack state #f #({basic-block #({tag 9:350}) 350 425}, {basic-block #({tag 11:320}) 320 345}) beq {tag 11:320}, ecx, 2 #({tag 9:350}) [350->425] (level:1) is #f with stack state #f #({basic-block #() 425 430}) asl N7/edi, ecx, 2 store-stack-arg-n N7/edi, 1 pop esi sub ecx, ecx, 1 add esp, esp, 4 asl N8/edi, ecx, 2 sub esp, esp, N8/edi move N6/edi, esp push esi add eax, eax, 4 move edi, N6/edi move esi, eax copy-words-down-w edi, esi, ecx move edi, G2/edx ld eax, eax, -4 #() [425->430] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 5:115}) [115->125] (level:1) is #f with stack state #f #({basic-block #() 125 130}) move-return-address #f, 8, #f move edi, G2/edx #() [125->130] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 6:130}) [130->145] (level:1) is #f with stack state #f #({basic-block #() 145 150}) move-return-address #f, 8, #f move edi, G2/edx ld eax, eax, 0 #() [145->150] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 7:150}) [150->175] (level:1) is #f with stack state #f #({basic-block #() 175 180}) ld esi, eax, 4 store-stack-arg-n esi, 1 move-return-address #f, 4, #f move edi, G2/edx ld eax, eax, 0 #() [175->180] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 8:180}) [180->210] (level:1) is #f with stack state #f #({basic-block #() 210 215}) ld esi, eax, 4 store-stack-arg-n esi, 0 ld esi, eax, 8 store-stack-arg-n esi, 1 move edi, G2/edx ld eax, eax, 0 #() [210->215] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 10:295}) [295->315] (level:1) is #f with stack state #f #({basic-block #() 315 320}) store-stack-arg-n 4, 1 move-return-address #f, 4, #f move edi, G2/edx ld eax, eax, 0 #() [315->320] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 11:320}) [320->345] (level:1) is #f with stack state #f #({basic-block #() 345 350}) ld esi, eax, 4 store-stack-arg-n esi, 0 store-stack-arg-n 8, 1 move edi, G2/edx ld eax, eax, 0 #() [345->350] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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 35}) rem "This is a dummy first basic block." #() [5->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) sub esp, esp, 8 ld esi, esp, 8 st esi, esp, 0 st ebx, esp, 4 st edi, esp, 8 ld N0/ebx, ebx, 8 #() [35->40] (level:0) is #f with stack state #f #() jmp N0/ebx, 1, 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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 50}) sub esp, esp, 8 ld esi, esp, 8 st esi, esp, 0 ld esi, esp, 12 st esi, esp, 4 st ebx, esp, 8 st edi, esp, 12 ld N0/ebx, ebx, 8 #() [45->50] (level:0) is #f with stack state #f #() jmp N0/ebx, 1, 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 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) sub esp, esp, 8 ld esi, esp, 8 st esi, esp, 0 ld esi, esp, 12 st esi, esp, 4 ld esi, esp, 16 st esi, esp, 8 st ebx, esp, 12 st edi, esp, 16 ld N0/ebx, ebx, 8 #() [55->60] (level:0) is #f with stack state #f #() jmp N0/ebx, 1, 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/ebx, ebx move G1/edx, edi move G0/eax, G1/edx #({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/edi, G0/eax, 0 ld N3/edi, N3/edi, 8 and N3/edi, N3/edi, 8192 beq {tag 1:45}, N3/edi, 0 #() [40->45] (level:1) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) ld G0/eax, G0/eax, 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}) pop N4/edi push 1 push {constant "KLsimple_object_vectorGVKdW"} move G0/eax, esp push N4/edi preserve-registers-entry ld N6/edi, G2/ebx, 8 push G1/edx push G2/ebx move eax, G0/eax call N6/edi, 1 #() [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 8 +++ ending code for general_engine_node_n_0 +++ +++ Live variable scopes for general_engine_node_n_0 +++ Start scope at 39 with frame for no variables End scope at 45 +++ No Source Code Locators for general_engine_node_n_0 +++ +++ 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/ebx, ebx move G1/ecx, edi move G0/edi, G1/ecx #({tag 2:20}) [20->40] (level:1) is #f with stack state #f #({basic-block #() 40 45}, {basic-block #({tag 1:45}) 45 125}) ld N3/edx, G0/edi, 0 ld N3/edx, N3/edx, 8 and N3/edx, N3/edx, 8192 beq {tag 1:45}, N3/edx, 0 #() [40->45] (level:1) is #f with stack state #f #({basic-block #({tag 2:20}) 20 40}) ld G0/edi, G0/edi, 20 #() [145->150] (level:0) is #f with stack state #f #() bra {tag 2:20} #({tag 1:45}) [45->125] (level:1) is #f with stack state #f #({basic-block #() 125 140}) ld N4/edi, G0/edi, 8 ld N4/edi, N4/edi, 4 and N4/edi, N4/edi, 1020 pop N5/edx push eax add G7/edi, N4/edi, 1 push G7/edi push {constant "KLsimple_object_vectorGVKdW"} move G0/edi, esp push N5/edx preserve-registers-entry ld N8/edx, G2/ebx, 8 push G1/ecx push G2/ebx move eax, G0/edi call N8/edx, 1 #() [125->140] (level:1) is #f with stack state #f #({basic-block #() 140 145}) preserve-registers-exit ld G9/edi, esp, 8 add N10/edi, G9/edi, 7 #() [140->145] (level:1) is #f with stack state #f #() rts-and-drop N10/edi +++ ending code for general_engine_node_n +++ +++ Live variable scopes for general_engine_node_n +++ Start scope at 54 with frame for no variables End scope at 62 +++ 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/ebx, ebx move G0/edi, edi preserve-registers-entry push G0/edi sub esp, esp, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G3/eax, eax st-index G3/eax, esp, 0, 8 move G2/eax, esp ld G0/edi, ebp, -4 ld N4/edx, G1/ebx, 8 push G0/edi push G1/ebx move eax, G2/eax call N4/edx, 1 #() [85->95] (level:0) is #f with stack state #f #({basic-block #() 95 100}) preserve-registers-exit load-stack-arg-n #t, N5/edi, 0 #() [95->100] (level:0) is #f with stack state #f #() rts-and-drop N5/edi +++ ending code for general_engine_node_n_optionals_0 +++ +++ Live variable scopes for general_engine_node_n_optionals_0 +++ Start scope at 3 with frame for no variables End scope at 29 +++ No Source Code Locators for general_engine_node_n_optionals_0 +++ +++ 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/ebx, ebx move G0/edi, edi preserve-registers-entry push G0/edi move G0/edi, G0/edi #({tag 2:30}) [30->50] (level:1) is #f with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 1:55}) 55 225}) ld N4/edx, G0/edi, 0 ld N4/edx, N4/edx, 8 and N4/edx, N4/edx, 8192 beq {tag 1:55}, N4/edx, 0 #() [50->55] (level:1) is #f with stack state #f #({basic-block #({tag 2:30}) 30 50}) ld G0/edi, G0/edi, 20 #() [250->255] (level:0) is #f with stack state #f #() bra {tag 2:30} #({tag 1:55}) [55->225] (level:1) is #f with stack state #f #({basic-block #() 225 245}) ld N3/edx, G0/edi, 8 ld N3/edx, N3/edx, 4 and N3/edx, N3/edx, 1020 pop G0/edi preserve-registers-exit preserve-registers-entry push G0/edi push G1/ebx add N5/edi, N3/edx, 4 sub esp, esp, N5/edi add G6/edi, N5/edi, 1 push G6/edi push {constant "KLsimple_object_vectorGVKdW"} move G7/eax, eax st G7/eax, esp, 8 add esi, ebp, 8 add N8/edi, esp, 12 asr N9/ecx, N3/edx, 2 sub N9/ecx, N9/ecx, 1 move edi, N8/edi move esi, esi copy-words-down-w edi, esi, N9/ecx add N11/edi, N3/edx, 4 ld G10/edi, ebp, N11/edi st-index G10/edi, esp, N3/edx, 8 move G2/eax, esp push N3/edx ld G1/ebx, ebp, -8 ld G0/edi, ebp, -4 ld N12/edx, G1/ebx, 8 push G0/edi push G1/ebx move eax, G2/eax call N12/edx, 1 #() [225->245] (level:1) is #f with stack state #f #({basic-block #() 245 250}) pop N3/edx preserve-registers-exit add N14/edx, N3/edx, 4 ld N13/edx, esp, N14/edx #() [245->250] (level:1) is #f with stack state #f #() rts-and-drop N13/edx +++ ending code for general_engine_node_n_optionals +++ +++ Live variable scopes for general_engine_node_n_optionals +++ Start scope at 3 with frame for no variables End scope at 37 Start scope at 38 no frame for no variables End scope at 41 Start scope at 42 with frame for no variables End scope at 106 +++ 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/ebx, ebx move G0/edi, edi preserve-registers-entry push G0/edi move G2/eax, eax ld G0/edi, ebp, -4 ld N3/edx, G1/ebx, 8 push G0/edi push G1/ebx move eax, G2/eax call N3/edx, 1 #() [60->70] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit load-stack-arg-n #t, N4/edi, 0 #() [70->75] (level:0) is #f with stack state #f #() rts-and-drop N4/edi +++ ending code for general_engine_node_spread_optionals_0 +++ +++ Live variable scopes for general_engine_node_spread_optionals_0 +++ Start scope at 3 with frame for no variables End scope at 13 +++ No Source Code Locators for general_engine_node_spread_optionals_0 +++ +++ 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/ebx, ebx move G0/edi, edi preserve-registers-entry push G0/edi move G0/edi, G0/edi #({tag 2:30}) [30->50] (level:1) is #f with stack state #f #({basic-block #() 50 55}, {basic-block #({tag 1:55}) 55 285}) ld N4/edx, G0/edi, 0 ld N4/edx, N4/edx, 8 and N4/edx, N4/edx, 8192 beq {tag 1:55}, N4/edx, 0 #() [50->55] (level:1) is #f with stack state #f #({basic-block #({tag 2:30}) 30 50}) ld G0/edi, G0/edi, 20 #() [310->315] (level:0) is #f with stack state #f #() bra {tag 2:30} #({tag 1:55}) [55->285] (level:1) is #f with stack state #f #({basic-block #() 285 305}) ld N3/edx, G0/edi, 8 ld N3/edx, N3/edx, 4 and N3/edx, N3/edx, 1020 pop G0/edi preserve-registers-exit preserve-registers-entry push G0/edi push G1/ebx add N8/edi, N3/edx, 4 ld G5/edi, ebp, N8/edi ld N6/edi, G5/edi, 4 sub N6/edi, N6/edi, 1 sub esp, esp, N6/edi add N7/edi, N6/edi, N3/edx sub esp, esp, N3/edx add G9/edi, N7/edi, 1 push G9/edi push {constant "KLsimple_object_vectorGVKdW"} move G10/eax, eax st G10/eax, esp, 8 add esi, ebp, 8 add N11/edi, esp, 12 asr N12/ecx, N3/edx, 2 sub N12/ecx, N12/ecx, 1 move edi, N11/edi move esi, esi copy-words-down-w edi, esi, N12/ecx add N17/edi, N3/edx, 4 ld G13/edi, ebp, N17/edi ld N15/ecx, G13/edi, 4 asr N15/ecx, N15/ecx, 2 add N16/ebx, G13/edi, 8 add N14/edi, esp, 8 add N14/edi, N14/edi, N3/edx move edi, N14/edi move esi, N16/ebx copy-words-down-w edi, esi, N15/ecx move G2/eax, esp push N3/edx ld G1/ebx, ebp, -8 ld G0/edi, ebp, -4 ld N18/edx, G1/ebx, 8 push G0/edi push G1/ebx move eax, G2/eax call N18/edx, 1 #() [285->305] (level:1) is #f with stack state #f #({basic-block #() 305 310}) pop N3/edx preserve-registers-exit add N20/edx, N3/edx, 4 ld N19/edx, esp, N20/edx #() [305->310] (level:1) is #f with stack state #f #() rts-and-drop N19/edx +++ ending code for general_engine_node_spread_optionals +++ +++ Live variable scopes for general_engine_node_spread_optionals +++ Start scope at 3 with frame for no variables End scope at 37 Start scope at 38 no frame for no variables End scope at 41 Start scope at 42 with frame for no variables End scope at 135 +++ 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/eax, eax ld N3/ebx, ebx, 8 add N3/ebx, N3/ebx, 3 ld G0/edi, G2/eax, N3/ebx beq {tag 1:45}, G0/edi, {constant "KPunboundVKi"} #() [30->35] (level:0) is #f with stack state #f #({basic-block #({tag 2:35}) 35 40}) move eax, G0/edi #({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/ebx, N3/ebx, 2 sub N4/ebx, N4/ebx, 1 asl G1/ebx, N4/ebx, 2 add G1/ebx, G1/ebx, 1 push G1/ebx move eax, G2/eax call {constant "Kunbound_instance_slotVKeI"}, 1 #() [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/eax, eax load-stack-arg-n #t, G1/edi, 0 ld N2/ebx, ebx, 8 add N2/ebx, N2/ebx, 3 st G0/eax, G1/edi, N2/ebx move eax, G0/eax reset-values #() [40->45] (level:0) is #f with stack state #f #() rts-and-drop 4 +++ 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/eax, eax load-stack-arg-n #t, G3/edi, 0 ld N4/ebx, ebx, 8 add N4/ebx, N4/ebx, 3 add N6/ebx, G2/eax, N4/ebx ld G0/edx, N6/ebx, -4 blt {tag 1:75}, G3/edi, 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/edi, G0/edx #() [45->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 2:90}) 90 105}) and N5/edx, G3/edi, -4 ld G1/ebx, N6/ebx, N5/edx beq {tag 2:90}, G1/ebx, {constant "KPunboundVKi"} #() [60->65] (level:0) is #f with stack state #f #({basic-block #({tag 3:65}) 65 70}) move eax, G1/ebx #({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 4 #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:65}) 65 70}) push G3/edi move eax, G2/eax call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1 #() [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}) push G3/edi move eax, G2/eax call {constant "Kunbound_repeated_slotVKeI"}, 1 #() [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/edx, eax load-stack-arg-n #t, G2/eax, 0 load-stack-arg-n #t, G3/edi, 1 ld N4/ebx, ebx, 8 add N4/ebx, N4/ebx, 3 add N6/ebx, G2/eax, N4/ebx ld G0/ecx, N6/ebx, -4 blt {tag 1:75}, G3/edi, 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/edi, G0/ecx #() [50->65] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) and N5/edi, G3/edi, -4 st G1/edx, N6/ebx, N5/edi move eax, G1/edx #({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 4 #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) push G3/edi move eax, G2/eax call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1 #() [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/eax, eax load-stack-arg-n #t, G2/edi, 0 ld N3/ebx, ebx, 8 add N3/ebx, N3/ebx, 3 add N6/ebx, G1/eax, N3/ebx ld G0/edx, N6/ebx, -4 blt {tag 1:75}, G2/edi, 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/edi, G0/edx #() [45->65] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) asr N5/eax, G2/edi, 2 ldb N4/eax, N6/ebx, N5/eax asl eax, N4/eax, 2 add eax, eax, 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 4 #({tag 1:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}) 65 70}) push G2/edi move eax, G1/eax call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1 #() [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/edx, eax load-stack-arg-n #t, G2/eax, 0 load-stack-arg-n #t, G3/edi, 1 ld N4/ebx, ebx, 8 add N4/ebx, N4/ebx, 3 add N7/ebx, G2/eax, N4/ebx ld G0/ecx, N7/ebx, -4 blt {tag 1:80}, G3/edi, 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/edi, G0/ecx #() [50->70] (level:0) is #f with stack state #f #({basic-block #({tag 2:70}) 70 75}) asr N5/eax, G1/edx, 2 asr N6/edi, G3/edi, 2 stb N5/eax, N7/ebx, N6/edi move eax, G1/edx #({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 4 #({tag 1:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #({tag 2:70}) 70 75}) push G3/edi move eax, G2/eax call {constant "Krepeated_slot_getter_index_out_of_range_trapVKeI"}, 1 #() [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/ebx, ebx rem "eliminated" ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [35->40] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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/ebx, ebx move G1/edi, edi move N2/edx, eax ld N3/edx, N2/edx, 4 nbit {tag 1:110}, N3/edx, 4, 0 #() [30->95] (level:0) is #f with stack state #f #({basic-block #() 95 105}) preserve-registers-entry push G1/edi sub esp, esp, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G5/eax, eax st-index G5/eax, esp, 0, 8 move G4/eax, esp ld G1/edi, ebp, -4 push G0/ebx push G1/edi move eax, G4/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [95->105] (level:0) is #f with stack state #f #({basic-block #() 105 110}) preserve-registers-exit load-stack-arg-n #t, N6/edi, 0 #() [105->110] (level:0) is #f with stack state #f #() rts-and-drop N6/edi #({tag 1:110}) [110->130] (level:0) is #f with stack state #f #({basic-block #() 130 135}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [130->135] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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 13 with frame for no variables End scope at 39 +++ 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/ebx, ebx move G1/edi, edi load-stack-arg-n #t, N2/edx, 0 ld N3/edx, N2/edx, 4 nbit {tag 1:120}, N3/edx, 4, 0 #() [30->105] (level:0) is #f with stack state #f #({basic-block #() 105 115}) preserve-registers-entry push G1/edi sub esp, esp, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G5/eax, eax st G5/eax, esp, 8 ld G6/edi, ebp, 8 st-index G6/edi, esp, 4, 8 move G4/eax, esp ld G1/edi, ebp, -4 push G0/ebx push G1/edi move eax, G4/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [105->115] (level:0) is #f with stack state #f #({basic-block #() 115 120}) preserve-registers-exit load-stack-arg-n #t, N7/edi, 1 #() [115->120] (level:0) is #f with stack state #f #() rts-and-drop N7/edi #({tag 1:120}) [120->140] (level:0) is #f with stack state #f #({basic-block #() 140 145}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [140->145] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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 15 with frame for no variables End scope at 48 +++ 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/ebx, ebx move G1/edi, edi load-stack-arg-n #t, N2/edx, 1 ld N3/edx, N2/edx, 4 nbit {tag 1:130}, N3/edx, 4, 0 #() [30->115] (level:0) is #f with stack state #f #({basic-block #() 115 125}) preserve-registers-entry push G1/edi sub esp, esp, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G5/eax, eax st G5/eax, esp, 8 ld G6/edi, ebp, 8 st G6/edi, esp, 12 ld G7/edi, ebp, 12 st-index G7/edi, esp, 8, 8 move G4/eax, esp ld G1/edi, ebp, -4 push G0/ebx push G1/edi move eax, G4/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [115->125] (level:0) is #f with stack state #f #({basic-block #() 125 130}) preserve-registers-exit load-stack-arg-n #t, N8/edi, 2 #() [125->130] (level:0) is #f with stack state #f #() rts-and-drop N8/edi #({tag 1:130}) [130->150] (level:0) is #f with stack state #f #({basic-block #() 150 155}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [150->155] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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 15 with frame for no variables End scope at 55 +++ No Source Code Locators for unrestricted_keyed_single_method_entry_2 +++ +++ 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 205}, {basic-block #({tag 1:230}) 230 250}) move G0/ebx, ebx move G1/edi, edi ld N4/edx, G0/ebx, 4 asr N4/edx, N4/edx, 6 and N4/edx, N4/edx, 1020 move N5/edx, N4/edx ld N2/edx, esp, N5/edx ld N3/edx, N2/edx, 4 nbit {tag 1:230}, N3/edx, 4, 0 #() [50->205] (level:0) is #f with stack state #f #({basic-block #() 205 225}) ld N7/edx, G0/ebx, 4 asr N7/edx, N7/edx, 6 and N7/edx, N7/edx, 1020 preserve-registers-entry push G1/edi push G0/ebx add N8/edi, N7/edx, 4 sub esp, esp, N8/edi add G9/edi, N8/edi, 1 push G9/edi push {constant "KLsimple_object_vectorGVKdW"} move G10/eax, eax st G10/eax, esp, 8 add esi, ebp, 8 add N11/edi, esp, 12 asr N12/ecx, N7/edx, 2 sub N12/ecx, N12/ecx, 1 move edi, N11/edi move esi, esi copy-words-down-w edi, esi, N12/ecx add N14/edi, N7/edx, 4 ld G13/edi, ebp, N14/edi st-index G13/edi, esp, N7/edx, 8 move G6/eax, esp push N7/edx ld G0/ebx, ebp, -8 ld G1/edi, ebp, -4 push G0/ebx push G1/edi move eax, G6/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [205->225] (level:0) is #f with stack state #f #({basic-block #() 225 230}) pop N7/edx preserve-registers-exit add N16/edx, N7/edx, 4 ld N15/edx, esp, N16/edx #() [225->230] (level:0) is #f with stack state #f #() rts-and-drop N15/edx #({tag 1:230}) [230->250] (level:0) is #f with stack state #f #({basic-block #() 250 255}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [250->255] (level:0) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f +++ ending code for unrestricted_keyed_single_method_entry +++ +++ Live variable scopes for unrestricted_keyed_single_method_entry +++ Start scope at 38 with frame for no variables End scope at 102 +++ 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/ebx, ebx move G1/edi, edi move G2/edx, eax ld G4/edx, G2/edx, 4 bit {tag 2:170}, G4/edx, 4, 0 #() [30->80] (level:0) is #f with stack state #f #({basic-block #({tag 6:80}) 80 85}) move G3/edx, eax push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G5/ebx, G0/ebx, 24 ld N6/edi, eax, 4 sub N6/edi, N6/edi, 1 add N6/edi, N6/edi, eax #({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}, N6/edi, eax #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld esi, N6/edi, 0 ld ebp, G5/ebx, 4 sub ebp, ebp, 1 add ebp, ebp, G5/ebx #({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}, ebp, G5/ebx #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N7/edx, ebp, 4 beq {tag 9:125}, N7/edx, esi #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub ebp, ebp, 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 esi, 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/edi push esi sub esp, esp, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G9/eax, eax st-index G9/eax, esp, 0, 8 move G8/eax, esp ld esi, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:275}, esi, 0 #() [235->275] (level:2) is #f with stack state #f #({basic-block #({tag 10:295}) 295 305}) ld G10/edx, G0/ebx, 24 push {constant "KPfalseVKi"} push G10/edx push esi push G0/ebx push G1/edi move eax, G8/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({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, N11/edi, 0 #() [305->310] (level:2) is #f with stack state #f #() rts-and-drop N11/edi #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:310}) 310 330}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:310}) [310->330] (level:1) is #f with stack state #f #({basic-block #() 330 335}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [330->335] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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/edi pop G0/ebx pop ebp pop eax #() [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 N6/edi, N6/edi, 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}) push G0/ebx push G1/edi move eax, G8/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [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 109 +++ 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/ebx, ebx move G1/edi, edi load-stack-arg-n #t, G2/edx, 0 ld G4/edx, G2/edx, 4 bit {tag 2:170}, G4/edx, 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/edx, 0 push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G5/ebx, G0/ebx, 24 ld N6/edi, eax, 4 sub N6/edi, N6/edi, 1 add N6/edi, N6/edi, eax #({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}, N6/edi, eax #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld esi, N6/edi, 0 ld ebp, G5/ebx, 4 sub ebp, ebp, 1 add ebp, ebp, G5/ebx #({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}, ebp, G5/ebx #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N7/edx, ebp, 4 beq {tag 9:125}, N7/edx, esi #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub ebp, ebp, 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 esi, 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/edi push esi sub esp, esp, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G9/eax, eax st G9/eax, esp, 8 ld G10/edi, ebp, 8 st-index G10/edi, esp, 4, 8 move G8/eax, esp ld esi, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:285}, esi, 0 #() [245->285] (level:2) is #f with stack state #f #({basic-block #({tag 10:305}) 305 315}) ld G11/edx, G0/ebx, 24 push {constant "KPfalseVKi"} push G11/edx push esi push G0/ebx push G1/edi move eax, G8/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({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, N12/edi, 1 #() [315->320] (level:2) is #f with stack state #f #() rts-and-drop N12/edi #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:320}) 320 340}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:320}) [320->340] (level:1) is #f with stack state #f #({basic-block #() 340 345}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [340->345] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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/edi pop G0/ebx pop ebp pop eax #() [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 N6/edi, N6/edi, 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}) push G0/ebx push G1/edi move eax, G8/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [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 68 with frame for no variables End scope at 120 +++ 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/ebx, ebx move G1/edi, edi load-stack-arg-n #t, G2/edx, 1 ld G4/edx, G2/edx, 4 bit {tag 2:170}, G4/edx, 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/edx, 1 push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G5/ebx, G0/ebx, 24 ld N6/edi, eax, 4 sub N6/edi, N6/edi, 1 add N6/edi, N6/edi, eax #({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}, N6/edi, eax #() [85->105] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) ld esi, N6/edi, 0 ld ebp, G5/ebx, 4 sub ebp, ebp, 1 add ebp, ebp, G5/ebx #({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}, ebp, G5/ebx #() [110->120] (level:2) is #f with stack state #f #({basic-block #() 120 125}, {basic-block #({tag 9:125}) 125 130}) ld N7/edx, ebp, 4 beq {tag 9:125}, N7/edx, esi #() [120->125] (level:1) is #f with stack state #f #({basic-block #({tag 8:105}) 105 110}) sub ebp, ebp, 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 esi, 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/edi push esi sub esp, esp, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G9/eax, eax st G9/eax, esp, 8 ld G10/edi, ebp, 8 st G10/edi, esp, 12 ld G11/edi, ebp, 12 st-index G11/edi, esp, 8, 8 move G8/eax, esp ld esi, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:295}, esi, 0 #() [255->295] (level:2) is #f with stack state #f #({basic-block #({tag 10:315}) 315 325}) ld G12/edx, G0/ebx, 24 push {constant "KPfalseVKi"} push G12/edx push esi push G0/ebx push G1/edi move eax, G8/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({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, N13/edi, 2 #() [325->330] (level:2) is #f with stack state #f #() rts-and-drop N13/edi #({tag 4:150}, {tag 7:150}) [150->170] (level:1) is #f with stack state #f #({basic-block #({tag 1:330}) 330 350}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:330}) [330->350] (level:1) is #f with stack state #f #({basic-block #() 350 355}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [350->355] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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/edi pop G0/ebx pop ebp pop eax #() [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 N6/edi, N6/edi, 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}) push G0/ebx push G1/edi move eax, G8/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [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 68 with frame for no variables End scope at 127 +++ No Source Code Locators for explicit_keyed_single_method_entry_2 +++ +++ 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/ebx, ebx move G1/edi, edi move esi, G0/ebx ld N5/ebx, G0/ebx, 4 asr N5/ebx, N5/ebx, 6 and N5/ebx, N5/ebx, 1020 move N6/ebx, N5/ebx ld G2/ebx, esp, N6/ebx ld G4/ebx, G2/ebx, 4 bit {tag 2:220}, G4/ebx, 4, 0 #() [55->130] (level:0) is #f with stack state #f #({basic-block #({tag 6:130}) 130 135}) move G0/ebx, esi ld N7/edx, G0/ebx, 4 asr N7/edx, N7/edx, 6 and N7/edx, N7/edx, 1020 move N8/edx, N7/edx ld G3/edx, esp, N8/edx push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G9/ebx, G0/ebx, 24 ld N10/edi, eax, 4 sub N10/edi, N10/edi, 1 add N10/edi, N10/edi, eax #({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}, N10/edi, eax #() [135->155] (level:1) is #f with stack state #f #({basic-block #({tag 8:155}) 155 160}) ld esi, N10/edi, 0 ld ebp, G9/ebx, 4 sub ebp, ebp, 1 add ebp, ebp, G9/ebx #({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}, ebp, G9/ebx #() [160->170] (level:2) is #f with stack state #f #({basic-block #() 170 175}, {basic-block #({tag 9:175}) 175 180}) ld N11/edx, ebp, 4 beq {tag 9:175}, N11/edx, esi #() [170->175] (level:1) is #f with stack state #f #({basic-block #({tag 8:155}) 155 160}) sub ebp, ebp, 4 #() [490->495] (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 380}) move G0/ebx, esi move esi, 0 #({tag 3:230}) [230->380] (level:2) is #f with stack state #f #({basic-block #() 380 420}, {basic-block #({tag 11:420}) 420 440}) ld N13/edx, G0/ebx, 4 asr N13/edx, N13/edx, 6 and N13/edx, N13/edx, 1020 preserve-registers-entry push G1/edi push G0/ebx push esi add N14/edi, N13/edx, 4 sub esp, esp, N14/edi add G15/edi, N14/edi, 1 push G15/edi push {constant "KLsimple_object_vectorGVKdW"} move G16/eax, eax st G16/eax, esp, 8 add esi, ebp, 8 add N17/edi, esp, 12 asr N18/ecx, N13/edx, 2 sub N18/ecx, N18/ecx, 1 move edi, N17/edi move esi, esi copy-words-down-w edi, esi, N18/ecx add N20/edi, N13/edx, 4 ld G19/edi, ebp, N20/edi st-index G19/edi, esp, N13/edx, 8 move G12/eax, esp ld esi, ebp, -12 push N13/edx ld G0/ebx, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:420}, esi, 0 #() [380->420] (level:2) is #f with stack state #f #({basic-block #({tag 10:440}) 440 460}) ld G21/edx, G0/ebx, 24 push {constant "KPfalseVKi"} push G21/edx push esi push G0/ebx push G1/edi move eax, G12/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({tag 10:440}) [440->460] (level:2) is #f with stack state #f #({basic-block #() 460 465}) pop N13/edx preserve-registers-exit add N23/edx, N13/edx, 4 ld N22/edx, esp, N23/edx #() [460->465] (level:2) is #f with stack state #f #() rts-and-drop N22/edx #({tag 4:200}, {tag 7:200}) [200->220] (level:1) is #f with stack state #f #({basic-block #({tag 1:465}) 465 485}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:465}) [465->485] (level:1) is #f with stack state #f #({basic-block #() 485 490}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [485->490] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 5:180}) [180->200] (level:2) is #f with stack state #f #({basic-block #({tag 3:230}) 230 380}) pop G1/edi pop G0/ebx pop ebp pop eax #() [495->500] (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 N10/edi, N10/edi, 8 #() [500->505] (level:0) is #f with stack state #f #() bra {tag 6:130} #({tag 11:420}) [420->440] (level:2) is #f with stack state #f #({basic-block #({tag 10:440}) 440 460}) push G0/ebx push G1/edi move eax, G12/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [505->510] (level:0) is #f with stack state #f #() bra {tag 10:440} +++ ending code for explicit_keyed_single_method_entry +++ +++ Live variable scopes for explicit_keyed_single_method_entry +++ Start scope at 120 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/ebx, ebx move G1/edi, edi move G2/edx, eax ld G4/edx, G2/edx, 4 bit {tag 2:175}, G4/edx, 4, 0 #() [30->85] (level:0) is #f with stack state #f #({basic-block #({tag 6:85}) 85 90}) move G3/edx, eax push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G6/ebx, G0/ebx, 16 ld G5/edx, G6/ebx, 20 ld N7/edi, eax, 4 sub N7/edi, N7/edi, 1 add N7/edi, N7/edi, eax #({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}, N7/edi, eax #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld esi, N7/edi, 0 ld ebp, G5/edx, 4 sub ebp, ebp, 1 add ebp, ebp, G5/edx #({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}, ebp, G5/edx #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N8/ebx, ebp, 0 beq {tag 9:130}, N8/ebx, esi #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub ebp, ebp, 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 esi, 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/edi push esi sub esp, esp, 4 push 5 push {constant "KLsimple_object_vectorGVKdW"} move G10/eax, eax st-index G10/eax, esp, 0, 8 move G9/eax, esp ld esi, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:285}, esi, 0 #() [240->285] (level:2) is #f with stack state #f #({basic-block #({tag 10:305}) 305 315}) ld G12/edx, G0/ebx, 16 ld G11/edx, G12/edx, 20 push {constant "KPtrueVKi"} push G11/edx push esi push G0/ebx push G1/edi move eax, G9/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({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, N13/edi, 0 #() [315->320] (level:2) is #f with stack state #f #() rts-and-drop N13/edi #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:320}) 320 340}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:320}) [320->340] (level:1) is #f with stack state #f #({basic-block #() 340 345}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [340->345] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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/edi pop G0/ebx pop ebp pop eax #() [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 N7/edi, N7/edi, 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}) push G0/ebx push G1/edi move eax, G9/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [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 67 with frame for no variables End scope at 115 +++ 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/ebx, ebx move G1/edi, edi load-stack-arg-n #t, G2/edx, 0 ld G4/edx, G2/edx, 4 bit {tag 2:175}, G4/edx, 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/edx, 0 push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G6/ebx, G0/ebx, 16 ld G5/edx, G6/ebx, 20 ld N7/edi, eax, 4 sub N7/edi, N7/edi, 1 add N7/edi, N7/edi, eax #({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}, N7/edi, eax #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld esi, N7/edi, 0 ld ebp, G5/edx, 4 sub ebp, ebp, 1 add ebp, ebp, G5/edx #({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}, ebp, G5/edx #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N8/ebx, ebp, 0 beq {tag 9:130}, N8/ebx, esi #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub ebp, ebp, 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 esi, 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/edi push esi sub esp, esp, 8 push 9 push {constant "KLsimple_object_vectorGVKdW"} move G10/eax, eax st G10/eax, esp, 8 ld G11/edi, ebp, 8 st-index G11/edi, esp, 4, 8 move G9/eax, esp ld esi, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:295}, esi, 0 #() [250->295] (level:2) is #f with stack state #f #({basic-block #({tag 10:315}) 315 325}) ld G13/edx, G0/ebx, 16 ld G12/edx, G13/edx, 20 push {constant "KPtrueVKi"} push G12/edx push esi push G0/ebx push G1/edi move eax, G9/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({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, N14/edi, 1 #() [325->330] (level:2) is #f with stack state #f #() rts-and-drop N14/edi #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:330}) 330 350}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:330}) [330->350] (level:1) is #f with stack state #f #({basic-block #() 350 355}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [350->355] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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/edi pop G0/ebx pop ebp pop eax #() [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 N7/edi, N7/edi, 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}) push G0/ebx push G1/edi move eax, G9/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [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 71 with frame for no variables End scope at 126 +++ 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/ebx, ebx move G1/edi, edi load-stack-arg-n #t, G2/edx, 1 ld G4/edx, G2/edx, 4 bit {tag 2:175}, G4/edx, 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/edx, 1 push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G6/ebx, G0/ebx, 16 ld G5/edx, G6/ebx, 20 ld N7/edi, eax, 4 sub N7/edi, N7/edi, 1 add N7/edi, N7/edi, eax #({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}, N7/edi, eax #() [90->110] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) ld esi, N7/edi, 0 ld ebp, G5/edx, 4 sub ebp, ebp, 1 add ebp, ebp, G5/edx #({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}, ebp, G5/edx #() [115->125] (level:2) is #f with stack state #f #({basic-block #() 125 130}, {basic-block #({tag 9:130}) 130 135}) ld N8/ebx, ebp, 0 beq {tag 9:130}, N8/ebx, esi #() [125->130] (level:1) is #f with stack state #f #({basic-block #({tag 8:110}) 110 115}) sub ebp, ebp, 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 esi, 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/edi push esi sub esp, esp, 12 push 13 push {constant "KLsimple_object_vectorGVKdW"} move G10/eax, eax st G10/eax, esp, 8 ld G11/edi, ebp, 8 st G11/edi, esp, 12 ld G12/edi, ebp, 12 st-index G12/edi, esp, 8, 8 move G9/eax, esp ld esi, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:305}, esi, 0 #() [260->305] (level:2) is #f with stack state #f #({basic-block #({tag 10:325}) 325 335}) ld G14/edx, G0/ebx, 16 ld G13/edx, G14/edx, 20 push {constant "KPtrueVKi"} push G13/edx push esi push G0/ebx push G1/edi move eax, G9/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({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, N15/edi, 2 #() [335->340] (level:2) is #f with stack state #f #() rts-and-drop N15/edi #({tag 4:155}, {tag 7:155}) [155->175] (level:1) is #f with stack state #f #({basic-block #({tag 1:340}) 340 360}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:340}) [340->360] (level:1) is #f with stack state #f #({basic-block #() 360 365}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [360->365] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 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/edi pop G0/ebx pop ebp pop eax #() [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 N7/edi, N7/edi, 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}) push G0/ebx push G1/edi move eax, G9/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [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 71 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 +++ +++ 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/ebx, ebx move G1/edi, edi move esi, G0/ebx ld N5/ebx, G0/ebx, 4 asr N5/ebx, N5/ebx, 6 and N5/ebx, N5/ebx, 1020 move N6/ebx, N5/ebx ld G2/ebx, esp, N6/ebx ld G4/ebx, G2/ebx, 4 bit {tag 2:225}, G4/ebx, 4, 0 #() [55->135] (level:0) is #f with stack state #f #({basic-block #({tag 6:135}) 135 140}) move G0/ebx, esi ld N7/edx, G0/ebx, 4 asr N7/edx, N7/edx, 6 and N7/edx, N7/edx, 1020 move N8/edx, N7/edx ld G3/edx, esp, N8/edx push eax push ebp push G0/ebx push G1/edi move eax, G3/edx ld G10/ebx, G0/ebx, 16 ld G9/edx, G10/ebx, 20 ld N11/edi, eax, 4 sub N11/edi, N11/edi, 1 add N11/edi, N11/edi, eax #({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}, N11/edi, eax #() [140->160] (level:1) is #f with stack state #f #({basic-block #({tag 8:160}) 160 165}) ld esi, N11/edi, 0 ld ebp, G9/edx, 4 sub ebp, ebp, 1 add ebp, ebp, G9/edx #({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}, ebp, G9/edx #() [165->175] (level:2) is #f with stack state #f #({basic-block #() 175 180}, {basic-block #({tag 9:180}) 180 185}) ld N12/ebx, ebp, 0 beq {tag 9:180}, N12/ebx, esi #() [175->180] (level:1) is #f with stack state #f #({basic-block #({tag 8:160}) 160 165}) sub ebp, ebp, 8 #() [500->505] (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 385}) move G0/ebx, esi move esi, 0 #({tag 3:235}) [235->385] (level:2) is #f with stack state #f #({basic-block #() 385 430}, {basic-block #({tag 11:430}) 430 450}) ld N14/edx, G0/ebx, 4 asr N14/edx, N14/edx, 6 and N14/edx, N14/edx, 1020 preserve-registers-entry push G1/edi push G0/ebx push esi add N15/edi, N14/edx, 4 sub esp, esp, N15/edi add G16/edi, N15/edi, 1 push G16/edi push {constant "KLsimple_object_vectorGVKdW"} move G17/eax, eax st G17/eax, esp, 8 add esi, ebp, 8 add N18/edi, esp, 12 asr N19/ecx, N14/edx, 2 sub N19/ecx, N19/ecx, 1 move edi, N18/edi move esi, esi copy-words-down-w edi, esi, N19/ecx add N21/edi, N14/edx, 4 ld G20/edi, ebp, N21/edi st-index G20/edi, esp, N14/edx, 8 move G13/eax, esp ld esi, ebp, -12 push N14/edx ld G0/ebx, ebp, -8 ld G1/edi, ebp, -4 beq {tag 11:430}, esi, 0 #() [385->430] (level:2) is #f with stack state #f #({basic-block #({tag 10:450}) 450 470}) ld G23/edx, G0/ebx, 16 ld G22/edx, G23/edx, 20 push {constant "KPtrueVKi"} push G22/edx push esi push G0/ebx push G1/edi move eax, G13/eax call {constant "Kinvalid_keyword_trapVKeI"}, 1 #({tag 10:450}) [450->470] (level:2) is #f with stack state #f #({basic-block #() 470 475}) pop N14/edx preserve-registers-exit add N25/edx, N14/edx, 4 ld N24/edx, esp, N25/edx #() [470->475] (level:2) is #f with stack state #f #() rts-and-drop N24/edx #({tag 4:205}, {tag 7:205}) [205->225] (level:1) is #f with stack state #f #({basic-block #({tag 1:475}) 475 495}) add esp, esp, 4 pop G0/ebx pop ebp pop eax #({tag 1:475}) [475->495] (level:1) is #f with stack state #f #({basic-block #() 495 500}) ld G1/edi, G0/ebx, 20 ld G0/ebx, G0/ebx, 16 move ebx, G0/ebx move edi, G1/edi #() [495->500] (level:1) is #f with stack state #f #() jmp-indirect ebx, 12, 1, 0, #f, #f #({tag 5:185}) [185->205] (level:2) is #f with stack state #f #({basic-block #({tag 3:235}) 235 385}) pop G1/edi pop G0/ebx pop ebp pop eax #() [505->510] (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 N11/edi, N11/edi, 8 #() [510->515] (level:0) is #f with stack state #f #() bra {tag 6:135} #({tag 11:430}) [430->450] (level:2) is #f with stack state #f #({basic-block #({tag 10:450}) 450 470}) push G0/ebx push G1/edi move eax, G13/eax call {constant "Kodd_number_of_keyword_args_trapVKeI"}, 1 #() [515->520] (level:0) is #f with stack state #f #() bra {tag 10:450} +++ ending code for implicit_keyed_single_method_entry +++ +++ Live variable scopes for implicit_keyed_single_method_entry +++ Start scope at 123 with frame for no variables End scope at 209 +++ 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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}) move G0/ecx, eax push eax push edi ld N1/edx, ebx, 8 push ebx push edi move eax, G0/ecx call N1/edx, 1 #() [45->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}) load-stack-arg-n #t, G0/ecx, 0 push eax push edi ld N1/edx, ebx, 8 push ebx push edi move eax, G0/ecx call N1/edx, 1 #() [45->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}) load-stack-arg-n #t, G0/ecx, 1 push eax push edi ld N1/edx, ebx, 8 push ebx push edi move eax, G0/ecx call N1/edx, 1 #() [45->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}) load-stack-arg-n #t, G0/ecx, 2 push eax push edi ld N1/edx, ebx, 8 push ebx push edi move eax, G0/ecx call N1/edx, 1 #() [45->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}) load-stack-arg-n #t, G0/ecx, 3 push eax push edi ld N1/edx, ebx, 8 push ebx push edi move eax, G0/ecx call N1/edx, 1 #() [45->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}) load-stack-arg-n #t, G0/ecx, 4 push eax push edi ld N1/edx, ebx, 8 push ebx push edi move eax, G0/ecx call N1/edx, 1 #() [45->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 45}) rem "This is a dummy first basic block." #() [5->45] (level:0) is #f with stack state #f #({basic-block #() 45 65}) load-stack-arg-n #t, G0/ecx, 5 push eax push edi ld N1/edx, ebx, 8 push ebx push edi move eax, G0/ecx call N1/edx, 1 #() [45->65] (level:0) is #f with stack state #f #({basic-block #() 65 70}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [65->70] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 65}) rem "This is a dummy first basic block." #() [5->65] (level:0) is #f with stack state #f #({basic-block #() 65 85}) ld N3/edx, ebx, 4 asr N3/edx, N3/edx, 6 and N3/edx, N3/edx, 1020 move N4/edx, N3/edx ld G0/edx, esp, N4/edx push eax push edi ld N1/ecx, ebx, 8 push ebx push edi move eax, G0/edx call N1/ecx, 1 #() [65->85] (level:0) is #f with stack state #f #({basic-block #() 85 90}) move ebx, eax pop edi pop eax ld N2/edx, ebx, 12 #() [85->90] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) move G0/edx, eax push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 24 #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 0 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 24 #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 1 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 24 #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 2 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 24 #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 3 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 24 #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 4 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 24 #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 5 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 24 #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 80}, {basic-block #({tag 1:95}) 95 105}) ld N3/edx, ebx, 4 asr N3/edx, N3/edx, 6 and N3/edx, N3/edx, 1020 move N4/edx, N3/edx ld G0/edx, esp, N4/edx push eax push edi ld N1/edi, ebx, 16 push ebx move G6/edi, N1/edi beq {tag 1:95}, G6/edi, {constant "KLobjectGVKd"} #() [60->80] (level:0) is #f with stack state #f #({basic-block #() 80 85}) ld N5/ebx, G6/edi, 4 push G6/edi move eax, G0/edx call N5/ebx, 1 #() [80->85] (level:0) is #f with stack state #f #({basic-block #() 85 95}, {basic-block #({tag 1:95}) 95 105}) bne {tag 1:95}, eax, {constant "KPfalseVKi"} #() [85->95] (level:0) is #f with stack state #f #({basic-block #({tag 2:105}) 105 120}) pop ebx ld ebx, ebx, 24 #({tag 2:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) pop edi pop eax ld N2/edx, ebx, 12 #() [120->125] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:95}) [95->105] (level:0) is #f with stack state #f #({basic-block #({tag 2:105}) 105 120}) pop ebx ld ebx, ebx, 20 #() [125->130] (level:0) is #f with stack state #f #() bra {tag 2:105} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) move G0/edx, eax push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 0 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 1 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 2 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 3 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 4 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 40}) rem "This is a dummy first basic block." #() [5->40] (level:0) is #f with stack state #f #({basic-block #() 40 60}, {basic-block #({tag 1:75}) 75 85}) load-stack-arg-n #t, G0/edx, 5 push eax push edi ld N1/edi, ebx, 16 push ebx move G4/edi, N1/edi beq {tag 1:75}, G4/edi, {constant "KLobjectGVKd"} #() [40->60] (level:0) is #f with stack state #f #({basic-block #() 60 65}) ld N3/ebx, G4/edi, 4 push G4/edi move eax, G0/edx call N3/ebx, 1 #() [60->65] (level:0) is #f with stack state #f #({basic-block #() 65 75}, {basic-block #({tag 1:75}) 75 85}) bne {tag 1:75}, eax, {constant "KPfalseVKi"} #() [65->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:85}) [85->100] (level:0) is #f with stack state #f #({basic-block #() 100 105}) pop edi pop eax ld N2/edx, ebx, 12 #() [100->105] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #({tag 2:85}) 85 100}) pop ebx ld ebx, ebx, 20 #() [105->110] (level:0) is #f with stack state #f #() bra {tag 2:85} +++ 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 60}) rem "This is a dummy first basic block." #() [5->60] (level:0) is #f with stack state #f #({basic-block #() 60 80}, {basic-block #({tag 1:95}) 95 105}) ld N3/edx, ebx, 4 asr N3/edx, N3/edx, 6 and N3/edx, N3/edx, 1020 move N4/edx, N3/edx ld G0/edx, esp, N4/edx push eax push edi ld N1/edi, ebx, 16 push ebx move G6/edi, N1/edi beq {tag 1:95}, G6/edi, {constant "KLobjectGVKd"} #() [60->80] (level:0) is #f with stack state #f #({basic-block #() 80 85}) ld N5/ebx, G6/edi, 4 push G6/edi move eax, G0/edx call N5/ebx, 1 #() [80->85] (level:0) is #f with stack state #f #({basic-block #() 85 95}, {basic-block #({tag 1:95}) 95 105}) bne {tag 1:95}, eax, {constant "KPfalseVKi"} #() [85->95] (level:0) is #f with stack state #f #({basic-block #({tag 2:105}) 105 120}) pop ebx move ebx, {indirect-constant "Dinapplicable_engine_nodeVKg"} #({tag 2:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #() 120 125}) pop edi pop eax ld N2/edx, ebx, 12 #() [120->125] (level:0) is #f with stack state #f #() jmp N2/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:95}) [95->105] (level:0) is #f with stack state #f #({basic-block #({tag 2:105}) 105 120}) pop ebx ld ebx, ebx, 20 #() [125->130] (level:0) is #f with stack state #f #() bra {tag 2:105} +++ 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 80}) move G0/ecx, eax move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:75}, N1/edx, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:60}, N1/edx, G0/ecx #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [80->85] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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 80}) load-stack-arg-n #t, G0/ecx, 0 move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:75}, N1/edx, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:60}, N1/edx, G0/ecx #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [80->85] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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 80}) load-stack-arg-n #t, G0/ecx, 1 move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:75}, N1/edx, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:60}, N1/edx, G0/ecx #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [80->85] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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 80}) load-stack-arg-n #t, G0/ecx, 2 move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:75}, N1/edx, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:60}, N1/edx, G0/ecx #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [80->85] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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 80}) load-stack-arg-n #t, G0/ecx, 3 move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:75}, N1/edx, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:60}, N1/edx, G0/ecx #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [80->85] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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 80}) load-stack-arg-n #t, G0/ecx, 4 move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:75}, N1/edx, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:60}, N1/edx, G0/ecx #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [80->85] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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 80}) load-stack-arg-n #t, G0/ecx, 5 move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:75}, N1/edx, 0 #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:60}, N1/edx, G0/ecx #() [45->55] (level:0) is #f with stack state #f #({basic-block #() 55 60}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [55->60] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #({tag 3:30}) 30 45}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [80->85] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [70->75] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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 100}) ld N2/ecx, ebx, 4 asr N2/ecx, N2/ecx, 6 and N2/ecx, N2/ecx, 1020 move N3/ecx, N2/ecx ld G0/ecx, esp, N3/ecx move N1/edx, G0/ecx and N1/edx, N1/edx, 3 bne {tag 1:95}, N1/edx, 0 #() [45->50] (level:0) is #f with stack state #f #({basic-block #({tag 3:50}) 50 65}) ld G0/ecx, G0/ecx, 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/ecx, G0/ecx, 1 ld N1/edx, ebx, 16 bne {tag 2:80}, N1/edx, G0/ecx #() [65->75] (level:0) is #f with stack state #f #({basic-block #() 75 80}) ld ebx, ebx, 20 ld N1/edx, ebx, 12 #() [75->80] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:95}) [95->100] (level:0) is #f with stack state #f #({basic-block #({tag 3:50}) 50 65}) ld-index-scaled G0/ecx, {indirect-constant "Ddirect_object_mm_wrappersVKi"}, N1/edx, 0 #() [100->105] (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 ebx, {indirect-constant "Dabsent_engine_nodeVKg"} ld N1/edx, ebx, 12 #() [90->95] (level:0) is #f with stack state #f #() jmp N1/edx, #[1, #"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/ecx, edi #({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/edx, G2/ecx, 0 ld N3/edx, N3/edx, 8 and N3/edx, N3/edx, 8192 beq {tag 3:35}, N3/edx, 0 #() [30->35] (level:1) is #f with stack state #f #({basic-block #({tag 4:10}) 10 30}) ld G2/ecx, G2/ecx, 20 #() [120->125] (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:95}) 95 105}) ld N1/edx, G2/ecx, 8 ld N1/edx, N1/edx, 4 asr N1/edx, N1/edx, 2 and N1/edx, N1/edx, 255 ld N4/ecx, G2/ecx, 8 ld N4/ecx, N4/ecx, 4 and N4/ecx, N4/ecx, 1310720 bne {tag 1:95}, N4/ecx, 0 #() [75->85] (level:1) is #f with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_n"} bge {tag 5:115}, N1/edx, 1 #() [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) bne {tag 6:115}, N1/edx, 0 #() [90->95] (level:1) is #f with stack state #f #({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_n_0"} #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) [115->115] (level:1) is #f with stack state #f #({basic-block #({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) 115 120}) #({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) [115->120] (level:1) is #f with stack state #f #() jmp N0/ecx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:95}) [95->105] (level:1) is #f with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_spread_optionals"} bge {tag 7:115}, N1/edx, 1 #() [105->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) bne {tag 8:115}, N1/edx, 0 #() [110->115] (level:1) is #f with stack state #f #({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_spread_optionals_0"} #() [125->130] (level:0) is #f with stack state #f #() bra {tag 2:115} +++ 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/ecx, edi #({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/edx, G2/ecx, 0 ld N3/edx, N3/edx, 8 and N3/edx, N3/edx, 8192 beq {tag 3:35}, N3/edx, 0 #() [30->35] (level:1) is #f with stack state #f #({basic-block #({tag 4:10}) 10 30}) ld G2/ecx, G2/ecx, 20 #() [120->125] (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:95}) 95 105}) ld N1/edx, G2/ecx, 8 ld N1/edx, N1/edx, 4 asr N1/edx, N1/edx, 2 and N1/edx, N1/edx, 255 ld N4/ecx, G2/ecx, 8 ld N4/ecx, N4/ecx, 4 and N4/ecx, N4/ecx, 1310720 bne {tag 1:95}, N4/ecx, 0 #() [75->85] (level:1) is #f with stack state #f #({basic-block #() 85 90}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_n"} bge {tag 5:115}, N1/edx, 1 #() [85->90] (level:1) is #f with stack state #f #({basic-block #() 90 95}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) bne {tag 6:115}, N1/edx, 0 #() [90->95] (level:1) is #f with stack state #f #({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_n_0"} #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) [115->115] (level:1) is #f with stack state #f #({basic-block #({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) 115 120}) #({tag 8:115}, {tag 7:115}, {tag 6:115}, {tag 5:115}, {tag 2:115}) [115->120] (level:1) is #f with stack state #f #() jmp N0/ecx, #[1, #"mlist", #"function"], 0, #f, #f #({tag 1:95}) [95->105] (level:1) is #f with stack state #f #({basic-block #() 105 110}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_n_optionals"} bge {tag 7:115}, N1/edx, 1 #() [105->110] (level:1) is #f with stack state #f #({basic-block #() 110 115}, {basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) bne {tag 8:115}, N1/edx, 0 #() [110->115] (level:1) is #f with stack state #f #({basic-block #({tag 2:115}, {tag 5:115}, {tag 6:115}, {tag 7:115}, {tag 8:115}) 115 115}) move N0/ecx, {constant "general_engine_node_n_optionals_0"} #() [125->130] (level:0) is #f with stack state #f #() bra {tag 2:115} +++ 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 edi, ebx ld ebx, edi, 16 ld N0/edx, ebx, 12 #() [20->25] (level:0) is #f with stack state #f #() jmp N0/edx, #[1, #"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 edi, ebx 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/edx, ebx, 24, 1 beq {tag 1:40}, N0/edx, 0 #({tag 2:25}) [25->35] (level:0) is #f with stack state #f #({basic-block #() 35 40}) ld ebx, ebx, 16 ld N0/edx, ebx, 12 #() [35->40] (level:0) is #f with stack state #f #() jmp N0/edx, #[1, #"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 ebx, ebx, 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/eax, eax move N1/edi, {constant "cache_header_entry"} st N1/edi, G0/eax, 12 move eax, G0/eax #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 4 +++ 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/eax, eax move N1/edi, {constant "general_engine_node_n_entry"} st N1/edi, G0/eax, 12 move eax, G0/eax #() [25->30] (level:0) is green with stack state #f #() rts-and-drop 4 +++ 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/eax, eax move N2/edi, {constant "general_engine_node_spread_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "single_method_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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:65}, {tag 4:65}) 65 75}) move G0/eax, eax ld N1/edi, G0/eax, 4 asr N1/edi, N1/edi, 8 and N1/edi, N1/edi, 255 move N2/ebx, {constant "implicit_keyed_single_method_entry"} bge {tag 1:65}, N1/edi, 3 #() [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/edi, 0 #() [40->45] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "implicit_keyed_single_method_entry_0"} #({tag 1:65}, {tag 4:65}) [65->75] (level:0) is green with stack state #f #({basic-block #() 75 80}) st N2/ebx, G0/eax, 12 move eax, G0/eax #() [75->80] (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/edi, 1 #() [50->55] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "implicit_keyed_single_method_entry_1"} #() [80->85] (level:0) is #f with stack state #f #() bra {tag 1:65} #({tag 3:55}) [55->60] (level:0) is green with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75}) bne {tag 4:65}, N1/edi, 2 #() [60->65] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "implicit_keyed_single_method_entry_2"} #() [85->90] (level:0) is #f with stack state #f #() bra {tag 1:65} +++ 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:65}, {tag 4:65}) 65 75}) move G0/eax, eax ld N1/edi, G0/eax, 4 asr N1/edi, N1/edi, 8 and N1/edi, N1/edi, 255 move N2/ebx, {constant "explicit_keyed_single_method_entry"} bge {tag 1:65}, N1/edi, 3 #() [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/edi, 0 #() [40->45] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "explicit_keyed_single_method_entry_0"} #({tag 1:65}, {tag 4:65}) [65->75] (level:0) is green with stack state #f #({basic-block #() 75 80}) st N2/ebx, G0/eax, 12 move eax, G0/eax #() [75->80] (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/edi, 1 #() [50->55] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "explicit_keyed_single_method_entry_1"} #() [80->85] (level:0) is #f with stack state #f #() bra {tag 1:65} #({tag 3:55}) [55->60] (level:0) is green with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75}) bne {tag 4:65}, N1/edi, 2 #() [60->65] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "explicit_keyed_single_method_entry_2"} #() [85->90] (level:0) is #f with stack state #f #() bra {tag 1:65} +++ 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:65}, {tag 4:65}) 65 75}) move G0/eax, eax ld N1/edi, G0/eax, 4 asr N1/edi, N1/edi, 8 and N1/edi, N1/edi, 255 move N2/ebx, {constant "unrestricted_keyed_single_method_entry"} bge {tag 1:65}, N1/edi, 3 #() [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/edi, 0 #() [40->45] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "unrestricted_keyed_single_method_entry_0"} #({tag 1:65}, {tag 4:65}) [65->75] (level:0) is green with stack state #f #({basic-block #() 75 80}) st N2/ebx, G0/eax, 12 move eax, G0/eax #() [75->80] (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/edi, 1 #() [50->55] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "unrestricted_keyed_single_method_entry_1"} #() [80->85] (level:0) is #f with stack state #f #() bra {tag 1:65} #({tag 3:55}) [55->60] (level:0) is green with stack state #f #({basic-block #() 60 65}, {basic-block #({tag 1:65}, {tag 4:65}) 65 75}) bne {tag 4:65}, N1/edi, 2 #() [60->65] (level:0) is green with stack state #f #({basic-block #({tag 1:65}, {tag 4:65}) 65 75}) move N2/ebx, {constant "unrestricted_keyed_single_method_entry_2"} #() [85->90] (level:0) is #f with stack state #f #() bra {tag 1:65} +++ 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/eax, eax move N2/edi, {constant "profiling_cache_header_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "cache_header_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "boxed_instance_slot_getter_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "boxed_instance_slot_setter_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "boxed_repeated_instance_slot_getter_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "boxed_repeated_instance_slot_setter_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "raw_byte_repeated_instance_slot_getter_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "raw_byte_repeated_instance_slot_setter_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "general_engine_node_1_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "general_engine_node_2_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "general_engine_node_3_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/eax, eax move N2/edi, {constant "general_engine_node_n_entry"} st N2/edi, G0/eax, 12 move eax, G0/eax #() [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/edi, eax, 4 and N0/edi, N0/edi, 252 ld N1/edi, {constant "Kinitialize_engine_node_table"}, N0/edi #() [20->25] (level:0) is green with stack state #f #() jmp N1/edi, 1, 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/eax, eax ld N1/edi, G0/eax, 4 asr N1/edi, N1/edi, 8 and N1/edi, N1/edi, 255 ld N3/ebx, G0/eax, 4 asr N3/ebx, N3/ebx, 2 and N3/ebx, N3/ebx, 63 beq {tag 1:140}, N3/ebx, 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/ebx, 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/ebx, 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/ebx, 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/ebx, {constant "discriminate_on_argument_entry"} bge {tag 6:385}, N1/edi, 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/edi, 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/ebx, {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/ebx, G0/eax, 12 move eax, G0/eax #() [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/ebx, {constant "if_type_discriminator_engine"} bge {tag 14:385}, N1/edi, 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/edi, 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/ebx, {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/ebx, {constant "typecheck_discriminator_engine"} bge {tag 22:385}, N1/edi, 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/edi, 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/ebx, {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/ebx, {constant "monomorphic_by_class_discriminator_engine"} bge {tag 30:385}, N1/edi, 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/edi, 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/ebx, {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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/edi, 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/ebx, {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/eax, eax ld N3/edi, G0/eax, 8 ld N3/edi, N3/edi, 4 asr N3/edi, N3/edi, 2 and N3/edi, N3/edi, 255 ld N4/ebx, G0/eax, 8 ld N4/ebx, N4/ebx, 4 and N4/ebx, N4/ebx, 1310720 bne {tag 1:135}, N4/ebx, 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/ebx, {constant "new_gf_xep"} bge {tag 3:130}, N3/edi, 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/edi, 0 #() [65->70] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/ebx, {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/ebx, G0/eax, 4 #({tag 2:225}) [220->225] (level:0) is green with stack state #f #({basic-block #({tag 2:225}) 225 230}) move eax, G0/eax #({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/ebx, {constant "new_gf_optional_xep"} bge {tag 11:215}, N3/edi, 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/edi, 0 #() [150->155] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/ebx, {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/ebx, G0/eax, 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/edi, 1 #() [75->80] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/ebx, {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/edi, 1 #() [160->165] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/ebx, {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/edi, 2 #() [85->90] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/ebx, {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/edi, 2 #() [170->175] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/ebx, {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/edi, 3 #() [95->100] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/ebx, {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/edi, 3 #() [180->185] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/ebx, {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/edi, 4 #() [105->110] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/ebx, {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/edi, 4 #() [190->195] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/ebx, {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/edi, 5 #() [115->120] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/ebx, {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/edi, 5 #() [200->205] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/ebx, {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/edi, 6 #() [125->130] (level:0) is green with stack state #f #({basic-block #({tag 3:130}, {tag 10:130}) 130 135}) move N2/ebx, {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/edi, 6 #() [210->215] (level:0) is green with stack state #f #({basic-block #({tag 11:215}, {tag 18:215}) 215 220}) move N2/ebx, {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:145}) 145 160}) add N4/ebx, {indirect-constant "Poblist"}, 8 sub N5/edi, {indirect-constant "PoblistUcursor"}, 8 asr N5/edi, N5/edi, 2 bne {tag 8:145}, N5/edi, 0 #() [25->30] (level:0) is green with stack state before #({basic-block #({tag 1:80}) 80 100}) move G6/eax, {constant "KPempty_vectorVKi"} #({tag 1:80}) [80->100] (level:0) is green with stack state before #({basic-block #({tag 6:100}) 100 105}) move {indirect-constant "PoblistUsize"}, 8 move {indirect-constant "PoblistUcursor"}, 8 move {indirect-constant "Poblist"}, 0 move eax, G6/eax #({tag 6:100}) [100->105] (level:0) is green with stack state #f #() rts-and-drop 0 #({tag 8:145}) [145->160] (level:0) is #f with stack state #f #({basic-block #({tag 3:105}) 105 115}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:105}) [105->115] (level:0) is brown with stack state with #({basic-block #({tag 2:30}) 30 70}) move N0/edx, N4/ebx move N1/edi, N5/edi #({tag 2:30}) [30->70] (level:0) is red with stack state with #({basic-block #() 70 80}) asl N3/ebx, N1/edi, 2 add N3/ebx, N3/ebx, 8 push N0/edx push 1 push N1/edi push {constant "KLsimple_object_vectorGVKdW"} push N3/ebx call-alien {constant "primitive_alloc_rt"}, 0 #() [70->80] (level:0) is red with stack state with #({basic-block #({tag 4:120}) 115 120}) add esp, esp, 20 move G2/eax, eax #({tag 4:120}) [115->120] (level:0) is yellow with stack state with #({basic-block #({tag 4:120}, {tag 5:120}) 120 140}) move G6/eax, G2/eax #({tag 4:120}, {tag 5:120}) [120->140] (level:0) is green with stack state with #({basic-block #({tag 7:140}) 140 145}) move {indirect-constant "PoblistUsize"}, 8 move {indirect-constant "PoblistUcursor"}, 8 move {indirect-constant "Poblist"}, 0 move eax, G6/eax #({tag 7:140}) [140->145] (level:0) is #f with stack state #f #({basic-block #({tag 6:100}) 100 105}) preserve-registers-exit #() [160->165] (level:0) is #f with stack state #f #() bra {tag 6:100} +++ ending code for primitive_preboot_symbols +++ +++ Live variable scopes for primitive_preboot_symbols +++ Start scope at 65 with frame for no variables End scope at 123 +++ 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:50}) 50 65}) rem "This is a dummy first basic block." #({tag 2:50}) [50->65] (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 40}) move G0/eax, eax push G0/eax push {constant "KLsymbolGVKdW"} push 8 call-alien {constant "primitive_alloc_s1"}, 0 #() [30->40] (level:0) is red with stack state with #({basic-block #({tag 1:45}) 45 50}) add esp, esp, 12 move eax, eax #({tag 1:45}) [45->50] (level:0) is #f with stack state #f #({basic-block #() 40 45}) preserve-registers-exit #() [40->45] (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 3 with frame for no variables End scope at 19 +++ 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 #({tag 12:310}) 310 325}) rem "This is a dummy first basic block." #({tag 12:310}) [310->325] (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 green with stack state with #({basic-block #({tag 3:25}) 25 30}) move G18/GSPILL-0, eax move N3/NSPILL-1, {indirect-constant "PoblistUcursor"} move N4/NSPILL-0, {indirect-constant "Poblist"} move N5/ecx, 8 #({tag 3:25}) [25->30] (level:1) is green with stack state with #({basic-block #() 30 55}, {basic-block #({tag 2:120}) 120 125}) bge {tag 2:120}, N5/ecx, N3/NSPILL-1 #() [30->55] (level:1) is green with stack state with #({basic-block #() 55 65}, {basic-block #({tag 5:115}) 115 120}) ld G19/eax, N4/NSPILL-0, N5/ecx ld G2/GSPILL-1, G19/eax, 4 ld N7/edi, G18/GSPILL-0, 4 ld N8/ebx, G2/GSPILL-1, 4 bne {tag 5:115}, N7/edi, N8/ebx #() [55->65] (level:1) is green with stack state with #({basic-block #({tag 7:65}) 65 70}) asr N6/edi, N7/edi, 2 sub N6/edi, N6/edi, 1 #({tag 7:65}) [65->70] (level:2) is green with stack state with #({basic-block #() 70 85}, {basic-block #({tag 4:125}) 125 130}) blt {tag 4:125}, N6/edi, 0 #() [70->85] (level:2) is green with stack state with #({basic-block #() 85 95}, {basic-block #({tag 6:110}) 110 115}) ldb-index N9/edx, G18/GSPILL-0, N6/edi, 8 ldb-index N10/ebx, G2/GSPILL-1, N6/edi, 8 beq {tag 6:110}, N9/edx, N10/ebx #() [85->95] (level:2) is green with stack state with #({basic-block #() 95 105}, {basic-block #({tag 5:115}) 115 120}) eor N9/edx, N9/edx, N10/ebx bne {tag 5:115}, N9/edx, 32 #() [95->105] (level:2) is green with stack state with #({basic-block #() 105 110}, {basic-block #({tag 5:115}) 115 120}) or N10/ebx, N10/ebx, 32 blt {tag 5:115}, N10/ebx, 97 #() [105->110] (level:2) is green with stack state with #({basic-block #({tag 6:110}) 110 115}, {basic-block #({tag 5:115}) 115 120}) bgt {tag 5:115}, N10/ebx, 122 #({tag 6:110}) [110->115] (level:1) is green with stack state with #({basic-block #({tag 7:65}) 65 70}) sub N6/edi, N6/edi, 1 #() [325->330] (level:0) is #f with stack state #f #() bra {tag 7:65} #({tag 2:120}) [120->125] (level:1) is green with stack state with #({basic-block #({tag 4:125}) 125 130}) move G19/eax, {constant "KPfalseVKi"} #({tag 4:125}) [125->130] (level:2) is green with stack state with #({basic-block #({tag 9:295}) 295 300}, {basic-block #({tag 1:305}) 285 290}) bne {tag 1:305}, G19/eax, {constant "KPfalseVKi"} #({tag 9:295}) [295->300] (level:2) is brown with stack state with #({basic-block #() 130 150}) move G0/edi, G18/GSPILL-0 #() [130->150] (level:2) is red with stack state with #({basic-block #() 150 180}) push G0/edi push {constant "KLsymbolGVKdW"} push 8 call-alien {constant "primitive_alloc_s1"}, 0 #() [150->180] (level:2) is red with stack state with #({basic-block #() 180 235}, {basic-block #({tag 8:270}) 270 285}) add esp, esp, 12 move G1/GSPILL-0, eax move N12/edi, {indirect-constant "PoblistUsize"} move N15/NSPILL-0, {indirect-constant "PoblistUcursor"} move G11/ebx, {indirect-constant "Poblist"} blt {tag 8:270}, N15/NSPILL-0, N12/edi #() [180->235] (level:2) is red with stack state with #({basic-block #() 235 270}) sub N13/NSPILL-1, N12/edi, 8 add N12/edi, N12/edi, 1024 add N17/NSPILL-2, G11/ebx, 8 sub N14/ebx, N12/edi, 8 asr N14/ebx, N14/ebx, 2 push {constant "KPunboundVKi"} push 1 push N14/ebx push {constant "KLsimple_object_vectorGVKdW"} push N12/edi call-alien {constant "primitive_alloc_rf"}, 0 #() [235->270] (level:2) is red with stack state with #({basic-block #({tag 8:270}) 270 285}) add esp, esp, 20 move {indirect-constant "Poblist"}, eax move G11/ebx, eax add N16/eax, eax, 8 move {indirect-constant "PoblistUsize"}, N12/edi asr N13/NSPILL-1, N13/NSPILL-1, 2 copy-words-down-w N16/eax, N17/NSPILL-2, N13/NSPILL-1 #({tag 8:270}) [270->285] (level:2) is red with stack state with #({basic-block #({tag 10:300}) 300 305}) st G1/GSPILL-0, G11/ebx, N15/NSPILL-0 add N15/NSPILL-0, N15/NSPILL-0, 4 move {indirect-constant "PoblistUcursor"}, N15/NSPILL-0 #({tag 10:300}) [300->305] (level:2) is yellow with stack state with #({basic-block #({tag 1:305}) 285 290}) move G19/eax, G1/GSPILL-0 #({tag 1:305}) [285->290] (level:2) is green with stack state with #({basic-block #({tag 1:305}, {tag 11:305}) 305 310}) move eax, G19/eax #({tag 1:305}, {tag 11:305}) [305->310] (level:0) is #f with stack state #f #({basic-block #() 290 295}) preserve-registers-exit #() [290->295] (level:2) is green with stack state #f #() rts-and-drop 0 #({tag 5:115}) [115->120] (level:2) is green with stack state with #({basic-block #({tag 3:25}) 25 30}) add N5/ecx, N5/ecx, 4 #() [330->335] (level:0) is #f with stack state #f #() bra {tag 3:25} +++ ending code for primitive_string_as_symbol +++ +++ Frame sizes for primitive_string_as_symbol: GC: 2, NC: 3 +++ +++ Live variable scopes for primitive_string_as_symbol +++ Start scope at 3 with frame for no variables End scope at 309 +++ 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 #({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 green with stack state with #({basic-block #({tag 3:30}) 30 35}) move G19/eax, eax ld G0/GSPILL-1, G19/eax, 4 move N4/NSPILL-2, {indirect-constant "PoblistUcursor"} move N5/NSPILL-1, {indirect-constant "Poblist"} move N6/NSPILL-0, 8 #({tag 3:30}) [30->35] (level:1) is green with stack state with #({basic-block #() 35 60}, {basic-block #({tag 2:125}) 125 130}) bge {tag 2:125}, N6/NSPILL-0, N4/NSPILL-2 #() [35->60] (level:1) is green with stack state with #({basic-block #() 60 70}, {basic-block #({tag 5:120}) 120 125}) ld G2/ecx, N5/NSPILL-1, N6/NSPILL-0 ld G3/GSPILL-0, G2/ecx, 4 ld N8/edi, G0/GSPILL-1, 4 ld N9/ebx, G3/GSPILL-0, 4 bne {tag 5:120}, N8/edi, N9/ebx #() [60->70] (level:1) is green with stack state with #({basic-block #({tag 7:70}) 70 75}) asr N7/edi, N8/edi, 2 sub N7/edi, N7/edi, 1 #({tag 7:70}) [70->75] (level:2) is green with stack state with #({basic-block #() 75 90}, {basic-block #({tag 4:130}) 130 135}) blt {tag 4:130}, N7/edi, 0 #() [75->90] (level:2) is green with stack state with #({basic-block #() 90 100}, {basic-block #({tag 6:115}) 115 120}) ldb-index N10/edx, G0/GSPILL-1, N7/edi, 8 ldb-index N11/ebx, G3/GSPILL-0, N7/edi, 8 beq {tag 6:115}, N10/edx, N11/ebx #() [90->100] (level:2) is green with stack state with #({basic-block #() 100 110}, {basic-block #({tag 5:120}) 120 125}) eor N10/edx, N10/edx, N11/ebx bne {tag 5:120}, N10/edx, 32 #() [100->110] (level:2) is green with stack state with #({basic-block #() 110 115}, {basic-block #({tag 5:120}) 120 125}) or N11/ebx, N11/ebx, 32 blt {tag 5:120}, N11/ebx, 97 #() [110->115] (level:2) is green with stack state with #({basic-block #({tag 6:115}) 115 120}, {basic-block #({tag 5:120}) 120 125}) bgt {tag 5:120}, N11/ebx, 122 #({tag 6:115}) [115->120] (level:1) is green with stack state with #({basic-block #({tag 7:70}) 70 75}) sub N7/edi, N7/edi, 1 #() [330->335] (level:0) is #f with stack state #f #() bra {tag 7:70} #({tag 2:125}) [125->130] (level:1) is green with stack state with #({basic-block #({tag 4:130}) 130 135}) move G2/ecx, {constant "KPfalseVKi"} #({tag 4:130}) [130->135] (level:2) is green with stack state with #({basic-block #() 135 155}, {basic-block #({tag 1:265}) 265 270}) bne {tag 1:265}, G2/ecx, {constant "KPfalseVKi"} #() [135->155] (level:2) is green with stack state with #({basic-block #({tag 9:275}) 275 295}, {basic-block #({tag 8:245}) 245 265}) move N21/edx, {indirect-constant "PoblistUsize"} move N22/edi, {indirect-constant "PoblistUcursor"} move G20/ebx, {indirect-constant "Poblist"} blt {tag 8:245}, N22/edi, N21/edx #({tag 9:275}) [275->295] (level:2) is brown with stack state with #({basic-block #() 155 210}) move G1/GSPILL-0, G19/eax move G12/ebx, G20/ebx move N13/NSPILL-0, N21/edx move N16/NSPILL-3, N22/edi #() [155->210] (level:2) is red with stack state with #({basic-block #() 210 245}) sub N14/NSPILL-1, N13/NSPILL-0, 8 add N13/NSPILL-0, N13/NSPILL-0, 1024 add N18/NSPILL-2, G12/ebx, 8 sub N15/edi, N13/NSPILL-0, 8 asr N15/edi, N15/edi, 2 push {constant "KPunboundVKi"} push 1 push N15/edi push {constant "KLsimple_object_vectorGVKdW"} push N13/NSPILL-0 call-alien {constant "primitive_alloc_rf"}, 0 #() [210->245] (level:2) is red with stack state with #({basic-block #({tag 10:295}) 295 310}) add esp, esp, 20 move {indirect-constant "Poblist"}, eax move G12/ebx, eax add N17/edi, eax, 8 move {indirect-constant "PoblistUsize"}, N13/NSPILL-0 asr N14/NSPILL-1, N14/NSPILL-1, 2 copy-words-down-w N17/edi, N18/NSPILL-2, N14/NSPILL-1 #({tag 10:295}) [295->310] (level:2) is yellow with stack state with #({basic-block #({tag 8:245}) 245 265}) move G19/eax, G1/GSPILL-0 move G20/ebx, G12/ebx move N22/edi, N16/NSPILL-3 #({tag 8:245}) [245->265] (level:2) is green with stack state with #({basic-block #({tag 1:265}) 265 270}) st G19/eax, G20/ebx, N22/edi add N22/edi, N22/edi, 4 move {indirect-constant "PoblistUcursor"}, N22/edi move G2/ecx, G19/eax #({tag 1:265}) [265->270] (level:2) is green with stack state with #({basic-block #({tag 11:310}) 310 315}) move eax, G2/ecx #({tag 11:310}) [310->315] (level:0) is #f with stack state #f #({basic-block #() 270 275}) preserve-registers-exit #() [270->275] (level:2) is green with stack state #f #() rts-and-drop 0 #({tag 5:120}) [120->125] (level:2) is green with stack state with #({basic-block #({tag 3:30}) 30 35}) add N6/NSPILL-0, N6/NSPILL-0, 4 #() [335->340] (level:0) is #f with stack state #f #() bra {tag 3:30} +++ ending code for primitive_resolve_symbol +++ +++ Frame sizes for primitive_resolve_symbol: GC: 2, NC: 4 +++ +++ Live variable scopes for primitive_resolve_symbol +++ Start scope at 3 with frame for no variables End scope at 305 +++ 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}, eax #() [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 7 with frame for no variables End scope at 26 +++ 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 7 with frame for no variables End scope at 11 +++ 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 "Kinteger_divide_by_0VKeI"}, 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 7 with frame for no variables End scope at 11 +++ 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:25}) 25 40}) rem "This is a dummy first basic block." #({tag 2:25}) [25->40] (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 15}) clear-float-exceptions call {constant "Kfloat_divide_by_0VKeI"}, 0 #() [15->15] (level:0) is red with stack state with #({basic-block #({tag 1:20}) 20 25}) #({tag 1:20}) [20->25] (level:0) is #f with stack state #f #({basic-block #() 15 20}) preserve-registers-exit #() [15->20] (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 7 with frame for no variables End scope at 13 +++ 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:25}) 25 40}) rem "This is a dummy first basic block." #({tag 2:25}) [25->40] (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 15}) clear-float-exceptions call {constant "Kfloat_overflowVKeI"}, 0 #() [15->15] (level:0) is red with stack state with #({basic-block #({tag 1:20}) 20 25}) #({tag 1:20}) [20->25] (level:0) is #f with stack state #f #({basic-block #() 15 20}) preserve-registers-exit #() [15->20] (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 7 with frame for no variables End scope at 13 +++ 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:25}) 25 40}) rem "This is a dummy first basic block." #({tag 2:25}) [25->40] (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 15}) clear-float-exceptions call {constant "Kfloat_underflowVKeI"}, 0 #() [15->15] (level:0) is red with stack state with #({basic-block #({tag 1:20}) 20 25}) #({tag 1:20}) [20->25] (level:0) is #f with stack state #f #({basic-block #() 15 20}) preserve-registers-exit #() [15->20] (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 7 with frame for no variables End scope at 13 +++ 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/ebx, ST move N0/eax, 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/edi, {constant "Kfloating_point_classes"}, N0/eax beq {tag 2:30}, N1/ebx, N2/edi #() [25->30] (level:1) is green with stack state #f #({basic-block #({tag 1:15}) 15 25}) add N0/eax, N0/eax, 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/eax, N0/eax, 4 ld eax, {constant "Kfloating_point_classes"}, N0/eax #() [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 +++