+++ 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{constant "Pmaster_gc_teb"} " in section ambiguous-data" = 0 +++ +++ (public) variable{constant "Pmaster_teb"} " in section ambiguous-data" = 0 +++ +++ (public) variable{indirect-constant "Pteb_tlv_index"} " in section untraced-data" = -1 +++ +++ (public) variable{indirect-constant "Pteb_chain"} " in section untraced-data" = 0 +++ +++ external: "_dylan_init_thread" +++ +++ external: "_dylan_callin_handler" +++ +++ external: "_trampoline_body" +++ +++ external: "_dylan_mm_register_thread" +++ +++ external: "_dylan_mm_deregister_thread_from_teb" +++ +++ external: "_dylan_init_memory_manager" +++ +++ external: "_dylan_shut_down_memory_manager" +++ +++ external: "_MMRegisterRootStatic" +++ +++ external: "_MMRegisterRootImmut" +++ +++ external: "_MMRegisterRootAmbig" +++ +++ external: "_MMRegisterRootExact" +++ +++ external: "_MMDeregisterRoot" +++ +++ external: "_MMFreeMisc" +++ +++ external: "Kmake_foreign_threadYthreads_primitivesVdylanI" +++ +++ external: "Kcall_application_exit_functionsVKeI" +++ +++ variable{constant "Pstatic_root"} " in section untraced-data" = 0 +++ +++ variable{constant "Pimmut_root"} " in section untraced-data" = 0 +++ +++ variable{constant "Pambig_root"} " in section untraced-data" = 0 +++ +++ variable{constant "Pexact_root"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "Pstarted_unloading"} " in section untraced-data" = 0 +++ +++ (public) variable{constant "_module_hInstance"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "_init_dylan_library"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "Pruntime_spin_lock"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "Pruntime_thread_count"} " in section untraced-data" = 0 +++ +++ external: "primitive_ensure_valid_teb" +++ +++ external: "primitive_register_traced_roots" +++ +++ external: "primitive_deregister_traced_roots" +++ +++ external: "_dylan_init_thread_local" +++ +++ external: "primitive_call_first_dylan_iep" +++ +++ (public) variable{indirect-constant "_Prunning_dylan_spy_functionQ"} " in section untraced-data" = 0 +++ +++ external: "spy_invoke_dylan_under_coded_restartVKi" +++ +++ external: "Kmake_simple_lockYthreads_primitivesVdylan" +++ +++ (public) variable{constant "_default_tlv_vector"} " in section ambiguous-data" = 0 +++ +++ (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" +++ defining "Knot_yet_relocated_string" in section untraced-objects +++ DATA "KLbyte_stringGVKdW" DATA 93 BYTE "Data not yet relocated." BYTE 0+++ external: "_OutputDebugStringA@4" +++ +++ external: "_QueryPerformanceCounter@4" +++ +++ external: "_QueryPerformanceFrequency@4" +++ +++ external: "_ExitProcess@4" +++ +++ external: "_WinExec@8" +++ +++ (public) variable{indirect-constant "PcounterUstartUlo"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "PcounterUstartUhi"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "PcounterUstopUlo"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "PcounterUstopUhi"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "PcounterUfrequencyUlo"} " in section untraced-data" = 0 +++ +++ (public) variable{indirect-constant "PcounterUfrequencyUhi"} " in section untraced-data" = 0 +++ +++ external: "_TlsAlloc@0" +++ +++ external: "_TlsFree@4" +++ +++ external: "_TlsGetValue@4" +++ +++ external: "_TlsSetValue@8" +++ +++ external: "_GetModuleHandleA@4" +++ +++ external: "primitive_fixup_imported_dylan_data" +++ +++ external: "primitive_fixup_unimported_dylan_data" +++ +++ external: "_VirtualProtect@16" +++ +++ Defining glue symbols +++ Data start is "_dylan_data_start" Data end is "_dylan_data_end" Variables start is "_dylan_vars_start" Variables end is "_dylan_vars_end" Objects start is "_dylan_objs_start" Objects end is "_dylan_objs_end" Fixup start is "_dylan_fixup_start" Fixup end is "_dylan_fixup_end" Import start is "_dylan_import_start" Import end is "_dylan_import_end" +++ start of code +++ +++ Exported function definition primitive_break +++ +++ starting code for primitive_break +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) halt #() [10->15] (level:0) is green with stack state #f #() rts-and-drop 0 +++ ending code for primitive_break +++ +++ No Source Code Locators for primitive_break +++ +++ Exported function definition primitive_error +++ +++ starting code for primitive_error +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:35}) 35 50}) rem "This is a dummy first basic block." #({tag 2:35}) [35->50] (level:0) is #f with stack state #f #({basic-block #() 5 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->25] (level:0) is red with stack state with #({basic-block #() 25 25}) move 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:95}) 95 110}) rem "This is a dummy first basic block." #({tag 3:95}) [95->110] (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 35}, {basic-block #({tag 1:35}) 35 85}) move G4/GSPILL-0, eax load-stack-arg-n #t, G5/edi, 0 bne {tag 1:35}, {indirect-constant "_Prunning_under_dylan_debuggerQ"}, 0 #() [20->35] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 85}) add N3/ebx, G4/GSPILL-0, 8 push N3/ebx call-alien {constant "_OutputDebugStringA@4"}, 0 #({tag 1:35}) [35->85] (level:0) is red with stack state with #({basic-block #({tag 2:90}) 90 95}) 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/GSPILL-0 halt pop eax #({tag 2: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 4 +++ ending code for primitive_invoke_debugger +++ +++ Frame sizes for primitive_invoke_debugger: GC: 1, NC: 0 +++ +++ Live variable scopes for primitive_invoke_debugger +++ Start scope at 3 with frame for no variables End scope at 64 +++ 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:75}) 75 90}, {basic-block #({tag 2:65}) 65 65}) beq {tag 2:65}, {indirect-constant "Tclass_profiling_enabledQTVKe"}, {constant "KPtrueVKi"} #({tag 8:75}) [75->90] (level:0) is #f with stack state #f #({basic-block #({tag 3:10}) 70 70}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:10}) [70->70] (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 #() 35 45}, {basic-block #({tag 1:45}) 45 65}) load-stack-arg-n #t, N0/edx, 0 load-stack-arg-n #t, N1/NSPILL--2, 1 rem "eliminated" load-stack-arg-n #t, N3/edi, 3 bne {tag 1:45}, {indirect-constant "_Prunning_under_dylan_debuggerQ"}, 0 #() [35->45] (level:0) is red with stack state with #({basic-block #({tag 1:45}) 45 65}) push N0/edx call-alien {constant "_OutputDebugStringA@4"}, 0 #({tag 1:45}) [45->65] (level:0) is red with stack state with #({basic-block #({tag 4:70}) 70 70}) push N3/edi push N1/NSPILL--2 halt pop eax #({tag 4:70}) [70->70] (level:0) is yellow with stack state with #({basic-block #({tag 4:70}, {tag 5:70}) 70 70}) #({tag 4:70}, {tag 5:70}) [70->70] (level:0) is green with stack state with #({basic-block #({tag 5:70}, {tag 4:70}, {tag 7:70}) 70 75}) #({tag 5:70}, {tag 4:70}, {tag 7:70}) [70->75] (level:0) is #f with stack state #f #({basic-block #({tag 2:65}, {tag 6:65}) 65 70}) preserve-registers-exit #({tag 2:65}, {tag 6:65}) [65->70] (level:0) is green with stack state #f #() rts #({tag 2:65}) [65->65] (level:0) is green with stack state before #({basic-block #({tag 2:65}, {tag 6:65}) 65 70}) +++ ending code for _class_allocation_break +++ +++ Live variable scopes for _class_allocation_break +++ Start scope at 16 with frame for no variables End scope at 43 +++ 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 35}, {basic-block #({tag 1:75}) 75 85}) 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:75}, N1/edx, N0/ecx #() [30->35] (level:0) is #f with stack state #f #({basic-block #({tag 3:35}) 35 45}) move eax, N3/edi #({tag 3:35}) [35->45] (level:1) is #f with stack state #f #({basic-block #() 45 55}, {basic-block #({tag 2:55}) 55 70}) get-seh N5/edi bhi {tag 2:55}, N5/edi, N2/ebx #() [45->55] (level:1) is #f with stack state #f #({basic-block #({tag 3:35}) 35 45}) ld N5/edi, N5/edi, 0 set-seh N5/edi #() [395->400] (level:0) is #f with stack state #f #() bra {tag 3:35} #({tag 1:75}) [75->85] (level:0) is #f with stack state #f #({basic-block #() 85 95}, {basic-block #({tag 4:95}) 95 105}) add N6/eax, N2/ebx, 4 bmvset {tag 4:95} #() [85->95] (level:0) is #f with stack state #f #({basic-block #({tag 5:185}) 185 190}) st N3/edi, N6/eax, 8 st 5, N6/eax, 4 #({tag 5:185}) [185->190] (level:0) is #f with stack state #f #({basic-block #({tag 7:190}) 190 195}) st N6/eax, N2/ebx, 0 #({tag 7:190}) [190->195] (level:1) is #f with stack state #f #({basic-block #({tag 10:195}) 195 205}, {basic-block #({tag 8:390}) 390 390}) beq {tag 8:390}, N1/edx, 0 #({tag 10:195}) [195->205] (level:2) is #f with stack state #f #({basic-block #() 205 215}, {basic-block #({tag 9:215}) 215 250}) get-seh N13/edi bhi {tag 9:215}, N13/edi, N1/edx #() [205->215] (level:1) is #f with stack state #f #({basic-block #({tag 10:195}) 195 205}) ld N13/edi, N13/edi, 0 set-seh N13/edi #() [400->405] (level:0) is #f with stack state #f #() bra {tag 10:195} #({tag 2:55}) [55->70] (level:1) is #f with stack state #f #({basic-block #() 70 75}) ld N4/edi, N2/ebx, 52 ld ebp, N2/ebx, 48 add esp, N2/ebx, 56 #() [70->75] (level:1) is #f with stack state #f #() jmp N4/edi, 1, 0, #f, #f #({tag 4:95}) [95->105] (level:0) is #f with stack state #f #({basic-block #() 105 130}, {basic-block #({tag 6:155}) 155 185}) ld-teb ecx, 32 ble {tag 6:155}, ecx, 8 #() [105->130] (level:0) is #f with stack state #f #({basic-block #() 130 155}) push ecx push N2/ebx push N1/edx move eax, ecx call {constant "primitive_allocate_vector"}, 1 #() [130->155] (level:0) is #f with stack state #f #({basic-block #({tag 6:155}) 155 185}) move G7/eax, eax pop N1/edx pop N2/ebx pop ecx move N6/eax, G7/eax #({tag 6:155}) [155->185] (level:0) is #f with stack state #f #({basic-block #({tag 5:185}) 185 190}) asl N9/edi, ecx, 2 add N9/edi, N9/edi, 1 st N9/edi, N6/eax, 4 add N8/edi, N6/eax, 8 ld-teb-address esi, 36 copy-words-down-w N8/edi, esi, ecx #() [405->410] (level:0) is #f with stack state #f #() bra {tag 5:185} #({tag 8:390}) [390->390] (level:1) is #f with stack state #f #({basic-block #({tag 8:390}) 390 395}) #({tag 9:215}) [215->250] (level:2) is #f with stack state #f #({basic-block #() 250 270}) move esp, N1/edx ld N10/edi, esp, 0 ld N11/eax, esp, 8 st-teb N10/edi, 0 ld ebp, esp, 4 push N2/ebx call N11/eax, 0 #() [250->270] (level:2) is #f with stack state #f #({basic-block #() 270 295}, {basic-block #({tag 7:190}) 190 195}) pop N2/ebx ld-teb N1/edx, 0 ld N12/edi, N2/ebx, 44 bne {tag 7:190}, N12/edi, N1/edx #() [270->295] (level:1) is #f with stack state #f #({basic-block #({tag 11:295}) 295 305}, {basic-block #({tag 12:305}) 305 315}) ld G14/eax, N2/ebx, 0 move N17/eax, G14/eax ld N15/edx, N17/eax, 4 asr N15/edx, N15/edx, 2 bne {tag 12:305}, N15/edx, 1 #({tag 11:295}) [295->305] (level:1) is #f with stack state #f #({basic-block #({tag 16:350}, {tag 14:350}) 350 360}) ld eax, N17/eax, 8 reset-values #({tag 16:350}, {tag 14:350}) [350->360] (level:2) is #f with stack state #f #({basic-block #() 360 370}, {basic-block #({tag 15:370}) 370 385}) get-seh N19/edi bhi {tag 15:370}, N19/edi, N2/ebx #() [360->370] (level:2) is #f with stack state #f #({basic-block #({tag 16:350}, {tag 14:350}) 350 360}) ld N19/edi, N19/edi, 0 set-seh N19/edi #() [410->415] (level:0) is #f with stack state #f #() bra {tag 16:350} #({tag 8:390}) [390->395] (level:1) is #f with stack state #f #() jmp {constant "primitive_error"}, 0, 0, #f, #f #({tag 12:305}) [305->315] (level:1) is #f with stack state #f #({basic-block #() 315 340}, {basic-block #({tag 13:340}) 340 350}) st-teb N15/edx, 32 beq {tag 13:340}, N15/edx, 0 #() [315->340] (level:1) is #f with stack state #f #({basic-block #({tag 16:350}, {tag 14:350}) 350 360}) add esi, N17/eax, 8 ld eax, esi, 0 ld-teb-address N16/edi, 36 copy-words-down-w N16/edi, esi, N15/edx set-values #() [415->420] (level:0) is #f with stack state #f #() bra {tag 16:350} #({tag 15:370}) [370->385] (level:2) is #f with stack state #f #({basic-block #() 385 390}) ld N18/edi, N2/ebx, 52 ld ebp, N2/ebx, 48 add esp, N2/ebx, 56 #() [385->390] (level:2) is #f with stack state #f #() jmp N18/edi, 1, 0, #f, #f #({tag 13:340}) [340->350] (level:1) is #f with stack state #f #({basic-block #({tag 16:350}, {tag 14:350}) 350 360}) move eax, {constant "KPfalseVKi"} set-values #() [420->425] (level:0) is #f with stack state #f #() bra {tag 16:350} +++ 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: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}) push {constant "PcounterUstartUlo"} call-alien {constant "_QueryPerformanceCounter@4"}, 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-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 13 +++ 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 4:130}) 130 145}) rem "This is a dummy first basic block." #({tag 4:130}) [130->145] (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 25}) push {constant "PcounterUstopUlo"} call-alien {constant "_QueryPerformanceCounter@4"}, 0 #() [15->25] (level:0) is red with stack state with #({basic-block #() 25 30}) push {constant "PcounterUfrequencyUlo"} call-alien {constant "_QueryPerformanceFrequency@4"}, 0 #() [25->30] (level:0) is red with stack state with #({basic-block #() 30 60}, {basic-block #({tag 2:115}) 115 125}) beq {tag 2:115}, eax, 0 #() [30->60] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 70}) subcx N0/eax, N8/edi, {indirect-constant "PcounterUstopUlo"}, {indirect-constant "PcounterUstartUlo"} sub N1/edx, {indirect-constant "PcounterUstopUhi"}, N8/edi sub N1/edx, N1/edx, {indirect-constant "PcounterUstartUhi"} divuxx N2/NSPILL-1, N4/edi, N0/eax, N1/edx, {indirect-constant "PcounterUfrequencyUlo"} mulux N5/ebx, N6/edi, N4/edi, 1000000 divuxx N3/NSPILL-0, #f, N5/ebx, N6/edi, {indirect-constant "PcounterUfrequencyUlo"} #({tag 1:60}) [60->70] (level:0) is red with stack state with #({basic-block #() 70 110}) move eax, 2 call {constant "primitive_allocate_vector"}, 1 #() [70->110] (level:0) is red with stack state with #({basic-block #({tag 3:125}) 125 130}) move G7/eax, eax asl N9/edi, N2/NSPILL-1, 2 add N9/edi, N9/edi, 1 st N9/edi, G7/eax, 8 asl N10/edi, N3/NSPILL-0, 2 add N10/edi, N10/edi, 1 st N10/edi, G7/eax, 12 move eax, G7/eax #({tag 3:125}) [125->130] (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 0 #({tag 2:115}) [115->125] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 70}) move N2/NSPILL-1, 0 move N3/NSPILL-0, 0 #() [145->150] (level:0) is #f with stack state #f #() bra {tag 1:60} +++ ending code for primitive_stop_timer +++ +++ Frame sizes for primitive_stop_timer: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_stop_timer +++ Start scope at 3 with frame for no variables End scope at 133 +++ 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: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}) push eax call-alien {constant "_ExitProcess@4"}, 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-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 9 +++ 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 4:35}) 35 50}) rem "This is a dummy first basic block." #({tag 4: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 N0/eax, eax push 1 push N0/eax call-alien {constant "_WinExec@8"}, 0 #() [25->25] (level:0) is red with stack state with #({basic-block #({tag 3:30}) 30 35}) #({tag 3:30}) [30->35] (level:0) is #f with stack state #f #({basic-block #() 25 30}) preserve-registers-exit #() [25->30] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_run_application +++ +++ Live variable scopes for primitive_run_application +++ Start scope at 3 with frame for no variables End scope at 11 +++ No Source Code Locators for primitive_run_application +++ +++ Exported function definition _make_foreign_thread_internal +++ +++ starting code for _make_foreign_thread_internal +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "Kmake_foreign_threadYthreads_primitivesVdylanI"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for _make_foreign_thread_internal +++ +++ Live variable scopes for _make_foreign_thread_internal +++ Start scope at 7 with frame for no variables End scope at 11 +++ No Source Code Locators for _make_foreign_thread_internal +++ +++ Exported function definition primitive_ensure_valid_teb +++ +++ starting code for primitive_ensure_valid_teb +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 13:360}) 360 375}) rem "This is a dummy first basic block." #({tag 13:360}) [360->375] (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 25}) push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsGetValue@4"}, 0 #() [15->25] (level:0) is red with stack state with #({basic-block #() 25 35}, {basic-block #({tag 1:290}) 290 300}) move N0/NSPILL-0, eax bne {tag 1:290}, N0/NSPILL-0, 0 #() [25->35] (level:0) is red with stack state with #({basic-block #() 35 75}) push 336 call-alien {constant "_dylan__malloc__misc"}, 0 #() [35->75] (level:0) is red with stack state with #({basic-block #() 75 80}) add esp, esp, 4 move N1/edi, eax add N2/NSPILL-1, N1/edi, 12 add N3/ebx, N2/NSPILL-1, 324 push N3/ebx push N1/edi push N1/edi call-alien {constant "_MMRegisterRootAmbig"}, 0 #() [75->80] (level:0) is red with stack state with #({basic-block #({tag 8:320}) 320 325}) add esp, esp, 12 #({tag 8:320}) [320->325] (level:1) is green with stack state with #({basic-block #({tag 9:85}) 85 90}, {basic-block #({tag 8:320}) 320 325}) conditional-move {tag 8:320}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 9:85}) [85->90] (level:0) is red with stack state with #({basic-block #() 90 95}, {basic-block #({tag 2:95}) 95 165}) beq {tag 2:95}, {indirect-constant "Pteb_chain"}, 0 #() [90->95] (level:0) is red with stack state with #({basic-block #({tag 2:95}) 95 165}) st N1/edi, {indirect-constant "Pteb_chain"}, 8 #({tag 2:95}) [95->165] (level:0) is red with stack state with #({basic-block #() 165 185}) st {indirect-constant "Pteb_chain"}, N1/edi, 4 st 0, N1/edi, 8 move {indirect-constant "Pteb_chain"}, N1/edi move {indirect-constant "Pruntime_spin_lock"}, 0 add N0/NSPILL-0, N2/NSPILL-1, 32 st 0, N2/NSPILL-1, 0 st 0, N2/NSPILL-1, 4 st 0, N0/NSPILL-0, 0 st {constant "KPempty_listVKi"}, N0/NSPILL-0, 16 st {constant "KPunboundVKi"}, N0/NSPILL-0, 4 set-teb N0/NSPILL-0 push N0/NSPILL-0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [165->185] (level:0) is red with stack state with #({basic-block #() 185 195}) st 0, N0/NSPILL-0, 20 or N4/edi, esp, 1020 push N4/edi call-alien {constant "_dylan_mm_register_thread"}, 0 #() [185->195] (level:0) is red with stack state with #({basic-block #() 195 210}, {basic-block #({tag 6:305}) 305 320}) add esp, esp, 4 beq {tag 6:305}, eax, 0 #() [195->210] (level:0) is red with stack state with #({basic-block #() 210 215}) push 0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [210->215] (level:0) is red with stack state with #({basic-block #({tag 6:305}) 305 320}) halt #({tag 6:305}) [305->320] (level:1) is green with stack state with #({basic-block #({tag 7:230}) 230 275}, {basic-block #({tag 6:305}) 305 320}) move N5/eax, {indirect-constant "Pruntime_thread_count"} add N6/edi, N5/eax, 1 conditional-move {tag 6:305}, {indirect-constant "Pruntime_thread_count"}, N6/edi, N5/eax #({tag 7:230}) [230->275] (level:0) is red with stack state with #({basic-block #() 275 290}) init-fpu push 0 move N7/edi, esp st -1, N0/NSPILL-0, 20 push 0 push 0 push {constant "_make_foreign_thread_internal"} push N7/edi call-alien {constant "_dylan_init_thread"}, 0 #() [275->290] (level:0) is red with stack state with #({basic-block #({tag 1:290}) 290 300}) add esp, esp, 16 add esp, esp, 4 st 0, N0/NSPILL-0, 20 #({tag 1:290}) [290->300] (level:0) is red with stack state with #({basic-block #({tag 10:325}) 325 330}) set-teb N0/NSPILL-0 move eax, N0/NSPILL-0 #({tag 10:325}) [325->330] (level:0) is #f with stack state #f #({basic-block #() 300 305}) preserve-registers-exit #() [300->305] (level:0) is red with stack state #f #() rts +++ ending code for primitive_ensure_valid_teb +++ +++ Frame sizes for primitive_ensure_valid_teb: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_ensure_valid_teb +++ Start scope at 3 with frame for no variables End scope at 361 +++ No Source Code Locators for primitive_ensure_valid_teb +++ +++ Exported function definition _dylan_call_in +++ +++ starting code for _dylan_call_in +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:105}) 105 120}) rem "This is a dummy first basic block." #({tag 3:105}) [105->120] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 65}) move N4/NSPILL-0, ecx move N5/NSPILL-1, eax call {constant "primitive_ensure_valid_teb"}, 0 #() [20->65] (level:0) is red with stack state with #({basic-block #() 65 95}) move N0/edi, eax st -1, N0/edi, 20 load-address-of-stack-arg-n #t, N2/edx, 0 push N2/edx push N5/NSPILL-1 move N3/edx, esp push N4/NSPILL-0 push N3/edx call-alien {constant "_dylan_callin_handler"}, 0 #() [65->95] (level:0) is red with stack state with #({basic-block #({tag 2:100}) 100 105}) add esp, esp, 8 add esp, esp, 8 move N1/eax, eax st 0, N0/edi, 20 move eax, N1/eax asl ecx, N4/NSPILL-0, 2 #({tag 2:100}) [100->105] (level:0) is #f with stack state #f #({basic-block #() 95 100}) preserve-registers-exit #() [95->100] (level:0) is red with stack state #f #() rts-and-drop ecx +++ ending code for _dylan_call_in +++ +++ Frame sizes for _dylan_call_in: GC: 0, NC: 2 +++ +++ Live variable scopes for _dylan_call_in +++ Start scope at 7 with frame for no variables End scope at 67 +++ No Source Code Locators for _dylan_call_in +++ +++ Exported function definition _dylan_call_in_syscall +++ +++ starting code for _dylan_call_in_syscall +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:100}) 100 115}) rem "This is a dummy first basic block." #({tag 3:100}) [100->115] (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 65}) move N4/NSPILL-1, ecx move N5/NSPILL-0, eax call {constant "primitive_ensure_valid_teb"}, 0 #() [20->65] (level:0) is red with stack state with #({basic-block #() 65 90}) move N0/edi, eax st -1, N0/edi, 20 load-address-of-stack-arg-n #t, N2/edx, 0 push N2/edx push N5/NSPILL-0 move N3/edx, esp push N4/NSPILL-1 push N3/edx call-alien {constant "_dylan_callin_handler"}, 0 #() [65->90] (level:0) is red with stack state with #({basic-block #({tag 2:95}) 95 100}) add esp, esp, 8 add esp, esp, 8 move N1/eax, eax st 0, N0/edi, 20 move eax, N1/eax #({tag 2: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 +++ ending code for _dylan_call_in_syscall +++ +++ Frame sizes for _dylan_call_in_syscall: GC: 0, NC: 2 +++ +++ Live variable scopes for _dylan_call_in_syscall +++ Start scope at 7 with frame for no variables End scope at 61 +++ No Source Code Locators for _dylan_call_in_syscall +++ +++ Exported function definition _dylan_callin_internal +++ +++ starting code for _dylan_callin_internal +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 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 #({tag 1:25}) 25 45}) load-stack-arg-n #t, N0/edx, 0 load-stack-arg-n #t, N1/ecx, 1 ld N2/eax, N0/edx, 0 ld N3/edx, N0/edx, 4 #({tag 1:25}) [25->45] (level:0) is red with stack state with #({basic-block #({tag 2:45}) 45 50}) asl N4/edi, N1/ecx, 2 sub esp, esp, N4/edi move N5/edi, esp copy-words-down-w N5/edi, N3/edx, N1/ecx #({tag 2:45}) [45->50] (level:0) is red with stack state with #({basic-block #() 50 50}) call-alien N2/eax, 0 #() [50->50] (level:0) is red with stack state with #({basic-block #({tag 3:55}) 55 60}) #({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 +++ ending code for _dylan_callin_internal +++ +++ Live variable scopes for _dylan_callin_internal +++ Start scope at 7 with frame for no variables End scope at 34 +++ No Source Code Locators for _dylan_callin_internal +++ +++ Exported function definition _inside_dylan_ffi_barrier +++ +++ starting code for _inside_dylan_ffi_barrier +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:50}) 50 65}) rem "This is a dummy first basic block." #({tag 3:50}) [50->65] (level:0) is #f with stack state #f #({basic-block #() 5 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 30}) push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsGetValue@4"}, 0 #() [15->30] (level:0) is red with stack state with #({basic-block #() 30 35}, {basic-block #({tag 1:45}) 35 40}) move N0/eax, eax ld N1/eax, N0/eax, 20 beq {tag 1:45}, N1/eax, -1 #() [30->35] (level:0) is red with stack state with #({basic-block #({tag 1:45}) 35 40}) move N1/eax, 0 #({tag 1:45}) [35->40] (level:0) is red with stack state with #({basic-block #({tag 1:45}, {tag 2:45}) 45 50}) move eax, N1/eax #({tag 1:45}, {tag 2: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 +++ ending code for _inside_dylan_ffi_barrier +++ +++ Live variable scopes for _inside_dylan_ffi_barrier +++ Start scope at 3 with frame for no variables End scope at 24 +++ No Source Code Locators for _inside_dylan_ffi_barrier +++ +++ Defining function primitive_register_traced_roots in section init-code +++ +++ Exported function definition primitive_register_traced_roots +++ +++ starting code for primitive_register_traced_roots +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 55}) rem "This is a dummy first basic block." #() [5->55] (level:0) is green with stack state before #({basic-block #({tag 13:190}) 190 205}, {basic-block #({tag 1:80}) 80 85}) move N0/edx, eax load-stack-arg-n #f, N1/ebx, 0 load-stack-arg-n #f, N2/ecx, 1 load-stack-arg-n #f, N3/NSPILL--3, 2 load-stack-arg-n #f, N4/NSPILL--4, 3 load-stack-arg-n #f, N5/NSPILL--5, 4 load-stack-arg-n #f, N6/NSPILL--6, 5 load-stack-arg-n #f, N7/edi, 6 load-stack-arg-n #f, N8/NSPILL--8, 7 beq {tag 1:80}, N0/edx, N1/ebx #({tag 13:190}) [190->205] (level:0) is #f with stack state #f #({basic-block #() 55 75}) preserve-registers-entry allocate-local-area allocate-raw-area #() [55->75] (level:0) is red with stack state with #({basic-block #() 75 80}) push N1/ebx push N0/edx push N2/ecx call-alien {constant "_MMRegisterRootAmbig"}, 0 #() [75->80] (level:0) is red with stack state with #({basic-block #({tag 8:150}) 150 155}) add esp, esp, 12 #({tag 8:150}) [150->155] (level:0) is green with stack state with #({basic-block #({tag 9:85}) 85 105}, {basic-block #({tag 6:145}) 145 150}) beq {tag 6:145}, N3/NSPILL--3, N4/NSPILL--4 #({tag 9:85}) [85->105] (level:0) is red with stack state with #({basic-block #() 105 110}) push N4/NSPILL--4 push N3/NSPILL--3 push N5/NSPILL--5 call-alien {constant "_MMRegisterRootStatic"}, 0 #() [105->110] (level:0) is red with stack state with #({basic-block #({tag 6:145}) 145 150}) add esp, esp, 12 #({tag 6:145}) [145->150] (level:0) is green with stack state with #({basic-block #({tag 7:115}) 115 135}, {basic-block #({tag 4:155}) 145 145}) beq {tag 4:155}, N6/NSPILL--6, N7/edi #({tag 7:115}) [115->135] (level:0) is red with stack state with #({basic-block #() 135 140}) push N7/edi push N6/NSPILL--6 push N8/NSPILL--8 call-alien {constant "_MMRegisterRootExact"}, 0 #() [135->140] (level:0) is red with stack state with #({basic-block #({tag 4:155}) 145 145}) add esp, esp, 12 #({tag 4:155}) [145->145] (level:0) is green with stack state with #({basic-block #({tag 4:155}, {tag 10:155}) 155 160}) #({tag 4:155}, {tag 10:155}) [155->160] (level:0) is #f with stack state #f #({basic-block #({tag 3:140}, {tag 5:140}) 140 145}) preserve-registers-exit #({tag 3:140}, {tag 5:140}) [140->145] (level:0) is green with stack state #f #() rts-and-drop 32 #({tag 1:80}) [80->85] (level:0) is green with stack state before #({basic-block #({tag 12:175}) 175 190}, {basic-block #({tag 2:110}) 110 115}) beq {tag 2:110}, N3/NSPILL--3, N4/NSPILL--4 #({tag 12:175}) [175->190] (level:0) is #f with stack state #f #({basic-block #({tag 9:85}) 85 105}) preserve-registers-entry allocate-local-area allocate-raw-area #() [205->210] (level:0) is #f with stack state #f #() bra {tag 9:85} #({tag 2:110}) [110->115] (level:0) is green with stack state before #({basic-block #({tag 11:160}) 160 175}, {basic-block #({tag 3:140}) 140 140}) beq {tag 3:140}, N6/NSPILL--6, N7/edi #({tag 11:160}) [160->175] (level:0) is #f with stack state #f #({basic-block #({tag 7:115}) 115 135}) preserve-registers-entry allocate-local-area allocate-raw-area #() [210->215] (level:0) is #f with stack state #f #() bra {tag 7:115} #({tag 3:140}) [140->140] (level:0) is green with stack state before #({basic-block #({tag 3:140}, {tag 5:140}) 140 145}) +++ ending code for primitive_register_traced_roots +++ +++ Live variable scopes for primitive_register_traced_roots +++ Start scope at 21 with frame for no variables End scope at 79 Start scope at 80 no frame for no variables End scope at 96 Start scope at 97 with frame for no variables End scope at 107 +++ No Source Code Locators for primitive_register_traced_roots +++ +++ Exported function definition _call_dylan_exit_functions_internal +++ +++ starting code for _call_dylan_exit_functions_internal +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {constant "Kcall_application_exit_functionsVKeI"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for _call_dylan_exit_functions_internal +++ +++ Live variable scopes for _call_dylan_exit_functions_internal +++ Start scope at 7 with frame for no variables End scope at 11 +++ No Source Code Locators for _call_dylan_exit_functions_internal +++ +++ Exported function definition _call_dylan_exit_functions +++ +++ starting code for _call_dylan_exit_functions +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 15}) rem "This is a dummy first basic block." #() [5->15] (level:0) is green with stack state #f #({basic-block #() 15 20}) move ecx, 0 move eax, {constant "_call_dylan_exit_functions_internal"} #() [15->20] (level:0) is green with stack state #f #() jmp-alien {constant "_dylan_call_in_syscall"}, #[1, #"arg-count"], 0, #f, #f +++ ending code for _call_dylan_exit_functions +++ +++ No Source Code Locators for _call_dylan_exit_functions +++ +++ Defining function primitive_deregister_traced_roots in section init-code +++ +++ Exported function definition primitive_deregister_traced_roots +++ +++ starting code for primitive_deregister_traced_roots +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 3:110}) 110 125}) rem "This is a dummy first basic block." #({tag 3:110}) [110->125] (level:0) is #f with stack state #f #({basic-block #() 5 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:40}) 40 55}) move N1/edi, eax load-stack-arg-n #t, N2/NSPILL--1, 0 load-stack-arg-n #t, N3/NSPILL--2, 1 bne {tag 1:40}, {indirect-constant "Pstarted_unloading"}, 0 #() [25->30] (level:0) is red with stack state with #({basic-block #() 30 40}) call-alien {constant "_call_dylan_exit_functions"}, 0 #() [30->40] (level:0) is red with stack state with #({basic-block #({tag 1:40}) 40 55}) move {indirect-constant "Pstarted_unloading"}, 1 call-alien {constant "_primitive_mps_park"}, 0 #({tag 1:40}) [40->55] (level:0) is red with stack state with #({basic-block #() 55 75}) ld N0/edi, N1/edi, 0 push N0/edi call-alien {constant "_MMDeregisterRoot"}, 0 #() [55->75] (level:0) is red with stack state with #({basic-block #() 75 95}) add esp, esp, 4 ld N0/edi, N2/NSPILL--1, 0 push N0/edi call-alien {constant "_MMDeregisterRoot"}, 0 #() [75->95] (level:0) is red with stack state with #({basic-block #() 95 100}) add esp, esp, 4 ld N0/edi, N3/NSPILL--2, 0 push N0/edi call-alien {constant "_MMDeregisterRoot"}, 0 #() [95->100] (level:0) is red with stack state with #({basic-block #({tag 2:105}) 105 110}) add esp, esp, 4 #({tag 2:105}) [105->110] (level:0) is #f with stack state #f #({basic-block #() 100 105}) preserve-registers-exit #() [100->105] (level:0) is red with stack state #f #() rts-and-drop 8 +++ ending code for primitive_deregister_traced_roots +++ +++ Live variable scopes for primitive_deregister_traced_roots +++ Start scope at 3 with frame for no variables End scope at 77 +++ No Source Code Locators for primitive_deregister_traced_roots +++ +++ Exported function definition _dylan_init_thread_local +++ +++ starting code for _dylan_init_thread_local +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 5}) rem "This is a dummy first basic block." #() [5->5] (level:0) is green with stack state #f #({basic-block #() 5 10}) #() [5->10] (level:0) is green with stack state #f #() jmp {constant "_dylan_init_thread"}, 0, 0, #f, #f +++ ending code for _dylan_init_thread_local +++ +++ No Source Code Locators for _dylan_init_thread_local +++ +++ Defining function primitive_call_first_dylan_iep in section init-code +++ +++ Exported function definition primitive_call_first_dylan_iep +++ +++ starting code for primitive_call_first_dylan_iep +++ #() [0->5] (level:0) is green with stack state before #({basic-block #() 5 10}) rem "This is a dummy first basic block." #() [5->10] (level:0) is green with stack state #f #({basic-block #() 10 15}) move N0/eax, eax #() [10->15] (level:0) is green with stack state #f #() jmp N0/eax, 0, 0, #f, #f +++ ending code for primitive_call_first_dylan_iep +++ +++ No Source Code Locators for primitive_call_first_dylan_iep +++ +++ Defining function _init_dylan_data in section init-code +++ +++ Static function definition _init_dylan_data +++ +++ starting code for _init_dylan_data +++ #() [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 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 35}) push {constant "_dylan_import_end"} move eax, {constant "_dylan_import_start"} call {constant "primitive_fixup_unimported_dylan_data"}, 1 #() [20->35] (level:0) is red with stack state with #({basic-block #() 35 85}) push {constant "_dylan_fixup_end"} move eax, {constant "_dylan_fixup_start"} call {constant "primitive_fixup_imported_dylan_data"}, 1 #() [35->85] (level:0) is red with stack state with #({basic-block #() 85 85}) push {constant "Pexact_root"} push {constant "_dylan_vars_end"} push {constant "_dylan_vars_start"} push {constant "Pstatic_root"} push {constant "_dylan_objs_end"} push {constant "_dylan_objs_start"} push {constant "Pambig_root"} push {constant "_dylan_data_end"} move eax, {constant "_dylan_data_start"} call {constant "primitive_register_traced_roots"}, 1 #() [85->85] (level:0) is red with stack state with #({basic-block #({tag 1:90}) 90 95}) #({tag 1:90}) [90->95] (level:0) is #f with stack state #f #({basic-block #() 85 90}) preserve-registers-exit #() [85->90] (level:0) is red with stack state #f #() rts +++ ending code for _init_dylan_data +++ +++ Live variable scopes for _init_dylan_data +++ Start scope at 7 with frame for no variables End scope at 86 +++ No Source Code Locators for _init_dylan_data +++ +++ Defining function _call_init_dylan in section init-code +++ +++ Static function definition _call_init_dylan +++ +++ starting code for _call_init_dylan +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:20}) 20 35}) rem "This is a dummy first basic block." #({tag 2:20}) [20->35] (level:0) is #f with stack state #f #({basic-block #() 5 10}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->10] (level:0) is red with stack state with #({basic-block #() 10 10}) call {indirect-constant "_init_dylan_library"}, 0 #() [10->10] (level:0) is red with stack state with #({basic-block #({tag 1:15}) 15 20}) #({tag 1:15}) [15->20] (level:0) is #f with stack state #f #({basic-block #() 10 15}) preserve-registers-exit #() [10->15] (level:0) is red with stack state #f #() rts +++ ending code for _call_init_dylan +++ +++ Live variable scopes for _call_init_dylan +++ Start scope at 7 with frame for no variables End scope at 12 +++ No Source Code Locators for _call_init_dylan +++ +++ Defining function _dylan_initialize in section init-code +++ +++ Static function definition _dylan_initialize +++ +++ starting code for _dylan_initialize +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:80}) 80 95}) rem "This is a dummy first basic block." #({tag 2:80}) [80->95] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 55}) push 0 move N0/NSPILL-0, esp call-alien {constant "_init_dylan_data"}, 0 #() [20->55] (level:0) is red with stack state with #({basic-block #() 55 70}) get-teb N1/edi st -1, N1/edi, 20 push 0 push 0 push {constant "_call_init_dylan"} push N0/NSPILL-0 call-alien {constant "_dylan_init_thread_local"}, 0 #() [55->70] (level:0) is red with stack state with #({basic-block #({tag 1:75}) 75 80}) add esp, esp, 16 st 0, N1/edi, 20 move eax, 0 #({tag 1:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit #() [70->75] (level:0) is red with stack state #f #() rts +++ ending code for _dylan_initialize +++ +++ Frame sizes for _dylan_initialize: GC: 0, NC: 1 +++ +++ Live variable scopes for _dylan_initialize +++ Start scope at 5 with frame for no variables End scope at 62 +++ No Source Code Locators for _dylan_initialize +++ +++ Defining function _dylan_main in section init-code +++ +++ starting code for _dylan_main +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2: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 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 25}) push 0 call-alien {constant "_GetModuleHandleA@4"}, 0 #() [15->25] (level:0) is red with stack state with #({basic-block #() 25 45}) st eax, {constant "_module_hInstance"}, 0 call-alien {constant "_dylan_initialize"}, 0 #() [25->45] (level:0) is red with stack state with #({basic-block #() 45 55}) push {constant "Pexact_root"} push {constant "Pstatic_root"} move eax, {constant "Pambig_root"} call {constant "primitive_deregister_traced_roots"}, 1 #() [45->55] (level:0) is red with stack state with #({basic-block #() 55 55}) move eax, eax call {constant "primitive_exit_application"}, 1 #() [55->55] (level:0) is red with stack state with #({basic-block #({tag 1:60}) 60 65}) #({tag 1:60}) [60->65] (level:0) is #f with stack state #f #({basic-block #() 55 60}) preserve-registers-exit #() [55->60] (level:0) is red with stack state #f #() rts +++ ending code for _dylan_main +++ +++ Live variable scopes for _dylan_main +++ Start scope at 7 with frame for no variables End scope at 51 +++ No Source Code Locators for _dylan_main +++ +++ Defining function _dylan_main_0 in section init-code +++ +++ Exported function definition _dylan_main_0 +++ +++ starting code for _dylan_main_0 +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 26:540}) 540 555}) rem "This is a dummy first basic block." #({tag 26:540}) [540->555] (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 "_TlsAlloc@0"}, 0 #() [10->20] (level:0) is red with stack state with #({basic-block #() 20 25}, {basic-block #({tag 1:25}) 25 70}) move {indirect-constant "Pteb_tlv_index"}, eax bne {tag 1:25}, eax, -1 #() [20->25] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 70}) halt #({tag 1:25}) [25->70] (level:0) is red with stack state with #({basic-block #() 70 80}) st 0, {constant "Pmaster_gc_teb"}, 0 st 0, {constant "Pmaster_gc_teb"}, 4 st 0, {constant "Pmaster_teb"}, 0 st {constant "KPempty_listVKi"}, {constant "Pmaster_teb"}, 16 st {constant "KPunboundVKi"}, {constant "Pmaster_teb"}, 4 set-teb {constant "Pmaster_teb"} push {constant "Pmaster_teb"} push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [70->80] (level:0) is red with stack state with #({basic-block #() 80 95}) st 0, {constant "Pmaster_teb"}, 20 call-alien {constant "_dylan_init_memory_manager"}, 0 #() [80->95] (level:0) is red with stack state with #({basic-block #() 95 105}) or N0/edx, esp, 1020 push N0/edx call-alien {constant "_dylan_mm_register_thread"}, 0 #() [95->105] (level:0) is red with stack state with #({basic-block #() 105 120}, {basic-block #({tag 19:460}) 460 475}) add esp, esp, 4 beq {tag 19:460}, eax, 0 #() [105->120] (level:0) is red with stack state with #({basic-block #() 120 125}) push 0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [120->125] (level:0) is red with stack state with #({basic-block #({tag 19:460}) 460 475}) halt #({tag 19:460}) [460->475] (level:1) is green with stack state with #({basic-block #({tag 20:140}) 140 155}, {basic-block #({tag 19:460}) 460 475}) move N1/eax, {indirect-constant "Pruntime_thread_count"} add N2/edx, N1/eax, 1 conditional-move {tag 19:460}, {indirect-constant "Pruntime_thread_count"}, N2/edx, N1/eax #({tag 20:140}) [140->155] (level:0) is red with stack state with #({basic-block #() 155 165}) init-fpu push 0 call-alien {constant "_GetModuleHandleA@4"}, 0 #() [155->165] (level:0) is red with stack state with #({basic-block #() 165 185}) st eax, {constant "_module_hInstance"}, 0 call-alien {constant "_dylan_initialize"}, 0 #() [165->185] (level:0) is red with stack state with #({basic-block #() 185 195}) push {constant "Pexact_root"} push {constant "Pstatic_root"} move eax, {constant "Pambig_root"} call {constant "primitive_deregister_traced_roots"}, 1 #() [185->195] (level:0) is red with stack state with #({basic-block #() 195 205}, {basic-block #({tag 5:230}) 230 235}) ld N3/edx, {constant "Pmaster_gc_teb"}, 4 beq {tag 5:230}, N3/edx, 0 #() [195->205] (level:0) is red with stack state with #({basic-block #() 205 215}) push {constant "Pmaster_gc_teb"} call-alien {constant "_dylan_mm_deregister_thread_from_teb"}, 0 #() [205->215] (level:0) is red with stack state with #({basic-block #({tag 18:445}) 445 460}) add esp, esp, 4 st 0, {constant "Pmaster_gc_teb"}, 4 #({tag 18:445}) [445->460] (level:1) is green with stack state with #({basic-block #({tag 5:230}) 230 235}, {basic-block #({tag 18:445}) 445 460}) move N4/eax, {indirect-constant "Pruntime_thread_count"} sub N5/edx, N4/eax, 1 conditional-move {tag 18:445}, {indirect-constant "Pruntime_thread_count"}, N5/edx, N4/eax #({tag 5:230}) [230->235] (level:0) is green with stack state with #({basic-block #({tag 8:235}) 235 240}) move N6/NSPILL-0, {indirect-constant "Pteb_chain"} #({tag 8:235}) [235->240] (level:1) is green with stack state with #({basic-block #() 240 255}, {basic-block #({tag 7:390}) 390 400}) beq {tag 7:390}, N6/NSPILL-0, 0 #() [240->255] (level:1) is green with stack state with #({basic-block #() 255 265}, {basic-block #({tag 9:290}) 290 300}) add N7/edi, N6/NSPILL-0, 12 ld N8/edx, N7/edi, 4 beq {tag 9:290}, N8/edx, 0 #() [255->265] (level:1) is red with stack state with #({basic-block #() 265 275}) push N7/edi call-alien {constant "_dylan_mm_deregister_thread_from_teb"}, 0 #() [265->275] (level:1) is red with stack state with #({basic-block #({tag 17:430}) 430 445}) add esp, esp, 4 st 0, N7/edi, 4 #({tag 17:430}) [430->445] (level:2) is green with stack state with #({basic-block #({tag 9:290}) 290 300}, {basic-block #({tag 17:430}) 430 445}) move N9/eax, {indirect-constant "Pruntime_thread_count"} sub N10/edx, N9/eax, 1 conditional-move {tag 17:430}, {indirect-constant "Pruntime_thread_count"}, N10/edx, N9/eax #({tag 9:290}) [290->300] (level:1) is green with stack state with #({basic-block #({tag 15:425}) 425 430}) ld N6/NSPILL-0, N6/NSPILL-0, 4 sub N11/edx, N7/edi, 12 #({tag 15:425}) [425->430] (level:2) is green with stack state with #({basic-block #({tag 16:305}) 305 320}, {basic-block #({tag 15:425}) 425 430}) conditional-move {tag 15:425}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 16:305}) [305->320] (level:1) is red with stack state with #({basic-block #() 320 325}, {basic-block #({tag 11:325}) 325 330}) ld N12/eax, N11/edx, 4 ld N13/ebx, N11/edx, 8 bne {tag 11:325}, {indirect-constant "Pteb_chain"}, N11/edx #() [320->325] (level:1) is red with stack state with #({basic-block #({tag 12:330}) 330 335}) move {indirect-constant "Pteb_chain"}, N12/eax #({tag 12:330}) [330->335] (level:1) is red with stack state with #({basic-block #() 335 340}, {basic-block #({tag 13:340}) 340 360}) beq {tag 13:340}, N12/eax, 0 #() [335->340] (level:1) is red with stack state with #({basic-block #({tag 13:340}) 340 360}) st N13/ebx, N12/eax, 8 #({tag 13:340}) [340->360] (level:1) is red with stack state with #({basic-block #() 360 385}) move {indirect-constant "Pruntime_spin_lock"}, 0 ld N11/edx, N7/edi, -12 push N11/edx call-alien {constant "_MMDeregisterRoot"}, 0 #() [360->385] (level:1) is red with stack state with #({basic-block #() 385 390}) add esp, esp, 4 sub N11/edx, N7/edi, 12 push 336 push N11/edx call-alien {constant "_MMFreeMisc"}, 0 #() [385->390] (level:1) is red with stack state with #({basic-block #({tag 8:235}) 235 240}) add esp, esp, 8 #() [555->560] (level:0) is #f with stack state #f #() bra {tag 8:235} #({tag 7:390}) [390->400] (level:1) is red with stack state with #({basic-block #() 400 405}) push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsFree@4"}, 0 #() [400->405] (level:1) is red with stack state with #({basic-block #() 405 410}, {basic-block #({tag 4:410}) 410 420}) bne {tag 4:410}, {indirect-constant "Pruntime_thread_count"}, 0 #() [405->410] (level:1) is red with stack state with #({basic-block #({tag 4:410}) 410 420}) call-alien {constant "_dylan_shut_down_memory_manager"}, 0 #({tag 4:410}) [410->420] (level:1) is red with stack state with #({basic-block #() 420 420}) move eax, eax call {constant "primitive_exit_application"}, 1 #() [420->420] (level:1) is red with stack state with #({basic-block #({tag 23:505}) 505 510}) #({tag 23:505}) [505->510] (level:0) is #f with stack state #f #({basic-block #() 420 425}) preserve-registers-exit #() [420->425] (level:1) is red with stack state #f #() rts #({tag 11:325}) [325->330] (level:1) is red with stack state with #({basic-block #({tag 12:330}) 330 335}) st N12/eax, N13/ebx, 4 #() [560->565] (level:0) is #f with stack state #f #() bra {tag 12:330} +++ ending code for _dylan_main_0 +++ +++ Frame sizes for _dylan_main_0: GC: 0, NC: 1 +++ +++ Live variable scopes for _dylan_main_0 +++ Start scope at 7 with frame for no variables End scope at 497 +++ No Source Code Locators for _dylan_main_0 +++ +++ starting code for primitive_runtime_module_handle +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:30}) 30 45}) rem "This is a dummy first basic block." #({tag 2:30}) [30->45] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 20}) ld N0/eax, {constant "_module_hInstance"}, 0 move eax, N0/eax call {constant "primitive_wrap_machine_word"}, 1 #() [20->20] (level:0) is red with stack state with #({basic-block #({tag 1:25}) 25 30}) #({tag 1:25}) [25->30] (level:0) is #f with stack state #f #({basic-block #() 20 25}) preserve-registers-exit #() [20->25] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_runtime_module_handle +++ +++ Live variable scopes for primitive_runtime_module_handle +++ Start scope at 3 with frame for no variables End scope at 13 +++ No Source Code Locators for primitive_runtime_module_handle +++ +++ Exported function definition primitive_manual_allocate +++ +++ starting code for primitive_manual_allocate +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2: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 15}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->15] (level:0) is red with stack state with #({basic-block #() 15 25}) move eax, eax call {constant "primitive_unwrap_abstract_integer"}, 1 #() [15->25] (level:0) is red with stack state with #({basic-block #() 25 40}) push eax call-alien {constant "_mps__malloc"}, 0 #() [25->40] (level:0) is red with stack state with #({basic-block #() 40 40}) add esp, esp, 4 move eax, eax call {constant "primitive_wrap_machine_word"}, 1 #() [40->40] (level:0) is red with stack state with #({basic-block #({tag 1:45}) 45 50}) #({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_manual_allocate +++ +++ Live variable scopes for primitive_manual_allocate +++ Start scope at 3 with frame for no variables End scope at 22 +++ No Source Code Locators for primitive_manual_allocate +++ +++ Exported function definition primitive_manual_free +++ +++ starting code for primitive_manual_free +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 2:40}) 40 55}) rem "This is a dummy first basic block." #({tag 2:40}) [40->55] (level:0) is #f with stack state #f #({basic-block #() 5 20}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->20] (level:0) is red with stack state with #({basic-block #() 20 30}) ld N0/eax, eax, 4 push N0/eax call-alien {constant "_mps__free"}, 0 #() [20->30] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 40}) add esp, esp, 4 move eax, {constant "KPfalseVKi"} #({tag 1:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 30 35}) preserve-registers-exit #() [30->35] (level:0) is red with stack state #f #() rts-and-drop 0 +++ ending code for primitive_manual_free +++ +++ Live variable scopes for primitive_manual_free +++ Start scope at 3 with frame for no variables End scope at 20 +++ No Source Code Locators for primitive_manual_free +++ +++ Exported function definition _call_first_dylan_function +++ +++ starting code for _call_first_dylan_function +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 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 red with stack state before #({basic-block #({tag 2:40}) 40 55}) rem "This is a dummy first basic block." #({tag 2:40}) [40->55] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 30}) load-stack-arg-n #t, N0/eax, 0 load-stack-arg-n #t, N1/edx, 1 push N1/edx move eax, N0/eax call {constant "primitive_fixup_imported_dylan_data"}, 1 #() [30->30] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 40}) #({tag 1:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 30 35}) preserve-registers-exit #() [30->35] (level:0) is red with stack state #f #() rts +++ ending code for _spy_fixup_imported_dylan_data +++ +++ Live variable scopes for _spy_fixup_imported_dylan_data +++ Start scope at 7 with frame for no variables End scope at 18 +++ 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 red with stack state before #({basic-block #({tag 2:40}) 40 55}) rem "This is a dummy first basic block." #({tag 2:40}) [40->55] (level:0) is #f with stack state #f #({basic-block #() 5 30}) preserve-registers-entry allocate-local-area allocate-raw-area #() [5->30] (level:0) is red with stack state with #({basic-block #() 30 30}) load-stack-arg-n #t, N0/eax, 0 load-stack-arg-n #t, N1/edx, 1 push N1/edx move eax, N0/eax call {constant "primitive_fixup_unimported_dylan_data"}, 1 #() [30->30] (level:0) is red with stack state with #({basic-block #({tag 1:35}) 35 40}) #({tag 1:35}) [35->40] (level:0) is #f with stack state #f #({basic-block #() 30 35}) preserve-registers-exit #() [30->35] (level:0) is red with stack state #f #() rts +++ ending code for _spy_fixup_unimported_dylan_data +++ +++ Live variable scopes for _spy_fixup_unimported_dylan_data +++ Start scope at 7 with frame for no variables End scope at 18 +++ 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: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}) push 0 call-alien {constant "_ExitProcess@4"}, 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 _spy_exit_application +++ +++ Live variable scopes for _spy_exit_application +++ Start scope at 3 with frame for no variables End scope at 10 +++ 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:80}) 80 95}) rem "This is a dummy first basic block." #({tag 4:80}) [80->95] (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 65}) load-stack-arg-n #t, N0/NSPILL--1, 0 load-stack-arg-n #t, N1/NSPILL--2, 1 load-stack-arg-n #t, N2/NSPILL--3, 2 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:75}) 70 70}, {basic-block #({tag 1:45}) 45 65}) control-flow-link {tag 1:45} #({tag 2:75}) [70->70] (level:0) is red with stack state with #({basic-block #({tag 2:75}, {tag 3:75}) 75 80}) #({tag 2:75}, {tag 3:75}) [75->80] (level:0) is #f with stack state #f #({basic-block #() 70 75}) preserve-registers-exit #() [70->75] (level:0) is red with stack state #f #() rts #({tag 1:45}) [45->65] (level:1) is red with stack state with #({basic-block #() 65 70}) move eax, N0/NSPILL--1 move edi, N1/NSPILL--2 move esi, N2/NSPILL--3 call {constant "primitive_reset_guard_page"}, #[1, #"mlist"] #() [65->70] (level:1) is red with stack state with #({basic-block #() 70 70}, {basic-block #({tag 1:45}) 45 65}) end-cleanup {tag 1:45}, #[] #() [70->70] (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 +++ +++ starting code for _dylan_thread_trampoline@4 +++ #() [0->5] (level:0) is red with stack state before #({basic-block #({tag 23:555}) 555 570}) rem "This is a dummy first basic block." #({tag 23:555}) [555->570] (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 60}) load-stack-arg-n #t, N0/NSPILL--1, 0 push 336 call-alien {constant "_dylan__malloc__misc"}, 0 #() [20->60] (level:0) is red with stack state with #({basic-block #() 60 65}) add esp, esp, 4 move N6/edi, eax add N7/NSPILL-0, N6/edi, 12 add N8/edx, N7/NSPILL-0, 324 push N8/edx push N6/edi push N6/edi call-alien {constant "_MMRegisterRootAmbig"}, 0 #() [60->65] (level:0) is red with stack state with #({basic-block #({tag 16:485}) 485 490}) add esp, esp, 12 #({tag 16:485}) [485->490] (level:1) is green with stack state with #({basic-block #({tag 17:70}) 70 75}, {basic-block #({tag 16:485}) 485 490}) conditional-move {tag 16:485}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 17:70}) [70->75] (level:0) is red with stack state with #({basic-block #() 75 80}, {basic-block #({tag 1:80}) 80 150}) beq {tag 1:80}, {indirect-constant "Pteb_chain"}, 0 #() [75->80] (level:0) is red with stack state with #({basic-block #({tag 1:80}) 80 150}) st N6/edi, {indirect-constant "Pteb_chain"}, 8 #({tag 1:80}) [80->150] (level:0) is red with stack state with #({basic-block #() 150 180}) st {indirect-constant "Pteb_chain"}, N6/edi, 4 st 0, N6/edi, 8 move {indirect-constant "Pteb_chain"}, N6/edi move {indirect-constant "Pruntime_spin_lock"}, 0 add N3/edi, N7/NSPILL-0, 32 st 0, N7/NSPILL-0, 0 st 0, N7/NSPILL-0, 4 st 0, N3/edi, 0 st {constant "KPempty_listVKi"}, N3/edi, 16 st {constant "KPunboundVKi"}, N3/edi, 4 set-teb N3/edi push N3/edi push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [150->180] (level:0) is red with stack state with #({basic-block #() 180 190}) st 0, N3/edi, 20 st -1, N3/edi, 20 sub N5/edi, N3/edi, 32 or N9/edx, esp, 1020 push N9/edx call-alien {constant "_dylan_mm_register_thread"}, 0 #() [180->190] (level:0) is red with stack state with #({basic-block #() 190 205}, {basic-block #({tag 14:470}) 470 485}) add esp, esp, 4 beq {tag 14:470}, eax, 0 #() [190->205] (level:0) is red with stack state with #({basic-block #() 205 210}) push 0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [205->210] (level:0) is red with stack state with #({basic-block #({tag 14:470}) 470 485}) halt #({tag 14:470}) [470->485] (level:1) is green with stack state with #({basic-block #({tag 15:225}) 225 260}, {basic-block #({tag 14:470}) 470 485}) move N10/eax, {indirect-constant "Pruntime_thread_count"} add N11/edx, N10/eax, 1 conditional-move {tag 14:470}, {indirect-constant "Pruntime_thread_count"}, N11/edx, N10/eax #({tag 15:225}) [225->260] (level:0) is red with stack state with #({basic-block #() 260 290}) init-fpu push 0 move N2/NSPILL-0, esp ld G1/GSPILL-0, N0/NSPILL--1, 0 push 4 push N0/NSPILL--1 call-alien {constant "_dylan__free__root"}, 0 #() [260->290] (level:0) is red with stack state with #({basic-block #() 290 305}) add esp, esp, 8 push 0 push G1/GSPILL-0 push {constant "_trampoline_body"} push N2/NSPILL-0 call-alien {constant "_dylan_init_thread"}, 0 #() [290->305] (level:0) is red with stack state with #({basic-block #() 305 315}) add esp, esp, 16 push N5/edi call-alien {constant "_dylan_mm_deregister_thread_from_teb"}, 0 #() [305->315] (level:0) is red with stack state with #({basic-block #({tag 12:455}) 455 470}) add esp, esp, 4 st 0, N5/edi, 4 #({tag 12:455}) [455->470] (level:1) is green with stack state with #({basic-block #({tag 13:330}) 330 345}, {basic-block #({tag 12:455}) 455 470}) move N12/eax, {indirect-constant "Pruntime_thread_count"} sub N13/edx, N12/eax, 1 conditional-move {tag 12:455}, {indirect-constant "Pruntime_thread_count"}, N13/edx, N12/eax #({tag 13:330}) [330->345] (level:0) is red with stack state with #({basic-block #() 345 350}) push 0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [345->350] (level:0) is red with stack state with #({basic-block #({tag 10:450}) 450 455}) sub N14/edx, N5/edi, 12 #({tag 10:450}) [450->455] (level:1) is green with stack state with #({basic-block #({tag 11:355}) 355 370}, {basic-block #({tag 10:450}) 450 455}) conditional-move {tag 10:450}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 11:355}) [355->370] (level:0) is red with stack state with #({basic-block #() 370 375}, {basic-block #({tag 6:375}) 375 380}) ld N15/eax, N14/edx, 4 ld N16/ebx, N14/edx, 8 bne {tag 6:375}, {indirect-constant "Pteb_chain"}, N14/edx #() [370->375] (level:0) is red with stack state with #({basic-block #({tag 7:380}) 380 385}) move {indirect-constant "Pteb_chain"}, N15/eax #({tag 7:380}) [380->385] (level:0) is red with stack state with #({basic-block #() 385 390}, {basic-block #({tag 8:390}) 390 410}) beq {tag 8:390}, N15/eax, 0 #() [385->390] (level:0) is red with stack state with #({basic-block #({tag 8:390}) 390 410}) st N16/ebx, N15/eax, 8 #({tag 8:390}) [390->410] (level:0) is red with stack state with #({basic-block #() 410 435}) move {indirect-constant "Pruntime_spin_lock"}, 0 ld N14/edx, N5/edi, -12 push N14/edx call-alien {constant "_MMDeregisterRoot"}, 0 #() [410->435] (level:0) is red with stack state with #({basic-block #() 435 445}) add esp, esp, 4 sub N14/edx, N5/edi, 12 push 336 push N14/edx call-alien {constant "_MMFreeMisc"}, 0 #() [435->445] (level:0) is red with stack state with #({basic-block #({tag 18:490}) 490 495}) add esp, esp, 8 move eax, 0 #({tag 18:490}) [490->495] (level:0) is #f with stack state #f #({basic-block #() 445 450}) preserve-registers-exit #() [445->450] (level:0) is red with stack state #f #() rts-and-drop 4 #({tag 6:375}) [375->380] (level:0) is red with stack state with #({basic-block #({tag 7:380}) 380 385}) st N15/eax, N16/ebx, 4 #() [570->575] (level:0) is #f with stack state #f #() bra {tag 7:380} +++ ending code for _dylan_thread_trampoline@4 +++ +++ Frame sizes for _dylan_thread_trampoline@4: GC: 1, NC: 1 +++ +++ Live variable scopes for _dylan_thread_trampoline@4 +++ Start scope at 6 with frame for no variables End scope at 466 +++ No Source Code Locators for _dylan_thread_trampoline@4 +++ +++ Defining function _DylanDllEntry@12 in section init-code +++ +++ starting code for _DylanDllEntry@12 +++ #() [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 48:845}) 845 860}) load-stack-arg-n #f, N0/eax, 0 load-stack-arg-n #f, N1/edx, 1 rem "eliminated" beq {tag 48:845}, 1, N1/edx #() [25->30] (level:0) is green with stack state before #({basic-block #() 30 35}, {basic-block #({tag 46:815}) 815 830}) beq {tag 46:815}, 2, N1/edx #() [30->35] (level:0) is green with stack state before #({basic-block #() 35 40}, {basic-block #({tag 45:800}) 800 815}) beq {tag 45:800}, 3, N1/edx #() [35->40] (level:0) is green with stack state before #({basic-block #({tag 15:40}, {tag 9:40}, {tag 5:40}) 40 45}, {basic-block #({tag 42:755}) 755 770}) beq {tag 42:755}, 0, N1/edx #({tag 15:40}, {tag 9:40}, {tag 5:40}) [40->45] (level:0) is green with stack state before #({basic-block #({tag 27:45}) 45 50}) move eax, -1 #({tag 27:45}) [45->50] (level:0) is green with stack state #f #() rts-and-drop 12 #({tag 48:845}) [845->860] (level:0) is #f with stack state #f #({basic-block #({tag 1:50}) 50 60}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 1:50}) [50->60] (level:0) is red with stack state with #({basic-block #() 60 70}) st N0/eax, {constant "_module_hInstance"}, 0 call-alien {constant "_TlsAlloc@0"}, 0 #() [60->70] (level:0) is red with stack state with #({basic-block #() 70 75}, {basic-block #({tag 6:75}) 75 120}) move {indirect-constant "Pteb_tlv_index"}, eax bne {tag 6:75}, eax, -1 #() [70->75] (level:0) is red with stack state with #({basic-block #({tag 6:75}) 75 120}) halt #({tag 6:75}) [75->120] (level:0) is red with stack state with #({basic-block #() 120 130}) st 0, {constant "Pmaster_gc_teb"}, 0 st 0, {constant "Pmaster_gc_teb"}, 4 st 0, {constant "Pmaster_teb"}, 0 st {constant "KPempty_listVKi"}, {constant "Pmaster_teb"}, 16 st {constant "KPunboundVKi"}, {constant "Pmaster_teb"}, 4 set-teb {constant "Pmaster_teb"} push {constant "Pmaster_teb"} push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [120->130] (level:0) is red with stack state with #({basic-block #() 130 145}) st 0, {constant "Pmaster_teb"}, 20 call-alien {constant "_dylan_init_memory_manager"}, 0 #() [130->145] (level:0) is red with stack state with #({basic-block #() 145 155}) or N3/edx, esp, 1020 push N3/edx call-alien {constant "_dylan_mm_register_thread"}, 0 #() [145->155] (level:0) is red with stack state with #({basic-block #() 155 170}, {basic-block #({tag 36:690}) 690 705}) add esp, esp, 4 beq {tag 36:690}, eax, 0 #() [155->170] (level:0) is red with stack state with #({basic-block #() 170 175}) push 0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [170->175] (level:0) is red with stack state with #({basic-block #({tag 36:690}) 690 705}) halt #({tag 36:690}) [690->705] (level:1) is green with stack state with #({basic-block #({tag 37:190}) 190 200}, {basic-block #({tag 36:690}) 690 705}) move N4/eax, {indirect-constant "Pruntime_thread_count"} add N5/edx, N4/eax, 1 conditional-move {tag 36:690}, {indirect-constant "Pruntime_thread_count"}, N5/edx, N4/eax #({tag 37:190}) [190->200] (level:0) is red with stack state with #({basic-block #({tag 2:200}) 200 215}) init-fpu call-alien {constant "_dylan_initialize"}, 0 #({tag 2:200}) [200->215] (level:0) is red with stack state with #({basic-block #({tag 26:630}) 630 635}) push 0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #({tag 26:630}) [630->635] (level:0) is green with stack state with #({basic-block #({tag 38:705}) 705 710}) move eax, -1 #({tag 38:705}) [705->710] (level:0) is #f with stack state #f #({basic-block #({tag 27:45}) 45 50}) preserve-registers-exit #() [860->865] (level:0) is #f with stack state #f #() bra {tag 27:45} #({tag 46:815}) [815->830] (level:0) is #f with stack state #f #({basic-block #({tag 2:200}) 200 215}) preserve-registers-entry allocate-local-area allocate-raw-area #() [865->870] (level:0) is #f with stack state #f #() bra {tag 2:200} #({tag 45:800}) [800->815] (level:0) is #f with stack state #f #({basic-block #({tag 3:215}) 215 225}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 3:215}) [215->225] (level:0) is red with stack state with #({basic-block #() 225 235}) push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsGetValue@4"}, 0 #() [225->235] (level:0) is red with stack state with #({basic-block #() 235 250}, {basic-block #({tag 26:630}) 630 635}) move N6/eax, eax beq {tag 26:630}, N6/eax, 0 #() [235->250] (level:0) is red with stack state with #({basic-block #() 250 260}) sub N7/edi, N6/eax, 32 push N7/edi call-alien {constant "_dylan_mm_deregister_thread_from_teb"}, 0 #() [250->260] (level:0) is red with stack state with #({basic-block #({tag 34:675}) 675 690}) add esp, esp, 4 st 0, N7/edi, 4 #({tag 34:675}) [675->690] (level:1) is green with stack state with #({basic-block #({tag 35:275}) 275 290}, {basic-block #({tag 34:675}) 675 690}) move N8/eax, {indirect-constant "Pruntime_thread_count"} sub N9/edx, N8/eax, 1 conditional-move {tag 34:675}, {indirect-constant "Pruntime_thread_count"}, N9/edx, N8/eax #({tag 35:275}) [275->290] (level:0) is red with stack state with #({basic-block #() 290 295}) push 0 push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsSetValue@8"}, 0 #() [290->295] (level:0) is red with stack state with #({basic-block #({tag 32:670}) 670 675}) sub N10/edx, N7/edi, 12 #({tag 32:670}) [670->675] (level:1) is green with stack state with #({basic-block #({tag 33:300}) 300 315}, {basic-block #({tag 32:670}) 670 675}) conditional-move {tag 32:670}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 33:300}) [300->315] (level:0) is red with stack state with #({basic-block #() 315 320}, {basic-block #({tag 11:320}) 320 325}) ld N11/eax, N10/edx, 4 ld N12/ebx, N10/edx, 8 bne {tag 11:320}, {indirect-constant "Pteb_chain"}, N10/edx #() [315->320] (level:0) is red with stack state with #({basic-block #({tag 12:325}) 325 330}) move {indirect-constant "Pteb_chain"}, N11/eax #({tag 12:325}) [325->330] (level:0) is red with stack state with #({basic-block #() 330 335}, {basic-block #({tag 13:335}) 335 355}) beq {tag 13:335}, N11/eax, 0 #() [330->335] (level:0) is red with stack state with #({basic-block #({tag 13:335}) 335 355}) st N12/ebx, N11/eax, 8 #({tag 13:335}) [335->355] (level:0) is red with stack state with #({basic-block #() 355 380}) move {indirect-constant "Pruntime_spin_lock"}, 0 ld N10/edx, N7/edi, -12 push N10/edx call-alien {constant "_MMDeregisterRoot"}, 0 #() [355->380] (level:0) is red with stack state with #({basic-block #() 380 385}) add esp, esp, 4 sub N10/edx, N7/edi, 12 push 336 push N10/edx call-alien {constant "_MMFreeMisc"}, 0 #() [380->385] (level:0) is red with stack state with #({basic-block #({tag 26:630}) 630 635}) add esp, esp, 8 #() [870->875] (level:0) is #f with stack state #f #() bra {tag 26:630} #({tag 42:755}) [755->770] (level:0) is #f with stack state #f #({basic-block #({tag 4:385}) 385 405}) preserve-registers-entry allocate-local-area allocate-raw-area #({tag 4:385}) [385->405] (level:0) is red with stack state with #({basic-block #() 405 415}) push {constant "Pexact_root"} push {constant "Pstatic_root"} move eax, {constant "Pambig_root"} call {constant "primitive_deregister_traced_roots"}, 1 #() [405->415] (level:0) is red with stack state with #({basic-block #() 415 425}, {basic-block #({tag 16:450}) 450 455}) ld N13/edx, {constant "Pmaster_gc_teb"}, 4 beq {tag 16:450}, N13/edx, 0 #() [415->425] (level:0) is red with stack state with #({basic-block #() 425 435}) push {constant "Pmaster_gc_teb"} call-alien {constant "_dylan_mm_deregister_thread_from_teb"}, 0 #() [425->435] (level:0) is red with stack state with #({basic-block #({tag 31:655}) 655 670}) add esp, esp, 4 st 0, {constant "Pmaster_gc_teb"}, 4 #({tag 31:655}) [655->670] (level:1) is green with stack state with #({basic-block #({tag 16:450}) 450 455}, {basic-block #({tag 31:655}) 655 670}) move N14/eax, {indirect-constant "Pruntime_thread_count"} sub N15/edx, N14/eax, 1 conditional-move {tag 31:655}, {indirect-constant "Pruntime_thread_count"}, N15/edx, N14/eax #({tag 16:450}) [450->455] (level:0) is green with stack state with #({basic-block #({tag 19:455}) 455 460}) move N16/NSPILL-0, {indirect-constant "Pteb_chain"} #({tag 19:455}) [455->460] (level:1) is green with stack state with #({basic-block #() 460 475}, {basic-block #({tag 18:610}) 610 620}) beq {tag 18:610}, N16/NSPILL-0, 0 #() [460->475] (level:1) is green with stack state with #({basic-block #() 475 485}, {basic-block #({tag 20:510}) 510 520}) add N17/edi, N16/NSPILL-0, 12 ld N18/edx, N17/edi, 4 beq {tag 20:510}, N18/edx, 0 #() [475->485] (level:1) is red with stack state with #({basic-block #() 485 495}) push N17/edi call-alien {constant "_dylan_mm_deregister_thread_from_teb"}, 0 #() [485->495] (level:1) is red with stack state with #({basic-block #({tag 30:640}) 640 655}) add esp, esp, 4 st 0, N17/edi, 4 #({tag 30:640}) [640->655] (level:2) is green with stack state with #({basic-block #({tag 20:510}) 510 520}, {basic-block #({tag 30:640}) 640 655}) move N19/eax, {indirect-constant "Pruntime_thread_count"} sub N20/edx, N19/eax, 1 conditional-move {tag 30:640}, {indirect-constant "Pruntime_thread_count"}, N20/edx, N19/eax #({tag 20:510}) [510->520] (level:1) is green with stack state with #({basic-block #({tag 28:635}) 635 640}) ld N16/NSPILL-0, N16/NSPILL-0, 4 sub N21/edx, N17/edi, 12 #({tag 28:635}) [635->640] (level:2) is green with stack state with #({basic-block #({tag 29:525}) 525 540}, {basic-block #({tag 28:635}) 635 640}) conditional-move {tag 28:635}, {indirect-constant "Pruntime_spin_lock"}, 1, 0 #({tag 29:525}) [525->540] (level:1) is red with stack state with #({basic-block #() 540 545}, {basic-block #({tag 22:545}) 545 550}) ld N22/eax, N21/edx, 4 ld N23/ebx, N21/edx, 8 bne {tag 22:545}, {indirect-constant "Pteb_chain"}, N21/edx #() [540->545] (level:1) is red with stack state with #({basic-block #({tag 23:550}) 550 555}) move {indirect-constant "Pteb_chain"}, N22/eax #({tag 23:550}) [550->555] (level:1) is red with stack state with #({basic-block #() 555 560}, {basic-block #({tag 24:560}) 560 580}) beq {tag 24:560}, N22/eax, 0 #() [555->560] (level:1) is red with stack state with #({basic-block #({tag 24:560}) 560 580}) st N23/ebx, N22/eax, 8 #({tag 24:560}) [560->580] (level:1) is red with stack state with #({basic-block #() 580 605}) move {indirect-constant "Pruntime_spin_lock"}, 0 ld N21/edx, N17/edi, -12 push N21/edx call-alien {constant "_MMDeregisterRoot"}, 0 #() [580->605] (level:1) is red with stack state with #({basic-block #() 605 610}) add esp, esp, 4 sub N21/edx, N17/edi, 12 push 336 push N21/edx call-alien {constant "_MMFreeMisc"}, 0 #() [605->610] (level:1) is red with stack state with #({basic-block #({tag 19:455}) 455 460}) add esp, esp, 8 #() [875->880] (level:0) is #f with stack state #f #() bra {tag 19:455} #({tag 11:320}) [320->325] (level:0) is red with stack state with #({basic-block #({tag 12:325}) 325 330}) st N11/eax, N12/ebx, 4 #() [880->885] (level:0) is #f with stack state #f #() bra {tag 12:325} #({tag 18:610}) [610->620] (level:1) is red with stack state with #({basic-block #() 620 625}) push {indirect-constant "Pteb_tlv_index"} call-alien {constant "_TlsFree@4"}, 0 #() [620->625] (level:1) is red with stack state with #({basic-block #() 625 630}, {basic-block #({tag 26:630}) 630 635}) bne {tag 26:630}, {indirect-constant "Pruntime_thread_count"}, 0 #() [625->630] (level:1) is red with stack state with #({basic-block #({tag 26:630}) 630 635}) call-alien {constant "_dylan_shut_down_memory_manager"}, 0 #() [885->890] (level:0) is #f with stack state #f #() bra {tag 26:630} #({tag 22:545}) [545->550] (level:1) is red with stack state with #({basic-block #({tag 23:550}) 550 555}) st N22/eax, N23/ebx, 4 #() [890->895] (level:0) is #f with stack state #f #() bra {tag 23:550} +++ ending code for _DylanDllEntry@12 +++ +++ Frame sizes for _DylanDllEntry@12: GC: 0, NC: 1 +++ +++ Live variable scopes for _DylanDllEntry@12 +++ Start scope at 55 with frame for no variables End scope at 270 Start scope at 271 no frame for no variables End scope at 290 Start scope at 291 with frame for no variables End scope at 488 +++ No Source Code Locators for _DylanDllEntry@12 +++ +++ Defining function primitive_fixup_imported_dylan_data in section init-code +++ +++ Exported function definition primitive_fixup_imported_dylan_data +++ +++ starting code for primitive_fixup_imported_dylan_data +++ #() [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 #({tag 22:235}) 235 250}, {basic-block #({tag 1:205}) 205 210}) move N0/eax, eax load-stack-arg-n #f, N1/NSPILL--1, 0 bhs {tag 1:205}, N0/eax, N1/NSPILL--1 #({tag 22:235}) [235->250] (level:0) is #f with stack state #f #({basic-block #() 20 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [20->25] (level:0) is green with stack state with #({basic-block #({tag 2:25}) 25 35}) move N2/edi, N0/eax #({tag 2:25}) [25->35] (level:1) is green with stack state with #({basic-block #({tag 4:35}) 35 50}) ld N3/NSPILL-1, N2/edi, 0 add N12/edi, N2/edi, 4 #({tag 4:35}) [35->50] (level:2) is green with stack state with #({basic-block #({tag 3:195}) 195 205}, {basic-block #({tag 7:75}) 75 80}) ldb N6/ebx, N12/edi, 0 add N12/edi, N12/edi, 1 bne {tag 7:75}, N6/ebx, 0 #({tag 3:195}) [195->205] (level:1) is green with stack state with #({basic-block #({tag 19:225}) 225 230}, {basic-block #({tag 2:25}) 25 35}) move N2/edi, N12/edi blo {tag 2:25}, N2/edi, N1/NSPILL--1 #({tag 19:225}) [225->230] (level:0) is green with stack state with #({basic-block #({tag 21:230}) 230 235}) move eax, 1 #({tag 21:230}) [230->235] (level:0) is #f with stack state #f #({basic-block #({tag 20:210}) 210 215}) preserve-registers-exit #({tag 20:210}) [210->215] (level:0) is green with stack state #f #() rts-and-drop 4 #({tag 1:205}) [205->210] (level:0) is green with stack state before #({basic-block #({tag 20:210}) 210 215}) move eax, 1 #() [250->255] (level:0) is #f with stack state #f #() bra {tag 20:210} #({tag 7:75}) [75->80] (level:2) is green with stack state with #({basic-block #({tag 8:80}) 80 95}, {basic-block #({tag 9:50}) 50 65}) beq {tag 9:50}, N6/ebx, 255 #({tag 8:80}) [80->95] (level:2) is green with stack state with #({basic-block #() 95 105}, {basic-block #({tag 17:215}) 215 220}) ld N7/edx, N12/edi, 0 ld N8/NSPILL-0, N7/edx, 0 beq {tag 17:215}, N8/NSPILL-0, 3 #() [95->105] (level:2) is green with stack state with #({basic-block #({tag 13:170}) 170 175}) add N12/edi, N12/edi, 4 move N11/eax, N3/NSPILL-1 #({tag 13:170}) [170->175] (level:3) is green with stack state with #({basic-block #({tag 4:35}) 35 50}, {basic-block #({tag 12:135}) 135 150}) beq {tag 4:35}, N6/ebx, 0 #({tag 12:135}) [135->150] (level:2) is green with stack state with #({basic-block #({tag 15:150}) 150 160}, {basic-block #({tag 14:105}) 105 120}) ldb N10/edx, N12/edi, 0 add N12/edi, N12/edi, 1 beq {tag 14:105}, N10/edx, 255 #({tag 15:150}) [150->160] (level:2) is green with stack state with #({basic-block #({tag 16:160}) 160 170}) asl N10/edx, N10/edx, 2 add N11/eax, N11/eax, N10/edx #({tag 16:160}) [160->170] (level:2) is green with stack state with #({basic-block #({tag 13:170}) 170 175}) st N8/NSPILL-0, N11/eax, 0 sub N6/ebx, N6/ebx, 1 #() [255->260] (level:0) is #f with stack state #f #() bra {tag 13:170} #({tag 9:50}) [50->65] (level:2) is green with stack state with #({basic-block #() 65 75}, {basic-block #({tag 8:80}) 80 95}) ldh N6/ebx, N12/edi, 0 add N12/edi, N12/edi, 2 bne {tag 8:80}, N6/ebx, 65535 #() [65->75] (level:2) is green with stack state with #({basic-block #({tag 8:80}) 80 95}) ld N6/ebx, N12/edi, 0 add N12/edi, N12/edi, 4 #() [260->265] (level:0) is #f with stack state #f #() bra {tag 8:80} #({tag 17:215}) [215->220] (level:2) is brown with stack state with #({basic-block #({tag 6:175}) 175 195}) move N4/NSPILL-0, N12/edi #({tag 6:175}) [175->195] (level:2) is red with stack state with #({basic-block #({tag 18:220}) 220 225}) move eax, {constant "Knot_yet_relocated_string"} move ebx, {constant "KerrorVKd"} move ecx, 1 call-indirect ebx, 4, 1 #({tag 18:220}) [220->225] (level:2) is yellow with stack state with #({basic-block #({tag 3:195}) 195 205}) move N12/edi, N4/NSPILL-0 #() [265->270] (level:0) is #f with stack state #f #() bra {tag 3:195} #({tag 14:105}) [105->120] (level:2) is green with stack state with #({basic-block #() 120 135}, {basic-block #({tag 15:150}) 150 160}) ldh N10/edx, N12/edi, 0 add N12/edi, N12/edi, 2 bne {tag 15:150}, N10/edx, 65535 #() [120->135] (level:2) is green with stack state with #({basic-block #({tag 16:160}) 160 170}) ld N10/edx, N12/edi, 0 add N12/edi, N12/edi, 4 add N11/eax, N3/NSPILL-1, N10/edx #() [270->275] (level:0) is #f with stack state #f #() bra {tag 16:160} +++ ending code for primitive_fixup_imported_dylan_data +++ +++ Frame sizes for primitive_fixup_imported_dylan_data: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_fixup_imported_dylan_data +++ Start scope at 9 with frame for no variables End scope at 42 +++ No Source Code Locators for primitive_fixup_imported_dylan_data +++ +++ Defining function primitive_fixup_unimported_dylan_data in section init-code +++ +++ Exported function definition primitive_fixup_unimported_dylan_data +++ +++ starting code for primitive_fixup_unimported_dylan_data +++ #() [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 #({tag 32:415}) 415 430}, {basic-block #({tag 1:385}) 385 390}) move N0/eax, eax load-stack-arg-n #f, N1/NSPILL--1, 0 bhs {tag 1:385}, N0/eax, N1/NSPILL--1 #({tag 32:415}) [415->430] (level:0) is #f with stack state #f #({basic-block #() 20 25}) preserve-registers-entry allocate-local-area allocate-raw-area #() [20->25] (level:0) is green with stack state with #({basic-block #({tag 2:25}) 25 35}) move N2/edi, N0/eax #({tag 2:25}) [25->35] (level:1) is green with stack state with #({basic-block #({tag 4:35}) 35 50}) ld N3/NSPILL-0, N2/edi, 0 add N18/edi, N2/edi, 4 #({tag 4:35}) [35->50] (level:3) is green with stack state with #({basic-block #() 50 65}, {basic-block #({tag 5:215}) 215 230}) ld N5/edx, N18/edi, 0 add N18/edi, N18/edi, 4 beq {tag 5:215}, N5/edx, #ex00000000FFFFFFFF #() [50->65] (level:2) is green with stack state with #({basic-block #({tag 3:375}) 375 385}, {basic-block #({tag 7:90}) 90 95}) ldb N6/ebx, N18/edi, 0 add N18/edi, N18/edi, 1 bne {tag 7:90}, N6/ebx, 0 #({tag 3:375}) [375->385] (level:1) is green with stack state with #({basic-block #({tag 29:405}) 405 410}, {basic-block #({tag 2:25}) 25 35}) move N2/edi, N18/edi blo {tag 2:25}, N2/edi, N1/NSPILL--1 #({tag 29:405}) [405->410] (level:0) is green with stack state with #({basic-block #({tag 31:410}) 410 415}) move eax, 1 #({tag 31:410}) [410->415] (level:0) is #f with stack state #f #({basic-block #({tag 30:390}) 390 395}) preserve-registers-exit #({tag 30:390}) [390->395] (level:0) is green with stack state #f #() rts-and-drop 4 #({tag 1:385}) [385->390] (level:0) is green with stack state before #({basic-block #({tag 30:390}) 390 395}) move eax, 1 #() [430->435] (level:0) is #f with stack state #f #() bra {tag 30:390} #({tag 5:215}) [215->230] (level:3) is green with stack state with #({basic-block #({tag 3:375}) 375 385}, {basic-block #({tag 17:255}) 255 260}) ldb N12/ebx, N18/edi, 0 add N18/edi, N18/edi, 1 beq {tag 3:375}, N12/ebx, 0 #({tag 17:255}) [255->260] (level:3) is green with stack state with #({basic-block #({tag 18:260}) 260 275}, {basic-block #({tag 19:230}) 230 245}) beq {tag 19:230}, N12/ebx, 255 #({tag 18:260}) [260->275] (level:3) is green with stack state with #({basic-block #() 275 285}, {basic-block #({tag 27:395}) 395 400}) ld N13/edx, N18/edi, 0 ld N14/NSPILL-1, N13/edx, 0 beq {tag 27:395}, N14/NSPILL-1, 3 #() [275->285] (level:3) is green with stack state with #({basic-block #({tag 23:350}) 350 355}) add N18/edi, N18/edi, 4 move N17/eax, N3/NSPILL-0 #({tag 23:350}) [350->355] (level:4) is green with stack state with #({basic-block #({tag 4:35}) 35 50}, {basic-block #({tag 22:315}) 315 330}) beq {tag 4:35}, N12/ebx, 0 #({tag 22:315}) [315->330] (level:3) is green with stack state with #({basic-block #({tag 25:330}) 330 340}, {basic-block #({tag 24:285}) 285 300}) ldb N16/edx, N18/edi, 0 add N18/edi, N18/edi, 1 beq {tag 24:285}, N16/edx, 255 #({tag 25:330}) [330->340] (level:3) is green with stack state with #({basic-block #({tag 26:340}) 340 350}) asl N16/edx, N16/edx, 2 add N17/eax, N17/eax, N16/edx #({tag 26:340}) [340->350] (level:3) is green with stack state with #({basic-block #({tag 23:350}) 350 355}) st N14/NSPILL-1, N17/eax, 0 sub N12/ebx, N12/ebx, 1 #() [435->440] (level:0) is #f with stack state #f #() bra {tag 23:350} #({tag 7:90}) [90->95] (level:2) is green with stack state with #({basic-block #({tag 8:95}) 95 110}, {basic-block #({tag 9:65}) 65 80}) beq {tag 9:65}, N6/ebx, 255 #({tag 8:95}) [95->110] (level:2) is green with stack state with #({basic-block #() 110 115}, {basic-block #({tag 27:395}) 395 400}) ld N7/ecx, N18/edi, 0 ld N8/NSPILL-1, N7/ecx, 0 beq {tag 27:395}, N8/NSPILL-1, 3 #() [110->115] (level:2) is green with stack state with #({basic-block #({tag 11:115}) 115 125}) add N18/edi, N18/edi, 4 #({tag 11:115}) [115->125] (level:3) is green with stack state with #({basic-block #() 125 140}, {basic-block #({tag 10:140}) 140 145}) and N9/ecx, N5/edx, 255 beq {tag 10:140}, N9/ecx, 255 #() [125->140] (level:2) is green with stack state with #({basic-block #({tag 11:115}) 115 125}) asl N9/ecx, N9/ecx, 2 ld N8/NSPILL-1, N8/NSPILL-1, N9/ecx asr N5/edx, N5/edx, 8 #() [440->445] (level:0) is #f with stack state #f #() bra {tag 11:115} #({tag 19:230}) [230->245] (level:3) is green with stack state with #({basic-block #() 245 255}, {basic-block #({tag 18:260}) 260 275}) ldh N12/ebx, N18/edi, 0 add N18/edi, N18/edi, 2 bne {tag 18:260}, N12/ebx, 65535 #() [245->255] (level:3) is green with stack state with #({basic-block #({tag 18:260}) 260 275}) ld N12/ebx, N18/edi, 0 add N18/edi, N18/edi, 4 #() [445->450] (level:0) is #f with stack state #f #() bra {tag 18:260} #({tag 27:395}) [395->400] (level:2) is brown with stack state with #({basic-block #({tag 6:355}) 355 375}) move N4/NSPILL-0, N18/edi #({tag 6:355}) [355->375] (level:2) is red with stack state with #({basic-block #({tag 28:400}) 400 405}) move eax, {constant "Knot_yet_relocated_string"} move ebx, {constant "KerrorVKd"} move ecx, 1 call-indirect ebx, 4, 1 #({tag 28:400}) [400->405] (level:2) is yellow with stack state with #({basic-block #({tag 3:375}) 375 385}) move N18/edi, N4/NSPILL-0 #() [450->455] (level:0) is #f with stack state #f #() bra {tag 3:375} #({tag 24:285}) [285->300] (level:3) is green with stack state with #({basic-block #() 300 315}, {basic-block #({tag 25:330}) 330 340}) ldh N16/edx, N18/edi, 0 add N18/edi, N18/edi, 2 bne {tag 25:330}, N16/edx, 65535 #() [300->315] (level:3) is green with stack state with #({basic-block #({tag 26:340}) 340 350}) ld N16/edx, N18/edi, 0 add N18/edi, N18/edi, 4 add N17/eax, N3/NSPILL-0, N16/edx #() [455->460] (level:0) is #f with stack state #f #() bra {tag 26:340} #({tag 9:65}) [65->80] (level:2) is green with stack state with #({basic-block #() 80 90}, {basic-block #({tag 8:95}) 95 110}) ldh N6/ebx, N18/edi, 0 add N18/edi, N18/edi, 2 bne {tag 8:95}, N6/ebx, 65535 #() [80->90] (level:2) is green with stack state with #({basic-block #({tag 8:95}) 95 110}) ld N6/ebx, N18/edi, 0 add N18/edi, N18/edi, 4 #() [460->465] (level:0) is #f with stack state #f #() bra {tag 8:95} #({tag 10:140}) [140->145] (level:3) is green with stack state with #({basic-block #({tag 13:210}) 210 215}) move N11/eax, N3/NSPILL-0 #({tag 13:210}) [210->215] (level:4) is green with stack state with #({basic-block #({tag 4:35}) 35 50}, {basic-block #({tag 12:175}) 175 190}) beq {tag 4:35}, N6/ebx, 0 #({tag 12:175}) [175->190] (level:3) is green with stack state with #({basic-block #({tag 15:190}) 190 200}, {basic-block #({tag 14:145}) 145 160}) ldb N10/edx, N18/edi, 0 add N18/edi, N18/edi, 1 beq {tag 14:145}, N10/edx, 255 #({tag 15:190}) [190->200] (level:3) is green with stack state with #({basic-block #({tag 16:200}) 200 210}) asl N10/edx, N10/edx, 2 add N11/eax, N11/eax, N10/edx #({tag 16:200}) [200->210] (level:3) is green with stack state with #({basic-block #({tag 13:210}) 210 215}) st N8/NSPILL-1, N11/eax, 0 sub N6/ebx, N6/ebx, 1 #() [465->470] (level:0) is #f with stack state #f #() bra {tag 13:210} #({tag 14:145}) [145->160] (level:3) is green with stack state with #({basic-block #() 160 175}, {basic-block #({tag 15:190}) 190 200}) ldh N10/edx, N18/edi, 0 add N18/edi, N18/edi, 2 bne {tag 15:190}, N10/edx, 65535 #() [160->175] (level:3) is green with stack state with #({basic-block #({tag 16:200}) 200 210}) ld N10/edx, N18/edi, 0 add N18/edi, N18/edi, 4 add N11/eax, N3/NSPILL-0, N10/edx #() [470->475] (level:0) is #f with stack state #f #() bra {tag 16:200} +++ ending code for primitive_fixup_unimported_dylan_data +++ +++ Frame sizes for primitive_fixup_unimported_dylan_data: GC: 0, NC: 2 +++ +++ Live variable scopes for primitive_fixup_unimported_dylan_data +++ Start scope at 9 with frame for no variables End scope at 55 +++ No Source Code Locators for primitive_fixup_unimported_dylan_data +++ +++ Exported function definition primitive_reset_guard_page +++ +++ starting code for primitive_reset_guard_page +++ #() [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:30}) 30 70}) add esp, esp, 8 pop N1/edx sub N0/ebx, eax, 4 blo {tag 1:30}, esp, N0/ebx #() [25->30] (level:0) is #f with stack state #f #({basic-block #({tag 1:30}) 30 70}) move esp, N0/ebx #({tag 1:30}) [30->70] (level:0) is #f with stack state #f #({basic-block #() 70 105}) push N1/edx sub esp, esp, 4 move N2/ebx, esp push N2/ebx push esi push edi push eax call-alien {constant "_VirtualProtect@16"}, 0 #() [70->105] (level:0) is #f with stack state #f #({basic-block #({tag 2:105}) 105 115}, {basic-block #({tag 3:115}) 115 125}) add esp, esp, 4 pop N1/edx ld G3/eax, N1/edx, 0 move N6/eax, G3/eax ld N4/ebx, N6/eax, 4 asr N4/ebx, N4/ebx, 2 bne {tag 3:115}, N4/ebx, 1 #({tag 2:105}) [105->115] (level:0) is #f with stack state #f #({basic-block #({tag 5:160}) 160 175}) ld eax, N6/eax, 8 reset-values #({tag 5:160}) [160->175] (level:0) is #f with stack state #f #({basic-block #() 175 175}) push eax move eax, N1/edx call {constant "primitive_nlx"}, 1 #() [175->175] (level:0) is #f with stack state #f #() #({tag 3:115}) [115->125] (level:0) is #f with stack state #f #({basic-block #() 125 150}, {basic-block #({tag 4:150}) 150 160}) st-teb N4/ebx, 32 beq {tag 4:150}, N4/ebx, 0 #() [125->150] (level:0) is #f with stack state #f #({basic-block #({tag 5:160}) 160 175}) add esi, N6/eax, 8 ld eax, esi, 0 ld-teb-address N5/edi, 36 copy-words-down-w N5/edi, esi, N4/ebx set-values #() [175->180] (level:0) is #f with stack state #f #() bra {tag 5:160} #({tag 4:150}) [150->160] (level:0) is #f with stack state #f #({basic-block #({tag 5:160}) 160 175}) move eax, {constant "KPfalseVKi"} set-values #() [180->185] (level:0) is #f with stack state #f #() bra {tag 5:160} +++ ending code for primitive_reset_guard_page +++ +++ No Source Code Locators for primitive_reset_guard_page +++