diff --git a/Scripts/CallStackWalk.py b/Scripts/CallStackWalk.py index c6bcca7..8a1fe6c 100644 --- a/Scripts/CallStackWalk.py +++ b/Scripts/CallStackWalk.py @@ -4,7 +4,7 @@ A script that tries to determine the call stack Run the application with the debugger, suspend the debugger, select a thread and finally run the script. -Copyright (c) 1990-2018 Hex-Rays +Copyright (c) 1990-2019 Hex-Rays ALL RIGHTS RESERVED. """ import ida_ua diff --git a/Scripts/DrvsDispatch.py b/Scripts/DrvsDispatch.py index 34b11e0..47fcc09 100644 --- a/Scripts/DrvsDispatch.py +++ b/Scripts/DrvsDispatch.py @@ -2,7 +2,7 @@ A script to demonstrate how to send commands to the debugger and then parse and use the output in IDA -Copyright (c) 1990-2018 Hex-Rays +Copyright (c) 1990-2019 Hex-Rays ALL RIGHTS RESERVED. """ diff --git a/Scripts/ExchainDump.py b/Scripts/ExchainDump.py index 265fafa..5356f3a 100644 --- a/Scripts/ExchainDump.py +++ b/Scripts/ExchainDump.py @@ -2,7 +2,7 @@ This script shows how to send debugger commands and use the result in IDA -Copyright (c) 1990-2009 Hex-Rays +Copyright (c) 1990-2019 Hex-Rays ALL RIGHTS RESERVED. """ diff --git a/Scripts/FindInstructions.py b/Scripts/FindInstructions.py index e55abd7..71223ea 100644 --- a/Scripts/FindInstructions.py +++ b/Scripts/FindInstructions.py @@ -13,7 +13,7 @@ The general syntax is: * To specify in which context the instructions should be assembled, pass asm_where=ea: find("jmp dword ptr [esp]", asm_where=here()) -Copyright (c) 1990-2018 Hex-Rays +Copyright (c) 1990-2019 Hex-Rays ALL RIGHTS RESERVED. """ from __future__ import print_function diff --git a/Scripts/SEHGraph.py b/Scripts/SEHGraph.py index 75f8f7c..f940b09 100644 --- a/Scripts/SEHGraph.py +++ b/Scripts/SEHGraph.py @@ -4,7 +4,7 @@ A script that graphs all the exception handlers in a given process It will be easy to see what thread uses what handler and what handlers are commonly used between threads -Copyright (c) 1990-2018 Hex-Rays +Copyright (c) 1990-2019 Hex-Rays ALL RIGHTS RESERVED. """ from __future__ import print_function diff --git a/Scripts/VaDump.py b/Scripts/VaDump.py index bc196c2..124e13a 100644 --- a/Scripts/VaDump.py +++ b/Scripts/VaDump.py @@ -2,7 +2,7 @@ This script shows how to send debugger commands and use the result in IDA -Copyright (c) 1990-2009 Hex-Rays +Copyright (c) 1990-2019 Hex-Rays ALL RIGHTS RESERVED. """ diff --git a/Scripts/VirusTotal.py b/Scripts/VirusTotal.py index 261ee4b..b627412 100644 --- a/Scripts/VirusTotal.py +++ b/Scripts/VirusTotal.py @@ -2,7 +2,7 @@ from __future__ import print_function # ----------------------------------------------------------------------- # VirusTotal IDA Plugin # By Elias Bachaalany -# (c) Hex-Rays 2011 +# (c) Hex-Rays 2011-2019 # # Special thanks: # - VirusTotal team diff --git a/api_contents.txt b/api_contents.txt index 2211045..1e75cd5 100644 --- a/api_contents.txt +++ b/api_contents.txt @@ -2,6 +2,7 @@ 'DBG_Hooks_dbg_bpt', 'DBG_Hooks_dbg_bpt_changed', 'DBG_Hooks_dbg_exception', + 'DBG_Hooks_dbg_finished_loading_bpts', 'DBG_Hooks_dbg_information', 'DBG_Hooks_dbg_library_load', 'DBG_Hooks_dbg_library_unload', @@ -11,6 +12,7 @@ 'DBG_Hooks_dbg_process_start', 'DBG_Hooks_dbg_request_error', 'DBG_Hooks_dbg_run_to', + 'DBG_Hooks_dbg_started_loading_bpts', 'DBG_Hooks_dbg_step_into', 'DBG_Hooks_dbg_step_over', 'DBG_Hooks_dbg_step_until_ret', @@ -185,6 +187,7 @@ 'IDP_Hooks_ev_demangle_name', 'IDP_Hooks_ev_emu_insn', 'IDP_Hooks_ev_endbinary', + 'IDP_Hooks_ev_ending_undo', 'IDP_Hooks_ev_equal_reglocs', 'IDP_Hooks_ev_extract_address', 'IDP_Hooks_ev_find_op_value', @@ -225,6 +228,7 @@ 'IDP_Hooks_ev_is_sane_insn', 'IDP_Hooks_ev_is_sp_based', 'IDP_Hooks_ev_is_switch', + 'IDP_Hooks_ev_last_cb_before_loader', 'IDP_Hooks_ev_loader', 'IDP_Hooks_ev_lower_func_type', 'IDP_Hooks_ev_max_ptr_size', @@ -250,6 +254,7 @@ 'IDP_Hooks_ev_out_special_item', 'IDP_Hooks_ev_realcvt', 'IDP_Hooks_ev_rename', + 'IDP_Hooks_ev_replaying_undo', 'IDP_Hooks_ev_set_idp_options', 'IDP_Hooks_ev_set_proc_options', 'IDP_Hooks_ev_setup_til', @@ -285,6 +290,7 @@ 'UI_Hooks_get_custom_viewer_hint', 'UI_Hooks_get_ea_hint', 'UI_Hooks_get_item_hint', + 'UI_Hooks_get_widget_config', 'UI_Hooks_hook', 'UI_Hooks_idcstart', 'UI_Hooks_idcstop', @@ -299,6 +305,7 @@ 'UI_Hooks_saved', 'UI_Hooks_saving', 'UI_Hooks_screen_ea_changed', + 'UI_Hooks_set_widget_config', 'UI_Hooks_suspend', 'UI_Hooks_term', 'UI_Hooks_unhook', @@ -327,8 +334,6 @@ '_ask_long__varargs__', '_ask_seg', '_ask_seg__varargs__', - '_choose_get_embedded_chobj_pointer', - '_decompile', '_kludge_use_TPopupMenu', '_ll_call_helper', '_ll_call_helper__varargs__', @@ -339,6 +344,7 @@ '_ll_make_num', '_ll_make_ref', '_ll_new_block', + 'accepts_small_udts', 'accepts_udts', 'action_ctx_base_t__get_form', 'action_ctx_base_t__get_form_title', @@ -351,8 +357,6 @@ 'action_ctx_base_t_cur_ea_set', 'action_ctx_base_t_cur_enum_get', 'action_ctx_base_t_cur_enum_set', - 'action_ctx_base_t_cur_extracted_ea_get', - 'action_ctx_base_t_cur_extracted_ea_set', 'action_ctx_base_t_cur_fchunk_get', 'action_ctx_base_t_cur_fchunk_set', 'action_ctx_base_t_cur_flags_get', @@ -365,6 +369,8 @@ 'action_ctx_base_t_cur_strmem_set', 'action_ctx_base_t_cur_struc_get', 'action_ctx_base_t_cur_struc_set', + 'action_ctx_base_t_cur_value_get', + 'action_ctx_base_t_cur_value_set', 'action_ctx_base_t_focus_get', 'action_ctx_base_t_focus_set', 'action_ctx_base_t_has_flag', @@ -475,6 +481,7 @@ 'apply_callee_tinfo', 'apply_cdecl', 'apply_idasgn_to', + 'apply_metadata', 'apply_named_type', 'apply_once_tinfo_and_name', 'apply_startup_sig', @@ -509,6 +516,8 @@ 'argloc_t_get_rrel', 'argloc_t_get_rrel__SWIG_0', 'argloc_t_get_rrel__SWIG_1', + 'argloc_t_has_reg', + 'argloc_t_has_stkoff', 'argloc_t_is_badloc', 'argloc_t_is_custom', 'argloc_t_is_ea', @@ -542,6 +551,126 @@ 'argpart_t_size_get', 'argpart_t_size_set', 'argpart_t_swap', + 'argpartvec_t___eq__', + 'argpartvec_t___getitem__', + 'argpartvec_t___len__', + 'argpartvec_t___ne__', + 'argpartvec_t___setitem__', + 'argpartvec_t__del', + 'argpartvec_t_add_unique', + 'argpartvec_t_at', + 'argpartvec_t_begin', + 'argpartvec_t_begin__SWIG_0', + 'argpartvec_t_begin__SWIG_1', + 'argpartvec_t_capacity', + 'argpartvec_t_clear', + 'argpartvec_t_empty', + 'argpartvec_t_end', + 'argpartvec_t_end__SWIG_0', + 'argpartvec_t_end__SWIG_1', + 'argpartvec_t_erase', + 'argpartvec_t_erase__SWIG_0', + 'argpartvec_t_erase__SWIG_1', + 'argpartvec_t_extract', + 'argpartvec_t_find', + 'argpartvec_t_find__SWIG_0', + 'argpartvec_t_find__SWIG_1', + 'argpartvec_t_grow', + 'argpartvec_t_has', + 'argpartvec_t_inject', + 'argpartvec_t_insert', + 'argpartvec_t_pop_back', + 'argpartvec_t_push_back', + 'argpartvec_t_push_back__SWIG_0', + 'argpartvec_t_push_back__SWIG_1', + 'argpartvec_t_qclear', + 'argpartvec_t_reserve', + 'argpartvec_t_resize', + 'argpartvec_t_resize__SWIG_0', + 'argpartvec_t_resize__SWIG_1', + 'argpartvec_t_size', + 'argpartvec_t_swap', + 'argpartvec_t_truncate', + 'array_of_bitsets___eq__', + 'array_of_bitsets___getitem__', + 'array_of_bitsets___len__', + 'array_of_bitsets___ne__', + 'array_of_bitsets___setitem__', + 'array_of_bitsets__del', + 'array_of_bitsets_add_unique', + 'array_of_bitsets_at', + 'array_of_bitsets_begin', + 'array_of_bitsets_begin__SWIG_0', + 'array_of_bitsets_begin__SWIG_1', + 'array_of_bitsets_capacity', + 'array_of_bitsets_clear', + 'array_of_bitsets_empty', + 'array_of_bitsets_end', + 'array_of_bitsets_end__SWIG_0', + 'array_of_bitsets_end__SWIG_1', + 'array_of_bitsets_erase', + 'array_of_bitsets_erase__SWIG_0', + 'array_of_bitsets_erase__SWIG_1', + 'array_of_bitsets_extract', + 'array_of_bitsets_find', + 'array_of_bitsets_find__SWIG_0', + 'array_of_bitsets_find__SWIG_1', + 'array_of_bitsets_grow', + 'array_of_bitsets_has', + 'array_of_bitsets_inject', + 'array_of_bitsets_insert', + 'array_of_bitsets_pop_back', + 'array_of_bitsets_push_back', + 'array_of_bitsets_push_back__SWIG_0', + 'array_of_bitsets_push_back__SWIG_1', + 'array_of_bitsets_qclear', + 'array_of_bitsets_reserve', + 'array_of_bitsets_resize', + 'array_of_bitsets_resize__SWIG_0', + 'array_of_bitsets_resize__SWIG_1', + 'array_of_bitsets_size', + 'array_of_bitsets_swap', + 'array_of_bitsets_truncate', + 'array_of_ivlsets___eq__', + 'array_of_ivlsets___getitem__', + 'array_of_ivlsets___len__', + 'array_of_ivlsets___ne__', + 'array_of_ivlsets___setitem__', + 'array_of_ivlsets__del', + 'array_of_ivlsets_add_unique', + 'array_of_ivlsets_at', + 'array_of_ivlsets_begin', + 'array_of_ivlsets_begin__SWIG_0', + 'array_of_ivlsets_begin__SWIG_1', + 'array_of_ivlsets_capacity', + 'array_of_ivlsets_clear', + 'array_of_ivlsets_empty', + 'array_of_ivlsets_end', + 'array_of_ivlsets_end__SWIG_0', + 'array_of_ivlsets_end__SWIG_1', + 'array_of_ivlsets_erase', + 'array_of_ivlsets_erase__SWIG_0', + 'array_of_ivlsets_erase__SWIG_1', + 'array_of_ivlsets_extract', + 'array_of_ivlsets_find', + 'array_of_ivlsets_find__SWIG_0', + 'array_of_ivlsets_find__SWIG_1', + 'array_of_ivlsets_grow', + 'array_of_ivlsets_has', + 'array_of_ivlsets_inject', + 'array_of_ivlsets_insert', + 'array_of_ivlsets_pop_back', + 'array_of_ivlsets_push_back', + 'array_of_ivlsets_push_back__SWIG_0', + 'array_of_ivlsets_push_back__SWIG_1', + 'array_of_ivlsets_qclear', + 'array_of_ivlsets_reserve', + 'array_of_ivlsets_resize', + 'array_of_ivlsets_resize__SWIG_0', + 'array_of_ivlsets_resize__SWIG_1', + 'array_of_ivlsets_size', + 'array_of_ivlsets_swap', + 'array_of_ivlsets_truncate', 'array_of_rangesets___eq__', 'array_of_rangesets___getitem__', 'array_of_rangesets___len__', @@ -734,6 +863,8 @@ 'auto_recreate_insn', 'auto_unmark', 'auto_wait', + 'auto_wait_range', + 'backup_metadata', 'banner', 'base2file', 'beep', @@ -764,6 +895,108 @@ 'bitfield_type_data_t_swap', 'bitfield_type_data_t_width_get', 'bitfield_type_data_t_width_set', + 'bitset_t___eq__', + 'bitset_t___ge__', + 'bitset_t___gt__', + 'bitset_t___le__', + 'bitset_t___lt__', + 'bitset_t___ne__', + 'bitset_t_add', + 'bitset_t_add__SWIG_0', + 'bitset_t_add__SWIG_1', + 'bitset_t_add__SWIG_2', + 'bitset_t_back', + 'bitset_t_begin', + 'bitset_t_clear', + 'bitset_t_compare', + 'bitset_t_copy', + 'bitset_t_count', + 'bitset_t_count__SWIG_0', + 'bitset_t_count__SWIG_1', + 'bitset_t_cut_at', + 'bitset_t_dstr', + 'bitset_t_empty', + 'bitset_t_end', + 'bitset_t_fill_with_ones', + 'bitset_t_front', + 'bitset_t_has', + 'bitset_t_has_all', + 'bitset_t_has_any', + 'bitset_t_has_common', + 'bitset_t_inc', + 'bitset_t_includes', + 'bitset_t_intersect', + 'bitset_t_is_subset_of', + 'bitset_t_itat', + 'bitset_t_itv', + 'bitset_t_last', + 'bitset_t_shift_down', + 'bitset_t_sub', + 'bitset_t_sub__SWIG_0', + 'bitset_t_sub__SWIG_1', + 'bitset_t_sub__SWIG_2', + 'bitset_t_swap', + 'block_chains_begin', + 'block_chains_clear', + 'block_chains_end', + 'block_chains_erase', + 'block_chains_find', + 'block_chains_free', + 'block_chains_get', + 'block_chains_insert', + 'block_chains_iterator_t___eq__', + 'block_chains_iterator_t___ne__', + 'block_chains_iterator_t_x_get', + 'block_chains_iterator_t_x_set', + 'block_chains_new', + 'block_chains_next', + 'block_chains_prev', + 'block_chains_size', + 'block_chains_t__print', + 'block_chains_t_dstr', + 'block_chains_t_get_chain', + 'block_chains_t_get_chain__SWIG_0', + 'block_chains_t_get_chain__SWIG_1', + 'block_chains_t_get_chain__SWIG_2', + 'block_chains_t_get_chain__SWIG_3', + 'block_chains_t_get_reg_chain', + 'block_chains_t_get_reg_chain__SWIG_0', + 'block_chains_t_get_reg_chain__SWIG_1', + 'block_chains_t_get_stk_chain', + 'block_chains_t_get_stk_chain__SWIG_0', + 'block_chains_t_get_stk_chain__SWIG_1', + 'block_chains_vec_t___getitem__', + 'block_chains_vec_t___len__', + 'block_chains_vec_t___setitem__', + 'block_chains_vec_t_at', + 'block_chains_vec_t_begin', + 'block_chains_vec_t_begin__SWIG_0', + 'block_chains_vec_t_begin__SWIG_1', + 'block_chains_vec_t_capacity', + 'block_chains_vec_t_clear', + 'block_chains_vec_t_empty', + 'block_chains_vec_t_end', + 'block_chains_vec_t_end__SWIG_0', + 'block_chains_vec_t_end__SWIG_1', + 'block_chains_vec_t_erase', + 'block_chains_vec_t_erase__SWIG_0', + 'block_chains_vec_t_erase__SWIG_1', + 'block_chains_vec_t_extract', + 'block_chains_vec_t_grow', + 'block_chains_vec_t_inject', + 'block_chains_vec_t_insert', + 'block_chains_vec_t_pop_back', + 'block_chains_vec_t_push_back', + 'block_chains_vec_t_push_back__SWIG_0', + 'block_chains_vec_t_push_back__SWIG_1', + 'block_chains_vec_t_qclear', + 'block_chains_vec_t_reserve', + 'block_chains_vec_t_resize', + 'block_chains_vec_t_resize__SWIG_0', + 'block_chains_vec_t_resize__SWIG_1', + 'block_chains_vec_t_size', + 'block_chains_vec_t_swap', + 'block_chains_vec_t_truncate', 'bookmarks_t_erase', 'bookmarks_t_find_index', 'bookmarks_t_get', @@ -952,8 +1185,10 @@ 'calc_dataseg', 'calc_def_align', 'calc_default_idaplace_flags', + 'calc_dflags', 'calc_dist', 'calc_fixup_size', + 'calc_func_metadata', 'calc_func_size', 'calc_idasgn_state', 'calc_max_align', @@ -1343,6 +1578,7 @@ 'cfunc_t_print_func', 'cfunc_t_refcnt_get', 'cfunc_t_refcnt_set', + 'cfunc_t_refresh_func_ctext', 'cfunc_t_release', 'cfunc_t_remove_unused_labels', 'cfunc_t_save_user_cmts', @@ -1405,6 +1641,7 @@ 'cfuncptr_t_print_func', 'cfuncptr_t_refcnt_get', 'cfuncptr_t_refcnt_set', + 'cfuncptr_t_refresh_func_ctext', 'cfuncptr_t_release', 'cfuncptr_t_remove_unused_labels', 'cfuncptr_t_reset', @@ -1438,6 +1675,42 @@ 'cgoto_t_compare', 'cgoto_t_label_num_get', 'cgoto_t_label_num_set', + 'chain_keeper_t_back', + 'chain_keeper_t_for_all_chains', + 'chain_keeper_t_front', + 'chain_t___lt__', + 'chain_t__print', + 'chain_t_append_list', + 'chain_t_clear_varnum', + 'chain_t_dstr', + 'chain_t_endoff', + 'chain_t_flags_get', + 'chain_t_flags_set', + 'chain_t_get_reg', + 'chain_t_get_stkoff', + 'chain_t_includes', + 'chain_t_is_fake', + 'chain_t_is_inited', + 'chain_t_is_overlapped', + 'chain_t_is_passreg', + 'chain_t_is_reg', + 'chain_t_is_replaced', + 'chain_t_is_stkoff', + 'chain_t_is_term', + 'chain_t_key', + 'chain_t_overlap', + 'chain_t_set_inited', + 'chain_t_set_overlapped', + 'chain_t_set_replaced', + 'chain_t_set_term', + 'chain_t_set_value', + 'chain_t_varnum_get', + 'chain_t_varnum_set', + 'chain_t_width_get', + 'chain_t_width_set', + 'chain_visitor_t_parent_get', + 'chain_visitor_t_parent_set', + 'chain_visitor_t_visit_chain', 'change_segment_status', 'change_storage_type', 'channel_redir_t_fd_get', @@ -1457,12 +1730,11 @@ 'char_flag', 'check_bpt', 'check_process_exit', - 'check_type_trait', - 'check_type_trait__SWIG_0', - 'check_type_trait__SWIG_1', + 'checkout_hexrays_license', 'choose_activate', + 'choose_choose', 'choose_close', - 'choose_create', + 'choose_create_embedded_chobj', 'choose_entry', 'choose_enum', 'choose_enum_by_value', @@ -1699,37 +1971,6 @@ 'codegen_t_mba_set', 'collect_stack_trace', 'compact_til', - 'compare', - 'compare', - 'compare', - 'compare__SWIG_10', - 'compare__SWIG_11', - 'compare__SWIG_19', - 'compare__SWIG_23', - 'compare__SWIG_24', - 'compare__SWIG_25', - 'compare__SWIG_26', - 'compare__SWIG_27', - 'compare__SWIG_28', - 'compare__SWIG_29', - 'compare__SWIG_30', - 'compare__SWIG_31', - 'compare__SWIG_32', - 'compare__SWIG_33', - 'compare__SWIG_34', - 'compare__SWIG_35', - 'compare__SWIG_36', - 'compare__SWIG_37', - 'compare__SWIG_38', - 'compare__SWIG_39', - 'compare__SWIG_40', - 'compare__SWIG_41', - 'compare__SWIG_42', - 'compare__SWIG_5', - 'compare__SWIG_6', - 'compare__SWIG_7', - 'compare__SWIG_7', - 'compare__SWIG_9', 'compare_tinfo', 'compile_idc_file', 'compile_idc_snippet', @@ -1740,7 +1981,6 @@ 'compiler_info_t_defalign_set', 'compiler_info_t_id_get', 'compiler_info_t_id_set', - 'compiler_info_t_set_64bit_pointer_size', 'compiler_info_t_size_b_get', 'compiler_info_t_size_b_set', 'compiler_info_t_size_e_get', @@ -1794,6 +2034,8 @@ 'create_oword', 'create_packed_real', 'create_qword', + 'create_simple_diff_handler', + 'create_simple_idb_diff_handler', 'create_source_viewer', 'create_strlit', 'create_struct', @@ -2037,6 +2279,7 @@ 'decode_preceding_insn', 'decode_prev_insn', 'decompile', + 'decompile_func', 'decompile_many', 'deep_copy_idcv', 'default_compiler', @@ -2116,6 +2359,9 @@ 'delete_aloc_visitor_t', 'delete_argloc_t', 'delete_argpart_t', + 'delete_argpartvec_t', + 'delete_array_of_bitsets', + 'delete_array_of_ivlsets', 'delete_array_of_rangesets', 'delete_array_parameters_t', 'delete_array_type_data_t', @@ -2124,6 +2370,10 @@ 'delete_bgcolors_t', 'delete_bit_bound_t', 'delete_bitfield_type_data_t', + 'delete_bitset_t', + 'delete_block_chains_iterator_t', + 'delete_block_chains_t', + 'delete_block_chains_vec_t', 'delete_boolvec_t', 'delete_boundaries_iterator_t', 'delete_boundaries_t', @@ -2152,6 +2402,9 @@ 'delete_cfunc_t', 'delete_cfuncptr_t', 'delete_cgoto_t', + 'delete_chain_keeper_t', + 'delete_chain_t', + 'delete_chain_visitor_t', 'delete_channel_redir_t', 'delete_chooser_item_attrs_t', 'delete_cif_t', @@ -2194,6 +2447,7 @@ 'delete_edge_t', 'delete_enum_const_t', 'delete_enum_member_t', + 'delete_enum_member_vec_t', 'delete_enum_member_visitor_t', 'delete_enum_type_data_t', 'delete_enumplace_t', @@ -2201,19 +2455,36 @@ 'delete_exception_info_t', 'delete_excinfo_t', 'delete_excvec_t', + 'delete_extra_cmt_t', 'delete_extra_cmts', + 'delete_extra_cmts_t', 'delete_fixup_data_t', 'delete_fixup_info_t', 'delete_fnum_array', 'delete_fnumber_t', + 'delete_frame_desc_t', + 'delete_frame_mem_t', + 'delete_frame_mems_t', + 'delete_func_info_and_frequency_t', + 'delete_func_info_and_frequency_vec_t', + 'delete_func_info_and_pattern_t', + 'delete_func_info_and_pattern_vec_t', + 'delete_func_info_base_t', + 'delete_func_info_pattern_and_frequency_t', + 'delete_func_info_pattern_and_frequency_vec_t', + 'delete_func_info_t', + 'delete_func_info_vec_t', 'delete_func_item_iterator_t', + 'delete_func_md_diff_handler_t', 'delete_func_parent_iterator_t', 'delete_func_t', 'delete_func_tail_iterator_t', 'delete_func_type_data_t', 'delete_funcarg_t', 'delete_funcargvec_t', + 'delete_gco_info_t', 'delete_generic_linput_t', + 'delete_graph_chains_t', 'delete_graph_item_t', 'delete_graph_location_info_t', 'delete_graph_node_visitor_t', @@ -2225,6 +2496,7 @@ 'delete_hexwarns_t', 'delete_hidden_range_t', 'delete_highlighter_cbs_t', + 'delete_history_entries_helper_t', 'delete_history_item_t', 'delete_history_t', 'delete_ida_lowertype_helper_t', @@ -2235,38 +2507,68 @@ 'delete_idp_desc_t', 'delete_idp_name_t', 'delete_imports', + 'delete_input_file_t', + 'delete_insn_cmt_t', + 'delete_insn_cmts_t', + 'delete_insn_ops_repr_t', + 'delete_insn_ops_reprs_t', + 'delete_insn_site_t', 'delete_insn_t', 'delete_instant_dbgopts_t', 'delete_int_pointer', 'delete_interval_t', 'delete_intvec_t', - 'delete_linput_buffer_t', + 'delete_ivl_t', + 'delete_ivl_with_name_t', + 'delete_ivlset_t', 'delete_llabel_t', 'delete_loader_input_t', 'delete_loader_t', - 'delete_locchange_md_t', 'delete_lochist_entry_t', 'delete_lochist_t', 'delete_lock_func', 'delete_lock_segment', 'delete_longlongvec_t', 'delete_lowertype_helper_t', + 'delete_lumina_client_t', + 'delete_lumina_op_res_vec_t', 'delete_lvar_locator_t', 'delete_lvar_mapping_iterator_t', 'delete_lvar_mapping_t', + 'delete_lvar_ref_t', 'delete_lvar_saved_info_t', 'delete_lvar_saved_infos_t', 'delete_lvar_t', 'delete_lvar_uservec_t', 'delete_lvars_t', + 'delete_mba_range_iterator_t', + 'delete_mba_ranges_t', + 'delete_mbl_array_t', + 'delete_mblock_t', + 'delete_mcallarg_t', + 'delete_mcallargs_t', + 'delete_mcallinfo_t', + 'delete_mcases_t', + 'delete_md_type_parts_t', 'delete_member_t', 'delete_meminfo_vec_t', 'delete_memory_info_t', 'delete_memreg_info_t', 'delete_memreg_infos_t', 'delete_menu', + 'delete_metadata_iterator_t', 'delete_microcode_filter_t', + 'delete_minsn_t', + 'delete_minsn_visitor_t', + 'delete_mlist_mop_visitor_t', + 'delete_mlist_t', + 'delete_mnumber_t', 'delete_modinfo_t', + 'delete_mop_addr_t', + 'delete_mop_pair_t', + 'delete_mop_t', + 'delete_mop_visitor_t', + 'delete_mopvec_t', 'delete_mutable_graph', 'delete_mutable_graph_t', 'delete_netnode', @@ -2275,21 +2577,43 @@ 'delete_node_layout_t', 'delete_node_ordering_t', 'delete_number_format_t', + 'delete_op_parent_info_t', 'delete_op_t', 'delete_operand_locator_t', 'delete_operands_array', 'delete_operator_info_t', 'delete_opinfo_t', + 'delete_oprepr_t', + 'delete_optblock_t', + 'delete_optinsn_t', + 'delete_pattern_id_t', + 'delete_pkt_clean_db_t', + 'delete_pkt_debugctl_t', + 'delete_pkt_dump_md_result_t', + 'delete_pkt_dump_md_t', + 'delete_pkt_get_pop_result_t', + 'delete_pkt_get_pop_t', + 'delete_pkt_helo_t', + 'delete_pkt_pull_md_result_t', + 'delete_pkt_pull_md_t', + 'delete_pkt_push_md_result_t', + 'delete_pkt_push_md_t', + 'delete_pkt_rpc_fail_t', + 'delete_pkt_rpc_notify_t', + 'delete_pkt_rpc_ok_t', 'delete_place_t', 'delete_plugin_info_t', 'delete_point_t', 'delete_pointseq_t', 'delete_pointvec_t', + 'delete_pop_fun_t', 'delete_predicate_t', 'delete_printop_t', 'delete_process_info_t', 'delete_procinfo_vec_t', 'delete_ptr_type_data_t', + 'delete_push_md_opts_t', + 'delete_push_md_result_t', 'delete_qbasic_block_t', 'delete_qfile_t', 'delete_qflow_chart_t', @@ -2312,18 +2636,24 @@ 'delete_reg_info_t', 'delete_regarg_t', 'delete_reginfovec_t', + 'delete_register_info_t', 'delete_regobj_t', 'delete_regobjs_t', + 'delete_regobjvec_t', 'delete_regval_t', 'delete_regvar_array', 'delete_regvar_t', 'delete_renderer_info_pos_t', 'delete_renderer_info_t', 'delete_renderer_pos_info_t', + 'delete_rlist_t', 'delete_row_info_t', 'delete_rrel_t', 'delete_scattered_aloc_t', 'delete_scattered_segm_t', + 'delete_scif_t', + 'delete_scif_visitor_t', + 'delete_screen_graph_selection_base_t', 'delete_screen_graph_selection_t', 'delete_segm_move_info_t', 'delete_segm_move_info_vec_t', @@ -2333,15 +2663,21 @@ 'delete_sel_array', 'delete_sel_pointer', 'delete_selection_item_t', + 'delete_serialized_tinfo', 'delete_simd_info_t', + 'delete_simple_diff_handler_t', + 'delete_simple_idb_diff_handler_t', 'delete_simpleline_place_t', 'delete_simpleline_t', 'delete_sizevec_t', + 'delete_skipped_func_t', + 'delete_skipped_funcs_t', 'delete_snapshot_t', 'delete_sreg_range_t', 'delete_stkpnt_array', 'delete_stkpnt_t', 'delete_stkpnts_t', + 'delete_stkvar_ref_t', 'delete_strarray_t', 'delete_string_info_t', 'delete_strpath_ids_array', @@ -2354,6 +2690,7 @@ 'delete_sval_pointer', 'delete_switch_info_t', 'delete_switch_table', + 'delete_sync_source_t', 'delete_tev_info_reg_t', 'delete_tev_info_t', 'delete_tev_reg_value_t', @@ -2384,12 +2721,16 @@ 'delete_udt_type_data_t', 'delete_udtmembervec_t', 'delete_ui_requests_t', + 'delete_ui_stroff_applicator_t', + 'delete_ui_stroff_op_t', + 'delete_ui_stroff_ops_t', 'delete_uintvec_t', 'delete_ulonglongvec_t', 'delete_unreferenced_stkvars', 'delete_user_cmts_iterator_t', 'delete_user_cmts_t', 'delete_user_graph_place_t', + 'delete_user_identification_t', 'delete_user_iflags_iterator_t', 'delete_user_iflags_t', 'delete_user_labels_iterator_t', @@ -2397,11 +2738,17 @@ 'delete_user_lvar_modifier_t', 'delete_user_numforms_iterator_t', 'delete_user_numforms_t', + 'delete_user_stkpnt_t', + 'delete_user_stkpnts_t', 'delete_user_unions_iterator_t', 'delete_user_unions_t', 'delete_uval_array', + 'delete_uval_ivl_ivlset_t', + 'delete_uval_ivl_t', + 'delete_valrng_t', 'delete_valstr_t', 'delete_valstrs_t', + 'delete_valstrvec_t', 'delete_var_ref_t', 'delete_vc_printer_t', 'delete_vd_failure_t', @@ -2411,6 +2758,8 @@ 'delete_vdui_t', 'delete_view_mouse_event_location_t', 'delete_view_mouse_event_t', + 'delete_vivl_t', + 'delete_voff_t', 'delete_wrong_stkvar_ops', 'delete_xrefblk_t', 'delete_xreflist_entry_t', @@ -2424,6 +2773,7 @@ 'detach_action_from_toolbar', 'detach_custom_data_format', 'detach_process', + 'diff_metadata', 'diff_trace_file', 'disable_bblk_trace', 'disable_bpt', @@ -2484,27 +2834,39 @@ 'disown_View_Hooks', 'disown_aloc_visitor_t', 'disown_cfunc_parentee_t', + 'disown_chain_visitor_t', 'disown_codegen_t', 'disown_const_aloc_visitor_t', 'disown_ctree_parentee_t', 'disown_ctree_visitor_t', 'disown_enum_member_visitor_t', + 'disown_func_md_diff_handler_t', 'disown_graph_node_visitor_t', 'disown_graph_path_visitor_t', 'disown_graph_visitor_t', 'disown_highlighter_cbs_t', 'disown_microcode_filter_t', + 'disown_minsn_visitor_t', + 'disown_mlist_mop_visitor_t', + 'disown_mop_visitor_t', 'disown_mutable_graph_t', + 'disown_optblock_t', + 'disown_optinsn_t', 'disown_predicate_t', + 'disown_scif_visitor_t', 'disown_struct_field_visitor_t', 'disown_text_sink_t', 'disown_tinfo_visitor_t', 'disown_udc_filter_t', + 'disown_ui_stroff_applicator_t', 'disown_user_lvar_modifier_t', + 'disown_vc_printer_t', + 'disown_vd_printer_t', 'display_copyright_warning', 'display_gdl', 'display_widget', 'double_flag', + 'dstr', 'dstr_tinfo', 'dummy_ptrtype', 'dump_func_type_data', @@ -2555,6 +2917,7 @@ 'ea_pointer_cast', 'ea_pointer_frompointer', 'ea_pointer_value', + 'ea_to_ea64', 'ea_viewer_history_push_and_jump', 'eamap_begin', 'eamap_clear', @@ -2646,6 +3009,46 @@ 'enum_member_t_swap', 'enum_member_t_value_get', 'enum_member_t_value_set', + 'enum_member_vec_t___eq__', + 'enum_member_vec_t___getitem__', + 'enum_member_vec_t___len__', + 'enum_member_vec_t___ne__', + 'enum_member_vec_t___setitem__', + 'enum_member_vec_t__del', + 'enum_member_vec_t_add_unique', + 'enum_member_vec_t_at', + 'enum_member_vec_t_begin', + 'enum_member_vec_t_begin__SWIG_0', + 'enum_member_vec_t_begin__SWIG_1', + 'enum_member_vec_t_capacity', + 'enum_member_vec_t_clear', + 'enum_member_vec_t_empty', + 'enum_member_vec_t_end', + 'enum_member_vec_t_end__SWIG_0', + 'enum_member_vec_t_end__SWIG_1', + 'enum_member_vec_t_erase', + 'enum_member_vec_t_erase__SWIG_0', + 'enum_member_vec_t_erase__SWIG_1', + 'enum_member_vec_t_extract', + 'enum_member_vec_t_find', + 'enum_member_vec_t_find__SWIG_0', + 'enum_member_vec_t_find__SWIG_1', + 'enum_member_vec_t_grow', + 'enum_member_vec_t_has', + 'enum_member_vec_t_inject', + 'enum_member_vec_t_insert', + 'enum_member_vec_t_pop_back', + 'enum_member_vec_t_push_back', + 'enum_member_vec_t_push_back__SWIG_0', + 'enum_member_vec_t_push_back__SWIG_1', + 'enum_member_vec_t_qclear', + 'enum_member_vec_t_reserve', + 'enum_member_vec_t_resize', + 'enum_member_vec_t_resize__SWIG_0', + 'enum_member_vec_t_resize__SWIG_1', + 'enum_member_vec_t_size', + 'enum_member_vec_t_swap', + 'enum_member_vec_t_truncate', 'enum_member_visitor_t_visit_enum_member', 'enum_type_data_t_bte_get', 'enum_type_data_t_bte_set', @@ -2737,9 +3140,51 @@ 'exit_process', 'expand_struc', 'extend_sign', + 'extra_cmt_t_next_get', + 'extra_cmt_t_next_set', + 'extra_cmt_t_prev_get', + 'extra_cmt_t_prev_set', + 'extra_cmts_t___getitem__', + 'extra_cmts_t___len__', + 'extra_cmts_t___setitem__', + 'extra_cmts_t_at', + 'extra_cmts_t_begin', + 'extra_cmts_t_begin__SWIG_0', + 'extra_cmts_t_begin__SWIG_1', + 'extra_cmts_t_capacity', + 'extra_cmts_t_clear', + 'extra_cmts_t_empty', + 'extra_cmts_t_end', + 'extra_cmts_t_end__SWIG_0', + 'extra_cmts_t_end__SWIG_1', + 'extra_cmts_t_erase', + 'extra_cmts_t_erase__SWIG_0', + 'extra_cmts_t_erase__SWIG_1', + 'extra_cmts_t_extract', + 'extra_cmts_t_grow', + 'extra_cmts_t_inject', + 'extra_cmts_t_insert', + 'extra_cmts_t_pop_back', + 'extra_cmts_t_push_back', + 'extra_cmts_t_push_back__SWIG_0', + 'extra_cmts_t_push_back__SWIG_1', + 'extra_cmts_t_qclear', + 'extra_cmts_t_reserve', + 'extra_cmts_t_resize', + 'extra_cmts_t_resize__SWIG_0', + 'extra_cmts_t_resize__SWIG_1', + 'extra_cmts_t_size', + 'extra_cmts_t_swap', + 'extra_cmts_t_truncate', 'extract_argloc', + 'extract_extra_cmts_from_metadata', + 'extract_frame_desc_from_metadata', + 'extract_insn_cmts_from_metadata', + 'extract_insn_opreprs_from_metadata', 'extract_module_from_archive', 'extract_name', + 'extract_type_from_metadata', + 'extract_user_stkpnts_from_metadata', 'f_any', 'f_has_cmt', 'f_has_dummy_name', @@ -2867,6 +3312,7 @@ 'for_all_enum_members', 'force_name', 'forget_problem', + 'format_basestring', 'formchgcbfa_close', 'formchgcbfa_enable_field', 'formchgcbfa_get_field_value', @@ -2876,6 +3322,60 @@ 'formchgcbfa_set_field_value', 'formchgcbfa_set_focused_field', 'formchgcbfa_show_field', + 'frame_desc_t_argsize_get', + 'frame_desc_t_argsize_set', + 'frame_desc_t_frregs_get', + 'frame_desc_t_frregs_set', + 'frame_desc_t_frsize_get', + 'frame_desc_t_frsize_set', + 'frame_desc_t_members_get', + 'frame_desc_t_members_set', + 'frame_mem_t_cmt_get', + 'frame_mem_t_cmt_set', + 'frame_mem_t_info_get', + 'frame_mem_t_info_set', + 'frame_mem_t_name_get', + 'frame_mem_t_name_set', + 'frame_mem_t_nbytes_get', + 'frame_mem_t_nbytes_set', + 'frame_mem_t_offset_get', + 'frame_mem_t_offset_set', + 'frame_mem_t_rptcmt_get', + 'frame_mem_t_rptcmt_set', + 'frame_mem_t_type_get', + 'frame_mem_t_type_set', + 'frame_mems_t___getitem__', + 'frame_mems_t___len__', + 'frame_mems_t___setitem__', + 'frame_mems_t_at', + 'frame_mems_t_begin', + 'frame_mems_t_begin__SWIG_0', + 'frame_mems_t_begin__SWIG_1', + 'frame_mems_t_capacity', + 'frame_mems_t_clear', + 'frame_mems_t_empty', + 'frame_mems_t_end', + 'frame_mems_t_end__SWIG_0', + 'frame_mems_t_end__SWIG_1', + 'frame_mems_t_erase', + 'frame_mems_t_erase__SWIG_0', + 'frame_mems_t_erase__SWIG_1', + 'frame_mems_t_extract', + 'frame_mems_t_grow', + 'frame_mems_t_inject', + 'frame_mems_t_insert', + 'frame_mems_t_pop_back', + 'frame_mems_t_push_back', + 'frame_mems_t_push_back__SWIG_0', + 'frame_mems_t_push_back__SWIG_1', + 'frame_mems_t_qclear', + 'frame_mems_t_reserve', + 'frame_mems_t_resize', + 'frame_mems_t_resize__SWIG_0', + 'frame_mems_t_resize__SWIG_1', + 'frame_mems_t_size', + 'frame_mems_t_swap', + 'frame_mems_t_truncate', 'frame_off_args', 'frame_off_lvars', 'frame_off_retaddr', @@ -2887,6 +3387,150 @@ 'func_contains', 'func_does_return', 'func_has_stkframe_hole', + 'func_info_and_frequency_t_frequency_get', + 'func_info_and_frequency_t_frequency_set', + 'func_info_and_frequency_vec_t___getitem__', + 'func_info_and_frequency_vec_t___len__', + 'func_info_and_frequency_vec_t___setitem__', + 'func_info_and_frequency_vec_t_at', + 'func_info_and_frequency_vec_t_begin', + 'func_info_and_frequency_vec_t_begin__SWIG_0', + 'func_info_and_frequency_vec_t_begin__SWIG_1', + 'func_info_and_frequency_vec_t_capacity', + 'func_info_and_frequency_vec_t_clear', + 'func_info_and_frequency_vec_t_empty', + 'func_info_and_frequency_vec_t_end', + 'func_info_and_frequency_vec_t_end__SWIG_0', + 'func_info_and_frequency_vec_t_end__SWIG_1', + 'func_info_and_frequency_vec_t_erase', + 'func_info_and_frequency_vec_t_erase__SWIG_0', + 'func_info_and_frequency_vec_t_erase__SWIG_1', + 'func_info_and_frequency_vec_t_extract', + 'func_info_and_frequency_vec_t_grow', + 'func_info_and_frequency_vec_t_inject', + 'func_info_and_frequency_vec_t_insert', + 'func_info_and_frequency_vec_t_pop_back', + 'func_info_and_frequency_vec_t_push_back', + 'func_info_and_frequency_vec_t_push_back__SWIG_0', + 'func_info_and_frequency_vec_t_push_back__SWIG_1', + 'func_info_and_frequency_vec_t_qclear', + 'func_info_and_frequency_vec_t_reserve', + 'func_info_and_frequency_vec_t_resize', + 'func_info_and_frequency_vec_t_resize__SWIG_0', + 'func_info_and_frequency_vec_t_resize__SWIG_1', + 'func_info_and_frequency_vec_t_size', + 'func_info_and_frequency_vec_t_swap', + 'func_info_and_frequency_vec_t_truncate', + 'func_info_and_pattern_t_pattern_id_get', + 'func_info_and_pattern_t_pattern_id_set', + 'func_info_and_pattern_vec_t___getitem__', + 'func_info_and_pattern_vec_t___len__', + 'func_info_and_pattern_vec_t___setitem__', + 'func_info_and_pattern_vec_t_at', + 'func_info_and_pattern_vec_t_begin', + 'func_info_and_pattern_vec_t_begin__SWIG_0', + 'func_info_and_pattern_vec_t_begin__SWIG_1', + 'func_info_and_pattern_vec_t_capacity', + 'func_info_and_pattern_vec_t_clear', + 'func_info_and_pattern_vec_t_empty', + 'func_info_and_pattern_vec_t_end', + 'func_info_and_pattern_vec_t_end__SWIG_0', + 'func_info_and_pattern_vec_t_end__SWIG_1', + 'func_info_and_pattern_vec_t_erase', + 'func_info_and_pattern_vec_t_erase__SWIG_0', + 'func_info_and_pattern_vec_t_erase__SWIG_1', + 'func_info_and_pattern_vec_t_extract', + 'func_info_and_pattern_vec_t_grow', + 'func_info_and_pattern_vec_t_inject', + 'func_info_and_pattern_vec_t_insert', + 'func_info_and_pattern_vec_t_pop_back', + 'func_info_and_pattern_vec_t_push_back', + 'func_info_and_pattern_vec_t_push_back__SWIG_0', + 'func_info_and_pattern_vec_t_push_back__SWIG_1', + 'func_info_and_pattern_vec_t_qclear', + 'func_info_and_pattern_vec_t_reserve', + 'func_info_and_pattern_vec_t_resize', + 'func_info_and_pattern_vec_t_resize__SWIG_0', + 'func_info_and_pattern_vec_t_resize__SWIG_1', + 'func_info_and_pattern_vec_t_size', + 'func_info_and_pattern_vec_t_swap', + 'func_info_and_pattern_vec_t_truncate', + 'func_info_base_t_metadata_get', + 'func_info_base_t_metadata_set', + 'func_info_base_t_name_get', + 'func_info_base_t_name_set', + 'func_info_pattern_and_frequency_t_frequency_get', + 'func_info_pattern_and_frequency_t_frequency_set', + 'func_info_pattern_and_frequency_vec_t___getitem__', + 'func_info_pattern_and_frequency_vec_t___len__', + 'func_info_pattern_and_frequency_vec_t___setitem__', + 'func_info_pattern_and_frequency_vec_t_at', + 'func_info_pattern_and_frequency_vec_t_begin', + 'func_info_pattern_and_frequency_vec_t_begin__SWIG_0', + 'func_info_pattern_and_frequency_vec_t_begin__SWIG_1', + 'func_info_pattern_and_frequency_vec_t_capacity', + 'func_info_pattern_and_frequency_vec_t_clear', + 'func_info_pattern_and_frequency_vec_t_empty', + 'func_info_pattern_and_frequency_vec_t_end', + 'func_info_pattern_and_frequency_vec_t_end__SWIG_0', + 'func_info_pattern_and_frequency_vec_t_end__SWIG_1', + 'func_info_pattern_and_frequency_vec_t_erase', + 'func_info_pattern_and_frequency_vec_t_erase__SWIG_0', + 'func_info_pattern_and_frequency_vec_t_erase__SWIG_1', + 'func_info_pattern_and_frequency_vec_t_extract', + 'func_info_pattern_and_frequency_vec_t_grow', + 'func_info_pattern_and_frequency_vec_t_inject', + 'func_info_pattern_and_frequency_vec_t_insert', + 'func_info_pattern_and_frequency_vec_t_pop_back', + 'func_info_pattern_and_frequency_vec_t_push_back', + 'func_info_pattern_and_frequency_vec_t_push_back__SWIG_0', + 'func_info_pattern_and_frequency_vec_t_push_back__SWIG_1', + 'func_info_pattern_and_frequency_vec_t_qclear', + 'func_info_pattern_and_frequency_vec_t_reserve', + 'func_info_pattern_and_frequency_vec_t_resize', + 'func_info_pattern_and_frequency_vec_t_resize__SWIG_0', + 'func_info_pattern_and_frequency_vec_t_resize__SWIG_1', + 'func_info_pattern_and_frequency_vec_t_size', + 'func_info_pattern_and_frequency_vec_t_swap', + 'func_info_pattern_and_frequency_vec_t_truncate', + 'func_info_t_metadata_get', + 'func_info_t_metadata_set', + 'func_info_t_name_get', + 'func_info_t_name_set', + 'func_info_t_size_get', + 'func_info_t_size_set', + 'func_info_vec_t___getitem__', + 'func_info_vec_t___len__', + 'func_info_vec_t___setitem__', + 'func_info_vec_t_at', + 'func_info_vec_t_begin', + 'func_info_vec_t_begin__SWIG_0', + 'func_info_vec_t_begin__SWIG_1', + 'func_info_vec_t_capacity', + 'func_info_vec_t_clear', + 'func_info_vec_t_empty', + 'func_info_vec_t_end', + 'func_info_vec_t_end__SWIG_0', + 'func_info_vec_t_end__SWIG_1', + 'func_info_vec_t_erase', + 'func_info_vec_t_erase__SWIG_0', + 'func_info_vec_t_erase__SWIG_1', + 'func_info_vec_t_extract', + 'func_info_vec_t_grow', + 'func_info_vec_t_inject', + 'func_info_vec_t_insert', + 'func_info_vec_t_pop_back', + 'func_info_vec_t_push_back', + 'func_info_vec_t_push_back__SWIG_0', + 'func_info_vec_t_push_back__SWIG_1', + 'func_info_vec_t_qclear', + 'func_info_vec_t_reserve', + 'func_info_vec_t_resize', + 'func_info_vec_t_resize__SWIG_0', + 'func_info_vec_t_resize__SWIG_1', + 'func_info_vec_t_size', + 'func_info_vec_t_swap', + 'func_info_vec_t_truncate', 'func_item_iterator_decode_preceding_insn', 'func_item_iterator_decode_prev_insn', 'func_item_iterator_next', @@ -2911,6 +3555,15 @@ 'func_item_iterator_t_prev_not_tail', 'func_item_iterator_t_set', 'func_item_iterator_t_set_range', + 'func_md_diff_handler_t_on_comment_changed', + 'func_md_diff_handler_t_on_extra_comment_changed', + 'func_md_diff_handler_t_on_frame_member_changed', + 'func_md_diff_handler_t_on_function_comment_changed', + 'func_md_diff_handler_t_on_insn_ops_repr_changed', + 'func_md_diff_handler_t_on_name_changed', + 'func_md_diff_handler_t_on_proto_changed', + 'func_md_diff_handler_t_on_score_changed', + 'func_md_diff_handler_t_on_user_stkpnt_changed', 'func_parent_iterator_set', 'func_parent_iterator_t_first', 'func_parent_iterator_t_last', @@ -3051,6 +3704,16 @@ 'funcargvec_t_swap', 'funcargvec_t_truncate', 'gcc_layout', + 'gco_info_t_append_to_list', + 'gco_info_t_flags_get', + 'gco_info_t_flags_set', + 'gco_info_t_is_def', + 'gco_info_t_is_reg', + 'gco_info_t_is_use', + 'gco_info_t_name_get', + 'gco_info_t_name_set', + 'gco_info_t_size_get', + 'gco_info_t_size_set', 'gen_complex_call_chart', 'gen_decorate_name', 'gen_disasm_text', @@ -3061,6 +3724,7 @@ 'gen_gdl', 'gen_idb_event', 'gen_idb_event__varargs__', + 'gen_microcode', 'gen_simple_call_chart', 'gen_use_arg_tinfos', 'generate_disasm_line', @@ -3127,6 +3791,7 @@ 'get_ctype_name', 'get_curline', 'get_current_idasgn', + 'get_current_operand', 'get_current_source_file', 'get_current_source_line', 'get_current_thread', @@ -3274,11 +3939,15 @@ 'get_idasgn_qty', 'get_idasgn_title', 'get_idati', + 'get_idb_notifier_addr', + 'get_idb_notifier_ud_addr', 'get_idc_filename', 'get_idcv_attr', 'get_idcv_class_name', 'get_idcv_slice', 'get_idp_name', + 'get_idp_notifier_addr', + 'get_idp_notifier_ud_addr', 'get_ids_modnode', 'get_imagebase', 'get_immvals', @@ -3311,6 +3980,7 @@ 'get_local_vars', 'get_long_name', 'get_lookback', + 'get_lumina_rpc_packet_t_index_from_base', 'get_manual_insn', 'get_manual_regions', 'get_manual_regions__SWIG_0', @@ -3327,6 +3997,7 @@ 'get_member_by_name', 'get_member_cmt', 'get_member_fullname', + 'get_member_id', 'get_member_name', 'get_member_size', 'get_member_struc', @@ -3335,6 +4006,7 @@ 'get_merror_desc', 'get_min_spd_ea', 'get_module_info', + 'get_mreg_name', 'get_name', 'get_name_base_ea', 'get_name_color', @@ -3426,6 +4098,7 @@ 'get_reg_val', 'get_reg_val__SWIG_0', 'get_reg_val__SWIG_1', + 'get_reg_val__SWIG_2', 'get_reg_vals', 'get_registered_actions', 'get_ret_tev_return', @@ -3447,7 +4120,9 @@ 'get_segment_combination', 'get_segment_translations', 'get_selector_qty', + 'get_server_connection', 'get_short_name', + 'get_signed_mcode', 'get_source_linnum', 'get_sourcefile', 'get_sp_delta', @@ -3491,6 +4166,7 @@ 'get_switch_info', 'get_switch_parent', 'get_tab_size', + 'get_temp_regs', 'get_tev_ea', 'get_tev_event', 'get_tev_info', @@ -3514,6 +4190,7 @@ 'get_type_flags', 'get_type_ordinal', 'get_unk_type', + 'get_unsigned_mcode', 'get_user_idadir', 'get_user_strlist_options', 'get_view_renderer_type', @@ -3531,6 +4208,8 @@ 'get_window_id', 'get_word', 'get_zero_ranges', + 'getb_reginsn', + 'getf_reginsn', 'getn_bpt', 'getn_enum', 'getn_fchunk', @@ -3544,6 +4223,11 @@ 'getnseg', 'getseg', 'getsysfile', + 'graph_chains_t_acquire', + 'graph_chains_t_for_all_chains', + 'graph_chains_t_is_locked', + 'graph_chains_t_release', + 'graph_chains_t_swap', 'graph_item_t_b_get', 'graph_item_t_b_set', 'graph_item_t_e_get', @@ -3591,6 +4275,7 @@ 'handle_debug_event', 'has_any_name', 'has_auto_name', + 'has_backup_metadata', 'has_cached_cfunc', 'has_cf_chg', 'has_cf_use', @@ -3602,6 +4287,7 @@ 'has_insn_feature', 'has_lname', 'has_name', + 'has_regvar', 'has_ti', 'has_ti0', 'has_ti1', @@ -3690,6 +4376,9 @@ 'highlighter_cbs_t_prev_block_state', 'highlighter_cbs_t_set_block_state', 'highlighter_cbs_t_set_style', + 'history_entries_helper_t_next_entry', + 'history_entries_helper_t_next_entry_index', + 'history_entries_helper_t_res_get', 'history_item_t_ea_get', 'history_item_t_ea_set', 'history_item_t_end_get', @@ -3716,7 +4405,6 @@ 'idainfo_asmtype_set', 'idainfo_baseaddr_get', 'idainfo_baseaddr_set', - 'idainfo_big_arg_align', 'idainfo_bin_prefix_size_get', 'idainfo_bin_prefix_size_set', 'idainfo_cc_get', @@ -3731,40 +4419,20 @@ 'idainfo_demnames_set', 'idainfo_filetype_get', 'idainfo_filetype_set', - 'idainfo_gen_lzero', - 'idainfo_gen_null', - 'idainfo_gen_tryblks', 'idainfo_get_abiname', - 'idainfo_get_demname_form', 'idainfo_get_maxEA', 'idainfo_get_minEA', - 'idainfo_get_pack_mode', 'idainfo_get_procName', 'idainfo_highoff_get', 'idainfo_highoff_set', 'idainfo_indent_get', 'idainfo_indent_set', - 'idainfo_is_32bit', - 'idainfo_is_64bit', - 'idainfo_is_auto_enabled', - 'idainfo_is_be', - 'idainfo_is_dll', - 'idainfo_is_flat_off32', - 'idainfo_is_graph_view', - 'idainfo_is_hard_float', - 'idainfo_is_kernel_mode', - 'idainfo_is_mem_aligned4', - 'idainfo_is_snapshot', - 'idainfo_is_wide_high_byte_first', 'idainfo_lenxref_get', 'idainfo_lenxref_set', 'idainfo_lflags_get', 'idainfo_lflags_set', - 'idainfo_like_binary', - 'idainfo_line_pref_with_seg', 'idainfo_listnames_get', 'idainfo_listnames_set', - 'idainfo_loading_idc', 'idainfo_long_demnames_get', 'idainfo_long_demnames_set', 'idainfo_lowoff_get', @@ -3791,10 +4459,8 @@ 'idainfo_ostype_set', 'idainfo_outflags_get', 'idainfo_outflags_set', - 'idainfo_pack_stkargs', 'idainfo_procname_get', 'idainfo_procname_set', - 'idainfo_readonly_idb', 'idainfo_refcmtnum_get', 'idainfo_refcmtnum_set', 'idainfo_s_cmtflg_get', @@ -3807,30 +4473,12 @@ 'idainfo_s_prefflag_set', 'idainfo_s_xrefflag_get', 'idainfo_s_xrefflag_set', - 'idainfo_set_64bit', - 'idainfo_set_auto_enabled', - 'idainfo_set_be', - 'idainfo_set_gen_lzero', - 'idainfo_set_gen_null', - 'idainfo_set_gen_tryblks', - 'idainfo_set_graph_view', - 'idainfo_set_line_pref_with_seg', 'idainfo_set_maxEA', 'idainfo_set_minEA', - 'idainfo_set_pack_mode', - 'idainfo_set_show_auto', - 'idainfo_set_show_line_pref', - 'idainfo_set_show_void', - 'idainfo_set_wide_high_byte_first', 'idainfo_short_demnames_get', 'idainfo_short_demnames_set', - 'idainfo_show_auto', - 'idainfo_show_line_pref', - 'idainfo_show_void', 'idainfo_specsegs_get', 'idainfo_specsegs_set', - 'idainfo_stack_ldbl', - 'idainfo_stack_varargs', 'idainfo_start_cs_get', 'idainfo_start_cs_set', 'idainfo_start_ea_get', @@ -3857,8 +4505,6 @@ 'idainfo_tag_set', 'idainfo_type_xrefnum_get', 'idainfo_type_xrefnum_set', - 'idainfo_use_allasm', - 'idainfo_use_gcc_layout', 'idainfo_version_get', 'idainfo_version_set', 'idainfo_xrefnum_get', @@ -3910,7 +4556,6 @@ 'idc_value_t_set_string', 'idc_value_t_set_string__SWIG_0', 'idc_value_t_set_string__SWIG_1', - 'idc_value_t_set_string__SWIG_2', 'idc_value_t_swap', 'idc_value_t_u_str', 'idc_value_t_vtype_get', @@ -3972,13 +4617,440 @@ 'idp_name_t_sname_get', 'idp_name_t_sname_set', 'import_type', + 'inf_abi_set_by_user', + 'inf_allow_non_matched_ops', + 'inf_allow_sigmulti', + 'inf_append_sigcmt', + 'inf_big_arg_align', + 'inf_check_manual_ops', + 'inf_check_unicode_strlits', + 'inf_coagulate_code', + 'inf_coagulate_data', + 'inf_compress_idb', + 'inf_create_all_xrefs', + 'inf_create_func_from_call', + 'inf_create_func_from_ptr', + 'inf_create_func_tails', + 'inf_create_jump_tables', + 'inf_create_off_on_dref', + 'inf_create_off_using_fixup', + 'inf_create_strlit_on_xref', + 'inf_data_offset', + 'inf_dbg_no_store_path', + 'inf_decode_fpp', + 'inf_del_no_xref_insns', + 'inf_final_pass', + 'inf_full_sp_ana', + 'inf_gen_assume', + 'inf_gen_lzero', + 'inf_gen_null', + 'inf_gen_org', + 'inf_gen_tryblks', + 'inf_get_abibits', + 'inf_get_af', + 'inf_get_af2', + 'inf_get_af2_low', + 'inf_get_af_high', + 'inf_get_af_low', + 'inf_get_appcall_options', + 'inf_get_apptype', + 'inf_get_asmtype', + 'inf_get_baseaddr', + 'inf_get_bin_prefix_size', + 'inf_get_cc', + 'inf_get_cc_cm', + 'inf_get_cc_defalign', + 'inf_get_cc_id', + 'inf_get_cc_size_b', + 'inf_get_cc_size_e', + 'inf_get_cc_size_i', + 'inf_get_cc_size_l', + 'inf_get_cc_size_ldbl', + 'inf_get_cc_size_ll', + 'inf_get_cc_size_s', + 'inf_get_cmtflg', + 'inf_get_comment', + 'inf_get_database_change_count', + 'inf_get_datatypes', + 'inf_get_demname_form', + 'inf_get_demnames', + 'inf_get_filetype', + 'inf_get_genflags', + 'inf_get_highoff', + 'inf_get_indent', + 'inf_get_lenxref', + 'inf_get_lflags', + 'inf_get_limiter', + 'inf_get_listnames', + 'inf_get_long_demnames', + 'inf_get_lowoff', + 'inf_get_main', + 'inf_get_margin', + 'inf_get_max_autoname_len', + 'inf_get_max_ea', + 'inf_get_maxref', + 'inf_get_min_ea', + 'inf_get_nametype', + 'inf_get_netdelta', + 'inf_get_omax_ea', + 'inf_get_omin_ea', + 'inf_get_ostype', + 'inf_get_outflags', + 'inf_get_pack_mode', + 'inf_get_prefflag', + 'inf_get_privrange', + 'inf_get_privrange__SWIG_0', + 'inf_get_privrange__SWIG_1', + 'inf_get_privrange_end_ea', + 'inf_get_privrange_start_ea', + 'inf_get_procname', + 'inf_get_refcmtnum', + 'inf_get_short_demnames', + 'inf_get_specsegs', + 'inf_get_start_cs', + 'inf_get_start_ea', + 'inf_get_start_ip', + 'inf_get_start_sp', + 'inf_get_start_ss', + 'inf_get_strlit_break', + 'inf_get_strlit_flags', + 'inf_get_strlit_pref', + 'inf_get_strlit_sernum', + 'inf_get_strlit_zeroes', + 'inf_get_strtype', + 'inf_get_type_xrefnum', + 'inf_get_version', + 'inf_get_xrefflag', + 'inf_get_xrefnum', + 'inf_guess_func_type', + 'inf_handle_eh', + 'inf_handle_rtti', + 'inf_hide_comments', + 'inf_hide_libfuncs', + 'inf_inc_database_change_count', + 'inf_is_32bit', + 'inf_is_64bit', + 'inf_is_auto_enabled', + 'inf_is_be', + 'inf_is_dll', + 'inf_is_flat_off32', + 'inf_is_graph_view', + 'inf_is_hard_float', + 'inf_is_kernel_mode', + 'inf_is_limiter_empty', + 'inf_is_limiter_thick', + 'inf_is_limiter_thin', + 'inf_is_mem_aligned4', + 'inf_is_snapshot', + 'inf_is_wide_high_byte_first', + 'inf_like_binary', + 'inf_line_pref_with_seg', + 'inf_loading_idc', + 'inf_macros_enabled', + 'inf_map_stkargs', + 'inf_mark_code', + 'inf_no_store_user_info', + 'inf_noflow_to_data', + 'inf_noret_ana', + 'inf_op_offset', + 'inf_pack_idb', + 'inf_pack_stkargs', + 'inf_postinc_strlit_sernum', + 'inf_prefix_show_funcoff', + 'inf_prefix_show_segaddr', + 'inf_prefix_show_stack', + 'inf_propagate_regargs', + 'inf_propagate_stkargs', + 'inf_readonly_idb', + 'inf_rename_jumpfunc', + 'inf_rename_nullsub', + 'inf_set_32bit', + 'inf_set_64bit', + 'inf_set_abi_set_by_user', + 'inf_set_abibits', + 'inf_set_af', + 'inf_set_af2', + 'inf_set_af2_low', + 'inf_set_af_high', + 'inf_set_af_low', + 'inf_set_allow_non_matched_ops', + 'inf_set_allow_sigmulti', + 'inf_set_appcall_options', + 'inf_set_append_sigcmt', + 'inf_set_apptype', + 'inf_set_asmtype', + 'inf_set_auto_enabled', + 'inf_set_baseaddr', + 'inf_set_be', + 'inf_set_big_arg_align', + 'inf_set_bin_prefix_size', + 'inf_set_cc', + 'inf_set_cc_cm', + 'inf_set_cc_defalign', + 'inf_set_cc_id', + 'inf_set_cc_size_b', + 'inf_set_cc_size_e', + 'inf_set_cc_size_i', + 'inf_set_cc_size_l', + 'inf_set_cc_size_ldbl', + 'inf_set_cc_size_ll', + 'inf_set_cc_size_s', + 'inf_set_check_manual_ops', + 'inf_set_check_unicode_strlits', + 'inf_set_cmtflg', + 'inf_set_coagulate_code', + 'inf_set_coagulate_data', + 'inf_set_comment', + 'inf_set_compress_idb', + 'inf_set_create_all_xrefs', + 'inf_set_create_func_from_call', + 'inf_set_create_func_from_ptr', + 'inf_set_create_func_tails', + 'inf_set_create_jump_tables', + 'inf_set_create_off_on_dref', + 'inf_set_create_off_using_fixup', + 'inf_set_create_strlit_on_xref', + 'inf_set_data_offset', + 'inf_set_database_change_count', + 'inf_set_datatypes', + 'inf_set_dbg_no_store_path', + 'inf_set_decode_fpp', + 'inf_set_del_no_xref_insns', + 'inf_set_demnames', + 'inf_set_dll', + 'inf_set_filetype', + 'inf_set_final_pass', + 'inf_set_flat_off32', + 'inf_set_full_sp_ana', + 'inf_set_gen_assume', + 'inf_set_gen_lzero', + 'inf_set_gen_null', + 'inf_set_gen_org', + 'inf_set_gen_tryblks', + 'inf_set_genflags', + 'inf_set_graph_view', + 'inf_set_guess_func_type', + 'inf_set_handle_eh', + 'inf_set_handle_rtti', + 'inf_set_hard_float', + 'inf_set_hide_comments', + 'inf_set_hide_libfuncs', + 'inf_set_highoff', + 'inf_set_indent', + 'inf_set_kernel_mode', + 'inf_set_lenxref', + 'inf_set_lflags', + 'inf_set_limiter', + 'inf_set_limiter_empty', + 'inf_set_limiter_thick', + 'inf_set_limiter_thin', + 'inf_set_line_pref_with_seg', + 'inf_set_listnames', + 'inf_set_loading_idc', + 'inf_set_long_demnames', + 'inf_set_lowoff', + 'inf_set_macros_enabled', + 'inf_set_main', + 'inf_set_map_stkargs', + 'inf_set_margin', + 'inf_set_mark_code', + 'inf_set_max_autoname_len', + 'inf_set_max_ea', + 'inf_set_maxref', + 'inf_set_mem_aligned4', + 'inf_set_min_ea', + 'inf_set_nametype', + 'inf_set_netdelta', + 'inf_set_no_store_user_info', + 'inf_set_noflow_to_data', + 'inf_set_noret_ana', + 'inf_set_omax_ea', + 'inf_set_omin_ea', + 'inf_set_op_offset', + 'inf_set_ostype', + 'inf_set_outflags', + 'inf_set_pack_idb', + 'inf_set_pack_mode', + 'inf_set_pack_stkargs', + 'inf_set_prefflag', + 'inf_set_prefix_show_funcoff', + 'inf_set_prefix_show_segaddr', + 'inf_set_prefix_show_stack', + 'inf_set_privrange', + 'inf_set_privrange_end_ea', + 'inf_set_privrange_start_ea', + 'inf_set_procname', + 'inf_set_propagate_regargs', + 'inf_set_propagate_stkargs', + 'inf_set_readonly_idb', + 'inf_set_refcmtnum', + 'inf_set_rename_jumpfunc', + 'inf_set_rename_nullsub', + 'inf_set_short_demnames', + 'inf_set_should_create_stkvars', + 'inf_set_should_trace_sp', + 'inf_set_show_all_comments', + 'inf_set_show_auto', + 'inf_set_show_hidden_funcs', + 'inf_set_show_hidden_insns', + 'inf_set_show_hidden_segms', + 'inf_set_show_line_pref', + 'inf_set_show_repeatables', + 'inf_set_show_src_linnum', + 'inf_set_show_void', + 'inf_set_show_xref_fncoff', + 'inf_set_show_xref_seg', + 'inf_set_show_xref_tmarks', + 'inf_set_show_xref_val', + 'inf_set_snapshot', + 'inf_set_specsegs', + 'inf_set_stack_ldbl', + 'inf_set_stack_varargs', + 'inf_set_start_cs', + 'inf_set_start_ea', + 'inf_set_start_ip', + 'inf_set_start_sp', + 'inf_set_start_ss', + 'inf_set_strlit_autocmt', + 'inf_set_strlit_break', + 'inf_set_strlit_flags', + 'inf_set_strlit_name_bit', + 'inf_set_strlit_names', + 'inf_set_strlit_pref', + 'inf_set_strlit_savecase', + 'inf_set_strlit_serial_names', + 'inf_set_strlit_sernum', + 'inf_set_strlit_zeroes', + 'inf_set_strtype', + 'inf_set_test_mode', + 'inf_set_trace_flow', + 'inf_set_truncate_on_del', + 'inf_set_type_xrefnum', + 'inf_set_unicode_strlits', + 'inf_set_use_allasm', + 'inf_set_use_flirt', + 'inf_set_use_gcc_layout', + 'inf_set_version', + 'inf_set_wide_high_byte_first', + 'inf_set_xrefflag', + 'inf_set_xrefnum', + 'inf_should_create_stkvars', + 'inf_should_trace_sp', + 'inf_show_all_comments', + 'inf_show_auto', + 'inf_show_hidden_funcs', + 'inf_show_hidden_insns', + 'inf_show_hidden_segms', + 'inf_show_line_pref', + 'inf_show_repeatables', + 'inf_show_src_linnum', + 'inf_show_void', + 'inf_show_xref_fncoff', + 'inf_show_xref_seg', + 'inf_show_xref_tmarks', + 'inf_show_xref_val', + 'inf_stack_ldbl', + 'inf_stack_varargs', + 'inf_strlit_autocmt', + 'inf_strlit_name_bit', + 'inf_strlit_names', + 'inf_strlit_savecase', + 'inf_strlit_serial_names', + 'inf_test_mode', + 'inf_trace_flow', + 'inf_truncate_on_del', + 'inf_unicode_strlits', + 'inf_use_allasm', + 'inf_use_flirt', + 'inf_use_gcc_layout', 'info', 'info__varargs__', 'init_hexrays_plugin', + 'input_file_t_md5_get', + 'input_file_t_md5_set', + 'input_file_t_path_get', + 'input_file_t_path_set', 'insn_add_cref', 'insn_add_dref', 'insn_add_off_drefs', + 'insn_cmt_t_cmt_get', + 'insn_cmt_t_cmt_set', + 'insn_cmts_t___getitem__', + 'insn_cmts_t___len__', + 'insn_cmts_t___setitem__', + 'insn_cmts_t_at', + 'insn_cmts_t_begin', + 'insn_cmts_t_begin__SWIG_0', + 'insn_cmts_t_begin__SWIG_1', + 'insn_cmts_t_capacity', + 'insn_cmts_t_clear', + 'insn_cmts_t_empty', + 'insn_cmts_t_end', + 'insn_cmts_t_end__SWIG_0', + 'insn_cmts_t_end__SWIG_1', + 'insn_cmts_t_erase', + 'insn_cmts_t_erase__SWIG_0', + 'insn_cmts_t_erase__SWIG_1', + 'insn_cmts_t_extract', + 'insn_cmts_t_grow', + 'insn_cmts_t_inject', + 'insn_cmts_t_insert', + 'insn_cmts_t_pop_back', + 'insn_cmts_t_push_back', + 'insn_cmts_t_push_back__SWIG_0', + 'insn_cmts_t_push_back__SWIG_1', + 'insn_cmts_t_qclear', + 'insn_cmts_t_reserve', + 'insn_cmts_t_resize', + 'insn_cmts_t_resize__SWIG_0', + 'insn_cmts_t_resize__SWIG_1', + 'insn_cmts_t_size', + 'insn_cmts_t_swap', + 'insn_cmts_t_truncate', 'insn_create_stkvar', + 'insn_ops_repr_t_flags_get', + 'insn_ops_repr_t_flags_set', + 'insn_ops_repr_t_op0_get', + 'insn_ops_repr_t_op0_set', + 'insn_ops_repr_t_op1_get', + 'insn_ops_repr_t_op1_set', + 'insn_ops_reprs_t___getitem__', + 'insn_ops_reprs_t___len__', + 'insn_ops_reprs_t___setitem__', + 'insn_ops_reprs_t_at', + 'insn_ops_reprs_t_begin', + 'insn_ops_reprs_t_begin__SWIG_0', + 'insn_ops_reprs_t_begin__SWIG_1', + 'insn_ops_reprs_t_capacity', + 'insn_ops_reprs_t_clear', + 'insn_ops_reprs_t_empty', + 'insn_ops_reprs_t_end', + 'insn_ops_reprs_t_end__SWIG_0', + 'insn_ops_reprs_t_end__SWIG_1', + 'insn_ops_reprs_t_erase', + 'insn_ops_reprs_t_erase__SWIG_0', + 'insn_ops_reprs_t_erase__SWIG_1', + 'insn_ops_reprs_t_extract', + 'insn_ops_reprs_t_grow', + 'insn_ops_reprs_t_inject', + 'insn_ops_reprs_t_insert', + 'insn_ops_reprs_t_pop_back', + 'insn_ops_reprs_t_push_back', + 'insn_ops_reprs_t_push_back__SWIG_0', + 'insn_ops_reprs_t_push_back__SWIG_1', + 'insn_ops_reprs_t_qclear', + 'insn_ops_reprs_t_reserve', + 'insn_ops_reprs_t_resize', + 'insn_ops_reprs_t_resize__SWIG_0', + 'insn_ops_reprs_t_resize__SWIG_1', + 'insn_ops_reprs_t_size', + 'insn_ops_reprs_t_swap', + 'insn_ops_reprs_t_truncate', + 'insn_site_t_fchunk_nr_get', + 'insn_site_t_fchunk_nr_set', + 'insn_site_t_fchunk_off_get', + 'insn_site_t_fchunk_off_set', + 'insn_site_t_toea', 'insn_t___get_auxpref__', 'insn_t___get_operand__', 'insn_t___get_ops__', @@ -4107,7 +5179,6 @@ 'is_align', 'is_align_flow', 'is_align_insn', - 'is_allowed_on_small_struni', 'is_anonymous_member_name', 'is_assignment', 'is_attached_custom_data_format', @@ -4156,6 +5227,7 @@ 'is_enum1', 'is_enum_fromtil', 'is_enum_hidden', + 'is_filetype_like_binary', 'is_finally_visible_func', 'is_finally_visible_item', 'is_finally_visible_segm', @@ -4188,6 +5260,7 @@ 'is_inplace_def', 'is_insn_trace_enabled', 'is_invsign', + 'is_kreg', 'is_libitem', 'is_loaded', 'is_logical', @@ -4200,6 +5273,21 @@ 'is_manual', 'is_manual_insn', 'is_mapped', + 'is_may_access', + 'is_mcode_addsub', + 'is_mcode_call', + 'is_mcode_commutative', + 'is_mcode_convertible_to_jmp', + 'is_mcode_convertible_to_set', + 'is_mcode_divmod', + 'is_mcode_fpu', + 'is_mcode_j1', + 'is_mcode_jcond', + 'is_mcode_propagatable', + 'is_mcode_set', + 'is_mcode_set1', + 'is_mcode_shift', + 'is_mcode_xdsu', 'is_member_id', 'is_miniidb', 'is_msg_inited', @@ -4251,7 +5339,8 @@ 'is_seg0', 'is_seg1', 'is_segm_locked', - 'is_small_struni', + 'is_signed_mcode', + 'is_small_udt', 'is_spec_ea', 'is_spec_segm', 'is_special_member', @@ -4318,6 +5407,7 @@ 'is_unary', 'is_union', 'is_unknown', + 'is_unsigned_mcode', 'is_user_cc', 'is_usersp', 'is_userti', @@ -4337,15 +5427,61 @@ 'is_yword', 'is_zstroff', 'is_zword', + 'ivl_t___eq__', + 'ivl_t___ge__', + 'ivl_t___gt__', + 'ivl_t___le__', + 'ivl_t___lt__', + 'ivl_t___ne__', + 'ivl_t_clear', + 'ivl_t_compare', + 'ivl_t_contains', + 'ivl_t_dstr', + 'ivl_t_empty', + 'ivl_t_extend_to_cover', + 'ivl_t_includes', + 'ivl_t_intersect', + 'ivl_t_overlap', + 'ivl_with_name_t_ivl_get', + 'ivl_with_name_t_ivl_set', + 'ivl_with_name_t_part_get', + 'ivl_with_name_t_part_set', + 'ivl_with_name_t_whole_get', + 'ivl_with_name_t_whole_set', + 'ivlset_t___eq__', + 'ivlset_t___ge__', + 'ivlset_t___gt__', + 'ivlset_t___le__', + 'ivlset_t___lt__', + 'ivlset_t___ne__', + 'ivlset_t__print', + 'ivlset_t_add', + 'ivlset_t_add__SWIG_0', + 'ivlset_t_add__SWIG_1', + 'ivlset_t_add__SWIG_2', + 'ivlset_t_addmasked', + 'ivlset_t_compare', + 'ivlset_t_contains', + 'ivlset_t_count', + 'ivlset_t_dstr', + 'ivlset_t_has_common', + 'ivlset_t_has_common__SWIG_0', + 'ivlset_t_has_common__SWIG_1', + 'ivlset_t_includes', + 'ivlset_t_intersect', + 'ivlset_t_sub', + 'ivlset_t_sub__SWIG_0', + 'ivlset_t_sub__SWIG_1', + 'ivlset_t_sub__SWIG_2', + 'jcnd2set', 'jobj_wrapper_t_get_dict', 'jumpto', 'jumpto__SWIG_0', 'jumpto__SWIG_1', 'last_idcv_attr', 'leading_zero_important', + 'lexcompare', 'lexcompare_tinfo', - 'linput_buffer_t_eof', - 'linput_buffer_t_read', 'list_bptgrps', 'list_bptgrps__SWIG_0', 'list_bptgrps__SWIG_1', @@ -4387,8 +5523,6 @@ 'loader_t_flags_set', 'loader_t_version_get', 'loader_t_version_set', - 'locchange_md_t_is_sync', - 'locchange_md_t_reason', 'lochist_entry_t___eq__', 'lochist_entry_t___ne__', 'lochist_entry_t_acquire_place', @@ -4468,6 +5602,54 @@ 'lower_type', 'lowertype_helper_t_func_has_stkframe_hole', 'lowertype_helper_t_get_func_purged_bytes', + 'lumina_client_t_get_pop', + 'lumina_client_t_pull_md', + 'lumina_client_t_pull_md__SWIG_0', + 'lumina_client_t_pull_md__SWIG_1', + 'lumina_client_t_push_md', + 'lumina_client_t_push_md__SWIG_0', + 'lumina_client_t_push_md__SWIG_1', + 'lumina_client_t_set_pattern_id_md5', + 'lumina_op_res_vec_t___eq__', + 'lumina_op_res_vec_t___getitem__', + 'lumina_op_res_vec_t___len__', + 'lumina_op_res_vec_t___ne__', + 'lumina_op_res_vec_t___setitem__', + 'lumina_op_res_vec_t__del', + 'lumina_op_res_vec_t_add_unique', + 'lumina_op_res_vec_t_at', + 'lumina_op_res_vec_t_begin', + 'lumina_op_res_vec_t_begin__SWIG_0', + 'lumina_op_res_vec_t_begin__SWIG_1', + 'lumina_op_res_vec_t_capacity', + 'lumina_op_res_vec_t_clear', + 'lumina_op_res_vec_t_empty', + 'lumina_op_res_vec_t_end', + 'lumina_op_res_vec_t_end__SWIG_0', + 'lumina_op_res_vec_t_end__SWIG_1', + 'lumina_op_res_vec_t_erase', + 'lumina_op_res_vec_t_erase__SWIG_0', + 'lumina_op_res_vec_t_erase__SWIG_1', + 'lumina_op_res_vec_t_extract', + 'lumina_op_res_vec_t_find', + 'lumina_op_res_vec_t_find__SWIG_0', + 'lumina_op_res_vec_t_find__SWIG_1', + 'lumina_op_res_vec_t_grow', + 'lumina_op_res_vec_t_has', + 'lumina_op_res_vec_t_inject', + 'lumina_op_res_vec_t_insert', + 'lumina_op_res_vec_t_pop_back', + 'lumina_op_res_vec_t_push_back', + 'lumina_op_res_vec_t_push_back__SWIG_0', + 'lumina_op_res_vec_t_push_back__SWIG_1', + 'lumina_op_res_vec_t_qclear', + 'lumina_op_res_vec_t_reserve', + 'lumina_op_res_vec_t_resize', + 'lumina_op_res_vec_t_resize__SWIG_0', + 'lumina_op_res_vec_t_resize__SWIG_1', + 'lumina_op_res_vec_t_size', + 'lumina_op_res_vec_t_swap', + 'lumina_op_res_vec_t_truncate', 'lvar_locator_t___eq__', 'lvar_locator_t___ge__', 'lvar_locator_t___gt__', @@ -4510,6 +5692,20 @@ 'lvar_mapping_t_at', 'lvar_mapping_t_size', 'lvar_off', + 'lvar_ref_t___eq__', + 'lvar_ref_t___ge__', + 'lvar_ref_t___gt__', + 'lvar_ref_t___le__', + 'lvar_ref_t___lt__', + 'lvar_ref_t___ne__', + 'lvar_ref_t_compare', + 'lvar_ref_t_idx_get', + 'lvar_ref_t_idx_set', + 'lvar_ref_t_mba_get', + 'lvar_ref_t_off_get', + 'lvar_ref_t_off_set', + 'lvar_ref_t_swap', + 'lvar_ref_t_var', 'lvar_saved_info_t___eq__', 'lvar_saved_info_t___ne__', 'lvar_saved_info_t_clear_keep', @@ -4578,12 +5774,14 @@ 'lvar_t_append_list', 'lvar_t_clear_used', 'lvar_t_clr_arg_var', + 'lvar_t_clr_dummy_arg', 'lvar_t_clr_fake_var', 'lvar_t_clr_floating_var', 'lvar_t_clr_forced_var', 'lvar_t_clr_mapdst_var', 'lvar_t_clr_mreg_done', 'lvar_t_clr_noptr_var', + 'lvar_t_clr_notarg', 'lvar_t_clr_overlapped_var', 'lvar_t_clr_spoiled_var', 'lvar_t_clr_thisarg', @@ -4606,11 +5804,13 @@ 'lvar_t_has_user_type', 'lvar_t_is_aliasable', 'lvar_t_is_arg_var', + 'lvar_t_is_dummy_arg', 'lvar_t_is_fake_var', 'lvar_t_is_floating_var', 'lvar_t_is_forced_var', 'lvar_t_is_mapdst_var', 'lvar_t_is_noptr_var', + 'lvar_t_is_notarg', 'lvar_t_is_overlapped_var', 'lvar_t_is_result_var', 'lvar_t_is_spoiled_var', @@ -4620,6 +5820,7 @@ 'lvar_t_name_get', 'lvar_t_name_set', 'lvar_t_set_arg_var', + 'lvar_t_set_dummy_arg', 'lvar_t_set_fake_var', 'lvar_t_set_final_lvar_type', 'lvar_t_set_floating_var', @@ -4629,6 +5830,7 @@ 'lvar_t_set_mreg_done', 'lvar_t_set_non_typed', 'lvar_t_set_noptr_var', + 'lvar_t_set_notarg', 'lvar_t_set_overlapped_var', 'lvar_t_set_spoiled_var', 'lvar_t_set_thisarg', @@ -4647,6 +5849,7 @@ 'lvar_t_used', 'lvar_t_width_get', 'lvar_t_width_set', + 'lvar_uservec_t_clear', 'lvar_uservec_t_find_info', 'lvar_uservec_t_keep_info', 'lvar_uservec_t_lmaps_get', @@ -4682,6 +5885,431 @@ 'mark_position', 'may_create_stkvars', 'may_trace_sp', + 'mba_range_iterator_t_chunk', + 'mba_range_iterator_t_fii_get', + 'mba_range_iterator_t_fii_set', + 'mba_range_iterator_t_is_snippet', + 'mba_range_iterator_t_next', + 'mba_range_iterator_t_rii_get', + 'mba_range_iterator_t_rii_set', + 'mba_range_iterator_t_set', + 'mba_ranges_t_clear', + 'mba_ranges_t_empty', + 'mba_ranges_t_is_fragmented', + 'mba_ranges_t_is_snippet', + 'mba_ranges_t_pfn_get', + 'mba_ranges_t_pfn_set', + 'mba_ranges_t_ranges_get', + 'mba_ranges_t_ranges_set', + 'mba_ranges_t_start', + 'mbl_array_t__deregister', + 'mbl_array_t__print', + 'mbl_array_t__register', + 'mbl_array_t_aliased_args_get', + 'mbl_array_t_aliased_args_set', + 'mbl_array_t_aliased_memory_get', + 'mbl_array_t_aliased_memory_set', + 'mbl_array_t_aliased_vars_get', + 'mbl_array_t_aliased_vars_set', + 'mbl_array_t_alloc_lvars', + 'mbl_array_t_analyze_calls', + 'mbl_array_t_arg', + 'mbl_array_t_arg__SWIG_0', + 'mbl_array_t_arg__SWIG_1', + 'mbl_array_t_argbase', + 'mbl_array_t_argidx_get', + 'mbl_array_t_argidx_ok', + 'mbl_array_t_argidx_set', + 'mbl_array_t_bad_call_sp_detected', + 'mbl_array_t_blocks_get', + 'mbl_array_t_blocks_set', + 'mbl_array_t_build_graph', + 'mbl_array_t_calc_shins_flags', + 'mbl_array_t_callinfo_built', + 'mbl_array_t_cc_get', + 'mbl_array_t_cc_set', + 'mbl_array_t_chain_varnums_ok', + 'mbl_array_t_clr_cdtr', + 'mbl_array_t_clr_mba_flags', + 'mbl_array_t_clr_mba_flags2', + 'mbl_array_t_combine_blocks', + 'mbl_array_t_common_stkvars_stkargs', + 'mbl_array_t_consumed_argregs_get', + 'mbl_array_t_consumed_argregs_set', + 'mbl_array_t_copy_block', + 'mbl_array_t_deleted_pairs', + 'mbl_array_t_deserialize', + 'mbl_array_t_display_numaddrs', + 'mbl_array_t_display_valnums', + 'mbl_array_t_dump', + 'mbl_array_t_dump_mba', + 'mbl_array_t_dump_mba__varargs__', + 'mbl_array_t_entry_ea_get', + 'mbl_array_t_entry_ea_set', + 'mbl_array_t_error_ea_get', + 'mbl_array_t_error_ea_set', + 'mbl_array_t_error_strarg_get', + 'mbl_array_t_error_strarg_set', + 'mbl_array_t_final_type_get', + 'mbl_array_t_final_type_set', + 'mbl_array_t_find_mop', + 'mbl_array_t_first_epilog_ea_get', + 'mbl_array_t_first_epilog_ea_set', + 'mbl_array_t_for_all_insns', + 'mbl_array_t_for_all_ops', + 'mbl_array_t_for_all_topinsns', + 'mbl_array_t_fpd_get', + 'mbl_array_t_fpd_set', + 'mbl_array_t_frregs_get', + 'mbl_array_t_frregs_set', + 'mbl_array_t_frsize_get', + 'mbl_array_t_frsize_set', + 'mbl_array_t_fti_flags_get', + 'mbl_array_t_fti_flags_set', + 'mbl_array_t_fullsize_get', + 'mbl_array_t_fullsize_set', + 'mbl_array_t_generated_asserts', + 'mbl_array_t_get_args_region', + 'mbl_array_t_get_curfunc', + 'mbl_array_t_get_graph', + 'mbl_array_t_get_ida_argloc', + 'mbl_array_t_get_lvars_region', + 'mbl_array_t_get_mba_flags', + 'mbl_array_t_get_mba_flags2', + 'mbl_array_t_get_mblock', + 'mbl_array_t_get_mblock__SWIG_0', + 'mbl_array_t_get_mblock__SWIG_1', + 'mbl_array_t_get_shadow_region', + 'mbl_array_t_get_stack_region', + 'mbl_array_t_get_std_region', + 'mbl_array_t_gotoff_stkvars_get', + 'mbl_array_t_gotoff_stkvars_set', + 'mbl_array_t_graph_insns', + 'mbl_array_t_has_bad_sp', + 'mbl_array_t_has_over_chains', + 'mbl_array_t_has_overvars', + 'mbl_array_t_has_passregs', + 'mbl_array_t_idaloc2vd', + 'mbl_array_t_idb_node_get', + 'mbl_array_t_idb_node_set', + 'mbl_array_t_idb_spoiled_get', + 'mbl_array_t_idb_spoiled_set', + 'mbl_array_t_idb_type_get', + 'mbl_array_t_idb_type_set', + 'mbl_array_t_inargoff_get', + 'mbl_array_t_inargoff_set', + 'mbl_array_t_insert_block', + 'mbl_array_t_is_cdtr', + 'mbl_array_t_is_ctr', + 'mbl_array_t_is_dtr', + 'mbl_array_t_is_pattern', + 'mbl_array_t_is_snippet', + 'mbl_array_t_is_stkarg', + 'mbl_array_t_is_thunk', + 'mbl_array_t_label_get', + 'mbl_array_t_label_set', + 'mbl_array_t_last_prolog_ea_get', + 'mbl_array_t_last_prolog_ea_set', + 'mbl_array_t_loaded_gdl', + 'mbl_array_t_lvar_names_ok', + 'mbl_array_t_lvars_allocated', + 'mbl_array_t_lvars_renamed', + 'mbl_array_t_mark_chains_dirty', + 'mbl_array_t_maturity_get', + 'mbl_array_t_maturity_set', + 'mbl_array_t_may_refine_rettype', + 'mbl_array_t_mbr_get', + 'mbl_array_t_mbr_set', + 'mbl_array_t_minargref_get', + 'mbl_array_t_minargref_set', + 'mbl_array_t_minstkref_ea_get', + 'mbl_array_t_minstkref_ea_set', + 'mbl_array_t_minstkref_get', + 'mbl_array_t_minstkref_set', + 'mbl_array_t_natural_get', + 'mbl_array_t_natural_set', + 'mbl_array_t_nodel_memory_get', + 'mbl_array_t_nodel_memory_set', + 'mbl_array_t_notes_get', + 'mbl_array_t_notes_set', + 'mbl_array_t_npurged_get', + 'mbl_array_t_npurged_set', + 'mbl_array_t_occurred_warns_get', + 'mbl_array_t_occurred_warns_set', + 'mbl_array_t_optimize_global', + 'mbl_array_t_optimize_local', + 'mbl_array_t_optimized', + 'mbl_array_t_pfn_flags_get', + 'mbl_array_t_pfn_flags_set', + 'mbl_array_t_precise_defeas', + 'mbl_array_t_propagated_asserts', + 'mbl_array_t_qty_get', + 'mbl_array_t_qty_set', + 'mbl_array_t_really_alloc', + 'mbl_array_t_regargs_is_not_aligned', + 'mbl_array_t_remove_block', + 'mbl_array_t_remove_empty_blocks', + 'mbl_array_t_reqmat_get', + 'mbl_array_t_reqmat_set', + 'mbl_array_t_restricted_memory_get', + 'mbl_array_t_restricted_memory_set', + 'mbl_array_t_retsize_get', + 'mbl_array_t_retsize_set', + 'mbl_array_t_returns_fpval', + 'mbl_array_t_retvaridx_get', + 'mbl_array_t_retvaridx_set', + 'mbl_array_t_rtype_refined', + 'mbl_array_t_saverest_done', + 'mbl_array_t_serialize', + 'mbl_array_t_set_mba_flags', + 'mbl_array_t_set_mba_flags2', + 'mbl_array_t_shadow_args_get', + 'mbl_array_t_shadow_args_set', + 'mbl_array_t_short_display', + 'mbl_array_t_should_beautify', + 'mbl_array_t_show_reduction', + 'mbl_array_t_spd_adjust_get', + 'mbl_array_t_spd_adjust_set', + 'mbl_array_t_spoiled_list_get', + 'mbl_array_t_spoiled_list_set', + 'mbl_array_t_stacksize_get', + 'mbl_array_t_stacksize_set', + 'mbl_array_t_std_ivls_get', + 'mbl_array_t_std_ivls_set', + 'mbl_array_t_stkoff_ida2vd', + 'mbl_array_t_stkoff_vd2ida', + 'mbl_array_t_term', + 'mbl_array_t_tmpstk_size_get', + 'mbl_array_t_tmpstk_size_set', + 'mbl_array_t_use_frame', + 'mbl_array_t_use_wingraph32', + 'mbl_array_t_valranges_done', + 'mbl_array_t_vars_get', + 'mbl_array_t_vars_set', + 'mbl_array_t_vd2idaloc', + 'mbl_array_t_vd2idaloc__SWIG_0', + 'mbl_array_t_vd2idaloc__SWIG_1', + 'mbl_array_t_verify', + 'mbl_array_t_write_to_const_detected', + 'mbl_graph_t_get_chain_stamp', + 'mbl_graph_t_get_du', + 'mbl_graph_t_get_mblock', + 'mbl_graph_t_get_ud', + 'mbl_graph_t_is_du_chain_dirty', + 'mbl_graph_t_is_redefined_globally', + 'mbl_graph_t_is_ud_chain_dirty', + 'mbl_graph_t_is_used_globally', + 'mblock_t__print', + 'mblock_t_append_def_list', + 'mblock_t_append_use_list', + 'mblock_t_build_def_list', + 'mblock_t_build_lists', + 'mblock_t_build_use_list', + 'mblock_t_dead_at_start_get', + 'mblock_t_dead_at_start_set', + 'mblock_t_dnu_get', + 'mblock_t_dnu_set', + 'mblock_t_dump', + 'mblock_t_dump_block', + 'mblock_t_dump_block__varargs__', + 'mblock_t_empty', + 'mblock_t_end_get', + 'mblock_t_end_set', + 'mblock_t_find_access', + 'mblock_t_find_def', + 'mblock_t_find_first_use', + 'mblock_t_find_redefinition', + 'mblock_t_find_use', + 'mblock_t_flags_get', + 'mblock_t_flags_set', + 'mblock_t_for_all_insns', + 'mblock_t_for_all_ops', + 'mblock_t_for_all_uses', + 'mblock_t_get_reginsn_qty', + 'mblock_t_get_valranges', + 'mblock_t_get_valranges__SWIG_0', + 'mblock_t_get_valranges__SWIG_1', + 'mblock_t_head_get', + 'mblock_t_head_set', + 'mblock_t_insert_into_block', + 'mblock_t_is_branch', + 'mblock_t_is_call_block', + 'mblock_t_is_nway', + 'mblock_t_is_redefined', + 'mblock_t_is_rhs_redefined', + 'mblock_t_is_simple_goto_block', + 'mblock_t_is_simple_jcnd_block', + 'mblock_t_is_unknown_call', + 'mblock_t_is_used', + 'mblock_t_lists_dirty', + 'mblock_t_lists_ready', + 'mblock_t_make_lists_ready', + 'mblock_t_make_nop', + 'mblock_t_mark_lists_dirty', + 'mblock_t_maxbsp_get', + 'mblock_t_maxbsp_set', + 'mblock_t_maybdef_get', + 'mblock_t_maybdef_set', + 'mblock_t_maybuse_get', + 'mblock_t_maybuse_set', + 'mblock_t_mba_get', + 'mblock_t_mba_set', + 'mblock_t_minbargref_get', + 'mblock_t_minbargref_set', + 'mblock_t_minbstkref_get', + 'mblock_t_minbstkref_set', + 'mblock_t_mustbdef_get', + 'mblock_t_mustbdef_set', + 'mblock_t_mustbuse_get', + 'mblock_t_mustbuse_set', + 'mblock_t_needs_propagation', + 'mblock_t_nextb_get', + 'mblock_t_nextb_set', + 'mblock_t_npred', + 'mblock_t_nsucc', + 'mblock_t_optimize_block', + 'mblock_t_optimize_insn', + 'mblock_t_optimize_useless_jump', + 'mblock_t_pred', + 'mblock_t_predset_get', + 'mblock_t_predset_set', + 'mblock_t_prevb_get', + 'mblock_t_prevb_set', + 'mblock_t_remove_from_block', + 'mblock_t_request_demote64', + 'mblock_t_request_propagation', + 'mblock_t_serial_get', + 'mblock_t_serial_set', + 'mblock_t_start_get', + 'mblock_t_start_set', + 'mblock_t_succ', + 'mblock_t_succset_get', + 'mblock_t_succset_set', + 'mblock_t_tail_get', + 'mblock_t_tail_set', + 'mblock_t_type_get', + 'mblock_t_type_set', + 'mcallarg_t__print', + 'mcallarg_t_argloc_get', + 'mcallarg_t_argloc_set', + 'mcallarg_t_copy_mop', + 'mcallarg_t_dstr', + 'mcallarg_t_ea_get', + 'mcallarg_t_ea_set', + 'mcallarg_t_make_int', + 'mcallarg_t_make_uint', + 'mcallarg_t_name_get', + 'mcallarg_t_name_set', + 'mcallarg_t_set_regarg', + 'mcallarg_t_set_regarg__SWIG_0', + 'mcallarg_t_set_regarg__SWIG_1', + 'mcallarg_t_set_regarg__SWIG_2', + 'mcallarg_t_type_get', + 'mcallarg_t_type_set', + 'mcallargs_t___eq__', + 'mcallargs_t___getitem__', + 'mcallargs_t___len__', + 'mcallargs_t___ne__', + 'mcallargs_t___setitem__', + 'mcallargs_t__del', + 'mcallargs_t_add_unique', + 'mcallargs_t_at', + 'mcallargs_t_begin', + 'mcallargs_t_begin__SWIG_0', + 'mcallargs_t_begin__SWIG_1', + 'mcallargs_t_capacity', + 'mcallargs_t_clear', + 'mcallargs_t_empty', + 'mcallargs_t_end', + 'mcallargs_t_end__SWIG_0', + 'mcallargs_t_end__SWIG_1', + 'mcallargs_t_erase', + 'mcallargs_t_erase__SWIG_0', + 'mcallargs_t_erase__SWIG_1', + 'mcallargs_t_extract', + 'mcallargs_t_find', + 'mcallargs_t_find__SWIG_0', + 'mcallargs_t_find__SWIG_1', + 'mcallargs_t_grow', + 'mcallargs_t_has', + 'mcallargs_t_inject', + 'mcallargs_t_insert', + 'mcallargs_t_pop_back', + 'mcallargs_t_push_back', + 'mcallargs_t_push_back__SWIG_0', + 'mcallargs_t_push_back__SWIG_1', + 'mcallargs_t_qclear', + 'mcallargs_t_reserve', + 'mcallargs_t_resize', + 'mcallargs_t_resize__SWIG_0', + 'mcallargs_t_resize__SWIG_1', + 'mcallargs_t_size', + 'mcallargs_t_swap', + 'mcallargs_t_truncate', + 'mcallinfo_t__print', + 'mcallinfo_t_args_get', + 'mcallinfo_t_args_set', + 'mcallinfo_t_call_spd_get', + 'mcallinfo_t_call_spd_set', + 'mcallinfo_t_callee_get', + 'mcallinfo_t_callee_set', + 'mcallinfo_t_cc_get', + 'mcallinfo_t_cc_set', + 'mcallinfo_t_dead_regs_get', + 'mcallinfo_t_dead_regs_set', + 'mcallinfo_t_dstr', + 'mcallinfo_t_flags_get', + 'mcallinfo_t_flags_set', + 'mcallinfo_t_get_type', + 'mcallinfo_t_is_vararg', + 'mcallinfo_t_lexcompare', + 'mcallinfo_t_pass_regs_get', + 'mcallinfo_t_pass_regs_set', + 'mcallinfo_t_retregs_get', + 'mcallinfo_t_retregs_set', + 'mcallinfo_t_return_argloc_get', + 'mcallinfo_t_return_argloc_set', + 'mcallinfo_t_return_regs_get', + 'mcallinfo_t_return_regs_set', + 'mcallinfo_t_return_type_get', + 'mcallinfo_t_return_type_set', + 'mcallinfo_t_role_get', + 'mcallinfo_t_role_set', + 'mcallinfo_t_set_type', + 'mcallinfo_t_solid_args_get', + 'mcallinfo_t_solid_args_set', + 'mcallinfo_t_spoiled_get', + 'mcallinfo_t_spoiled_set', + 'mcallinfo_t_stkargs_top_get', + 'mcallinfo_t_stkargs_top_set', + 'mcallinfo_t_visible_memory_get', + 'mcallinfo_t_visible_memory_set', + 'mcases_t___eq__', + 'mcases_t___ge__', + 'mcases_t___gt__', + 'mcases_t___le__', + 'mcases_t___lt__', + 'mcases_t___ne__', + 'mcases_t__print', + 'mcases_t_compare', + 'mcases_t_dstr', + 'mcases_t_empty', + 'mcases_t_resize', + 'mcases_t_size', + 'mcases_t_swap', + 'mcases_t_targets_get', + 'mcases_t_targets_set', + 'mcases_t_values_get', + 'mcases_t_values_set', + 'mcode_modifies_d', + 'md_type_parts_t___eq__', + 'md_type_parts_t___ne__', + 'md_type_parts_t_fields_get', + 'md_type_parts_t_fields_set', + 'md_type_parts_t_type_get', + 'md_type_parts_t_type_set', + 'md_type_parts_t_userti_get', + 'md_type_parts_t_userti_set', 'mem2base', 'member_t_by_til', 'member_t_eoff_get', @@ -4788,8 +6416,173 @@ 'memreg_infos_t_size', 'memreg_infos_t_swap', 'memreg_infos_t_truncate', + 'metadata_iterator_t_data_end', + 'metadata_iterator_t_data_get', + 'metadata_iterator_t_data_set', + 'metadata_iterator_t_key_get', + 'metadata_iterator_t_key_set', + 'metadata_iterator_t_next', + 'metadata_iterator_t_size_get', + 'metadata_iterator_t_size_set', 'microcode_filter_t_apply', 'microcode_filter_t_match', + 'minsn_t___dbg_get_meminfo', + 'minsn_t___dbg_get_registered_kind', + 'minsn_t___lt__', + 'minsn_t__deregister', + 'minsn_t__make_nop', + 'minsn_t__obj_id', + 'minsn_t__print', + 'minsn_t__register', + 'minsn_t_clr_assert', + 'minsn_t_clr_combinable', + 'minsn_t_clr_combined', + 'minsn_t_clr_fpinsn', + 'minsn_t_clr_ignlowsrc', + 'minsn_t_clr_multimov', + 'minsn_t_clr_noret_icall', + 'minsn_t_clr_propagatable', + 'minsn_t_clr_tailcall', + 'minsn_t_contains_call', + 'minsn_t_contains_opcode', + 'minsn_t_d_get', + 'minsn_t_d_set', + 'minsn_t_dstr', + 'minsn_t_ea_get', + 'minsn_t_ea_set', + 'minsn_t_equal_insns', + 'minsn_t_find_call', + 'minsn_t_find_ins_op', + 'minsn_t_find_num_op', + 'minsn_t_find_opcode', + 'minsn_t_find_opcode__SWIG_0', + 'minsn_t_find_opcode__SWIG_1', + 'minsn_t_for_all_insns', + 'minsn_t_for_all_ops', + 'minsn_t_get_role', + 'minsn_t_get_split_size', + 'minsn_t_has_side_effects', + 'minsn_t_iprops_get', + 'minsn_t_iprops_set', + 'minsn_t_is_after', + 'minsn_t_is_alloca', + 'minsn_t_is_assert', + 'minsn_t_is_between', + 'minsn_t_is_bswap', + 'minsn_t_is_cleaning_pop', + 'minsn_t_is_combinable', + 'minsn_t_is_combined', + 'minsn_t_is_extstx', + 'minsn_t_is_farcall', + 'minsn_t_is_fpinsn', + 'minsn_t_is_helper', + 'minsn_t_is_ignlowsrc', + 'minsn_t_is_inverted_jx', + 'minsn_t_is_like_move', + 'minsn_t_is_memcpy', + 'minsn_t_is_memset', + 'minsn_t_is_mov', + 'minsn_t_is_multimov', + 'minsn_t_is_noret_call', + 'minsn_t_is_optional', + 'minsn_t_is_persistent', + 'minsn_t_is_propagatable', + 'minsn_t_is_readflags', + 'minsn_t_is_tailcall', + 'minsn_t_is_unknown_call', + 'minsn_t_is_wild_match', + 'minsn_t_l_get', + 'minsn_t_l_set', + 'minsn_t_lexcompare', + 'minsn_t_may_use_aliased_memory', + 'minsn_t_modifes_d', + 'minsn_t_modifies_pair_mop', + 'minsn_t_next_get', + 'minsn_t_next_set', + 'minsn_t_opcode_get', + 'minsn_t_opcode_set', + 'minsn_t_optimize_solo', + 'minsn_t_optimize_subtree', + 'minsn_t_prev_get', + 'minsn_t_prev_set', + 'minsn_t_r_get', + 'minsn_t_r_set', + 'minsn_t_set_assert', + 'minsn_t_set_cleaning_pop', + 'minsn_t_set_combinable', + 'minsn_t_set_extstx', + 'minsn_t_set_farcall', + 'minsn_t_set_fpinsn', + 'minsn_t_set_ignlowsrc', + 'minsn_t_set_inverted_jx', + 'minsn_t_set_multimov', + 'minsn_t_set_noret_icall', + 'minsn_t_set_optional', + 'minsn_t_set_persistent', + 'minsn_t_set_split_size', + 'minsn_t_set_tailcall', + 'minsn_t_set_wild_match', + 'minsn_t_setaddr', + 'minsn_t_swap', + 'minsn_t_was_noret_icall', + 'minsn_t_was_split', + 'minsn_visitor_t_visit_minsn', + 'mlist_mop_visitor_t_changed_get', + 'mlist_mop_visitor_t_changed_set', + 'mlist_mop_visitor_t_curins_get', + 'mlist_mop_visitor_t_curins_set', + 'mlist_mop_visitor_t_list_get', + 'mlist_mop_visitor_t_list_set', + 'mlist_mop_visitor_t_topins_get', + 'mlist_mop_visitor_t_topins_set', + 'mlist_mop_visitor_t_visit_mop', + 'mlist_t___eq__', + 'mlist_t___ge__', + 'mlist_t___gt__', + 'mlist_t___le__', + 'mlist_t___lt__', + 'mlist_t___ne__', + 'mlist_t__print', + 'mlist_t_add', + 'mlist_t_add__SWIG_0', + 'mlist_t_add__SWIG_1', + 'mlist_t_add__SWIG_2', + 'mlist_t_add__SWIG_3', + 'mlist_t_addmem', + 'mlist_t_clear', + 'mlist_t_compare', + 'mlist_t_count', + 'mlist_t_dstr', + 'mlist_t_empty', + 'mlist_t_has', + 'mlist_t_has_all', + 'mlist_t_has_any', + 'mlist_t_has_common', + 'mlist_t_has_memory', + 'mlist_t_includes', + 'mlist_t_intersect', + 'mlist_t_is_subset_of', + 'mlist_t_mem_get', + 'mlist_t_mem_set', + 'mlist_t_reg_get', + 'mlist_t_reg_set', + 'mlist_t_sub', + 'mlist_t_sub__SWIG_0', + 'mlist_t_sub__SWIG_1', + 'mlist_t_sub__SWIG_2', + 'mlist_t_swap', + 'mnumber_t___eq__', + 'mnumber_t___ge__', + 'mnumber_t___gt__', + 'mnumber_t___le__', + 'mnumber_t___lt__', + 'mnumber_t___ne__', + 'mnumber_t_compare', + 'mnumber_t_org_value_get', + 'mnumber_t_org_value_set', + 'mnumber_t_update_value', + 'mnumber_t_value_get', + 'mnumber_t_value_set', 'modify_user_lvars', 'modinfo_t_base_get', 'modinfo_t_base_set', @@ -4799,14 +6592,211 @@ 'modinfo_t_rebase_to_set', 'modinfo_t_size_get', 'modinfo_t_size_set', + 'mop_addr_t_insize_get', + 'mop_addr_t_insize_set', + 'mop_addr_t_lexcompare', + 'mop_addr_t_outsize_get', + 'mop_addr_t_outsize_set', + 'mop_pair_t_hop_get', + 'mop_pair_t_hop_set', + 'mop_pair_t_lop_get', + 'mop_pair_t_lop_set', + 'mop_t___dbg_get_meminfo', + 'mop_t___dbg_get_registered_kind', + 'mop_t___eq__', + 'mop_t___lt__', + 'mop_t___ne__', + 'mop_t__deregister', + 'mop_t__get_a', + 'mop_t__get_b', + 'mop_t__get_c', + 'mop_t__get_cstr', + 'mop_t__get_d', + 'mop_t__get_f', + 'mop_t__get_fpc', + 'mop_t__get_g', + 'mop_t__get_helper', + 'mop_t__get_l', + 'mop_t__get_nnn', + 'mop_t__get_pair', + 'mop_t__get_r', + 'mop_t__get_s', + 'mop_t__get_scif', + 'mop_t__get_t', + 'mop_t__make_blkref', + 'mop_t__make_callinfo', + 'mop_t__make_cases', + 'mop_t__make_gvar', + 'mop_t__make_insn', + 'mop_t__make_lvar', + 'mop_t__make_pair', + 'mop_t__make_reg', + 'mop_t__make_reg__SWIG_0', + 'mop_t__make_reg__SWIG_1', + 'mop_t__make_stkvar', + 'mop_t__make_strlit', + 'mop_t__obj_id', + 'mop_t__print', + 'mop_t__register', + 'mop_t__set_a', + 'mop_t__set_b', + 'mop_t__set_c', + 'mop_t__set_cstr', + 'mop_t__set_d', + 'mop_t__set_f', + 'mop_t__set_fpc', + 'mop_t__set_g', + 'mop_t__set_helper', + 'mop_t__set_l', + 'mop_t__set_nnn', + 'mop_t__set_pair', + 'mop_t__set_r', + 'mop_t__set_s', + 'mop_t__set_scif', + 'mop_t__set_t', + 'mop_t_apply_ld_mcode', + 'mop_t_apply_xds', + 'mop_t_apply_xdu', + 'mop_t_assign', + 'mop_t_change_size', + 'mop_t_create_from_insn', + 'mop_t_create_from_ivlset', + 'mop_t_create_from_mlist', + 'mop_t_create_from_scattered_vdloc', + 'mop_t_create_from_vdloc', + 'mop_t_double_size', + 'mop_t_dstr', + 'mop_t_equal_mops', + 'mop_t_erase', + 'mop_t_erase_but_keep_size', + 'mop_t_for_all_ops', + 'mop_t_for_all_scattered_submops', + 'mop_t_get_insn', + 'mop_t_get_insn__SWIG_0', + 'mop_t_get_insn__SWIG_1', + 'mop_t_get_stkoff', + 'mop_t_get_stkvar', + 'mop_t_has_side_effects', + 'mop_t_is01', + 'mop_t_is_bit_reg', + 'mop_t_is_bit_reg__SWIG_0', + 'mop_t_is_bit_reg__SWIG_1', + 'mop_t_is_cc', + 'mop_t_is_ccflags', + 'mop_t_is_constant', + 'mop_t_is_equal_to', + 'mop_t_is_extended_from', + 'mop_t_is_glbaddr', + 'mop_t_is_glbaddr__SWIG_0', + 'mop_t_is_glbaddr__SWIG_1', + 'mop_t_is_impptr_done', + 'mop_t_is_insn', + 'mop_t_is_insn__SWIG_0', + 'mop_t_is_insn__SWIG_1', + 'mop_t_is_kreg', + 'mop_t_is_mob', + 'mop_t_is_negative_constant', + 'mop_t_is_one', + 'mop_t_is_positive_constant', + 'mop_t_is_reg', + 'mop_t_is_reg__SWIG_0', + 'mop_t_is_reg__SWIG_1', + 'mop_t_is_reg__SWIG_2', + 'mop_t_is_scattered', + 'mop_t_is_sign_extended_from', + 'mop_t_is_stkaddr', + 'mop_t_is_udt', + 'mop_t_is_undef_val', + 'mop_t_is_zero', + 'mop_t_is_zero_extended_from', + 'mop_t_lexcompare', + 'mop_t_make_blkref', + 'mop_t_make_first_half', + 'mop_t_make_fpnum', + 'mop_t_make_gvar', + 'mop_t_make_helper', + 'mop_t_make_high_half', + 'mop_t_make_insn', + 'mop_t_make_low_half', + 'mop_t_make_number', + 'mop_t_make_reg', + 'mop_t_make_reg__SWIG_0', + 'mop_t_make_reg__SWIG_1', + 'mop_t_make_reg_pair', + 'mop_t_make_second_half', + 'mop_t_may_use_aliased_memory', + 'mop_t_oprops_get', + 'mop_t_oprops_set', + 'mop_t_preserve_side_effects', + 'mop_t_probably_floating', + 'mop_t_set_impptr_done', + 'mop_t_set_udt', + 'mop_t_set_undef_val', + 'mop_t_shift_mop', + 'mop_t_signed_value', + 'mop_t_size_get', + 'mop_t_size_set', + 'mop_t_swap', + 'mop_t_t_get', + 'mop_t_t_set', + 'mop_t_unsigned_value', + 'mop_t_valnum_get', + 'mop_t_valnum_set', + 'mop_t_value', + 'mop_t_zero', + 'mop_visitor_t_prune_get', + 'mop_visitor_t_prune_set', + 'mop_visitor_t_visit_mop', + 'mopvec_t___eq__', + 'mopvec_t___getitem__', + 'mopvec_t___len__', + 'mopvec_t___ne__', + 'mopvec_t___setitem__', + 'mopvec_t__del', + 'mopvec_t_add_unique', + 'mopvec_t_at', + 'mopvec_t_begin', + 'mopvec_t_begin__SWIG_0', + 'mopvec_t_begin__SWIG_1', + 'mopvec_t_capacity', + 'mopvec_t_clear', + 'mopvec_t_empty', + 'mopvec_t_end', + 'mopvec_t_end__SWIG_0', + 'mopvec_t_end__SWIG_1', + 'mopvec_t_erase', + 'mopvec_t_erase__SWIG_0', + 'mopvec_t_erase__SWIG_1', + 'mopvec_t_extract', + 'mopvec_t_find', + 'mopvec_t_find__SWIG_0', + 'mopvec_t_find__SWIG_1', + 'mopvec_t_grow', + 'mopvec_t_has', + 'mopvec_t_inject', + 'mopvec_t_insert', + 'mopvec_t_pop_back', + 'mopvec_t_push_back', + 'mopvec_t_push_back__SWIG_0', + 'mopvec_t_push_back__SWIG_1', + 'mopvec_t_qclear', + 'mopvec_t_reserve', + 'mopvec_t_resize', + 'mopvec_t_resize__SWIG_0', + 'mopvec_t_resize__SWIG_1', + 'mopvec_t_size', + 'mopvec_t_swap', + 'mopvec_t_truncate', 'move_bpt_to_grp', 'move_idcv', 'move_segm', 'move_segm_start', + 'mreg2reg', 'msg', 'msg_clear', 'msg_get_lines', 'msg_save', + 'must_mcode_close_block', 'mutable_graph_t_belongs_get', 'mutable_graph_t_belongs_set', 'mutable_graph_t_calc_group_ea', @@ -4869,6 +6859,7 @@ 'mutable_graph_t_succs_set', 'mutable_graph_t_succset', 'nbits', + 'negate_mcode_relation', 'negated_relation', 'netnode___eq__', 'netnode___eq____SWIG_0', @@ -5018,6 +7009,15 @@ 'new_argpart_t', 'new_argpart_t__SWIG_0', 'new_argpart_t__SWIG_1', + 'new_argpartvec_t', + 'new_argpartvec_t__SWIG_0', + 'new_argpartvec_t__SWIG_1', + 'new_array_of_bitsets', + 'new_array_of_bitsets__SWIG_0', + 'new_array_of_bitsets__SWIG_1', + 'new_array_of_ivlsets', + 'new_array_of_ivlsets__SWIG_0', + 'new_array_of_ivlsets__SWIG_1', 'new_array_of_rangesets', 'new_array_of_rangesets__SWIG_0', 'new_array_of_rangesets__SWIG_1', @@ -5028,6 +7028,14 @@ 'new_bgcolors_t', 'new_bit_bound_t', 'new_bitfield_type_data_t', + 'new_bitset_t', + 'new_bitset_t__SWIG_0', + 'new_bitset_t__SWIG_1', + 'new_block_chains_iterator_t', + 'new_block_chains_t', + 'new_block_chains_vec_t', + 'new_block_chains_vec_t__SWIG_0', + 'new_block_chains_vec_t__SWIG_1', 'new_boolvec_t', 'new_boolvec_t__SWIG_0', 'new_boolvec_t__SWIG_1', @@ -5078,6 +7086,12 @@ 'new_cfuncptr_t__SWIG_0', 'new_cfuncptr_t__SWIG_1', 'new_cgoto_t', + 'new_chain_keeper_t', + 'new_chain_t', + 'new_chain_t__SWIG_0', + 'new_chain_t__SWIG_1', + 'new_chain_t__SWIG_2', + 'new_chain_visitor_t', 'new_channel_redir_t', 'new_chooser_item_attrs_t', 'new_cif_t', @@ -5152,6 +7166,9 @@ 'new_edge_t__SWIG_1', 'new_enum_const_t', 'new_enum_member_t', + 'new_enum_member_vec_t', + 'new_enum_member_vec_t__SWIG_0', + 'new_enum_member_vec_t__SWIG_1', 'new_enum_member_visitor_t', 'new_enum_type_data_t', 'new_eval_ctx_t', @@ -5162,15 +7179,42 @@ 'new_excvec_t', 'new_excvec_t__SWIG_0', 'new_excvec_t__SWIG_1', + 'new_extra_cmt_t', + 'new_extra_cmts_t', + 'new_extra_cmts_t__SWIG_0', + 'new_extra_cmts_t__SWIG_1', 'new_fixup_data_t', 'new_fixup_data_t__SWIG_0', 'new_fixup_data_t__SWIG_1', 'new_fixup_info_t', 'new_fnum_array', 'new_fnumber_t', + 'new_frame_desc_t', + 'new_frame_mem_t', + 'new_frame_mems_t', + 'new_frame_mems_t__SWIG_0', + 'new_frame_mems_t__SWIG_1', + 'new_func_info_and_frequency_t', + 'new_func_info_and_frequency_vec_t', + 'new_func_info_and_frequency_vec_t__SWIG_0', + 'new_func_info_and_frequency_vec_t__SWIG_1', + 'new_func_info_and_pattern_t', + 'new_func_info_and_pattern_vec_t', + 'new_func_info_and_pattern_vec_t__SWIG_0', + 'new_func_info_and_pattern_vec_t__SWIG_1', + 'new_func_info_base_t', + 'new_func_info_pattern_and_frequency_t', + 'new_func_info_pattern_and_frequency_vec_t', + 'new_func_info_pattern_and_frequency_vec_t__SWIG_0', + 'new_func_info_pattern_and_frequency_vec_t__SWIG_1', + 'new_func_info_t', + 'new_func_info_vec_t', + 'new_func_info_vec_t__SWIG_0', + 'new_func_info_vec_t__SWIG_1', 'new_func_item_iterator_t', 'new_func_item_iterator_t__SWIG_0', 'new_func_item_iterator_t__SWIG_1', + 'new_func_md_diff_handler_t', 'new_func_parent_iterator_t', 'new_func_parent_iterator_t__SWIG_0', 'new_func_parent_iterator_t__SWIG_1', @@ -5183,6 +7227,8 @@ 'new_funcargvec_t', 'new_funcargvec_t__SWIG_0', 'new_funcargvec_t__SWIG_1', + 'new_gco_info_t', + 'new_graph_chains_t', 'new_graph_item_t', 'new_graph_location_info_t', 'new_graph_node_visitor_t', @@ -5199,6 +7245,7 @@ 'new_hexwarns_t__SWIG_1', 'new_hidden_range_t', 'new_highlighter_cbs_t', + 'new_history_entries_helper_t', 'new_history_item_t', 'new_history_item_t__SWIG_0', 'new_history_item_t__SWIG_1', @@ -5211,12 +7258,21 @@ 'new_idc_value_t__SWIG_0', 'new_idc_value_t__SWIG_1', 'new_idc_value_t__SWIG_2', - 'new_idc_value_t__SWIG_3', 'new_idc_values_t', 'new_idc_values_t__SWIG_0', 'new_idc_values_t__SWIG_1', 'new_idp_desc_t', 'new_idp_name_t', + 'new_input_file_t', + 'new_insn_cmt_t', + 'new_insn_cmts_t', + 'new_insn_cmts_t__SWIG_0', + 'new_insn_cmts_t__SWIG_1', + 'new_insn_ops_repr_t', + 'new_insn_ops_reprs_t', + 'new_insn_ops_reprs_t__SWIG_0', + 'new_insn_ops_reprs_t__SWIG_1', + 'new_insn_site_t', 'new_insn_t', 'new_instant_dbgopts_t', 'new_int_pointer', @@ -5227,11 +7283,14 @@ 'new_intvec_t', 'new_intvec_t__SWIG_0', 'new_intvec_t__SWIG_1', - 'new_linput_buffer_t', + 'new_ivl_t', + 'new_ivl_with_name_t', + 'new_ivlset_t', + 'new_ivlset_t__SWIG_0', + 'new_ivlset_t__SWIG_1', 'new_llabel_t', 'new_loader_input_t', 'new_loader_t', - 'new_locchange_md_t', 'new_lochist_entry_t', 'new_lochist_entry_t__SWIG_0', 'new_lochist_entry_t__SWIG_1', @@ -5242,17 +7301,36 @@ 'new_longlongvec_t', 'new_longlongvec_t__SWIG_0', 'new_longlongvec_t__SWIG_1', + 'new_lumina_op_res_vec_t', + 'new_lumina_op_res_vec_t__SWIG_0', + 'new_lumina_op_res_vec_t__SWIG_1', 'new_lvar_locator_t', 'new_lvar_locator_t__SWIG_0', 'new_lvar_locator_t__SWIG_1', 'new_lvar_mapping_iterator_t', 'new_lvar_mapping_t', + 'new_lvar_ref_t', + 'new_lvar_ref_t__SWIG_0', + 'new_lvar_ref_t__SWIG_1', 'new_lvar_saved_info_t', 'new_lvar_saved_infos_t', 'new_lvar_saved_infos_t__SWIG_0', 'new_lvar_saved_infos_t__SWIG_1', 'new_lvar_uservec_t', 'new_lvars_t', + 'new_mba_range_iterator_t', + 'new_mba_ranges_t', + 'new_mba_ranges_t__SWIG_0', + 'new_mba_ranges_t__SWIG_1', + 'new_mcallarg_t', + 'new_mcallarg_t__SWIG_0', + 'new_mcallarg_t__SWIG_1', + 'new_mcallargs_t', + 'new_mcallargs_t__SWIG_0', + 'new_mcallargs_t__SWIG_1', + 'new_mcallinfo_t', + 'new_mcases_t', + 'new_md_type_parts_t', 'new_member_t', 'new_meminfo_vec_t', 'new_meminfo_vec_t__SWIG_0', @@ -5262,8 +7340,32 @@ 'new_memreg_infos_t', 'new_memreg_infos_t__SWIG_0', 'new_memreg_infos_t__SWIG_1', + 'new_metadata_iterator_t', 'new_microcode_filter_t', + 'new_minsn_t', + 'new_minsn_t__SWIG_0', + 'new_minsn_t__SWIG_1', + 'new_minsn_visitor_t', + 'new_mlist_mop_visitor_t', + 'new_mlist_t', + 'new_mlist_t__SWIG_0', + 'new_mlist_t__SWIG_1', + 'new_mlist_t__SWIG_2', + 'new_mnumber_t', 'new_modinfo_t', + 'new_mop_addr_t', + 'new_mop_addr_t__SWIG_0', + 'new_mop_addr_t__SWIG_1', + 'new_mop_addr_t__SWIG_2', + 'new_mop_pair_t', + 'new_mop_t', + 'new_mop_t__SWIG_0', + 'new_mop_t__SWIG_1', + 'new_mop_t__SWIG_2', + 'new_mop_visitor_t', + 'new_mopvec_t', + 'new_mopvec_t__SWIG_0', + 'new_mopvec_t__SWIG_1', 'new_netnode', 'new_netnode__SWIG_0', 'new_netnode__SWIG_1', @@ -5275,11 +7377,31 @@ 'new_node_layout_t__SWIG_1', 'new_node_ordering_t', 'new_number_format_t', + 'new_op_parent_info_t', 'new_op_t', 'new_operand_locator_t', 'new_operands_array', 'new_operator_info_t', 'new_opinfo_t', + 'new_oprepr_t', + 'new_optblock_t', + 'new_optinsn_t', + 'new_packet', + 'new_pattern_id_t', + 'new_pkt_clean_db_t', + 'new_pkt_debugctl_t', + 'new_pkt_dump_md_result_t', + 'new_pkt_dump_md_t', + 'new_pkt_get_pop_result_t', + 'new_pkt_get_pop_t', + 'new_pkt_helo_t', + 'new_pkt_pull_md_result_t', + 'new_pkt_pull_md_t', + 'new_pkt_push_md_result_t', + 'new_pkt_push_md_t', + 'new_pkt_rpc_fail_t', + 'new_pkt_rpc_notify_t', + 'new_pkt_rpc_ok_t', 'new_plugin_info_t', 'new_point_t', 'new_point_t__SWIG_0', @@ -5288,6 +7410,7 @@ 'new_pointvec_t', 'new_pointvec_t__SWIG_0', 'new_pointvec_t__SWIG_1', + 'new_pop_fun_t', 'new_predicate_t', 'new_printop_t', 'new_process_info_t', @@ -5295,6 +7418,8 @@ 'new_procinfo_vec_t__SWIG_0', 'new_procinfo_vec_t__SWIG_1', 'new_ptr_type_data_t', + 'new_push_md_opts_t', + 'new_push_md_result_t', 'new_qbasic_block_t', 'new_qfile_t', 'new_qfile_t__SWIG_0', @@ -5345,8 +7470,12 @@ 'new_reginfovec_t', 'new_reginfovec_t__SWIG_0', 'new_reginfovec_t__SWIG_1', + 'new_register_info_t', 'new_regobj_t', 'new_regobjs_t', + 'new_regobjvec_t', + 'new_regobjvec_t__SWIG_0', + 'new_regobjvec_t__SWIG_1', 'new_regval_t', 'new_regval_t__SWIG_0', 'new_regval_t__SWIG_1', @@ -5355,10 +7484,19 @@ 'new_renderer_info_pos_t', 'new_renderer_info_t', 'new_renderer_pos_info_t', + 'new_rlist_t', + 'new_rlist_t__SWIG_0', + 'new_rlist_t__SWIG_1', + 'new_rlist_t__SWIG_2', 'new_row_info_t', 'new_rrel_t', 'new_scattered_aloc_t', 'new_scattered_segm_t', + 'new_scif_t', + 'new_scif_visitor_t', + 'new_screen_graph_selection_base_t', + 'new_screen_graph_selection_base_t__SWIG_0', + 'new_screen_graph_selection_base_t__SWIG_1', 'new_screen_graph_selection_t', 'new_segm_move_info_t', 'new_segm_move_info_vec_t', @@ -5374,20 +7512,25 @@ 'new_selection_item_t__SWIG_1', 'new_selection_item_t__SWIG_2', 'new_selection_item_t__SWIG_3', + 'new_serialized_tinfo', 'new_simd_info_t', 'new_simpleline_t', 'new_simpleline_t__SWIG_0', 'new_simpleline_t__SWIG_1', 'new_simpleline_t__SWIG_2', - 'new_simpleline_t__SWIG_3', 'new_sizevec_t', 'new_sizevec_t__SWIG_0', 'new_sizevec_t__SWIG_1', + 'new_skipped_func_t', + 'new_skipped_funcs_t', + 'new_skipped_funcs_t__SWIG_0', + 'new_skipped_funcs_t__SWIG_1', 'new_snapshot_t', 'new_sreg_range_t', 'new_stkpnt_array', 'new_stkpnt_t', 'new_stkpnts_t', + 'new_stkvar_ref_t', 'new_strarray_t', 'new_string_info_t', 'new_string_info_t__SWIG_0', @@ -5401,6 +7544,9 @@ 'new_strwinsetup_t', 'new_sval_pointer', 'new_switch_info_t', + 'new_sync_source_t', + 'new_sync_source_t__SWIG_0', + 'new_sync_source_t__SWIG_1', 'new_tev_info_reg_t', 'new_tev_info_t', 'new_tev_reg_value_t', @@ -5451,6 +7597,11 @@ 'new_udtmembervec_t__SWIG_0', 'new_udtmembervec_t__SWIG_1', 'new_ui_requests_t', + 'new_ui_stroff_applicator_t', + 'new_ui_stroff_op_t', + 'new_ui_stroff_ops_t', + 'new_ui_stroff_ops_t__SWIG_0', + 'new_ui_stroff_ops_t__SWIG_1', 'new_uintvec_t', 'new_uintvec_t__SWIG_0', 'new_uintvec_t__SWIG_1', @@ -5459,6 +7610,7 @@ 'new_ulonglongvec_t__SWIG_1', 'new_user_cmts_iterator_t', 'new_user_cmts_t', + 'new_user_identification_t', 'new_user_iflags_iterator_t', 'new_user_iflags_t', 'new_user_labels_iterator_t', @@ -5466,11 +7618,26 @@ 'new_user_lvar_modifier_t', 'new_user_numforms_iterator_t', 'new_user_numforms_t', + 'new_user_stkpnt_t', + 'new_user_stkpnts_t', + 'new_user_stkpnts_t__SWIG_0', + 'new_user_stkpnts_t__SWIG_1', 'new_user_unions_iterator_t', 'new_user_unions_t', 'new_uval_array', + 'new_uval_ivl_ivlset_t', + 'new_uval_ivl_ivlset_t__SWIG_0', + 'new_uval_ivl_ivlset_t__SWIG_1', + 'new_uval_ivl_t', + 'new_uval_ivl_t__SWIG_1', + 'new_valrng_t', + 'new_valrng_t__SWIG_0', + 'new_valrng_t__SWIG_1', 'new_valstr_t', 'new_valstrs_t', + 'new_valstrvec_t', + 'new_valstrvec_t__SWIG_0', + 'new_valstrvec_t__SWIG_1', 'new_var_ref_t', 'new_vc_printer_t', 'new_vd_failure_t', @@ -5479,12 +7646,18 @@ 'new_vd_failure_t__SWIG_2', 'new_vd_failure_t__SWIG_3', 'new_vd_interr_t', - 'new_vd_interr_t__SWIG_0', - 'new_vd_interr_t__SWIG_1', 'new_vd_printer_t', 'new_vdloc_t', 'new_view_mouse_event_location_t', 'new_view_mouse_event_t', + 'new_vivl_t', + 'new_vivl_t__SWIG_0', + 'new_vivl_t__SWIG_1', + 'new_vivl_t__SWIG_2', + 'new_voff_t', + 'new_voff_t__SWIG_0', + 'new_voff_t__SWIG_1', + 'new_voff_t__SWIG_2', 'new_xrefblk_t', 'new_xreflist_entry_t', 'new_xreflist_t', @@ -5566,7 +7739,6 @@ 'node_ordering_t_size', 'nomem', 'nomem__varargs__', - 'notify_when', 'num_flag', 'number_format_t_flags_get', 'number_format_t_flags_set', @@ -5604,6 +7776,14 @@ 'op_oct', 'op_offset', 'op_offset_ex', + 'op_parent_info_t_blk_get', + 'op_parent_info_t_blk_set', + 'op_parent_info_t_curins_get', + 'op_parent_info_t_curins_set', + 'op_parent_info_t_mba_get', + 'op_parent_info_t_mba_set', + 'op_parent_info_t_topins_get', + 'op_parent_info_t_topins_set', 'op_plain_offset', 'op_seg', 'op_stkvar', @@ -5712,7 +7892,17 @@ 'opinfo_t_strtype_set', 'opinfo_t_tid_get', 'opinfo_t_tid_set', + 'oprepr_t_flags_get', + 'oprepr_t_flags_set', + 'oprepr_t_opinfo_get', + 'oprepr_t_opinfo_set', + 'optblock_t_func', + 'optblock_t_install', + 'optblock_t_remove', 'optimize_argloc', + 'optinsn_t_func', + 'optinsn_t_install', + 'optinsn_t_remove', 'outctx_base_t__from_ptrval__', 'outctx_base_t_close_comment', 'outctx_base_t_clr_gen_label', @@ -5799,6 +7989,7 @@ 'outctx_t_out_specea', 'outctx_t_retrieve_cmt', 'outctx_t_retrieve_name', + 'outctx_t_set_bin_state', 'outctx_t_setup_outctx', 'outctx_t_wif_get', 'outctx_t_wif_set', @@ -5821,6 +8012,10 @@ 'patch_fixup_value', 'patch_qword', 'patch_word', + 'pattern_id_t_data_get', + 'pattern_id_t_data_set', + 'pattern_id_t_type_get', + 'pattern_id_t_type_set', 'peek_auto_queue', 'ph_calcrel', 'ph_find_op_value', @@ -5842,6 +8037,56 @@ 'ph_get_segreg_size', 'ph_get_tbyte_size', 'ph_get_version', + 'pkt_debugctl_t_args_get', + 'pkt_debugctl_t_args_set', + 'pkt_dump_md_result_t_contents_get', + 'pkt_dump_md_result_t_contents_set', + 'pkt_dump_md_t_sort_get', + 'pkt_dump_md_t_sort_set', + 'pkt_get_pop_result_t_results_get', + 'pkt_get_pop_result_t_results_set', + 'pkt_get_pop_t_nresults_get', + 'pkt_get_pop_t_nresults_set', + 'pkt_helo_t_client_version_get', + 'pkt_helo_t_client_version_set', + 'pkt_helo_t_key_get', + 'pkt_helo_t_key_set', + 'pkt_helo_t_license_id_get', + 'pkt_helo_t_license_id_set', + 'pkt_helo_t_record_conv_get', + 'pkt_helo_t_record_conv_set', + 'pkt_pull_md_result_t_codes_get', + 'pkt_pull_md_result_t_codes_set', + 'pkt_pull_md_result_t_results_get', + 'pkt_pull_md_result_t_results_set', + 'pkt_pull_md_t_flags_get', + 'pkt_pull_md_t_flags_set', + 'pkt_pull_md_t_keys_get', + 'pkt_pull_md_t_keys_set', + 'pkt_pull_md_t_pattern_ids_get', + 'pkt_pull_md_t_pattern_ids_set', + 'pkt_push_md_result_t_codes_get', + 'pkt_push_md_result_t_codes_set', + 'pkt_push_md_t_contents_get', + 'pkt_push_md_t_contents_set', + 'pkt_push_md_t_ea64s_get', + 'pkt_push_md_t_ea64s_set', + 'pkt_push_md_t_flags_get', + 'pkt_push_md_t_flags_set', + 'pkt_push_md_t_hostname_get', + 'pkt_push_md_t_hostname_set', + 'pkt_push_md_t_idb_get', + 'pkt_push_md_t_idb_set', + 'pkt_push_md_t_input_get', + 'pkt_push_md_t_input_set', + 'pkt_rpc_fail_t_error_get', + 'pkt_rpc_fail_t_error_set', + 'pkt_rpc_fail_t_result_get', + 'pkt_rpc_fail_t_result_set', + 'pkt_rpc_notify_t_text_get', + 'pkt_rpc_notify_t_text_set', + 'pkt_rpc_notify_t_type_get', + 'pkt_rpc_notify_t_type_set', 'place_t__print', 'place_t_adjust', 'place_t_as_enumplace_t', @@ -5945,6 +8190,12 @@ 'pointvec_t_size', 'pointvec_t_swap', 'pointvec_t_truncate', + 'pop_fun_t_ea64_get', + 'pop_fun_t_ea64_set', + 'pop_fun_t_hostname_get', + 'pop_fun_t_hostname_set', + 'pop_fun_t_input_get', + 'pop_fun_t_input_set', 'predicate_t_should_display', 'prev_addr', 'prev_chunk', @@ -6027,6 +8278,16 @@ 'ptr_type_data_t_swap', 'ptr_type_data_t_taptr_bits_get', 'ptr_type_data_t_taptr_bits_set', + 'push_md_opts_t_eas_get', + 'push_md_opts_t_eas_set', + 'push_md_opts_t_min_func_size_get', + 'push_md_opts_t_min_func_size_set', + 'push_md_result_t_codes_get', + 'push_md_result_t_codes_set', + 'push_md_result_t_contents_get', + 'push_md_result_t_contents_set', + 'push_md_result_t_eas_get', + 'push_md_result_t_eas_set', 'put_byte', 'put_bytes', 'put_dbg_byte', @@ -6064,7 +8325,6 @@ 'pyscv_close', 'pyscv_count', 'pyscv_del_line', - 'pyscv_delete', 'pyscv_edit_line', 'pyscv_get_current_line', 'pyscv_get_current_word', @@ -6078,7 +8338,6 @@ 'pyscv_jumpto', 'pyscv_patch_line', 'pyscv_refresh', - 'pyscv_refresh_current', 'pyscv_show', 'pyw_convert_defvals', 'pyw_register_idc_func', @@ -6568,6 +8827,7 @@ 'refresh_idaview_anyway', 'refresh_navband', 'refresh_viewer', + 'reg2mreg', 'reg_data_type', 'reg_delete', 'reg_delete_subkey', @@ -6651,6 +8911,18 @@ 'register_and_attach_to_menu', 'register_custom_data_format', 'register_custom_data_type', + 'register_info_t_bit_strings_get', + 'register_info_t_bit_strings_set', + 'register_info_t_default_bit_strings_mask_get', + 'register_info_t_default_bit_strings_mask_set', + 'register_info_t_dtype_get', + 'register_info_t_dtype_set', + 'register_info_t_flags_get', + 'register_info_t_flags_set', + 'register_info_t_name_get', + 'register_info_t_name_set', + 'register_info_t_register_class_get', + 'register_info_t_register_class_set', 'register_timer', 'regobj_t_regidx_get', 'regobj_t_regidx_set', @@ -6659,14 +8931,40 @@ 'regobj_t_size', 'regobj_t_value_get', 'regobj_t_value_set', + 'regobjvec_t___getitem__', + 'regobjvec_t___len__', + 'regobjvec_t___setitem__', + 'regobjvec_t_at', + 'regobjvec_t_begin', + 'regobjvec_t_begin__SWIG_0', + 'regobjvec_t_begin__SWIG_1', + 'regobjvec_t_capacity', + 'regobjvec_t_clear', + 'regobjvec_t_empty', + 'regobjvec_t_end', + 'regobjvec_t_end__SWIG_0', + 'regobjvec_t_end__SWIG_1', + 'regobjvec_t_erase', + 'regobjvec_t_erase__SWIG_0', + 'regobjvec_t_erase__SWIG_1', + 'regobjvec_t_extract', + 'regobjvec_t_grow', + 'regobjvec_t_inject', + 'regobjvec_t_insert', + 'regobjvec_t_pop_back', + 'regobjvec_t_push_back', + 'regobjvec_t_push_back__SWIG_0', + 'regobjvec_t_push_back__SWIG_1', + 'regobjvec_t_qclear', + 'regobjvec_t_reserve', + 'regobjvec_t_resize', + 'regobjvec_t_resize__SWIG_0', + 'regobjvec_t_resize__SWIG_1', + 'regobjvec_t_size', + 'regobjvec_t_swap', + 'regobjvec_t_truncate', 'regval_t___eq__', 'regval_t___ne__', - 'regval_t__set_bytes', - 'regval_t__set_bytes__SWIG_0', - 'regval_t__set_bytes__SWIG_1', - 'regval_t__set_bytes__SWIG_2', - 'regval_t__set_float', - 'regval_t__set_int', 'regval_t_bytes', 'regval_t_bytes__SWIG_0', 'regval_t_bytes__SWIG_1', @@ -6687,6 +8985,7 @@ 'regval_t_set_bytes__SWIG_2', 'regval_t_set_float', 'regval_t_set_int', + 'regval_t_set_unavailable', 'regval_t_swap', 'regvar_array___getitem__', 'regvar_array___len__', @@ -6804,6 +9103,8 @@ 'retrieve_member_info', 'revert_byte', 'revert_ida_decisions', + 'revert_metadata', + 'rlist_t_dstr', 'row_info_t_bottom_get', 'row_info_t_bottom_set', 'row_info_t_height', @@ -6831,7 +9132,55 @@ 'save_user_unions', 'scattered_segm_t_name_get', 'scattered_segm_t_name_set', + 'scif_t_mba_get', + 'scif_t_mba_set', + 'scif_t_name_get', + 'scif_t_name_set', + 'scif_t_type_get', + 'scif_t_type_set', + 'scif_visitor_t_visit_scif_mop', + 'score_metadata', 'score_tinfo', + 'screen_graph_selection_base_t___eq__', + 'screen_graph_selection_base_t___getitem__', + 'screen_graph_selection_base_t___len__', + 'screen_graph_selection_base_t___ne__', + 'screen_graph_selection_base_t___setitem__', + 'screen_graph_selection_base_t__del', + 'screen_graph_selection_base_t_add_unique', + 'screen_graph_selection_base_t_at', + 'screen_graph_selection_base_t_begin', + 'screen_graph_selection_base_t_begin__SWIG_0', + 'screen_graph_selection_base_t_begin__SWIG_1', + 'screen_graph_selection_base_t_capacity', + 'screen_graph_selection_base_t_clear', + 'screen_graph_selection_base_t_empty', + 'screen_graph_selection_base_t_end', + 'screen_graph_selection_base_t_end__SWIG_0', + 'screen_graph_selection_base_t_end__SWIG_1', + 'screen_graph_selection_base_t_erase', + 'screen_graph_selection_base_t_erase__SWIG_0', + 'screen_graph_selection_base_t_erase__SWIG_1', + 'screen_graph_selection_base_t_extract', + 'screen_graph_selection_base_t_find', + 'screen_graph_selection_base_t_find__SWIG_0', + 'screen_graph_selection_base_t_find__SWIG_1', + 'screen_graph_selection_base_t_grow', + 'screen_graph_selection_base_t_has', + 'screen_graph_selection_base_t_inject', + 'screen_graph_selection_base_t_insert', + 'screen_graph_selection_base_t_pop_back', + 'screen_graph_selection_base_t_push_back', + 'screen_graph_selection_base_t_push_back__SWIG_0', + 'screen_graph_selection_base_t_push_back__SWIG_1', + 'screen_graph_selection_base_t_qclear', + 'screen_graph_selection_base_t_reserve', + 'screen_graph_selection_base_t_resize', + 'screen_graph_selection_base_t_resize__SWIG_0', + 'screen_graph_selection_base_t_resize__SWIG_1', + 'screen_graph_selection_base_t_size', + 'screen_graph_selection_base_t_swap', + 'screen_graph_selection_base_t_truncate', 'screen_graph_selection_t_add', 'screen_graph_selection_t_add_node', 'screen_graph_selection_t_add_point', @@ -6960,6 +9309,7 @@ 'sel_pointer_frompointer', 'sel_pointer_value', 'select_thread', + 'select_udt_by_offset', 'selection_item_t___eq__', 'selection_item_t___lt__', 'selection_item_t___ne__', @@ -6972,6 +9322,11 @@ 'selection_item_t_node_set', 'send_database', 'serialize_tinfo', + 'serialized_tinfo_fields_get', + 'serialized_tinfo_fields_set', + 'serialized_tinfo_type_get', + 'serialized_tinfo_type_set', + 'set2jcnd', 'set__bnot0', 'set__bnot1', 'set__invsign0', @@ -7093,7 +9448,6 @@ 'set_reg_val', 'set_reg_val__SWIG_0', 'set_reg_val__SWIG_1', - 'set_reg_val__SWIG_2', 'set_regvar_cmt', 'set_remote_debugger', 'set_resume_mode', @@ -7146,14 +9500,9 @@ 'set_visible_segm', 'set_zstroff', 'setup_selector', - 'should_create_stkvars', - 'should_trace_sp', 'show_addr', - 'show_all_comments', 'show_auto', - 'show_comments', 'show_name', - 'show_repeatables', 'show_wait_box', 'show_wait_box__varargs__', 'simd_info_t_match_pattern', @@ -7165,6 +9514,27 @@ 'simd_info_t_size_set', 'simd_info_t_tif_get', 'simd_info_t_tif_set', + 'simple_diff_handler_t_indent_get', + 'simple_diff_handler_t_indent_set', + 'simple_diff_handler_t_lines_get', + 'simple_diff_handler_t_lines_set', + 'simple_diff_handler_t_on_comment_changed', + 'simple_diff_handler_t_on_extra_comment_changed', + 'simple_diff_handler_t_on_frame_member_changed', + 'simple_diff_handler_t_on_function_comment_changed', + 'simple_diff_handler_t_on_insn_ops_repr_changed', + 'simple_diff_handler_t_on_name_changed', + 'simple_diff_handler_t_on_proto_changed', + 'simple_diff_handler_t_on_score_changed', + 'simple_diff_handler_t_on_user_stkpnt_changed', + 'simple_graph_t_colored_gdl_edges_get', + 'simple_graph_t_colored_gdl_edges_set', + 'simple_graph_t_title_get', + 'simple_graph_t_title_set', + 'simple_idb_diff_handler_t_header_generated_get', + 'simple_idb_diff_handler_t_header_generated_set', + 'simple_idb_diff_handler_t_pfn_get', + 'simple_idb_diff_handler_t_pfn_set', 'simpleline_place_t_n_get', 'simpleline_place_t_n_set', 'simpleline_t_bgcolor_get', @@ -7214,6 +9584,42 @@ 'sizevec_t_size', 'sizevec_t_swap', 'sizevec_t_truncate', + 'skipped_func_t_count_get', + 'skipped_func_t_count_set', + 'skipped_func_t_pattern_id_get', + 'skipped_func_t_pattern_id_set', + 'skipped_funcs_t___getitem__', + 'skipped_funcs_t___len__', + 'skipped_funcs_t___setitem__', + 'skipped_funcs_t_at', + 'skipped_funcs_t_begin', + 'skipped_funcs_t_begin__SWIG_0', + 'skipped_funcs_t_begin__SWIG_1', + 'skipped_funcs_t_capacity', + 'skipped_funcs_t_clear', + 'skipped_funcs_t_empty', + 'skipped_funcs_t_end', + 'skipped_funcs_t_end__SWIG_0', + 'skipped_funcs_t_end__SWIG_1', + 'skipped_funcs_t_erase', + 'skipped_funcs_t_erase__SWIG_0', + 'skipped_funcs_t_erase__SWIG_1', + 'skipped_funcs_t_extract', + 'skipped_funcs_t_grow', + 'skipped_funcs_t_inject', + 'skipped_funcs_t_insert', + 'skipped_funcs_t_pop_back', + 'skipped_funcs_t_push_back', + 'skipped_funcs_t_push_back__SWIG_0', + 'skipped_funcs_t_push_back__SWIG_1', + 'skipped_funcs_t_qclear', + 'skipped_funcs_t_reserve', + 'skipped_funcs_t_resize', + 'skipped_funcs_t_resize__SWIG_0', + 'skipped_funcs_t_resize__SWIG_1', + 'skipped_funcs_t_size', + 'skipped_funcs_t_swap', + 'skipped_funcs_t_truncate', 'snapshot_t___eq__', 'snapshot_t___ge__', 'snapshot_t___gt__', @@ -7231,6 +9637,8 @@ 'snapshot_t_flags_set', 'snapshot_t_id_get', 'snapshot_t_id_set', + 'soff_to_fpoff', + 'split_metadata', 'split_sreg_range', 'srcdbg_request_step_into', 'srcdbg_request_step_over', @@ -7252,12 +9660,37 @@ 'stkpnt_array___setitem__', 'stkpnt_array_count_get', 'stkpnt_array_data_get', + 'stkpnt_t___eq__', + 'stkpnt_t___ge__', + 'stkpnt_t___gt__', + 'stkpnt_t___le__', 'stkpnt_t___lt__', + 'stkpnt_t___ne__', + 'stkpnt_t_compare', 'stkpnt_t_ea_get', 'stkpnt_t_ea_set', 'stkpnt_t_spd_get', 'stkpnt_t_spd_set', + 'stkpnts_t___eq__', + 'stkpnts_t___ge__', + 'stkpnts_t___gt__', + 'stkpnts_t___le__', + 'stkpnts_t___lt__', + 'stkpnts_t___ne__', + 'stkpnts_t_compare', 'stkvar_flag', + 'stkvar_ref_t___eq__', + 'stkvar_ref_t___ge__', + 'stkvar_ref_t___gt__', + 'stkvar_ref_t___le__', + 'stkvar_ref_t___lt__', + 'stkvar_ref_t___ne__', + 'stkvar_ref_t_compare', + 'stkvar_ref_t_get_stkvar', + 'stkvar_ref_t_mba_get', + 'stkvar_ref_t_off_get', + 'stkvar_ref_t_off_set', + 'stkvar_ref_t_swap', 'store_exceptions', 'store_til', 'str2ea', @@ -7369,6 +9802,7 @@ 'sval_pointer_frompointer', 'sval_pointer_value', 'swap_idcvs', + 'swap_mcode_relation', 'swapped_relation', 'switch_info_t__from_ptrval__', 'switch_info_t__get_values_lowcase', @@ -7421,6 +9855,13 @@ 'switch_info_t_startea_get', 'switch_info_t_startea_set', 'switch_info_t_use_std_table', + 'sync_source_t___eq__', + 'sync_source_t___ne__', + 'sync_source_t_get_register', + 'sync_source_t_get_widget', + 'sync_source_t_is_register', + 'sync_source_t_is_widget', + 'sync_sources', 'tag_addr', 'tag_advance', 'tag_remove', @@ -7525,6 +9966,7 @@ 'thread_name_t_name_set', 'thread_name_t_tid_get', 'thread_name_t_tid_set', + 'throw_idc_exception', 'tid_array___getitem__', 'tid_array___setitem__', 'tid_array_cast', @@ -7573,6 +10015,7 @@ 'tinfo_t_compare', 'tinfo_t_compare_with', 'tinfo_t_convert_array_to_ptr', + 'tinfo_t_copy', 'tinfo_t_create_array', 'tinfo_t_create_array__SWIG_0', 'tinfo_t_create_array__SWIG_1', @@ -7596,7 +10039,6 @@ 'tinfo_t_deserialize', 'tinfo_t_deserialize__SWIG_0', 'tinfo_t_deserialize__SWIG_1', - 'tinfo_t_deserialize__SWIG_2', 'tinfo_t_dstr', 'tinfo_t_empty', 'tinfo_t_equals_to', @@ -7732,6 +10174,7 @@ 'tinfo_t_is_unsigned', 'tinfo_t_is_user_cc', 'tinfo_t_is_vararg_cc', + 'tinfo_t_is_varstruct', 'tinfo_t_is_vftable', 'tinfo_t_is_void', 'tinfo_t_is_volatile', @@ -7915,6 +10358,13 @@ 'udcall_map_prev', 'udcall_map_second', 'udcall_map_size', + 'udcall_t___eq__', + 'udcall_t___ge__', + 'udcall_t___gt__', + 'udcall_t___le__', + 'udcall_t___lt__', + 'udcall_t___ne__', + 'udcall_t_compare', 'udcall_t_name_get', 'udcall_t_name_set', 'udcall_t_tif_get', @@ -8018,6 +10468,53 @@ 'udtmembervec_t_truncate', 'ui_load_new_file', 'ui_run_debugger', + 'ui_stroff_applicator_t_apply', + 'ui_stroff_op_t___eq__', + 'ui_stroff_op_t___ne__', + 'ui_stroff_op_t_offset_get', + 'ui_stroff_op_t_offset_set', + 'ui_stroff_op_t_text_get', + 'ui_stroff_op_t_text_set', + 'ui_stroff_ops_t___eq__', + 'ui_stroff_ops_t___getitem__', + 'ui_stroff_ops_t___len__', + 'ui_stroff_ops_t___ne__', + 'ui_stroff_ops_t___setitem__', + 'ui_stroff_ops_t__del', + 'ui_stroff_ops_t_add_unique', + 'ui_stroff_ops_t_at', + 'ui_stroff_ops_t_begin', + 'ui_stroff_ops_t_begin__SWIG_0', + 'ui_stroff_ops_t_begin__SWIG_1', + 'ui_stroff_ops_t_capacity', + 'ui_stroff_ops_t_clear', + 'ui_stroff_ops_t_empty', + 'ui_stroff_ops_t_end', + 'ui_stroff_ops_t_end__SWIG_0', + 'ui_stroff_ops_t_end__SWIG_1', + 'ui_stroff_ops_t_erase', + 'ui_stroff_ops_t_erase__SWIG_0', + 'ui_stroff_ops_t_erase__SWIG_1', + 'ui_stroff_ops_t_extract', + 'ui_stroff_ops_t_find', + 'ui_stroff_ops_t_find__SWIG_0', + 'ui_stroff_ops_t_find__SWIG_1', + 'ui_stroff_ops_t_grow', + 'ui_stroff_ops_t_has', + 'ui_stroff_ops_t_inject', + 'ui_stroff_ops_t_insert', + 'ui_stroff_ops_t_pop_back', + 'ui_stroff_ops_t_push_back', + 'ui_stroff_ops_t_push_back__SWIG_0', + 'ui_stroff_ops_t_push_back__SWIG_1', + 'ui_stroff_ops_t_qclear', + 'ui_stroff_ops_t_reserve', + 'ui_stroff_ops_t_resize', + 'ui_stroff_ops_t_resize__SWIG_0', + 'ui_stroff_ops_t_resize__SWIG_1', + 'ui_stroff_ops_t_size', + 'ui_stroff_ops_t_swap', + 'ui_stroff_ops_t_truncate', 'uintvec_t___eq__', 'uintvec_t___getitem__', 'uintvec_t___len__', @@ -8144,6 +10641,12 @@ 'user_cmts_t_size', 'user_graph_place_t_node_get', 'user_graph_place_t_node_set', + 'user_identification_t_email_get', + 'user_identification_t_email_set', + 'user_identification_t_license_id_get', + 'user_identification_t_license_id_set', + 'user_identification_t_user_name_get', + 'user_identification_t_user_name_set', 'user_iflags_begin', 'user_iflags_clear', 'user_iflags_end', @@ -8202,6 +10705,40 @@ 'user_numforms_size', 'user_numforms_t_at', 'user_numforms_t_size', + 'user_stkpnt_t_delta_get', + 'user_stkpnt_t_delta_set', + 'user_stkpnts_t___getitem__', + 'user_stkpnts_t___len__', + 'user_stkpnts_t___setitem__', + 'user_stkpnts_t_at', + 'user_stkpnts_t_begin', + 'user_stkpnts_t_begin__SWIG_0', + 'user_stkpnts_t_begin__SWIG_1', + 'user_stkpnts_t_capacity', + 'user_stkpnts_t_clear', + 'user_stkpnts_t_empty', + 'user_stkpnts_t_end', + 'user_stkpnts_t_end__SWIG_0', + 'user_stkpnts_t_end__SWIG_1', + 'user_stkpnts_t_erase', + 'user_stkpnts_t_erase__SWIG_0', + 'user_stkpnts_t_erase__SWIG_1', + 'user_stkpnts_t_extract', + 'user_stkpnts_t_grow', + 'user_stkpnts_t_inject', + 'user_stkpnts_t_insert', + 'user_stkpnts_t_pop_back', + 'user_stkpnts_t_push_back', + 'user_stkpnts_t_push_back__SWIG_0', + 'user_stkpnts_t_push_back__SWIG_1', + 'user_stkpnts_t_qclear', + 'user_stkpnts_t_reserve', + 'user_stkpnts_t_resize', + 'user_stkpnts_t_resize__SWIG_0', + 'user_stkpnts_t_resize__SWIG_1', + 'user_stkpnts_t_size', + 'user_stkpnts_t_swap', + 'user_stkpnts_t_truncate', 'user_unions_begin', 'user_unions_clear', 'user_unions_end', @@ -8226,8 +10763,70 @@ 'uval_array___setitem__', 'uval_array_cast', 'uval_array_frompointer', + 'uval_ivl_ivlset_t___eq__', + 'uval_ivl_ivlset_t___ne__', + 'uval_ivl_ivlset_t_all_values', + 'uval_ivl_ivlset_t_begin', + 'uval_ivl_ivlset_t_begin__SWIG_0', + 'uval_ivl_ivlset_t_begin__SWIG_1', + 'uval_ivl_ivlset_t_clear', + 'uval_ivl_ivlset_t_empty', + 'uval_ivl_ivlset_t_end', + 'uval_ivl_ivlset_t_end__SWIG_0', + 'uval_ivl_ivlset_t_end__SWIG_1', + 'uval_ivl_ivlset_t_getivl', + 'uval_ivl_ivlset_t_lastivl', + 'uval_ivl_ivlset_t_nivls', + 'uval_ivl_ivlset_t_qclear', + 'uval_ivl_ivlset_t_set_all_values', + 'uval_ivl_ivlset_t_single_value', + 'uval_ivl_ivlset_t_swap', + 'uval_ivl_t_end', + 'uval_ivl_t_last', + 'uval_ivl_t_off_get', + 'uval_ivl_t_off_set', + 'uval_ivl_t_size_get', + 'uval_ivl_t_size_set', + 'uval_ivl_t_valid', 'validate_idb_names', 'validate_name', + 'valrng_t___eq__', + 'valrng_t___ge__', + 'valrng_t___gt__', + 'valrng_t___le__', + 'valrng_t___lt__', + 'valrng_t___ne__', + 'valrng_t__deregister', + 'valrng_t__print', + 'valrng_t__register', + 'valrng_t_all_values', + 'valrng_t_compare', + 'valrng_t_cvt_to_cmp', + 'valrng_t_cvt_to_single_value', + 'valrng_t_dstr', + 'valrng_t_empty', + 'valrng_t_get_size', + 'valrng_t_has', + 'valrng_t_intersect_with', + 'valrng_t_inverse', + 'valrng_t_is_unknown', + 'valrng_t_max_svalue', + 'valrng_t_max_svalue__SWIG_0', + 'valrng_t_max_svalue__SWIG_1', + 'valrng_t_max_value', + 'valrng_t_max_value__SWIG_0', + 'valrng_t_max_value__SWIG_1', + 'valrng_t_min_svalue', + 'valrng_t_min_svalue__SWIG_0', + 'valrng_t_min_svalue__SWIG_1', + 'valrng_t_reduce_size', + 'valrng_t_set_all', + 'valrng_t_set_cmp', + 'valrng_t_set_eq', + 'valrng_t_set_none', + 'valrng_t_set_unk', + 'valrng_t_swap', + 'valrng_t_unite_with', 'valstr_t_info_get', 'valstr_t_info_set', 'valstr_t_length_get', @@ -8238,6 +10837,38 @@ 'valstr_t_oneline_set', 'valstr_t_props_get', 'valstr_t_props_set', + 'valstrvec_t___getitem__', + 'valstrvec_t___len__', + 'valstrvec_t___setitem__', + 'valstrvec_t_at', + 'valstrvec_t_begin', + 'valstrvec_t_begin__SWIG_0', + 'valstrvec_t_begin__SWIG_1', + 'valstrvec_t_capacity', + 'valstrvec_t_clear', + 'valstrvec_t_empty', + 'valstrvec_t_end', + 'valstrvec_t_end__SWIG_0', + 'valstrvec_t_end__SWIG_1', + 'valstrvec_t_erase', + 'valstrvec_t_erase__SWIG_0', + 'valstrvec_t_erase__SWIG_1', + 'valstrvec_t_extract', + 'valstrvec_t_grow', + 'valstrvec_t_inject', + 'valstrvec_t_insert', + 'valstrvec_t_pop_back', + 'valstrvec_t_push_back', + 'valstrvec_t_push_back__SWIG_0', + 'valstrvec_t_push_back__SWIG_1', + 'valstrvec_t_qclear', + 'valstrvec_t_reserve', + 'valstrvec_t_resize', + 'valstrvec_t_resize__SWIG_0', + 'valstrvec_t_resize__SWIG_1', + 'valstrvec_t_size', + 'valstrvec_t_swap', + 'valstrvec_t_truncate', 'var_ref_t___eq__', 'var_ref_t___ge__', 'var_ref_t___gt__', @@ -8261,6 +10892,8 @@ 'vd_printer_t__print__varargs__', 'vd_printer_t_hdrlines_get', 'vd_printer_t_hdrlines_set', + 'vd_printer_t_tmpbuf_get', + 'vd_printer_t_tmpbuf_set', 'vdloc_t___eq__', 'vdloc_t___ge__', 'vdloc_t___gt__', @@ -8376,6 +11009,52 @@ 'visit_patched_bytes', 'visit_stroff_fields', 'visit_subtypes', + 'vivl_t___eq__', + 'vivl_t___eq____SWIG_0', + 'vivl_t___eq____SWIG_1', + 'vivl_t___ge__', + 'vivl_t___gt__', + 'vivl_t___le__', + 'vivl_t___lt__', + 'vivl_t___ne__', + 'vivl_t__print', + 'vivl_t_compare', + 'vivl_t_contains', + 'vivl_t_dstr', + 'vivl_t_extend_to_cover', + 'vivl_t_includes', + 'vivl_t_intersect', + 'vivl_t_overlap', + 'vivl_t_set', + 'vivl_t_set__SWIG_0', + 'vivl_t_set__SWIG_1', + 'vivl_t_set_reg', + 'vivl_t_set_stkoff', + 'vivl_t_size_get', + 'vivl_t_size_set', + 'voff_t___eq__', + 'voff_t___ge__', + 'voff_t___gt__', + 'voff_t___le__', + 'voff_t___lt__', + 'voff_t___ne__', + 'voff_t_add', + 'voff_t_compare', + 'voff_t_defined', + 'voff_t_diff', + 'voff_t_get_reg', + 'voff_t_get_stkoff', + 'voff_t_inc', + 'voff_t_is_reg', + 'voff_t_is_stkoff', + 'voff_t_off_get', + 'voff_t_off_set', + 'voff_t_set', + 'voff_t_set_reg', + 'voff_t_set_stkoff', + 'voff_t_type_get', + 'voff_t_type_set', + 'voff_t_undef', 'wait_for_next_event', 'warning', 'warning__varargs__', @@ -8452,4 +11131,4 @@ 'xreflist_t_swap', 'xreflist_t_truncate', 'yword_flag', - 'zword_flag']} \ No newline at end of file + 'zword_flag']} diff --git a/examples/ex_idphook_asm.py b/examples/ex_idphook_asm.py index 3b5327c..c20381c 100644 --- a/examples/ex_idphook_asm.py +++ b/examples/ex_idphook_asm.py @@ -15,9 +15,6 @@ import idautils #-------------------------------------------------------------------------- class assemble_idp_hook_t(idaapi.IDP_Hooks): - def __init__(self): - idaapi.IDP_Hooks.__init__(self) - def assemble(self, ea, cs, ip, use32, line): line = line.strip() if line == "xor eax, eax": diff --git a/examples/ex_uihook.py b/examples/ex_uihook.py index 2eab66f..40a6e79 100644 --- a/examples/ex_uihook.py +++ b/examples/ex_uihook.py @@ -15,13 +15,16 @@ class MyUiHook(idaapi.UI_Hooks): idaapi.UI_Hooks.__init__(self) self.cmdname = "" - def preprocess(self, name): - print("IDA preprocessing command: %s" % name) + def _log(self, msg): + print(">>> MyUiHook: %s" % msg) + + def preprocess_action(self, name): + self._log("IDA preprocessing command: %s" % name) self.cmdname = name return 0 - def postprocess(self): - print("IDA finished processing command: %s" % self.cmdname) + def postprocess_action(self): + self._log("IDA finished processing command: %s" % self.cmdname) return 0 def saving(self): @@ -30,7 +33,7 @@ class MyUiHook(idaapi.UI_Hooks): @return: Ignored """ - print("Saving....") + self._log("Saving....") def saved(self): """ @@ -38,7 +41,7 @@ class MyUiHook(idaapi.UI_Hooks): @return: Ignored """ - print("Saved") + self._log("Saved") def term(self): """ @@ -47,7 +50,7 @@ class MyUiHook(idaapi.UI_Hooks): This callback is best used within the context of a plugin_t with PLUGIN_FIX flags """ - print("IDA terminated") + self._log("IDA terminated") def get_ea_hint(self, ea): """ @@ -56,21 +59,21 @@ class MyUiHook(idaapi.UI_Hooks): @param ea: The address @return: String with the hint or None """ - print("get_ea_hint(%x)" % ea) + self._log("get_ea_hint(%x)" % ea) def populating_widget_popup(self, widget, popup, ctx): """ The UI is currently populating the widget popup. Now is a good time to attach actions. """ - print("populating_widget_popup; title: %s" % (ctx.widget_title,)) + self._log("populating_widget_popup; title: %s" % (ctx.widget_title,)) def finish_populating_widget_popup(self, widget, popup, ctx): """ The UI is done populating the widget popup. Now is the last chance to attach actions. """ - print("finish_populating_widget_popup; title: %s" % (ctx.widget_title,)) + self._log("finish_populating_widget_popup; title: %s" % (ctx.widget_title,)) #--------------------------------------------------------------------- @@ -80,12 +83,14 @@ try: print("UI hook: checking for hook...") uihook print("UI hook: unhooking....") + ui_hook_stat2 = "" uihook.unhook() del uihook except: print("UI hook: not installed, installing now....") ui_hook_stat = "" + ui_hook_stat2 = "un" uihook = MyUiHook() uihook.hook() -print("UI hook %sinstalled. Run the script again to %sinstall" % (ui_hook_stat, ui_hook_stat)) +print("UI hook %sinstalled. Run the script again to %sinstall" % (ui_hook_stat, ui_hook_stat2)) diff --git a/examples/vds10.py b/examples/vds10.py new file mode 100644 index 0000000..8960d09 --- /dev/null +++ b/examples/vds10.py @@ -0,0 +1,64 @@ +# +# Hex-Rays Decompiler project +# Copyright (c) 2007-2019 by Hex-Rays, support@hex-rays.com +# ALL RIGHTS RESERVED. +# +# Sample plugin for Hex-Rays Decompiler. +# It installs a custom microcode optimization rule: +# call !DbgRaiseAssertionFailure .0 +# => +# call !DbgRaiseAssertionFailure .0 +# +# To see this plugin in action please use arm64_brk.i64, in the hexrays sdk +# +# This is a rewrite in Python of the vds10 example that comes with hexrays sdk. +# + +import ida_bytes +import ida_range +import ida_kernwin +import ida_hexrays +import ida_typeinf + +class nt_assert_optimizer_t(ida_hexrays.optinsn_t): + def func(self, blk, ins): + if self.handle_nt_assert(ins): + return 1 + return 0 + + def handle_nt_assert(self, ins): + # recognize call !DbgRaiseAssertionFailure .0 + if not ins.is_helper("DbgRaiseAssertionFailure"): + return False + + # did we already add an argument? + fi = ins.d.f; + if not fi.args.empty(): + return False + + # use a comment from the disassembly listing as the call argument + cmt = ida_bytes.get_cmt(ins.ea, False) + if not cmt: + return False + + # remove "NT_ASSERT("...")" to make the listing nicer + if cmt.startswith("NT_ASSERT(\""): + cmt = cmt[11:] + if cmt.endswith("\")"): + cmt = cmt[:-2] + + # all ok, transform the instruction by adding one more call argument + fa = fi.args.push_back() + fa.t = ida_hexrays.mop_str; + fa.cstr = cmt + fa.type = ida_typeinf.tinfo_t.get_stock(ida_typeinf.STI_PCCHAR) # const char * + fa.size = fa.type.get_size() + return True + + +if ida_hexrays.init_hexrays_plugin(): + optimizer = nt_assert_optimizer_t() + optimizer.install() +else: + print('vds10: Hex-rays is not available.') + diff --git a/examples/vds11.py b/examples/vds11.py new file mode 100644 index 0000000..1a00931 --- /dev/null +++ b/examples/vds11.py @@ -0,0 +1,79 @@ +# +# Hex-Rays Decompiler project +# Copyright (c) 2007-2019 by Hex-Rays, support@hex-rays.com +# ALL RIGHTS RESERVED. +# +# Sample plugin for Hex-Rays Decompiler. +# It installs a custom block optimization rule: +# +# goto L1 => goto L2 +# ... +# L1: +# goto L2 +# +# In other words we fix a goto target if it points to a chain of gotos. +# This improves the decompiler output in some cases. +# +# This is a rewrite in Python of the vds11 example that comes with hexrays sdk. +# + +import ida_bytes +import ida_range +import ida_kernwin +import ida_hexrays +import ida_typeinf + +class goto_optimizer_t(ida_hexrays.optblock_t): + def func(self, blk): + if self.handle_goto_chain(blk): + return 1 + return 0 + + def handle_goto_chain(self, blk): + mgoto = blk.tail + if not mgoto or mgoto.opcode != ida_hexrays.m_goto: + return False + + visited = [] + t0 = mgoto.l.b + i = t0 + mba = blk.mba + + # follow the goto chain + while True: + if i in visited: + return False + visited.append(i) + b = mba.get_mblock(i) + m2 = ida_hexrays.getf_reginsn(b.head) + if not m2 or m2.opcode != ida_hexrays.m_goto: + break + i = m2.l.b + + if i == t0: + return False # not a chain + + # all ok, found a goto chain + mgoto.l.b = i # jump directly to the end of the chain + + # fix the successor/predecessor lists + blk.succset[0] = i + mba.get_mblock(i).predset.add(blk.serial) + mba.get_mblock(t0).predset._del(blk.serial) + + # since we changed the control flow graph, invalidate the use/def chains. + # stricly speaking it is not really necessary in our plugin because + # we did not move around any microcode operands. + mba.mark_chains_dirty() + + # it is a good idea to verify microcode after each change + # however, it may be time consuming, so comment it out eventually + mba.verify(True); + return True + + +if ida_hexrays.init_hexrays_plugin(): + optimizer = goto_optimizer_t() + optimizer.install() +else: + print('vds11: Hex-rays is not available.') diff --git a/examples/vds12.py b/examples/vds12.py new file mode 100644 index 0000000..e8f3deb --- /dev/null +++ b/examples/vds12.py @@ -0,0 +1,155 @@ +# +# Hex-Rays Decompiler project +# Copyright (c) 2007-2019 by Hex-Rays, support@hex-rays.com +# ALL RIGHTS RESERVED. +# +# Sample plugin for Hex-Rays Decompiler. +# It shows list of direct references to a register from the current +# instruction. +# +# This is a rewrite in Python of the vds12 example that comes with hexrays sdk. +# + +import ida_pro +import ida_hexrays +import ida_kernwin +import ida_funcs +import ida_bytes +import ida_lines + +def collect_block_xrefs(out, mlist, blk, ins, find_uses): + p = ins + while p and not mlist.empty(): + use = blk.build_use_list(p, ida_hexrays.MUST_ACCESS); # things used by the insn + _def = blk.build_def_list(p, ida_hexrays.MUST_ACCESS); # things defined by the insn + plst = use if find_uses else _def + if mlist.has_common(plst): + if not p.ea in out: + out.append(p.ea) # this microinstruction seems to use our operand + mlist.sub(_def) + p = p.next if find_uses else p.prev + + +def collect_xrefs(out, ctx, mop, mlist, du, find_uses): + # first collect the references in the current block + start = ctx.topins.next if find_uses else ctx.topins.prev; + collect_block_xrefs(out, mlist, ctx.blk, start, find_uses) + + # then find references in other blocks + serial = ctx.blk.serial; # block number of the operand + bc = du[serial] # chains of that block + voff = ida_hexrays.voff_t(mop) + ch = bc.get_chain(voff) # chain of the operand + if not ch: + return # odd + for bn in ch: + b = ctx.mba.get_mblock(bn) + ins = b.head if find_uses else b.tail + tmp = ida_hexrays.mlist_t() + tmp.add(mlist) + collect_block_xrefs(out, tmp, b, ins, find_uses) + + +class xref_chooser_t(ida_kernwin.Choose): + def __init__(self, xrefs, t, n, ea, gco): + ida_kernwin.Choose.__init__( + self, + t, + [["Type", 3], ["Address", 16], ["Instruction", 60]]) + + self.xrefs = xrefs + self.ndefs = n + self.curr_ea = ea + self.gco = gco + self.items = [ self._make_item(idx) for idx in xrange(len(xrefs)) ] + + def OnGetSize(self): + return len(self.items) + + def OnGetLine(self, n): + return self.items[n] + + def _make_item(self, idx): + ea = self.xrefs[idx] + both_mask = ida_hexrays.GCO_USE|ida_hexrays.GCO_DEF + both = (self.gco.flags & both_mask) == both_mask + if ea == self.curr_ea and both: + type_str = "use/def" + elif idx < self.ndefs: + type_str = "def" + else: + type_str = "use" + insn = ida_lines.generate_disasm_line(ea, ida_lines.GENDSM_REMOVE_TAGS) + return [type_str, "%08x" % ea, insn] + + +def show_xrefs(ea, gco, xrefs, ndefs): + title = "xrefs to %s at %08x" % (gco.name, ea) + xc = xref_chooser_t(xrefs, title, ndefs, ea, gco) + i = xc.Show(True) + if i >= 0: + ida_kernwin.jumpto(xrefs[i]) + + +if ida_hexrays.init_hexrays_plugin(): + ea = ida_kernwin.get_screen_ea() + pfn = ida_funcs.get_func(ea) + w = ida_kernwin.warning + if pfn: + F = ida_bytes.get_flags(ea) + if ida_bytes.is_code(F): + gco = ida_hexrays.gco_info_t() + if ida_hexrays.get_current_operand(gco): + # generate microcode + hf = ida_hexrays.hexrays_failure_t() + mbr = ida_hexrays.mba_ranges_t(pfn) + mba = ida_hexrays.gen_microcode( + mbr, + hf, + None, + ida_hexrays.DECOMP_WARNINGS, + ida_hexrays.MMAT_PREOPTIMIZED) + if mba: + merr = mba.build_graph() + if merr == ida_hexrays.MERR_OK: + ncalls = mba.analyze_calls(ida_hexrays.ACFL_GUESS) + if ncalls < 0: + print("%08x: failed to determine some calling conventions", pfn.start_ea) + mlist = ida_hexrays.mlist_t() + if gco.append_to_list(mlist, mba): + ctx = ida_hexrays.op_parent_info_t() + mop = mba.find_mop(ctx, ea, gco.is_def(), mlist) + if mop: + xrefs = ida_pro.eavec_t() + ndefs = 0 + graph = mba.get_graph() + ud = graph.get_ud(ida_hexrays.GC_REGS_AND_STKVARS) + du = graph.get_du(ida_hexrays.GC_REGS_AND_STKVARS) + if gco.is_use(): + collect_xrefs(xrefs, ctx, mop, mlist, ud, False) + ndefs = xrefs.size() + if ea not in xrefs: + xrefs.append(ea) + if gco.is_def(): + if ea not in xrefs: + xrefs.append(ea) + ndefs = len(xrefs) + collect_xrefs(xrefs, ctx, mop, mlist, du, True) + show_xrefs(ea, gco, xrefs, ndefs) + else: + w("Could not find the operand in the microcode, sorry") + else: + w("Failed to represent %s as microcode list" % gco.name) + else: + w("%08x: %s" % (errea, ida_hexrays.get_merror_desc(merr, mba))) + else: + w("%08x: %s" % (hf.errea, hf.str)) + else: + w("Could not find a register or stkvar in the current operand") + else: + w("Please position the cursor on an instruction") + else: + w("Please position the cursor within a function") +else: + print('vds12: Hex-rays is not available.') + diff --git a/examples/vds13.py b/examples/vds13.py new file mode 100644 index 0000000..09cf178 --- /dev/null +++ b/examples/vds13.py @@ -0,0 +1,39 @@ +# +# Hex-Rays Decompiler project +# Copyright (c) 2007-2019 by Hex-Rays, support@hex-rays.com +# ALL RIGHTS RESERVED. +# +# Sample plugin for Hex-Rays Decompiler. +# It generates microcode for selection and dumps it to the output window. +# +# This is a rewrite in Python of the vds13 example that comes with hexrays sdk. +# + +import ida_bytes +import ida_range +import ida_kernwin +import ida_hexrays + +if ida_hexrays.init_hexrays_plugin(): + sel, sea, eea = ida_kernwin.read_range_selection(None) + w = ida_kernwin.warning + if sel: + F = ida_bytes.get_flags(sea) + if ida_bytes.is_code(F): + hf = ida_hexrays.hexrays_failure_t() + mbr = ida_hexrays.mba_ranges_t() + mbr.ranges.push_back(ida_range.range_t(sea, eea)) + mba = ida_hexrays.gen_microcode(mbr, hf, None, ida_hexrays.DECOMP_WARNINGS) + if mba: + print("Successfully generated microcode for 0x%08x..0x%08x\n" % (sea, eea)) + vp = ida_hexrays.vd_printer_t() + mba._print(vp) + else: + w("0x%08x: %s" % (hf.errea, hf.str)) + else: + w("The selected range must start with an instruction") + else: + w("Please select a range of addresses to analyze") +else: + print('vds13: Hex-rays is not available.') + diff --git a/examples/vds17.py b/examples/vds17.py new file mode 100644 index 0000000..20bd52c --- /dev/null +++ b/examples/vds17.py @@ -0,0 +1,142 @@ +# +# Hex-Rays Decompiler project +# Copyright (c) 2007-2019 by Hex-Rays, support@hex-rays.com +# ALL RIGHTS RESERVED. +# +# Sample plugin for Hex-Rays Decompiler. +# It shows how to use "Select offsets" widget (select_udt_by_offset() call). +# This plugin repeats the Alt-Y functionality. +# Usage: place cursor on the union field and press Shift-T +# +# This is a rewrite in Python of the vds17 example that comes with hexrays sdk. +# + +import ida_idaapi +import ida_hexrays + +# -------------------------------------------------------------------------- +class func_stroff_ah_t(ida_kernwin.action_handler_t): + def __init__(self): + ida_kernwin.action_handler_t.__init__(self) + + def activate(self, ctx): + # get current item + vu = ida_hexrays.get_widget_vdui(ctx.widget) + vu.get_current_item(idaapi.USE_KEYBOARD) + + # check the current item is union field + if not vu.item.is_citem(): + return 0 + e = vu.item.e + while True: + op = e.op + if op != ida_hexrays.cot_memptr and op != ida_hexrays.cot_memref: + return 0 + e = e.x + if op == ida_hexrays.cot_memptr: + if e.type.is_union(): + break + else: + if ida_typeinf.remove_pointer(e.type).is_union(): + break + if not e.type.is_udt(): + return 0 + + # calculate member's offset + off = 0 + e = vu.item.e + while True: + e2 = e.x + tif = ida_typeinf.remove_pointer(e2.type) + if not tif.is_union(): + off += e.m + e = e2 + if e2.op != ida_hexrays.cot_memptr and e2.op != ida_hexrays.cot_memref: + break + if not e2.type.is_udt(): + break + + # go up and collect more member references (in order to calculate the final offset) + p = vu.item.e + while True: + p2 = vu.cfunc.body.find_parent_of(p) + if p2.op == ida_hexrays.cot_memptr: + break + if p2.op == ida_hexrays.cot_memref: + e2 = p2 + tif = remove_pointer(e2.x.type) + if not tif.is_union(): + off += e2.m + p = p2 + continue + if p2.op == ida_hexrays.cot_ref: + # handle &a.b + N (this expression may appear if the user previously selected + # a wrong field) + delta = 0 + add = vu.cfunc.body.find_parent_of(p2) + if add.op == ida_hexrays.cot_cast: + add = vu.cfunc.body.find_parent_of(add) + if add.op == ida_hexrays.cot_add and add.y.op == ida_hexrays.cot_num: + delta = add.y.numval() + objsize = add.type.get_ptrarr_objsize() + nbytes = delta * objsize + off += nbytes + # we can use the calling helpers like WORD/BYTE/... + # to calculate the more precise offset + # if ( p2->op == cot_call && (e2->exflags & EXFL_LVALUE) != 0 ) + break + + ea = vu.item.e.ea + # the item itself may be unaddressable. + # TODO: find its addressable parent + if ea == idaapi.BADADDR: + return 0 + + # prepare the text representation for the item, + # use the neighborhoods of cursor + line = idaapi.tag_remove(ida_kernwin.get_custom_viewer_curline(vu.ct, False)) + line_len = len(line) + x = max(0, vu.cpos.x - 10) + l = min(10, line_len - vu.cpos.x) + 10 + line = line[x:x+l] + + ops = ida_hexrays.ui_stroff_ops_t() + op = ops.push_back() + op.offset = off + op.text = line + + class set_union_sel_t(ida_hexrays.ui_stroff_applicator_t): + def __init__(self, eas): + ida_hexrays.ui_stroff_applicator_t.__init__(self) + self.eas = eas + + def apply(self, opnum, path): + vu.cfunc.set_user_union_selection(self.eas[opnum], path) + vu.cfunc.save_user_unions() + return True + + su = set_union_sel_t([ea]) + res = ida_hexrays.select_udt_by_offset(None, ops, su) + if res != 0: + # regenerate ctree + vu.refresh_view(True) + + return 1 + + def update(self, ctx): + return ida_kernwin.AST_ENABLE_FOR_WIDGET if \ + ctx.widget_type == ida_kernwin.BWN_PSEUDOCODE else \ + ida_kernwin.AST_DISABLE_FOR_WIDGET + + +# -------------------------------------------------------------------------- +if ida_hexrays.init_hexrays_plugin(): + print("Hex-rays version %s has been detected, Structure offsets ready to use" % idaapi.get_hexrays_version()) + ida_kernwin.register_action( + ida_kernwin.action_desc_t( + "vds17:strchoose", + "Structure offsets", + func_stroff_ah_t(), + "Shift+T")) +else: + print('vds17: Hex-rays is not available.') diff --git a/examples/vds5.py b/examples/vds5.py index de5bf5d..0628f0b 100644 --- a/examples/vds5.py +++ b/examples/vds5.py @@ -1,5 +1,6 @@ from __future__ import print_function +import ida_idaapi import ida_pro import ida_hexrays import ida_kernwin diff --git a/examples/vds6.py b/examples/vds6.py index 464e51d..3545758 100644 --- a/examples/vds6.py +++ b/examples/vds6.py @@ -9,6 +9,7 @@ from __future__ import print_function import idautils import idc +import ida_idaapi import ida_hexrays import ida_lines diff --git a/examples/vds8.py b/examples/vds8.py index 2ee13bf..b0e0b1a 100644 --- a/examples/vds8.py +++ b/examples/vds8.py @@ -1,6 +1,6 @@ # Hex-Rays Decompiler project -# Copyright (c) 2007-2018 by Hex-Rays, support@hex-rays.com +# Copyright (c) 2007-2019 by Hex-Rays, support@hex-rays.com # ALL RIGHTS RESERVED. # # Sample script for Hex-Rays Decompiler usage of udc_filter_t @@ -10,6 +10,7 @@ # # It is also added into the right-click menu as "vds8.py:Toggle UDC" +import ida_idaapi import ida_hexrays import ida_kernwin import ida_allins @@ -64,9 +65,6 @@ class toggle_udc_ah_t(ida_kernwin.action_handler_t): # -------------------------------------------------------------------------- class my_hooks_t(ida_kernwin.UI_Hooks): - def __init__(self): - ida_kernwin.UI_Hooks.__init__(self) - def populating_widget_popup(self, widget, popup): if ida_kernwin.get_widget_type(widget) == ida_kernwin.BWN_PSEUDOCODE: ida_kernwin.attach_action_to_popup(widget, popup, ACTION_NAME) diff --git a/examples/vds_create_hint.py b/examples/vds_create_hint.py index 404d8b0..d124f5f 100644 --- a/examples/vds_create_hint.py +++ b/examples/vds_create_hint.py @@ -7,6 +7,7 @@ If the object under the cursor is: - an 'if' statement, replace the hint with our own, saying "condition" """ +import ida_idaapi import ida_hexrays class hint_hooks_t(ida_hexrays.Hexrays_Hooks): diff --git a/examples/vds_hooks.py b/examples/vds_hooks.py index 52a67d6..d499584 100644 --- a/examples/vds_hooks.py +++ b/examples/vds_hooks.py @@ -3,6 +3,7 @@ Various hooks for Hexrays Decompiler """ from __future__ import print_function +import ida_idaapi import ida_typeinf import ida_hexrays diff --git a/examples/vds_modify_user_lvars.py b/examples/vds_modify_user_lvars.py new file mode 100644 index 0000000..28c6939 --- /dev/null +++ b/examples/vds_modify_user_lvars.py @@ -0,0 +1,45 @@ + +import ida_hexrays +import ida_typeinf + +import idc + +class my_modifier_t(ida_hexrays.user_lvar_modifier_t): + def __init__(self, name_prefix="", cmt_prefix="", new_types={}): + ida_hexrays.user_lvar_modifier_t.__init__(self) + self.name_prefix = name_prefix + self.cmt_prefix = cmt_prefix + self.new_types = new_types + + def modify_lvars(self, lvars): + def log(msg): + print("modify_lvars: %s" % msg) + log("len(lvars.lvvec) = %d" % len(lvars.lvvec)) + log("lvars.lmaps.size() = %d" % lvars.lmaps.size()) + log("lvars.stkoff_delta = %d" % lvars.stkoff_delta) + log("lvars.ulv_flags = %x" % lvars.ulv_flags) + + for idx, one in enumerate(lvars.lvvec): + def varlog(msg): + log("var #%d: %s" % (idx, msg)) + varlog("name = '%s'" % one.name) + varlog("type = '%s'" % one.type._print()) + varlog("cmt = '%s'" % one.cmt) + varlog("size = %d" % one.size) + varlog("flags = %x" % one.flags) + new_type = self.new_types.get(one.name) + if new_type: + ida_typeinf.parse_decl(one.type, None, new_type, 0) + one.name = self.name_prefix + one.name + one.cmt = self.cmt_prefix + one.cmt + + return True + + +def modify_function_lvars(name_prefix="patched_", cmt_prefix="(patched) ", new_types={}): + ea = idc.here() + my_mod = my_modifier_t( + name_prefix=name_prefix, + cmt_prefix=cmt_prefix, + new_types=new_types) + ida_hexrays.modify_user_lvars(ea, my_mod) diff --git a/idapython.script b/idapython.script index 6a9df92..7a292e9 100644 --- a/idapython.script +++ b/idapython.script @@ -10,6 +10,7 @@ global: PyW_IsSequenceType; PyW_ObjectToString; PyW_PyListToEaVec; + PyW_PyListToEa64Vec; PyW_PyListToSizeVec; PyW_PyListToStrVec; PyW_ShowCbErr; @@ -19,7 +20,6 @@ global: PyW_TryImportModule; PyW_register_compiled_form; PyW_unregister_compiled_form; - add_notify_when; create_linked_class_instance; disable_script_timeout; enable_extlang_python; @@ -58,6 +58,7 @@ global: register_module_lifecycle_callbacks; set_script_timeout; set_interruptible_state; + setup_new_execution; til_deregister_python_array_type_data_t_instance; til_deregister_python_func_type_data_t_instance; til_deregister_python_ptr_type_data_t_instance; diff --git a/idapython_implib.def b/idapython_implib.def index 10ff797..f37f78f 100644 --- a/idapython_implib.def +++ b/idapython_implib.def @@ -10,6 +10,7 @@ EXPORTS PyW_IsSequenceType PyW_ObjectToString PyW_PyListToEaVec + PyW_PyListToEa64Vec PyW_PyListToSizeVec PyW_PyListToStrVec PyW_register_compiled_form @@ -17,7 +18,6 @@ EXPORTS PyW_TryGetAttrString PyW_TryImportModule PyW_unregister_compiled_form - add_notify_when create_linked_class_instance disable_script_timeout enable_extlang_python @@ -51,6 +51,7 @@ EXPORTS pyw_convert_idc_args set_script_timeout set_interruptible_state + setup_new_execution til_deregister_python_array_type_data_t_instance til_deregister_python_func_type_data_t_instance til_deregister_python_ptr_type_data_t_instance diff --git a/makefile b/makefile index cf9dbc0..e0364e5 100644 --- a/makefile +++ b/makefile @@ -42,8 +42,15 @@ else endif ifndef __MKDEP__ I = $(ST_SDK)/ -else - # HACK for mkdep to add dependencies for $(F)python$(O) +endif + +# HACK HIJACK the $(LIBDIR) variable to point to our staging SDK +ifneq ($(OUT_OF_TREE_BUILD),) + LIBDIR = $(IDA)lib/$(TARGET_PROCESSOR_NAME)_$(SYSNAME)_$(COMPILER_NAME)_$(ADRSIZE)$(STATSUF) +endif + +# HACK for mkdep to add dependencies for $(F)python$(O) +ifdef __MKDEP__ OBJS += $(F)python$(O) endif @@ -103,9 +110,14 @@ ifdef DO_IDAMAKE_SIMPLIFY QGEN_IDC_BC695 = @echo $(call qcolor,gen_idc_bc695) $< && # QINJECT_PLFM = @echo $(call qcolor,inject_plfm) $< && # QINJECT_PYDOC = @echo $(call qcolor,inject_pydoc) $$< && # + QINJECT_BASE_HOOKS_FLAGS = @echo $(call qcolor,inject_base_hooks_flags) $< && # QPATCH_CODEGEN = @echo $(call qcolor,patch_codegen) $$< && # + QPATCH_H_CODEGEN = @echo $(call qcolor,patch_h_codegen) $$< && # + QPATCH_PYTHON_CODEGEN = @echo $(call qcolor,patch_python_codegen) $$< && # QSWIG = @echo $(call qcolor,swig) $$< && # - QUPATE_SDK = @echo $(call qcolor,update_sdk) $< && # + QUPDATE_SDK = @echo $(call qcolor,update_sdk) $< && # + QSPLIT_HEXRAYS_TEMPLATES = @echo $(call qcolor,split_hexrays_templates) $< && # + QPYDOC_INJECTIONS = @echo $(call qcolor,check_injections) $@ && # endif #---------------------------------------------------------------------- @@ -127,6 +139,9 @@ DEPLOY_IDAUTILS_PY=$(DEPLOY_PYDIR)/idautils.py DEPLOY_IDC_BC695_PY=$(DEPLOY_PYDIR)/idc_bc695.py DEPLOY_IDAAPI_PY=$(DEPLOY_PYDIR)/idaapi.py DEPLOY_IDADEX_PY=$(DEPLOY_PYDIR)/idadex.py +ifdef TESTABLE_BUILD + DEPLOY_LUMINA_MODEL_PY=$(DEPLOY_PYDIR)/lumina_model.py +endif ifeq ($(OUT_OF_TREE_BUILD),) TEST_IDC=test_idc IDC_BC695_IDC_SOURCE?=$(DEPLOY_PYDIR)/../idc/idc.idc @@ -184,6 +199,9 @@ MODULES_NAMES += idp MODULES_NAMES += kernwin MODULES_NAMES += lines MODULES_NAMES += loader +ifdef TESTABLE_BUILD + MODULES_NAMES += lumina +endif MODULES_NAMES += moves MODULES_NAMES += nalt MODULES_NAMES += name @@ -251,7 +269,8 @@ pyfiles: $(DEPLOY_IDAUTILS_PY) \ $(DEPLOY_IDC_BC695_PY) \ $(DEPLOY_INIT_PY) \ $(DEPLOY_IDAAPI_PY) \ - $(DEPLOY_IDADEX_PY) + $(DEPLOY_IDADEX_PY) \ + $(DEPLOY_LUMINA_MODEL_PY) GENHOOKS=tools/genhooks/ @@ -273,6 +292,9 @@ $(DEPLOY_IDAAPI_PY): python/idaapi.py tools/genidaapi.py $(IDAPYTHON_MODULES) $(DEPLOY_IDADEX_PY): python/idadex.py $(CP) $? $@ +$(DEPLOY_LUMINA_MODEL_PY): python/lumina_model.py + $(CP) $? $@ + $(DEPLOY_PYDIR)/lib/%: precompiled/lib/% cp $< $@ $(Q)chmod +w $@ @@ -306,13 +328,35 @@ $(foreach d,$(sort $(DIRLIST)),$(if $(wildcard $(d)),,$(shell mkdir -p $(d)))) #---------------------------------------------------------------------- # obj/.../idasdk/*.h[pp] +# NOTE: Because we have the following sequence in hexrays.hpp: +# - definition of template "template struct ivl_tpl" +# - instantiation of template into "typedef ivl_tpl uval_ivl_t;" +# - subclassing of "uval_ivl_t": "struct ivl_t : public uval_ivl_t", +# we are in trouble in our hexrays.i file, because by the time SWiG +# processes "struct ivl_t", it won't have properly instantiated the +# template, leading to the IDAPython proxy class "ivl_t" not subclassing +# "uval_ivl_t". Therefore, we have to split the hexrays.hpp header file +# into two: one that defines the template, and one that instantiates it. +# This way, we can '%import "hexrays_templates.hpp"', then do the SWiG +# template incantation, and finally '%include "hexrays_notemplates.hpp"' +# to actually generate wrappers. ifeq ($(OUT_OF_TREE_BUILD),) $(ST_SDK)/%.h: $(IDA_INCLUDE)/%.h - $(QUPATE_SDK)$(PYTHON) ../../bin/update_sdk.py $(FILTER_SDK_FLAGS) -filter-file -input $^ -output $@ + $(QUPDATE_SDK) perl ../../etc/sdk/filter_src.pl $^ $@ $(ST_SDK)/%.hpp: $(IDA_INCLUDE)/%.hpp - $(QUPATE_SDK)$(PYTHON) ../../bin/update_sdk.py $(FILTER_SDK_FLAGS) -filter-file -input $^ -output $@ + $(QUPDATE_SDK) perl ../../etc/sdk/filter_src.pl $^ $@ +HEXRAYS_HPP_SPLIT_DIR:=$(ST_SDK) +else +HEXRAYS_HPP_SPLIT_DIR:=$(F) endif +$(HEXRAYS_HPP_SPLIT_DIR)/hexrays_notemplates.hpp: $(ST_SDK)/hexrays.hpp tools/split_hexrays_templates.py + $(QSPLIT_HEXRAYS_TEMPLATES)$(PYTHON) tools/split_hexrays_templates.py \ + --input $< \ + --out-templates $(HEXRAYS_HPP_SPLIT_DIR)/hexrays_templates.hpp \ + --out-body=$(HEXRAYS_HPP_SPLIT_DIR)/hexrays_notemplates.hpp +SWIGFLAGS += -I$(HEXRAYS_HPP_SPLIT_DIR) + #---------------------------------------------------------------------- # obj/.../pywraps/* $(ST_PYW)/%.hpp: pywraps/%.hpp @@ -329,6 +373,7 @@ $(ST_PYW)/py_idp.hpp: pywraps/py_idp.hpp \ $(GENHOOKS)recipe_idphooks.py \ $(PARSED_HEADERS_MARKER) $(MAKEFILE_DEP) | $(SDK_SOURCES) $(QGENHOOKS)$(PYTHON) $(GENHOOKS)genhooks.py -i $< -o $@ \ + -c IDP_Hooks \ -x $(ST_PARSED_HEADERS)/structprocessor__t.xml -e event_t \ -r int -n 0 -m hookgenIDP -q "processor_t::" \ -R $(GENHOOKS)recipe_idphooks.py @@ -337,15 +382,17 @@ $(ST_PYW)/py_idp_idbhooks.hpp: pywraps/py_idp_idbhooks.hpp \ $(GENHOOKS)recipe_idbhooks.py \ $(GENHOOKS)genhooks.py $(PARSED_HEADERS_MARKER) $(MAKEFILE_DEP) | $(SDK_SOURCES) $(QGENHOOKS)$(PYTHON) $(GENHOOKS)genhooks.py -i $< -o $@ \ + -c IDB_Hooks \ -x $(ST_PARSED_HEADERS)/namespaceidb__event.xml -e event_code_t \ - -r int -n 0 -m hookgenIDB -q "idb_event::" \ + -r void -n 0 -m hookgenIDB -q "idb_event::" \ -R $(GENHOOKS)recipe_idbhooks.py $(ST_PYW)/py_dbg.hpp: pywraps/py_dbg.hpp \ $(I)dbg.hpp \ $(GENHOOKS)recipe_dbghooks.py \ $(GENHOOKS)genhooks.py $(PARSED_HEADERS_MARKER) $(MAKEFILE_DEP) | $(SDK_SOURCES) $(QGENHOOKS)$(PYTHON) $(GENHOOKS)genhooks.py -i $< -o $@ \ - -x $(ST_PARSED_HEADERS)/dbg_8hpp.xml -e dbg_notification_t \ + -c DBG_Hooks \ + -x $(ST_PARSED_HEADERS)/dbg_8hpp.xml -q "dbg_notification_t::" -e dbg_notification_t \ -r void -n 0 -m hookgenDBG \ -R $(GENHOOKS)recipe_dbghooks.py $(ST_PYW)/py_kernwin.hpp: pywraps/py_kernwin.hpp \ @@ -353,7 +400,9 @@ $(ST_PYW)/py_kernwin.hpp: pywraps/py_kernwin.hpp \ $(GENHOOKS)recipe_uihooks.py \ $(GENHOOKS)genhooks.py $(PARSED_HEADERS_MARKER) $(MAKEFILE_DEP) | $(SDK_SOURCES) $(QGENHOOKS)$(PYTHON) $(GENHOOKS)genhooks.py -i $< -o $@ \ + -c UI_Hooks \ -x $(ST_PARSED_HEADERS)/kernwin_8hpp.xml -e ui_notification_t \ + -q "ui_notification_t::" \ -r void -n 0 -m hookgenUI \ -R $(GENHOOKS)recipe_uihooks.py \ -d "ui_dbg_,ui_obsolete" -D "ui:" -s "ui_" @@ -362,15 +411,19 @@ $(ST_PYW)/py_kernwin_viewhooks.hpp: pywraps/py_kernwin_viewhooks.hpp \ $(GENHOOKS)recipe_viewhooks.py \ $(GENHOOKS)genhooks.py $(PARSED_HEADERS_MARKER) $(MAKEFILE_DEP) | $(SDK_SOURCES) $(QGENHOOKS)$(PYTHON) $(GENHOOKS)genhooks.py -i $< -o $@ \ + -c View_Hooks \ -x $(ST_PARSED_HEADERS)/kernwin_8hpp.xml -e view_notification_t \ + -q "view_notification_t::" \ -r void -n 0 -m hookgenVIEW \ -R $(GENHOOKS)recipe_viewhooks.py $(ST_PYW)/py_hexrays_hooks.hpp: pywraps/py_hexrays_hooks.hpp \ - $(I)hexrays.hpp \ + $(HEXRAYS_HPP_SPLIT_DIR)/hexrays_notemplates.hpp \ $(GENHOOKS)recipe_hexrays.py \ $(GENHOOKS)genhooks.py $(PARSED_HEADERS_MARKER) $(MAKEFILE_DEP) | $(SDK_SOURCES) $(QGENHOOKS)$(PYTHON) $(GENHOOKS)genhooks.py -i $< -o $@ \ + -c Hexrays_Hooks \ -x $(ST_PARSED_HEADERS)/hexrays_8hpp.xml -e hexrays_event_t \ + -q "hexrays_event_t::" \ -r int -n 0 -m hookgenHEXRAYS \ -R $(GENHOOKS)recipe_hexrays.py \ -s "hxe_,lxe_" @@ -382,8 +435,8 @@ CC_DEFS += $(BC695_CC_DEF) CC_DEFS += $(DEF_TYPE_TABLE) CC_DEFS += $(WITH_HEXRAYS_DEF) CC_DEFS += USE_STANDARD_FILE_FUNCTIONS -CC_DEFS += VER_MAJOR="1" -CC_DEFS += VER_MINOR="7" +CC_DEFS += VER_MAJOR="7" +CC_DEFS += VER_MINOR="3" CC_DEFS += VER_PATCH="0" CC_DEFS += __EXPR_SRC CC_INCP += $(F) @@ -391,8 +444,23 @@ CC_INCP += $(IDA_INCLUDE) CC_INCP += $(ST_SWIG) CC_INCP += . -# suppress warnings -WARNS = $(NOWARNS) +ifdef __UNIX__ + # suppress some warnings + # see https://github.com/swig/swig/pull/801 + # FIXME: remove these once swig is fixed + CC_WNO += -Wno-shadow + CC_WNO += -Wno-unused-parameter + # FIXME: these should be fixed and removed + CC_WNO += -Wno-attributes + CC_WNO += -Wno-delete-non-virtual-dtor + CC_WNO += -Wno-deprecated-declarations + CC_WNO += -Wno-format-nonliteral + CC_WNO += -Wno-write-strings + ifdef __MAC__ + # additional switches for clang + CC_WNO += -Wno-deprecated-register + endif +endif # disable -pthread in CFLAGS PTHR_SWITCH = @@ -403,7 +471,6 @@ NO_OBSOLETE_FUNCS = #---------------------------------------------------------------------- ifdef TESTABLE_BUILD SWIGFLAGS+=-DTESTABLE_BUILD - FILTER_SDK_FLAGS+=-testable-build endif ST_SWIG_HEADER = $(ST_SWIG)/header.i @@ -416,12 +483,17 @@ endif find-pywraps-deps = $(wildcard pywraps/py_$(subst .i,,$(notdir $(1)))*.hpp) $(wildcard pywraps/py_$(subst .i,,$(notdir $(1)))*.py) find-pydoc-patches-deps = $(wildcard tools/inject_pydoc/$(1).py) - +find-patch-codegen-deps = $(wildcard tools/patch_codegen/*$(1)*.py) ADDITIONAL_PYWRAP_DEP_idp=$(ST_PYW)/py_idp.py $(ST_PYW)/py_idp.py: pywraps/py_idp.py.in tools/inject_plfm.py $(ST_SDK)/idp.hpp $(QINJECT_PLFM)$(PYTHON) tools/inject_plfm.py -i $< -o $@ -d $(ST_SDK)/idp.hpp +ADDITIONAL_PYWRAP_DEP_idaapi=$(ST_PYW)/py_idaapi.hpp +$(ST_PYW)/py_idaapi.hpp: pywraps/py_idaapi.hpp.in tools/inject_base_hooks_flags.py pywraps.hpp + $(QINJECT_BASE_HOOKS_FLAGS)$(PYTHON) tools/inject_base_hooks_flags.py -i $< -o $@ -f pywraps.hpp + + # Some .i files depend on some other .i files in order to be parseable by SWiG # (e.g., segregs.i imports range.i). Declare the list of such dependencies here # so they will be picked by the auto-generated rules. @@ -430,7 +502,7 @@ SWIG_IFACE_dbg=idd SWIG_IFACE_frame=range SWIG_IFACE_funcs=range SWIG_IFACE_gdl=range -SWIG_IFACE_hexrays=typeinf +SWIG_IFACE_hexrays=pro typeinf xref SWIG_IFACE_idd=range SWIG_IFACE_segment=range SWIG_IFACE_segregs=range @@ -439,6 +511,7 @@ SWIG_IFACE_tryblks=range MODULE_LIFECYCLE_hexrays=--lifecycle-aware MODULE_LIFECYCLE_bytes=--lifecycle-aware +MODULE_LIFECYCLE_idaapi=--lifecycle-aware define make-module-rules @@ -454,7 +527,7 @@ define make-module-rules # files. # ../../bin/x86_linux_gcc/python/ida_$(1).py (note: dep. on .cpp. See note above.) - $(DEPLOY_PYDIR)/ida_$(1).py: $(ST_WRAP)/$(1).cpp $(PARSED_HEADERS_MARKER) $(call find-pydoc-patches-deps,$(1)) | tools/inject_pydoc.py + $(DEPLOY_PYDIR)/ida_$(1).py: $(ST_WRAP)/$(1).cpp $(PARSED_HEADERS_MARKER) $(call find-pydoc-patches-deps,$(1)) $(call find-patch-codegen-deps,$(1)) | tools/inject_pydoc.py $(QINJECT_PYDOC)$(PYTHON) tools/inject_pydoc.py \ -x $(ST_PARSED_HEADERS) \ -m $(1) \ @@ -477,17 +550,29 @@ define make-module-rules --xml-doc-directory $(ST_PARSED_HEADERS) # obj/x86_linux_gcc/wrappers/X.cpp - $(ST_WRAP)/$(1).cpp: $(ST_SWIG)/$(1).i tools/patch_codegen.py $(PATCH_DIRECTORS_SCRIPT) $(PARSED_HEADERS_MARKER) tools/chkapi.py + $(ST_WRAP)/$(1).cpp: $(ST_SWIG)/$(1).i tools/patch_codegen.py tools/patch_python_codegen.py $(PATCH_DIRECTORS_SCRIPT) $(PARSED_HEADERS_MARKER) tools/chkapi.py $(QSWIG)$(SWIG) -modern $(addprefix -D,$(WITH_HEXRAYS_DEF)) -python -threads -c++ -shadow \ -D__GNUC__ $(SWIGFLAGS) $(addprefix -D,$(DEF64)) -I$(ST_SWIG) \ - -outdir $(ST_WRAP) -o $$@ -I$(ST_SDK) $$< - $(Q)$(PYTHON) tools/patch_constants.py --file $(ST_WRAP)/$(1).cpp + -outdir $(ST_WRAP) -o $$@.in1 -oh $(ST_WRAP)/$(1).h -I$(ST_SDK) -DIDAPYTHON_MODULE_$(1)=1 $$< + $(Q)$(PYTHON) tools/patch_constants.py \ + --input $(ST_WRAP)/$(1).cpp.in1 \ + --output $(ST_WRAP)/$(1).cpp.in2 $(QPATCH_CODEGEN)$(PYTHON) tools/patch_codegen.py \ --apply-valist-patches \ - --file $(ST_WRAP)/$(1).cpp \ + --input $(ST_WRAP)/$(1).cpp.in2 \ + --output $(ST_WRAP)/$(1).cpp \ --module $(1) \ --xml-doc-directory $(ST_PARSED_HEADERS) \ - --patches tools/patch_codegen/$(1).py + --patches tools/patch_codegen/$(1).py \ + --batch-patches tools/patch_codegen/$(1)_batch.py + $(QPATCH_H_CODEGEN)$(PYTHON) tools/patch_h_codegen.py \ + --file $(ST_WRAP)/$(1).h \ + --module $(1) \ + --patches tools/patch_codegen/$(1)_h.py + $(QPATCH_PYTHON_CODEGEN)$(PYTHON) tools/patch_python_codegen.py \ + --file $(ST_WRAP)/ida_$(1).py \ + --module $(1) \ + --patches tools/patch_codegen/ida_$(1).py ifdef __NT__ $(PYTHON) $(PATCH_DIRECTORS_SCRIPT) --file $(ST_WRAP)/$(1).h endif @@ -505,9 +590,10 @@ vpath %.cpp $(ST_WRAP) ifdef __NT__ # remove warnings from generated code: # error C4296: '<': expression is always false + # warning C4647: behavior change: __is_pod(type) has different value in previous versions # warning C4700: uninitialized local variable 'c_result' used # warning C4706: assignment within conditional expression - $(X_O): CFLAGS += /wd4296 /wd4700 /wd4706 + $(X_O): CFLAGS += /wd4296 /wd4647 /wd4700 /wd4706 endif # disable -fno-rtti $(X_O): NORTTI = @@ -544,7 +630,11 @@ $(DEPLOY_LIBDIR)/_ida_%$(MODULE_SFX): $(F)_ida_%$(MODULE_SFX) $(Q)$(CP) $< $@ #---------------------------------------------------------------------- +ifdef TESTABLE_BUILD API_CONTENTS = api_contents.txt +else +API_CONTENTS = release_api_contents.txt +endif ST_API_CONTENTS = $(F)$(API_CONTENTS) .PRECIOUS: $(ST_API_CONTENTS) @@ -562,7 +652,11 @@ endif #---------------------------------------------------------------------- # Check that doc injection is stable +ifdef TESTABLE_BUILD PYDOC_INJECTIONS = pydoc_injections.txt +else +PYDOC_INJECTIONS = release_pydoc_injections.txt +endif ST_PYDOC_INJECTIONS = $(F)$(PYDOC_INJECTIONS) .PRECIOUS: $(ST_PYDOC_INJECTIONS) @@ -572,7 +666,7 @@ ifdef __CODE_CHECKER__ $(Q)touch $@ else ifeq ($(OUT_OF_TREE_BUILD),) - $(Q)$(IDA_CMD) $(BATCH_SWITCH) -OIDAPython:AUTOIMPORT_COMPAT_IDA695=NO -S"$< $@ $(ST_WRAP)" -t -L$(F)dumpdoc.log >/dev/null + $(QPYDOC_INJECTIONS)$(IDA_CMD) $(BATCH_SWITCH) -OIDAPython:AUTOIMPORT_COMPAT_IDA695=NO -S"$< $@ $(ST_WRAP)" -t -L$(F)dumpdoc.log >/dev/null $(Q)(diff -w $(PYDOC_INJECTIONS) $(ST_PYDOC_INJECTIONS)) > /dev/null || \ (echo "PYDOC INJECTION CHANGED! update $(PYDOC_INJECTIONS) or fix .. what needs fixing" && \ echo "(New API: $(ST_PYDOC_INJECTIONS)) ***" && \ diff --git a/out_of_tree/parsed_notifications.zip b/out_of_tree/parsed_notifications.zip index 1203d94..a9ac86d 100644 Binary files a/out_of_tree/parsed_notifications.zip and b/out_of_tree/parsed_notifications.zip differ diff --git a/pydoc_injections.txt b/pydoc_injections.txt index 06d1e06..e5cc533 100644 --- a/pydoc_injections.txt +++ b/pydoc_injections.txt @@ -152,8 +152,24 @@ ida_auto.auto_wait(): auto_wait() -> bool - Process everything in the queues and return true. Return false if - Ctrl-Break was pressed. + Process everything in the queues and return true. + + @return: false if the user clicked cancel. (the wait box must be + displayed by the caller if desired) + + +ida_auto.auto_wait_range(): + + auto_wait_range(ea1, ea2) -> ssize_t + + + Process everything in the specified range and return true. + + @param ea1 (C++: ea_t) + @param ea2 (C++: ea_t) + @return: number of autoanalysis steps made. -1 if the user clicked + cancel. (the wait box must be displayed by the caller if + desired) ida_auto.enable_auto(): @@ -357,7 +373,8 @@ ida_bytes.add_dword(): Add a value to one dword of the program. This function works for wide byte processors too. This function takes into account order of bytes - specified in {is_be()}this function works incorrectly if {nbits} > 16 + specified in \inf{is_be()}this function works incorrectly if + \ph{nbits} > 16 @param ea: linear address (C++: ea_t) @param value: byte value (C++: uint64) @@ -404,7 +421,7 @@ ida_bytes.add_qword(): Add a value to one qword of the program. This function does not work for wide byte processors. This function takes into account order of - bytes specified in {is_be()} + bytes specified in \inf{is_be()} @param ea: linear address (C++: ea_t) @param value: byte value (C++: uint64) @@ -417,7 +434,7 @@ ida_bytes.add_word(): Add a value to one word of the program. This function works for wide byte processors too. This function takes into account order of bytes - specified in {is_be()} + specified in \inf{is_be()} @param ea: linear address (C++: ea_t) @param value: byte value (C++: uint64) @@ -506,6 +523,11 @@ ida_bytes.calc_def_align(): @param maxa (C++: int) +ida_bytes.calc_dflags(): + + calc_dflags(f, force) -> flags_t + + ida_bytes.calc_max_align(): calc_max_align(endea) -> int @@ -683,7 +705,7 @@ ida_bytes.create_align(): ida_bytes.create_byte(): - create_byte(ea, length) -> bool + create_byte(ea, length, force=False) -> bool Convert to byte. @@ -691,11 +713,12 @@ ida_bytes.create_byte(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_custdata(): - create_custdata(ea, length, dtid, fid) -> bool + create_custdata(ea, length, dtid, fid, force=False) -> bool Convert to custom data type. @@ -705,6 +728,7 @@ ida_bytes.create_custdata(): @param length (C++: asize_t) @param dtid (C++: int) @param fid (C++: int) + @param force (C++: bool) ida_bytes.create_data(): @@ -729,7 +753,7 @@ ida_bytes.create_data(): ida_bytes.create_double(): - create_double(ea, length) -> bool + create_double(ea, length, force=False) -> bool Convert to double. @@ -737,11 +761,12 @@ ida_bytes.create_double(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_dword(): - create_dword(ea, length) -> bool + create_dword(ea, length, force=False) -> bool Convert to dword. @@ -749,11 +774,12 @@ ida_bytes.create_dword(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_float(): - create_float(ea, length) -> bool + create_float(ea, length, force=False) -> bool Convert to float. @@ -761,11 +787,12 @@ ida_bytes.create_float(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_oword(): - create_oword(ea, length) -> bool + create_oword(ea, length, force=False) -> bool Convert to octaword/xmm word. @@ -773,11 +800,12 @@ ida_bytes.create_oword(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_packed_real(): - create_packed_real(ea, length) -> bool + create_packed_real(ea, length, force=False) -> bool Convert to packed decimal real. @@ -785,11 +813,12 @@ ida_bytes.create_packed_real(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_qword(): - create_qword(ea, length) -> bool + create_qword(ea, length, force=False) -> bool Convert to quadword. @@ -797,6 +826,7 @@ ida_bytes.create_qword(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_strlit(): @@ -817,19 +847,21 @@ ida_bytes.create_strlit(): ida_bytes.create_struct(): - create_struct(ea, length, tid) -> bool + create_struct(ea, length, tid, force=False) -> bool - Convert to struct + Convert to struct. + @param ea (C++: ea_t) @param length (C++: asize_t) @param tid (C++: tid_t) + @param force (C++: bool) ida_bytes.create_tbyte(): - create_tbyte(ea, length) -> bool + create_tbyte(ea, length, force=False) -> bool Convert to tbyte. @@ -837,11 +869,12 @@ ida_bytes.create_tbyte(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_word(): - create_word(ea, length) -> bool + create_word(ea, length, force=False) -> bool Convert to word. @@ -849,11 +882,12 @@ ida_bytes.create_word(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_yword(): - create_yword(ea, length) -> bool + create_yword(ea, length, force=False) -> bool Convert to ymm word. @@ -861,11 +895,12 @@ ida_bytes.create_yword(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.create_zword(): - create_zword(ea, length) -> bool + create_zword(ea, length, force=False) -> bool Convert to zmm word. @@ -873,6 +908,7 @@ ida_bytes.create_zword(): @param ea (C++: ea_t) @param length (C++: asize_t) + @param force (C++: bool) ida_bytes.cust_flag(): @@ -1472,9 +1508,9 @@ ida_bytes.get_32bit(): Get not more than 32bits of the program at 'ea'. @param ea (C++: ea_t) - @return: 32 bit value, depending on {nbits}: if ( nbits <= 8 ) - return get_dword(ea); if ( nbits <= 16) return - get_wide_word(ea); return get_wide_byte(ea); + @return: 32 bit value, depending on \ph{nbits}: if ( nbits <= 8 ) + return get_dword(ea); if ( nbits <= 16) return + get_wide_word(ea); return get_wide_byte(ea); ida_bytes.get_64bit(): @@ -1485,9 +1521,9 @@ ida_bytes.get_64bit(): Get not more than 64bits of the program at 'ea'. @param ea (C++: ea_t) - @return: 64 bit value, depending on {nbits}: if ( nbits <= 8 ) - return get_qword(ea); if ( nbits <= 16) return - get_wide_dword(ea); return get_wide_byte(ea); + @return: 64 bit value, depending on \ph{nbits}: if ( nbits <= 8 ) + return get_qword(ea); if ( nbits <= 16) return + get_wide_dword(ea); return get_wide_byte(ea); ida_bytes.get_8bit(): @@ -1604,7 +1640,7 @@ ida_bytes.get_data_elsize(): structure id. Otherwise is ignored (may be NULL). If specified as NULL, will be automatically retrieved from the database (C++: const opinfo_t *) - @return: byte : 1 word : 2 etc... + @return: byte : 1 word : 2 etc... ida_bytes.get_data_value(): @@ -1651,8 +1687,8 @@ ida_bytes.get_dword(): Get one dword (32-bit) of the program at 'ea'. This function takes - into account order of bytes specified in {is_be()} This function works - only for 8bit byte processors. + into account order of bytes specified in \inf{is_be()} This function + works only for 8bit byte processors. @param ea (C++: ea_t) @@ -1864,7 +1900,7 @@ ida_bytes.get_mapping(): @param n: number of mapping range (0.. get_mappings_qty() -1) (C++: size_t) @return: false if the specified range doesn't exist, otherwise returns - `from', `to', `size' + from , to , size ida_bytes.get_mappings_qty(): @@ -1907,10 +1943,17 @@ ida_bytes.get_octet(): Get 8 bits of the program at 'ea'. The main usage of this function is - to iterate range of bytes. Here is an example:'ea' is incremented each - time when a new byte is read. In the above example, it will be - incremented in the first loop iteration.uint64v;intnbit=0;for(...){uch - arbyte=get_octet(&ea,&v,&nbit);...} + to iterate range of bytes. Here is an example: + + uint64 v; + int nbit = 0; + for ( ... ) { + uchar byte = get_octet(&ea, &v, &nbit); + ... + } + + 'ea' is incremented each time when a new byte is read. In the above + example, it will be incremented in the first loop iteration. @param ea (C++: ea_t *) @param v (C++: uint64 *) @@ -1972,7 +2015,7 @@ ida_bytes.get_original_dword(): Get original dword (that was before patching) This function works for wide byte processors too. This function takes into account order of - bytes specified in {is_be()} + bytes specified in \inf{is_be()} @param ea (C++: ea_t) @@ -1984,7 +2027,7 @@ ida_bytes.get_original_qword(): Get original qword value (that was before patching) This function DOESN'T work for wide byte processors too. This function takes into - account order of bytes specified in {is_be()} + account order of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @@ -1996,7 +2039,7 @@ ida_bytes.get_original_word(): Get original word value (that was before patching). This function works for wide byte processors too. This function takes into account - order of bytes specified in {is_be()} + order of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @@ -2030,8 +2073,8 @@ ida_bytes.get_qword(): Get one qword (64-bit) of the program at 'ea'. This function takes - into account order of bytes specified in {is_be()} This function works - only for 8bit byte processors. + into account order of bytes specified in \inf{is_be()} This function + works only for 8bit byte processors. @param ea (C++: ea_t) @@ -2106,8 +2149,8 @@ ida_bytes.get_wide_dword(): Get two wide words (4 'bytes') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This - function takes into account order of bytes specified in {is_be()}this - function works incorrectly if {nbits} > 16 + function takes into account order of bytes specified in + \inf{is_be()}this function works incorrectly if \ph{nbits} > 16 @param ea (C++: ea_t) @@ -2120,7 +2163,7 @@ ida_bytes.get_wide_word(): Get one wide word (2 'byte') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This - function takes into account order of bytes specified in {is_be()} + function takes into account order of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @@ -2131,8 +2174,8 @@ ida_bytes.get_word(): Get one word (16-bit) of the program at 'ea'. This function takes into - account order of bytes specified in {is_be()} This function works only - for 8bit byte processors. + account order of bytes specified in \inf{is_be()} This function works + only for 8bit byte processors. @param ea (C++: ea_t) @@ -2147,7 +2190,7 @@ ida_bytes.get_zero_ranges(): initialized byte ranges may be not included. Only zero bytes that use the sparse storage method (STT_MM) are reported. - @param zranges: pointer to the return value. can not be NULL (C++: + @param zranges: pointer to the return value. cannot be NULL (C++: rangeset_t *) @param range: the range of addresses to verify. can be NULL - means all ranges (C++: const range_t *) @@ -2378,8 +2421,8 @@ ida_bytes.is_bnot(): is_bnot(ea, F, n) -> bool - Should we negate the operand?. {a_bnot} should be defined in the idp - module in order to work with this function + Should we negate the operand?. sh{a_bnot} should be defined in the + idp module in order to work with this function @param ea (C++: ea_t) @param F (C++: flags_t) @@ -2710,9 +2753,9 @@ ida_bytes.is_lzero(): Display leading zeroes in operands. The global switch for the leading - zeroes is in {s_genflags} The leading zeroes doesn't work if the octal - numbers start with 0 Display leading zeroes? (takes into account - {s_genflags}) + zeroes is in \inf{s_genflags} The leading zeroes doesn't work if the + octal numbers start with 0 Display leading zeroes? (takes into account + \inf{s_genflags}) @param ea (C++: ea_t) @param n (C++: int) @@ -3117,7 +3160,7 @@ ida_bytes.nbits(): Get number of bits in a byte at the given address. @param ea (C++: ea_t) - @return: {dnbits()} if the address doesn't belong to a segment, + @return: \ph{dnbits()} if the address doesn't belong to a segment, otherwise the result depends on the segment type @@ -3463,7 +3506,7 @@ ida_bytes.patch_dword(): Patch a dword of the program. The original value of the dword is saved and can be obtained by 'get_original_dword()' . This function DOESN'T work for wide byte processors. This function takes into account order - of bytes specified in {is_be()} + of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @param x (C++: uint64) @@ -3477,7 +3520,7 @@ ida_bytes.patch_qword(): Patch a qword of the program. The original value of the qword is saved and can be obtained by 'get_original_qword()' . This function DOESN'T work for wide byte processors. This function takes into account order - of bytes specified in {is_be()} + of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @param x (C++: uint64) @@ -3491,7 +3534,7 @@ ida_bytes.patch_word(): Patch a word of the program. The original value of the word is saved and can be obtained by 'get_original_word()' . This function works for wide byte processors too. This function takes into account order of - bytes specified in {is_be()} + bytes specified in \inf{is_be()} @param ea (C++: ea_t) @param x (C++: uint64) @@ -3630,9 +3673,10 @@ ida_bytes.put_dword(): Set value of one dword of the program. This function takes into - account order of bytes specified in {is_be()} This function works for - wide byte processors too.the original value of the dword is completely - lost and can't be recovered by the 'get_original_dword()' function. + account order of bytes specified in \inf{is_be()} This function works + for wide byte processors too.the original value of the dword is + completely lost and can't be recovered by the 'get_original_dword()' + function. @param ea: linear address (C++: ea_t) @param x: dword value (C++: uint64) @@ -3644,7 +3688,7 @@ ida_bytes.put_qword(): Set value of one qword (8 bytes) of the program. This function takes - into account order of bytes specified in {is_be()} This function + into account order of bytes specified in \inf{is_be()} This function DOESN'T works for wide byte processors. @param ea: linear address (C++: ea_t) @@ -3657,7 +3701,7 @@ ida_bytes.put_word(): Set value of one word of the program. This function takes into account - order of bytes specified in {is_be()} This function works for wide + order of bytes specified in \inf{is_be()} This function works for wide byte processors too.The original value of the word is completely lost and can't be recovered by the 'get_original_word()' function. ea - linear address x - word value @@ -3748,8 +3792,8 @@ ida_bytes.set_cmt(): Set an indented comment. @param ea: linear address (C++: ea_t) - @param comm: comment string NULL: do nothing (return 0) "" : delete - comment (C++: const char *) + @param comm: comment string NULL: do nothing (return 0) "" : + delete comment (C++: const char *) @param rptble: is repeatable? (C++: bool) @return: success @@ -3763,7 +3807,7 @@ ida_bytes.set_forced_operand(): @param ea: linear address (C++: ea_t) @param n: number of operand (0, 1, 2) (C++: int) - @param op: text of operand NULL: do nothing (return 0) "" : delete + @param op: text of operand NULL: do nothing (return 0) "" : delete forced operand (C++: const char *) @return: success @@ -3934,7 +3978,7 @@ ida_bytes.update_hidden_range(): update_hidden_range(ha) -> bool - Update hidden range information in the database. You can not use this + Update hidden range information in the database. You cannot use this function to change the range boundaries @param ha: range to update (C++: const hidden_range_t *) @@ -4071,6 +4115,13 @@ removes all references to the next instruction, then plan to convert to unexplored the next instruction too. """ +ida_bytes.DELIT_KEEPFUNC +""" +Just delete xrefs, ops e.t.c. + +do not undefine the function start. +""" + ida_bytes.DELIT_NOCMT """ reject to delete if a comment is in address range (except for the @@ -4524,7 +4575,7 @@ use normal name ida_bytes.STRCONV_ESCAPE """ -convert non-printable characters to C escapes (, , ) +convert non-printable characters to C escapes (, \\xNN, \\uNNNN) """ ida_bytes.STRCONV_INCLLEN @@ -4559,6 +4610,11 @@ ida_dbg.DBG_Hooks.dbg_exception(): dbg_exception(self, pid, tid, ea, exc_code, exc_can_cont, exc_ea, exc_info) -> int +ida_dbg.DBG_Hooks.dbg_finished_loading_bpts(): + + dbg_finished_loading_bpts(self) + + ida_dbg.DBG_Hooks.dbg_information(): dbg_information(self, pid, tid, ea, info) @@ -4604,6 +4660,11 @@ ida_dbg.DBG_Hooks.dbg_run_to(): dbg_run_to(self, pid, tid, ea) +ida_dbg.DBG_Hooks.dbg_started_loading_bpts(): + + dbg_started_loading_bpts(self) + + ida_dbg.DBG_Hooks.dbg_step_into(): dbg_step_into(self) @@ -4655,7 +4716,7 @@ ida_dbg.add_bpt(): add_bpt(bpt) -> bool - Add a new breakpoint in the debugged process. {Type, Synchronous + Add a new breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)}Only one breakpoint can exist at a given address. @@ -4690,9 +4751,10 @@ ida_dbg.attach_process(): attach_process(pid=pid_t(-1), event_id=-1) -> int - Attach the debugger to a running process. {Type, Asynchronous function - - available as Request, Notification, 'dbg_process_attach' }This - function shouldn't be called as a request if 'NO_PROCESS' is used. + Attach the debugger to a running process. \sq{Type, Asynchronous + function - available as Request, Notification, 'dbg_process_attach' + }This function shouldn't be called as a request if 'NO_PROCESS' is + used. @param pid: PID of the process to attach to. If NO_PROCESS , a dialog box will interactively ask the user for the process to @@ -5072,7 +5134,7 @@ ida_dbg.clear_requests_queue(): clear_requests_queue() - Clear the queue of waiting requests. {Type, Synchronous function, + Clear the queue of waiting requests. \sq{Type, Synchronous function, Notification, none (synchronous function)}If a request is currently running, this one isn't stopped. @@ -5082,7 +5144,7 @@ ida_dbg.clear_trace(): clear_trace() - Clear all events in the trace buffer. {Type, Synchronous function - + Clear all events in the trace buffer. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @@ -5096,7 +5158,7 @@ ida_dbg.continue_process(): continue_process() -> bool - Continue the execution of the process in the debugger. {Type, + Continue the execution of the process in the debugger. \sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)}The 'continue_process()' function can be called from a notification handler to force the continuation of the process. @@ -5130,7 +5192,7 @@ ida_dbg.dbg_add_bpt_tev(): dbg_add_bpt_tev(tid, ea, bp) -> bool - Add a new breakpoint trace element to the current trace. {Type, + Add a new breakpoint trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param tid (C++: thid_t) @@ -5144,8 +5206,8 @@ ida_dbg.dbg_add_call_tev(): dbg_add_call_tev(tid, caller, callee) - Add a new call trace element to the current trace. {Type, Synchronous - function, Notification, none (synchronous function)} + Add a new call trace element to the current trace. \sq{Type, + Synchronous function, Notification, none (synchronous function)} @param tid (C++: thid_t) @param caller (C++: ea_t) @@ -5157,7 +5219,7 @@ ida_dbg.dbg_add_debug_event(): dbg_add_debug_event(event) - Add a new debug event to the current trace. {Type, Synchronous + Add a new debug event to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param event (C++: debug_event_t *) @@ -5168,7 +5230,7 @@ ida_dbg.dbg_add_insn_tev(): dbg_add_insn_tev(tid, ea, save=SAVE_DIFF) -> bool - Add a new instruction trace element to the current trace. {Type, + Add a new instruction trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param tid (C++: thid_t) @@ -5182,8 +5244,8 @@ ida_dbg.dbg_add_many_tevs(): dbg_add_many_tevs(new_tevs) -> bool - Add many new trace elements to the current trace. {Type, Synchronous - function, Notification, none (synchronous function)} + Add many new trace elements to the current trace. \sq{Type, + Synchronous function, Notification, none (synchronous function)} @param new_tevs (C++: tevinforeg_vec_t *) @return: false if the operation failed for any tev_info_t object @@ -5194,7 +5256,7 @@ ida_dbg.dbg_add_ret_tev(): dbg_add_ret_tev(tid, ret_insn, return_to) - Add a new return trace element to the current trace. {Type, + Add a new return trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param tid (C++: thid_t) @@ -5207,7 +5269,7 @@ ida_dbg.dbg_add_tev(): dbg_add_tev(type, tid, address) - Add a new trace element to the current trace. {Type, Synchronous + Add a new trace element to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param type (C++: tev_type_t) @@ -5220,7 +5282,7 @@ ida_dbg.dbg_add_thread(): dbg_add_thread(tid) - Add a thread to the current trace. {Type, Synchronous function, + Add a thread to the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param tid (C++: thid_t) @@ -5250,8 +5312,8 @@ ida_dbg.dbg_del_thread(): dbg_del_thread(tid) - Delete a thread from the current trace. {Type, Synchronous function, - Notification, none (synchronous function)} + Delete a thread from the current trace. \sq{Type, Synchronous + function, Notification, none (synchronous function)} @param tid (C++: thid_t) @@ -5272,9 +5334,9 @@ ida_dbg.define_exception(): Convenience function: define new exception code. - @param code: exception code (can not be 0) (C++: uint) - @param name: exception name (can not be empty or NULL) (C++: const - char *) + @param code: exception code (cannot be 0) (C++: uint) + @param name: exception name (cannot be empty or NULL) (C++: const char + *) @param desc: exception description (maybe NULL) (C++: const char *) @param flags: combination of Exception info flags (C++: int) @return: failure message or NULL. You must call store_exceptions() @@ -5287,7 +5349,7 @@ ida_dbg.del_bpt(): del_bpt(bptloc) -> bool - Delete an existing breakpoint in the debugged process. {Type, + Delete an existing breakpoint in the debugged process. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @@ -5309,7 +5371,7 @@ ida_dbg.detach_process(): detach_process() -> bool - Detach the debugger from the debugged process. {Type, Asynchronous + Detach the debugger from the debugged process. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_process_detach' } @@ -5407,7 +5469,7 @@ ida_dbg.exit_process(): exit_process() -> bool - Terminate the debugging of the current process. {Type, Asynchronous + Terminate the debugging of the current process. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_process_exit' } @@ -5416,8 +5478,8 @@ ida_dbg.find_bpt(): find_bpt(bptloc, bpt) -> bool - Find a breakpoint by location. {Type, Synchronous function - available - as request, Notification, none (synchronous function)} + Find a breakpoint by location. \sq{Type, Synchronous function - + available as request, Notification, none (synchronous function)} @param bptloc: Breakpoint location (C++: const bpt_location_t &) @param bpt: bpt is filled if the breakpoint was found (C++: bpt_t *) @@ -5429,7 +5491,7 @@ ida_dbg.get_bblk_trace_options(): Get current basic block tracing options. Also see 'BT_LOG_INSTS' - {Type, Synchronous function, Notification, none (synchronous + \sq{Type, Synchronous function, Notification, none (synchronous function)} @@ -5438,8 +5500,8 @@ ida_dbg.get_bpt(): get_bpt(ea, bpt) -> bool - Get the characteristics of a breakpoint. {Type, Synchronous function, - Notification, none (synchronous function)} + Get the characteristics of a breakpoint. \sq{Type, Synchronous + function, Notification, none (synchronous function)} @param ea: any address in the breakpoint range (C++: ea_t) @param bpt: if not NULL, is filled with the characteristics. (C++: @@ -5457,8 +5519,8 @@ ida_dbg.get_bpt_qty(): get_bpt_qty() -> int - Get number of breakpoints. {Type, Synchronous function, Notification, - none (synchronous function)} + Get number of breakpoints. \sq{Type, Synchronous function, + Notification, none (synchronous function)} ida_dbg.get_bpt_tev_ea(): @@ -5467,7 +5529,7 @@ ida_dbg.get_bpt_tev_ea(): Get the address associated to a read, read/write or execution trace - event. {Type, Synchronous function, Notification, none (synchronous + event. \sq{Type, Synchronous function, Notification, none (synchronous function)}Usually, a breakpoint is associated with a read, read/write or execution trace event. However, the returned address could be any address in the range of this breakpoint. If the breakpoint was deleted @@ -5495,7 +5557,7 @@ ida_dbg.get_call_tev_callee(): get_call_tev_callee(n) -> ea_t - Get the called function from a function call trace event. {Type, + Get the called function from a function call trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 @@ -5518,8 +5580,8 @@ ida_dbg.get_current_thread(): get_current_thread() -> thid_t - Get current thread ID. {Type, Synchronous function, Notification, none - (synchronous function)} + Get current thread ID. \sq{Type, Synchronous function, Notification, + none (synchronous function)} ida_dbg.get_dbg_byte(): @@ -5544,7 +5606,7 @@ ida_dbg.get_dbg_reg_info(): get_dbg_reg_info(regname, ri) -> bool - Get register information {Type, Synchronous function, Notification, + Get register information \sq{Type, Synchronous function, Notification, none (synchronous function)} @param regname (C++: const char *) @@ -5574,7 +5636,7 @@ ida_dbg.get_func_trace_options(): get_func_trace_options() -> int - Get current function tracing options. Also see 'FT_LOG_RET' {Type, + Get current function tracing options. Also see 'FT_LOG_RET' \sq{Type, Synchronous function, Notification, none (synchronous function)} @@ -5594,7 +5656,7 @@ ida_dbg.get_insn_tev_reg_mem(): Read the memory pointed by register values from an instruction trace - event. {Type, Synchronous function, Notification, none (synchronous + event. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 @@ -5609,7 +5671,7 @@ ida_dbg.get_insn_tev_reg_result(): Read the resulting register value from an instruction trace event. - {Type, Synchronous function, Notification, none (synchronous + \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 @@ -5625,7 +5687,7 @@ ida_dbg.get_insn_tev_reg_val(): get_insn_tev_reg_val(n, regname, regval) -> bool - Read a register value from an instruction trace event. {Type, + Read a register value from an instruction trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)}This is the value of the register before the execution of the instruction. @@ -5642,7 +5704,7 @@ ida_dbg.get_insn_trace_options(): Get current instruction tracing options. Also see 'IT_LOG_SAME_IP' - {Type, Synchronous function, Notification, none (synchronous + \sq{Type, Synchronous function, Notification, none (synchronous function)} @@ -5704,8 +5766,8 @@ ida_dbg.get_process_state(): get_process_state() -> int - Return the state of the currently debugged process. {Type, Synchronous - function, Notification, none (synchronous function)} + Return the state of the currently debugged process. \sq{Type, + Synchronous function, Notification, none (synchronous function)} @return: one of Debugged process states @@ -5716,7 +5778,7 @@ ida_dbg.get_processes(): Take a snapshot of running processes and return their description. - {Type, Synchronous function, Notification, none (synchronous + \sq{Type, Synchronous function, Notification, none (synchronous function)} @param proclist (C++: procinfo_vec_t *) @@ -5727,9 +5789,10 @@ ida_dbg.get_reg_val(): get_reg_val(regname, regval) -> bool get_reg_val(regname, ival) -> bool + get_reg_val(regname) -> PyObject * - Read a register value from the current thread. {Type, Synchronous + Read a register value from the current thread. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param regname (C++: const char *) @@ -5746,7 +5809,7 @@ ida_dbg.get_ret_tev_return(): get_ret_tev_return(n) -> ea_t - Get the return address from a function return trace event. {Type, + Get the return address from a function return trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 @@ -5760,8 +5823,8 @@ ida_dbg.get_running_notification(): Get the notification associated (if any) with the current running - request. {Type, Synchronous function, Notification, none (synchronous - function)} + request. \sq{Type, Synchronous function, Notification, none + (synchronous function)} @return: dbg_null if no running request @@ -5771,7 +5834,7 @@ ida_dbg.get_running_request(): get_running_request() -> ui_notification_t - Get the current running request. {Type, Synchronous function, + Get the current running request. \sq{Type, Synchronous function, Notification, none (synchronous function)} @return: ui_null if no running request @@ -5796,7 +5859,7 @@ ida_dbg.get_step_trace_options(): get_step_trace_options() -> int - Get current step tracing options. {Type, Synchronous function, + Get current step tracing options. \sq{Type, Synchronous function, Notification, none (synchronous function)} @return: Step trace options @@ -5813,8 +5876,8 @@ ida_dbg.get_tev_event(): Get the corresponding debug event, if any, for the specified tev - object. {Type, Synchronous function, Notification, none (synchronous - function)} + object. \sq{Type, Synchronous function, Notification, none + (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 represents the latest added trace event. (C++: int) @@ -5828,8 +5891,8 @@ ida_dbg.get_tev_info(): get_tev_info(n, tev_info) -> bool - Get main information about a trace event. {Type, Synchronous function, - Notification, none (synchronous function)} + Get main information about a trace event. \sq{Type, Synchronous + function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 represents the latest added trace event. (C++: int) @@ -5842,7 +5905,7 @@ ida_dbg.get_tev_memory_info(): get_tev_memory_info(n, mi) -> bool - Get the memory layout, if any, for the specified tev object. {Type, + Get the memory layout, if any, for the specified tev object. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 @@ -5857,7 +5920,7 @@ ida_dbg.get_tev_qty(): get_tev_qty() -> int - Get number of trace events available in trace buffer. {Type, + Get number of trace events available in trace buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)} @@ -5876,8 +5939,8 @@ ida_dbg.get_thread_qty(): get_thread_qty() -> int - Get number of threads. {Type, Synchronous function, Notification, none - (synchronous function)} + Get number of threads. \sq{Type, Synchronous function, Notification, + none (synchronous function)} ida_dbg.get_trace_base_address(): @@ -5885,7 +5948,7 @@ ida_dbg.get_trace_base_address(): get_trace_base_address() -> ea_t - Get the base address of the current trace. {Type, Synchronous + Get the base address of the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @return: the base address of the currently loaded trace @@ -5915,8 +5978,8 @@ ida_dbg.getn_bpt(): getn_bpt(n, bpt) -> bool - Get the characteristics of a breakpoint. {Type, Synchronous function, - Notification, none (synchronous function)} + Get the characteristics of a breakpoint. \sq{Type, Synchronous + function, Notification, none (synchronous function)} @param n: number of breakpoint, is in range 0.. get_bpt_qty() -1 (C++: int) @@ -5929,7 +5992,7 @@ ida_dbg.getn_thread(): getn_thread(n) -> thid_t - Get the ID of a thread. {Type, Synchronous function, Notification, + Get the ID of a thread. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of thread, is in range 0.. get_thread_qty() -1 (C++: @@ -5942,7 +6005,7 @@ ida_dbg.getn_thread_name(): getn_thread_name(n) -> char const * - Get the NAME of a thread {Type, Synchronous function, Notification, + Get the NAME of a thread \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of thread, is in range 0.. get_thread_qty() -1 or -1 @@ -5988,8 +6051,8 @@ ida_dbg.invalidate_dbg_state(): invalidate_dbg_state(dbginv) -> int - Invalidate cached debugger information. {Type, Synchronous function, - Notification, none (synchronous function)} + Invalidate cached debugger information. \sq{Type, Synchronous + function, Notification, none (synchronous function)} @param dbginv: Debugged process invalidation options (C++: int) @return: current debugger state (one of Debugged process states ) @@ -6060,8 +6123,8 @@ ida_dbg.is_func_trace_enabled(): is_func_trace_enabled() -> bool - Get current state of functions tracing. {Type, Synchronous function, - Notification, none (synchronous function)} + Get current state of functions tracing. \sq{Type, Synchronous + function, Notification, none (synchronous function)} ida_dbg.is_insn_trace_enabled(): @@ -6069,7 +6132,7 @@ ida_dbg.is_insn_trace_enabled(): is_insn_trace_enabled() -> bool - Get current state of instructions tracing. {Type, Synchronous + Get current state of instructions tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)} @@ -6078,7 +6141,7 @@ ida_dbg.is_reg_custom(): is_reg_custom(regname) -> bool - Does a register contain a value of a custom data type? {Type, + Does a register contain a value of a custom data type? \sq{Type, Synchronous function, Notification, none (synchronous function)} @param regname (C++: const char *) @@ -6089,7 +6152,7 @@ ida_dbg.is_reg_float(): is_reg_float(regname) -> bool - Does a register contain a floating point value? {Type, Synchronous + Does a register contain a floating point value? \sq{Type, Synchronous function, Notification, none (synchronous function)} @param regname (C++: const char *) @@ -6100,8 +6163,8 @@ ida_dbg.is_reg_integer(): is_reg_integer(regname) -> bool - Does a register contain an integer value? {Type, Synchronous function, - Notification, none (synchronous function)} + Does a register contain an integer value? \sq{Type, Synchronous + function, Notification, none (synchronous function)} @param regname (C++: const char *) @@ -6119,7 +6182,7 @@ ida_dbg.is_step_trace_enabled(): is_step_trace_enabled() -> bool - Get current state of step tracing. {Type, Synchronous function, + Get current state of step tracing. \sq{Type, Synchronous function, Notification, none (synchronous function)} @@ -6512,14 +6575,13 @@ ida_dbg.request_set_insn_trace_options(): ida_dbg.request_set_reg_val(): - request_set_reg_val(regname, regval) -> bool + request_set_reg_val(regname, o) -> PyObject * Post a 'set_reg_val()' request. @param regname (C++: const char *) - @param regval (C++: const regval_t *) ida_dbg.request_set_resume_mode(): @@ -6606,7 +6668,7 @@ ida_dbg.resume_thread(): resume_thread(tid) -> int - Resume thread. {Type, Synchronous function - available as request, + Resume thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @param tid: thread id (C++: thid_t) @@ -6629,7 +6691,7 @@ ida_dbg.run_requests(): Execute requests until all requests are processed or an asynchronous - function is called. {Type, Synchronous function, Notification, none + function is called. \sq{Type, Synchronous function, Notification, none (synchronous function)}If called from a notification handler, the execution of requests will be postponed to the end of the execution of all notification handlers. @@ -6647,7 +6709,7 @@ ida_dbg.run_to(): is active, a new process is started. Technically, the debugger sets up a temporary breakpoint at the given address, and continues (or starts) the execution of the whole process. So, all threads continue their - execution! {Type, Asynchronous function - available as Request, + execution! \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_run_to' } @param ea: target address (C++: ea_t) @@ -6676,7 +6738,7 @@ ida_dbg.select_thread(): Select the given thread as the current debugged thread. All thread related execution functions will work on this thread. The process must - be suspended to select a new thread. {Type, Synchronous function - + be suspended to select a new thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @param tid: ID of the thread to select (C++: thid_t) @@ -6748,7 +6810,7 @@ ida_dbg.set_func_trace_options(): set_func_trace_options(options) - Modify function tracing options. {Type, Synchronous function - + Modify function tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @param options (C++: int) @@ -6772,7 +6834,7 @@ ida_dbg.set_insn_trace_options(): set_insn_trace_options(options) - Modify instruction tracing options. {Type, Synchronous function - + Modify instruction tracing options. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @param options (C++: int) @@ -6810,7 +6872,7 @@ ida_dbg.set_process_state(): only when the process is suspended. The process state is usually restored before returning control to the caller. You must know that it is ok to change the process state, doing it at arbitrary moments may - crash the application or IDA. {Type, Synchronous function, + crash the application or IDA. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param newstate: new process state (one of Debugged process states ) @@ -6825,17 +6887,15 @@ ida_dbg.set_process_state(): ida_dbg.set_reg_val(): - set_reg_val(regname, regval) -> bool - set_reg_val(regname, ival) -> bool - set_reg_val(tid, regidx, value) -> int + set_reg_val(regname, o) -> PyObject + set_reg_val(tid, regidx, o) -> PyObject * - Write a register value to the current thread. {Type, Synchronous + Write a register value to the current thread. \sq{Type, Synchronous function - available as Request, Notification, none (synchronous function)} @param regname (C++: const char *) - @param regval (C++: const regval_t *) ida_dbg.set_remote_debugger(): @@ -6868,8 +6928,8 @@ ida_dbg.set_step_trace_options(): set_step_trace_options(options) - Modify step tracing options. {Type, Synchronous function - available - as request, Notification, none (synchronous function)} + Modify step tracing options. \sq{Type, Synchronous function - + available as request, Notification, none (synchronous function)} @param options (C++: int) @@ -6879,7 +6939,7 @@ ida_dbg.set_trace_base_address(): set_trace_base_address(ea) - Set the base address of the current trace. {Type, Synchronous + Set the base address of the current trace. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param ea (C++: ea_t) @@ -6913,7 +6973,7 @@ ida_dbg.set_trace_size(): set_trace_size(size) -> bool - Specify the new size of the circular buffer. {Type, Synchronous + Specify the new size of the circular buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)}If you specify 0, all available memory can be quickly used !!! @@ -6958,7 +7018,7 @@ ida_dbg.start_process(): start_process(path=None, args=None, sdir=None) -> int - Start a process in the debugger. {Type, Asynchronous function - + Start a process in the debugger. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_process_start' }You can also use the 'run_to()' function to easily start the execution of a process until a given address is reached.For all parameters, a NULL value @@ -6976,7 +7036,7 @@ ida_dbg.step_into(): Execute one instruction in the current thread. Other threads are kept - suspended. {Type, Asynchronous function - available as Request, + suspended. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_step_into' } @@ -6986,7 +7046,7 @@ ida_dbg.step_over(): Execute one instruction in the current thread, but without entering - into functions. Others threads keep suspended. {Type, Asynchronous + into functions. Others threads keep suspended. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_step_over' } @@ -6997,7 +7057,7 @@ ida_dbg.step_until_ret(): Execute instructions in the current thread until a function return instruction is executed (aka "step out"). Other threads are kept - suspended. {Type, Asynchronous function - available as Request, + suspended. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_step_until_ret' } @@ -7015,8 +7075,8 @@ ida_dbg.suspend_process(): suspend_process() -> bool - Suspend the process in the debugger. { Type,Synchronous function (if - in a notification handler)Asynchronous function (everywhere + Suspend the process in the debugger. \sq{ Type,Synchronous function + (if in a notification handler)Asynchronous function (everywhere else)available as Request, Notification,none (if in a notification handler) 'dbg_suspend_process' (everywhere else) }The 'suspend_process()' function can be called from a notification handler @@ -7031,7 +7091,7 @@ ida_dbg.suspend_thread(): Suspend thread. Suspending a thread may deadlock the whole application - if the suspended was owning some synchronization objects. {Type, + if the suspended was owning some synchronization objects. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @@ -7290,7 +7350,7 @@ ida_dbg.update_bpt(): Update modifiable characteristics of an existing breakpoint. To update - the breakpoint location, use 'change_bptlocs()' {Type, Synchronous + the breakpoint location, use 'change_bptlocs()' \sq{Type, Synchronous function, Notification, none (synchronous function)}Only the following fields can be modified: 'bpt_t::cndbody' 'bpt_t::pass_count' 'bpt_t::flags' 'bpt_t::size' 'bpt_t::type' Changing some properties @@ -7840,14 +7900,13 @@ ida_diskio.get_ida_subdirs(): Get list of directories in which to find a specific IDA resource (see - 'IDA subdirectories' ). The order of the resulting list is as - follows:[$IDAUSR/subdir (0..N entries)]$ENVVAR for backwards - compatibility with some subdirs that could be overriden with - environment variables, such as $IDASGN, $IDAIDS, $IDAIDC, and - $IDATIL.$IDADIR/subdir + 'IDA subdirectories' ). The order of the resulting list is as follows: - @param subdir (C++: const char *) - @param flags (C++: int) + - [$IDAUSR/subdir (0..N entries)] + - $IDADIR/subdir + + @param subdir: name of the resource to list (C++: const char *) + @param flags: Subdirectory modification flags bits (C++: int) @return: number of directories appended to 'dirs' @@ -7878,9 +7937,12 @@ ida_diskio.get_user_idadir(): get_user_idadir() -> char const * - Get user ida related directory.if $IDAUSR is defined:the first element - in $IDAUSRelsedefault user directory ($HOME/.idapro or APPDATAHex- - Rays/IDA Pro) + Get user ida related directory. + + - if $IDAUSR is defined: + - the first element in $IDAUSR + - else + - default user directory ($HOME/.idapro or %APPDATA%Hex-Rays/IDA Pro) ida_diskio.getsysfile(): @@ -7908,21 +7970,6 @@ ida_diskio.idadir(): @param subdir (C++: const char *) -class ida_diskio.linput_buffer_t(): - - Proxy of C++ linput_buffer_t class - - -ida_diskio.linput_buffer_t.eof(): - - eof(self) -> bool - - -ida_diskio.linput_buffer_t.read(): - - read(self, buf, n) -> ssize_t - - ida_diskio.open_linput(): open_linput(file, remote) -> linput_t * @@ -7949,10 +7996,20 @@ ida_diskio.qlgetz(): === ida_diskio EPYDOC INJECTIONS === +ida_diskio.IDA_SUBDIR_IDADIR_FIRST +""" +$IDADIR/subdir will be first, not last +""" + ida_diskio.IDA_SUBDIR_IDP """ append the processor name as a subdirectory """ + +ida_diskio.IDA_SUBDIR_ONLY_EXISTING +""" +only existing directories will be present +""" === ida_diskio EPYDOC INJECTIONS END === ida_entry.add_entry(): @@ -8059,9 +8116,15 @@ ida_entry.set_entry_forwarder(): === ida_entry EPYDOC INJECTIONS === ida_entry.AEF_IDBENC """ -non-ASCII bytes will be decoded accordingly +the name is given in the IDB encoding; non-ASCII bytes will be decoded +accordingly Specifying AEF_IDBENC also implies AEF_NODUMMY +""" -the name is given in the IDB encoding; +ida_entry.AEF_NODUMMY +""" +it begins with a dummy suffix. See also AEF_IDBENC + +automatically prepend the name with '_' if """ ida_entry.AEF_UTF8 @@ -8712,15 +8775,26 @@ ida_expr.add_idc_func(): Add an IDC function. This function does not modify the predefined - kernel functions. Example:staticerror_tidaapimyfunc5(idc_value_t*argv, - idc_value_t*res){msg("myfunciscalledwitharg0=%aandarg1=%s - ",argv[0].n - um,argv[1].str);res->num=5;//let'sreturn5returneOk;}staticconstcharmyf - unc5_args[]={VT_LONG,VT_STR,0};staticconstext_idcfunc_tmyfunc_desc={"M - yFunc5",myfunc5,myfunc5_args,NULL,0,EXTFUN_BASE};//afterthis:add_idc_f - unc(myfunc_desc);//thereisanewIDCfunctionwhichcanbecalledlikethis:MyFu - nc5(0x123,"test");If the function already exists, it will be replaced - by the new function + kernel functions. Example: + + static error_t idaapi myfunc5(idc_value_t *argv, idc_value_t *res) + { + msg("myfunc is called with arg0=%a and arg1=%s + ", argv[0].num, argv[1].str); + res->num = 5; // let's return 5 + return eOk; + } + static const char myfunc5_args[] = { VT_LONG, VT_STR, 0 }; + static const ext_idcfunc_t myfunc_desc = { "MyFunc5", myfunc5, myfunc5_args, NULL, 0, EXTFUN_BASE }; + + // after this: + add_idc_func(myfunc_desc); + + // there is a new IDC function which can be called like this: + MyFunc5(0x123, "test"); + + If the function already exists, it will be replaced by the new + function @return: success @@ -8897,7 +8971,7 @@ ida_expr.exec_system_script(): @param file: file name with IDC function(s). The file will be searched in the idc subdir of ida (C++: const char *) @param complain_if_no_file: 1: display warning if the file is not - found 0: don't complain if file doesn't + found 0: don't complain if file doesn't exist (C++: bool) @@ -9126,7 +9200,6 @@ ida_expr.idc_value_t.set_string(): set_string(self, _str, len) set_string(self, _str) - set_string(self, _str) ida_expr.idc_value_t.swap(): @@ -9288,10 +9361,10 @@ ida_expr.idcv_num(): Convert IDC variable to a long number. @param v (C++: idc_value_t *) - @return: v = 0 if IDC variable = "false" string v = 1 if IDC variable - = "true" string v = number if IDC variable is number or - string containing a number eTypeConflict if IDC variable = - empty string + @return: v = 0 if IDC variable = "false" string v = 1 if IDC + variable = "true" string v = number if IDC variable is + number or string containing a number eTypeConflict if IDC + variable = empty string ida_expr.idcv_object(): @@ -9441,6 +9514,21 @@ ida_expr.swap_idcvs(): @param v2 (C++: idc_value_t *) +ida_expr.throw_idc_exception(): + + throw_idc_exception(r, desc) -> error_t + + + Create an idc execution exception object. This helper function can be + used to return an exception from C++ code to IDC. In other words this + function can be called from 'idc_func_t()' callbacks. Sample usage: if + ( !ok ) return throw_idc_exception(r, "detailed error msg"); + + @param r: object to hold the exception object (C++: idc_value_t *) + @param desc: exception description (C++: const char *) + @return: eExecThrow + + === ida_expr EPYDOC INJECTIONS === ida_expr.CPL_DEL_MACROS @@ -9806,11 +9894,12 @@ ida_fixup.get_fixup_value(): Get the operand value. This function get fixup bytes from data or an instruction at `ea' and convert them to the operand value (maybe - partially). It is opposite in meaning to the. For example, FIXUP_HI8 - read a byte at `ea' and shifts it left by 8 bits, or AArch64's custom - fixup BRANCH26 get low 26 bits of the insn at `ea' and shifts it left - by 2 bits. This function is mainly used to get a relocation addend. - 'patch_fixup_value()' 'fixup_handler_t::size' + partially). It is opposite in meaning to the 'patch_fixup_value()' . + For example, FIXUP_HI8 read a byte at 'patch_fixup_value()' `ea' and + shifts it left by 8 bits, or AArch64's custom fixup BRANCH26 get low + 26 bits of the insn at `ea' and shifts it left by 2 bits. This + function is mainly used to get a relocation addend. + 'fixup_handler_t::size' @param ea: address to get fixup bytes from, the size of the fixup bytes depends on the fixup type. (C++: ea_t) @@ -9862,7 +9951,7 @@ ida_fixup.patch_fixup_value(): Patch the fixup bytes. This function updates data or an instruction at `ea' to the fixup bytes. For example, FIXUP_HI8 updates a byte at `ea' - to the high byte of `fd->off', or AArch64's custom fixup BRANCH26 + to the high byte of `fd->off' , or AArch64's custom fixup BRANCH26 updates low 26 bits of the insn at `ea' to the value of `fd->off' shifted right by 2. 'fixup_handler_t::size' @@ -9905,7 +9994,7 @@ database and can be used by the loader at its discretion. ida_fixup.FIXUPF_REL """ -fixup is relative to the linear address `base'. Otherwise fixup is +fixup is relative to the linear address `base' . Otherwise fixup is relative to the start of the segment with `sel' selector. """ @@ -10088,7 +10177,7 @@ ida_frame.add_auto_stkpnt(): @param pfn: pointer to function. may be NULL. (C++: func_t *) @param ea: linear address where SP changes. usually this is the end of the instruction which modifies the stack pointer - ({ea}+{size}) (C++: ea_t) + (\cmd{ea}+\cmd{size}) (C++: ea_t) @param delta: difference between old and new values of SP (C++: sval_t) @return: success @@ -10261,7 +10350,8 @@ ida_frame.find_regvar(): Find a register variable definition (powerful version). One of 'canon' - and 'user' should be NULL. + and 'user' should be NULL. If both 'canon' and 'user' are NULL it + returns the first regvar definition in the range. @param pfn: function in question (C++: func_t *) @param ea1: range of addresses to search. ea1==BADADDR means the @@ -10443,6 +10533,17 @@ ida_frame.get_stkvar(): where actval: actual value used to fetch stack variable +ida_frame.has_regvar(): + + has_regvar(pfn, ea) -> bool + + + Is there a register variable definition? + + @param pfn: function in question (C++: func_t *) + @param ea: current address (C++: ea_t) + + ida_frame.is_funcarg_off(): is_funcarg_off(pfn, frameoff) -> bool @@ -10622,11 +10723,29 @@ ida_frame.set_regvar_cmt(): @return: Register variable error codes +ida_frame.soff_to_fpoff(): + + soff_to_fpoff(pfn, soff) -> sval_t + + + Convert struct offsets into fp-relative offsets. This function + converts the offsets inside the 'struc_t' object into the frame + pointer offsets (for example, EBP-relative). + + @param pfn (C++: func_t *) + @param soff (C++: uval_t) + + class ida_frame.stkpnt_t(): Proxy of C++ stkpnt_t class +ida_frame.stkpnt_t.compare(): + + compare(self, r) -> int + + ida_frame.stkpnt_t.ea: stkpnt_t_ea_get(self) -> ea_t @@ -10638,6 +10757,11 @@ class ida_frame.stkpnts_t(): Proxy of C++ stkpnts_t class +ida_frame.stkpnts_t.compare(): + + compare(self, r) -> int + + ida_frame.update_fpd(): update_fpd(pfn, fpd) -> bool @@ -10646,7 +10770,7 @@ ida_frame.update_fpd(): Update frame pointer delta. @param pfn: pointer to function structure (C++: func_t *) - @param fpd: new fpd value. can not be bigger than the local variable + @param fpd: new fpd value. cannot be bigger than the local variable range size. (C++: asize_t) @return: success @@ -10855,7 +10979,7 @@ ida_funcs.append_func_tail(): Append a new tail chunk to the function definition. If the tail already exists, then it will simply be added to the function tail list Otherwise a new tail will be created and its owner will be set to be - our function If a new tail can not be created, then this function will + our function If a new tail cannot be created, then this function will fail. @param pfn (C++: func_t *) @@ -10889,8 +11013,8 @@ ida_funcs.apply_startup_sig(): Apply a startup signature file to the specified address. - @param ea: address to apply the signature to; usually {start_ea} (C++: - ea_t) + @param ea: address to apply the signature to; usually \inf{start_ea} + (C++: ea_t) @param startup: the name of the signature file without path and extension (C++: const char *) @return: true if successfully applied the signature @@ -10968,7 +11092,7 @@ ida_funcs.find_func_bounds(): Determine the boundaries of a new function. This function tries to find the start and end addresses of a new function. It calls the - module with {func_bounds} in order to fine tune the function + module with \ph{func_bounds} in order to fine tune the function boundaries. @param nfn: structure to fill with information \ nfn->start_ea points @@ -11676,7 +11800,7 @@ ida_funcs.is_finally_visible_func(): is_finally_visible_func(pfn) -> bool - Is the function visible (event after considering 'SW_SHHID_FUNC' )? + Is the function visible (event after considering 'SCF_SHHID_FUNC' )? @param pfn (C++: func_t *) @@ -11749,8 +11873,8 @@ ida_funcs.lock_func_range(): Lock function pointer Locked pointers are guaranteed to remain valid - until they are unlocked. Ranges with locked pointers can not be - deleted or moved. + until they are unlocked. Ranges with locked pointers cannot be deleted + or moved. @param pfn (C++: const func_t *) @param lock (C++: bool) @@ -11790,9 +11914,9 @@ ida_funcs.reanalyze_function(): reanalyze_function(pfn, ea1=0, ea2=BADADDR, analyze_parents=False) - Reanalyze a function. This function analyzes all chunks of the given - function. Optional parameters (ea1, ea2) may be used to narrow the - analyzed range. + Reanalyze a function. This function plans to analyzes all chunks of + the given function. Optional parameters (ea1, ea2) may be used to + narrow the analyzed range. @param pfn: pointer to a function (C++: func_t *) @param ea1: start of the range to analyze (C++: ea_t) @@ -12728,7 +12852,7 @@ ida_graph.GraphViewer.UI_Hooks_Trampoline.database_inited(): ida_graph.GraphViewer.UI_Hooks_Trampoline.debugger_menu_change(): - debugger_menu_change(self, enable) -> int + debugger_menu_change(self, enable) ida_graph.GraphViewer.UI_Hooks_Trampoline.finish_populating_widget_popup(): @@ -12770,6 +12894,11 @@ ida_graph.GraphViewer.UI_Hooks_Trampoline.get_item_hint(): get_item_hint(self, ea, max_lines) -> PyObject * +ida_graph.GraphViewer.UI_Hooks_Trampoline.get_widget_config(): + + get_widget_config(self, widget, cfg) -> PyObject * + + ida_graph.GraphViewer.UI_Hooks_Trampoline.hook(): hook(self) -> bool @@ -12862,6 +12991,11 @@ ida_graph.GraphViewer.UI_Hooks_Trampoline.screen_ea_changed(): screen_ea_changed(self, ea, prev_ea) +ida_graph.GraphViewer.UI_Hooks_Trampoline.set_widget_config(): + + set_widget_config(self, widget, cfg) + + ida_graph.GraphViewer.UI_Hooks_Trampoline.suspend(): suspend(self) @@ -13072,7 +13206,7 @@ class ida_graph.edge_info_t(): ida_graph.edge_info_t.color: - edge_info_t_color_get(self) -> int + edge_info_t_color_get(self) -> bgcolor_t ida_graph.edge_info_t.dstoff: edge_info_t_dstoff_get(self) -> int @@ -14183,6 +14317,127 @@ ida_graph.row_info_t.nodes: ida_graph.row_info_t.top: row_info_t_top_get(self) -> int +class ida_graph.screen_graph_selection_base_t(): + + Proxy of C++ qvector<(selection_item_t)> class + + +ida_graph.screen_graph_selection_base_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_graph.screen_graph_selection_base_t.at(): + + at(self, _idx) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.begin(): + + begin(self) -> selection_item_t + begin(self) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.capacity(): + + capacity(self) -> size_t + + +ida_graph.screen_graph_selection_base_t.clear(): + + clear(self) + + +ida_graph.screen_graph_selection_base_t.empty(): + + empty(self) -> bool + + +ida_graph.screen_graph_selection_base_t.end(): + + end(self) -> selection_item_t + end(self) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.erase(): + + erase(self, it) -> selection_item_t + erase(self, first, last) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.extract(): + + extract(self) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.find(): + + find(self, x) -> selection_item_t + find(self, x) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.grow(): + + grow(self, x=selection_item_t()) + + +ida_graph.screen_graph_selection_base_t.has(): + + has(self, x) -> bool + + +ida_graph.screen_graph_selection_base_t.inject(): + + inject(self, s, len) + + +ida_graph.screen_graph_selection_base_t.insert(): + + insert(self, it, x) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.pop_back(): + + pop_back(self) + + +ida_graph.screen_graph_selection_base_t.push_back(): + + push_back(self, x) + push_back(self) -> selection_item_t + + +ida_graph.screen_graph_selection_base_t.qclear(): + + qclear(self) + + +ida_graph.screen_graph_selection_base_t.reserve(): + + reserve(self, cnt) + + +ida_graph.screen_graph_selection_base_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_graph.screen_graph_selection_base_t.size(): + + size(self) -> size_t + + +ida_graph.screen_graph_selection_base_t.swap(): + + swap(self, r) + + +ida_graph.screen_graph_selection_base_t.truncate(): + + truncate(self) + + class ida_graph.screen_graph_selection_t(): Proxy of C++ screen_graph_selection_t class @@ -14203,6 +14458,32 @@ ida_graph.screen_graph_selection_t.add_point(): add_point(self, e, idx) +ida_graph.screen_graph_selection_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_graph.screen_graph_selection_t.at(): + + at(self, _idx) -> selection_item_t + + +ida_graph.screen_graph_selection_t.begin(): + + begin(self) -> selection_item_t + begin(self) -> selection_item_t + + +ida_graph.screen_graph_selection_t.capacity(): + + capacity(self) -> size_t + + +ida_graph.screen_graph_selection_t.clear(): + + clear(self) + + ida_graph.screen_graph_selection_t.del_node(): del_node(self, node) @@ -14213,11 +14494,54 @@ ida_graph.screen_graph_selection_t.del_point(): del_point(self, e, idx) +ida_graph.screen_graph_selection_t.empty(): + + empty(self) -> bool + + +ida_graph.screen_graph_selection_t.end(): + + end(self) -> selection_item_t + end(self) -> selection_item_t + + +ida_graph.screen_graph_selection_t.erase(): + + erase(self, it) -> selection_item_t + erase(self, first, last) -> selection_item_t + + +ida_graph.screen_graph_selection_t.extract(): + + extract(self) -> selection_item_t + + +ida_graph.screen_graph_selection_t.find(): + + find(self, x) -> selection_item_t + find(self, x) -> selection_item_t + + +ida_graph.screen_graph_selection_t.grow(): + + grow(self, x=selection_item_t()) + + ida_graph.screen_graph_selection_t.has(): has(self, item) -> bool +ida_graph.screen_graph_selection_t.inject(): + + inject(self, s, len) + + +ida_graph.screen_graph_selection_t.insert(): + + insert(self, it, x) -> selection_item_t + + ida_graph.screen_graph_selection_t.items_count(): items_count(self, look_for_nodes) -> size_t @@ -14233,11 +14557,53 @@ ida_graph.screen_graph_selection_t.points_count(): points_count(self) -> size_t +ida_graph.screen_graph_selection_t.pop_back(): + + pop_back(self) + + +ida_graph.screen_graph_selection_t.push_back(): + + push_back(self, x) + push_back(self) -> selection_item_t + + +ida_graph.screen_graph_selection_t.qclear(): + + qclear(self) + + +ida_graph.screen_graph_selection_t.reserve(): + + reserve(self, cnt) + + +ida_graph.screen_graph_selection_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_graph.screen_graph_selection_t.size(): + + size(self) -> size_t + + ida_graph.screen_graph_selection_t.sub(): sub(self, s) +ida_graph.screen_graph_selection_t.swap(): + + swap(self, r) + + +ida_graph.screen_graph_selection_t.truncate(): + + truncate(self) + + class ida_graph.selection_item_t(): Proxy of C++ selection_item_t class @@ -14611,7 +14977,7 @@ ida_hexrays.Hexrays_Hooks.lvar_cmt_changed(): ida_hexrays.Hexrays_Hooks.lvar_mapping_changed(): - lvar_mapping_changed(self, vu, _from, to) -> int + lvar_mapping_changed(self, vu, frm, to) -> int ida_hexrays.Hexrays_Hooks.lvar_name_changed(): @@ -14681,7 +15047,7 @@ ida_hexrays.Hexrays_Hooks.right_click(): ida_hexrays.Hexrays_Hooks.stkpnts(): - stkpnts(self, mba, stkpnts) -> int + stkpnts(self, mba, _sps) -> int ida_hexrays.Hexrays_Hooks.structural(): @@ -14704,6 +15070,17 @@ ida_hexrays.Hexrays_Hooks.unhook(): unhook(self) -> bool +ida_hexrays.accepts_small_udts(): + + accepts_small_udts(op) -> bool + + + Is the operator allowed on small structure or union? + + + @param op (C++: ctype_t) + + ida_hexrays.accepts_udts(): accepts_udts(op) -> bool @@ -14723,6 +15100,248 @@ ida_hexrays.arglocs_overlap(): @param w2 (C++: size_t) +class ida_hexrays.array_of_bitsets(): + + Proxy of C++ qvector<(bitset_t)> class + + +ida_hexrays.array_of_bitsets.add_unique(): + + add_unique(self, x) -> bool + + +ida_hexrays.array_of_bitsets.at(): + + at(self, _idx) -> bitset_t + + +ida_hexrays.array_of_bitsets.begin(): + + begin(self) -> bitset_t + begin(self) -> bitset_t + + +ida_hexrays.array_of_bitsets.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.array_of_bitsets.clear(): + + clear(self) + + +ida_hexrays.array_of_bitsets.empty(): + + empty(self) -> bool + + +ida_hexrays.array_of_bitsets.end(): + + end(self) -> bitset_t + end(self) -> bitset_t + + +ida_hexrays.array_of_bitsets.erase(): + + erase(self, it) -> bitset_t + erase(self, first, last) -> bitset_t + + +ida_hexrays.array_of_bitsets.extract(): + + extract(self) -> bitset_t + + +ida_hexrays.array_of_bitsets.find(): + + find(self, x) -> bitset_t + find(self, x) -> bitset_t + + +ida_hexrays.array_of_bitsets.grow(): + + grow(self, x=bitset_t()) + + +ida_hexrays.array_of_bitsets.has(): + + has(self, x) -> bool + + +ida_hexrays.array_of_bitsets.inject(): + + inject(self, s, len) + + +ida_hexrays.array_of_bitsets.insert(): + + insert(self, it, x) -> bitset_t + + +ida_hexrays.array_of_bitsets.pop_back(): + + pop_back(self) + + +ida_hexrays.array_of_bitsets.push_back(): + + push_back(self, x) + push_back(self) -> bitset_t + + +ida_hexrays.array_of_bitsets.qclear(): + + qclear(self) + + +ida_hexrays.array_of_bitsets.reserve(): + + reserve(self, cnt) + + +ida_hexrays.array_of_bitsets.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.array_of_bitsets.size(): + + size(self) -> size_t + + +ida_hexrays.array_of_bitsets.swap(): + + swap(self, r) + + +ida_hexrays.array_of_bitsets.truncate(): + + truncate(self) + + +class ida_hexrays.array_of_ivlsets(): + + Proxy of C++ qvector<(ivlset_t)> class + + +ida_hexrays.array_of_ivlsets.add_unique(): + + add_unique(self, x) -> bool + + +ida_hexrays.array_of_ivlsets.at(): + + at(self, _idx) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.begin(): + + begin(self) -> ivlset_t + begin(self) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.array_of_ivlsets.clear(): + + clear(self) + + +ida_hexrays.array_of_ivlsets.empty(): + + empty(self) -> bool + + +ida_hexrays.array_of_ivlsets.end(): + + end(self) -> ivlset_t + end(self) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.erase(): + + erase(self, it) -> ivlset_t + erase(self, first, last) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.extract(): + + extract(self) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.find(): + + find(self, x) -> ivlset_t + find(self, x) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.grow(): + + grow(self, x=ivlset_t()) + + +ida_hexrays.array_of_ivlsets.has(): + + has(self, x) -> bool + + +ida_hexrays.array_of_ivlsets.inject(): + + inject(self, s, len) + + +ida_hexrays.array_of_ivlsets.insert(): + + insert(self, it, x) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.pop_back(): + + pop_back(self) + + +ida_hexrays.array_of_ivlsets.push_back(): + + push_back(self, x) + push_back(self) -> ivlset_t + + +ida_hexrays.array_of_ivlsets.qclear(): + + qclear(self) + + +ida_hexrays.array_of_ivlsets.reserve(): + + reserve(self, cnt) + + +ida_hexrays.array_of_ivlsets.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.array_of_ivlsets.size(): + + size(self) -> size_t + + +ida_hexrays.array_of_ivlsets.swap(): + + swap(self, r) + + +ida_hexrays.array_of_ivlsets.truncate(): + + truncate(self) + + ida_hexrays.asgop(): asgop(cop) -> ctype_t @@ -14759,6 +15378,431 @@ ida_hexrays.bit_bound_t.nbits: ida_hexrays.bit_bound_t.sbits: bit_bound_t_sbits_get(self) -> int16 +class ida_hexrays.bitset_t(): + + Proxy of C++ bitset_t class + + +ida_hexrays.bitset_t.add(): + + add(self, bit) -> bool + add(self, bit, width) -> bool + add(self, ml) -> bool + + +ida_hexrays.bitset_t.back(): + + back(self) -> int + + +ida_hexrays.bitset_t.begin(): + + begin(self) -> bitset_t::iterator + + +ida_hexrays.bitset_t.clear(): + + clear(self) + + +ida_hexrays.bitset_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.bitset_t.copy(): + + copy(self, m) -> bitset_t + + +ida_hexrays.bitset_t.count(): + + count(self) -> int + count(self, bit) -> int + + +ida_hexrays.bitset_t.cut_at(): + + cut_at(self, maxbit) -> bool + + +ida_hexrays.bitset_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.bitset_t.empty(): + + empty(self) -> bool + + +ida_hexrays.bitset_t.end(): + + end(self) -> bitset_t::iterator + + +ida_hexrays.bitset_t.fill_with_ones(): + + fill_with_ones(self, maxbit) + + +ida_hexrays.bitset_t.front(): + + front(self) -> int + + +ida_hexrays.bitset_t.has(): + + has(self, bit) -> bool + + +ida_hexrays.bitset_t.has_all(): + + has_all(self, bit, width) -> bool + + +ida_hexrays.bitset_t.has_any(): + + has_any(self, bit, width) -> bool + + +ida_hexrays.bitset_t.has_common(): + + has_common(self, ml) -> bool + + +ida_hexrays.bitset_t.inc(): + + inc(self, p, n=1) + + +ida_hexrays.bitset_t.includes(): + + includes(self, ml) -> bool + + +ida_hexrays.bitset_t.intersect(): + + intersect(self, ml) -> bool + + +ida_hexrays.bitset_t.is_subset_of(): + + is_subset_of(self, ml) -> bool + + +ida_hexrays.bitset_t.itat(): + + itat(self, n) -> bitset_t::iterator + + +ida_hexrays.bitset_t.itv(): + + itv(self, it) -> int + + +ida_hexrays.bitset_t.last(): + + last(self) -> int + + +ida_hexrays.bitset_t.shift_down(): + + shift_down(self, shift) + + +ida_hexrays.bitset_t.sub(): + + sub(self, bit) -> bool + sub(self, bit, width) -> bool + sub(self, ml) -> bool + + +ida_hexrays.bitset_t.swap(): + + swap(self, r) + + +ida_hexrays.block_chains_begin(): + + block_chains_begin(set) -> block_chains_iterator_t + + + Get iterator pointing to the beginning of 'block_chains_t' . + + + @param set (C++: const block_chains_t *) + + +ida_hexrays.block_chains_clear(): + + block_chains_clear(set) + + + Clear 'block_chains_t' . + + + @param set (C++: block_chains_t *) + + +ida_hexrays.block_chains_end(): + + block_chains_end(set) -> block_chains_iterator_t + + + Get iterator pointing to the end of 'block_chains_t' . + + + @param set (C++: const block_chains_t *) + + +ida_hexrays.block_chains_erase(): + + block_chains_erase(set, p) + + + Erase current element from 'block_chains_t' . + + + @param set (C++: block_chains_t *) + @param p (C++: block_chains_iterator_t) + + +ida_hexrays.block_chains_find(): + + block_chains_find(set, val) -> block_chains_iterator_t + + + Find the specified key in set 'block_chains_t' . + + + @param set (C++: const block_chains_t *) + @param val (C++: const chain_t &) + + +ida_hexrays.block_chains_free(): + + block_chains_free(set) + + + Delete 'block_chains_t' instance. + + + @param set (C++: block_chains_t *) + + +ida_hexrays.block_chains_get(): + + block_chains_get(p) -> chain_t + + + Get reference to the current set value. + + + @param p (C++: block_chains_iterator_t) + + +ida_hexrays.block_chains_insert(): + + block_chains_insert(set, val) -> block_chains_iterator_t + + + Insert new ( 'chain_t' ) into set 'block_chains_t' . + + + @param set (C++: block_chains_t *) + @param val (C++: const chain_t &) + + +class ida_hexrays.block_chains_iterator_t(): + + Proxy of C++ block_chains_iterator_t class + + +ida_hexrays.block_chains_iterator_t.x: + block_chains_iterator_t_x_get(self) -> iterator_word + +ida_hexrays.block_chains_new(): + + block_chains_new() -> block_chains_t + + + Create a new 'block_chains_t' instance. + + +ida_hexrays.block_chains_next(): + + block_chains_next(p) -> block_chains_iterator_t + + + Move to the next element. + + + @param p (C++: block_chains_iterator_t) + + +ida_hexrays.block_chains_prev(): + + block_chains_prev(p) -> block_chains_iterator_t + + + Move to the previous element. + + + @param p (C++: block_chains_iterator_t) + + +ida_hexrays.block_chains_size(): + + block_chains_size(set) -> size_t + + + Get size of 'block_chains_t' . + + + @param set (C++: block_chains_t *) + + +class ida_hexrays.block_chains_t(): + + Proxy of C++ block_chains_t class + + +ida_hexrays.block_chains_t._print(): + + _print(self) + + +ida_hexrays.block_chains_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.block_chains_t.get_chain(): + + get_chain(self, k, width=1) -> chain_t + get_chain(self, k, width=1) -> chain_t + get_chain(self, ch) -> chain_t + get_chain(self, ch) -> chain_t + + +ida_hexrays.block_chains_t.get_reg_chain(): + + get_reg_chain(self, reg, width=1) -> chain_t + get_reg_chain(self, reg, width=1) -> chain_t + + +ida_hexrays.block_chains_t.get_stk_chain(): + + get_stk_chain(self, off, width=1) -> chain_t + get_stk_chain(self, off, width=1) -> chain_t + + +class ida_hexrays.block_chains_vec_t(): + + Proxy of C++ qvector<(block_chains_t)> class + + +ida_hexrays.block_chains_vec_t.at(): + + at(self, _idx) -> block_chains_t + + +ida_hexrays.block_chains_vec_t.begin(): + + begin(self) -> block_chains_t + begin(self) -> block_chains_t + + +ida_hexrays.block_chains_vec_t.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.block_chains_vec_t.clear(): + + clear(self) + + +ida_hexrays.block_chains_vec_t.empty(): + + empty(self) -> bool + + +ida_hexrays.block_chains_vec_t.end(): + + end(self) -> block_chains_t + end(self) -> block_chains_t + + +ida_hexrays.block_chains_vec_t.erase(): + + erase(self, it) -> block_chains_t + erase(self, first, last) -> block_chains_t + + +ida_hexrays.block_chains_vec_t.extract(): + + extract(self) -> block_chains_t + + +ida_hexrays.block_chains_vec_t.grow(): + + grow(self, x=block_chains_t()) + + +ida_hexrays.block_chains_vec_t.inject(): + + inject(self, s, len) + + +ida_hexrays.block_chains_vec_t.insert(): + + insert(self, it, x) -> block_chains_t + + +ida_hexrays.block_chains_vec_t.pop_back(): + + pop_back(self) + + +ida_hexrays.block_chains_vec_t.push_back(): + + push_back(self, x) + push_back(self) -> block_chains_t + + +ida_hexrays.block_chains_vec_t.qclear(): + + qclear(self) + + +ida_hexrays.block_chains_vec_t.reserve(): + + reserve(self, cnt) + + +ida_hexrays.block_chains_vec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.block_chains_vec_t.size(): + + size(self) -> size_t + + +ida_hexrays.block_chains_vec_t.swap(): + + swap(self, r) + + +ida_hexrays.block_chains_vec_t.truncate(): + + truncate(self) + + ida_hexrays.boundaries_begin(): boundaries_begin(map) -> boundaries_iterator_t @@ -15548,6 +16592,12 @@ ida_hexrays.carglist_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.carglist_t.append(): + + push_back(self, x) + push_back(self) -> carg_t + + ida_hexrays.carglist_t.at(): __getitem__(self, i) -> carg_t @@ -15675,16 +16725,133 @@ class ida_hexrays.casm_t(): Proxy of C++ casm_t class +ida_hexrays.casm_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_hexrays.casm_t.append(): + + push_back(self, x) + push_back(self) -> unsigned-ea-like-numeric-type & + + +ida_hexrays.casm_t.at(): + + __getitem__(self, i) -> unsigned-ea-like-numeric-type & + + +ida_hexrays.casm_t.begin(): + + begin(self) -> qvector< unsigned-ea-like-numeric-type >::iterator + begin(self) -> qvector< unsigned-ea-like-numeric-type >::const_iterator + + +ida_hexrays.casm_t.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.casm_t.clear(): + + clear(self) + + ida_hexrays.casm_t.compare(): compare(self, r) -> int +ida_hexrays.casm_t.empty(): + + empty(self) -> bool + + +ida_hexrays.casm_t.end(): + + end(self) -> qvector< unsigned-ea-like-numeric-type >::iterator + end(self) -> qvector< unsigned-ea-like-numeric-type >::const_iterator + + +ida_hexrays.casm_t.erase(): + + erase(self, it) -> qvector< unsigned-ea-like-numeric-type >::iterator + erase(self, first, last) -> qvector< unsigned-ea-like-numeric-type >::iterator + + +ida_hexrays.casm_t.extract(): + + extract(self) -> unsigned-ea-like-numeric-type * + + +ida_hexrays.casm_t.find(): + + find(self, x) -> qvector< unsigned-ea-like-numeric-type >::iterator + find(self, x) -> qvector< unsigned-ea-like-numeric-type >::const_iterator + + +ida_hexrays.casm_t.has(): + + has(self, x) -> bool + + +ida_hexrays.casm_t.inject(): + + inject(self, s, len) + + +ida_hexrays.casm_t.insert(): + + insert(self, it, x) -> qvector< unsigned-ea-like-numeric-type >::iterator + + ida_hexrays.casm_t.one_insn(): one_insn(self) -> bool +ida_hexrays.casm_t.pop_back(): + + pop_back(self) + + +ida_hexrays.casm_t.push_back(): + + push_back(self, x) + push_back(self) -> unsigned-ea-like-numeric-type & + + +ida_hexrays.casm_t.qclear(): + + qclear(self) + + +ida_hexrays.casm_t.reserve(): + + reserve(self, cnt) + + +ida_hexrays.casm_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.casm_t.size(): + + size(self) -> size_t + + +ida_hexrays.casm_t.swap(): + + swap(self, r) + + +ida_hexrays.casm_t.truncate(): + + truncate(self) + + class ida_hexrays.cblock_t(): Proxy of C++ cblock_t class @@ -15926,7 +17093,7 @@ ida_hexrays.ccase_t.value(): ida_hexrays.ccase_t.values: - ccase_t_values_get(self) -> uint64vec_t * + ccase_t_values_get(self) -> ulonglongvec_t ida_hexrays.ccase_t.zero(): @@ -15943,6 +17110,12 @@ ida_hexrays.ccases_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.ccases_t.append(): + + push_back(self, x) + push_back(self) -> ccase_t + + ida_hexrays.ccases_t.at(): __getitem__(self, i) -> ccase_t @@ -16565,7 +17738,7 @@ class ida_hexrays.cfunc_t(): ida_hexrays.cfunc_t.argidx: - cfunc_t_argidx_get(self) -> intvec_t & + cfunc_t_argidx_get(self) -> intvec_t ida_hexrays.cfunc_t.body: cfunc_t_body_get(self) -> cinsn_t @@ -16636,7 +17809,7 @@ ida_hexrays.cfunc_t.get_lvars(): ida_hexrays.cfunc_t.get_pseudocode(): - get_pseudocode(self) -> strvec_t const & + get_pseudocode(self) -> strvec_t ida_hexrays.cfunc_t.get_stkoff_delta(): @@ -16681,7 +17854,7 @@ ida_hexrays.cfunc_t.maturity: cfunc_t_maturity_get(self) -> ctree_maturity_t ida_hexrays.cfunc_t.mba: - cfunc_t_mba_get(self) -> mbl_array_t * + cfunc_t_mba_get(self) -> mbl_array_t ida_hexrays.cfunc_t.numforms: cfunc_t_numforms_get(self) -> user_numforms_t @@ -16698,12 +17871,17 @@ ida_hexrays.cfunc_t.print_func(): ida_hexrays.cfunc_t.pseudocode: - get_pseudocode(self) -> strvec_t const & + get_pseudocode(self) -> strvec_t ida_hexrays.cfunc_t.refcnt: cfunc_t_refcnt_get(self) -> int +ida_hexrays.cfunc_t.refresh_func_ctext(): + + refresh_func_ctext(self) + + ida_hexrays.cfunc_t.release(): release(self) @@ -16798,7 +17976,7 @@ class ida_hexrays.cfuncptr_t(): ida_hexrays.cfuncptr_t.argidx: - cfuncptr_t_argidx_get(self) -> intvec_t & + cfuncptr_t_argidx_get(self) -> intvec_t ida_hexrays.cfuncptr_t.body: cfuncptr_t_body_get(self) -> cinsn_t @@ -16859,7 +18037,7 @@ ida_hexrays.cfuncptr_t.get_lvars(): ida_hexrays.cfuncptr_t.get_pseudocode(): - get_pseudocode(self) -> strvec_t const & + get_pseudocode(self) -> strvec_t ida_hexrays.cfuncptr_t.get_stkoff_delta(): @@ -16899,7 +18077,7 @@ ida_hexrays.cfuncptr_t.maturity: cfuncptr_t_maturity_get(self) -> ctree_maturity_t ida_hexrays.cfuncptr_t.mba: - cfuncptr_t_mba_get(self) -> mbl_array_t * + cfuncptr_t_mba_get(self) -> mbl_array_t ida_hexrays.cfuncptr_t.numforms: cfuncptr_t_numforms_get(self) -> user_numforms_t @@ -16917,6 +18095,11 @@ ida_hexrays.cfuncptr_t.print_func(): ida_hexrays.cfuncptr_t.refcnt: cfuncptr_t_refcnt_get(self) -> int +ida_hexrays.cfuncptr_t.refresh_func_ctext(): + + refresh_func_ctext(self) + + ida_hexrays.cfuncptr_t.release(): release(self) @@ -17008,6 +18191,302 @@ ida_hexrays.cgoto_t.compare(): ida_hexrays.cgoto_t.label_num: cgoto_t_label_num_get(self) -> int +class ida_hexrays.chain_keeper_t(): + + Proxy of C++ chain_keeper_t class + + +ida_hexrays.chain_keeper_t.back(): + + back(self) -> block_chains_t + + +ida_hexrays.chain_keeper_t.for_all_chains(): + + for_all_chains(self, cv, gca) -> int + + +ida_hexrays.chain_keeper_t.front(): + + front(self) -> block_chains_t + + +class ida_hexrays.chain_t(): + + Proxy of C++ chain_t class + + +ida_hexrays.chain_t._print(): + + _print(self) + + +ida_hexrays.chain_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_hexrays.chain_t.append(): + + push_back(self, x) + push_back(self) -> int & + + +ida_hexrays.chain_t.append_list(): + + append_list(self, list) + + +ida_hexrays.chain_t.at(): + + __getitem__(self, i) -> int const & + + +ida_hexrays.chain_t.begin(): + + begin(self) -> qvector< int >::iterator + begin(self) -> qvector< int >::const_iterator + + +ida_hexrays.chain_t.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.chain_t.clear(): + + clear(self) + + +ida_hexrays.chain_t.clear_varnum(): + + clear_varnum(self) + + +ida_hexrays.chain_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.chain_t.empty(): + + empty(self) -> bool + + +ida_hexrays.chain_t.end(): + + end(self) -> qvector< int >::iterator + end(self) -> qvector< int >::const_iterator + + +ida_hexrays.chain_t.endoff(): + + endoff(self) -> voff_t + + +ida_hexrays.chain_t.erase(): + + erase(self, it) -> qvector< int >::iterator + erase(self, first, last) -> qvector< int >::iterator + + +ida_hexrays.chain_t.extract(): + + extract(self) -> int * + + +ida_hexrays.chain_t.find(): + + find(self, x) -> qvector< int >::iterator + find(self, x) -> qvector< int >::const_iterator + + +ida_hexrays.chain_t.flags: + chain_t_flags_get(self) -> uchar + +ida_hexrays.chain_t.get_reg(): + + get_reg(self) -> mreg_t + + +ida_hexrays.chain_t.get_stkoff(): + + get_stkoff(self) -> sval_t + + +ida_hexrays.chain_t.has(): + + has(self, x) -> bool + + +ida_hexrays.chain_t.includes(): + + includes(self, r) -> bool + + +ida_hexrays.chain_t.inject(): + + inject(self, s, len) + + +ida_hexrays.chain_t.insert(): + + insert(self, it, x) -> qvector< int >::iterator + + +ida_hexrays.chain_t.is_fake(): + + is_fake(self) -> bool + + +ida_hexrays.chain_t.is_inited(): + + is_inited(self) -> bool + + +ida_hexrays.chain_t.is_overlapped(): + + is_overlapped(self) -> bool + + +ida_hexrays.chain_t.is_passreg(): + + is_passreg(self) -> bool + + +ida_hexrays.chain_t.is_reg(): + + is_reg(self) -> bool + + +ida_hexrays.chain_t.is_replaced(): + + is_replaced(self) -> bool + + +ida_hexrays.chain_t.is_stkoff(): + + is_stkoff(self) -> bool + + +ida_hexrays.chain_t.is_term(): + + is_term(self) -> bool + + +ida_hexrays.chain_t.key(): + + key(self) -> voff_t + + +ida_hexrays.chain_t.overlap(): + + overlap(self, r) -> bool + + +ida_hexrays.chain_t.pop_back(): + + pop_back(self) + + +ida_hexrays.chain_t.push_back(): + + push_back(self, x) + push_back(self) -> int & + + +ida_hexrays.chain_t.qclear(): + + qclear(self) + + +ida_hexrays.chain_t.reserve(): + + reserve(self, cnt) + + +ida_hexrays.chain_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.chain_t.set_inited(): + + set_inited(self, b) + + +ida_hexrays.chain_t.set_overlapped(): + + set_overlapped(self, b) + + +ida_hexrays.chain_t.set_replaced(): + + set_replaced(self, b) + + +ida_hexrays.chain_t.set_term(): + + set_term(self, b) + + +ida_hexrays.chain_t.set_value(): + + set_value(self, r) + + +ida_hexrays.chain_t.size(): + + size(self) -> size_t + + +ida_hexrays.chain_t.swap(): + + swap(self, r) + + +ida_hexrays.chain_t.truncate(): + + truncate(self) + + +ida_hexrays.chain_t.varnum: + chain_t_varnum_get(self) -> int + +ida_hexrays.chain_t.width: + chain_t_width_get(self) -> int + +class ida_hexrays.chain_visitor_t(): + + Proxy of C++ chain_visitor_t class + + +ida_hexrays.chain_visitor_t.parent: + chain_visitor_t_parent_get(self) -> block_chains_t + +ida_hexrays.chain_visitor_t.visit_chain(): + + visit_chain(self, nblock, ch) -> int + + +ida_hexrays.checkout_hexrays_license(): + + checkout_hexrays_license(silent) -> bool + + + Check out a floating decompiler license. This function will display a + dialog box if the license is not available. For non-floating licenses + this function is effectively no-op. It is not necessary to call this + function before decompiling. If the license was not checked out, the + decompiler will automatically do it. This function can be used to + check out a license in advance and ensure that a license is available. + + @param silent: silently fail if the license can not be checked out. + (C++: bool) + @return: false if failed + + class ida_hexrays.cif_t(): Proxy of C++ cif_t class @@ -17200,6 +18679,12 @@ ida_hexrays.cinsnptrvec_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.cinsnptrvec_t.append(): + + push_back(self, x) + push_back(self) -> cinsn_t *& + + ida_hexrays.cinsnptrvec_t.at(): __getitem__(self, i) -> cinsn_t @@ -17492,12 +18977,12 @@ ida_hexrays.codegen_t.analyze_prolog(): ida_hexrays.codegen_t.emit(): emit(self, code, width, l, r, d, offsize) -> minsn_t - emit(self, code, l, r, d) -> minsn_t * + emit(self, code, l, r, d) -> minsn_t ida_hexrays.codegen_t.emit_micro_mvm(): - emit_micro_mvm(self, code, dtype, l, r, d, offsize) -> minsn_t * + emit_micro_mvm(self, code, dtype, l, r, d, offsize) -> minsn_t ida_hexrays.codegen_t.gen_micro(): @@ -17517,53 +19002,10 @@ ida_hexrays.codegen_t.load_operand(): ida_hexrays.codegen_t.mb: - codegen_t_mb_get(self) -> mblock_t * + codegen_t_mb_get(self) -> mblock_t ida_hexrays.codegen_t.mba: - codegen_t_mba_get(self) -> mbl_array_t * - -ida_hexrays.compare(): - - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - + codegen_t_mba_get(self) -> mbl_array_t ida_hexrays.convert_to_user_call(): @@ -17741,6 +19183,12 @@ ida_hexrays.ctree_items_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.ctree_items_t.append(): + + push_back(self, x) + push_back(self) -> citem_t *& + + ida_hexrays.ctree_items_t.at(): __getitem__(self, i) -> citem_t @@ -18075,6 +19523,23 @@ ida_hexrays.debug_hexrays_ctree(): debug_hexrays_ctree(msg) +ida_hexrays.decompile_func(): + + decompile_func(pfn, hf, flags=0) -> cfuncptr_t + + + Decompile a function. Multiple decompilations of the same function + return the same object. + + @param pfn: pointer to function to decompile (C++: func_t *) + @param hf: extended error information (if failed) (C++: + hexrays_failure_t *) + @param flags: bitwise combination of decompile() flags ... bits (C++: + int) + @return: pointer to the decompilation result (a reference counted + pointer). NULL if failed. + + ida_hexrays.decompile_many(): decompile_many(outfile, funcaddrs, flags) -> bool @@ -18091,6 +19556,17 @@ ida_hexrays.decompile_many(): cancelled decompilation +ida_hexrays.dstr(): + + dstr(tif) -> char const * + + + Print the specified type info. This function can be used from a + debugger by typing "tif->dstr()" + + @param tif (C++: const tinfo_t *) + + ida_hexrays.dummy_ptrtype(): dummy_ptrtype(ptrsize, isfp) -> tinfo_t @@ -18313,6 +19789,12 @@ ida_hexrays.eamap_t.valuetype.add_unique(): add_unique(self, x) -> bool +ida_hexrays.eamap_t.valuetype.append(): + + push_back(self, x) + push_back(self) -> cinsn_t *& + + ida_hexrays.eamap_t.valuetype.at(): __getitem__(self, i) -> cinsn_t @@ -18460,11 +19942,76 @@ ida_hexrays.fnumber_t.fnum: ida_hexrays.fnumber_t.nbytes: fnumber_t_nbytes_get(self) -> int +class ida_hexrays.gco_info_t(): + + Proxy of C++ gco_info_t class + + +ida_hexrays.gco_info_t.append_to_list(): + + append_to_list(self, list, mba) -> bool + + +ida_hexrays.gco_info_t.flags: + gco_info_t_flags_get(self) -> int + +ida_hexrays.gco_info_t.is_def(): + + is_def(self) -> bool + + +ida_hexrays.gco_info_t.is_reg(): + + is_reg(self) -> bool + + +ida_hexrays.gco_info_t.is_use(): + + is_use(self) -> bool + + +ida_hexrays.gco_info_t.name: + gco_info_t_name_get(self) -> qstring * + +ida_hexrays.gco_info_t.size: + gco_info_t_size_get(self) -> int + +ida_hexrays.gen_microcode(): + + gen_microcode(mbr, hf, retlist=None, flags=0, reqmat=MMAT_GLBOPT3) -> mbl_array_t + + + Generate microcode of an arbitrary code snippet + + @param mbr: snippet ranges (C++: const mba_ranges_t &) + @param hf: extended error information (if failed) (C++: + hexrays_failure_t *) + @param retlist: list of registers the snippet returns (C++: const + mlist_t *) + @param flags: bitwise combination of decompile() flags ... bits (C++: + int) + @param reqmat: required microcode maturity (C++: mba_maturity_t) + @return: pointer to the microcode, NULL if failed. + + ida_hexrays.get_ctype_name(): get_ctype_name(op) -> char const * +ida_hexrays.get_current_operand(): + + get_current_operand(out) -> bool + + + Get the instruction operand under the cursor. This function determines + the operand that is under the cursor in the active disassembly + listing. If the operand refers to a register or stack variable, it + return true. + + @param out (C++: gco_info_t *) + + ida_hexrays.get_float_type(): get_float_type(width) -> tinfo_t @@ -18525,6 +20072,11 @@ ida_hexrays.get_merror_desc(): @return: the error address +ida_hexrays.get_mreg_name(): + + get_mreg_name(bit, width, ud=None) -> int + + ida_hexrays.get_op_signness(): get_op_signness(op) -> type_sign_t @@ -18537,6 +20089,24 @@ ida_hexrays.get_op_signness(): @param op (C++: ctype_t) +ida_hexrays.get_signed_mcode(): + + get_signed_mcode(code) -> mcode_t + + +ida_hexrays.get_temp_regs(): + + get_temp_regs() -> mlist_t + + + Get list of temporary registers. Tempregs are temporary registers that + are used during code generation. They do not map to regular processor + registers. They are used only to store temporary values during + execution of one instruction. Tempregs may not be used to pass a value + from one block to another. In other words, at the end of a block all + tempregs must be dead. + + ida_hexrays.get_type(): get_type(id, tif, guess) -> bool @@ -18562,6 +20132,11 @@ ida_hexrays.get_unk_type(): @param size: size of the type in bytes (C++: int) +ida_hexrays.get_unsigned_mcode(): + + get_unsigned_mcode(code) -> mcode_t + + ida_hexrays.get_widget_vdui(): get_widget_vdui(f) -> vdui_t @@ -18573,6 +20148,153 @@ ida_hexrays.get_widget_vdui(): @return: a vdui_t *, or NULL +ida_hexrays.getb_reginsn(): + + getb_reginsn(ins) -> minsn_t + + + Skip assertions backward. + + + @param ins (C++: const minsn_t *) + + +ida_hexrays.getf_reginsn(): + + getf_reginsn(ins) -> minsn_t + + + Skip assertions forward. + + + @param ins (C++: const minsn_t *) + + +class ida_hexrays.graph_chains_t(): + + Proxy of C++ graph_chains_t class + + +ida_hexrays.graph_chains_t.acquire(): + + acquire(self) + + +ida_hexrays.graph_chains_t.at(): + + at(self, _idx) -> block_chains_t + + +ida_hexrays.graph_chains_t.begin(): + + begin(self) -> block_chains_t + begin(self) -> block_chains_t + + +ida_hexrays.graph_chains_t.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.graph_chains_t.clear(): + + clear(self) + + +ida_hexrays.graph_chains_t.empty(): + + empty(self) -> bool + + +ida_hexrays.graph_chains_t.end(): + + end(self) -> block_chains_t + end(self) -> block_chains_t + + +ida_hexrays.graph_chains_t.erase(): + + erase(self, it) -> block_chains_t + erase(self, first, last) -> block_chains_t + + +ida_hexrays.graph_chains_t.extract(): + + extract(self) -> block_chains_t + + +ida_hexrays.graph_chains_t.for_all_chains(): + + for_all_chains(self, cv, gca_flags) -> int + + +ida_hexrays.graph_chains_t.grow(): + + grow(self, x=block_chains_t()) + + +ida_hexrays.graph_chains_t.inject(): + + inject(self, s, len) + + +ida_hexrays.graph_chains_t.insert(): + + insert(self, it, x) -> block_chains_t + + +ida_hexrays.graph_chains_t.is_locked(): + + is_locked(self) -> bool + + +ida_hexrays.graph_chains_t.pop_back(): + + pop_back(self) + + +ida_hexrays.graph_chains_t.push_back(): + + push_back(self, x) + push_back(self) -> block_chains_t + + +ida_hexrays.graph_chains_t.qclear(): + + qclear(self) + + +ida_hexrays.graph_chains_t.release(): + + release(self) + + +ida_hexrays.graph_chains_t.reserve(): + + reserve(self, cnt) + + +ida_hexrays.graph_chains_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.graph_chains_t.size(): + + size(self) -> size_t + + +ida_hexrays.graph_chains_t.swap(): + + swap(self, r) + + +ida_hexrays.graph_chains_t.truncate(): + + truncate(self) + + ida_hexrays.has_cached_cfunc(): has_cached_cfunc(ea) -> bool @@ -18642,6 +20364,12 @@ ida_hexrays.hexwarns_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.hexwarns_t.append(): + + push_back(self, x) + push_back(self) -> hexwarn_t + + ida_hexrays.hexwarns_t.at(): __getitem__(self, i) -> hexwarn_t @@ -18793,6 +20521,12 @@ ida_hexrays.history_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.history_t.append(): + + push_back(self, x) + push_back(self) -> history_item_t + + ida_hexrays.history_t.at(): __getitem__(self, i) -> history_item_t @@ -18963,10 +20697,10 @@ ida_hexrays.is_additive(): ida_hexrays.is_allowed_on_small_struni(): - is_allowed_on_small_struni(op) -> bool + accepts_small_udts(op) -> bool - Is the operator allowed on small struni (structure/union)? + Is the operator allowed on small structure or union? @param op (C++: ctype_t) @@ -19049,6 +20783,17 @@ ida_hexrays.is_inplace_def(): @param type (C++: const tinfo_t &) +ida_hexrays.is_kreg(): + + is_kreg(r) -> bool + + + Is a kernel register? + + + @param r (C++: mreg_t) + + ida_hexrays.is_logical(): is_logical(op) -> bool @@ -19082,6 +20827,89 @@ ida_hexrays.is_lvalue(): @param op (C++: ctype_t) +ida_hexrays.is_may_access(): + + is_may_access(maymust) -> bool + + +ida_hexrays.is_mcode_addsub(): + + is_mcode_addsub(mcode) -> bool + + +ida_hexrays.is_mcode_call(): + + is_mcode_call(mcode) -> bool + + +ida_hexrays.is_mcode_commutative(): + + is_mcode_commutative(mcode) -> bool + + +ida_hexrays.is_mcode_convertible_to_jmp(): + + is_mcode_convertible_to_jmp(mcode) -> bool + + +ida_hexrays.is_mcode_convertible_to_set(): + + is_mcode_convertible_to_set(mcode) -> bool + + +ida_hexrays.is_mcode_divmod(): + + is_mcode_divmod(op) -> bool + + +ida_hexrays.is_mcode_fpu(): + + is_mcode_fpu(mcode) -> bool + + +ida_hexrays.is_mcode_j1(): + + is_mcode_j1(mcode) -> bool + + +ida_hexrays.is_mcode_jcond(): + + is_mcode_jcond(mcode) -> bool + + +ida_hexrays.is_mcode_propagatable(): + + is_mcode_propagatable(mcode) -> bool + + + May opcode be propagated? Such opcodes can be used in sub-instructions + (nested instructions) There is a handful of non-propagatable opcodes, + like jumps, ret, nop, etc All other regular opcodes are propagatable + and may appear in a nested instruction. + + @param mcode (C++: mcode_t) + + +ida_hexrays.is_mcode_set(): + + is_mcode_set(mcode) -> bool + + +ida_hexrays.is_mcode_set1(): + + is_mcode_set1(mcode) -> bool + + +ida_hexrays.is_mcode_shift(): + + is_mcode_shift(mcode) -> bool + + +ida_hexrays.is_mcode_xdsu(): + + is_mcode_xdsu(mcode) -> bool + + ida_hexrays.is_multiplicative(): is_multiplicative(op) -> bool @@ -19149,9 +20977,26 @@ ida_hexrays.is_relational(): @param op (C++: ctype_t) +ida_hexrays.is_signed_mcode(): + + is_signed_mcode(code) -> bool + + ida_hexrays.is_small_struni(): - is_small_struni(tif) -> bool + is_small_udt(tif) -> bool + + + Is a small structure or union? + + @param tif (C++: const tinfo_t &) + @return: true if the type is a small UDT (user defined type). Small + UDTs fit into a register (or pair or registers) as a rule. + + +ida_hexrays.is_small_udt(): + + is_small_udt(tif) -> bool Is a small structure or union? @@ -19183,6 +21028,233 @@ ida_hexrays.is_unary(): @param op (C++: ctype_t) +ida_hexrays.is_unsigned_mcode(): + + is_unsigned_mcode(code) -> bool + + +class ida_hexrays.ivl_t(): + + Proxy of C++ ivl_t class + + +ida_hexrays.ivl_t.clear(): + + clear(self) + + +ida_hexrays.ivl_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.ivl_t.contains(): + + contains(self, off2) -> bool + + +ida_hexrays.ivl_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.ivl_t.empty(): + + empty(self) -> bool + + +ida_hexrays.ivl_t.end(): + + end(self) -> unsigned-ea-like-numeric-type + + +ida_hexrays.ivl_t.extend_to_cover(): + + extend_to_cover(self, r) -> bool + + +ida_hexrays.ivl_t.includes(): + + includes(self, ivl) -> bool + + +ida_hexrays.ivl_t.intersect(): + + intersect(self, r) + + +ida_hexrays.ivl_t.last(): + + last(self) -> unsigned-ea-like-numeric-type + + +ida_hexrays.ivl_t.off: + uval_ivl_t_off_get(self) -> unsigned-ea-like-numeric-type + +ida_hexrays.ivl_t.overlap(): + + overlap(self, ivl) -> bool + + +ida_hexrays.ivl_t.size: + uval_ivl_t_size_get(self) -> unsigned-ea-like-numeric-type + +ida_hexrays.ivl_t.valid(): + + valid(self) -> bool + + +class ida_hexrays.ivl_with_name_t(): + + Proxy of C++ ivl_with_name_t class + + +ida_hexrays.ivl_with_name_t.ivl: + ivl_with_name_t_ivl_get(self) -> ivl_t + +ida_hexrays.ivl_with_name_t.part: + ivl_with_name_t_part_get(self) -> char const * + +ida_hexrays.ivl_with_name_t.whole: + ivl_with_name_t_whole_get(self) -> char const * + +class ida_hexrays.ivlset_t(): + + Proxy of C++ ivlset_t class + + +ida_hexrays.ivlset_t._print(): + + _print(self) + + +ida_hexrays.ivlset_t.add(): + + add(self, ivl) -> bool + add(self, ea, size) -> bool + add(self, ivs) -> bool + + +ida_hexrays.ivlset_t.addmasked(): + + addmasked(self, ivs, mask) -> bool + + +ida_hexrays.ivlset_t.all_values(): + + all_values(self) -> bool + + +ida_hexrays.ivlset_t.begin(): + + begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator + begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator + + +ida_hexrays.ivlset_t.clear(): + + clear(self) + + +ida_hexrays.ivlset_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.ivlset_t.contains(): + + contains(self, off) -> bool + + +ida_hexrays.ivlset_t.count(): + + count(self) -> asize_t + + +ida_hexrays.ivlset_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.ivlset_t.empty(): + + empty(self) -> bool + + +ida_hexrays.ivlset_t.end(): + + end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator + end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator + + +ida_hexrays.ivlset_t.getivl(): + + getivl(self, idx) -> ivl_t + + +ida_hexrays.ivlset_t.has_common(): + + has_common(self, ivl, strict=False) -> bool + has_common(self, ivs) -> bool + + +ida_hexrays.ivlset_t.includes(): + + includes(self, ivs) -> bool + + +ida_hexrays.ivlset_t.intersect(): + + intersect(self, ivs) -> bool + + +ida_hexrays.ivlset_t.lastivl(): + + lastivl(self) -> ivl_t + + +ida_hexrays.ivlset_t.nivls(): + + nivls(self) -> size_t + + +ida_hexrays.ivlset_t.qclear(): + + qclear(self) + + +ida_hexrays.ivlset_t.set_all_values(): + + set_all_values(self) + + +ida_hexrays.ivlset_t.single_value(): + + single_value(self, v) -> bool + + +ida_hexrays.ivlset_t.sub(): + + sub(self, ivl) -> bool + sub(self, ea, size) -> bool + sub(self, ivs) -> bool + + +ida_hexrays.ivlset_t.swap(): + + swap(self, r) + + +ida_hexrays.jcnd2set(): + + jcnd2set(code) -> mcode_t + + +ida_hexrays.lexcompare(): + + lexcompare(a, b) -> int + + class ida_hexrays.lvar_locator_t(): Proxy of C++ lvar_locator_t class @@ -19413,6 +21485,35 @@ ida_hexrays.lvar_mapping_t.size(): size(self) -> size_t +class ida_hexrays.lvar_ref_t(): + + Proxy of C++ lvar_ref_t class + + +ida_hexrays.lvar_ref_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.lvar_ref_t.idx: + lvar_ref_t_idx_get(self) -> int + +ida_hexrays.lvar_ref_t.mba: + lvar_ref_t_mba_get(self) -> mbl_array_t + +ida_hexrays.lvar_ref_t.off: + lvar_ref_t_off_get(self) -> sval_t + +ida_hexrays.lvar_ref_t.swap(): + + swap(self, r) + + +ida_hexrays.lvar_ref_t.var(): + + var(self) -> lvar_t + + class ida_hexrays.lvar_saved_info_t(): Proxy of C++ lvar_saved_info_t class @@ -19496,6 +21597,12 @@ ida_hexrays.lvar_saved_infos_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.lvar_saved_infos_t.append(): + + push_back(self, x) + push_back(self) -> lvar_saved_info_t + + ida_hexrays.lvar_saved_infos_t.at(): __getitem__(self, i) -> lvar_saved_info_t @@ -19632,6 +21739,11 @@ ida_hexrays.lvar_t.clr_arg_var(): clr_arg_var(self) +ida_hexrays.lvar_t.clr_dummy_arg(): + + clr_dummy_arg(self) + + ida_hexrays.lvar_t.clr_fake_var(): clr_fake_var(self) @@ -19662,6 +21774,11 @@ ida_hexrays.lvar_t.clr_noptr_var(): clr_noptr_var(self) +ida_hexrays.lvar_t.clr_notarg(): + + clr_notarg(self) + + ida_hexrays.lvar_t.clr_overlapped_var(): clr_overlapped_var(self) @@ -19780,6 +21897,11 @@ ida_hexrays.lvar_t.is_arg_var: is_arg_var(self) -> bool +ida_hexrays.lvar_t.is_dummy_arg(): + + is_dummy_arg(self) -> bool + + ida_hexrays.lvar_t.is_fake_var: is_fake_var(self) -> bool @@ -19805,6 +21927,11 @@ ida_hexrays.lvar_t.is_noptr_var(): is_noptr_var(self) -> bool +ida_hexrays.lvar_t.is_notarg(): + + is_notarg(self) -> bool + + ida_hexrays.lvar_t.is_overlapped_var: is_overlapped_var(self) -> bool @@ -19871,6 +21998,11 @@ ida_hexrays.lvar_t.set_arg_var(): set_arg_var(self) +ida_hexrays.lvar_t.set_dummy_arg(): + + set_dummy_arg(self) + + ida_hexrays.lvar_t.set_fake_var(): set_fake_var(self) @@ -19916,6 +22048,11 @@ ida_hexrays.lvar_t.set_noptr_var(): set_noptr_var(self) +ida_hexrays.lvar_t.set_notarg(): + + set_notarg(self) + + ida_hexrays.lvar_t.set_overlapped_var(): set_overlapped_var(self) @@ -19988,6 +22125,11 @@ class ida_hexrays.lvar_uservec_t(): Proxy of C++ lvar_uservec_t class +ida_hexrays.lvar_uservec_t.clear(): + + clear(self) + + ida_hexrays.lvar_uservec_t.find_info(): find_info(self, vloc) -> lvar_saved_info_t @@ -20025,6 +22167,12 @@ ida_hexrays.lvars_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.lvars_t.append(): + + push_back(self, x) + push_back(self) -> lvar_t + + ida_hexrays.lvars_t.at(): __getitem__(self, i) -> lvar_t @@ -20176,6 +22324,1682 @@ ida_hexrays.mark_cfunc_dirty(): @return: if a cache entry existed. +class ida_hexrays.mba_range_iterator_t(): + + Proxy of C++ mba_range_iterator_t class + + +ida_hexrays.mba_range_iterator_t.chunk(): + + chunk(self) -> range_t + + +ida_hexrays.mba_range_iterator_t.fii: + mba_range_iterator_t_fii_get(self) -> func_tail_iterator_t + +ida_hexrays.mba_range_iterator_t.is_snippet(): + + is_snippet(self) -> bool + + +ida_hexrays.mba_range_iterator_t.next(): + + next(self) -> bool + + +ida_hexrays.mba_range_iterator_t.rii: + mba_range_iterator_t_rii_get(self) -> range_chunk_iterator_t * + +ida_hexrays.mba_range_iterator_t.set(): + + set(self, mbr) -> bool + + +class ida_hexrays.mba_ranges_t(): + + Proxy of C++ mba_ranges_t class + + +ida_hexrays.mba_ranges_t.clear(): + + clear(self) + + +ida_hexrays.mba_ranges_t.empty(): + + empty(self) -> bool + + +ida_hexrays.mba_ranges_t.is_fragmented(): + + is_fragmented(self) -> bool + + +ida_hexrays.mba_ranges_t.is_snippet(): + + is_snippet(self) -> bool + + +ida_hexrays.mba_ranges_t.pfn: + mba_ranges_t_pfn_get(self) -> func_t * + +ida_hexrays.mba_ranges_t.ranges: + mba_ranges_t_ranges_get(self) -> rangevec_t + +ida_hexrays.mba_ranges_t.start(): + + start(self) -> ea_t + + +class ida_hexrays.mbl_array_t(): + + Proxy of C++ mbl_array_t class + + +ida_hexrays.mbl_array_t._print(): + + _print(self, vp) + + +ida_hexrays.mbl_array_t.aliased_args: + mbl_array_t_aliased_args_get(self) -> ivl_t + +ida_hexrays.mbl_array_t.aliased_memory: + mbl_array_t_aliased_memory_get(self) -> ivlset_t + +ida_hexrays.mbl_array_t.aliased_vars: + mbl_array_t_aliased_vars_get(self) -> ivl_t + +ida_hexrays.mbl_array_t.alloc_lvars(): + + alloc_lvars(self) + + +ida_hexrays.mbl_array_t.analyze_calls(): + + analyze_calls(self, acflags) -> int + + +ida_hexrays.mbl_array_t.arg(): + + arg(self, n) -> lvar_t + arg(self, n) -> lvar_t + + +ida_hexrays.mbl_array_t.argbase(): + + argbase(self) -> sval_t + + +ida_hexrays.mbl_array_t.argidx: + mbl_array_t_argidx_get(self) -> intvec_t + +ida_hexrays.mbl_array_t.argidx_ok(): + + argidx_ok(self) -> bool + + +ida_hexrays.mbl_array_t.bad_call_sp_detected(): + + bad_call_sp_detected(self) -> bool + + +ida_hexrays.mbl_array_t.blocks: + mbl_array_t_blocks_get(self) -> mblock_t + +ida_hexrays.mbl_array_t.build_graph(): + + build_graph(self) -> merror_t + + +ida_hexrays.mbl_array_t.calc_shins_flags(): + + calc_shins_flags(self) -> int + + +ida_hexrays.mbl_array_t.callinfo_built(): + + callinfo_built(self) -> bool + + +ida_hexrays.mbl_array_t.cc: + mbl_array_t_cc_get(self) -> cm_t + +ida_hexrays.mbl_array_t.chain_varnums_ok(): + + chain_varnums_ok(self) -> bool + + +ida_hexrays.mbl_array_t.clr_cdtr(): + + clr_cdtr(self) + + +ida_hexrays.mbl_array_t.clr_mba_flags(): + + clr_mba_flags(self, f) + + +ida_hexrays.mbl_array_t.clr_mba_flags2(): + + clr_mba_flags2(self, f) + + +ida_hexrays.mbl_array_t.combine_blocks(): + + combine_blocks(self) -> bool + + +ida_hexrays.mbl_array_t.common_stkvars_stkargs(): + + common_stkvars_stkargs(self) -> bool + + +ida_hexrays.mbl_array_t.consumed_argregs: + mbl_array_t_consumed_argregs_get(self) -> rlist_t + +ida_hexrays.mbl_array_t.copy_block(): + + copy_block(self, blk, new_serial, cpblk_flags=3) -> mblock_t + + +ida_hexrays.mbl_array_t.deleted_pairs(): + + deleted_pairs(self) -> bool + + +ida_hexrays.mbl_array_t.deserialize(): + + deserialize(bytes, nbytes) -> mbl_array_t + + +ida_hexrays.mbl_array_t.display_numaddrs(): + + display_numaddrs(self) -> bool + + +ida_hexrays.mbl_array_t.display_valnums(): + + display_valnums(self) -> bool + + +ida_hexrays.mbl_array_t.dump(): + + dump(self) + + +ida_hexrays.mbl_array_t.dump_mba(): + + dump_mba(self, _verify, title) + + +ida_hexrays.mbl_array_t.entry_ea: + mbl_array_t_entry_ea_get(self) -> ea_t + +ida_hexrays.mbl_array_t.error_ea: + mbl_array_t_error_ea_get(self) -> ea_t + +ida_hexrays.mbl_array_t.error_strarg: + mbl_array_t_error_strarg_get(self) -> qstring * + +ida_hexrays.mbl_array_t.final_type: + mbl_array_t_final_type_get(self) -> bool + +ida_hexrays.mbl_array_t.find_mop(): + + find_mop(self, ctx, ea, is_dest, list) -> mop_t + + +ida_hexrays.mbl_array_t.first_epilog_ea: + mbl_array_t_first_epilog_ea_get(self) -> ea_t + +ida_hexrays.mbl_array_t.for_all_insns(): + + for_all_insns(self, mv) -> int + + +ida_hexrays.mbl_array_t.for_all_ops(): + + for_all_ops(self, mv) -> int + + +ida_hexrays.mbl_array_t.for_all_topinsns(): + + for_all_topinsns(self, mv) -> int + + +ida_hexrays.mbl_array_t.fpd: + mbl_array_t_fpd_get(self) -> sval_t + +ida_hexrays.mbl_array_t.frregs: + mbl_array_t_frregs_get(self) -> sval_t + +ida_hexrays.mbl_array_t.frsize: + mbl_array_t_frsize_get(self) -> sval_t + +ida_hexrays.mbl_array_t.fti_flags: + mbl_array_t_fti_flags_get(self) -> int + +ida_hexrays.mbl_array_t.fullsize: + mbl_array_t_fullsize_get(self) -> sval_t + +ida_hexrays.mbl_array_t.generated_asserts(): + + generated_asserts(self) -> bool + + +ida_hexrays.mbl_array_t.get_args_region(): + + get_args_region(self) -> ivl_t + + +ida_hexrays.mbl_array_t.get_curfunc(): + + get_curfunc(self) -> func_t * + + +ida_hexrays.mbl_array_t.get_graph(): + + get_graph(self) -> mbl_graph_t + + +ida_hexrays.mbl_array_t.get_ida_argloc(): + + get_ida_argloc(self, v) -> argloc_t + + +ida_hexrays.mbl_array_t.get_lvars_region(): + + get_lvars_region(self) -> ivl_t + + +ida_hexrays.mbl_array_t.get_mba_flags(): + + get_mba_flags(self) -> int + + +ida_hexrays.mbl_array_t.get_mba_flags2(): + + get_mba_flags2(self) -> int + + +ida_hexrays.mbl_array_t.get_mblock(): + + get_mblock(self, n) -> mblock_t + get_mblock(self, n) -> mblock_t + + +ida_hexrays.mbl_array_t.get_shadow_region(): + + get_shadow_region(self) -> ivl_t + + +ida_hexrays.mbl_array_t.get_stack_region(): + + get_stack_region(self) -> ivl_t + + +ida_hexrays.mbl_array_t.get_std_region(): + + get_std_region(self, idx) -> ivl_t + + +ida_hexrays.mbl_array_t.gotoff_stkvars: + mbl_array_t_gotoff_stkvars_get(self) -> ivlset_t + +ida_hexrays.mbl_array_t.graph_insns(): + + graph_insns(self) -> bool + + +ida_hexrays.mbl_array_t.has_bad_sp(): + + has_bad_sp(self) -> bool + + +ida_hexrays.mbl_array_t.has_over_chains(): + + has_over_chains(self) -> bool + + +ida_hexrays.mbl_array_t.has_overvars(): + + has_overvars(self) -> bool + + +ida_hexrays.mbl_array_t.has_passregs(): + + has_passregs(self) -> bool + + +ida_hexrays.mbl_array_t.idaloc2vd(): + + idaloc2vd(self, loc, width) -> vdloc_t + + +ida_hexrays.mbl_array_t.idb_node: + mbl_array_t_idb_node_get(self) -> netnode + +ida_hexrays.mbl_array_t.idb_spoiled: + mbl_array_t_idb_spoiled_get(self) -> reginfovec_t + +ida_hexrays.mbl_array_t.idb_type: + mbl_array_t_idb_type_get(self) -> tinfo_t + +ida_hexrays.mbl_array_t.inargoff: + mbl_array_t_inargoff_get(self) -> sval_t + +ida_hexrays.mbl_array_t.insert_block(): + + insert_block(self, bblk) -> mblock_t + + +ida_hexrays.mbl_array_t.is_cdtr(): + + is_cdtr(self) -> bool + + +ida_hexrays.mbl_array_t.is_ctr(): + + is_ctr(self) -> bool + + +ida_hexrays.mbl_array_t.is_dtr(): + + is_dtr(self) -> bool + + +ida_hexrays.mbl_array_t.is_pattern(): + + is_pattern(self) -> bool + + +ida_hexrays.mbl_array_t.is_snippet(): + + is_snippet(self) -> bool + + +ida_hexrays.mbl_array_t.is_stkarg(): + + is_stkarg(self, v) -> bool + + +ida_hexrays.mbl_array_t.is_thunk(): + + is_thunk(self) -> bool + + +ida_hexrays.mbl_array_t.label: + mbl_array_t_label_get(self) -> qstring * + +ida_hexrays.mbl_array_t.last_prolog_ea: + mbl_array_t_last_prolog_ea_get(self) -> ea_t + +ida_hexrays.mbl_array_t.loaded_gdl(): + + loaded_gdl(self) -> bool + + +ida_hexrays.mbl_array_t.lvar_names_ok(): + + lvar_names_ok(self) -> bool + + +ida_hexrays.mbl_array_t.lvars_allocated(): + + lvars_allocated(self) -> bool + + +ida_hexrays.mbl_array_t.lvars_renamed(): + + lvars_renamed(self) -> bool + + +ida_hexrays.mbl_array_t.mark_chains_dirty(): + + mark_chains_dirty(self) + + +ida_hexrays.mbl_array_t.maturity: + mbl_array_t_maturity_get(self) -> mba_maturity_t + +ida_hexrays.mbl_array_t.may_refine_rettype(): + + may_refine_rettype(self) -> bool + + +ida_hexrays.mbl_array_t.mbr: + mbl_array_t_mbr_get(self) -> mba_ranges_t + +ida_hexrays.mbl_array_t.minargref: + mbl_array_t_minargref_get(self) -> sval_t + +ida_hexrays.mbl_array_t.minstkref: + mbl_array_t_minstkref_get(self) -> sval_t + +ida_hexrays.mbl_array_t.minstkref_ea: + mbl_array_t_minstkref_ea_get(self) -> ea_t + +ida_hexrays.mbl_array_t.natural: + mbl_array_t_natural_get(self) -> mblock_t ** + +ida_hexrays.mbl_array_t.nodel_memory: + mbl_array_t_nodel_memory_get(self) -> mlist_t + +ida_hexrays.mbl_array_t.notes: + mbl_array_t_notes_get(self) -> hexwarns_t + +ida_hexrays.mbl_array_t.npurged: + mbl_array_t_npurged_get(self) -> int + +ida_hexrays.mbl_array_t.occurred_warns: + mbl_array_t_occurred_warns_get(self) -> uchar [32] + +ida_hexrays.mbl_array_t.optimize_global(): + + optimize_global(self) -> merror_t + + +ida_hexrays.mbl_array_t.optimize_local(): + + optimize_local(self, locopt_bits) -> int + + +ida_hexrays.mbl_array_t.optimized(): + + optimized(self) -> bool + + +ida_hexrays.mbl_array_t.pfn_flags: + mbl_array_t_pfn_flags_get(self) -> int + +ida_hexrays.mbl_array_t.precise_defeas(): + + precise_defeas(self) -> bool + + +ida_hexrays.mbl_array_t.propagated_asserts(): + + propagated_asserts(self) -> bool + + +ida_hexrays.mbl_array_t.qty: + mbl_array_t_qty_get(self) -> int + +ida_hexrays.mbl_array_t.really_alloc(): + + really_alloc(self) -> bool + + +ida_hexrays.mbl_array_t.regargs_is_not_aligned(): + + regargs_is_not_aligned(self) -> bool + + +ida_hexrays.mbl_array_t.remove_block(): + + remove_block(self, blk) -> bool + + +ida_hexrays.mbl_array_t.remove_empty_blocks(): + + remove_empty_blocks(self) -> bool + + +ida_hexrays.mbl_array_t.reqmat: + mbl_array_t_reqmat_get(self) -> mba_maturity_t + +ida_hexrays.mbl_array_t.restricted_memory: + mbl_array_t_restricted_memory_get(self) -> ivlset_t + +ida_hexrays.mbl_array_t.retsize: + mbl_array_t_retsize_get(self) -> int + +ida_hexrays.mbl_array_t.returns_fpval(): + + returns_fpval(self) -> bool + + +ida_hexrays.mbl_array_t.retvaridx: + mbl_array_t_retvaridx_get(self) -> int + +ida_hexrays.mbl_array_t.rtype_refined(): + + rtype_refined(self) -> bool + + +ida_hexrays.mbl_array_t.saverest_done(): + + saverest_done(self) -> bool + + +ida_hexrays.mbl_array_t.serialize(): + + serialize(self) + + +ida_hexrays.mbl_array_t.set_mba_flags(): + + set_mba_flags(self, f) + + +ida_hexrays.mbl_array_t.set_mba_flags2(): + + set_mba_flags2(self, f) + + +ida_hexrays.mbl_array_t.shadow_args: + mbl_array_t_shadow_args_get(self) -> int + +ida_hexrays.mbl_array_t.short_display(): + + short_display(self) -> bool + + +ida_hexrays.mbl_array_t.should_beautify(): + + should_beautify(self) -> bool + + +ida_hexrays.mbl_array_t.show_reduction(): + + show_reduction(self) -> bool + + +ida_hexrays.mbl_array_t.spd_adjust: + mbl_array_t_spd_adjust_get(self) -> sval_t + +ida_hexrays.mbl_array_t.spoiled_list: + mbl_array_t_spoiled_list_get(self) -> mlist_t + +ida_hexrays.mbl_array_t.stacksize: + mbl_array_t_stacksize_get(self) -> sval_t + +ida_hexrays.mbl_array_t.std_ivls: + mbl_array_t_std_ivls_get(self) -> ivl_with_name_t + +ida_hexrays.mbl_array_t.stkoff_ida2vd(): + + stkoff_ida2vd(self, off) -> sval_t + + +ida_hexrays.mbl_array_t.stkoff_vd2ida(): + + stkoff_vd2ida(self, off) -> sval_t + + +ida_hexrays.mbl_array_t.term(): + + term(self) + + +ida_hexrays.mbl_array_t.tmpstk_size: + mbl_array_t_tmpstk_size_get(self) -> sval_t + +ida_hexrays.mbl_array_t.use_frame(): + + use_frame(self) -> bool + + +ida_hexrays.mbl_array_t.use_wingraph32(): + + use_wingraph32(self) -> bool + + +ida_hexrays.mbl_array_t.valranges_done(): + + valranges_done(self) -> bool + + +ida_hexrays.mbl_array_t.vars: + mbl_array_t_vars_get(self) -> lvars_t + +ida_hexrays.mbl_array_t.vd2idaloc(): + + vd2idaloc(self, loc, width, spd) -> argloc_t + vd2idaloc(self, loc, width) -> argloc_t + + +ida_hexrays.mbl_array_t.verify(): + + verify(self, always) + + +ida_hexrays.mbl_array_t.write_to_const_detected(): + + write_to_const_detected(self) -> bool + + +ida_hexrays.mbl_array_t_deserialize(): + + mbl_array_t_deserialize(bytes, nbytes) -> mbl_array_t + + +class ida_hexrays.mbl_graph_t(): + + Proxy of C++ mbl_graph_t class + + +ida_hexrays.mbl_graph_t.colored_gdl_edges: + simple_graph_t_colored_gdl_edges_get(self) -> bool + +ida_hexrays.mbl_graph_t.get_chain_stamp(): + + get_chain_stamp(self) -> int + + +ida_hexrays.mbl_graph_t.get_du(): + + get_du(self, gctype) -> graph_chains_t + + +ida_hexrays.mbl_graph_t.get_mblock(): + + get_mblock(self, n) -> mblock_t + + +ida_hexrays.mbl_graph_t.get_ud(): + + get_ud(self, gctype) -> graph_chains_t + + +ida_hexrays.mbl_graph_t.is_du_chain_dirty(): + + is_du_chain_dirty(self, gctype) -> bool + + +ida_hexrays.mbl_graph_t.is_redefined_globally(): + + is_redefined_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool + + +ida_hexrays.mbl_graph_t.is_ud_chain_dirty(): + + is_ud_chain_dirty(self, gctype) -> bool + + +ida_hexrays.mbl_graph_t.is_used_globally(): + + is_used_globally(self, list, b1, b2, m1, m2, maymust=MAY_ACCESS) -> bool + + +ida_hexrays.mbl_graph_t.title: + simple_graph_t_title_get(self) -> qstring * + +class ida_hexrays.mblock_t(): + + Proxy of C++ mblock_t class + + +ida_hexrays.mblock_t._print(): + + _print(self, vp) + + +ida_hexrays.mblock_t.append_def_list(): + + append_def_list(self, list, op, maymust) + + +ida_hexrays.mblock_t.append_use_list(): + + append_use_list(self, list, op, maymust, mask=bitrange_t(0, USHRT_MAX)) + + +ida_hexrays.mblock_t.build_def_list(): + + build_def_list(self, ins, maymust) -> mlist_t + + +ida_hexrays.mblock_t.build_lists(): + + build_lists(self, kill_deads) -> int + + +ida_hexrays.mblock_t.build_use_list(): + + build_use_list(self, ins, maymust) -> mlist_t + + +ida_hexrays.mblock_t.dead_at_start: + mblock_t_dead_at_start_get(self) -> mlist_t + +ida_hexrays.mblock_t.dnu: + mblock_t_dnu_get(self) -> mlist_t + +ida_hexrays.mblock_t.dump(): + + dump(self) + + +ida_hexrays.mblock_t.dump_block(): + + dump_block(self, title) + + +ida_hexrays.mblock_t.empty(): + + empty(self) -> bool + + +ida_hexrays.mblock_t.end: + mblock_t_end_get(self) -> ea_t + +ida_hexrays.mblock_t.find_access(): + + find_access(self, op, parent, mend, fdflags) -> minsn_t + + +ida_hexrays.mblock_t.find_def(): + + find_def(self, op, p_i1, i2, fdflags) -> minsn_t + + +ida_hexrays.mblock_t.find_first_use(): + + find_first_use(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t + + +ida_hexrays.mblock_t.find_redefinition(): + + find_redefinition(self, list, i1, i2, maymust=MAY_ACCESS) -> minsn_t + + +ida_hexrays.mblock_t.find_use(): + + find_use(self, op, p_i1, i2, fdflags) -> minsn_t + + +ida_hexrays.mblock_t.flags: + mblock_t_flags_get(self) -> uint32 + +ida_hexrays.mblock_t.for_all_insns(): + + for_all_insns(self, mv) -> int + + +ida_hexrays.mblock_t.for_all_ops(): + + for_all_ops(self, mv) -> int + + +ida_hexrays.mblock_t.for_all_uses(): + + for_all_uses(self, list, i1, i2, mmv) -> int + + +ida_hexrays.mblock_t.get_reginsn_qty(): + + get_reginsn_qty(self) -> size_t + + +ida_hexrays.mblock_t.get_valranges(): + + get_valranges(self, res, vivl, vrflags) -> bool + get_valranges(self, res, vivl, m, vrflags) -> bool + + +ida_hexrays.mblock_t.head: + mblock_t_head_get(self) -> minsn_t + +ida_hexrays.mblock_t.insert_into_block(): + + insert_into_block(self, nm, om) -> minsn_t + + +ida_hexrays.mblock_t.is_branch(): + + is_branch(self) -> bool + + +ida_hexrays.mblock_t.is_call_block(): + + is_call_block(self) -> bool + + +ida_hexrays.mblock_t.is_nway(): + + is_nway(self) -> bool + + +ida_hexrays.mblock_t.is_redefined(): + + is_redefined(self, list, i1, i2, maymust=MAY_ACCESS) -> bool + + +ida_hexrays.mblock_t.is_rhs_redefined(): + + is_rhs_redefined(self, ins, i1, i2) -> bool + + +ida_hexrays.mblock_t.is_simple_goto_block(): + + is_simple_goto_block(self) -> bool + + +ida_hexrays.mblock_t.is_simple_jcnd_block(): + + is_simple_jcnd_block(self) -> bool + + +ida_hexrays.mblock_t.is_unknown_call(): + + is_unknown_call(self) -> bool + + +ida_hexrays.mblock_t.is_used(): + + is_used(self, list, i1, i2, maymust=MAY_ACCESS) -> bool + + +ida_hexrays.mblock_t.lists_dirty(): + + lists_dirty(self) -> bool + + +ida_hexrays.mblock_t.lists_ready(): + + lists_ready(self) -> bool + + +ida_hexrays.mblock_t.make_lists_ready(): + + make_lists_ready(self) -> int + + +ida_hexrays.mblock_t.make_nop(): + + make_nop(self, m) + + +ida_hexrays.mblock_t.mark_lists_dirty(): + + mark_lists_dirty(self) + + +ida_hexrays.mblock_t.maxbsp: + mblock_t_maxbsp_get(self) -> sval_t + +ida_hexrays.mblock_t.maybdef: + mblock_t_maybdef_get(self) -> mlist_t + +ida_hexrays.mblock_t.maybuse: + mblock_t_maybuse_get(self) -> mlist_t + +ida_hexrays.mblock_t.mba: + mblock_t_mba_get(self) -> mbl_array_t + +ida_hexrays.mblock_t.minbargref: + mblock_t_minbargref_get(self) -> sval_t + +ida_hexrays.mblock_t.minbstkref: + mblock_t_minbstkref_get(self) -> sval_t + +ida_hexrays.mblock_t.mustbdef: + mblock_t_mustbdef_get(self) -> mlist_t + +ida_hexrays.mblock_t.mustbuse: + mblock_t_mustbuse_get(self) -> mlist_t + +ida_hexrays.mblock_t.needs_propagation(): + + needs_propagation(self) -> bool + + +ida_hexrays.mblock_t.nextb: + mblock_t_nextb_get(self) -> mblock_t + +ida_hexrays.mblock_t.npred(): + + npred(self) -> int + + +ida_hexrays.mblock_t.nsucc(): + + nsucc(self) -> int + + +ida_hexrays.mblock_t.optimize_block(): + + optimize_block(self) -> int + + +ida_hexrays.mblock_t.optimize_insn(): + + optimize_insn(self, m, optflags=0x0002|0x0004) -> int + + +ida_hexrays.mblock_t.optimize_useless_jump(): + + optimize_useless_jump(self) -> int + + +ida_hexrays.mblock_t.pred(): + + pred(self, n) -> int + + +ida_hexrays.mblock_t.preds(): + + Iterates the list of predecessor blocks + + +ida_hexrays.mblock_t.predset: + mblock_t_predset_get(self) -> intvec_t + +ida_hexrays.mblock_t.prevb: + mblock_t_prevb_get(self) -> mblock_t + +ida_hexrays.mblock_t.remove_from_block(): + + remove_from_block(self, m) -> minsn_t + + +ida_hexrays.mblock_t.request_demote64(): + + request_demote64(self) + + +ida_hexrays.mblock_t.request_propagation(): + + request_propagation(self) + + +ida_hexrays.mblock_t.serial: + mblock_t_serial_get(self) -> int + +ida_hexrays.mblock_t.start: + mblock_t_start_get(self) -> ea_t + +ida_hexrays.mblock_t.succ(): + + succ(self, n) -> int + + +ida_hexrays.mblock_t.succs(): + + Iterates the list of successor blocks + + +ida_hexrays.mblock_t.succset: + mblock_t_succset_get(self) -> intvec_t + +ida_hexrays.mblock_t.tail: + mblock_t_tail_get(self) -> minsn_t + +ida_hexrays.mblock_t.type: + mblock_t_type_get(self) -> mblock_type_t + +class ida_hexrays.mcallarg_t(): + + Proxy of C++ mcallarg_t class + + +ida_hexrays.mcallarg_t._print(): + + _print(self, shins_flags=0x04|0x02) + + +ida_hexrays.mcallarg_t.apply_ld_mcode(): + + apply_ld_mcode(self, mcode, ea, newsize) + + +ida_hexrays.mcallarg_t.apply_xds(): + + apply_xds(self, ea, newsize) + + +ida_hexrays.mcallarg_t.apply_xdu(): + + apply_xdu(self, ea, newsize) + + +ida_hexrays.mcallarg_t.argloc: + mcallarg_t_argloc_get(self) -> argloc_t + +ida_hexrays.mcallarg_t.assign(): + + assign(self, rop) -> mop_t + + +ida_hexrays.mcallarg_t.change_size(): + + change_size(self, nsize, sideff=WITH_SIDEFF) -> bool + + +ida_hexrays.mcallarg_t.copy_mop(): + + copy_mop(self, op) + + +ida_hexrays.mcallarg_t.create_from_insn(): + + create_from_insn(self, m) + + +ida_hexrays.mcallarg_t.create_from_ivlset(): + + create_from_ivlset(self, mba, ivs, fullsize) -> bool + + +ida_hexrays.mcallarg_t.create_from_mlist(): + + create_from_mlist(self, mba, lst, fullsize) -> bool + + +ida_hexrays.mcallarg_t.create_from_scattered_vdloc(): + + create_from_scattered_vdloc(self, mba, name, type, loc) + + +ida_hexrays.mcallarg_t.create_from_vdloc(): + + create_from_vdloc(self, mba, loc, _size) + + +ida_hexrays.mcallarg_t.double_size(): + + double_size(self, sideff=WITH_SIDEFF) -> bool + + +ida_hexrays.mcallarg_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.mcallarg_t.ea: + mcallarg_t_ea_get(self) -> ea_t + +ida_hexrays.mcallarg_t.equal_mops(): + + equal_mops(self, rop, eqflags) -> bool + + +ida_hexrays.mcallarg_t.erase(): + + erase(self) + + +ida_hexrays.mcallarg_t.erase_but_keep_size(): + + erase_but_keep_size(self) + + +ida_hexrays.mcallarg_t.for_all_ops(): + + for_all_ops(self, mv, type=None, is_target=False) -> int + + +ida_hexrays.mcallarg_t.for_all_scattered_submops(): + + for_all_scattered_submops(self, sv) -> int + + +ida_hexrays.mcallarg_t.get_insn(): + + get_insn(self, code) -> minsn_t + get_insn(self, code) -> minsn_t + + +ida_hexrays.mcallarg_t.get_stkoff(): + + get_stkoff(self, p_off) -> bool + + +ida_hexrays.mcallarg_t.get_stkvar(): + + get_stkvar(self, p_off) -> member_t * + + +ida_hexrays.mcallarg_t.has_side_effects(): + + has_side_effects(self, include_ldx_and_divs=False) -> bool + + +ida_hexrays.mcallarg_t.is01(): + + is01(self) -> bool + + +ida_hexrays.mcallarg_t.is_bit_reg(): + + is_bit_reg(self, reg) -> bool + is_bit_reg(self) -> bool + + +ida_hexrays.mcallarg_t.is_cc(): + + is_cc(self) -> bool + + +ida_hexrays.mcallarg_t.is_ccflags(): + + is_ccflags(self) -> bool + + +ida_hexrays.mcallarg_t.is_constant(): + + is_constant(self, is_signed=True) -> bool + + +ida_hexrays.mcallarg_t.is_equal_to(): + + is_equal_to(self, n, is_signed=True) -> bool + + +ida_hexrays.mcallarg_t.is_extended_from(): + + is_extended_from(self, nbytes, is_signed) -> bool + + +ida_hexrays.mcallarg_t.is_glbaddr(): + + is_glbaddr(self) -> bool + is_glbaddr(self, ea) -> bool + + +ida_hexrays.mcallarg_t.is_impptr_done(): + + is_impptr_done(self) -> bool + + +ida_hexrays.mcallarg_t.is_insn(): + + is_insn(self) -> bool + is_insn(self, code) -> bool + + +ida_hexrays.mcallarg_t.is_kreg(): + + is_kreg(self) -> bool + + +ida_hexrays.mcallarg_t.is_mob(): + + is_mob(self, serial) -> bool + + +ida_hexrays.mcallarg_t.is_negative_constant(): + + is_negative_constant(self) -> bool + + +ida_hexrays.mcallarg_t.is_one(): + + is_one(self) -> bool + + +ida_hexrays.mcallarg_t.is_positive_constant(): + + is_positive_constant(self) -> bool + + +ida_hexrays.mcallarg_t.is_reg(): + + is_reg(self) -> bool + is_reg(self, _r) -> bool + is_reg(self, _r, _size) -> bool + + +ida_hexrays.mcallarg_t.is_scattered(): + + is_scattered(self) -> bool + + +ida_hexrays.mcallarg_t.is_sign_extended_from(): + + is_sign_extended_from(self, nbytes) -> bool + + +ida_hexrays.mcallarg_t.is_stkaddr(): + + is_stkaddr(self) -> bool + + +ida_hexrays.mcallarg_t.is_udt(): + + is_udt(self) -> bool + + +ida_hexrays.mcallarg_t.is_undef_val(): + + is_undef_val(self) -> bool + + +ida_hexrays.mcallarg_t.is_zero(): + + is_zero(self) -> bool + + +ida_hexrays.mcallarg_t.is_zero_extended_from(): + + is_zero_extended_from(self, nbytes) -> bool + + +ida_hexrays.mcallarg_t.lexcompare(): + + lexcompare(self, rop) -> int + + +ida_hexrays.mcallarg_t.make_blkref(): + + make_blkref(self, blknum) + + +ida_hexrays.mcallarg_t.make_first_half(): + + make_first_half(self, width) -> bool + + +ida_hexrays.mcallarg_t.make_fpnum(): + + make_fpnum(self, bytes, _size) -> bool + + +ida_hexrays.mcallarg_t.make_gvar(): + + make_gvar(self, ea) + + +ida_hexrays.mcallarg_t.make_helper(): + + make_helper(self, name) + + +ida_hexrays.mcallarg_t.make_high_half(): + + make_high_half(self, width) -> bool + + +ida_hexrays.mcallarg_t.make_insn(): + + make_insn(self, ins) + + +ida_hexrays.mcallarg_t.make_int(): + + make_int(self, val, val_ea, opno=0) + + +ida_hexrays.mcallarg_t.make_low_half(): + + make_low_half(self, width) -> bool + + +ida_hexrays.mcallarg_t.make_number(): + + make_number(self, _value, _size, _ea=BADADDR, opnum=0) + + +ida_hexrays.mcallarg_t.make_reg(): + + make_reg(self, reg) + make_reg(self, reg, _size) + + +ida_hexrays.mcallarg_t.make_reg_pair(): + + make_reg_pair(self, loreg, hireg, halfsize) + + +ida_hexrays.mcallarg_t.make_second_half(): + + make_second_half(self, width) -> bool + + +ida_hexrays.mcallarg_t.make_uint(): + + make_uint(self, val, val_ea, opno=0) + + +ida_hexrays.mcallarg_t.may_use_aliased_memory(): + + may_use_aliased_memory(self) -> bool + + +ida_hexrays.mcallarg_t.name: + mcallarg_t_name_get(self) -> qstring * + +ida_hexrays.mcallarg_t.obj_id: + + _obj_id(self) -> PyObject * + + +ida_hexrays.mcallarg_t.oprops: + mop_t_oprops_get(self) -> uint8 + +ida_hexrays.mcallarg_t.preserve_side_effects(): + + preserve_side_effects(self, blk, top, moved_calls=None) -> bool + + +ida_hexrays.mcallarg_t.probably_floating(): + + probably_floating(self) -> bool + + +ida_hexrays.mcallarg_t.set_impptr_done(): + + set_impptr_done(self) + + +ida_hexrays.mcallarg_t.set_regarg(): + + set_regarg(self, mr, sz, tif) + set_regarg(self, mr, tif) + set_regarg(self, mr, dt, sign=type_unsigned) + + +ida_hexrays.mcallarg_t.set_udt(): + + set_udt(self) + + +ida_hexrays.mcallarg_t.set_undef_val(): + + set_undef_val(self) + + +ida_hexrays.mcallarg_t.shift_mop(): + + shift_mop(self, offset) -> bool + + +ida_hexrays.mcallarg_t.signed_value(): + + signed_value(self) -> int64 + + +ida_hexrays.mcallarg_t.size: + mop_t_size_get(self) -> int + +ida_hexrays.mcallarg_t.swap(): + + swap(self, rop) + + +ida_hexrays.mcallarg_t.t: + + _get_t(self) -> mopt_t + + +ida_hexrays.mcallarg_t.type: + mcallarg_t_type_get(self) -> tinfo_t + +ida_hexrays.mcallarg_t.unsigned_value(): + + unsigned_value(self) -> uint64 + + +ida_hexrays.mcallarg_t.valnum: + mop_t_valnum_get(self) -> uint16 + +ida_hexrays.mcallarg_t.value(): + + value(self, is_signed) -> uint64 + + +ida_hexrays.mcallarg_t.zero(): + + zero(self) + + +class ida_hexrays.mcallargs_t(): + + Proxy of C++ qvector<(mcallarg_t)> class + + +ida_hexrays.mcallargs_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_hexrays.mcallargs_t.at(): + + at(self, _idx) -> mcallarg_t + + +ida_hexrays.mcallargs_t.begin(): + + begin(self) -> mcallarg_t + begin(self) -> mcallarg_t + + +ida_hexrays.mcallargs_t.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.mcallargs_t.clear(): + + clear(self) + + +ida_hexrays.mcallargs_t.empty(): + + empty(self) -> bool + + +ida_hexrays.mcallargs_t.end(): + + end(self) -> mcallarg_t + end(self) -> mcallarg_t + + +ida_hexrays.mcallargs_t.erase(): + + erase(self, it) -> mcallarg_t + erase(self, first, last) -> mcallarg_t + + +ida_hexrays.mcallargs_t.extract(): + + extract(self) -> mcallarg_t + + +ida_hexrays.mcallargs_t.find(): + + find(self, x) -> mcallarg_t + find(self, x) -> mcallarg_t + + +ida_hexrays.mcallargs_t.grow(): + + grow(self, x=mcallarg_t()) + + +ida_hexrays.mcallargs_t.has(): + + has(self, x) -> bool + + +ida_hexrays.mcallargs_t.inject(): + + inject(self, s, len) + + +ida_hexrays.mcallargs_t.insert(): + + insert(self, it, x) -> mcallarg_t + + +ida_hexrays.mcallargs_t.pop_back(): + + pop_back(self) + + +ida_hexrays.mcallargs_t.push_back(): + + push_back(self, x) + push_back(self) -> mcallarg_t + + +ida_hexrays.mcallargs_t.qclear(): + + qclear(self) + + +ida_hexrays.mcallargs_t.reserve(): + + reserve(self, cnt) + + +ida_hexrays.mcallargs_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.mcallargs_t.size(): + + size(self) -> size_t + + +ida_hexrays.mcallargs_t.swap(): + + swap(self, r) + + +ida_hexrays.mcallargs_t.truncate(): + + truncate(self) + + +class ida_hexrays.mcallinfo_t(): + + Proxy of C++ mcallinfo_t class + + +ida_hexrays.mcallinfo_t._print(): + + _print(self, size=-1, shins_flags=0x04|0x02) + + +ida_hexrays.mcallinfo_t.args: + mcallinfo_t_args_get(self) -> mcallargs_t + +ida_hexrays.mcallinfo_t.call_spd: + mcallinfo_t_call_spd_get(self) -> int + +ida_hexrays.mcallinfo_t.callee: + mcallinfo_t_callee_get(self) -> ea_t + +ida_hexrays.mcallinfo_t.cc: + mcallinfo_t_cc_get(self) -> cm_t + +ida_hexrays.mcallinfo_t.dead_regs: + mcallinfo_t_dead_regs_get(self) -> mlist_t + +ida_hexrays.mcallinfo_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.mcallinfo_t.flags: + mcallinfo_t_flags_get(self) -> int + +ida_hexrays.mcallinfo_t.get_type(): + + get_type(self) -> tinfo_t + + +ida_hexrays.mcallinfo_t.is_vararg(): + + is_vararg(self) -> bool + + +ida_hexrays.mcallinfo_t.lexcompare(): + + lexcompare(self, f) -> int + + +ida_hexrays.mcallinfo_t.pass_regs: + mcallinfo_t_pass_regs_get(self) -> mlist_t + +ida_hexrays.mcallinfo_t.retregs: + mcallinfo_t_retregs_get(self) -> mopvec_t + +ida_hexrays.mcallinfo_t.return_argloc: + mcallinfo_t_return_argloc_get(self) -> argloc_t + +ida_hexrays.mcallinfo_t.return_regs: + mcallinfo_t_return_regs_get(self) -> mlist_t + +ida_hexrays.mcallinfo_t.return_type: + mcallinfo_t_return_type_get(self) -> tinfo_t + +ida_hexrays.mcallinfo_t.role: + mcallinfo_t_role_get(self) -> funcrole_t + +ida_hexrays.mcallinfo_t.set_type(): + + set_type(self, type) -> bool + + +ida_hexrays.mcallinfo_t.solid_args: + mcallinfo_t_solid_args_get(self) -> int + +ida_hexrays.mcallinfo_t.spoiled: + mcallinfo_t_spoiled_get(self) -> mlist_t + +ida_hexrays.mcallinfo_t.stkargs_top: + mcallinfo_t_stkargs_top_get(self) -> int + +ida_hexrays.mcallinfo_t.visible_memory: + mcallinfo_t_visible_memory_get(self) -> ivlset_t + +class ida_hexrays.mcases_t(): + + Proxy of C++ mcases_t class + + +ida_hexrays.mcases_t._print(): + + _print(self) + + +ida_hexrays.mcases_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.mcases_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.mcases_t.empty(): + + empty(self) -> bool + + +ida_hexrays.mcases_t.resize(): + + resize(self, s) + + +ida_hexrays.mcases_t.size(): + + size(self) -> size_t + + +ida_hexrays.mcases_t.swap(): + + swap(self, r) + + +ida_hexrays.mcases_t.targets: + mcases_t_targets_get(self) -> intvec_t + +ida_hexrays.mcases_t.values: + mcases_t_values_get(self) -> casevec_t + +ida_hexrays.mcode_modifies_d(): + + mcode_modifies_d(mcode) -> bool + + class ida_hexrays.microcode_filter_t(): Proxy of C++ microcode_filter_t class @@ -20191,6 +24015,593 @@ ida_hexrays.microcode_filter_t.match(): match(self, cdg) -> bool +class ida_hexrays.minsn_t(): + + Proxy of C++ minsn_t class + + +ida_hexrays.minsn_t._print(): + + _print(self, shins_flags=0x04|0x02) + + +ida_hexrays.minsn_t.clr_assert(): + + clr_assert(self) + + +ida_hexrays.minsn_t.clr_combinable(): + + clr_combinable(self) + + +ida_hexrays.minsn_t.clr_combined(): + + clr_combined(self) + + +ida_hexrays.minsn_t.clr_fpinsn(): + + clr_fpinsn(self) + + +ida_hexrays.minsn_t.clr_ignlowsrc(): + + clr_ignlowsrc(self) + + +ida_hexrays.minsn_t.clr_multimov(): + + clr_multimov(self) + + +ida_hexrays.minsn_t.clr_noret_icall(): + + clr_noret_icall(self) + + +ida_hexrays.minsn_t.clr_propagatable(): + + clr_propagatable(self) + + +ida_hexrays.minsn_t.clr_tailcall(): + + clr_tailcall(self) + + +ida_hexrays.minsn_t.contains_call(): + + contains_call(self, with_helpers=False) -> bool + + +ida_hexrays.minsn_t.contains_opcode(): + + contains_opcode(self, mcode) -> bool + + +ida_hexrays.minsn_t.d: + minsn_t_d_get(self) -> mop_t + +ida_hexrays.minsn_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.minsn_t.ea: + minsn_t_ea_get(self) -> ea_t + +ida_hexrays.minsn_t.equal_insns(): + + equal_insns(self, m, eqflags) -> bool + + +ida_hexrays.minsn_t.find_call(): + + find_call(self, with_helpers=False) -> minsn_t + + +ida_hexrays.minsn_t.find_ins_op(): + + find_ins_op(self, other, op=m_nop) -> minsn_t + + +ida_hexrays.minsn_t.find_num_op(): + + find_num_op(self, other) -> mop_t + + +ida_hexrays.minsn_t.find_opcode(): + + find_opcode(self, mcode) -> minsn_t + find_opcode(self, mcode) -> minsn_t + + +ida_hexrays.minsn_t.for_all_insns(): + + for_all_insns(self, mv) -> int + + +ida_hexrays.minsn_t.for_all_ops(): + + for_all_ops(self, mv) -> int + + +ida_hexrays.minsn_t.get_role(): + + get_role(self) -> funcrole_t + + +ida_hexrays.minsn_t.get_split_size(): + + get_split_size(self) -> int + + +ida_hexrays.minsn_t.has_side_effects(): + + has_side_effects(self, include_ldx_and_divs=False) -> bool + + +ida_hexrays.minsn_t.iprops: + minsn_t_iprops_get(self) -> int + +ida_hexrays.minsn_t.is_after(): + + is_after(self, m) -> bool + + +ida_hexrays.minsn_t.is_alloca(): + + is_alloca(self) -> bool + + +ida_hexrays.minsn_t.is_assert(): + + is_assert(self) -> bool + + +ida_hexrays.minsn_t.is_between(): + + is_between(self, m1, m2) -> bool + + +ida_hexrays.minsn_t.is_bswap(): + + is_bswap(self) -> bool + + +ida_hexrays.minsn_t.is_cleaning_pop(): + + is_cleaning_pop(self) -> bool + + +ida_hexrays.minsn_t.is_combinable(): + + is_combinable(self) -> bool + + +ida_hexrays.minsn_t.is_combined(): + + is_combined(self) -> bool + + +ida_hexrays.minsn_t.is_extstx(): + + is_extstx(self) -> bool + + +ida_hexrays.minsn_t.is_farcall(): + + is_farcall(self) -> bool + + +ida_hexrays.minsn_t.is_fpinsn(): + + is_fpinsn(self) -> bool + + +ida_hexrays.minsn_t.is_helper(): + + is_helper(self, name) -> bool + + +ida_hexrays.minsn_t.is_ignlowsrc(): + + is_ignlowsrc(self) -> bool + + +ida_hexrays.minsn_t.is_inverted_jx(): + + is_inverted_jx(self) -> bool + + +ida_hexrays.minsn_t.is_like_move(): + + is_like_move(self) -> bool + + +ida_hexrays.minsn_t.is_memcpy(): + + is_memcpy(self) -> bool + + +ida_hexrays.minsn_t.is_memset(): + + is_memset(self) -> bool + + +ida_hexrays.minsn_t.is_mov(): + + is_mov(self) -> bool + + +ida_hexrays.minsn_t.is_multimov(): + + is_multimov(self) -> bool + + +ida_hexrays.minsn_t.is_noret_call(): + + is_noret_call(self, ignore_noret_icall=False) -> bool + + +ida_hexrays.minsn_t.is_optional(): + + is_optional(self) -> bool + + +ida_hexrays.minsn_t.is_persistent(): + + is_persistent(self) -> bool + + +ida_hexrays.minsn_t.is_propagatable(): + + is_propagatable(self) -> bool + + +ida_hexrays.minsn_t.is_readflags(): + + is_readflags(self) -> bool + + +ida_hexrays.minsn_t.is_tailcall(): + + is_tailcall(self) -> bool + + +ida_hexrays.minsn_t.is_unknown_call(): + + is_unknown_call(self) -> bool + + +ida_hexrays.minsn_t.is_wild_match(): + + is_wild_match(self) -> bool + + +ida_hexrays.minsn_t.l: + minsn_t_l_get(self) -> mop_t + +ida_hexrays.minsn_t.lexcompare(): + + lexcompare(self, ri) -> int + + +ida_hexrays.minsn_t.may_use_aliased_memory(): + + may_use_aliased_memory(self) -> bool + + +ida_hexrays.minsn_t.modifes_d(): + + modifes_d(self) -> bool + + +ida_hexrays.minsn_t.modifies_pair_mop(): + + modifies_pair_mop(self) -> bool + + +ida_hexrays.minsn_t.next: + minsn_t_next_get(self) -> minsn_t + +ida_hexrays.minsn_t.obj_id: + + _obj_id(self) -> PyObject * + + +ida_hexrays.minsn_t.opcode: + minsn_t_opcode_get(self) -> mcode_t + +ida_hexrays.minsn_t.optimize_solo(): + + optimize_solo(self, optflags=0) -> int + + +ida_hexrays.minsn_t.optimize_subtree(): + + optimize_subtree(self, blk, top, parent, converted_call, optflags=0x0002) -> int + + +ida_hexrays.minsn_t.prev: + minsn_t_prev_get(self) -> minsn_t + +ida_hexrays.minsn_t.r: + minsn_t_r_get(self) -> mop_t + +ida_hexrays.minsn_t.set_assert(): + + set_assert(self) + + +ida_hexrays.minsn_t.set_cleaning_pop(): + + set_cleaning_pop(self) + + +ida_hexrays.minsn_t.set_combinable(): + + set_combinable(self) + + +ida_hexrays.minsn_t.set_extstx(): + + set_extstx(self) + + +ida_hexrays.minsn_t.set_farcall(): + + set_farcall(self) + + +ida_hexrays.minsn_t.set_fpinsn(): + + set_fpinsn(self) + + +ida_hexrays.minsn_t.set_ignlowsrc(): + + set_ignlowsrc(self) + + +ida_hexrays.minsn_t.set_inverted_jx(): + + set_inverted_jx(self) + + +ida_hexrays.minsn_t.set_multimov(): + + set_multimov(self) + + +ida_hexrays.minsn_t.set_noret_icall(): + + set_noret_icall(self) + + +ida_hexrays.minsn_t.set_optional(): + + set_optional(self) + + +ida_hexrays.minsn_t.set_persistent(): + + set_persistent(self) + + +ida_hexrays.minsn_t.set_split_size(): + + set_split_size(self, s) + + +ida_hexrays.minsn_t.set_tailcall(): + + set_tailcall(self) + + +ida_hexrays.minsn_t.set_wild_match(): + + set_wild_match(self) + + +ida_hexrays.minsn_t.setaddr(): + + setaddr(self, new_ea) + + +ida_hexrays.minsn_t.swap(): + + swap(self, m) + + +ida_hexrays.minsn_t.was_noret_icall(): + + was_noret_icall(self) -> bool + + +ida_hexrays.minsn_t.was_split(): + + was_split(self) -> bool + + +class ida_hexrays.minsn_visitor_t(): + + Proxy of C++ minsn_visitor_t class + + +ida_hexrays.minsn_visitor_t.blk: + op_parent_info_t_blk_get(self) -> mblock_t + +ida_hexrays.minsn_visitor_t.curins: + op_parent_info_t_curins_get(self) -> minsn_t + +ida_hexrays.minsn_visitor_t.mba: + op_parent_info_t_mba_get(self) -> mbl_array_t + +ida_hexrays.minsn_visitor_t.topins: + op_parent_info_t_topins_get(self) -> minsn_t + +ida_hexrays.minsn_visitor_t.visit_minsn(): + + visit_minsn(self) -> int + + +class ida_hexrays.mlist_mop_visitor_t(): + + Proxy of C++ mlist_mop_visitor_t class + + +ida_hexrays.mlist_mop_visitor_t.changed: + mlist_mop_visitor_t_changed_get(self) -> bool + +ida_hexrays.mlist_mop_visitor_t.curins: + mlist_mop_visitor_t_curins_get(self) -> minsn_t + +ida_hexrays.mlist_mop_visitor_t.list: + mlist_mop_visitor_t_list_get(self) -> mlist_t + +ida_hexrays.mlist_mop_visitor_t.topins: + mlist_mop_visitor_t_topins_get(self) -> minsn_t + +ida_hexrays.mlist_mop_visitor_t.visit_mop(): + + visit_mop(self, op) -> int + + +class ida_hexrays.mlist_t(): + + Proxy of C++ mlist_t class + + +ida_hexrays.mlist_t._print(): + + _print(self) + + +ida_hexrays.mlist_t.add(): + + add(self, r, size) -> bool + add(self, r) -> bool + add(self, ivl) -> bool + add(self, lst) -> bool + + +ida_hexrays.mlist_t.addmem(): + + addmem(self, ea, size) -> bool + + +ida_hexrays.mlist_t.clear(): + + clear(self) + + +ida_hexrays.mlist_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.mlist_t.count(): + + count(self) -> asize_t + + +ida_hexrays.mlist_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.mlist_t.empty(): + + empty(self) -> bool + + +ida_hexrays.mlist_t.has(): + + has(self, r) -> bool + + +ida_hexrays.mlist_t.has_all(): + + has_all(self, r, size) -> bool + + +ida_hexrays.mlist_t.has_any(): + + has_any(self, r, size) -> bool + + +ida_hexrays.mlist_t.has_common(): + + has_common(self, lst) -> bool + + +ida_hexrays.mlist_t.has_memory(): + + has_memory(self) -> bool + + +ida_hexrays.mlist_t.includes(): + + includes(self, lst) -> bool + + +ida_hexrays.mlist_t.intersect(): + + intersect(self, lst) -> bool + + +ida_hexrays.mlist_t.is_subset_of(): + + is_subset_of(self, lst) -> bool + + +ida_hexrays.mlist_t.mem: + mlist_t_mem_get(self) -> ivlset_t + +ida_hexrays.mlist_t.reg: + mlist_t_reg_get(self) -> rlist_t + +ida_hexrays.mlist_t.sub(): + + sub(self, r, size) -> bool + sub(self, ivl) -> bool + sub(self, lst) -> bool + + +ida_hexrays.mlist_t.swap(): + + swap(self, r) + + +class ida_hexrays.mnumber_t(): + + Proxy of C++ mnumber_t class + + +ida_hexrays.mnumber_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.mnumber_t.ea: + operand_locator_t_ea_get(self) -> ea_t + +ida_hexrays.mnumber_t.opnum: + operand_locator_t_opnum_get(self) -> int + +ida_hexrays.mnumber_t.org_value: + mnumber_t_org_value_get(self) -> uint64 + +ida_hexrays.mnumber_t.update_value(): + + update_value(self, val64) + + +ida_hexrays.mnumber_t.value: + mnumber_t_value_get(self) -> uint64 + ida_hexrays.modify_user_lvars(): modify_user_lvars(entry_ea, mlv) -> bool @@ -20203,6 +24614,966 @@ ida_hexrays.modify_user_lvars(): @return: true if modified variables +class ida_hexrays.mop_addr_t(): + + Proxy of C++ mop_addr_t class + + +ida_hexrays.mop_addr_t._print(): + + _print(self, shins_flags=0x04|0x02) + + +ida_hexrays.mop_addr_t.apply_ld_mcode(): + + apply_ld_mcode(self, mcode, ea, newsize) + + +ida_hexrays.mop_addr_t.apply_xds(): + + apply_xds(self, ea, newsize) + + +ida_hexrays.mop_addr_t.apply_xdu(): + + apply_xdu(self, ea, newsize) + + +ida_hexrays.mop_addr_t.assign(): + + assign(self, rop) -> mop_t + + +ida_hexrays.mop_addr_t.change_size(): + + change_size(self, nsize, sideff=WITH_SIDEFF) -> bool + + +ida_hexrays.mop_addr_t.create_from_insn(): + + create_from_insn(self, m) + + +ida_hexrays.mop_addr_t.create_from_ivlset(): + + create_from_ivlset(self, mba, ivs, fullsize) -> bool + + +ida_hexrays.mop_addr_t.create_from_mlist(): + + create_from_mlist(self, mba, lst, fullsize) -> bool + + +ida_hexrays.mop_addr_t.create_from_scattered_vdloc(): + + create_from_scattered_vdloc(self, mba, name, type, loc) + + +ida_hexrays.mop_addr_t.create_from_vdloc(): + + create_from_vdloc(self, mba, loc, _size) + + +ida_hexrays.mop_addr_t.double_size(): + + double_size(self, sideff=WITH_SIDEFF) -> bool + + +ida_hexrays.mop_addr_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.mop_addr_t.equal_mops(): + + equal_mops(self, rop, eqflags) -> bool + + +ida_hexrays.mop_addr_t.erase(): + + erase(self) + + +ida_hexrays.mop_addr_t.erase_but_keep_size(): + + erase_but_keep_size(self) + + +ida_hexrays.mop_addr_t.for_all_ops(): + + for_all_ops(self, mv, type=None, is_target=False) -> int + + +ida_hexrays.mop_addr_t.for_all_scattered_submops(): + + for_all_scattered_submops(self, sv) -> int + + +ida_hexrays.mop_addr_t.get_insn(): + + get_insn(self, code) -> minsn_t + get_insn(self, code) -> minsn_t + + +ida_hexrays.mop_addr_t.get_stkoff(): + + get_stkoff(self, p_off) -> bool + + +ida_hexrays.mop_addr_t.get_stkvar(): + + get_stkvar(self, p_off) -> member_t * + + +ida_hexrays.mop_addr_t.has_side_effects(): + + has_side_effects(self, include_ldx_and_divs=False) -> bool + + +ida_hexrays.mop_addr_t.insize: + mop_addr_t_insize_get(self) -> int + +ida_hexrays.mop_addr_t.is01(): + + is01(self) -> bool + + +ida_hexrays.mop_addr_t.is_bit_reg(): + + is_bit_reg(self, reg) -> bool + is_bit_reg(self) -> bool + + +ida_hexrays.mop_addr_t.is_cc(): + + is_cc(self) -> bool + + +ida_hexrays.mop_addr_t.is_ccflags(): + + is_ccflags(self) -> bool + + +ida_hexrays.mop_addr_t.is_constant(): + + is_constant(self, is_signed=True) -> bool + + +ida_hexrays.mop_addr_t.is_equal_to(): + + is_equal_to(self, n, is_signed=True) -> bool + + +ida_hexrays.mop_addr_t.is_extended_from(): + + is_extended_from(self, nbytes, is_signed) -> bool + + +ida_hexrays.mop_addr_t.is_glbaddr(): + + is_glbaddr(self) -> bool + is_glbaddr(self, ea) -> bool + + +ida_hexrays.mop_addr_t.is_impptr_done(): + + is_impptr_done(self) -> bool + + +ida_hexrays.mop_addr_t.is_insn(): + + is_insn(self) -> bool + is_insn(self, code) -> bool + + +ida_hexrays.mop_addr_t.is_kreg(): + + is_kreg(self) -> bool + + +ida_hexrays.mop_addr_t.is_mob(): + + is_mob(self, serial) -> bool + + +ida_hexrays.mop_addr_t.is_negative_constant(): + + is_negative_constant(self) -> bool + + +ida_hexrays.mop_addr_t.is_one(): + + is_one(self) -> bool + + +ida_hexrays.mop_addr_t.is_positive_constant(): + + is_positive_constant(self) -> bool + + +ida_hexrays.mop_addr_t.is_reg(): + + is_reg(self) -> bool + is_reg(self, _r) -> bool + is_reg(self, _r, _size) -> bool + + +ida_hexrays.mop_addr_t.is_scattered(): + + is_scattered(self) -> bool + + +ida_hexrays.mop_addr_t.is_sign_extended_from(): + + is_sign_extended_from(self, nbytes) -> bool + + +ida_hexrays.mop_addr_t.is_stkaddr(): + + is_stkaddr(self) -> bool + + +ida_hexrays.mop_addr_t.is_udt(): + + is_udt(self) -> bool + + +ida_hexrays.mop_addr_t.is_undef_val(): + + is_undef_val(self) -> bool + + +ida_hexrays.mop_addr_t.is_zero(): + + is_zero(self) -> bool + + +ida_hexrays.mop_addr_t.is_zero_extended_from(): + + is_zero_extended_from(self, nbytes) -> bool + + +ida_hexrays.mop_addr_t.lexcompare(): + + lexcompare(self, ra) -> int + + +ida_hexrays.mop_addr_t.make_blkref(): + + make_blkref(self, blknum) + + +ida_hexrays.mop_addr_t.make_first_half(): + + make_first_half(self, width) -> bool + + +ida_hexrays.mop_addr_t.make_fpnum(): + + make_fpnum(self, bytes, _size) -> bool + + +ida_hexrays.mop_addr_t.make_gvar(): + + make_gvar(self, ea) + + +ida_hexrays.mop_addr_t.make_helper(): + + make_helper(self, name) + + +ida_hexrays.mop_addr_t.make_high_half(): + + make_high_half(self, width) -> bool + + +ida_hexrays.mop_addr_t.make_insn(): + + make_insn(self, ins) + + +ida_hexrays.mop_addr_t.make_low_half(): + + make_low_half(self, width) -> bool + + +ida_hexrays.mop_addr_t.make_number(): + + make_number(self, _value, _size, _ea=BADADDR, opnum=0) + + +ida_hexrays.mop_addr_t.make_reg(): + + make_reg(self, reg) + make_reg(self, reg, _size) + + +ida_hexrays.mop_addr_t.make_reg_pair(): + + make_reg_pair(self, loreg, hireg, halfsize) + + +ida_hexrays.mop_addr_t.make_second_half(): + + make_second_half(self, width) -> bool + + +ida_hexrays.mop_addr_t.may_use_aliased_memory(): + + may_use_aliased_memory(self) -> bool + + +ida_hexrays.mop_addr_t.obj_id: + + _obj_id(self) -> PyObject * + + +ida_hexrays.mop_addr_t.oprops: + mop_t_oprops_get(self) -> uint8 + +ida_hexrays.mop_addr_t.outsize: + mop_addr_t_outsize_get(self) -> int + +ida_hexrays.mop_addr_t.preserve_side_effects(): + + preserve_side_effects(self, blk, top, moved_calls=None) -> bool + + +ida_hexrays.mop_addr_t.probably_floating(): + + probably_floating(self) -> bool + + +ida_hexrays.mop_addr_t.set_impptr_done(): + + set_impptr_done(self) + + +ida_hexrays.mop_addr_t.set_udt(): + + set_udt(self) + + +ida_hexrays.mop_addr_t.set_undef_val(): + + set_undef_val(self) + + +ida_hexrays.mop_addr_t.shift_mop(): + + shift_mop(self, offset) -> bool + + +ida_hexrays.mop_addr_t.signed_value(): + + signed_value(self) -> int64 + + +ida_hexrays.mop_addr_t.size: + mop_t_size_get(self) -> int + +ida_hexrays.mop_addr_t.swap(): + + swap(self, rop) + + +ida_hexrays.mop_addr_t.t: + + _get_t(self) -> mopt_t + + +ida_hexrays.mop_addr_t.unsigned_value(): + + unsigned_value(self) -> uint64 + + +ida_hexrays.mop_addr_t.valnum: + mop_t_valnum_get(self) -> uint16 + +ida_hexrays.mop_addr_t.value(): + + value(self, is_signed) -> uint64 + + +ida_hexrays.mop_addr_t.zero(): + + zero(self) + + +class ida_hexrays.mop_pair_t(): + + Proxy of C++ mop_pair_t class + + +ida_hexrays.mop_pair_t.hop: + mop_pair_t_hop_get(self) -> mop_t + +ida_hexrays.mop_pair_t.lop: + mop_pair_t_lop_get(self) -> mop_t + +class ida_hexrays.mop_t(): + + Proxy of C++ mop_t class + + +ida_hexrays.mop_t._print(): + + _print(self, shins_flags=0x04|0x02) + + +ida_hexrays.mop_t.apply_ld_mcode(): + + apply_ld_mcode(self, mcode, ea, newsize) + + +ida_hexrays.mop_t.apply_xds(): + + apply_xds(self, ea, newsize) + + +ida_hexrays.mop_t.apply_xdu(): + + apply_xdu(self, ea, newsize) + + +ida_hexrays.mop_t.assign(): + + assign(self, rop) -> mop_t + + +ida_hexrays.mop_t.change_size(): + + change_size(self, nsize, sideff=WITH_SIDEFF) -> bool + + +ida_hexrays.mop_t.create_from_insn(): + + create_from_insn(self, m) + + +ida_hexrays.mop_t.create_from_ivlset(): + + create_from_ivlset(self, mba, ivs, fullsize) -> bool + + +ida_hexrays.mop_t.create_from_mlist(): + + create_from_mlist(self, mba, lst, fullsize) -> bool + + +ida_hexrays.mop_t.create_from_scattered_vdloc(): + + create_from_scattered_vdloc(self, mba, name, type, loc) + + +ida_hexrays.mop_t.create_from_vdloc(): + + create_from_vdloc(self, mba, loc, _size) + + +ida_hexrays.mop_t.double_size(): + + double_size(self, sideff=WITH_SIDEFF) -> bool + + +ida_hexrays.mop_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.mop_t.equal_mops(): + + equal_mops(self, rop, eqflags) -> bool + + +ida_hexrays.mop_t.erase(): + + erase(self) + + +ida_hexrays.mop_t.erase_but_keep_size(): + + erase_but_keep_size(self) + + +ida_hexrays.mop_t.for_all_ops(): + + for_all_ops(self, mv, type=None, is_target=False) -> int + + +ida_hexrays.mop_t.for_all_scattered_submops(): + + for_all_scattered_submops(self, sv) -> int + + +ida_hexrays.mop_t.get_insn(): + + get_insn(self, code) -> minsn_t + get_insn(self, code) -> minsn_t + + +ida_hexrays.mop_t.get_stkoff(): + + get_stkoff(self, p_off) -> bool + + +ida_hexrays.mop_t.get_stkvar(): + + get_stkvar(self, p_off) -> member_t * + + +ida_hexrays.mop_t.has_side_effects(): + + has_side_effects(self, include_ldx_and_divs=False) -> bool + + +ida_hexrays.mop_t.is01(): + + is01(self) -> bool + + +ida_hexrays.mop_t.is_bit_reg(): + + is_bit_reg(self, reg) -> bool + is_bit_reg(self) -> bool + + +ida_hexrays.mop_t.is_cc(): + + is_cc(self) -> bool + + +ida_hexrays.mop_t.is_ccflags(): + + is_ccflags(self) -> bool + + +ida_hexrays.mop_t.is_constant(): + + is_constant(self, is_signed=True) -> bool + + +ida_hexrays.mop_t.is_equal_to(): + + is_equal_to(self, n, is_signed=True) -> bool + + +ida_hexrays.mop_t.is_extended_from(): + + is_extended_from(self, nbytes, is_signed) -> bool + + +ida_hexrays.mop_t.is_glbaddr(): + + is_glbaddr(self) -> bool + is_glbaddr(self, ea) -> bool + + +ida_hexrays.mop_t.is_impptr_done(): + + is_impptr_done(self) -> bool + + +ida_hexrays.mop_t.is_insn(): + + is_insn(self) -> bool + is_insn(self, code) -> bool + + +ida_hexrays.mop_t.is_kreg(): + + is_kreg(self) -> bool + + +ida_hexrays.mop_t.is_mob(): + + is_mob(self, serial) -> bool + + +ida_hexrays.mop_t.is_negative_constant(): + + is_negative_constant(self) -> bool + + +ida_hexrays.mop_t.is_one(): + + is_one(self) -> bool + + +ida_hexrays.mop_t.is_positive_constant(): + + is_positive_constant(self) -> bool + + +ida_hexrays.mop_t.is_reg(): + + is_reg(self) -> bool + is_reg(self, _r) -> bool + is_reg(self, _r, _size) -> bool + + +ida_hexrays.mop_t.is_scattered(): + + is_scattered(self) -> bool + + +ida_hexrays.mop_t.is_sign_extended_from(): + + is_sign_extended_from(self, nbytes) -> bool + + +ida_hexrays.mop_t.is_stkaddr(): + + is_stkaddr(self) -> bool + + +ida_hexrays.mop_t.is_udt(): + + is_udt(self) -> bool + + +ida_hexrays.mop_t.is_undef_val(): + + is_undef_val(self) -> bool + + +ida_hexrays.mop_t.is_zero(): + + is_zero(self) -> bool + + +ida_hexrays.mop_t.is_zero_extended_from(): + + is_zero_extended_from(self, nbytes) -> bool + + +ida_hexrays.mop_t.lexcompare(): + + lexcompare(self, rop) -> int + + +ida_hexrays.mop_t.make_blkref(): + + make_blkref(self, blknum) + + +ida_hexrays.mop_t.make_first_half(): + + make_first_half(self, width) -> bool + + +ida_hexrays.mop_t.make_fpnum(): + + make_fpnum(self, bytes, _size) -> bool + + +ida_hexrays.mop_t.make_gvar(): + + make_gvar(self, ea) + + +ida_hexrays.mop_t.make_helper(): + + make_helper(self, name) + + +ida_hexrays.mop_t.make_high_half(): + + make_high_half(self, width) -> bool + + +ida_hexrays.mop_t.make_insn(): + + make_insn(self, ins) + + +ida_hexrays.mop_t.make_low_half(): + + make_low_half(self, width) -> bool + + +ida_hexrays.mop_t.make_number(): + + make_number(self, _value, _size, _ea=BADADDR, opnum=0) + + +ida_hexrays.mop_t.make_reg(): + + make_reg(self, reg) + make_reg(self, reg, _size) + + +ida_hexrays.mop_t.make_reg_pair(): + + make_reg_pair(self, loreg, hireg, halfsize) + + +ida_hexrays.mop_t.make_second_half(): + + make_second_half(self, width) -> bool + + +ida_hexrays.mop_t.may_use_aliased_memory(): + + may_use_aliased_memory(self) -> bool + + +ida_hexrays.mop_t.obj_id: + + _obj_id(self) -> PyObject * + + +ida_hexrays.mop_t.oprops: + mop_t_oprops_get(self) -> uint8 + +ida_hexrays.mop_t.preserve_side_effects(): + + preserve_side_effects(self, blk, top, moved_calls=None) -> bool + + +ida_hexrays.mop_t.probably_floating(): + + probably_floating(self) -> bool + + +ida_hexrays.mop_t.set_impptr_done(): + + set_impptr_done(self) + + +ida_hexrays.mop_t.set_udt(): + + set_udt(self) + + +ida_hexrays.mop_t.set_undef_val(): + + set_undef_val(self) + + +ida_hexrays.mop_t.shift_mop(): + + shift_mop(self, offset) -> bool + + +ida_hexrays.mop_t.signed_value(): + + signed_value(self) -> int64 + + +ida_hexrays.mop_t.size: + mop_t_size_get(self) -> int + +ida_hexrays.mop_t.swap(): + + swap(self, rop) + + +ida_hexrays.mop_t.t: + + _get_t(self) -> mopt_t + + +ida_hexrays.mop_t.unsigned_value(): + + unsigned_value(self) -> uint64 + + +ida_hexrays.mop_t.valnum: + mop_t_valnum_get(self) -> uint16 + +ida_hexrays.mop_t.value(): + + value(self, is_signed) -> uint64 + + +ida_hexrays.mop_t.zero(): + + zero(self) + + +class ida_hexrays.mop_visitor_t(): + + Proxy of C++ mop_visitor_t class + + +ida_hexrays.mop_visitor_t.blk: + op_parent_info_t_blk_get(self) -> mblock_t + +ida_hexrays.mop_visitor_t.curins: + op_parent_info_t_curins_get(self) -> minsn_t + +ida_hexrays.mop_visitor_t.mba: + op_parent_info_t_mba_get(self) -> mbl_array_t + +ida_hexrays.mop_visitor_t.prune: + mop_visitor_t_prune_get(self) -> bool + +ida_hexrays.mop_visitor_t.topins: + op_parent_info_t_topins_get(self) -> minsn_t + +ida_hexrays.mop_visitor_t.visit_mop(): + + visit_mop(self, op, type, is_target) -> int + + +class ida_hexrays.mopvec_t(): + + Proxy of C++ qvector<(mop_t)> class + + +ida_hexrays.mopvec_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_hexrays.mopvec_t.at(): + + at(self, _idx) -> mop_t + + +ida_hexrays.mopvec_t.begin(): + + begin(self) -> mop_t + begin(self) -> mop_t + + +ida_hexrays.mopvec_t.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.mopvec_t.clear(): + + clear(self) + + +ida_hexrays.mopvec_t.empty(): + + empty(self) -> bool + + +ida_hexrays.mopvec_t.end(): + + end(self) -> mop_t + end(self) -> mop_t + + +ida_hexrays.mopvec_t.erase(): + + erase(self, it) -> mop_t + erase(self, first, last) -> mop_t + + +ida_hexrays.mopvec_t.extract(): + + extract(self) -> mop_t + + +ida_hexrays.mopvec_t.find(): + + find(self, x) -> mop_t + find(self, x) -> mop_t + + +ida_hexrays.mopvec_t.grow(): + + grow(self, x=mop_t()) + + +ida_hexrays.mopvec_t.has(): + + has(self, x) -> bool + + +ida_hexrays.mopvec_t.inject(): + + inject(self, s, len) + + +ida_hexrays.mopvec_t.insert(): + + insert(self, it, x) -> mop_t + + +ida_hexrays.mopvec_t.pop_back(): + + pop_back(self) + + +ida_hexrays.mopvec_t.push_back(): + + push_back(self, x) + push_back(self) -> mop_t + + +ida_hexrays.mopvec_t.qclear(): + + qclear(self) + + +ida_hexrays.mopvec_t.reserve(): + + reserve(self, cnt) + + +ida_hexrays.mopvec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.mopvec_t.size(): + + size(self) -> size_t + + +ida_hexrays.mopvec_t.swap(): + + swap(self, r) + + +ida_hexrays.mopvec_t.truncate(): + + truncate(self) + + +ida_hexrays.mreg2reg(): + + mreg2reg(reg, width) -> int + + + Map a microregister to processor register. + + @param reg: microregister number (C++: mreg_t) + @param width: size of microregister in bytes (C++: int) + @return: processor register id or -1 + + +ida_hexrays.must_mcode_close_block(): + + must_mcode_close_block(mcode, including_calls) -> bool + + + Must an instruction with the given opcode be the last one in a block? + Such opcodes are called closing opcodes. + + @param mcode: instruction opcode (C++: mcode_t) + @param including_calls: should m_call/m_icall be considered as the + closing opcodes? If this function returns + true, the opcode cannot appear in the middle + of a block. Calls are a special case because + before MMAT_CALLS they are closing opcodes. + Afteer MMAT_CALLS that are not considered as + closing opcodes. (C++: bool) + + +ida_hexrays.negate_mcode_relation(): + + negate_mcode_relation(code) -> mcode_t + + ida_hexrays.negated_relation(): negated_relation(op) -> ctype_t @@ -20287,6 +25658,23 @@ ida_hexrays.number_format_t.serial: ida_hexrays.number_format_t.type_name: number_format_t_type_name_get(self) -> qstring * +class ida_hexrays.op_parent_info_t(): + + Proxy of C++ op_parent_info_t class + + +ida_hexrays.op_parent_info_t.blk: + op_parent_info_t_blk_get(self) -> mblock_t + +ida_hexrays.op_parent_info_t.curins: + op_parent_info_t_curins_get(self) -> minsn_t + +ida_hexrays.op_parent_info_t.mba: + op_parent_info_t_mba_get(self) -> mbl_array_t + +ida_hexrays.op_parent_info_t.topins: + op_parent_info_t_topins_get(self) -> minsn_t + ida_hexrays.op_uses_x(): op_uses_x(op) -> bool @@ -20371,6 +25759,46 @@ ida_hexrays.operator_info_t.text: ida_hexrays.operator_info_t.valency: operator_info_t_valency_get(self) -> uchar +class ida_hexrays.optblock_t(): + + Proxy of C++ optblock_t class + + +ida_hexrays.optblock_t.func(): + + func(self, blk) -> int + + +ida_hexrays.optblock_t.install(): + + install(self) + + +ida_hexrays.optblock_t.remove(): + + remove(self) -> bool + + +class ida_hexrays.optinsn_t(): + + Proxy of C++ optinsn_t class + + +ida_hexrays.optinsn_t.func(): + + func(self, blk, ins) -> int + + +ida_hexrays.optinsn_t.install(): + + install(self) + + +ida_hexrays.optinsn_t.remove(): + + remove(self) -> bool + + ida_hexrays.parse_user_call(): parse_user_call(udc, decl, silent) -> bool @@ -20456,7 +25884,7 @@ ida_hexrays.qlist_cinsn_t.front(): ida_hexrays.qlist_cinsn_t.insert(): insert(self, p, x) -> qlist< cinsn_t >::iterator - insert(self, p) -> cinsn_t + insert(self, p) -> qlist< cinsn_t >::iterator insert(self, p, x) -> qlist_cinsn_t_iterator @@ -20545,6 +25973,9 @@ ida_hexrays.qstring_printer_t.oneliner(): oneliner(self) -> bool +ida_hexrays.qstring_printer_t.tmpbuf: + vd_printer_t_tmpbuf_get(self) -> qstring * + ida_hexrays.qstring_printer_t.with_tags: qstring_printer_t_with_tags_get(self) -> bool @@ -20563,6 +25994,12 @@ ida_hexrays.qvector_carg_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.qvector_carg_t.append(): + + push_back(self, x) + push_back(self) -> carg_t + + ida_hexrays.qvector_carg_t.at(): __getitem__(self, i) -> carg_t @@ -20684,6 +26121,12 @@ ida_hexrays.qvector_ccase_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.qvector_ccase_t.append(): + + push_back(self, x) + push_back(self) -> ccase_t + + ida_hexrays.qvector_ccase_t.at(): __getitem__(self, i) -> ccase_t @@ -20926,6 +26369,12 @@ ida_hexrays.qvector_lvar_t.add_unique(): add_unique(self, x) -> bool +ida_hexrays.qvector_lvar_t.append(): + + push_back(self, x) + push_back(self) -> lvar_t + + ida_hexrays.qvector_lvar_t.at(): __getitem__(self, i) -> lvar_t @@ -21037,6 +26486,17 @@ ida_hexrays.qvector_lvar_t.truncate(): truncate(self) +ida_hexrays.reg2mreg(): + + reg2mreg(reg) -> mreg_t + + + Map a processor register to microregister. + + @param reg: processor register number (C++: int) + @return: microregister register id or mr_none + + ida_hexrays.remitem(): remitem(e) @@ -21130,6 +26590,151 @@ ida_hexrays.restore_user_unions(): be deleted by the caller using delete_user_unions() +class ida_hexrays.rlist_t(): + + Proxy of C++ rlist_t class + + +ida_hexrays.rlist_t.add(): + + add(self, bit) -> bool + add(self, bit, width) -> bool + add(self, ml) -> bool + + +ida_hexrays.rlist_t.back(): + + back(self) -> int + + +ida_hexrays.rlist_t.begin(): + + begin(self) -> bitset_t::iterator + + +ida_hexrays.rlist_t.clear(): + + clear(self) + + +ida_hexrays.rlist_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.rlist_t.copy(): + + copy(self, m) -> bitset_t + + +ida_hexrays.rlist_t.count(): + + count(self) -> int + count(self, bit) -> int + + +ida_hexrays.rlist_t.cut_at(): + + cut_at(self, maxbit) -> bool + + +ida_hexrays.rlist_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.rlist_t.empty(): + + empty(self) -> bool + + +ida_hexrays.rlist_t.end(): + + end(self) -> bitset_t::iterator + + +ida_hexrays.rlist_t.fill_with_ones(): + + fill_with_ones(self, maxbit) + + +ida_hexrays.rlist_t.front(): + + front(self) -> int + + +ida_hexrays.rlist_t.has(): + + has(self, bit) -> bool + + +ida_hexrays.rlist_t.has_all(): + + has_all(self, bit, width) -> bool + + +ida_hexrays.rlist_t.has_any(): + + has_any(self, bit, width) -> bool + + +ida_hexrays.rlist_t.has_common(): + + has_common(self, ml) -> bool + + +ida_hexrays.rlist_t.inc(): + + inc(self, p, n=1) + + +ida_hexrays.rlist_t.includes(): + + includes(self, ml) -> bool + + +ida_hexrays.rlist_t.intersect(): + + intersect(self, ml) -> bool + + +ida_hexrays.rlist_t.is_subset_of(): + + is_subset_of(self, ml) -> bool + + +ida_hexrays.rlist_t.itat(): + + itat(self, n) -> bitset_t::iterator + + +ida_hexrays.rlist_t.itv(): + + itv(self, it) -> int + + +ida_hexrays.rlist_t.last(): + + last(self) -> int + + +ida_hexrays.rlist_t.shift_down(): + + shift_down(self, shift) + + +ida_hexrays.rlist_t.sub(): + + sub(self, bit) -> bool + sub(self, bit, width) -> bool + sub(self, ml) -> bool + + +ida_hexrays.rlist_t.swap(): + + swap(self, r) + + ida_hexrays.save_user_cmts(): save_user_cmts(func_ea, user_cmts) @@ -21214,6 +26819,226 @@ ida_hexrays.save_user_unions(): user_unions_t *) +class ida_hexrays.scif_t(): + + Proxy of C++ scif_t class + + +ida_hexrays.scif_t.advance(): + + advance(self, delta) -> bool + + +ida_hexrays.scif_t.atype(): + + atype(self) -> argloc_type_t + + +ida_hexrays.scif_t.calc_offset(): + + calc_offset(self) -> sval_t + + +ida_hexrays.scif_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.scif_t.consume_rrel(): + + consume_rrel(self, p) + + +ida_hexrays.scif_t.consume_scattered(): + + consume_scattered(self, p) + + +ida_hexrays.scif_t.get_biggest(): + + get_biggest(self) -> argloc_t::biggest_t + + +ida_hexrays.scif_t.get_custom(): + + get_custom(self) -> void * + + +ida_hexrays.scif_t.get_ea(): + + get_ea(self) -> ea_t + + +ida_hexrays.scif_t.get_reginfo(): + + get_reginfo(self) -> uint32 + + +ida_hexrays.scif_t.get_rrel(): + + get_rrel(self) -> rrel_t + get_rrel(self) -> rrel_t + + +ida_hexrays.scif_t.has_reg(): + + has_reg(self) -> bool + + +ida_hexrays.scif_t.has_stkoff(): + + has_stkoff(self) -> bool + + +ida_hexrays.scif_t.is_aliasable(): + + is_aliasable(self, mb, size) -> bool + + +ida_hexrays.scif_t.is_badloc(): + + is_badloc(self) -> bool + + +ida_hexrays.scif_t.is_custom(): + + is_custom(self) -> bool + + +ida_hexrays.scif_t.is_ea(): + + is_ea(self) -> bool + + +ida_hexrays.scif_t.is_fragmented(): + + is_fragmented(self) -> bool + + +ida_hexrays.scif_t.is_mixed_scattered(): + + is_mixed_scattered(self) -> bool + + +ida_hexrays.scif_t.is_reg(): + + is_reg(self) -> bool + + +ida_hexrays.scif_t.is_reg1(): + + is_reg1(self) -> bool + + +ida_hexrays.scif_t.is_reg2(): + + is_reg2(self) -> bool + + +ida_hexrays.scif_t.is_rrel(): + + is_rrel(self) -> bool + + +ida_hexrays.scif_t.is_scattered(): + + is_scattered(self) -> bool + + +ida_hexrays.scif_t.is_stkoff(): + + is_stkoff(self) -> bool + + +ida_hexrays.scif_t.mba: + scif_t_mba_get(self) -> mbl_array_t + +ida_hexrays.scif_t.name: + scif_t_name_get(self) -> qstring * + +ida_hexrays.scif_t.reg1(): + + reg1(self) -> int + + +ida_hexrays.scif_t.reg2(): + + reg2(self) -> int + + +ida_hexrays.scif_t.regoff(): + + regoff(self) -> int + + +ida_hexrays.scif_t.scattered(): + + scattered(self) -> scattered_aloc_t + scattered(self) -> scattered_aloc_t + + +ida_hexrays.scif_t.set_badloc(): + + set_badloc(self) + + +ida_hexrays.scif_t.set_ea(): + + set_ea(self, _ea) + + +ida_hexrays.scif_t.set_reg1(): + + set_reg1(self, r1) + + +ida_hexrays.scif_t.set_reg2(): + + set_reg2(self, _reg1, _reg2) + + +ida_hexrays.scif_t.set_stkoff(): + + set_stkoff(self, off) + + +ida_hexrays.scif_t.stkoff(): + + stkoff(self) -> sval_t + + +ida_hexrays.scif_t.swap(): + + swap(self, r) + + +ida_hexrays.scif_t.type: + scif_t_type_get(self) -> tinfo_t + +class ida_hexrays.scif_visitor_t(): + + Proxy of C++ scif_visitor_t class + + +ida_hexrays.scif_visitor_t.visit_scif_mop(): + + visit_scif_mop(self, r, off) -> int + + +ida_hexrays.select_udt_by_offset(): + + select_udt_by_offset(udts, ops, applicator) -> int + + + Select UDT + + @param udts: list of UDT tinfo_t for the selection, if NULL or empty + then UDTs from the "Local types" will be used (C++: const + qvector < tinfo_t > *) + @param ops: operands (C++: const ui_stroff_ops_t &) + @param applicator (C++: ui_stroff_applicator_t &) + + ida_hexrays.send_database(): send_database(err, silent) @@ -21230,6 +27055,11 @@ ida_hexrays.send_database(): the database. (C++: bool) +ida_hexrays.set2jcnd(): + + set2jcnd(code) -> mcode_t + + ida_hexrays.set_type(): set_type(id, tif, source, force=False) -> bool @@ -21246,6 +27076,48 @@ ida_hexrays.set_type(): @return: success +class ida_hexrays.simple_graph_t(): + + Proxy of C++ simple_graph_t class + + +ida_hexrays.simple_graph_t.colored_gdl_edges: + simple_graph_t_colored_gdl_edges_get(self) -> bool + +ida_hexrays.simple_graph_t.title: + simple_graph_t_title_get(self) -> qstring * + +class ida_hexrays.stkvar_ref_t(): + + Proxy of C++ stkvar_ref_t class + + +ida_hexrays.stkvar_ref_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.stkvar_ref_t.get_stkvar(): + + get_stkvar(self, p_off=None) -> member_t * + + +ida_hexrays.stkvar_ref_t.mba: + stkvar_ref_t_mba_get(self) -> mbl_array_t + +ida_hexrays.stkvar_ref_t.off: + stkvar_ref_t_off_get(self) -> sval_t + +ida_hexrays.stkvar_ref_t.swap(): + + swap(self, r) + + +ida_hexrays.swap_mcode_relation(): + + swap_mcode_relation(code) -> mcode_t + + ida_hexrays.swapped_relation(): swapped_relation(op) -> ctype_t @@ -21453,12 +27325,165 @@ class ida_hexrays.udcall_t(): Proxy of C++ udcall_t class +ida_hexrays.udcall_t.compare(): + + compare(self, r) -> int + + ida_hexrays.udcall_t.name: udcall_t_name_get(self) -> qstring * ida_hexrays.udcall_t.tif: udcall_t_tif_get(self) -> tinfo_t +class ida_hexrays.ui_stroff_applicator_t(): + + Proxy of C++ ui_stroff_applicator_t class + + +ida_hexrays.ui_stroff_applicator_t.apply(): + + apply(self, opnum, path) -> bool + + +class ida_hexrays.ui_stroff_op_t(): + + Proxy of C++ ui_stroff_op_t class + + +ida_hexrays.ui_stroff_op_t.offset: + ui_stroff_op_t_offset_get(self) -> uval_t + +ida_hexrays.ui_stroff_op_t.text: + ui_stroff_op_t_text_get(self) -> qstring * + +class ida_hexrays.ui_stroff_ops_t(): + + Proxy of C++ qvector<(ui_stroff_op_t)> class + + +ida_hexrays.ui_stroff_ops_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_hexrays.ui_stroff_ops_t.append(): + + push_back(self, x) + push_back(self) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.at(): + + __getitem__(self, i) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.begin(): + + begin(self) -> ui_stroff_op_t + begin(self) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.capacity(): + + capacity(self) -> size_t + + +ida_hexrays.ui_stroff_ops_t.clear(): + + clear(self) + + +ida_hexrays.ui_stroff_ops_t.empty(): + + empty(self) -> bool + + +ida_hexrays.ui_stroff_ops_t.end(): + + end(self) -> ui_stroff_op_t + end(self) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.erase(): + + erase(self, it) -> ui_stroff_op_t + erase(self, first, last) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.extract(): + + extract(self) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.find(): + + find(self, x) -> ui_stroff_op_t + find(self, x) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.grow(): + + grow(self, x=ui_stroff_op_t()) + + +ida_hexrays.ui_stroff_ops_t.has(): + + has(self, x) -> bool + + +ida_hexrays.ui_stroff_ops_t.inject(): + + inject(self, s, len) + + +ida_hexrays.ui_stroff_ops_t.insert(): + + insert(self, it, x) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.pop_back(): + + pop_back(self) + + +ida_hexrays.ui_stroff_ops_t.push_back(): + + push_back(self, x) + push_back(self) -> ui_stroff_op_t + + +ida_hexrays.ui_stroff_ops_t.qclear(): + + qclear(self) + + +ida_hexrays.ui_stroff_ops_t.reserve(): + + reserve(self, cnt) + + +ida_hexrays.ui_stroff_ops_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_hexrays.ui_stroff_ops_t.size(): + + size(self) -> size_t + + +ida_hexrays.ui_stroff_ops_t.swap(): + + swap(self, r) + + +ida_hexrays.ui_stroff_ops_t.truncate(): + + truncate(self) + + ida_hexrays.user_cmts_begin(): user_cmts_begin(map) -> user_cmts_iterator_t @@ -22453,7 +28478,7 @@ ida_hexrays.user_unions_prev(): ida_hexrays.user_unions_second(): - user_unions_second(p) -> intvec_t & + user_unions_second(p) -> intvec_t Get reference to the current map value. @@ -22480,7 +28505,7 @@ class ida_hexrays.user_unions_t(): ida_hexrays.user_unions_t.at(): - at(self, _Keyval) -> qvector< int > & + at(self, _Keyval) -> intvec_t ida_hexrays.user_unions_t.pop(): @@ -22508,6 +28533,12 @@ ida_hexrays.user_unions_t.valuetype.add_unique(): add_unique(self, x) -> bool +ida_hexrays.user_unions_t.valuetype.append(): + + push_back(self, x) + push_back(self) -> int & + + ida_hexrays.user_unions_t.valuetype.at(): __getitem__(self, i) -> int const & @@ -22614,6 +28645,222 @@ ida_hexrays.user_unions_t.valuetype.truncate(): truncate(self) +class ida_hexrays.uval_ivl_ivlset_t(): + + Proxy of C++ ivlset_tpl<(ivl_t,uval_t)> class + + +ida_hexrays.uval_ivl_ivlset_t.all_values(): + + all_values(self) -> bool + + +ida_hexrays.uval_ivl_ivlset_t.begin(): + + begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator + begin(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator + + +ida_hexrays.uval_ivl_ivlset_t.clear(): + + clear(self) + + +ida_hexrays.uval_ivl_ivlset_t.empty(): + + empty(self) -> bool + + +ida_hexrays.uval_ivl_ivlset_t.end(): + + end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::const_iterator + end(self) -> ivlset_tpl< ivl_t,unsigned-ea-like-numeric-type >::iterator + + +ida_hexrays.uval_ivl_ivlset_t.getivl(): + + getivl(self, idx) -> ivl_t + + +ida_hexrays.uval_ivl_ivlset_t.lastivl(): + + lastivl(self) -> ivl_t + + +ida_hexrays.uval_ivl_ivlset_t.nivls(): + + nivls(self) -> size_t + + +ida_hexrays.uval_ivl_ivlset_t.qclear(): + + qclear(self) + + +ida_hexrays.uval_ivl_ivlset_t.set_all_values(): + + set_all_values(self) + + +ida_hexrays.uval_ivl_ivlset_t.single_value(): + + single_value(self, v) -> bool + + +ida_hexrays.uval_ivl_ivlset_t.swap(): + + swap(self, r) + + +class ida_hexrays.uval_ivl_t(): + + Proxy of C++ ivl_tpl<(uval_t)> class + + +ida_hexrays.uval_ivl_t.end(): + + end(self) -> unsigned-ea-like-numeric-type + + +ida_hexrays.uval_ivl_t.last(): + + last(self) -> unsigned-ea-like-numeric-type + + +ida_hexrays.uval_ivl_t.off: + uval_ivl_t_off_get(self) -> unsigned-ea-like-numeric-type + +ida_hexrays.uval_ivl_t.size: + uval_ivl_t_size_get(self) -> unsigned-ea-like-numeric-type + +ida_hexrays.uval_ivl_t.valid(): + + valid(self) -> bool + + +class ida_hexrays.valrng_t(): + + Proxy of C++ valrng_t class + + +ida_hexrays.valrng_t._print(): + + _print(self) + + +ida_hexrays.valrng_t.all_values(): + + all_values(self) -> bool + + +ida_hexrays.valrng_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.valrng_t.cvt_to_cmp(): + + cvt_to_cmp(self, strict) -> bool + + +ida_hexrays.valrng_t.cvt_to_single_value(): + + cvt_to_single_value(self) -> bool + + +ida_hexrays.valrng_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.valrng_t.empty(): + + empty(self) -> bool + + +ida_hexrays.valrng_t.get_size(): + + get_size(self) -> int + + +ida_hexrays.valrng_t.has(): + + has(self, v) -> bool + + +ida_hexrays.valrng_t.intersect_with(): + + intersect_with(self, r) -> bool + + +ida_hexrays.valrng_t.inverse(): + + inverse(self) + + +ida_hexrays.valrng_t.is_unknown(): + + is_unknown(self) -> bool + + +ida_hexrays.valrng_t.max_svalue(): + + max_svalue(self, size_) -> uvlr_t + max_svalue(self) -> uvlr_t + + +ida_hexrays.valrng_t.max_value(): + + max_value(self, size_) -> uvlr_t + max_value(self) -> uvlr_t + + +ida_hexrays.valrng_t.min_svalue(): + + min_svalue(self, size_) -> uvlr_t + min_svalue(self) -> uvlr_t + + +ida_hexrays.valrng_t.reduce_size(): + + reduce_size(self, new_size) -> bool + + +ida_hexrays.valrng_t.set_all(): + + set_all(self) + + +ida_hexrays.valrng_t.set_cmp(): + + set_cmp(self, cmp, _value) + + +ida_hexrays.valrng_t.set_eq(): + + set_eq(self, v) + + +ida_hexrays.valrng_t.set_none(): + + set_none(self) + + +ida_hexrays.valrng_t.set_unk(): + + set_unk(self) + + +ida_hexrays.valrng_t.swap(): + + swap(self, r) + + +ida_hexrays.valrng_t.unite_with(): + + unite_with(self, r) -> bool + + class ida_hexrays.var_ref_t(): Proxy of C++ var_ref_t class @@ -22628,7 +28875,7 @@ ida_hexrays.var_ref_t.idx: var_ref_t_idx_get(self) -> int ida_hexrays.var_ref_t.mba: - var_ref_t_mba_get(self) -> mbl_array_t * + var_ref_t_mba_get(self) -> mbl_array_t class ida_hexrays.vc_printer_t(): @@ -22654,6 +28901,9 @@ ida_hexrays.vc_printer_t.oneliner(): oneliner(self) -> bool +ida_hexrays.vc_printer_t.tmpbuf: + vd_printer_t_tmpbuf_get(self) -> qstring * + class ida_hexrays.vd_failure_t(): Proxy of C++ vd_failure_t class @@ -22693,6 +28943,9 @@ ida_hexrays.vd_printer_t._print(): ida_hexrays.vd_printer_t.hdrlines: vd_printer_t_hdrlines_get(self) -> int +ida_hexrays.vd_printer_t.tmpbuf: + vd_printer_t_tmpbuf_get(self) -> qstring * + class ida_hexrays.vdloc_t(): Proxy of C++ vdloc_t class @@ -22754,6 +29007,16 @@ ida_hexrays.vdloc_t.get_rrel(): get_rrel(self) -> rrel_t +ida_hexrays.vdloc_t.has_reg(): + + has_reg(self) -> bool + + +ida_hexrays.vdloc_t.has_stkoff(): + + has_stkoff(self) -> bool + + ida_hexrays.vdloc_t.is_aliasable(): is_aliasable(self, mb, size) -> bool @@ -22978,11 +29241,11 @@ ida_hexrays.vdui_t.locked(): ida_hexrays.vdui_t.map_lvar(): - map_lvar(self, _from, to) -> bool + map_lvar(self, frm, to) -> bool ida_hexrays.vdui_t.mba: - vdui_t_mba_get(self) -> mbl_array_t * + vdui_t_mba_get(self) -> mbl_array_t ida_hexrays.vdui_t.refresh_cpos(): @@ -23133,8 +29396,224 @@ ida_hexrays.vdui_t.visible(): visible(self) -> bool +class ida_hexrays.vivl_t(): + + Proxy of C++ vivl_t class + + +ida_hexrays.vivl_t._print(): + + _print(self) + + +ida_hexrays.vivl_t.add(): + + add(self, width) -> voff_t + + +ida_hexrays.vivl_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.vivl_t.contains(): + + contains(self, voff2) -> bool + + +ida_hexrays.vivl_t.defined(): + + defined(self) -> bool + + +ida_hexrays.vivl_t.diff(): + + diff(self, r) -> sval_t + + +ida_hexrays.vivl_t.dstr(): + + dstr(self) -> char const * + + +ida_hexrays.vivl_t.extend_to_cover(): + + extend_to_cover(self, r) -> bool + + +ida_hexrays.vivl_t.get_reg(): + + get_reg(self) -> mreg_t + + +ida_hexrays.vivl_t.get_stkoff(): + + get_stkoff(self) -> sval_t + + +ida_hexrays.vivl_t.inc(): + + inc(self, delta) + + +ida_hexrays.vivl_t.includes(): + + includes(self, r) -> bool + + +ida_hexrays.vivl_t.intersect(): + + intersect(self, r) -> uval_t + + +ida_hexrays.vivl_t.is_reg(): + + is_reg(self) -> bool + + +ida_hexrays.vivl_t.is_stkoff(): + + is_stkoff(self) -> bool + + +ida_hexrays.vivl_t.off: + voff_t_off_get(self) -> sval_t + +ida_hexrays.vivl_t.overlap(): + + overlap(self, r) -> bool + + +ida_hexrays.vivl_t.set(): + + set(self, _type, _off, _size=0) + set(self, voff, _size) + + +ida_hexrays.vivl_t.set_reg(): + + set_reg(self, mreg, sz=0) + + +ida_hexrays.vivl_t.set_stkoff(): + + set_stkoff(self, stkoff, sz=0) + + +ida_hexrays.vivl_t.size: + vivl_t_size_get(self) -> int + +ida_hexrays.vivl_t.type: + voff_t_type_get(self) -> mopt_t + +ida_hexrays.vivl_t.undef(): + + undef(self) + + +class ida_hexrays.voff_t(): + + Proxy of C++ voff_t class + + +ida_hexrays.voff_t.add(): + + add(self, width) -> voff_t + + +ida_hexrays.voff_t.compare(): + + compare(self, r) -> int + + +ida_hexrays.voff_t.defined(): + + defined(self) -> bool + + +ida_hexrays.voff_t.diff(): + + diff(self, r) -> sval_t + + +ida_hexrays.voff_t.get_reg(): + + get_reg(self) -> mreg_t + + +ida_hexrays.voff_t.get_stkoff(): + + get_stkoff(self) -> sval_t + + +ida_hexrays.voff_t.inc(): + + inc(self, delta) + + +ida_hexrays.voff_t.is_reg(): + + is_reg(self) -> bool + + +ida_hexrays.voff_t.is_stkoff(): + + is_stkoff(self) -> bool + + +ida_hexrays.voff_t.off: + voff_t_off_get(self) -> sval_t + +ida_hexrays.voff_t.set(): + + set(self, _type, _off) + + +ida_hexrays.voff_t.set_reg(): + + set_reg(self, mreg) + + +ida_hexrays.voff_t.set_stkoff(): + + set_stkoff(self, stkoff) + + +ida_hexrays.voff_t.type: + voff_t_type_get(self) -> mopt_t + +ida_hexrays.voff_t.undef(): + + undef(self) + + === ida_hexrays EPYDOC INJECTIONS === +ida_hexrays.ACFL_BLKOPT +""" +perform interblock transformations +""" + +ida_hexrays.ACFL_GLBDEL +""" +perform dead code eliminition +""" + +ida_hexrays.ACFL_GLBPROP +""" +perform global propagation +""" + +ida_hexrays.ACFL_GUESS +""" +may guess calling conventions +""" + +ida_hexrays.ACFL_LOCOPT +""" +perform local propagation (requires ACFL_BLKOPT) +""" + ida_hexrays.ANCHOR_BLKCMT """ block comment (for ctree items) @@ -23180,11 +29659,58 @@ ida_hexrays.CFS_TEXT 'sv' is ready (and hdrlines) """ +ida_hexrays.CHF_FAKE +""" +fake chain created by widen_chains() +""" + +ida_hexrays.CHF_INITED +""" +is chain initialized? (valid only after lvar allocation) +""" + +ida_hexrays.CHF_OVER +""" +overlapped chain +""" + +ida_hexrays.CHF_PASSTHRU +""" +pass-thru chain, must use the input variable to the block +""" + +ida_hexrays.CHF_REPLACED +""" +chain operands have been replaced? +""" + +ida_hexrays.CHF_TERM +""" +terminating chain; the variable does not survive across the block +""" + ida_hexrays.CIT_COLLAPSED """ display element in collapsed form """ +ida_hexrays.CPBLK_FAST +""" +do not update minbstkref and minbargref +""" + +ida_hexrays.CPBLK_MINREF +""" +update minbstkref and minbargref +""" + +ida_hexrays.CPBLK_OPTJMP +""" +if it becomes useless + +del the jump insn at the end of the block +""" + ida_hexrays.CV_FAST """ do not maintain parent information @@ -23238,6 +29764,26 @@ ida_hexrays.DECOMP_WARNINGS display warnings in the output window """ +ida_hexrays.EQ_CMPDEST +""" +compare instruction destinations +""" + +ida_hexrays.EQ_IGNCODE +""" +ignore instruction opcodes +""" + +ida_hexrays.EQ_IGNSIZE +""" +ignore operand sizes +""" + +ida_hexrays.EQ_OPTINSN +""" +optimize mop_d operands +""" + ida_hexrays.EXFL_ALL """ all currently defined bits @@ -23288,6 +29834,133 @@ ida_hexrays.EXFL_VFTABLE is ptr to vftable (used for cot_memptr, cot_memref) """ +ida_hexrays.FCI_DEAD +""" +some return registers were determined dead +""" + +ida_hexrays.FCI_FINAL +""" +call type is final, should not be changed +""" + +ida_hexrays.FCI_HASCALL +""" +A function is an synthetic helper combined from several instructions +and at least one of them was a call to a real functions +""" + +ida_hexrays.FCI_HASFMT +""" +printf- or scanf-style format string + +A variadic function with recognized +""" + +ida_hexrays.FCI_NORET +""" +call does not return +""" + +ida_hexrays.FCI_NOSIDE +""" +call does not have side effects +""" + +ida_hexrays.FCI_PROP +""" +call has been propagated +""" + +ida_hexrays.FCI_PURE +""" +pure function +""" + +ida_hexrays.FCI_SPLOK +""" +spoiled/visible_memory lists have been optimized. for some functions +we can reduce them as soon as information about the arguments becomes +available. in order not to try optimize them again we use this bit. +""" + +ida_hexrays.FD_BACKWARD +""" +search direction +""" + +ida_hexrays.FD_DEF +""" +look for definition +""" + +ida_hexrays.FD_DIRTY +""" +by function calls and indirect memory access + +ignore possible implicit definitions +""" + +ida_hexrays.FD_FORWARD +""" +search direction +""" + +ida_hexrays.FD_USE +""" +look for use +""" + +ida_hexrays.GCA_ALLOC +""" +enumerate only allocated chains +""" + +ida_hexrays.GCA_EMPTY +""" +include empty chains +""" + +ida_hexrays.GCA_NALLOC +""" +enumerate only non-allocated chains +""" + +ida_hexrays.GCA_OFIRST +""" +consider only chains of the first block +""" + +ida_hexrays.GCA_OLAST +""" +consider only chains of the last block +""" + +ida_hexrays.GCA_SPEC +""" +include chains for special registers +""" + +ida_hexrays.GCO_DEF +""" +is destination operand? +""" + +ida_hexrays.GCO_REG +""" +is register? otherwise a stack variable +""" + +ida_hexrays.GCO_STK +""" +a stack variable +""" + +ida_hexrays.GCO_USE +""" +is source operand? +""" + ida_hexrays.GLN_ALL """ get both @@ -23303,6 +29976,135 @@ ida_hexrays.GLN_GOTO_TARGET get goto target """ +ida_hexrays.IPROP_ASSERT +""" +assertion: usually mov #val, op. assertions are used to help the +optimizer. assertions are ignored when generating ctree +""" + +ida_hexrays.IPROP_CLNPOP +""" +(e.g. "pop ecx" is often used for that) + +the purpose of the instruction is to clean stack +""" + +ida_hexrays.IPROP_COMBINED +""" +insn has been modified because of a partial reference +""" + +ida_hexrays.IPROP_DONT_COMB +""" +may not combine this instruction with others +""" + +ida_hexrays.IPROP_DONT_PROP +""" +may not propagate +""" + +ida_hexrays.IPROP_EXTSTX +""" +this is m_ext propagated into m_stx +""" + +ida_hexrays.IPROP_FARCALL +""" +call of a far function using push cs/call sequence +""" + +ida_hexrays.IPROP_FPINSN +""" +floating point insn +""" + +ida_hexrays.IPROP_IGNLOWSRC +""" +low part of the instruction source operand has been created +artificially (this bit is used only for 'and x, 80...') +""" + +ida_hexrays.IPROP_INV_JX +""" +inverted conditional jump +""" + +ida_hexrays.IPROP_MULTI_MOV +""" +(example: STM on ARM may transfer multiple registers) + +the minsn was generated as part of insn that moves multiple +registersbits that can be set by plugins: +""" + +ida_hexrays.IPROP_OPTIONAL +""" +optional instruction +""" + +ida_hexrays.IPROP_PERSIST +""" +persistent insn; they are not destroyed +""" + +ida_hexrays.IPROP_SPLIT +""" +the instruction has been split: +""" + +ida_hexrays.IPROP_SPLIT1 +""" +into 1 byte +""" + +ida_hexrays.IPROP_SPLIT2 +""" +into 2 bytes +""" + +ida_hexrays.IPROP_SPLIT4 +""" +into 4 bytes +""" + +ida_hexrays.IPROP_SPLIT8 +""" +into 8 bytes +""" + +ida_hexrays.IPROP_TAILCALL +""" +tail call +""" + +ida_hexrays.IPROP_WAS_NORET +""" +was noret icall +""" + +ida_hexrays.IPROP_WILDMATCH +""" +match multiple insns +""" + +ida_hexrays.LOCOPT_ALL +""" +is not set, only dirty blocks will be optimized + +redo optimization for all blocks. if this bit +""" + +ida_hexrays.LOCOPT_REFINE +""" +refine return type, ok to fail +""" + +ida_hexrays.LOCOPT_REFINE2 +""" +refine return type, try harder +""" + ida_hexrays.LVINF_FORCE """ force allocation of a new variable. forces the decompiler to create a @@ -23322,6 +30124,248 @@ ida_hexrays.LVINF_NOPTR variable type should not be a pointer """ +ida_hexrays.MBA_ASRPROP +""" +assertion have been propagated +""" + +ida_hexrays.MBA_ASRTOK +""" +assertions have been generated +""" + +ida_hexrays.MBA_CALLS +""" +callinfo has been built +""" + +ida_hexrays.MBA_CHVARS +""" +can verify chain varnums +""" + +ida_hexrays.MBA_CMBBLK +""" +request to combine blocks +""" + +ida_hexrays.MBA_CMNSTK +""" +stkvars+stkargs should be considered as one area +""" + +ida_hexrays.MBA_COLGDL +""" +display graph after each reduction +""" + +ida_hexrays.MBA_DELPAIRS +""" +pairs have been deleted once +""" + +ida_hexrays.MBA_GLBOPT +""" +microcode has been optimized globally +""" + +ida_hexrays.MBA_INSGDL +""" +display instruction in graphs +""" + +ida_hexrays.MBA_LOADED +""" +loaded gdl, no instructions (debugging) +""" + +ida_hexrays.MBA_LVARS0 +""" +lvar pre-allocation has been performed +""" + +ida_hexrays.MBA_LVARS1 +""" +lvar real allocation has been performed +""" + +ida_hexrays.MBA_NICE +""" +apply transformations to c code +""" + +ida_hexrays.MBA_NOFUNC +""" +function is not present, addresses might be wrong +""" + +ida_hexrays.MBA_NUMADDR +""" +display definition addresses for numbers +""" + +ida_hexrays.MBA_OVERVAR +""" +an overlapped variable has been detected +""" + +ida_hexrays.MBA_PASSREGS +""" +has 'mcallinfo_t::pass_regs' +""" + +ida_hexrays.MBA_PATTERN +""" +microcode pattern, callinfo is present +""" + +ida_hexrays.MBA_PRCDEFS +""" +use precise defeas for chain-allocated lvars +""" + +ida_hexrays.MBA_PREOPT +""" +preoptimization stage complete +""" + +ida_hexrays.MBA_REFINE +""" +may refine return value size +""" + +ida_hexrays.MBA_RETFP +""" +function returns floating point value +""" + +ida_hexrays.MBA_RETREF +""" +return type has been refined +""" + +ida_hexrays.MBA_SAVRST +""" +save-restore analysis has been performed +""" + +ida_hexrays.MBA_SHORT +""" +use short display +""" + +ida_hexrays.MBA_SPLINFO +""" +(final_type ? idb_spoiled : spoiled_regs) is valid +""" + +ida_hexrays.MBA_THUNK +""" +thunk function +""" + +ida_hexrays.MBA_VALNUM +""" +display value numbers +""" + +ida_hexrays.MBA_WINGR32 +""" +use wingraph32 +""" + +ida_hexrays.MBL_BACKPROP +""" +performed backprop_cc +""" + +ida_hexrays.MBL_CALL +""" +call information has been built +""" + +ida_hexrays.MBL_COMB +""" +needs "combine" pass +""" + +ida_hexrays.MBL_DEAD +""" +needs "eliminate deads" pass +""" + +ida_hexrays.MBL_DMT64 +""" +needs "demote 64bits" +""" + +ida_hexrays.MBL_DSLOT +""" +block for delay slot +""" + +ida_hexrays.MBL_FAKE +""" +fake block (after a tail call) +""" + +ida_hexrays.MBL_GOTO +""" +this block is a goto target +""" + +ida_hexrays.MBL_INCONST +""" +inconsistent lists: we are building them +""" + +ida_hexrays.MBL_LIST +""" +use/def lists are ready (not dirty) +""" + +ida_hexrays.MBL_NONFAKE +""" +regular block +""" + +ida_hexrays.MBL_NORET +""" +dead end block: doesn't return execution control +""" + +ida_hexrays.MBL_PRIV +""" +the specified are accepted (used in patterns) + +private block - no instructions except +""" + +ida_hexrays.MBL_PROP +""" +needs 'propagation' pass +""" + +ida_hexrays.MBL_PUSH +""" +needs "convert push/pop instructions" +""" + +ida_hexrays.MBL_TCAL +""" +aritifical call block for tail calls +""" + +ida_hexrays.MBL_VALRANGES +""" +should optimize using value ranges +""" + +ida_hexrays.NALT_VD +""" +this index is not used by ida +""" + ida_hexrays.NF_BINVDONE """ temporary internal bit: inverting bits is done @@ -23352,6 +30396,51 @@ ida_hexrays.NF_STROFF internal bit: used as stroff, valid iff 'is_stroff()' """ +ida_hexrays.OPROP_CCFLAGS +""" +condition codes register value +""" + +ida_hexrays.OPROP_FLOAT +""" +possibly floating value +""" + +ida_hexrays.OPROP_IMPDONE +""" +imported operand (a pointer) has been dereferenced +""" + +ida_hexrays.OPROP_UDEFVAL +""" +uses undefined value +""" + +ida_hexrays.OPROP_UDT +""" +a struct or union +""" + +ida_hexrays.OPTI_ADDREXPRS +""" +optimize all address expressions (&x+N; &x-&y) +""" + +ida_hexrays.OPTI_COMBINSNS +""" +may combine insns (only for optimize_insn) +""" + +ida_hexrays.OPTI_MINSTKREF +""" +may update minstkref +""" + +ida_hexrays.OPTI_NO_LDXOPT +""" +do not optimize low/high(ldx) +""" + ida_hexrays.SHINS_LDXEA """ display address of ldx expressions (not used) @@ -23436,6 +30525,26 @@ ida_hexrays.VDUI_VISIBLE """ is visible? """ + +ida_hexrays.VR_AT_END +""" +get value ranges after the instruction or at the block end, just after +the last instruction (if M is NULL) +""" + +ida_hexrays.VR_AT_START +""" +at the block start (if M is NULL) + +get value ranges before the instruction or +""" + +ida_hexrays.VR_EXACT +""" +valrng size will be >= vivl.size + +find exact match. if not set, the returned +""" === ida_hexrays EPYDOC INJECTIONS END === ida_ida.calc_default_idaplace_flags(): @@ -23459,11 +30568,6 @@ ida_ida.compiler_info_t.defalign: ida_ida.compiler_info_t.id: compiler_info_t_id_get(self) -> comp_t -ida_ida.compiler_info_t.set_64bit_pointer_size(): - - set_64bit_pointer_size(self) - - ida_ida.compiler_info_t.size_b: compiler_info_t_size_b_get(self) -> uchar @@ -23516,11 +30620,6 @@ ida_ida.idainfo.asmtype: ida_ida.idainfo.baseaddr: idainfo_baseaddr_get(self) -> uval_t -ida_ida.idainfo.big_arg_align(): - - big_arg_align(self) -> bool - - ida_ida.idainfo.bin_prefix_size: idainfo_bin_prefix_size_get(self) -> short @@ -23542,31 +30641,11 @@ ida_ida.idainfo.demnames: ida_ida.idainfo.filetype: idainfo_filetype_get(self) -> ushort -ida_ida.idainfo.gen_lzero(): - - gen_lzero(self) -> bool - - -ida_ida.idainfo.gen_null(): - - gen_null(self) -> bool - - -ida_ida.idainfo.gen_tryblks(): - - gen_tryblks(self) -> bool - - ida_ida.idainfo.get_abiname(): get_abiname(self) -> qstring -ida_ida.idainfo.get_demname_form(): - - get_demname_form(self) -> uchar - - ida_ida.idainfo.get_maxEA(): get_maxEA(self) -> ea_t @@ -23577,11 +30656,6 @@ ida_ida.idainfo.get_minEA(): get_minEA(self) -> ea_t -ida_ida.idainfo.get_pack_mode(): - - get_pack_mode(self) -> int - - ida_ida.idainfo.get_procName(): get_procName(self) -> qstring @@ -23593,90 +30667,15 @@ ida_ida.idainfo.highoff: ida_ida.idainfo.indent: idainfo_indent_get(self) -> uchar -ida_ida.idainfo.is_32bit(): - - is_32bit(self) -> bool - - -ida_ida.idainfo.is_64bit(): - - is_64bit(self) -> bool - - -ida_ida.idainfo.is_auto_enabled(): - - is_auto_enabled(self) -> bool - - -ida_ida.idainfo.is_be(): - - is_be(self) -> bool - - -ida_ida.idainfo.is_dll(): - - is_dll(self) -> bool - - -ida_ida.idainfo.is_flat_off32(): - - is_flat_off32(self) -> bool - - -ida_ida.idainfo.is_graph_view(): - - is_graph_view(self) -> bool - - -ida_ida.idainfo.is_hard_float(): - - is_hard_float(self) -> bool - - -ida_ida.idainfo.is_kernel_mode(): - - is_kernel_mode(self) -> bool - - -ida_ida.idainfo.is_mem_aligned4(): - - is_mem_aligned4(self) -> bool - - -ida_ida.idainfo.is_snapshot(): - - is_snapshot(self) -> bool - - -ida_ida.idainfo.is_wide_high_byte_first(): - - is_wide_high_byte_first(self) -> bool - - ida_ida.idainfo.lenxref: idainfo_lenxref_get(self) -> ushort ida_ida.idainfo.lflags: idainfo_lflags_get(self) -> uint32 -ida_ida.idainfo.like_binary(): - - like_binary(self) -> bool - - -ida_ida.idainfo.line_pref_with_seg(): - - line_pref_with_seg(self) -> bool - - ida_ida.idainfo.listnames: idainfo_listnames_get(self) -> uchar -ida_ida.idainfo.loading_idc(): - - loading_idc(self) -> bool - - ida_ida.idainfo.long_demnames: idainfo_long_demnames_get(self) -> uint32 @@ -23726,11 +30725,6 @@ ida_ida.idainfo.ostype: ida_ida.idainfo.outflags: idainfo_outflags_get(self) -> uint32 -ida_ida.idainfo.pack_stkargs(): - - pack_stkargs(self) -> bool - - ida_ida.idainfo.procName: get_procName(self) -> qstring @@ -23739,11 +30733,6 @@ ida_ida.idainfo.procName: ida_ida.idainfo.procname: idainfo_procname_get(self) -> char [16] -ida_ida.idainfo.readonly_idb(): - - readonly_idb(self) -> bool - - ida_ida.idainfo.refcmtnum: idainfo_refcmtnum_get(self) -> uchar @@ -23762,46 +30751,6 @@ ida_ida.idainfo.s_prefflag: ida_ida.idainfo.s_xrefflag: idainfo_s_xrefflag_get(self) -> uchar -ida_ida.idainfo.set_64bit(): - - set_64bit(self) - - -ida_ida.idainfo.set_auto_enabled(): - - set_auto_enabled(self, value) - - -ida_ida.idainfo.set_be(): - - set_be(self, value) -> bool - - -ida_ida.idainfo.set_gen_lzero(): - - set_gen_lzero(self, value) - - -ida_ida.idainfo.set_gen_null(): - - set_gen_null(self, value) - - -ida_ida.idainfo.set_gen_tryblks(): - - set_gen_tryblks(self, value) - - -ida_ida.idainfo.set_graph_view(): - - set_graph_view(self, value) - - -ida_ida.idainfo.set_line_pref_with_seg(): - - set_line_pref_with_seg(self, value) - - ida_ida.idainfo.set_maxEA(): set_maxEA(self, ea) @@ -23812,62 +30761,12 @@ ida_ida.idainfo.set_minEA(): set_minEA(self, ea) -ida_ida.idainfo.set_pack_mode(): - - set_pack_mode(self, pack_mode) -> int - - -ida_ida.idainfo.set_show_auto(): - - set_show_auto(self, value) - - -ida_ida.idainfo.set_show_line_pref(): - - set_show_line_pref(self, value) - - -ida_ida.idainfo.set_show_void(): - - set_show_void(self, value) - - -ida_ida.idainfo.set_wide_high_byte_first(): - - set_wide_high_byte_first(self, value) - - ida_ida.idainfo.short_demnames: idainfo_short_demnames_get(self) -> uint32 -ida_ida.idainfo.show_auto(): - - show_auto(self) -> bool - - -ida_ida.idainfo.show_line_pref(): - - show_line_pref(self) -> bool - - -ida_ida.idainfo.show_void(): - - show_void(self) -> bool - - ida_ida.idainfo.specsegs: idainfo_specsegs_get(self) -> uchar -ida_ida.idainfo.stack_ldbl(): - - stack_ldbl(self) -> bool - - -ida_ida.idainfo.stack_varargs(): - - stack_varargs(self) -> bool - - ida_ida.idainfo.start_cs: idainfo_start_cs_get(self) -> sel_t @@ -23907,60 +30806,1999 @@ ida_ida.idainfo.tag: ida_ida.idainfo.type_xrefnum: idainfo_type_xrefnum_get(self) -> uchar -ida_ida.idainfo.use_allasm(): - - use_allasm(self) -> bool - - -ida_ida.idainfo.use_gcc_layout(): - - use_gcc_layout(self) -> bool - - ida_ida.idainfo.version: idainfo_version_get(self) -> ushort ida_ida.idainfo.xrefnum: idainfo_xrefnum_get(self) -> uchar +ida_ida.idainfo_big_arg_align(): + + inf_big_arg_align() -> bool + + +ida_ida.idainfo_gen_lzero(): + + inf_gen_lzero() -> bool + + +ida_ida.idainfo_gen_null(): + + inf_gen_null() -> bool + + +ida_ida.idainfo_gen_tryblks(): + + inf_gen_tryblks() -> bool + + +ida_ida.idainfo_get_demname_form(): + + inf_get_demname_form() -> uchar + + + Get 'DEMNAM_MASK' bits of #demnames. + + +ida_ida.idainfo_get_pack_mode(): + + inf_get_pack_mode() -> int + + +ida_ida.idainfo_is_32bit(): + + inf_is_32bit() -> bool + + +ida_ida.idainfo_is_64bit(): + + inf_is_64bit() -> bool + + +ida_ida.idainfo_is_auto_enabled(): + + inf_is_auto_enabled() -> bool + + +ida_ida.idainfo_is_be(): + + inf_is_be() -> bool + + +ida_ida.idainfo_is_dll(): + + inf_is_dll() -> bool + + +ida_ida.idainfo_is_flat_off32(): + + inf_is_flat_off32() -> bool + + +ida_ida.idainfo_is_graph_view(): + + inf_is_graph_view() -> bool + + +ida_ida.idainfo_is_hard_float(): + + inf_is_hard_float() -> bool + + +ida_ida.idainfo_is_kernel_mode(): + + inf_is_kernel_mode() -> bool + + +ida_ida.idainfo_is_mem_aligned4(): + + inf_is_mem_aligned4() -> bool + + +ida_ida.idainfo_is_snapshot(): + + inf_is_snapshot() -> bool + + +ida_ida.idainfo_is_wide_high_byte_first(): + + inf_is_wide_high_byte_first() -> bool + + +ida_ida.idainfo_like_binary(): + + inf_like_binary() -> bool + + +ida_ida.idainfo_line_pref_with_seg(): + + inf_line_pref_with_seg() -> bool + + +ida_ida.idainfo_loading_idc(): + + inf_loading_idc() -> bool + + +ida_ida.idainfo_map_stkargs(): + + inf_map_stkargs() -> bool + + +ida_ida.idainfo_pack_stkargs(): + + inf_pack_stkargs() -> bool + + +ida_ida.idainfo_readonly_idb(): + + inf_readonly_idb() -> bool + + +ida_ida.idainfo_set_64bit(): + + inf_set_64bit(_v=True) -> bool + + +ida_ida.idainfo_set_auto_enabled(): + + inf_set_auto_enabled(_v=True) -> bool + + +ida_ida.idainfo_set_be(): + + inf_set_be(_v=True) -> bool + + +ida_ida.idainfo_set_gen_lzero(): + + inf_set_gen_lzero(_v=True) -> bool + + +ida_ida.idainfo_set_gen_null(): + + inf_set_gen_null(_v=True) -> bool + + +ida_ida.idainfo_set_gen_tryblks(): + + inf_set_gen_tryblks(_v=True) -> bool + + +ida_ida.idainfo_set_graph_view(): + + inf_set_graph_view(_v=True) -> bool + + +ida_ida.idainfo_set_line_pref_with_seg(): + + inf_set_line_pref_with_seg(_v=True) -> bool + + +ida_ida.idainfo_set_pack_mode(): + + inf_set_pack_mode(pack_mode) -> int + + +ida_ida.idainfo_set_show_auto(): + + inf_set_show_auto(_v=True) -> bool + + +ida_ida.idainfo_set_show_line_pref(): + + inf_set_show_line_pref(_v=True) -> bool + + +ida_ida.idainfo_set_show_void(): + + inf_set_show_void(_v=True) -> bool + + +ida_ida.idainfo_set_wide_high_byte_first(): + + inf_set_wide_high_byte_first(_v=True) -> bool + + +ida_ida.idainfo_show_auto(): + + inf_show_auto() -> bool + + +ida_ida.idainfo_show_line_pref(): + + inf_show_line_pref() -> bool + + +ida_ida.idainfo_show_void(): + + inf_show_void() -> bool + + +ida_ida.idainfo_stack_ldbl(): + + inf_stack_ldbl() -> bool + + +ida_ida.idainfo_stack_varargs(): + + inf_stack_varargs() -> bool + + +ida_ida.idainfo_use_allasm(): + + inf_use_allasm() -> bool + + +ida_ida.idainfo_use_gcc_layout(): + + inf_use_gcc_layout() -> bool + + +ida_ida.inf_abi_set_by_user(): + + inf_abi_set_by_user() -> bool + + +ida_ida.inf_allow_non_matched_ops(): + + inf_allow_non_matched_ops() -> bool + + +ida_ida.inf_allow_sigmulti(): + + inf_allow_sigmulti() -> bool + + +ida_ida.inf_append_sigcmt(): + + inf_append_sigcmt() -> bool + + +ida_ida.inf_big_arg_align(): + + inf_big_arg_align() -> bool + + +ida_ida.inf_check_manual_ops(): + + inf_check_manual_ops() -> bool + + +ida_ida.inf_check_unicode_strlits(): + + inf_check_unicode_strlits() -> bool + + +ida_ida.inf_coagulate_code(): + + inf_coagulate_code() -> bool + + +ida_ida.inf_coagulate_data(): + + inf_coagulate_data() -> bool + + +ida_ida.inf_compress_idb(): + + inf_compress_idb() -> bool + + +ida_ida.inf_create_all_xrefs(): + + inf_create_all_xrefs() -> bool + + +ida_ida.inf_create_func_from_call(): + + inf_create_func_from_call() -> bool + + +ida_ida.inf_create_func_from_ptr(): + + inf_create_func_from_ptr() -> bool + + +ida_ida.inf_create_func_tails(): + + inf_create_func_tails() -> bool + + +ida_ida.inf_create_jump_tables(): + + inf_create_jump_tables() -> bool + + +ida_ida.inf_create_off_on_dref(): + + inf_create_off_on_dref() -> bool + + +ida_ida.inf_create_off_using_fixup(): + + inf_create_off_using_fixup() -> bool + + +ida_ida.inf_create_strlit_on_xref(): + + inf_create_strlit_on_xref() -> bool + + +ida_ida.inf_data_offset(): + + inf_data_offset() -> bool + + +ida_ida.inf_dbg_no_store_path(): + + inf_dbg_no_store_path() -> bool + + +ida_ida.inf_decode_fpp(): + + inf_decode_fpp() -> bool + + +ida_ida.inf_del_no_xref_insns(): + + inf_del_no_xref_insns() -> bool + + +ida_ida.inf_final_pass(): + + inf_final_pass() -> bool + + +ida_ida.inf_full_sp_ana(): + + inf_full_sp_ana() -> bool + + +ida_ida.inf_gen_assume(): + + inf_gen_assume() -> bool + + +ida_ida.inf_gen_lzero(): + + inf_gen_lzero() -> bool + + +ida_ida.inf_gen_null(): + + inf_gen_null() -> bool + + +ida_ida.inf_gen_org(): + + inf_gen_org() -> bool + + +ida_ida.inf_gen_tryblks(): + + inf_gen_tryblks() -> bool + + +ida_ida.inf_get_abibits(): + + inf_get_abibits() -> uint32 + + +ida_ida.inf_get_af(): + + inf_get_af() -> uint32 + + +ida_ida.inf_get_af2(): + + inf_get_af2() -> uint32 + + +ida_ida.inf_get_af2_low(): + + inf_get_af2_low() -> ushort + + + Get/set low 16bit half of inf.af2. + + +ida_ida.inf_get_af_high(): + + inf_get_af_high() -> ushort + + +ida_ida.inf_get_af_low(): + + inf_get_af_low() -> ushort + + + Get/set low/high 16bit halves of inf.af. + + +ida_ida.inf_get_appcall_options(): + + inf_get_appcall_options() -> uint32 + + +ida_ida.inf_get_apptype(): + + inf_get_apptype() -> ushort + + +ida_ida.inf_get_asmtype(): + + inf_get_asmtype() -> uchar + + +ida_ida.inf_get_baseaddr(): + + inf_get_baseaddr() -> uval_t + + +ida_ida.inf_get_bin_prefix_size(): + + inf_get_bin_prefix_size() -> short + + +ida_ida.inf_get_cc(): + + inf_get_cc(out) -> bool + + +ida_ida.inf_get_cc_cm(): + + inf_get_cc_cm() -> cm_t + + +ida_ida.inf_get_cc_defalign(): + + inf_get_cc_defalign() -> uchar + + +ida_ida.inf_get_cc_id(): + + inf_get_cc_id() -> comp_t + + +ida_ida.inf_get_cc_size_b(): + + inf_get_cc_size_b() -> uchar + + +ida_ida.inf_get_cc_size_e(): + + inf_get_cc_size_e() -> uchar + + +ida_ida.inf_get_cc_size_i(): + + inf_get_cc_size_i() -> uchar + + +ida_ida.inf_get_cc_size_l(): + + inf_get_cc_size_l() -> uchar + + +ida_ida.inf_get_cc_size_ldbl(): + + inf_get_cc_size_ldbl() -> uchar + + +ida_ida.inf_get_cc_size_ll(): + + inf_get_cc_size_ll() -> uchar + + +ida_ida.inf_get_cc_size_s(): + + inf_get_cc_size_s() -> uchar + + +ida_ida.inf_get_cmtflg(): + + inf_get_cmtflg() -> uchar + + +ida_ida.inf_get_comment(): + + inf_get_comment() -> uchar + + +ida_ida.inf_get_database_change_count(): + + inf_get_database_change_count() -> uint32 + + +ida_ida.inf_get_datatypes(): + + inf_get_datatypes() -> uval_t + + +ida_ida.inf_get_demname_form(): + + inf_get_demname_form() -> uchar + + + Get 'DEMNAM_MASK' bits of #demnames. + + +ida_ida.inf_get_demnames(): + + inf_get_demnames() -> uchar + + +ida_ida.inf_get_filetype(): + + inf_get_filetype() -> filetype_t + + +ida_ida.inf_get_genflags(): + + inf_get_genflags() -> ushort + + +ida_ida.inf_get_highoff(): + + inf_get_highoff() -> ea_t + + +ida_ida.inf_get_indent(): + + inf_get_indent() -> uchar + + +ida_ida.inf_get_lenxref(): + + inf_get_lenxref() -> ushort + + +ida_ida.inf_get_lflags(): + + inf_get_lflags() -> uint32 + + +ida_ida.inf_get_limiter(): + + inf_get_limiter() -> uchar + + +ida_ida.inf_get_listnames(): + + inf_get_listnames() -> uchar + + +ida_ida.inf_get_long_demnames(): + + inf_get_long_demnames() -> uint32 + + +ida_ida.inf_get_lowoff(): + + inf_get_lowoff() -> ea_t + + +ida_ida.inf_get_main(): + + inf_get_main() -> ea_t + + +ida_ida.inf_get_margin(): + + inf_get_margin() -> ushort + + +ida_ida.inf_get_max_autoname_len(): + + inf_get_max_autoname_len() -> ushort + + +ida_ida.inf_get_max_ea(): + + inf_get_max_ea() -> ea_t + + +ida_ida.inf_get_maxref(): + + inf_get_maxref() -> uval_t + + +ida_ida.inf_get_min_ea(): + + inf_get_min_ea() -> ea_t + + +ida_ida.inf_get_nametype(): + + inf_get_nametype() -> char + + +ida_ida.inf_get_netdelta(): + + inf_get_netdelta() -> sval_t + + +ida_ida.inf_get_omax_ea(): + + inf_get_omax_ea() -> ea_t + + +ida_ida.inf_get_omin_ea(): + + inf_get_omin_ea() -> ea_t + + +ida_ida.inf_get_ostype(): + + inf_get_ostype() -> ushort + + +ida_ida.inf_get_outflags(): + + inf_get_outflags() -> uint32 + + +ida_ida.inf_get_pack_mode(): + + inf_get_pack_mode() -> int + + +ida_ida.inf_get_prefflag(): + + inf_get_prefflag() -> uchar + + +ida_ida.inf_get_privrange(): + + inf_get_privrange(out) -> bool + inf_get_privrange() -> range_t + + +ida_ida.inf_get_privrange_end_ea(): + + inf_get_privrange_end_ea() -> ea_t + + +ida_ida.inf_get_privrange_start_ea(): + + inf_get_privrange_start_ea() -> ea_t + + +ida_ida.inf_get_procname(): + + inf_get_procname() -> bool + + +ida_ida.inf_get_refcmtnum(): + + inf_get_refcmtnum() -> uchar + + +ida_ida.inf_get_short_demnames(): + + inf_get_short_demnames() -> uint32 + + +ida_ida.inf_get_specsegs(): + + inf_get_specsegs() -> uchar + + +ida_ida.inf_get_start_cs(): + + inf_get_start_cs() -> sel_t + + +ida_ida.inf_get_start_ea(): + + inf_get_start_ea() -> ea_t + + +ida_ida.inf_get_start_ip(): + + inf_get_start_ip() -> ea_t + + +ida_ida.inf_get_start_sp(): + + inf_get_start_sp() -> ea_t + + +ida_ida.inf_get_start_ss(): + + inf_get_start_ss() -> sel_t + + +ida_ida.inf_get_strlit_break(): + + inf_get_strlit_break() -> uchar + + +ida_ida.inf_get_strlit_flags(): + + inf_get_strlit_flags() -> uchar + + +ida_ida.inf_get_strlit_pref(): + + inf_get_strlit_pref() -> bool + + +ida_ida.inf_get_strlit_sernum(): + + inf_get_strlit_sernum() -> uval_t + + +ida_ida.inf_get_strlit_zeroes(): + + inf_get_strlit_zeroes() -> char + + +ida_ida.inf_get_strtype(): + + inf_get_strtype() -> int32 + + +ida_ida.inf_get_type_xrefnum(): + + inf_get_type_xrefnum() -> uchar + + +ida_ida.inf_get_version(): + + inf_get_version() -> ushort + + +ida_ida.inf_get_xrefflag(): + + inf_get_xrefflag() -> uchar + + +ida_ida.inf_get_xrefnum(): + + inf_get_xrefnum() -> uchar + + +ida_ida.inf_guess_func_type(): + + inf_guess_func_type() -> bool + + +ida_ida.inf_handle_eh(): + + inf_handle_eh() -> bool + + +ida_ida.inf_handle_rtti(): + + inf_handle_rtti() -> bool + + +ida_ida.inf_hide_comments(): + + inf_hide_comments() -> bool + + +ida_ida.inf_hide_libfuncs(): + + inf_hide_libfuncs() -> bool + + +ida_ida.inf_inc_database_change_count(): + + inf_inc_database_change_count(cnt=1) + + +ida_ida.inf_is_32bit(): + + inf_is_32bit() -> bool + + +ida_ida.inf_is_64bit(): + + inf_is_64bit() -> bool + + +ida_ida.inf_is_auto_enabled(): + + inf_is_auto_enabled() -> bool + + +ida_ida.inf_is_be(): + + inf_is_be() -> bool + + +ida_ida.inf_is_dll(): + + inf_is_dll() -> bool + + +ida_ida.inf_is_flat_off32(): + + inf_is_flat_off32() -> bool + + +ida_ida.inf_is_graph_view(): + + inf_is_graph_view() -> bool + + +ida_ida.inf_is_hard_float(): + + inf_is_hard_float() -> bool + + +ida_ida.inf_is_kernel_mode(): + + inf_is_kernel_mode() -> bool + + +ida_ida.inf_is_limiter_empty(): + + inf_is_limiter_empty() -> bool + + +ida_ida.inf_is_limiter_thick(): + + inf_is_limiter_thick() -> bool + + +ida_ida.inf_is_limiter_thin(): + + inf_is_limiter_thin() -> bool + + +ida_ida.inf_is_mem_aligned4(): + + inf_is_mem_aligned4() -> bool + + +ida_ida.inf_is_snapshot(): + + inf_is_snapshot() -> bool + + +ida_ida.inf_is_wide_high_byte_first(): + + inf_is_wide_high_byte_first() -> bool + + +ida_ida.inf_like_binary(): + + inf_like_binary() -> bool + + +ida_ida.inf_line_pref_with_seg(): + + inf_line_pref_with_seg() -> bool + + +ida_ida.inf_loading_idc(): + + inf_loading_idc() -> bool + + +ida_ida.inf_macros_enabled(): + + inf_macros_enabled() -> bool + + +ida_ida.inf_map_stkargs(): + + inf_map_stkargs() -> bool + + +ida_ida.inf_mark_code(): + + inf_mark_code() -> bool + + +ida_ida.inf_no_store_user_info(): + + inf_no_store_user_info() -> bool + + +ida_ida.inf_noflow_to_data(): + + inf_noflow_to_data() -> bool + + +ida_ida.inf_noret_ana(): + + inf_noret_ana() -> bool + + +ida_ida.inf_op_offset(): + + inf_op_offset() -> bool + + +ida_ida.inf_pack_idb(): + + inf_pack_idb() -> bool + + +ida_ida.inf_pack_stkargs(): + + inf_pack_stkargs() -> bool + + +ida_ida.inf_postinc_strlit_sernum(): + + inf_postinc_strlit_sernum(cnt=1) -> uval_t + + +ida_ida.inf_prefix_show_funcoff(): + + inf_prefix_show_funcoff() -> bool + + +ida_ida.inf_prefix_show_segaddr(): + + inf_prefix_show_segaddr() -> bool + + +ida_ida.inf_prefix_show_stack(): + + inf_prefix_show_stack() -> bool + + +ida_ida.inf_propagate_regargs(): + + inf_propagate_regargs() -> bool + + +ida_ida.inf_propagate_stkargs(): + + inf_propagate_stkargs() -> bool + + +ida_ida.inf_readonly_idb(): + + inf_readonly_idb() -> bool + + +ida_ida.inf_rename_jumpfunc(): + + inf_rename_jumpfunc() -> bool + + +ida_ida.inf_rename_nullsub(): + + inf_rename_nullsub() -> bool + + +ida_ida.inf_set_32bit(): + + inf_set_32bit(_v=True) -> bool + + +ida_ida.inf_set_64bit(): + + inf_set_64bit(_v=True) -> bool + + +ida_ida.inf_set_abi_set_by_user(): + + inf_set_abi_set_by_user(_v=True) -> bool + + +ida_ida.inf_set_abibits(): + + inf_set_abibits(_v) -> bool + + +ida_ida.inf_set_af(): + + inf_set_af(_v) -> bool + + +ida_ida.inf_set_af2(): + + inf_set_af2(_v) -> bool + + +ida_ida.inf_set_af2_low(): + + inf_set_af2_low(saf) + + +ida_ida.inf_set_af_high(): + + inf_set_af_high(saf2) + + +ida_ida.inf_set_af_low(): + + inf_set_af_low(saf) + + +ida_ida.inf_set_allow_non_matched_ops(): + + inf_set_allow_non_matched_ops(_v=True) -> bool + + +ida_ida.inf_set_allow_sigmulti(): + + inf_set_allow_sigmulti(_v=True) -> bool + + +ida_ida.inf_set_appcall_options(): + + inf_set_appcall_options(_v) -> bool + + +ida_ida.inf_set_append_sigcmt(): + + inf_set_append_sigcmt(_v=True) -> bool + + +ida_ida.inf_set_apptype(): + + inf_set_apptype(_v) -> bool + + +ida_ida.inf_set_asmtype(): + + inf_set_asmtype(_v) -> bool + + +ida_ida.inf_set_auto_enabled(): + + inf_set_auto_enabled(_v=True) -> bool + + +ida_ida.inf_set_baseaddr(): + + inf_set_baseaddr(_v) -> bool + + +ida_ida.inf_set_be(): + + inf_set_be(_v=True) -> bool + + +ida_ida.inf_set_big_arg_align(): + + inf_set_big_arg_align(_v=True) -> bool + + +ida_ida.inf_set_bin_prefix_size(): + + inf_set_bin_prefix_size(_v) -> bool + + +ida_ida.inf_set_cc(): + + inf_set_cc(_v) -> bool + + +ida_ida.inf_set_cc_cm(): + + inf_set_cc_cm(_v) -> bool + + +ida_ida.inf_set_cc_defalign(): + + inf_set_cc_defalign(_v) -> bool + + +ida_ida.inf_set_cc_id(): + + inf_set_cc_id(_v) -> bool + + +ida_ida.inf_set_cc_size_b(): + + inf_set_cc_size_b(_v) -> bool + + +ida_ida.inf_set_cc_size_e(): + + inf_set_cc_size_e(_v) -> bool + + +ida_ida.inf_set_cc_size_i(): + + inf_set_cc_size_i(_v) -> bool + + +ida_ida.inf_set_cc_size_l(): + + inf_set_cc_size_l(_v) -> bool + + +ida_ida.inf_set_cc_size_ldbl(): + + inf_set_cc_size_ldbl(_v) -> bool + + +ida_ida.inf_set_cc_size_ll(): + + inf_set_cc_size_ll(_v) -> bool + + +ida_ida.inf_set_cc_size_s(): + + inf_set_cc_size_s(_v) -> bool + + +ida_ida.inf_set_check_manual_ops(): + + inf_set_check_manual_ops(_v=True) -> bool + + +ida_ida.inf_set_check_unicode_strlits(): + + inf_set_check_unicode_strlits(_v=True) -> bool + + +ida_ida.inf_set_cmtflg(): + + inf_set_cmtflg(_v) -> bool + + +ida_ida.inf_set_coagulate_code(): + + inf_set_coagulate_code(_v=True) -> bool + + +ida_ida.inf_set_coagulate_data(): + + inf_set_coagulate_data(_v=True) -> bool + + +ida_ida.inf_set_comment(): + + inf_set_comment(_v) -> bool + + +ida_ida.inf_set_compress_idb(): + + inf_set_compress_idb(_v=True) -> bool + + +ida_ida.inf_set_create_all_xrefs(): + + inf_set_create_all_xrefs(_v=True) -> bool + + +ida_ida.inf_set_create_func_from_call(): + + inf_set_create_func_from_call(_v=True) -> bool + + +ida_ida.inf_set_create_func_from_ptr(): + + inf_set_create_func_from_ptr(_v=True) -> bool + + +ida_ida.inf_set_create_func_tails(): + + inf_set_create_func_tails(_v=True) -> bool + + +ida_ida.inf_set_create_jump_tables(): + + inf_set_create_jump_tables(_v=True) -> bool + + +ida_ida.inf_set_create_off_on_dref(): + + inf_set_create_off_on_dref(_v=True) -> bool + + +ida_ida.inf_set_create_off_using_fixup(): + + inf_set_create_off_using_fixup(_v=True) -> bool + + +ida_ida.inf_set_create_strlit_on_xref(): + + inf_set_create_strlit_on_xref(_v=True) -> bool + + +ida_ida.inf_set_data_offset(): + + inf_set_data_offset(_v=True) -> bool + + +ida_ida.inf_set_database_change_count(): + + inf_set_database_change_count(_v) -> bool + + +ida_ida.inf_set_datatypes(): + + inf_set_datatypes(_v) -> bool + + +ida_ida.inf_set_dbg_no_store_path(): + + inf_set_dbg_no_store_path(_v=True) -> bool + + +ida_ida.inf_set_decode_fpp(): + + inf_set_decode_fpp(_v=True) -> bool + + +ida_ida.inf_set_del_no_xref_insns(): + + inf_set_del_no_xref_insns(_v=True) -> bool + + +ida_ida.inf_set_demnames(): + + inf_set_demnames(_v) -> bool + + +ida_ida.inf_set_dll(): + + inf_set_dll(_v=True) -> bool + + +ida_ida.inf_set_filetype(): + + inf_set_filetype(_v) -> bool + + +ida_ida.inf_set_final_pass(): + + inf_set_final_pass(_v=True) -> bool + + +ida_ida.inf_set_flat_off32(): + + inf_set_flat_off32(_v=True) -> bool + + +ida_ida.inf_set_full_sp_ana(): + + inf_set_full_sp_ana(_v=True) -> bool + + +ida_ida.inf_set_gen_assume(): + + inf_set_gen_assume(_v=True) -> bool + + +ida_ida.inf_set_gen_lzero(): + + inf_set_gen_lzero(_v=True) -> bool + + +ida_ida.inf_set_gen_null(): + + inf_set_gen_null(_v=True) -> bool + + +ida_ida.inf_set_gen_org(): + + inf_set_gen_org(_v=True) -> bool + + +ida_ida.inf_set_gen_tryblks(): + + inf_set_gen_tryblks(_v=True) -> bool + + +ida_ida.inf_set_genflags(): + + inf_set_genflags(_v) -> bool + + +ida_ida.inf_set_graph_view(): + + inf_set_graph_view(_v=True) -> bool + + +ida_ida.inf_set_guess_func_type(): + + inf_set_guess_func_type(_v=True) -> bool + + +ida_ida.inf_set_handle_eh(): + + inf_set_handle_eh(_v=True) -> bool + + +ida_ida.inf_set_handle_rtti(): + + inf_set_handle_rtti(_v=True) -> bool + + +ida_ida.inf_set_hard_float(): + + inf_set_hard_float(_v=True) -> bool + + +ida_ida.inf_set_hide_comments(): + + inf_set_hide_comments(_v=True) -> bool + + +ida_ida.inf_set_hide_libfuncs(): + + inf_set_hide_libfuncs(_v=True) -> bool + + +ida_ida.inf_set_highoff(): + + inf_set_highoff(_v) -> bool + + +ida_ida.inf_set_indent(): + + inf_set_indent(_v) -> bool + + +ida_ida.inf_set_kernel_mode(): + + inf_set_kernel_mode(_v=True) -> bool + + +ida_ida.inf_set_lenxref(): + + inf_set_lenxref(_v) -> bool + + +ida_ida.inf_set_lflags(): + + inf_set_lflags(_v) -> bool + + +ida_ida.inf_set_limiter(): + + inf_set_limiter(_v) -> bool + + +ida_ida.inf_set_limiter_empty(): + + inf_set_limiter_empty(_v=True) -> bool + + +ida_ida.inf_set_limiter_thick(): + + inf_set_limiter_thick(_v=True) -> bool + + +ida_ida.inf_set_limiter_thin(): + + inf_set_limiter_thin(_v=True) -> bool + + +ida_ida.inf_set_line_pref_with_seg(): + + inf_set_line_pref_with_seg(_v=True) -> bool + + +ida_ida.inf_set_listnames(): + + inf_set_listnames(_v) -> bool + + +ida_ida.inf_set_loading_idc(): + + inf_set_loading_idc(_v=True) -> bool + + +ida_ida.inf_set_long_demnames(): + + inf_set_long_demnames(_v) -> bool + + +ida_ida.inf_set_lowoff(): + + inf_set_lowoff(_v) -> bool + + +ida_ida.inf_set_macros_enabled(): + + inf_set_macros_enabled(_v=True) -> bool + + +ida_ida.inf_set_main(): + + inf_set_main(_v) -> bool + + +ida_ida.inf_set_map_stkargs(): + + inf_set_map_stkargs(_v=True) -> bool + + +ida_ida.inf_set_margin(): + + inf_set_margin(_v) -> bool + + +ida_ida.inf_set_mark_code(): + + inf_set_mark_code(_v=True) -> bool + + +ida_ida.inf_set_max_autoname_len(): + + inf_set_max_autoname_len(_v) -> bool + + +ida_ida.inf_set_max_ea(): + + inf_set_max_ea(_v) -> bool + + +ida_ida.inf_set_maxref(): + + inf_set_maxref(_v) -> bool + + +ida_ida.inf_set_mem_aligned4(): + + inf_set_mem_aligned4(_v=True) -> bool + + +ida_ida.inf_set_min_ea(): + + inf_set_min_ea(_v) -> bool + + +ida_ida.inf_set_nametype(): + + inf_set_nametype(_v) -> bool + + +ida_ida.inf_set_netdelta(): + + inf_set_netdelta(_v) -> bool + + +ida_ida.inf_set_no_store_user_info(): + + inf_set_no_store_user_info(_v=True) -> bool + + +ida_ida.inf_set_noflow_to_data(): + + inf_set_noflow_to_data(_v=True) -> bool + + +ida_ida.inf_set_noret_ana(): + + inf_set_noret_ana(_v=True) -> bool + + +ida_ida.inf_set_omax_ea(): + + inf_set_omax_ea(_v) -> bool + + +ida_ida.inf_set_omin_ea(): + + inf_set_omin_ea(_v) -> bool + + +ida_ida.inf_set_op_offset(): + + inf_set_op_offset(_v=True) -> bool + + +ida_ida.inf_set_ostype(): + + inf_set_ostype(_v) -> bool + + +ida_ida.inf_set_outflags(): + + inf_set_outflags(_v) -> bool + + +ida_ida.inf_set_pack_idb(): + + inf_set_pack_idb(_v=True) -> bool + + +ida_ida.inf_set_pack_mode(): + + inf_set_pack_mode(pack_mode) -> int + + +ida_ida.inf_set_pack_stkargs(): + + inf_set_pack_stkargs(_v=True) -> bool + + +ida_ida.inf_set_prefflag(): + + inf_set_prefflag(_v) -> bool + + +ida_ida.inf_set_prefix_show_funcoff(): + + inf_set_prefix_show_funcoff(_v=True) -> bool + + +ida_ida.inf_set_prefix_show_segaddr(): + + inf_set_prefix_show_segaddr(_v=True) -> bool + + +ida_ida.inf_set_prefix_show_stack(): + + inf_set_prefix_show_stack(_v=True) -> bool + + +ida_ida.inf_set_privrange(): + + inf_set_privrange(_v) -> bool + + +ida_ida.inf_set_privrange_end_ea(): + + inf_set_privrange_end_ea(_v) -> bool + + +ida_ida.inf_set_privrange_start_ea(): + + inf_set_privrange_start_ea(_v) -> bool + + +ida_ida.inf_set_procname(): + + inf_set_procname(_v, len=size_t(-1)) -> bool + + +ida_ida.inf_set_propagate_regargs(): + + inf_set_propagate_regargs(_v=True) -> bool + + +ida_ida.inf_set_propagate_stkargs(): + + inf_set_propagate_stkargs(_v=True) -> bool + + +ida_ida.inf_set_readonly_idb(): + + inf_set_readonly_idb(_v=True) -> bool + + +ida_ida.inf_set_refcmtnum(): + + inf_set_refcmtnum(_v) -> bool + + +ida_ida.inf_set_rename_jumpfunc(): + + inf_set_rename_jumpfunc(_v=True) -> bool + + +ida_ida.inf_set_rename_nullsub(): + + inf_set_rename_nullsub(_v=True) -> bool + + +ida_ida.inf_set_short_demnames(): + + inf_set_short_demnames(_v) -> bool + + +ida_ida.inf_set_should_create_stkvars(): + + inf_set_should_create_stkvars(_v=True) -> bool + + +ida_ida.inf_set_should_trace_sp(): + + inf_set_should_trace_sp(_v=True) -> bool + + +ida_ida.inf_set_show_all_comments(): + + inf_set_show_all_comments(_v=True) -> bool + + +ida_ida.inf_set_show_auto(): + + inf_set_show_auto(_v=True) -> bool + + +ida_ida.inf_set_show_hidden_funcs(): + + inf_set_show_hidden_funcs(_v=True) -> bool + + +ida_ida.inf_set_show_hidden_insns(): + + inf_set_show_hidden_insns(_v=True) -> bool + + +ida_ida.inf_set_show_hidden_segms(): + + inf_set_show_hidden_segms(_v=True) -> bool + + +ida_ida.inf_set_show_line_pref(): + + inf_set_show_line_pref(_v=True) -> bool + + +ida_ida.inf_set_show_repeatables(): + + inf_set_show_repeatables(_v=True) -> bool + + +ida_ida.inf_set_show_src_linnum(): + + inf_set_show_src_linnum(_v=True) -> bool + + +ida_ida.inf_set_show_void(): + + inf_set_show_void(_v=True) -> bool + + +ida_ida.inf_set_show_xref_fncoff(): + + inf_set_show_xref_fncoff(_v=True) -> bool + + +ida_ida.inf_set_show_xref_seg(): + + inf_set_show_xref_seg(_v=True) -> bool + + +ida_ida.inf_set_show_xref_tmarks(): + + inf_set_show_xref_tmarks(_v=True) -> bool + + +ida_ida.inf_set_show_xref_val(): + + inf_set_show_xref_val(_v=True) -> bool + + +ida_ida.inf_set_snapshot(): + + inf_set_snapshot(_v=True) -> bool + + +ida_ida.inf_set_specsegs(): + + inf_set_specsegs(_v) -> bool + + +ida_ida.inf_set_stack_ldbl(): + + inf_set_stack_ldbl(_v=True) -> bool + + +ida_ida.inf_set_stack_varargs(): + + inf_set_stack_varargs(_v=True) -> bool + + +ida_ida.inf_set_start_cs(): + + inf_set_start_cs(_v) -> bool + + +ida_ida.inf_set_start_ea(): + + inf_set_start_ea(_v) -> bool + + +ida_ida.inf_set_start_ip(): + + inf_set_start_ip(_v) -> bool + + +ida_ida.inf_set_start_sp(): + + inf_set_start_sp(_v) -> bool + + +ida_ida.inf_set_start_ss(): + + inf_set_start_ss(_v) -> bool + + +ida_ida.inf_set_strlit_autocmt(): + + inf_set_strlit_autocmt(_v=True) -> bool + + +ida_ida.inf_set_strlit_break(): + + inf_set_strlit_break(_v) -> bool + + +ida_ida.inf_set_strlit_flags(): + + inf_set_strlit_flags(_v) -> bool + + +ida_ida.inf_set_strlit_name_bit(): + + inf_set_strlit_name_bit(_v=True) -> bool + + +ida_ida.inf_set_strlit_names(): + + inf_set_strlit_names(_v=True) -> bool + + +ida_ida.inf_set_strlit_pref(): + + inf_set_strlit_pref(_v, len=size_t(-1)) -> bool + + +ida_ida.inf_set_strlit_savecase(): + + inf_set_strlit_savecase(_v=True) -> bool + + +ida_ida.inf_set_strlit_serial_names(): + + inf_set_strlit_serial_names(_v=True) -> bool + + +ida_ida.inf_set_strlit_sernum(): + + inf_set_strlit_sernum(_v) -> bool + + +ida_ida.inf_set_strlit_zeroes(): + + inf_set_strlit_zeroes(_v) -> bool + + +ida_ida.inf_set_strtype(): + + inf_set_strtype(_v) -> bool + + +ida_ida.inf_set_test_mode(): + + inf_set_test_mode(_v=True) -> bool + + +ida_ida.inf_set_trace_flow(): + + inf_set_trace_flow(_v=True) -> bool + + +ida_ida.inf_set_truncate_on_del(): + + inf_set_truncate_on_del(_v=True) -> bool + + +ida_ida.inf_set_type_xrefnum(): + + inf_set_type_xrefnum(_v) -> bool + + +ida_ida.inf_set_unicode_strlits(): + + inf_set_unicode_strlits(_v=True) -> bool + + +ida_ida.inf_set_use_allasm(): + + inf_set_use_allasm(_v=True) -> bool + + +ida_ida.inf_set_use_flirt(): + + inf_set_use_flirt(_v=True) -> bool + + +ida_ida.inf_set_use_gcc_layout(): + + inf_set_use_gcc_layout(_v=True) -> bool + + +ida_ida.inf_set_version(): + + inf_set_version(_v) -> bool + + +ida_ida.inf_set_wide_high_byte_first(): + + inf_set_wide_high_byte_first(_v=True) -> bool + + +ida_ida.inf_set_xrefflag(): + + inf_set_xrefflag(_v) -> bool + + +ida_ida.inf_set_xrefnum(): + + inf_set_xrefnum(_v) -> bool + + +ida_ida.inf_should_create_stkvars(): + + inf_should_create_stkvars() -> bool + + +ida_ida.inf_should_trace_sp(): + + inf_should_trace_sp() -> bool + + +ida_ida.inf_show_all_comments(): + + inf_show_all_comments() -> bool + + +ida_ida.inf_show_auto(): + + inf_show_auto() -> bool + + +ida_ida.inf_show_hidden_funcs(): + + inf_show_hidden_funcs() -> bool + + +ida_ida.inf_show_hidden_insns(): + + inf_show_hidden_insns() -> bool + + +ida_ida.inf_show_hidden_segms(): + + inf_show_hidden_segms() -> bool + + +ida_ida.inf_show_line_pref(): + + inf_show_line_pref() -> bool + + +ida_ida.inf_show_repeatables(): + + inf_show_repeatables() -> bool + + +ida_ida.inf_show_src_linnum(): + + inf_show_src_linnum() -> bool + + +ida_ida.inf_show_void(): + + inf_show_void() -> bool + + +ida_ida.inf_show_xref_fncoff(): + + inf_show_xref_fncoff() -> bool + + +ida_ida.inf_show_xref_seg(): + + inf_show_xref_seg() -> bool + + +ida_ida.inf_show_xref_tmarks(): + + inf_show_xref_tmarks() -> bool + + +ida_ida.inf_show_xref_val(): + + inf_show_xref_val() -> bool + + +ida_ida.inf_stack_ldbl(): + + inf_stack_ldbl() -> bool + + +ida_ida.inf_stack_varargs(): + + inf_stack_varargs() -> bool + + +ida_ida.inf_strlit_autocmt(): + + inf_strlit_autocmt() -> bool + + +ida_ida.inf_strlit_name_bit(): + + inf_strlit_name_bit() -> bool + + +ida_ida.inf_strlit_names(): + + inf_strlit_names() -> bool + + +ida_ida.inf_strlit_savecase(): + + inf_strlit_savecase() -> bool + + +ida_ida.inf_strlit_serial_names(): + + inf_strlit_serial_names() -> bool + + +ida_ida.inf_test_mode(): + + inf_test_mode() -> bool + + +ida_ida.inf_trace_flow(): + + inf_trace_flow() -> bool + + +ida_ida.inf_truncate_on_del(): + + inf_truncate_on_del() -> bool + + +ida_ida.inf_unicode_strlits(): + + inf_unicode_strlits() -> bool + + +ida_ida.inf_use_allasm(): + + inf_use_allasm() -> bool + + +ida_ida.inf_use_flirt(): + + inf_use_flirt() -> bool + + +ida_ida.inf_use_gcc_layout(): + + inf_use_gcc_layout() -> bool + + +ida_ida.is_filetype_like_binary(): + + is_filetype_like_binary(ft) -> bool + + + Is unstructured input file? + + + @param ft (C++: filetype_t) + + +ida_ida.macros_enabled(): + + inf_macros_enabled() -> bool + + ida_ida.should_create_stkvars(): - should_create_stkvars() -> bool - - - Is IDA configured to create stack variables? + inf_should_create_stkvars() -> bool ida_ida.should_trace_sp(): - should_trace_sp() -> bool - - - Is IDA configured to trace the stack pointer? + inf_should_trace_sp() -> bool ida_ida.show_all_comments(): - show_all_comments() -> bool - - - Is IDA configured to show all comment lines? - - -ida_ida.show_comments(): - - show_comments() -> bool - - - Is IDA configured to show any comments at all? + inf_show_all_comments() -> bool ida_ida.show_repeatables(): - show_repeatables() -> bool - - - Is IDA configured to show all repeatable comments? + inf_show_repeatables() -> bool ida_ida.to_ea(): @@ -24001,6 +32839,11 @@ ida_ida.ABI_HARD_FLOAT use the floating-point register set """ +ida_ida.ABI_MAP_STKARGS +""" +register arguments are mapped to stack area (and consume stack slots) +""" + ida_ida.ABI_PACK_STKARGS """ do not align stack arguments to stack slots @@ -24014,7 +32857,7 @@ be changed ida_ida.ABI_STACK_LDBL """ -long double areuments are passed on stack +long double arguments are passed on stack """ ida_ida.ABI_STACK_VARARGS @@ -24030,7 +32873,12 @@ Handle EH information. ida_ida.AF2_DORTTI """ -Handle RTTI information +Handle RTTI information. +""" + +ida_ida.AF2_MACRO +""" +Try to combine several instructions into a macro instruction """ ida_ida.AF_ANORET @@ -24191,7 +33039,7 @@ Analyze and create all xrefs. ida_ida.AF_VERSP """ -Perform full SP-analysis. ({verify_sp}) +Perform full SP-analysis. (\\ph{verify_sp}) """ ida_ida.DEMNAM_CMNT @@ -24224,6 +33072,12 @@ ida_ida.DEMNAM_NONE don't display demangled names """ +ida_ida.IDAINFO_TAG_SIZE +""" +The database parameters. This structure is kept in the ida database. +It contains the essential parameters for the current program +""" + ida_ida.IDB_COMPRESSED """ compress & pack database components @@ -24258,7 +33112,7 @@ check manual operands? (unused) ida_ida.INFFL_GRAPH_VIEW """ -currently using graph options ({graph}) +currently using graph options (\\dto{graph}) """ ida_ida.INFFL_LOADIDC @@ -24339,7 +33193,7 @@ memory snapshot was taken? ida_ida.LFLG_WIDE_HBF """ -(wide bytes: {dnbits} > 8) +(wide bytes: \\ph{dnbits} > 8) Bit order of wide bytes: high byte first? """ @@ -24439,6 +33293,46 @@ ida_ida.PREF_STACK show stack pointer? """ +ida_ida.SCF_ALLCMT +""" +comment all lines? +""" + +ida_ida.SCF_LINNUM +""" +show source line numbers +""" + +ida_ida.SCF_NOCMT +""" +no comments at all +""" + +ida_ida.SCF_RPTCMT +""" +show repeatable comments? +""" + +ida_ida.SCF_SHHID_FUNC +""" +show hidden functions +""" + +ida_ida.SCF_SHHID_ITEM +""" +show hidden instructions +""" + +ida_ida.SCF_SHHID_SEGM +""" +show hidden segments +""" + +ida_ida.SCF_TESTMODE +""" +testida.idc is running +""" + ida_ida.STRF_AUTO """ names have 'autogenerated' bit? @@ -24469,51 +33363,11 @@ ida_ida.STRF_UNICODE unicode strings are present? """ -ida_ida.SW_ALLCMT -""" -comment all lines? -""" - -ida_ida.SW_LINNUM -""" -show source line numbers -""" - -ida_ida.SW_NOCMT -""" -no comments at all -""" - -ida_ida.SW_RPTCMT -""" -show repeatable comments? -""" - ida_ida.SW_SEGXRF """ show segments in xrefs? """ -ida_ida.SW_SHHID_FUNC -""" -show hidden functions -""" - -ida_ida.SW_SHHID_ITEM -""" -show hidden instructions -""" - -ida_ida.SW_SHHID_SEGM -""" -show hidden segments -""" - -ida_ida.SW_TESTMODE -""" -testida.idc is running -""" - ida_ida.SW_XRFFNC """ show function offsets? @@ -24757,6 +33611,11 @@ ida_idaapi.enable_python_cli(): enable_python_cli(enable) +ida_idaapi.format_basestring(): + + format_basestring(_in) -> PyObject * + + ida_idaapi.get_inf_structure(): get_inf_structure() -> idainfo @@ -24942,18 +33801,15 @@ ida_idaapi.loader_input_t_from_linput(): ida_idaapi.notify_when(): - notify_when(when, py_callable) -> bool - - - Register a callback that will be called when an event happens. - @param when: one of NW_XXXX constants - @param callback: This callback prototype varies depending on the 'when' parameter: - The general callback format: - def notify_when_callback(nw_code) - In the case of NW_OPENIDB: - def notify_when_callback(nw_code, is_old_database) - @return: Boolean - + Register a callback that will be called when an event happens. + @param when: one of NW_XXXX constants + @param callback: This callback prototype varies depending on the 'when' parameter: + The general callback format: + def notify_when_callback(nw_code) + In the case of NW_OPENIDB: + def notify_when_callback(nw_code, is_old_database) + @return: Boolean + class ida_idaapi.object_t(): @@ -25174,7 +34030,7 @@ ida_idd.Appcall__.proto(): Allows you to instantiate an appcall (callable object) with the desired prototype @param name_or_ea: The name of the function (will be resolved with LocByName()) - @param prototype: + @param proto_or_tinfo: function prototype as a string or type of the function as tinfo_t object @return: - On failure it raises an exception if the prototype could not be parsed or the address is not resolvable @@ -25188,7 +34044,8 @@ ida_idd.Appcall__.set_appcall_options(): ida_idd.Appcall__.typedobj(): - Parses a type string and returns an appcall object. + Returns an appcall object for a type (can be given as tinfo_t object or + as a string declaration) One can then use retrieve() member method @param ea: Optional parameter that later can be used to retrieve the type @return: Appcall object or raises ValueError exception @@ -26153,6 +35010,29 @@ ida_idd.procinfo_vec_t.truncate(): truncate(self) +class ida_idd.register_info_t(): + + Proxy of C++ register_info_t class + + +ida_idd.register_info_t.bit_strings: + register_info_t_bit_strings_get(self) -> char const *const * + +ida_idd.register_info_t.default_bit_strings_mask: + register_info_t_default_bit_strings_mask_get(self) -> uval_t + +ida_idd.register_info_t.dtype: + register_info_t_dtype_get(self) -> op_dtype_t + +ida_idd.register_info_t.flags: + register_info_t_flags_get(self) -> uint32 + +ida_idd.register_info_t.name: + register_info_t_name_get(self) -> char const * + +ida_idd.register_info_t.register_class: + register_info_t_register_class_get(self) -> register_class_t + class ida_idd.regval_t(): Proxy of C++ regval_t class @@ -26206,6 +35086,11 @@ ida_idd.regval_t.set_int(): set_int(self, x) +ida_idd.regval_t.set_unavailable(): + + set_unavailable(self) + + ida_idd.regval_t.swap(): swap(self, r) @@ -26326,6 +35211,56 @@ the main thread has not been created. It will be initialized later by a 'THREAD_STARTED' event. """ +ida_idd.REGISTER_ADDRESS +""" +may contain an address +""" + +ida_idd.REGISTER_CS +""" +code segment +""" + +ida_idd.REGISTER_CUSTFMT +""" +register should be displayed using a custom data format. the format +name is in bit_strings[0] the corresponding 'regval_t' will use +'bytevec_t' +""" + +ida_idd.REGISTER_FP +""" +frame pointer +""" + +ida_idd.REGISTER_IP +""" +instruction pointer +""" + +ida_idd.REGISTER_NOLF +""" +allowing the next register to be displayed to its right (on the same +line) + +displays this register without returning to the next line +""" + +ida_idd.REGISTER_READONLY +""" +the user can't modify the current value of this register +""" + +ida_idd.REGISTER_SP +""" +stack pointer +""" + +ida_idd.REGISTER_SS +""" +stack segment +""" + ida_idd.RVT_FLOAT """ floating point @@ -26367,252 +35302,252 @@ class ida_idp.IDB_Hooks(): ida_idp.IDB_Hooks.allsegs_moved(): - allsegs_moved(self, info) -> int + allsegs_moved(self, info) ida_idp.IDB_Hooks.auto_empty(): - auto_empty(self) -> int + auto_empty(self) ida_idp.IDB_Hooks.auto_empty_finally(): - auto_empty_finally(self) -> int + auto_empty_finally(self) ida_idp.IDB_Hooks.bookmark_changed(): - bookmark_changed(self, index, pos, desc) -> int + bookmark_changed(self, index, pos, desc) ida_idp.IDB_Hooks.byte_patched(): - byte_patched(self, ea, old_value) -> int + byte_patched(self, ea, old_value) ida_idp.IDB_Hooks.callee_addr_changed(): - callee_addr_changed(self, ea, callee) -> int + callee_addr_changed(self, ea, callee) ida_idp.IDB_Hooks.changing_cmt(): - changing_cmt(self, ea, repeatable_cmt, newcmt) -> int + changing_cmt(self, ea, repeatable_cmt, newcmt) ida_idp.IDB_Hooks.changing_enum_bf(): - changing_enum_bf(self, id, new_bf) -> int + changing_enum_bf(self, id, new_bf) ida_idp.IDB_Hooks.changing_enum_cmt(): - changing_enum_cmt(self, id, repeatable, newcmt) -> int + changing_enum_cmt(self, id, repeatable, newcmt) ida_idp.IDB_Hooks.changing_op_ti(): - changing_op_ti(self, ea, n, new_type, new_fnames) -> int + changing_op_ti(self, ea, n, new_type, new_fnames) ida_idp.IDB_Hooks.changing_op_type(): - changing_op_type(self, ea, n, opinfo) -> int + changing_op_type(self, ea, n, opinfo) ida_idp.IDB_Hooks.changing_range_cmt(): - changing_range_cmt(self, kind, a, cmt, repeatable) -> int + changing_range_cmt(self, kind, a, cmt, repeatable) ida_idp.IDB_Hooks.changing_segm_class(): - changing_segm_class(self, s) -> int + changing_segm_class(self, s) ida_idp.IDB_Hooks.changing_segm_end(): - changing_segm_end(self, s, new_end, segmod_flags) -> int + changing_segm_end(self, s, new_end, segmod_flags) ida_idp.IDB_Hooks.changing_segm_name(): - changing_segm_name(self, s, oldname) -> int + changing_segm_name(self, s, oldname) ida_idp.IDB_Hooks.changing_segm_start(): - changing_segm_start(self, s, new_start, segmod_flags) -> int + changing_segm_start(self, s, new_start, segmod_flags) ida_idp.IDB_Hooks.changing_struc_align(): - changing_struc_align(self, sptr) -> int + changing_struc_align(self, sptr) ida_idp.IDB_Hooks.changing_struc_cmt(): - changing_struc_cmt(self, struc_id, repeatable, newcmt) -> int + changing_struc_cmt(self, struc_id, repeatable, newcmt) ida_idp.IDB_Hooks.changing_struc_member(): - changing_struc_member(self, sptr, mptr, flag, ti, nbytes) -> int + changing_struc_member(self, sptr, mptr, flag, ti, nbytes) ida_idp.IDB_Hooks.changing_ti(): - changing_ti(self, ea, new_type, new_fnames) -> int + changing_ti(self, ea, new_type, new_fnames) ida_idp.IDB_Hooks.closebase(): - closebase(self) -> int + closebase(self) ida_idp.IDB_Hooks.cmt_changed(): - cmt_changed(self, ea, repeatable_cmt) -> int + cmt_changed(self, ea, repeatable_cmt) ida_idp.IDB_Hooks.compiler_changed(): - compiler_changed(self) -> int + compiler_changed(self) ida_idp.IDB_Hooks.deleting_enum(): - deleting_enum(self, id) -> int + deleting_enum(self, id) ida_idp.IDB_Hooks.deleting_enum_member(): - deleting_enum_member(self, id, cid) -> int + deleting_enum_member(self, id, cid) ida_idp.IDB_Hooks.deleting_func(): - deleting_func(self, pfn) -> int + deleting_func(self, pfn) ida_idp.IDB_Hooks.deleting_func_tail(): - deleting_func_tail(self, pfn, tail) -> int + deleting_func_tail(self, pfn, tail) ida_idp.IDB_Hooks.deleting_segm(): - deleting_segm(self, start_ea) -> int + deleting_segm(self, start_ea) ida_idp.IDB_Hooks.deleting_struc(): - deleting_struc(self, sptr) -> int + deleting_struc(self, sptr) ida_idp.IDB_Hooks.deleting_struc_member(): - deleting_struc_member(self, sptr, mptr) -> int + deleting_struc_member(self, sptr, mptr) ida_idp.IDB_Hooks.deleting_tryblks(): - deleting_tryblks(self, range) -> int + deleting_tryblks(self, range) ida_idp.IDB_Hooks.destroyed_items(): - destroyed_items(self, ea1, ea2, will_disable_range) -> int + destroyed_items(self, ea1, ea2, will_disable_range) ida_idp.IDB_Hooks.determined_main(): - determined_main(self, main) -> int + determined_main(self, main) ida_idp.IDB_Hooks.enum_bf_changed(): - enum_bf_changed(self, id) -> int + enum_bf_changed(self, id) ida_idp.IDB_Hooks.enum_cmt_changed(): - enum_cmt_changed(self, id, repeatable) -> int + enum_cmt_changed(self, id, repeatable) ida_idp.IDB_Hooks.enum_created(): - enum_created(self, id) -> int + enum_created(self, id) ida_idp.IDB_Hooks.enum_deleted(): - enum_deleted(self, id) -> int + enum_deleted(self, id) ida_idp.IDB_Hooks.enum_member_created(): - enum_member_created(self, id, cid) -> int + enum_member_created(self, id, cid) ida_idp.IDB_Hooks.enum_member_deleted(): - enum_member_deleted(self, id, cid) -> int + enum_member_deleted(self, id, cid) ida_idp.IDB_Hooks.enum_renamed(): - enum_renamed(self, id) -> int + enum_renamed(self, id) ida_idp.IDB_Hooks.expanding_struc(): - expanding_struc(self, sptr, offset, delta) -> int + expanding_struc(self, sptr, offset, delta) ida_idp.IDB_Hooks.extlang_changed(): - extlang_changed(self, kind, el, idx) -> int + extlang_changed(self, kind, el, idx) ida_idp.IDB_Hooks.extra_cmt_changed(): - extra_cmt_changed(self, ea, line_idx, cmt) -> int + extra_cmt_changed(self, ea, line_idx, cmt) ida_idp.IDB_Hooks.flow_chart_created(): - flow_chart_created(self, fc) -> int + flow_chart_created(self, fc) ida_idp.IDB_Hooks.frame_deleted(): - frame_deleted(self, pfn) -> int + frame_deleted(self, pfn) ida_idp.IDB_Hooks.func_added(): - func_added(self, pfn) -> int + func_added(self, pfn) ida_idp.IDB_Hooks.func_noret_changed(): - func_noret_changed(self, pfn) -> int + func_noret_changed(self, pfn) ida_idp.IDB_Hooks.func_tail_appended(): - func_tail_appended(self, pfn, tail) -> int + func_tail_appended(self, pfn, tail) ida_idp.IDB_Hooks.func_tail_deleted(): - func_tail_deleted(self, pfn, tail_ea) -> int + func_tail_deleted(self, pfn, tail_ea) ida_idp.IDB_Hooks.func_updated(): - func_updated(self, pfn) -> int + func_updated(self, pfn) ida_idp.IDB_Hooks.hook(): @@ -26622,212 +35557,212 @@ ida_idp.IDB_Hooks.hook(): ida_idp.IDB_Hooks.idasgn_loaded(): - idasgn_loaded(self, short_sig_name) -> int + idasgn_loaded(self, short_sig_name) ida_idp.IDB_Hooks.item_color_changed(): - item_color_changed(self, ea, color) -> int + item_color_changed(self, ea, color) ida_idp.IDB_Hooks.kernel_config_loaded(): - kernel_config_loaded(self) -> int + kernel_config_loaded(self) ida_idp.IDB_Hooks.loader_finished(): - loader_finished(self, li, neflags, filetypename) -> int + loader_finished(self, li, neflags, filetypename) ida_idp.IDB_Hooks.local_types_changed(): - local_types_changed(self) -> int + local_types_changed(self) ida_idp.IDB_Hooks.make_code(): - make_code(self, insn) -> int + make_code(self, insn) ida_idp.IDB_Hooks.make_data(): - make_data(self, ea, flags, tid, len) -> int + make_data(self, ea, flags, tid, len) ida_idp.IDB_Hooks.op_ti_changed(): - op_ti_changed(self, ea, n, type, fnames) -> int + op_ti_changed(self, ea, n, type, fnames) ida_idp.IDB_Hooks.op_type_changed(): - op_type_changed(self, ea, n) -> int + op_type_changed(self, ea, n) ida_idp.IDB_Hooks.range_cmt_changed(): - range_cmt_changed(self, kind, a, cmt, repeatable) -> int + range_cmt_changed(self, kind, a, cmt, repeatable) ida_idp.IDB_Hooks.renamed(): - renamed(self, ea, new_name, local_name) -> int + renamed(self, ea, new_name, local_name) ida_idp.IDB_Hooks.renaming_enum(): - renaming_enum(self, id, is_enum, newname) -> int + renaming_enum(self, id, is_enum, newname) ida_idp.IDB_Hooks.renaming_struc(): - renaming_struc(self, id, oldname, newname) -> int + renaming_struc(self, id, oldname, newname) ida_idp.IDB_Hooks.renaming_struc_member(): - renaming_struc_member(self, sptr, mptr, newname) -> int + renaming_struc_member(self, sptr, mptr, newname) ida_idp.IDB_Hooks.savebase(): - savebase(self) -> int + savebase(self) ida_idp.IDB_Hooks.segm_added(): - segm_added(self, s) -> int + segm_added(self, s) ida_idp.IDB_Hooks.segm_attrs_updated(): - segm_attrs_updated(self, s) -> int + segm_attrs_updated(self, s) ida_idp.IDB_Hooks.segm_class_changed(): - segm_class_changed(self, s, sclass) -> int + segm_class_changed(self, s, sclass) ida_idp.IDB_Hooks.segm_deleted(): - segm_deleted(self, start_ea, end_ea) -> int + segm_deleted(self, start_ea, end_ea) ida_idp.IDB_Hooks.segm_end_changed(): - segm_end_changed(self, s, oldend) -> int + segm_end_changed(self, s, oldend) ida_idp.IDB_Hooks.segm_moved(): - segm_moved(self, _from, to, size, changed_netmap) -> int + segm_moved(self, _from, to, size, changed_netmap) ida_idp.IDB_Hooks.segm_name_changed(): - segm_name_changed(self, s, name) -> int + segm_name_changed(self, s, name) ida_idp.IDB_Hooks.segm_start_changed(): - segm_start_changed(self, s, oldstart) -> int + segm_start_changed(self, s, oldstart) ida_idp.IDB_Hooks.set_func_end(): - set_func_end(self, pfn, new_end) -> int + set_func_end(self, pfn, new_end) ida_idp.IDB_Hooks.set_func_start(): - set_func_start(self, pfn, new_start) -> int + set_func_start(self, pfn, new_start) ida_idp.IDB_Hooks.sgr_changed(): - sgr_changed(self, start_ea, end_ea, regnum, value, old_value, tag) -> int + sgr_changed(self, start_ea, end_ea, regnum, value, old_value, tag) ida_idp.IDB_Hooks.sgr_deleted(): - sgr_deleted(self, start_ea, end_ea, regnum) -> int + sgr_deleted(self, start_ea, end_ea, regnum) ida_idp.IDB_Hooks.stkpnts_changed(): - stkpnts_changed(self, pfn) -> int + stkpnts_changed(self, pfn) ida_idp.IDB_Hooks.struc_align_changed(): - struc_align_changed(self, sptr) -> int + struc_align_changed(self, sptr) ida_idp.IDB_Hooks.struc_cmt_changed(): - struc_cmt_changed(self, struc_id, repeatable_cmt) -> int + struc_cmt_changed(self, struc_id, repeatable_cmt) ida_idp.IDB_Hooks.struc_created(): - struc_created(self, struc_id) -> int + struc_created(self, struc_id) ida_idp.IDB_Hooks.struc_deleted(): - struc_deleted(self, struc_id) -> int + struc_deleted(self, struc_id) ida_idp.IDB_Hooks.struc_expanded(): - struc_expanded(self, sptr) -> int + struc_expanded(self, sptr) ida_idp.IDB_Hooks.struc_member_changed(): - struc_member_changed(self, sptr, mptr) -> int + struc_member_changed(self, sptr, mptr) ida_idp.IDB_Hooks.struc_member_created(): - struc_member_created(self, sptr, mptr) -> int + struc_member_created(self, sptr, mptr) ida_idp.IDB_Hooks.struc_member_deleted(): - struc_member_deleted(self, sptr, member_id, offset) -> int + struc_member_deleted(self, sptr, member_id, offset) ida_idp.IDB_Hooks.struc_member_renamed(): - struc_member_renamed(self, sptr, mptr) -> int + struc_member_renamed(self, sptr, mptr) ida_idp.IDB_Hooks.struc_renamed(): - struc_renamed(self, sptr) -> int + struc_renamed(self, sptr) ida_idp.IDB_Hooks.tail_owner_changed(): - tail_owner_changed(self, tail, owner_func, old_owner) -> int + tail_owner_changed(self, tail, owner_func, old_owner) ida_idp.IDB_Hooks.thunk_func_created(): - thunk_func_created(self, pfn) -> int + thunk_func_created(self, pfn) ida_idp.IDB_Hooks.ti_changed(): - ti_changed(self, ea, type, fnames) -> int + ti_changed(self, ea, type, fnames) ida_idp.IDB_Hooks.tryblks_updated(): - tryblks_updated(self, tbv) -> int + tryblks_updated(self, tbv) ida_idp.IDB_Hooks.unhook(): @@ -26837,12 +35772,12 @@ ida_idp.IDB_Hooks.unhook(): ida_idp.IDB_Hooks.updating_tryblks(): - updating_tryblks(self, tbv) -> int + updating_tryblks(self, tbv) ida_idp.IDB_Hooks.upgraded(): - upgraded(self, _from) -> int + upgraded(self, _from) class ida_idp.IDP_Hooks(): @@ -26963,7 +35898,7 @@ ida_idp.IDP_Hooks.ev_calc_switch_cases(): ida_idp.IDP_Hooks.ev_calc_varglocs(): - ev_calc_varglocs(self, ftd, regs, stkargs, nfixed) -> int + ev_calc_varglocs(self, ftd, aux_regs, aux_stkargs, nfixed) -> int ida_idp.IDP_Hooks.ev_calcrel(): @@ -27058,6 +35993,11 @@ ida_idp.IDP_Hooks.ev_endbinary(): ev_endbinary(self, ok) -> int +ida_idp.IDP_Hooks.ev_ending_undo(): + + ev_ending_undo(self, action_name, is_undo) -> int + + ida_idp.IDP_Hooks.ev_equal_reglocs(): ev_equal_reglocs(self, a1, a2) -> int @@ -27100,7 +36040,7 @@ ida_idp.IDP_Hooks.ev_gen_regvar_def(): ida_idp.IDP_Hooks.ev_gen_src_file_lnnum(): - ev_gen_src_file_lnnum(self) -> int + ev_gen_src_file_lnnum(self, outctx, file, lnnum) -> int ida_idp.IDP_Hooks.ev_gen_stkvar_def(): @@ -27115,7 +36055,7 @@ ida_idp.IDP_Hooks.ev_get_abi_info(): ida_idp.IDP_Hooks.ev_get_autocmt(): - ev_get_autocmt(self, insn) -> int + ev_get_autocmt(self, insn) -> PyObject * ida_idp.IDP_Hooks.ev_get_bg_color(): @@ -27150,7 +36090,7 @@ ida_idp.IDP_Hooks.ev_get_macro_insn_head(): ida_idp.IDP_Hooks.ev_get_operand_string(): - ev_get_operand_string(self, insn, opnum) -> int + ev_get_operand_string(self, insn, opnum) -> PyObject * ida_idp.IDP_Hooks.ev_get_reg_info(): @@ -27285,6 +36225,11 @@ ida_idp.IDP_Hooks.ev_is_switch(): ev_is_switch(self, si, insn) -> int +ida_idp.IDP_Hooks.ev_last_cb_before_loader(): + + ev_last_cb_before_loader(self) -> int + + ida_idp.IDP_Hooks.ev_loader(): ev_loader(self) -> int @@ -27442,9 +36387,14 @@ ida_idp.IDP_Hooks.ev_rename(): not rename it. See also the 'renamed' event +ida_idp.IDP_Hooks.ev_replaying_undo(): + + ev_replaying_undo(self, action_name, vec, is_undo) -> int + + ida_idp.IDP_Hooks.ev_set_idp_options(): - ev_set_idp_options(self, keyword, value_type, value, errbuf) -> int + ev_set_idp_options(self, keyword, value_type, value, errbuf, idb_loaded) -> int ida_idp.IDP_Hooks.ev_set_proc_options(): @@ -27726,14 +36676,6 @@ ida_idp.cfg_get_cc_predefined_macros(): cfg_get_cc_predefined_macros(compid) -> char const * -ida_idp.compare(): - - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - - ida_idp.delay_slot_insn(): delay_slot_insn(ea, bexec, fexec) -> bool @@ -27758,6 +36700,16 @@ ida_idp.gen_idb_event(): @param code (C++: idb_event::event_code_t) +ida_idp.get_idb_notifier_addr(): + + get_idb_notifier_addr(arg1) -> PyObject * + + +ida_idp.get_idb_notifier_ud_addr(): + + get_idb_notifier_ud_addr(hooks) -> PyObject * + + ida_idp.get_idp_name(): get_idp_name() -> char * @@ -27769,6 +36721,16 @@ ida_idp.get_idp_name(): processor module is loaded, this function will return NULL +ida_idp.get_idp_notifier_addr(): + + get_idp_notifier_addr(arg1) -> PyObject * + + +ida_idp.get_idp_notifier_ud_addr(): + + get_idp_notifier_ud_addr(hooks) -> PyObject * + + ida_idp.get_reg_info(): get_reg_info(regname, bitrange) -> char const * @@ -27787,7 +36749,7 @@ ida_idp.get_reg_name(): Get text representation of a register. For most processors this - function will just return {reg_names}[reg]. If the processor module + function will just return \ph{reg_names}[reg]. If the processor module has implemented processor_t::get_reg_name, it will be used instead @param reg: internal register number as defined in the processor @@ -28063,10 +37025,305 @@ ida_idp.ph_get_version(): Returns the 'ph.version' -class ida_idp.processor_t(): +ida_idp.processor_t.ev_add_cref(): - Base class for all processor module scripts - + ev_add_cref(self, _from, to, type) -> int + + +ida_idp.processor_t.ev_add_dref(): + + ev_add_dref(self, _from, to, type) -> int + + +ida_idp.processor_t.ev_adjust_argloc(): + + ev_adjust_argloc(self, argloc, optional_type, size) -> int + + +ida_idp.processor_t.ev_adjust_libfunc_ea(): + + ev_adjust_libfunc_ea(self, sig, libfun, ea) -> int + + +ida_idp.processor_t.ev_adjust_refinfo(): + + ev_adjust_refinfo(self, ri, ea, n, fd) -> int + + +ida_idp.processor_t.ev_analyze_prolog(): + + ev_analyze_prolog(self, ea) -> int + + +ida_idp.processor_t.ev_arg_addrs_ready(): + + ev_arg_addrs_ready(self, caller, n, tif, addrs) -> int + + +ida_idp.processor_t.ev_calc_arglocs(): + + ev_calc_arglocs(self, fti) -> int + + +ida_idp.processor_t.ev_calc_cdecl_purged_bytes(): + + ev_calc_cdecl_purged_bytes(self, ea) -> int + + +ida_idp.processor_t.ev_calc_next_eas(): + + ev_calc_next_eas(self, res, insn, over) -> int + + +ida_idp.processor_t.ev_calc_purged_bytes(): + + ev_calc_purged_bytes(self, p_purged_bytes, fti) -> int + + +ida_idp.processor_t.ev_calc_retloc(): + + ev_calc_retloc(self, retloc, rettype, cc) -> int + + +ida_idp.processor_t.ev_calc_spdelta(): + + ev_calc_spdelta(self, spdelta, insn) -> int + + +ida_idp.processor_t.ev_calc_switch_cases(): + + ev_calc_switch_cases(self, casevec, targets, insn_ea, si) -> int + + +ida_idp.processor_t.ev_calc_varglocs(): + + ev_calc_varglocs(self, ftd, aux_regs, aux_stkargs, nfixed) -> int + + +ida_idp.processor_t.ev_calcrel(): + + ev_calcrel(self) -> int + + +ida_idp.processor_t.ev_clean_tbit(): + + ev_clean_tbit(self, ea, getreg, regvalues) -> int + + +ida_idp.processor_t.ev_create_flat_group(): + + ev_create_flat_group(self, image_base, bitness, dataseg_sel) -> int + + +ida_idp.processor_t.ev_decorate_name(): + + ev_decorate_name(self, name, mangle, cc, optional_type) -> PyObject * + + +ida_idp.processor_t.ev_del_cref(): + + ev_del_cref(self, _from, to, expand) -> int + + +ida_idp.processor_t.ev_del_dref(): + + ev_del_dref(self, _from, to) -> int + + +ida_idp.processor_t.ev_delay_slot_insn(): + + ev_delay_slot_insn(self, ea, bexec, fexec) -> PyObject * + + +ida_idp.processor_t.ev_demangle_name(): + + ev_demangle_name(self, name, disable_mask, demreq) -> PyObject * + + +ida_idp.processor_t.ev_ending_undo(): + + ev_ending_undo(self, action_name, is_undo) -> int + + +ida_idp.processor_t.ev_equal_reglocs(): + + ev_equal_reglocs(self, a1, a2) -> int + + +ida_idp.processor_t.ev_extract_address(): + + ev_extract_address(self, out_ea, screen_ea, string, position) -> int + + +ida_idp.processor_t.ev_find_op_value(): + + ev_find_op_value(self, pinsn, opn) -> PyObject * + + +ida_idp.processor_t.ev_find_reg_value(): + + ev_find_reg_value(self, pinsn, reg) -> PyObject * + + +ida_idp.processor_t.ev_gen_asm_or_lst(): + + ev_gen_asm_or_lst(self, starting, fp, is_asm, flags, outline) + + +ida_idp.processor_t.ev_gen_stkvar_def(): + + ev_gen_stkvar_def(self, outctx, mptr, v) -> int + + +ida_idp.processor_t.ev_get_abi_info(): + + ev_get_abi_info(self, abi_names, abi_opts, comp) -> int + + +ida_idp.processor_t.ev_get_bg_color(): + + ev_get_bg_color(self, ea) -> int or None + + +ida_idp.processor_t.ev_get_cc_regs(): + + ev_get_cc_regs(self, regs, cc) -> int + + +ida_idp.processor_t.ev_get_dbr_opnum(): + + ev_get_dbr_opnum(self, opnum, insn) -> int + + +ida_idp.processor_t.ev_get_default_enum_size(): + + ev_get_default_enum_size(self, cm) -> int + + +ida_idp.processor_t.ev_get_macro_insn_head(): + + ev_get_macro_insn_head(self, head, ip) -> int + + +ida_idp.processor_t.ev_get_reg_info(): + + ev_get_reg_info(self, main_regname, bitrange, regname) -> int + + +ida_idp.processor_t.ev_get_reg_name(): + + ev_get_reg_name(self, reg, width, reghi) -> PyObject * + + +ida_idp.processor_t.ev_get_simd_types(): + + ev_get_simd_types(self, out, simd_attrs, argloc, create_tifs) -> int + + +ida_idp.processor_t.ev_get_stkarg_offset(): + + ev_get_stkarg_offset(self) -> int + + +ida_idp.processor_t.ev_get_stkvar_scale_factor(): + + ev_get_stkvar_scale_factor(self) -> int + + +ida_idp.processor_t.ev_getreg(): + + ev_getreg(self, regval, regnum) -> int + + +ida_idp.processor_t.ev_init(): + + ev_init(self, idp_modname) -> int + + +ida_idp.processor_t.ev_insn_reads_tbit(): + + ev_insn_reads_tbit(self, insn, getreg, regvalues) -> int + + +ida_idp.processor_t.ev_is_cond_insn(): + + ev_is_cond_insn(self, insn) -> int + + +ida_idp.processor_t.ev_is_jump_func(): + + ev_is_jump_func(self, pfn, jump_target, func_pointer) -> int + + +ida_idp.processor_t.ev_last_cb_before_loader(): + + ev_last_cb_before_loader(self) -> int + + +ida_idp.processor_t.ev_loader(): + + ev_loader(self) -> int + + +ida_idp.processor_t.ev_lower_func_type(): + + ev_lower_func_type(self, argnums, fti) -> int + + +ida_idp.processor_t.ev_max_ptr_size(): + + ev_max_ptr_size(self) -> int + + +ida_idp.processor_t.ev_newasm(): + + ev_newasm(self, asmnum) -> int + + +ida_idp.processor_t.ev_next_exec_insn(): + + ev_next_exec_insn(self, target, ea, tid, getreg, regvalues) -> int + + +ida_idp.processor_t.ev_realcvt(): + + ev_realcvt(self, m, e, swt) -> int + + +ida_idp.processor_t.ev_replaying_undo(): + + ev_replaying_undo(self, action_name, vec, is_undo) -> int + + +ida_idp.processor_t.ev_setup_til(): + + ev_setup_til(self) + + +ida_idp.processor_t.ev_shadow_args_size(): + + ev_shadow_args_size(self, shadow_args_size, pfn) -> int + + +ida_idp.processor_t.ev_term(): + + ev_term(self) -> int + + +ida_idp.processor_t.ev_use_arg_types(): + + ev_use_arg_types(self, ea, fti, rargs) -> int + + +ida_idp.processor_t.ev_use_regarg_type(): + + ev_use_regarg_type(self, ea, rargs) -> PyObject * + + +ida_idp.processor_t.ev_use_stkarg_type(): + + ev_use_stkarg_type(self, ea, arg) -> int + ida_idp.processor_t.get_auxpref(): @@ -28085,6 +37342,25 @@ ida_idp.processor_t.get_uFlag(): Use this utility function to retrieve the 'uFlag' global variable +ida_idp.processor_t.hook(): + + hook(self) -> bool + + + Creates an IDP hook + + @return: Boolean true on success + + +ida_idp.processor_t.unhook(): + + unhook(self) -> bool + + + Removes the IDP hook + @return: Boolean true on success + + class ida_idp.reg_info_t(): Proxy of C++ reg_info_t class @@ -28106,11 +37382,11 @@ ida_idp.set_processor_type(): set_processor_type(procname, level) -> bool - Set target processor type. Once a processor module is loaded, it can - not be replaced until we close the idb. + Set target processor type. Once a processor module is loaded, it + cannot be replaced until we close the idb. @param procname: name of processor type (one of names present in - {psnames}) (C++: const char *) + \ph{psnames}) (C++: const char *) @param level: SETPROC_ (C++: setproc_level_t) @return: success @@ -28176,7 +37452,7 @@ ida_idp.AS2_STRINV """ (For processors with bytes bigger than 8 bits) -Invert meaning of {wide_high_byte_first} for text strings +Invert meaning of \\inf{wide_high_byte_first} for text strings """ ida_idp.AS2_TERSESTR @@ -28325,7 +37601,7 @@ ida_idp.AS_ALIGN2 ida_idp.AS_ASCIIC """ -(\n,\x01 and similar) +(\\n,\\x01 and similar) ascii directive accepts C-like escape sequences """ @@ -28979,8 +38255,8 @@ segments are 64-bit by default ida_idp.PR_DELAYED """ -has delayed jumps and calls if this flag is set, {is_basic_block_end}, -{has_delay_slot} should be implemented +has delayed jumps and calls if this flag is set, +\\ph{is_basic_block_end}, \\ph{has_delay_slot} should be implemented """ ida_idp.PR_NOCHANGE @@ -29009,7 +38285,7 @@ allow user register names for location names ida_idp.PR_SCALE_STKVARS """ -use {get_stkvar_scale} callback +use \\ph{get_stkvar_scale} callback """ ida_idp.PR_SEGS @@ -29052,7 +38328,7 @@ supports 64-bit addressing? ida_idp.PR_USE_ARG_TYPES """ -use {use_arg_types} callback +use \\ph{use_arg_types} callback """ ida_idp.PR_USE_TBYTE @@ -29144,7 +38420,7 @@ ida_kernwin.Choose.UI_Hooks_Trampoline.database_inited(): ida_kernwin.Choose.UI_Hooks_Trampoline.debugger_menu_change(): - debugger_menu_change(self, enable) -> int + debugger_menu_change(self, enable) ida_kernwin.Choose.UI_Hooks_Trampoline.finish_populating_widget_popup(): @@ -29186,6 +38462,11 @@ ida_kernwin.Choose.UI_Hooks_Trampoline.get_item_hint(): get_item_hint(self, ea, max_lines) -> PyObject * +ida_kernwin.Choose.UI_Hooks_Trampoline.get_widget_config(): + + get_widget_config(self, widget, cfg) -> PyObject * + + ida_kernwin.Choose.UI_Hooks_Trampoline.hook(): hook(self) -> bool @@ -29278,6 +38559,11 @@ ida_kernwin.Choose.UI_Hooks_Trampoline.screen_ea_changed(): screen_ea_changed(self, ea, prev_ea) +ida_kernwin.Choose.UI_Hooks_Trampoline.set_widget_config(): + + set_widget_config(self, widget, cfg) + + ida_kernwin.Choose.UI_Hooks_Trampoline.suspend(): suspend(self) @@ -30322,7 +39608,7 @@ ida_kernwin.UI_Hooks.database_inited(): ida_kernwin.UI_Hooks.debugger_menu_change(): - debugger_menu_change(self, enable) -> int + debugger_menu_change(self, enable) ida_kernwin.UI_Hooks.finish_populating_widget_popup(): @@ -30364,6 +39650,11 @@ ida_kernwin.UI_Hooks.get_item_hint(): get_item_hint(self, ea, max_lines) -> PyObject * +ida_kernwin.UI_Hooks.get_widget_config(): + + get_widget_config(self, widget, cfg) -> PyObject * + + ida_kernwin.UI_Hooks.hook(): hook(self) -> bool @@ -30469,6 +39760,11 @@ ida_kernwin.UI_Hooks.screen_ea_changed(): screen_ea_changed(self, ea, prev_ea) +ida_kernwin.UI_Hooks.set_widget_config(): + + set_widget_config(self, widget, cfg) + + ida_kernwin.UI_Hooks.suspend(): suspend(self) @@ -30621,7 +39917,7 @@ ida_kernwin.action_ctx_base_t.cur_enum: action_ctx_base_t_cur_enum_get(self) -> enum_t ida_kernwin.action_ctx_base_t.cur_extracted_ea: - action_ctx_base_t_cur_extracted_ea_get(self) -> ea_t + action_ctx_base_t_cur_value_get(self) -> uval_t ida_kernwin.action_ctx_base_t.cur_fchunk: action_ctx_base_t_cur_fchunk_get(self) -> func_t * @@ -30641,6 +39937,9 @@ ida_kernwin.action_ctx_base_t.cur_strmem: ida_kernwin.action_ctx_base_t.cur_struc: action_ctx_base_t_cur_struc_get(self) -> struc_t * +ida_kernwin.action_ctx_base_t.cur_value: + action_ctx_base_t_cur_value_get(self) -> uval_t + ida_kernwin.action_ctx_base_t.focus: action_ctx_base_t_focus_get(self) -> TWidget * @@ -30752,16 +40051,13 @@ ida_kernwin.add_idc_hotkey(): ida_kernwin.add_spaces(): - add_spaces(str, bufsize, len) -> char * + add_spaces(s, len) -> PyObject * Add space characters to the colored string so that its length will be at least 'len' characters. Don't trim the string if it is longer than 'len'. - @param str: pointer to colored string to modify (may not be NULL) - (C++: char *) - @param bufsize: size of the buffer with the string (C++: size_t) @param len: the desired length of the string (C++: ssize_t) @return: pointer to the end of input string @@ -30904,12 +40200,12 @@ ida_kernwin.attach_action_to_menu(): @param menupath: path to the menu item after or before which the insertion will take place. Example: - Debug/StartProcess Whitespace, punctuation are - ignored. It is allowed to specify only the prefix of - the menu item. Comparison is case insensitive. - menupath may start with the following prefixes: [S] - - modify the main menu of the structure window [E] - - modify the main menu of the enum window (C++: const + Debug/StartProcess Whitespace, punctuation are + ignored. It is allowed to specify only the prefix + of the menu item. Comparison is case insensitive. + menupath may start with the following prefixes: [S] + - modify the main menu of the structure window [E] + - modify the main menu of the enum window (C++: const char *) @param name: the action name (C++: const char *) @param flags: a combination of Set menu flags , to determine menu @@ -30929,9 +40225,9 @@ ida_kernwin.attach_action_to_popup(): @param widget: target widget (C++: TWidget *) @param popup_handle: target popup menu if non-NULL, the action is added to this popup menu invocation (i.e., - 'single-shot') if NULL, the action is added to a - list of actions that should always be present in - context menus for this widget (i.e., + 'single-shot') if NULL, the action is added to + a list of actions that should always be present + in context menus for this widget (i.e., 'permanent'.) (C++: TPopupMenu *) @param name: action name (C++: const char *) @param popuppath: can be NULL (C++: const char *) @@ -30995,15 +40291,12 @@ ida_kernwin.beep(): ida_kernwin.call_nav_colorizer(): - call_nav_colorizer(col, ea, nbytes) -> uint32 + call_nav_colorizer(dict, ea, nbytes) -> uint32 To be used with the IDA-provided colorizer, that is returned as result of the first call to set_nav_colorizer(). - This is a trivial trampoline, so that SWIG can generate a - wrapper that will do the types checking. - ida_kernwin.cancel_exec_request(): @@ -31021,14 +40314,19 @@ ida_kernwin.choose_activate(): choose_activate(self) +ida_kernwin.choose_choose(): + + choose_choose(self) -> int + + ida_kernwin.choose_close(): choose_close(self) -ida_kernwin.choose_create(): +ida_kernwin.choose_create_embedded_chobj(): - choose_create(self) -> int + choose_create_embedded_chobj(self) -> uint64 ida_kernwin.choose_entry(): @@ -31290,15 +40588,33 @@ ida_kernwin.create_empty_widget(): ida_kernwin.create_menu(): - create_menu(name, label, before=None) -> bool + create_menu(name, label, menupath=None) -> bool - Create a menu with the given name, label and optional position + Create a menu with the given name, label and optional position, either + in the menubar, or as a submenu. If 'menupath' is non-NULL, it + provides information about where the menu should be positioned. First, + IDA will try and resolve the corresponding menu by its name. If such + an existing menu is found and is present in the menubar, then the new + menu will be inserted in the menubar before it. Otherwise, IDA will + try to resolve 'menupath' as it would for 'attach_action_to_menu()' + and, if found, add the new menu like so: + + // The new 'My menu' submenu will appear in the 'Comments' submenu + // before the 'Enter comment..." command + create_menu("(...)", "My menu", "Edit/Comments/Enter comment..."); + + or + + // The new 'My menu' submenu will appear at the end of the + // 'Comments' submenu. + create_menu("(...)", "My menu", "Edit/Comments/"); + + If the above fails, the new menu will be appended to the menubar. @param name: name of menu (must be unique) (C++: const char *) @param label: label of menu (C++: const char *) - @param before: if non-NULL, the menu before which the new menu will be - inserted (C++: const char *) + @param menupath: where should the menu be inserted (C++: const char *) @return: success @@ -31554,13 +40870,16 @@ ida_kernwin.display_copyright_warning(): ida_kernwin.display_widget(): - display_widget(widget, options) + display_widget(widget, options, dest_ctrl=None) - Display a widget + Display a widget, dock it if not done before @param widget: widget to display (C++: TWidget *) - @param options: Widget open flags (C++: int) + @param options: Widget open flags (C++: uint32) + @param dest_ctrl: where to dock: if NULL or invalid then use the + active docker if there is not create a new tab + relative to current active tab (C++: const char *) ida_kernwin.ea2str(): @@ -32587,21 +41906,6 @@ ida_kernwin.load_dbg_dbginfo(): @param verbose: dump status to message window (C++: bool) -class ida_kernwin.locchange_md_t(): - - Proxy of C++ locchange_md_t class - - -ida_kernwin.locchange_md_t.is_sync(): - - is_sync(self) -> bool - - -ida_kernwin.locchange_md_t.reason(): - - reason(self) -> locchange_reason_t - - ida_kernwin.lookup_key_code(): lookup_key_code(key, shift, is_qt) -> ushort @@ -33124,7 +42428,7 @@ ida_kernwin.plgform_new(): ida_kernwin.plgform_show(): - plgform_show(py_link, py_obj, caption, options=WOPN_TAB|WOPN_RESTORE) -> bool + plgform_show(py_link, py_obj, caption, options=WOPN_DP_TAB|WOPN_RESTORE) -> bool ida_kernwin.process_ui_action(): @@ -33208,11 +42512,6 @@ ida_kernwin.pyscv_del_line(): pyscv_del_line(py_this, nline) -> bool -ida_kernwin.pyscv_delete(): - - pyscv_delete(py_this) -> bool - - ida_kernwin.pyscv_edit_line(): pyscv_edit_line(py_this, nline, py_sl) -> bool @@ -33278,11 +42577,6 @@ ida_kernwin.pyscv_refresh(): pyscv_refresh(py_this) -> bool -ida_kernwin.pyscv_refresh_current(): - - pyscv_refresh_current(py_this) -> bool - - ida_kernwin.pyscv_show(): pyscv_show(py_this) -> bool @@ -33297,7 +42591,7 @@ ida_kernwin.qcleanline(): @param cmt_char: character that denotes the start of a comment: the entire text is removed if the line begins with this - character (ignoring leading spaces) all text after + character (ignoring leading spaces) all text after (and including) this character is removed if flag CLNL_FINDCMT is set (C++: char) @param flags: a combination of line cleanup flags . defaults to @@ -33684,7 +42978,7 @@ ida_kernwin.set_highlight(): ida_kernwin.set_nav_colorizer(): - set_nav_colorizer(new_py_colorizer) -> nav_colorizer_t * + set_nav_colorizer(new_py_colorizer) -> PyObject * Set a new colorizer for the navigation band. @@ -33901,7 +43195,7 @@ ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.database_inited(): ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.debugger_menu_change(): - debugger_menu_change(self, enable) -> int + debugger_menu_change(self, enable) ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.finish_populating_widget_popup(): @@ -33943,6 +43237,11 @@ ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.get_item_hint(): get_item_hint(self, ea, max_lines) -> PyObject * +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.get_widget_config(): + + get_widget_config(self, widget, cfg) -> PyObject * + + ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.hook(): hook(self) -> bool @@ -34035,6 +43334,11 @@ ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.screen_ea_changed(): screen_ea_changed(self, ea, prev_ea) +ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.set_widget_config(): + + set_widget_config(self, widget, cfg) + + ida_kernwin.simplecustviewer_t.UI_Hooks_Trampoline.suspend(): suspend(self) @@ -34399,6 +43703,44 @@ ida_kernwin.structplace_t.touval(): touval(self, ud) -> uval_t +class ida_kernwin.sync_source_t(): + + Proxy of C++ sync_source_t class + + +ida_kernwin.sync_source_t.get_register(): + + get_register(self) -> char const * + + +ida_kernwin.sync_source_t.get_widget(): + + get_widget(self) -> TWidget const * + + +ida_kernwin.sync_source_t.is_register(): + + is_register(self) -> bool + + +ida_kernwin.sync_source_t.is_widget(): + + is_widget(self) -> bool + + +ida_kernwin.sync_sources(): + + sync_sources(what, with, sync) -> bool + + + [Un]synchronize sources + + @param what (C++: const sync_source_t &) + @param with (C++: const sync_source_t &) + @param sync (C++: bool) + @return: success + + ida_kernwin.take_database_snapshot(): take_database_snapshot(ss) -> PyObject * @@ -34406,7 +43748,7 @@ ida_kernwin.take_database_snapshot(): Take a database snapshot ( 'ui_take_database_snapshot' ). - @param ss: in/out parameter. in: description, flags out: filename, + @param ss: in/out parameter. in: description, flags out: filename, id (C++: snapshot_t *) @return: success @@ -34478,12 +43820,12 @@ ida_kernwin.textctrl_info_t_get_clink_ptr(): ida_kernwin.textctrl_info_t_get_flags(): - textctrl_info_t_get_flags(self, flags) -> unsigned int + textctrl_info_t_get_flags(self) -> unsigned int ida_kernwin.textctrl_info_t_get_tabsize(): - textctrl_info_t_get_tabsize(self, tabsize) -> unsigned int + textctrl_info_t_get_tabsize(self) -> unsigned int ida_kernwin.textctrl_info_t_get_text(): @@ -34754,6 +44096,13 @@ ida_kernwin.ACF_XTRN_EA cur_ea is in 'externs' segment """ +ida_kernwin.ADF_NO_UNDO +""" +useful for actions that do not modify the database. + +the action does not create an undo point. +""" + ida_kernwin.ADF_OWN_HANDLER """ handler is owned by the action; it'll be destroyed when the action is @@ -34860,6 +44209,11 @@ ida_kernwin.BWN_CUSTVIEW custom viewers """ +ida_kernwin.BWN_CV_LINE_INFOS +""" +custom viewers' lineinfo widget +""" + ida_kernwin.BWN_DISASM """ disassembly views @@ -34871,6 +44225,11 @@ Alias. Some BWN_* were confusing, and thus have been renamed. This is to ensure bw-compat. """ +ida_kernwin.BWN_DISASM_ARROWS +""" +disassembly arrows widget +""" + ida_kernwin.BWN_DUMP """ hex dumps @@ -35013,6 +44372,16 @@ ida_kernwin.BWN_SO_STRUCTS the 'Structure offsets' dialog's 'Structures and Unions' panel """ +ida_kernwin.BWN_SRCPTHMAP_CSR +""" +"Source paths..."'s path mappings chooser +""" + +ida_kernwin.BWN_SRCPTHUND_CSR +""" +"Source paths..."'s undesired paths chooser +""" + ida_kernwin.BWN_STACK """ Alias. Some BWN_* were confusing, and thus have been renamed. This is @@ -35049,6 +44418,11 @@ ida_kernwin.BWN_TRACE trace view """ +ida_kernwin.BWN_UNDOHIST +""" +Undo history. +""" + ida_kernwin.BWN_UNKNOWN """ unknown window @@ -35064,6 +44438,46 @@ ida_kernwin.BWN_XREFS xrefs """ +ida_kernwin.CHCOL_DEC +""" +decimal number +""" + +ida_kernwin.CHCOL_DEFHIDDEN +""" +column should be hidden by default +""" + +ida_kernwin.CHCOL_EA +""" +address +""" + +ida_kernwin.CHCOL_FNAME +""" +function name +""" + +ida_kernwin.CHCOL_FORMAT +""" +column format mask +""" + +ida_kernwin.CHCOL_HEX +""" +hexadecimal number +""" + +ida_kernwin.CHCOL_PATH +""" +file path +""" + +ida_kernwin.CHCOL_PLAIN +""" +plain string +""" + ida_kernwin.CHITEM_BOLD """ display the item in bold @@ -35091,7 +44505,7 @@ underline the item ida_kernwin.CHOOSER_MENU_EDIT """ -Values of themenu_indexparameter. +Values of the 'menu_index' parameter. Obsolete. Please don't use """ @@ -35108,16 +44522,16 @@ Obsolete. Please don't use. ida_kernwin.CHOOSER_MULTI_SELECTION """ -enable for multiple selections. A callback of -typechooser_multi_cb_twill be called for all selected items. +enable for multiple selections. A callback of type +'chooser_multi_cb_t' will be called for all selected items. """ ida_kernwin.CHOOSER_NO_SELECTION """ Flags. -enable even if there's no selected item.nwill be NO_SELECTION for a -callback. +enable even if there's no selected item. 'n' will be NO_SELECTION for +a callback. """ ida_kernwin.CHOOSER_POPUP_MENU @@ -35125,6 +44539,118 @@ ida_kernwin.CHOOSER_POPUP_MENU Add command to the popup menu. """ +ida_kernwin.CH_ATTRS +""" +generate ui_get_chooser_item_attrs (gui only) +""" + +ida_kernwin.CH_BUILTIN_MASK +""" +Mask for builtin chooser numbers. Plugins should not use them. +""" + +ida_kernwin.CH_CAN_DEL +""" +allow to delete existing item(s) +""" + +ida_kernwin.CH_CAN_EDIT +""" +allow to edit existing item(s) +""" + +ida_kernwin.CH_CAN_INS +""" +allow to insert new items +""" + +ida_kernwin.CH_CAN_REFRESH +""" +allow to refresh chooser +""" + +ida_kernwin.CH_FORCE_DEFAULT +""" +if a non-modal chooser was already open, change selection to the +default one +""" + +ida_kernwin.CH_KEEP +""" +The chooser instance's lifecycle is not tied to the lifecycle of the +widget showing its contents. Closing the widget will not destroy the +chooser structure. This allows for, e.g., static global chooser +instances that don't need to be allocated on the heap. Also stack- +allocated chooser instances must set this bit. +""" + +ida_kernwin.CH_MODAL +""" +Modal chooser. +""" + +ida_kernwin.CH_MULTI +""" +Obsolete. + +The chooser will allow multi-selection (only for GUI choosers). This +bit is set when using the 'chooser_multi_t' structure. +""" + +ida_kernwin.CH_NOBTNS +""" +do not display ok/cancel/help/search buttons. Meaningful only for gui +modal windows because non-modal windows do not have any buttons +anyway. Text mode does not have them neither. +""" + +ida_kernwin.CH_NOIDB +""" +use the chooser before opening the database +""" + +ida_kernwin.CH_NO_STATUS_BAR +""" +don't show a status bar +""" + +ida_kernwin.CH_QFLT +""" +open with quick filter enabled and focused +""" + +ida_kernwin.CH_QFTYP_DEFAULT +""" +set quick filtering type to the possible existing default for this +chooser +""" + +ida_kernwin.CH_QFTYP_FUZZY +""" +fuzzy search quick filter type +""" + +ida_kernwin.CH_QFTYP_NORMAL +""" +normal (i.e., lexicographical) quick filter type +""" + +ida_kernwin.CH_QFTYP_REGEX +""" +regex quick filter type +""" + +ida_kernwin.CH_QFTYP_WHOLE_WORDS +""" +whole words quick filter type +""" + +ida_kernwin.CH_RESTORE +""" +restore floating position if present (equivalent of WOPN_RESTORE) (GUI +version only) +""" + ida_kernwin.CLNL_FINDCMT """ Search for the comment symbol everywhere in the line, not only at the @@ -35276,6 +44802,11 @@ ida_kernwin.IWID_CALLS_CALLERS funcalls, callers (49) """ +ida_kernwin.IWID_CALL_STACK +""" +call stack (17) +""" + ida_kernwin.IWID_CHOOSER """ chooser (37) @@ -35306,12 +44837,22 @@ ida_kernwin.IWID_CUSTVIEW custom viewers (46) """ -ida_kernwin.IWID_DISASMS +ida_kernwin.IWID_CV_LINE_INFOS +""" +lineinfo widget (53) +""" + +ida_kernwin.IWID_DISASM """ disassembly views (29) """ -ida_kernwin.IWID_DUMPS +ida_kernwin.IWID_DISASM_ARROWS +""" +arrows widget (52) +""" + +ida_kernwin.IWID_DUMP """ hex dumps (30) """ @@ -35336,11 +44877,6 @@ ida_kernwin.IWID_FUNCS functions (3) """ -ida_kernwin.IWID_IDAMEMOS -""" -disassembly + hex dump views -""" - ida_kernwin.IWID_IMPORTS """ imports (1) @@ -35396,7 +44932,7 @@ ida_kernwin.IWID_PSEUDOCODE decompiler (48) """ -ida_kernwin.IWID_SEARCHS +ida_kernwin.IWID_SEARCH """ search results (19) """ @@ -35446,9 +44982,20 @@ ida_kernwin.IWID_SO_STRUCTS stroff (41) """ +ida_kernwin.IWID_SRCPTHMAP_CSR +""" +mappings chooser (54) +""" + +ida_kernwin.IWID_SRCPTHUND_CSR +""" +undesired chooser (55) +""" + ida_kernwin.IWID_STACK """ -call stack (17) +Alias. Some IWID_* were confusing, and thus have been renamed. This is +to ensure bw-compat. """ ida_kernwin.IWID_STKVIEW @@ -35481,6 +45028,11 @@ ida_kernwin.IWID_TRACE trace view (16) """ +ida_kernwin.IWID_UNDOHIST +""" +Undo history (56) +""" + ida_kernwin.IWID_WATCH """ watches (34) @@ -35888,8 +45440,8 @@ Default. ida_lines.COLOR_ESC """ -Escape character (Quote next character). This is needed to output '\1' -and '\2' characters. +Escape character (Quote next character). This is needed to output '\\1' +and '\\2' characters. """ ida_lines.COLOR_EXTERN @@ -36202,7 +45754,7 @@ ida_loader.clr_database_flag(): ida_loader.extract_module_from_archive(): - extract_module_from_archive(filename, bufsize, temp_file_ptr, is_remote) -> bool + extract_module_from_archive(fname, is_remote=False) -> PyObject * Extract a module for an archive file. Parse an archive file, show the @@ -36211,11 +45763,6 @@ ida_loader.extract_module_from_archive(): the process). This function can handle ZIP, AR, AIXAR, OMFLIB files. The temporary file will be automatically deleted by IDA at the end. - @param filename: in: input file. out: name of the selected module. - (C++: char *) - @param bufsize: size of the buffer with 'filename' (C++: size_t) - @param temp_file_ptr: will point to the name of the file that contains - the extracted module (C++: char **) @param is_remote: is the input file remote? (C++: bool) @@ -36266,7 +45813,7 @@ ida_loader.gen_exe_file(): @param fp (C++: FILE *) @return: fp the output file handle. if fp == NULL then return: 1: - can generate an executable file 0: can't generate an + can generate an executable file 0: can't generate an executable file @@ -36313,7 +45860,7 @@ ida_loader.get_file_type_name(): Get name of the current file type. The current file type is kept in - {filetype}. + \inf{filetype}. @return: size of answer, this function always succeeds @@ -36687,7 +46234,7 @@ ida_loader.reload_file(): input file. It doesn't modify the segmentation, names, comments, etc. @param file: name of the input file. if file == NULL then returns: - 1: can reload the input file 0: can't reload the input + 1: can reload the input file 0: can't reload the input file (C++: const char *) @param is_remote: is the file located on a remote computer with the debugger server? (C++: bool) @@ -36974,6 +46521,2040 @@ ida_loader.SSUF_PATH Update the path. """ === ida_loader EPYDOC INJECTIONS END === +ida_lumina.apply_metadata(): + + apply_metadata(ea, fi, flags=0x0) + + +ida_lumina.backup_metadata(): + + backup_metadata(ea) -> bool + + +ida_lumina.calc_func_metadata(): + + calc_func_metadata(out_fi, pfn, append_metadata=None) -> asize_t + + +ida_lumina.create_simple_diff_handler(): + + create_simple_diff_handler() -> simple_diff_handler_t + + +ida_lumina.create_simple_idb_diff_handler(): + + create_simple_idb_diff_handler(pfn) -> simple_idb_diff_handler_t + + +ida_lumina.diff_metadata(): + + diff_metadata(handler, left, right, flags=0) -> bool + + +ida_lumina.ea_to_ea64(): + + ea_to_ea64(ea) -> ea64_t + + +class ida_lumina.extra_cmt_t(): + + Proxy of C++ extra_cmt_t class + + +ida_lumina.extra_cmt_t.fchunk_nr: + insn_site_t_fchunk_nr_get(self) -> uint32 + +ida_lumina.extra_cmt_t.fchunk_off: + insn_site_t_fchunk_off_get(self) -> uint32 + +ida_lumina.extra_cmt_t.next: + extra_cmt_t_next_get(self) -> qstring * + +ida_lumina.extra_cmt_t.prev: + extra_cmt_t_prev_get(self) -> qstring * + +ida_lumina.extra_cmt_t.toea(): + + toea(self, pfn) -> ea_t + + +class ida_lumina.extra_cmts_t(): + + Proxy of C++ qvector<(extra_cmt_t)> class + + +ida_lumina.extra_cmts_t.at(): + + at(self, _idx) -> extra_cmt_t + + +ida_lumina.extra_cmts_t.begin(): + + begin(self) -> extra_cmt_t + begin(self) -> extra_cmt_t + + +ida_lumina.extra_cmts_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.extra_cmts_t.clear(): + + clear(self) + + +ida_lumina.extra_cmts_t.empty(): + + empty(self) -> bool + + +ida_lumina.extra_cmts_t.end(): + + end(self) -> extra_cmt_t + end(self) -> extra_cmt_t + + +ida_lumina.extra_cmts_t.erase(): + + erase(self, it) -> extra_cmt_t + erase(self, first, last) -> extra_cmt_t + + +ida_lumina.extra_cmts_t.extract(): + + extract(self) -> extra_cmt_t + + +ida_lumina.extra_cmts_t.grow(): + + grow(self, x=extra_cmt_t()) + + +ida_lumina.extra_cmts_t.inject(): + + inject(self, s, len) + + +ida_lumina.extra_cmts_t.insert(): + + insert(self, it, x) -> extra_cmt_t + + +ida_lumina.extra_cmts_t.pop_back(): + + pop_back(self) + + +ida_lumina.extra_cmts_t.push_back(): + + push_back(self, x) + push_back(self) -> extra_cmt_t + + +ida_lumina.extra_cmts_t.qclear(): + + qclear(self) + + +ida_lumina.extra_cmts_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.extra_cmts_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.extra_cmts_t.size(): + + size(self) -> size_t + + +ida_lumina.extra_cmts_t.swap(): + + swap(self, r) + + +ida_lumina.extra_cmts_t.truncate(): + + truncate(self) + + +ida_lumina.extract_extra_cmts_from_metadata(): + + extract_extra_cmts_from_metadata(out, ptr) + + +ida_lumina.extract_frame_desc_from_metadata(): + + extract_frame_desc_from_metadata(out, ptr) + + +ida_lumina.extract_insn_cmts_from_metadata(): + + extract_insn_cmts_from_metadata(out, ptr) + + +ida_lumina.extract_insn_opreprs_from_metadata(): + + extract_insn_opreprs_from_metadata(out, ptr) + + +ida_lumina.extract_type_from_metadata(): + + extract_type_from_metadata(out, _in) -> bool + + +ida_lumina.extract_user_stkpnts_from_metadata(): + + extract_user_stkpnts_from_metadata(out, ptr) + + +class ida_lumina.frame_desc_t(): + + Proxy of C++ frame_desc_t class + + +ida_lumina.frame_desc_t.argsize: + frame_desc_t_argsize_get(self) -> asize_t + +ida_lumina.frame_desc_t.frregs: + frame_desc_t_frregs_get(self) -> ushort + +ida_lumina.frame_desc_t.frsize: + frame_desc_t_frsize_get(self) -> sval_t + +ida_lumina.frame_desc_t.members: + frame_desc_t_members_get(self) -> frame_mems_t + +class ida_lumina.frame_mem_t(): + + Proxy of C++ frame_mem_t class + + +ida_lumina.frame_mem_t.cmt: + frame_mem_t_cmt_get(self) -> qstring * + +ida_lumina.frame_mem_t.info: + frame_mem_t_info_get(self) -> oprepr_t + +ida_lumina.frame_mem_t.name: + frame_mem_t_name_get(self) -> qstring * + +ida_lumina.frame_mem_t.nbytes: + frame_mem_t_nbytes_get(self) -> asize_t + +ida_lumina.frame_mem_t.offset: + frame_mem_t_offset_get(self) -> ea64_t + +ida_lumina.frame_mem_t.rptcmt: + frame_mem_t_rptcmt_get(self) -> qstring * + +ida_lumina.frame_mem_t.type: + frame_mem_t_type_get(self) -> serialized_tinfo + +class ida_lumina.frame_mems_t(): + + Proxy of C++ qvector<(frame_mem_t)> class + + +ida_lumina.frame_mems_t.at(): + + at(self, _idx) -> frame_mem_t + + +ida_lumina.frame_mems_t.begin(): + + begin(self) -> frame_mem_t + begin(self) -> frame_mem_t + + +ida_lumina.frame_mems_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.frame_mems_t.clear(): + + clear(self) + + +ida_lumina.frame_mems_t.empty(): + + empty(self) -> bool + + +ida_lumina.frame_mems_t.end(): + + end(self) -> frame_mem_t + end(self) -> frame_mem_t + + +ida_lumina.frame_mems_t.erase(): + + erase(self, it) -> frame_mem_t + erase(self, first, last) -> frame_mem_t + + +ida_lumina.frame_mems_t.extract(): + + extract(self) -> frame_mem_t + + +ida_lumina.frame_mems_t.grow(): + + grow(self, x=frame_mem_t()) + + +ida_lumina.frame_mems_t.inject(): + + inject(self, s, len) + + +ida_lumina.frame_mems_t.insert(): + + insert(self, it, x) -> frame_mem_t + + +ida_lumina.frame_mems_t.pop_back(): + + pop_back(self) + + +ida_lumina.frame_mems_t.push_back(): + + push_back(self, x) + push_back(self) -> frame_mem_t + + +ida_lumina.frame_mems_t.qclear(): + + qclear(self) + + +ida_lumina.frame_mems_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.frame_mems_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.frame_mems_t.size(): + + size(self) -> size_t + + +ida_lumina.frame_mems_t.swap(): + + swap(self, r) + + +ida_lumina.frame_mems_t.truncate(): + + truncate(self) + + +class ida_lumina.func_info_and_frequency_t(): + + Proxy of C++ func_info_and_frequency_t class + + +ida_lumina.func_info_and_frequency_t.frequency: + func_info_and_frequency_t_frequency_get(self) -> uint32 + +ida_lumina.func_info_and_frequency_t.metadata: + func_info_t_metadata_get(self) -> metadata_t * + +ida_lumina.func_info_and_frequency_t.name: + func_info_t_name_get(self) -> qstring * + +ida_lumina.func_info_and_frequency_t.size: + func_info_t_size_get(self) -> uint32 + +class ida_lumina.func_info_and_frequency_vec_t(): + + Proxy of C++ qvector<(func_info_and_frequency_t)> class + + +ida_lumina.func_info_and_frequency_vec_t.at(): + + at(self, _idx) -> func_info_and_frequency_t + + +ida_lumina.func_info_and_frequency_vec_t.begin(): + + begin(self) -> func_info_and_frequency_t + begin(self) -> func_info_and_frequency_t + + +ida_lumina.func_info_and_frequency_vec_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.func_info_and_frequency_vec_t.clear(): + + clear(self) + + +ida_lumina.func_info_and_frequency_vec_t.empty(): + + empty(self) -> bool + + +ida_lumina.func_info_and_frequency_vec_t.end(): + + end(self) -> func_info_and_frequency_t + end(self) -> func_info_and_frequency_t + + +ida_lumina.func_info_and_frequency_vec_t.erase(): + + erase(self, it) -> func_info_and_frequency_t + erase(self, first, last) -> func_info_and_frequency_t + + +ida_lumina.func_info_and_frequency_vec_t.extract(): + + extract(self) -> func_info_and_frequency_t + + +ida_lumina.func_info_and_frequency_vec_t.grow(): + + grow(self, x=func_info_and_frequency_t()) + + +ida_lumina.func_info_and_frequency_vec_t.inject(): + + inject(self, s, len) + + +ida_lumina.func_info_and_frequency_vec_t.insert(): + + insert(self, it, x) -> func_info_and_frequency_t + + +ida_lumina.func_info_and_frequency_vec_t.pop_back(): + + pop_back(self) + + +ida_lumina.func_info_and_frequency_vec_t.push_back(): + + push_back(self, x) + push_back(self) -> func_info_and_frequency_t + + +ida_lumina.func_info_and_frequency_vec_t.qclear(): + + qclear(self) + + +ida_lumina.func_info_and_frequency_vec_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.func_info_and_frequency_vec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.func_info_and_frequency_vec_t.size(): + + size(self) -> size_t + + +ida_lumina.func_info_and_frequency_vec_t.swap(): + + swap(self, r) + + +ida_lumina.func_info_and_frequency_vec_t.truncate(): + + truncate(self) + + +class ida_lumina.func_info_and_pattern_t(): + + Proxy of C++ func_info_and_pattern_t class + + +ida_lumina.func_info_and_pattern_t.metadata: + func_info_t_metadata_get(self) -> metadata_t * + +ida_lumina.func_info_and_pattern_t.name: + func_info_t_name_get(self) -> qstring * + +ida_lumina.func_info_and_pattern_t.pattern_id: + func_info_and_pattern_t_pattern_id_get(self) -> pattern_id_t + +ida_lumina.func_info_and_pattern_t.size: + func_info_t_size_get(self) -> uint32 + +class ida_lumina.func_info_and_pattern_vec_t(): + + Proxy of C++ qvector<(func_info_and_pattern_t)> class + + +ida_lumina.func_info_and_pattern_vec_t.at(): + + at(self, _idx) -> func_info_and_pattern_t + + +ida_lumina.func_info_and_pattern_vec_t.begin(): + + begin(self) -> func_info_and_pattern_t + begin(self) -> func_info_and_pattern_t + + +ida_lumina.func_info_and_pattern_vec_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.func_info_and_pattern_vec_t.clear(): + + clear(self) + + +ida_lumina.func_info_and_pattern_vec_t.empty(): + + empty(self) -> bool + + +ida_lumina.func_info_and_pattern_vec_t.end(): + + end(self) -> func_info_and_pattern_t + end(self) -> func_info_and_pattern_t + + +ida_lumina.func_info_and_pattern_vec_t.erase(): + + erase(self, it) -> func_info_and_pattern_t + erase(self, first, last) -> func_info_and_pattern_t + + +ida_lumina.func_info_and_pattern_vec_t.extract(): + + extract(self) -> func_info_and_pattern_t + + +ida_lumina.func_info_and_pattern_vec_t.grow(): + + grow(self, x=func_info_and_pattern_t()) + + +ida_lumina.func_info_and_pattern_vec_t.inject(): + + inject(self, s, len) + + +ida_lumina.func_info_and_pattern_vec_t.insert(): + + insert(self, it, x) -> func_info_and_pattern_t + + +ida_lumina.func_info_and_pattern_vec_t.pop_back(): + + pop_back(self) + + +ida_lumina.func_info_and_pattern_vec_t.push_back(): + + push_back(self, x) + push_back(self) -> func_info_and_pattern_t + + +ida_lumina.func_info_and_pattern_vec_t.qclear(): + + qclear(self) + + +ida_lumina.func_info_and_pattern_vec_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.func_info_and_pattern_vec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.func_info_and_pattern_vec_t.size(): + + size(self) -> size_t + + +ida_lumina.func_info_and_pattern_vec_t.swap(): + + swap(self, r) + + +ida_lumina.func_info_and_pattern_vec_t.truncate(): + + truncate(self) + + +class ida_lumina.func_info_base_t(): + + Proxy of C++ func_info_base_t class + + +ida_lumina.func_info_base_t.metadata: + func_info_base_t_metadata_get(self) -> metadata_t * + +ida_lumina.func_info_base_t.name: + func_info_base_t_name_get(self) -> qstring * + +class ida_lumina.func_info_pattern_and_frequency_t(): + + Proxy of C++ func_info_pattern_and_frequency_t class + + +ida_lumina.func_info_pattern_and_frequency_t.frequency: + func_info_pattern_and_frequency_t_frequency_get(self) -> uint32 + +ida_lumina.func_info_pattern_and_frequency_t.metadata: + func_info_t_metadata_get(self) -> metadata_t * + +ida_lumina.func_info_pattern_and_frequency_t.name: + func_info_t_name_get(self) -> qstring * + +ida_lumina.func_info_pattern_and_frequency_t.pattern_id: + func_info_and_pattern_t_pattern_id_get(self) -> pattern_id_t + +ida_lumina.func_info_pattern_and_frequency_t.size: + func_info_t_size_get(self) -> uint32 + +class ida_lumina.func_info_pattern_and_frequency_vec_t(): + + Proxy of C++ qvector<(func_info_pattern_and_frequency_t)> class + + +ida_lumina.func_info_pattern_and_frequency_vec_t.at(): + + at(self, _idx) -> func_info_pattern_and_frequency_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.begin(): + + begin(self) -> func_info_pattern_and_frequency_t + begin(self) -> func_info_pattern_and_frequency_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.clear(): + + clear(self) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.empty(): + + empty(self) -> bool + + +ida_lumina.func_info_pattern_and_frequency_vec_t.end(): + + end(self) -> func_info_pattern_and_frequency_t + end(self) -> func_info_pattern_and_frequency_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.erase(): + + erase(self, it) -> func_info_pattern_and_frequency_t + erase(self, first, last) -> func_info_pattern_and_frequency_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.extract(): + + extract(self) -> func_info_pattern_and_frequency_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.grow(): + + grow(self, x=func_info_pattern_and_frequency_t()) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.inject(): + + inject(self, s, len) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.insert(): + + insert(self, it, x) -> func_info_pattern_and_frequency_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.pop_back(): + + pop_back(self) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.push_back(): + + push_back(self, x) + push_back(self) -> func_info_pattern_and_frequency_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.qclear(): + + qclear(self) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.size(): + + size(self) -> size_t + + +ida_lumina.func_info_pattern_and_frequency_vec_t.swap(): + + swap(self, r) + + +ida_lumina.func_info_pattern_and_frequency_vec_t.truncate(): + + truncate(self) + + +class ida_lumina.func_info_t(): + + Proxy of C++ func_info_t class + + +ida_lumina.func_info_t.metadata: + func_info_t_metadata_get(self) -> metadata_t * + +ida_lumina.func_info_t.name: + func_info_t_name_get(self) -> qstring * + +ida_lumina.func_info_t.size: + func_info_t_size_get(self) -> uint32 + +class ida_lumina.func_info_vec_t(): + + Proxy of C++ qvector<(func_info_t)> class + + +ida_lumina.func_info_vec_t.at(): + + at(self, _idx) -> func_info_t + + +ida_lumina.func_info_vec_t.begin(): + + begin(self) -> func_info_t + begin(self) -> func_info_t + + +ida_lumina.func_info_vec_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.func_info_vec_t.clear(): + + clear(self) + + +ida_lumina.func_info_vec_t.empty(): + + empty(self) -> bool + + +ida_lumina.func_info_vec_t.end(): + + end(self) -> func_info_t + end(self) -> func_info_t + + +ida_lumina.func_info_vec_t.erase(): + + erase(self, it) -> func_info_t + erase(self, first, last) -> func_info_t + + +ida_lumina.func_info_vec_t.extract(): + + extract(self) -> func_info_t + + +ida_lumina.func_info_vec_t.grow(): + + grow(self, x=func_info_t()) + + +ida_lumina.func_info_vec_t.inject(): + + inject(self, s, len) + + +ida_lumina.func_info_vec_t.insert(): + + insert(self, it, x) -> func_info_t + + +ida_lumina.func_info_vec_t.pop_back(): + + pop_back(self) + + +ida_lumina.func_info_vec_t.push_back(): + + push_back(self, x) + push_back(self) -> func_info_t + + +ida_lumina.func_info_vec_t.qclear(): + + qclear(self) + + +ida_lumina.func_info_vec_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.func_info_vec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.func_info_vec_t.size(): + + size(self) -> size_t + + +ida_lumina.func_info_vec_t.swap(): + + swap(self, r) + + +ida_lumina.func_info_vec_t.truncate(): + + truncate(self) + + +class ida_lumina.func_md_diff_handler_t(): + + Proxy of C++ func_md_diff_handler_t class + + +ida_lumina.func_md_diff_handler_t.on_comment_changed(): + + on_comment_changed(self, fchunk_nr, fchunk_off, l, r, rep) + + +ida_lumina.func_md_diff_handler_t.on_extra_comment_changed(): + + on_extra_comment_changed(self, fchunk_nr, fchunk_off, l, r, is_prev) + + +ida_lumina.func_md_diff_handler_t.on_frame_member_changed(): + + on_frame_member_changed(self, offset, l, r) + + +ida_lumina.func_md_diff_handler_t.on_function_comment_changed(): + + on_function_comment_changed(self, l, r, rep) + + +ida_lumina.func_md_diff_handler_t.on_insn_ops_repr_changed(): + + on_insn_ops_repr_changed(self, fchunk_nr, fchunk_off, l, r) + + +ida_lumina.func_md_diff_handler_t.on_name_changed(): + + on_name_changed(self, l, r) + + +ida_lumina.func_md_diff_handler_t.on_proto_changed(): + + on_proto_changed(self, l, r) + + +ida_lumina.func_md_diff_handler_t.on_score_changed(): + + on_score_changed(self, l, r) + + +ida_lumina.func_md_diff_handler_t.on_user_stkpnt_changed(): + + on_user_stkpnt_changed(self, fchunk_nr, fchunk_off, l, r) + + +ida_lumina.get_lumina_rpc_packet_t_index_from_base(): + + get_lumina_rpc_packet_t_index_from_base(code) -> uchar + + +ida_lumina.get_server_connection(): + + get_server_connection() -> lumina_client_t + + +ida_lumina.has_backup_metadata(): + + has_backup_metadata(ea) -> bool + + +class ida_lumina.history_entries_helper_t(): + + Proxy of C++ history_entries_helper_t class + + +ida_lumina.history_entries_helper_t.next_entry(): + + next_entry(self, _from) -> change_desc_base_t const & + + +ida_lumina.history_entries_helper_t.next_entry_index(): + + next_entry_index(self, out_index, _from) -> bool + + +ida_lumina.history_entries_helper_t.res: + history_entries_helper_t_res_get(self) -> pkt_show_entries_result_t const & + +class ida_lumina.input_file_t(): + + Proxy of C++ input_file_t class + + +ida_lumina.input_file_t.md5: + input_file_t_md5_get(self) -> md5_t * + +ida_lumina.input_file_t.path: + input_file_t_path_get(self) -> qstring * + +class ida_lumina.insn_cmt_t(): + + Proxy of C++ insn_cmt_t class + + +ida_lumina.insn_cmt_t.cmt: + insn_cmt_t_cmt_get(self) -> qstring * + +ida_lumina.insn_cmt_t.fchunk_nr: + insn_site_t_fchunk_nr_get(self) -> uint32 + +ida_lumina.insn_cmt_t.fchunk_off: + insn_site_t_fchunk_off_get(self) -> uint32 + +ida_lumina.insn_cmt_t.toea(): + + toea(self, pfn) -> ea_t + + +class ida_lumina.insn_cmts_t(): + + Proxy of C++ qvector<(insn_cmt_t)> class + + +ida_lumina.insn_cmts_t.at(): + + at(self, _idx) -> insn_cmt_t + + +ida_lumina.insn_cmts_t.begin(): + + begin(self) -> insn_cmt_t + begin(self) -> insn_cmt_t + + +ida_lumina.insn_cmts_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.insn_cmts_t.clear(): + + clear(self) + + +ida_lumina.insn_cmts_t.empty(): + + empty(self) -> bool + + +ida_lumina.insn_cmts_t.end(): + + end(self) -> insn_cmt_t + end(self) -> insn_cmt_t + + +ida_lumina.insn_cmts_t.erase(): + + erase(self, it) -> insn_cmt_t + erase(self, first, last) -> insn_cmt_t + + +ida_lumina.insn_cmts_t.extract(): + + extract(self) -> insn_cmt_t + + +ida_lumina.insn_cmts_t.grow(): + + grow(self, x=insn_cmt_t()) + + +ida_lumina.insn_cmts_t.inject(): + + inject(self, s, len) + + +ida_lumina.insn_cmts_t.insert(): + + insert(self, it, x) -> insn_cmt_t + + +ida_lumina.insn_cmts_t.pop_back(): + + pop_back(self) + + +ida_lumina.insn_cmts_t.push_back(): + + push_back(self, x) + push_back(self) -> insn_cmt_t + + +ida_lumina.insn_cmts_t.qclear(): + + qclear(self) + + +ida_lumina.insn_cmts_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.insn_cmts_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.insn_cmts_t.size(): + + size(self) -> size_t + + +ida_lumina.insn_cmts_t.swap(): + + swap(self, r) + + +ida_lumina.insn_cmts_t.truncate(): + + truncate(self) + + +class ida_lumina.insn_ops_repr_t(): + + Proxy of C++ insn_ops_repr_t class + + +ida_lumina.insn_ops_repr_t.fchunk_nr: + insn_site_t_fchunk_nr_get(self) -> uint32 + +ida_lumina.insn_ops_repr_t.fchunk_off: + insn_site_t_fchunk_off_get(self) -> uint32 + +ida_lumina.insn_ops_repr_t.flags: + insn_ops_repr_t_flags_get(self) -> flags_t + +ida_lumina.insn_ops_repr_t.op0: + insn_ops_repr_t_op0_get(self) -> opinfo_t + +ida_lumina.insn_ops_repr_t.op1: + insn_ops_repr_t_op1_get(self) -> opinfo_t + +ida_lumina.insn_ops_repr_t.toea(): + + toea(self, pfn) -> ea_t + + +class ida_lumina.insn_ops_reprs_t(): + + Proxy of C++ qvector<(insn_ops_repr_t)> class + + +ida_lumina.insn_ops_reprs_t.at(): + + at(self, _idx) -> insn_ops_repr_t + + +ida_lumina.insn_ops_reprs_t.begin(): + + begin(self) -> insn_ops_repr_t + begin(self) -> insn_ops_repr_t + + +ida_lumina.insn_ops_reprs_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.insn_ops_reprs_t.clear(): + + clear(self) + + +ida_lumina.insn_ops_reprs_t.empty(): + + empty(self) -> bool + + +ida_lumina.insn_ops_reprs_t.end(): + + end(self) -> insn_ops_repr_t + end(self) -> insn_ops_repr_t + + +ida_lumina.insn_ops_reprs_t.erase(): + + erase(self, it) -> insn_ops_repr_t + erase(self, first, last) -> insn_ops_repr_t + + +ida_lumina.insn_ops_reprs_t.extract(): + + extract(self) -> insn_ops_repr_t + + +ida_lumina.insn_ops_reprs_t.grow(): + + grow(self, x=insn_ops_repr_t()) + + +ida_lumina.insn_ops_reprs_t.inject(): + + inject(self, s, len) + + +ida_lumina.insn_ops_reprs_t.insert(): + + insert(self, it, x) -> insn_ops_repr_t + + +ida_lumina.insn_ops_reprs_t.pop_back(): + + pop_back(self) + + +ida_lumina.insn_ops_reprs_t.push_back(): + + push_back(self, x) + push_back(self) -> insn_ops_repr_t + + +ida_lumina.insn_ops_reprs_t.qclear(): + + qclear(self) + + +ida_lumina.insn_ops_reprs_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.insn_ops_reprs_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.insn_ops_reprs_t.size(): + + size(self) -> size_t + + +ida_lumina.insn_ops_reprs_t.swap(): + + swap(self, r) + + +ida_lumina.insn_ops_reprs_t.truncate(): + + truncate(self) + + +class ida_lumina.insn_site_t(): + + Proxy of C++ insn_site_t class + + +ida_lumina.insn_site_t.fchunk_nr: + insn_site_t_fchunk_nr_get(self) -> uint32 + +ida_lumina.insn_site_t.fchunk_off: + insn_site_t_fchunk_off_get(self) -> uint32 + +ida_lumina.insn_site_t.toea(): + + toea(self, pfn) -> ea_t + + +class ida_lumina.lumina_client_t(): + + Proxy of C++ lumina_client_t class + + +ida_lumina.lumina_client_t.get_pop(): + + get_pop(self, nresults=10) -> pkt_get_pop_result_t + + +ida_lumina.lumina_client_t.pull_md(): + + pull_md(self, pattern_ids, pull_md_flags=0) -> pkt_pull_md_result_t + pull_md(self, funcs, pull_md_flags=0) -> pkt_pull_md_result_t + + +ida_lumina.lumina_client_t.push_md(): + + push_md(self, result, contents, eas, flags=0) -> bool + push_md(self, result, opts, append_metadata=None, flags=0) -> bool + + +ida_lumina.lumina_client_t.set_pattern_id_md5(): + + set_pattern_id_md5(self, out, md5) + + +class ida_lumina.lumina_op_res_vec_t(): + + Proxy of C++ qvector<(lumina_op_res_t)> class + + +ida_lumina.lumina_op_res_vec_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_lumina.lumina_op_res_vec_t.at(): + + at(self, _idx) -> lumina_op_res_t const & + + +ida_lumina.lumina_op_res_vec_t.begin(): + + begin(self) -> qvector< lumina_op_res_t >::iterator + begin(self) -> qvector< lumina_op_res_t >::const_iterator + + +ida_lumina.lumina_op_res_vec_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.lumina_op_res_vec_t.clear(): + + clear(self) + + +ida_lumina.lumina_op_res_vec_t.empty(): + + empty(self) -> bool + + +ida_lumina.lumina_op_res_vec_t.end(): + + end(self) -> qvector< lumina_op_res_t >::iterator + end(self) -> qvector< lumina_op_res_t >::const_iterator + + +ida_lumina.lumina_op_res_vec_t.erase(): + + erase(self, it) -> qvector< lumina_op_res_t >::iterator + erase(self, first, last) -> qvector< lumina_op_res_t >::iterator + + +ida_lumina.lumina_op_res_vec_t.extract(): + + extract(self) -> lumina_op_res_t * + + +ida_lumina.lumina_op_res_vec_t.find(): + + find(self, x) -> qvector< lumina_op_res_t >::iterator + find(self, x) -> qvector< lumina_op_res_t >::const_iterator + + +ida_lumina.lumina_op_res_vec_t.grow(): + + grow(self, x=lumina_op_res_t()) + + +ida_lumina.lumina_op_res_vec_t.has(): + + has(self, x) -> bool + + +ida_lumina.lumina_op_res_vec_t.inject(): + + inject(self, s, len) + + +ida_lumina.lumina_op_res_vec_t.insert(): + + insert(self, it, x) -> qvector< lumina_op_res_t >::iterator + + +ida_lumina.lumina_op_res_vec_t.pop_back(): + + pop_back(self) + + +ida_lumina.lumina_op_res_vec_t.push_back(): + + push_back(self, x) + push_back(self) -> lumina_op_res_t & + + +ida_lumina.lumina_op_res_vec_t.qclear(): + + qclear(self) + + +ida_lumina.lumina_op_res_vec_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.lumina_op_res_vec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.lumina_op_res_vec_t.size(): + + size(self) -> size_t + + +ida_lumina.lumina_op_res_vec_t.swap(): + + swap(self, r) + + +ida_lumina.lumina_op_res_vec_t.truncate(): + + truncate(self) + + +class ida_lumina.md_type_parts_t(): + + Proxy of C++ md_type_parts_t class + + +ida_lumina.md_type_parts_t.fields: + md_type_parts_t_fields_get(self) -> qtype * + +ida_lumina.md_type_parts_t.type: + md_type_parts_t_type_get(self) -> qtype * + +ida_lumina.md_type_parts_t.userti: + md_type_parts_t_userti_get(self) -> bool + +class ida_lumina.metadata_iterator_t(): + + Proxy of C++ metadata_iterator_t class + + +ida_lumina.metadata_iterator_t.data: + metadata_iterator_t_data_get(self) -> uchar const * + +ida_lumina.metadata_iterator_t.data_end(): + + data_end(self) -> uchar const * + + +ida_lumina.metadata_iterator_t.key: + metadata_iterator_t_key_get(self) -> mdkey_t + +ida_lumina.metadata_iterator_t.next(): + + next(self) -> bool + + +ida_lumina.metadata_iterator_t.size: + metadata_iterator_t_size_get(self) -> size_t + +ida_lumina.new_packet(): + + new_packet(code, ptr=None, len=0, version=-1) -> rpc_packet_data_t * + + +class ida_lumina.oprepr_t(): + + Proxy of C++ oprepr_t class + + +ida_lumina.oprepr_t.flags: + oprepr_t_flags_get(self) -> flags_t + +ida_lumina.oprepr_t.opinfo: + oprepr_t_opinfo_get(self) -> opinfo_t + +class ida_lumina.pattern_id_t(): + + Proxy of C++ pattern_id_t class + + +ida_lumina.pattern_id_t.data: + pattern_id_t_data_get(self) -> bytevec_t * + +ida_lumina.pattern_id_t.type: + pattern_id_t_type_get(self) -> pattern_type_t + +class ida_lumina.pkt_clean_db_t(): + + Proxy of C++ pkt_clean_db_t class + + +class ida_lumina.pkt_debugctl_t(): + + Proxy of C++ pkt_debugctl_t class + + +ida_lumina.pkt_debugctl_t.args: + pkt_debugctl_t_args_get(self) -> qstrvec_t * + +class ida_lumina.pkt_dump_md_result_t(): + + Proxy of C++ pkt_dump_md_result_t class + + +ida_lumina.pkt_dump_md_result_t.contents: + pkt_dump_md_result_t_contents_get(self) -> func_info_pattern_and_frequency_vec_t + +class ida_lumina.pkt_dump_md_t(): + + Proxy of C++ pkt_dump_md_t class + + +ida_lumina.pkt_dump_md_t.sort: + pkt_dump_md_t_sort_get(self) -> dump_md_sort_type_t + +class ida_lumina.pkt_get_pop_result_t(): + + Proxy of C++ pkt_get_pop_result_t class + + +ida_lumina.pkt_get_pop_result_t.results: + pkt_get_pop_result_t_results_get(self) -> pop_fun_vec_t * + +class ida_lumina.pkt_get_pop_t(): + + Proxy of C++ pkt_get_pop_t class + + +ida_lumina.pkt_get_pop_t.nresults: + pkt_get_pop_t_nresults_get(self) -> uint32 + +class ida_lumina.pkt_helo_t(): + + Proxy of C++ pkt_helo_t class + + +ida_lumina.pkt_helo_t.client_version: + pkt_helo_t_client_version_get(self) -> int + +ida_lumina.pkt_helo_t.key: + pkt_helo_t_key_get(self) -> bytevec_t * + +ida_lumina.pkt_helo_t.license_id: + pkt_helo_t_license_id_get(self) -> uchar [6] + +ida_lumina.pkt_helo_t.record_conv: + pkt_helo_t_record_conv_get(self) -> bool + +class ida_lumina.pkt_pull_md_result_t(): + + Proxy of C++ pkt_pull_md_result_t class + + +ida_lumina.pkt_pull_md_result_t.codes: + pkt_pull_md_result_t_codes_get(self) -> lumina_op_res_vec_t + +ida_lumina.pkt_pull_md_result_t.results: + pkt_pull_md_result_t_results_get(self) -> func_info_and_frequency_vec_t + +class ida_lumina.pkt_pull_md_t(): + + Proxy of C++ pkt_pull_md_t class + + +ida_lumina.pkt_pull_md_t.flags: + pkt_pull_md_t_flags_get(self) -> uint32 + +ida_lumina.pkt_pull_md_t.keys: + pkt_pull_md_t_keys_get(self) -> mdkey_vec_t * + +ida_lumina.pkt_pull_md_t.pattern_ids: + pkt_pull_md_t_pattern_ids_get(self) -> pattern_ids_t * + +class ida_lumina.pkt_push_md_result_t(): + + Proxy of C++ pkt_push_md_result_t class + + +ida_lumina.pkt_push_md_result_t.codes: + pkt_push_md_result_t_codes_get(self) -> lumina_op_res_vec_t + +class ida_lumina.pkt_push_md_t(): + + Proxy of C++ pkt_push_md_t class + + +ida_lumina.pkt_push_md_t.contents: + pkt_push_md_t_contents_get(self) -> func_info_and_pattern_vec_t + +ida_lumina.pkt_push_md_t.ea64s: + pkt_push_md_t_ea64s_get(self) -> ea64vec_t * + +ida_lumina.pkt_push_md_t.flags: + pkt_push_md_t_flags_get(self) -> uint32 + +ida_lumina.pkt_push_md_t.hostname: + pkt_push_md_t_hostname_get(self) -> qstring * + +ida_lumina.pkt_push_md_t.idb: + pkt_push_md_t_idb_get(self) -> qstring * + +ida_lumina.pkt_push_md_t.input: + pkt_push_md_t_input_get(self) -> input_file_t + +class ida_lumina.pkt_rpc_fail_t(): + + Proxy of C++ pkt_rpc_fail_t class + + +ida_lumina.pkt_rpc_fail_t.error: + pkt_rpc_fail_t_error_get(self) -> qstring * + +ida_lumina.pkt_rpc_fail_t.result: + pkt_rpc_fail_t_result_get(self) -> int + +class ida_lumina.pkt_rpc_notify_t(): + + Proxy of C++ pkt_rpc_notify_t class + + +ida_lumina.pkt_rpc_notify_t.text: + pkt_rpc_notify_t_text_get(self) -> qstring * + +ida_lumina.pkt_rpc_notify_t.type: + pkt_rpc_notify_t_type_get(self) -> rpc_notification_type_t + +class ida_lumina.pkt_rpc_ok_t(): + + Proxy of C++ pkt_rpc_ok_t class + + +class ida_lumina.pop_fun_t(): + + Proxy of C++ pop_fun_t class + + +ida_lumina.pop_fun_t.ea64: + pop_fun_t_ea64_get(self) -> ea64_t + +ida_lumina.pop_fun_t.frequency: + func_info_pattern_and_frequency_t_frequency_get(self) -> uint32 + +ida_lumina.pop_fun_t.hostname: + pop_fun_t_hostname_get(self) -> qstring * + +ida_lumina.pop_fun_t.input: + pop_fun_t_input_get(self) -> input_file_t + +ida_lumina.pop_fun_t.metadata: + func_info_t_metadata_get(self) -> metadata_t * + +ida_lumina.pop_fun_t.name: + func_info_t_name_get(self) -> qstring * + +ida_lumina.pop_fun_t.pattern_id: + func_info_and_pattern_t_pattern_id_get(self) -> pattern_id_t + +ida_lumina.pop_fun_t.size: + func_info_t_size_get(self) -> uint32 + +class ida_lumina.push_md_opts_t(): + + Proxy of C++ push_md_opts_t class + + +ida_lumina.push_md_opts_t.eas: + push_md_opts_t_eas_get(self) -> eavec_t * + +ida_lumina.push_md_opts_t.min_func_size: + push_md_opts_t_min_func_size_get(self) -> size_t + +class ida_lumina.push_md_result_t(): + + Proxy of C++ push_md_result_t class + + +ida_lumina.push_md_result_t.codes: + push_md_result_t_codes_get(self) -> lumina_op_res_vec_t + +ida_lumina.push_md_result_t.contents: + push_md_result_t_contents_get(self) -> func_info_and_pattern_vec_t + +ida_lumina.push_md_result_t.eas: + push_md_result_t_eas_get(self) -> eavec_t * + +ida_lumina.revert_metadata(): + + revert_metadata(ea) -> bool + + +ida_lumina.score_metadata(): + + score_metadata(fi) -> uint32 + + +class ida_lumina.serialized_tinfo(): + + Proxy of C++ serialized_tinfo class + + +ida_lumina.serialized_tinfo.fields: + serialized_tinfo_fields_get(self) -> qtype * + +ida_lumina.serialized_tinfo.type: + serialized_tinfo_type_get(self) -> qtype * + +class ida_lumina.simple_diff_handler_t(): + + Proxy of C++ simple_diff_handler_t class + + +ida_lumina.simple_diff_handler_t.indent: + simple_diff_handler_t_indent_get(self) -> uint32 + +ida_lumina.simple_diff_handler_t.lines: + simple_diff_handler_t_lines_get(self) -> qstrvec_t * + +ida_lumina.simple_diff_handler_t.on_comment_changed(): + + on_comment_changed(self, fchunk_nr, fchunk_off, l, r, rep) + + +ida_lumina.simple_diff_handler_t.on_extra_comment_changed(): + + on_extra_comment_changed(self, fchunk_nr, fchunk_off, l, r, is_prev) + + +ida_lumina.simple_diff_handler_t.on_frame_member_changed(): + + on_frame_member_changed(self, offset, l, r) + + +ida_lumina.simple_diff_handler_t.on_function_comment_changed(): + + on_function_comment_changed(self, l, r, rep) + + +ida_lumina.simple_diff_handler_t.on_insn_ops_repr_changed(): + + on_insn_ops_repr_changed(self, fchunk_nr, fchunk_off, l, r) + + +ida_lumina.simple_diff_handler_t.on_name_changed(): + + on_name_changed(self, l, r) + + +ida_lumina.simple_diff_handler_t.on_proto_changed(): + + on_proto_changed(self, l, r) + + +ida_lumina.simple_diff_handler_t.on_score_changed(): + + on_score_changed(self, l, r) + + +ida_lumina.simple_diff_handler_t.on_user_stkpnt_changed(): + + on_user_stkpnt_changed(self, fchunk_nr, fchunk_off, l, r) + + +class ida_lumina.simple_idb_diff_handler_t(): + + Proxy of C++ simple_idb_diff_handler_t class + + +ida_lumina.simple_idb_diff_handler_t.header_generated: + simple_idb_diff_handler_t_header_generated_get(self) -> bool + +ida_lumina.simple_idb_diff_handler_t.indent: + simple_diff_handler_t_indent_get(self) -> uint32 + +ida_lumina.simple_idb_diff_handler_t.lines: + simple_diff_handler_t_lines_get(self) -> qstrvec_t * + +ida_lumina.simple_idb_diff_handler_t.on_comment_changed(): + + on_comment_changed(self, fchunk_nr, fchunk_off, l, r, rep) + + +ida_lumina.simple_idb_diff_handler_t.on_extra_comment_changed(): + + on_extra_comment_changed(self, fchunk_nr, fchunk_off, l, r, is_prev) + + +ida_lumina.simple_idb_diff_handler_t.on_frame_member_changed(): + + on_frame_member_changed(self, offset, l, r) + + +ida_lumina.simple_idb_diff_handler_t.on_function_comment_changed(): + + on_function_comment_changed(self, l, r, rep) + + +ida_lumina.simple_idb_diff_handler_t.on_insn_ops_repr_changed(): + + on_insn_ops_repr_changed(self, fchunk_nr, fchunk_off, l, r) + + +ida_lumina.simple_idb_diff_handler_t.on_name_changed(): + + on_name_changed(self, l, r) + + +ida_lumina.simple_idb_diff_handler_t.on_proto_changed(): + + on_proto_changed(self, l, r) + + +ida_lumina.simple_idb_diff_handler_t.on_score_changed(): + + on_score_changed(self, l, r) + + +ida_lumina.simple_idb_diff_handler_t.on_user_stkpnt_changed(): + + on_user_stkpnt_changed(self, fchunk_nr, fchunk_off, l, r) + + +ida_lumina.simple_idb_diff_handler_t.pfn: + simple_idb_diff_handler_t_pfn_get(self) -> func_t const * + +class ida_lumina.skipped_func_t(): + + Proxy of C++ skipped_func_t class + + +ida_lumina.skipped_func_t.count: + skipped_func_t_count_get(self) -> uint32 + +ida_lumina.skipped_func_t.pattern_id: + skipped_func_t_pattern_id_get(self) -> pattern_id_t + +class ida_lumina.skipped_funcs_t(): + + Proxy of C++ qvector<(skipped_func_t)> class + + +ida_lumina.skipped_funcs_t.at(): + + at(self, _idx) -> skipped_func_t + + +ida_lumina.skipped_funcs_t.begin(): + + begin(self) -> skipped_func_t + begin(self) -> skipped_func_t + + +ida_lumina.skipped_funcs_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.skipped_funcs_t.clear(): + + clear(self) + + +ida_lumina.skipped_funcs_t.empty(): + + empty(self) -> bool + + +ida_lumina.skipped_funcs_t.end(): + + end(self) -> skipped_func_t + end(self) -> skipped_func_t + + +ida_lumina.skipped_funcs_t.erase(): + + erase(self, it) -> skipped_func_t + erase(self, first, last) -> skipped_func_t + + +ida_lumina.skipped_funcs_t.extract(): + + extract(self) -> skipped_func_t + + +ida_lumina.skipped_funcs_t.grow(): + + grow(self, x=skipped_func_t()) + + +ida_lumina.skipped_funcs_t.inject(): + + inject(self, s, len) + + +ida_lumina.skipped_funcs_t.insert(): + + insert(self, it, x) -> skipped_func_t + + +ida_lumina.skipped_funcs_t.pop_back(): + + pop_back(self) + + +ida_lumina.skipped_funcs_t.push_back(): + + push_back(self, x) + push_back(self) -> skipped_func_t + + +ida_lumina.skipped_funcs_t.qclear(): + + qclear(self) + + +ida_lumina.skipped_funcs_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.skipped_funcs_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.skipped_funcs_t.size(): + + size(self) -> size_t + + +ida_lumina.skipped_funcs_t.swap(): + + swap(self, r) + + +ida_lumina.skipped_funcs_t.truncate(): + + truncate(self) + + +ida_lumina.split_metadata(): + + split_metadata(md) -> PyObject * + + +class ida_lumina.user_identification_t(): + + Proxy of C++ user_identification_t class + + +ida_lumina.user_identification_t.email: + user_identification_t_email_get(self) -> qstring * + +ida_lumina.user_identification_t.license_id: + user_identification_t_license_id_get(self) -> qstring * + +ida_lumina.user_identification_t.user_name: + user_identification_t_user_name_get(self) -> qstring * + +class ida_lumina.user_stkpnt_t(): + + Proxy of C++ user_stkpnt_t class + + +ida_lumina.user_stkpnt_t.delta: + user_stkpnt_t_delta_get(self) -> int64 + +ida_lumina.user_stkpnt_t.fchunk_nr: + insn_site_t_fchunk_nr_get(self) -> uint32 + +ida_lumina.user_stkpnt_t.fchunk_off: + insn_site_t_fchunk_off_get(self) -> uint32 + +ida_lumina.user_stkpnt_t.toea(): + + toea(self, pfn) -> ea_t + + +class ida_lumina.user_stkpnts_t(): + + Proxy of C++ qvector<(user_stkpnt_t)> class + + +ida_lumina.user_stkpnts_t.at(): + + at(self, _idx) -> user_stkpnt_t + + +ida_lumina.user_stkpnts_t.begin(): + + begin(self) -> user_stkpnt_t + begin(self) -> user_stkpnt_t + + +ida_lumina.user_stkpnts_t.capacity(): + + capacity(self) -> size_t + + +ida_lumina.user_stkpnts_t.clear(): + + clear(self) + + +ida_lumina.user_stkpnts_t.empty(): + + empty(self) -> bool + + +ida_lumina.user_stkpnts_t.end(): + + end(self) -> user_stkpnt_t + end(self) -> user_stkpnt_t + + +ida_lumina.user_stkpnts_t.erase(): + + erase(self, it) -> user_stkpnt_t + erase(self, first, last) -> user_stkpnt_t + + +ida_lumina.user_stkpnts_t.extract(): + + extract(self) -> user_stkpnt_t + + +ida_lumina.user_stkpnts_t.grow(): + + grow(self, x=user_stkpnt_t()) + + +ida_lumina.user_stkpnts_t.inject(): + + inject(self, s, len) + + +ida_lumina.user_stkpnts_t.insert(): + + insert(self, it, x) -> user_stkpnt_t + + +ida_lumina.user_stkpnts_t.pop_back(): + + pop_back(self) + + +ida_lumina.user_stkpnts_t.push_back(): + + push_back(self, x) + push_back(self) -> user_stkpnt_t + + +ida_lumina.user_stkpnts_t.qclear(): + + qclear(self) + + +ida_lumina.user_stkpnts_t.reserve(): + + reserve(self, cnt) + + +ida_lumina.user_stkpnts_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_lumina.user_stkpnts_t.size(): + + size(self) -> size_t + + +ida_lumina.user_stkpnts_t.swap(): + + swap(self, r) + + +ida_lumina.user_stkpnts_t.truncate(): + + truncate(self) + + + +=== ida_lumina EPYDOC INJECTIONS === +ida_lumina.AMDF_FORCE +""" +apply kvps regardless of what's currently in the IDB, possibly +removing some attributes currently present (e.g., name, or prototype +could be lost) +""" + +ida_lumina.AMDF_UPGRADE +""" +"quality" than what's currently in the IDB + +apply kvps that seem to be of higher +""" + +ida_lumina.PMF_PUSH_MODE_MASK +""" +Conflict resolution mode. +""" +=== ida_lumina EPYDOC INJECTIONS END === class ida_moves.bookmarks_t(): Proxy of C++ bookmarks_t class @@ -37705,7 +49286,7 @@ ida_nalt.del_op_tinfo(): ida_nalt.del_refinfo(): - del_refinfo(ea, n) -> int + del_refinfo(ea, n) -> bool ida_nalt.del_source_linnum(): @@ -37966,7 +49547,7 @@ ida_nalt.get_outfile_encoding_idx(): ida_nalt.get_refinfo(): - get_refinfo(ri, ea, n) -> int + get_refinfo(ri, ea, n) -> bool ida_nalt.get_reftype_by_size(): @@ -38561,7 +50142,7 @@ ida_nalt.set_notcode(): set_notcode(ea) - Mark address so that it can not be converted to instruction. + Mark address so that it cannot be converted to instruction. @param ea (C++: ea_t) @@ -38590,12 +50171,12 @@ ida_nalt.set_outfile_encoding_idx(): ida_nalt.set_refinfo(): - set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> int + set_refinfo(ea, n, type, target=BADADDR, base=0, tdelta=0) -> bool ida_nalt.set_refinfo_ex(): - set_refinfo_ex(ea, n, ri) -> int + set_refinfo_ex(ea, n, ri) -> bool ida_nalt.set_retfp(): @@ -39049,8 +50630,8 @@ name is weak ida_nalt.AFL_ZSTROFF """ display struct field name at 0 offset when displaying an offset. -example: {offset somestruct.field_0} if this flag is clear, then -{offset somestruct} +example: \\v{offset somestruct.field_0} if this flag is clear, then +\\v{offset somestruct} """ ida_nalt.AP_ALLOWDUPS @@ -39340,6 +50921,12 @@ ida_nalt.NSUP_OREF7 outer complex reference information for operand 8 """ +ida_nalt.NSUP_ORIGFMD +""" +function metadata before lumina information was applied values +NSUP_ORIGFMD..NSUP_ORIGFMD+0x1000 are reserved +""" + ida_nalt.NSUP_POINTS """ SP change points blob (see funcs.cpp). values @@ -39441,7 +51028,7 @@ Patch netnode tag. ida_nalt.REFINFO_CUSTOM """ -a custom reference the kernel will call {notify}(ph.custom_offset, +a custom reference the kernel will call \\ph{notify}(ph.custom_offset, .... that can change all arguments used for calculations. This flag is useful for custom fixups """ @@ -39462,7 +51049,7 @@ destroy alignment dirs ida_nalt.REFINFO_RVAOFF """ based reference (rva) 'refinfo_t::base' will be forced to -'get_imagebase()' such a reference is displayed with the {a_rva} +'get_imagebase()' such a reference is displayed with the \\ash{a_rva} keyword """ @@ -39500,7 +51087,7 @@ C predefined macros. ida_nalt.RIDX_DBG_BINPATHS """ -debug binary paths, occupies 20 indexes +unused (20 indexes) """ ida_nalt.RIDX_DUALOP_GRAPH @@ -39583,6 +51170,11 @@ ida_nalt.RIDX_SRCDBG_PATHS source debug paths, occupies 20 indexes """ +ida_nalt.RIDX_SRCDBG_UNDESIRED +""" +user-closed source files, occupies 20 indexes +""" + ida_nalt.RIDX_STR_ENCODINGS """ a list of encodings for the program strings @@ -39648,9 +51240,9 @@ the next bytes of string type. ida_nalt.SWI_CUSTOM """ -custom jump table. {create_switch_xrefs} will be called to create code -xrefs for the table. Custom jump table must be created by the module -(see also 'SWI_STDTBL' ) +custom jump table. \\ph{create_switch_xrefs} will be called to create +code xrefs for the table. Custom jump table must be created by the +module (see also 'SWI_STDTBL' ) """ ida_nalt.SWI_DEFRET @@ -39985,7 +51577,7 @@ ida_name.extract_name(): @param line: input string (C++: const char *) @param x: x coordinate of cursor (C++: int) - @return: -1 if can not extract. otherwise length of the name + @return: -1 if cannot extract. otherwise length of the name ida_name.force_name(): @@ -40026,7 +51618,7 @@ ida_name.get_debug_name_ea(): ida_name.get_debug_names(): get_debug_names(names, ea1, ea2) - get_debug_names(ea1, ea2) -> PyObject * + get_debug_names(ea1, ea2, return_list=False) -> PyObject * ida_name.get_demangled_name(): @@ -40430,8 +52022,8 @@ ida_name.set_name(): @param ea: linear address. do nothing if ea is not valid (return 0). tail bytes can't have names. (C++: ea_t) - @param name: new name. NULL: do nothing (return 0). "" : delete - name. otherwise this is a new name. (C++: const char *) + @param name: new name. NULL: do nothing (return 0). "" : delete + name. otherwise this is a new name. (C++: const char *) @param flags: Set name flags . If a bit is not specified, then the corresponding action is not performed and the name will retain the same bits as before calling this function. @@ -40583,7 +52175,7 @@ use short form of demangled name ida_name.GN_STRICT """ -fail if can not demangle +fail if cannot demangle """ ida_name.GN_VISIBLE @@ -40651,6 +52243,13 @@ ida_name.SN_AUTO if set, make name autogenerated """ +ida_name.SN_DELTAIL +""" +delete the hindering item + +if name cannot be set because of a tail byte, +""" + ida_name.SN_FORCE """ if the specified name is already present in the database, try @@ -40659,9 +52258,8 @@ variations with a numerical suffix like "_123" ida_name.SN_IDBENC """ -non-ASCII bytes will be decoded accordingly - -the name is given in the IDB encoding; +the name is given in the IDB encoding; non-ASCII bytes will be decoded +accordingly. Specifying SN_IDBENC also implies SN_NODUMMY """ ida_name.SN_LOCAL @@ -40678,6 +52276,12 @@ clear, all invalid chars (those !is_ident_cp()) will be replaced by SUBSTCHAR List of valid characters is defined in ida.cfg """ +ida_name.SN_NODUMMY +""" +automatically prepend the name with '_' if it begins with a dummy +suffix such as 'sub_'. See also SN_IDBENC +""" + ida_name.SN_NOLIST """ if set, exclude name from the list. if not set, then include the name @@ -41300,8 +52904,8 @@ ida_offset.add_refinfo_dref(): add_refinfo_dref(insn, _from, ri, opval, type, opoff) -> ea_t - Add xrefs for a reference from the given instruction ({ea}). This - function creates a cross references to the target and the base. + Add xrefs for a reference from the given instruction (\insn_t{ea}). + This function creates a cross references to the target and the base. 'insn_t::add_off_drefs()' calls this function to create xrefs for 'offset' operand. @@ -41338,7 +52942,7 @@ ida_offset.calc_offset_base(): fixup information, current ds and cs values. @param ea: the referencing instruction/data address (C++: ea_t) - @param n: operand number 0: first operand 1: other operand (C++: + @param n: operand number 0: first operand 1: other operand (C++: int) @return: output base address or BADADDR @@ -41451,21 +53055,22 @@ ida_offset.get_offset_expression(): Get offset expression (in the form "offset name+displ"). This function - uses offset translation function ({translate}) if your IDP module has - such a function. Translation function is used to map linear addresses - in the program (only for offsets).Example: suppose we have instruction - at linear address 0x00011000: {mov ax, [bx+7422h]} and at ds:7422h: - {array dw ...} We want to represent the second operand with an offset - expression, so then we call: { get_offset_expresion(0x001100, 1, - 0x001102, 0x7422, buf); | | | | | | | | | +output buffer | | | +value - of offset expression | | +address offset value in the instruction | - +the second operand +address of instruction } and the function will - return a colored string: {offset array} + uses offset translation function (\ph{translate}) if your IDP module + has such a function. Translation function is used to map linear + addresses in the program (only for offsets).Example: suppose we have + instruction at linear address 0x00011000: {mov ax, [bx+7422h]} and + at ds:7422h: {array dw ...} We want to represent the second operand + with an offset expression, so then we call: { + get_offset_expresion(0x001100, 1, 0x001102, 0x7422, buf); | | | | | | + | | | +output buffer | | | +value of offset expression | | +address + offset value in the instruction | +the second operand +address of + instruction } and the function will return a colored string: {offset + array} @param ea: start of instruction or data with the offset expression (C++: ea_t) @param n: number of operand (may be ORed with OPND_OUTER ) 0: first - operand 1: second operand (C++: int) + operand 1: second operand (C++: int) @param _from: linear address of instruction operand or data referring to the name. This address will be used to get fixup information, so it should point to exact position of @@ -41475,11 +53080,11 @@ ida_offset.get_offset_expression(): (C++: adiff_t) @param getn_flags: combination of: GETN_APPZERO : meaningful only if the name refers to a structure. appends the struct - field name if the field offset is zero GETN_NODUMMY - : do not generate dummy names for the expression - but pretend they already exist (useful to verify - that the offset expression can be represented) - (C++: int) + field name if the field offset is zero + GETN_NODUMMY : do not generate dummy names for the + expression but pretend they already exist (useful + to verify that the offset expression can be + represented) (C++: int) ida_offset.op_offset(): @@ -41507,10 +53112,10 @@ ida_offset.op_offset_ex(): 'clr_op_type()' function. @param ea: linear address. if 'ea' has unexplored bytes, try to - convert them to no segment: fail 16bit segment: to 16bit - word data 32bit segment: to dword (C++: ea_t) + convert them to no segment: fail 16bit segment: to + 16bit word data 32bit segment: to dword (C++: ea_t) @param n: number of operand (may be ORed with OPND_OUTER ) 0: first - 1: second 2: third OPND_MASK : all operands (C++: int) + 1: second 2: third OPND_MASK : all operands (C++: int) @param ri: reference information (C++: const refinfo_t *) @return: success @@ -41538,6 +53143,12 @@ ida_pro.boolvec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.boolvec_t.append(): + + push_back(self, x) + push_back(self) -> bool & + + ida_pro.boolvec_t.at(): __getitem__(self, i) -> bool const & @@ -41700,12 +53311,6 @@ ida_pro.check_process_exit(): @param exit_code: pointer to the buffer for the exit code (C++: int *) -ida_pro.check_type_trait(): - - check_type_trait(arg1) -> bool - check_type_trait(arg1) -> bool - - ida_pro.clear_bits(): clear_bits(bitmap, low, high) @@ -41769,6 +53374,128 @@ ida_pro.ea_pointer_frompointer(): ea_pointer_frompointer(t) -> ea_pointer +class ida_pro.eavec_t(): + + Proxy of C++ qvector<(unsigned-ea-like-numeric-type)> class + + +ida_pro.eavec_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_pro.eavec_t.append(): + + push_back(self, x) + push_back(self) -> unsigned-ea-like-numeric-type & + + +ida_pro.eavec_t.at(): + + __getitem__(self, i) -> unsigned-ea-like-numeric-type & + + +ida_pro.eavec_t.begin(): + + begin(self) -> qvector< unsigned-ea-like-numeric-type >::iterator + begin(self) -> qvector< unsigned-ea-like-numeric-type >::const_iterator + + +ida_pro.eavec_t.capacity(): + + capacity(self) -> size_t + + +ida_pro.eavec_t.clear(): + + clear(self) + + +ida_pro.eavec_t.empty(): + + empty(self) -> bool + + +ida_pro.eavec_t.end(): + + end(self) -> qvector< unsigned-ea-like-numeric-type >::iterator + end(self) -> qvector< unsigned-ea-like-numeric-type >::const_iterator + + +ida_pro.eavec_t.erase(): + + erase(self, it) -> qvector< unsigned-ea-like-numeric-type >::iterator + erase(self, first, last) -> qvector< unsigned-ea-like-numeric-type >::iterator + + +ida_pro.eavec_t.extract(): + + extract(self) -> unsigned-ea-like-numeric-type * + + +ida_pro.eavec_t.find(): + + find(self, x) -> qvector< unsigned-ea-like-numeric-type >::iterator + find(self, x) -> qvector< unsigned-ea-like-numeric-type >::const_iterator + + +ida_pro.eavec_t.has(): + + has(self, x) -> bool + + +ida_pro.eavec_t.inject(): + + inject(self, s, len) + + +ida_pro.eavec_t.insert(): + + insert(self, it, x) -> qvector< unsigned-ea-like-numeric-type >::iterator + + +ida_pro.eavec_t.pop_back(): + + pop_back(self) + + +ida_pro.eavec_t.push_back(): + + push_back(self, x) + push_back(self) -> unsigned-ea-like-numeric-type & + + +ida_pro.eavec_t.qclear(): + + qclear(self) + + +ida_pro.eavec_t.reserve(): + + reserve(self, cnt) + + +ida_pro.eavec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_pro.eavec_t.size(): + + size(self) -> size_t + + +ida_pro.eavec_t.swap(): + + swap(self, r) + + +ida_pro.eavec_t.truncate(): + + truncate(self) + + ida_pro.extend_sign(): extend_sign(v, nbytes, sign_extend) -> uint64 @@ -41818,6 +53545,12 @@ ida_pro.int64vec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.int64vec_t.append(): + + push_back(self, x) + push_back(self) -> long long & + + ida_pro.int64vec_t.at(): __getitem__(self, i) -> long long const & @@ -41964,6 +53697,12 @@ ida_pro.intvec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.intvec_t.append(): + + push_back(self, x) + push_back(self) -> int & + + ida_pro.intvec_t.at(): __getitem__(self, i) -> int const & @@ -42115,6 +53854,12 @@ ida_pro.longlongvec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.longlongvec_t.append(): + + push_back(self, x) + push_back(self) -> long long & + + ida_pro.longlongvec_t.at(): __getitem__(self, i) -> long long const & @@ -42227,7 +53972,7 @@ ida_pro.parse_dbgopts(): Parse the -r command line switch (for instant debugging). r_switch - points to the value of the -r switch. Example: win32+ + points to the value of the -r switch. Example: win32@localhost+ @param ido (C++: struct instant_dbgopts_t *) @param r_switch (C++: const char *) @@ -42606,6 +54351,12 @@ class ida_pro.strvec_t(): Proxy of C++ qvector<(simpleline_t)> class +ida_pro.strvec_t.append(): + + push_back(self, x) + push_back(self) -> simpleline_t & + + ida_pro.strvec_t.at(): __getitem__(self, i) -> simpleline_t const & @@ -42746,6 +54497,12 @@ ida_pro.svalvec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.svalvec_t.append(): + + push_back(self, x) + push_back(self) -> signed-ea-like-numeric-type & + + ida_pro.svalvec_t.at(): __getitem__(self, i) -> signed-ea-like-numeric-type & @@ -42902,6 +54659,12 @@ ida_pro.uint64vec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.uint64vec_t.append(): + + push_back(self, x) + push_back(self) -> unsigned long long & + + ida_pro.uint64vec_t.at(): __getitem__(self, i) -> unsigned long long const & @@ -43018,6 +54781,12 @@ ida_pro.uintvec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.uintvec_t.append(): + + push_back(self, x) + push_back(self) -> unsigned int & + + ida_pro.uintvec_t.at(): __getitem__(self, i) -> unsigned int const & @@ -43134,6 +54903,12 @@ ida_pro.ulonglongvec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.ulonglongvec_t.append(): + + push_back(self, x) + push_back(self) -> unsigned long long & + + ida_pro.ulonglongvec_t.at(): __getitem__(self, i) -> unsigned long long const & @@ -43270,6 +55045,12 @@ ida_pro.uvalvec_t.add_unique(): add_unique(self, x) -> bool +ida_pro.uvalvec_t.append(): + + push_back(self, x) + push_back(self) -> unsigned-ea-like-numeric-type & + + ida_pro.uvalvec_t.at(): __getitem__(self, i) -> unsigned-ea-like-numeric-type & @@ -43399,12 +55180,12 @@ UTF-16 codepage. ida_pro.IDA_SDK_VERSION """ -IDA SDK v7.2. +IDA SDK v7.3. """ ida_pro.IDBDEC_ESCAPE """ -convert non-printable characters to C escapes (, , ) +convert non-printable characters to C escapes (, \\xNN, \\uNNNN) """ ida_pro.IOREDIR_APPEND @@ -44204,13 +55985,12 @@ ida_registry.reg_read_string(): ida_registry.reg_read_strlist(): - reg_read_strlist(list, subkey) + reg_read_strlist(subkey) Retrieve all string values associated with the given key. Also see 'reg_update_strlist()' . - @param list (C++: qstrvec_t *) @param subkey (C++: const char *) @@ -44494,7 +56274,7 @@ search towards higher addresses ida_search.SEARCH_IDENT """ search for an identifier (text search). it means that the characters -before and after the match can not be is_visible_char(). +before and after the match cannot be is_visible_char(). """ ida_search.SEARCH_NEXT @@ -44555,10 +56335,10 @@ ida_segment.add_segm(): @param name: name of new segment. may be NULL (C++: const char *) @param sclass: class of the segment. may be NULL. type of the new segment is modified if class is one of predefined - names: "CODE" -> SEG_CODE "DATA" -> SEG_DATA - "CONST" -> SEG_DATA "STACK" -> SEG_BSS "BSS" -> - SEG_BSS "XTRN" -> SEG_XTRN "COMM" -> SEG_COMM "ABS" - -> SEG_ABSSYM (C++: const char *) + names: "CODE" -> SEG_CODE "DATA" -> SEG_DATA + "CONST" -> SEG_DATA "STACK" -> SEG_BSS "BSS" -> + SEG_BSS "XTRN" -> SEG_XTRN "COMM" -> SEG_COMM + "ABS" -> SEG_ABSSYM (C++: const char *) @param flags (C++: int) @@ -44577,8 +56357,8 @@ ida_segment.add_segm_ex(): s.start_ea== BADADDR then s.start_ea <- get_segm_base(&s) if s.end_ea== BADADDR , then a segment up to the next segment will be created (if the next segment doesn't exist, - then 1 byte segment will be created). if the s.end_ea < - s.start_ea, then fail. if s.end_ea is too high and the new + then 1 byte segment will be created). if the s.end_ea < + s.start_ea, then fail. if s.end_ea is too high and the new segment would overlap the next segment, s.end_ea is adjusted properly. (C++: segment_t *) @param name: name of new segment. may be NULL. if specified, the @@ -44948,7 +56728,7 @@ ida_segment.is_finally_visible_segm(): is_finally_visible_segm(s) -> bool - See 'SFL_HIDDEN' , 'SW_SHHID_SEGM' . + See 'SFL_HIDDEN' , 'SCF_SHHID_SEGM' . @param s (C++: segment_t *) @@ -45015,8 +56795,8 @@ ida_segment.lock_segm(): Lock segment pointer Locked pointers are guaranteed to remain valid - until they are unlocked. Ranges with locked pointers can not be - deleted or moved. + until they are unlocked. Ranges with locked pointers cannot be deleted + or moved. @param segm (C++: const segment_t *) @param lock (C++: bool) @@ -45066,11 +56846,11 @@ ida_segment.move_segm_start(): linear address. (C++: ea_t) @param mode: policy for destroying defined items 0: if it is necessary to destroy defined items, display a dialog box - and ask confirmation 1: if it is necessary to destroy + and ask confirmation 1: if it is necessary to destroy defined items, just destroy them without asking the user -1: if it is necessary to destroy defined items, don't - destroy them (i.e. function will fail) -2: don't destroy - defined items (function will succeed) (C++: int) + destroy them (i.e. function will fail) -2: don't + destroy defined items (function will succeed) (C++: int) ida_segment.rebase_program(): @@ -45375,8 +57155,8 @@ ida_segment.set_segm_addressing(): and names in the segment @param s: pointer to segment (C++: segment_t *) - @param bitness: new addressing mode of segment 2: 64bit segment 1: - 32bit segment 0: 16bit segment (C++: size_t) + @param bitness: new addressing mode of segment 2: 64bit segment 1: + 32bit segment 0: 16bit segment (C++: size_t) @return: success @@ -45403,8 +57183,8 @@ ida_segment.set_segm_class(): @param sclass: segment class (may be NULL). If segment type is SEG_NORM and segment class is one of predefined names, then segment type is changed to: "CODE" -> SEG_CODE - "DATA" -> SEG_DATA "STACK" -> SEG_BSS "BSS" -> - SEG_BSS if "UNK" then segment type is reset to + "DATA" -> SEG_DATA "STACK" -> SEG_BSS "BSS" -> + SEG_BSS if "UNK" then segment type is reset to SEG_NORM . (C++: const char *) @param flags (C++: int) @@ -45496,8 +57276,8 @@ ida_segment.set_selector(): the creation of the segment will fail. @param selector: number of selector to map if selector == BADSEL , - then return 0 (fail) if the selector has had a - mapping, old mapping is destroyed if the selector + then return 0 (fail) if the selector has had a + mapping, old mapping is destroyed if the selector number is equal to paragraph value, then the mapping is destroyed because we don't need to keep trivial mappings. (C++: sel_t) @@ -45570,7 +57350,7 @@ fill gap between new segment and previous one. i.e. if such a gap exists, and this gap is less than 64K, then fill the gap by extending the previous segment and adding .align directive to it. This way we avoid gaps between segments. too many gaps lead to a virtual array -failure. it can not hold more than ~1000 gaps. +failure. it cannot hold more than ~1000 gaps. """ ida_segment.ADDSEG_IDBENC @@ -45652,18 +57432,16 @@ ida_segment.MAX_SEGM_TRANSLATIONS max number of segment translations """ -ida_segment.MFS_NETMAP -""" -valid for 'rebase_program()' - -change inf.netdelta if possible (this is faster) -""" - ida_segment.MOVE_SEGM_CHUNK """ Too many chunks are defined, can't move. """ +ida_segment.MOVE_SEGM_DEBUG +""" +Debugger segments cannot be moved. +""" + ida_segment.MOVE_SEGM_IDP """ IDP module forbids moving the segment. @@ -45676,7 +57454,7 @@ The segment has been moved but the loader complained. ida_segment.MOVE_SEGM_ODD """ -Can not move segments by an odd number of bytes. +Cannot move segments by an odd number of bytes. """ ida_segment.MOVE_SEGM_OK @@ -45711,6 +57489,13 @@ ida_segment.MSF_LDKEEP keep the loader in the memory (optimization) """ +ida_segment.MSF_NETNODES +""" +valid for 'rebase_program()' + +move netnodes instead of changing inf.netdelta (this is slower) +""" + ida_segment.MSF_NOFIX """ don't call the loader to fix relocations @@ -46027,8 +57812,8 @@ ida_segregs.del_sreg_range(): Delete segment register range started at ea. When a segment register range is deleted, the previous range is extended to cover the empty - space. The segment register range at the beginning of a segment can - not be deleted. + space. The segment register range at the beginning of a segment cannot + be deleted. @param ea: start_ea of the deleted range (C++: ea_t) @param rg: the segment register number (C++: int) @@ -46558,6 +58343,18 @@ ida_struct.get_member_fullname(): @param mid (C++: tid_t) +ida_struct.get_member_id(): + + get_member_id(sptr, offset) -> tid_t + + + Get member id at given offset. + + + @param sptr (C++: const struc_t *) + @param offset (C++: asize_t) + + ida_struct.get_member_name(): get_member_name(mid) -> ssize_t @@ -47268,7 +59065,7 @@ new type must be compatible with the old ida_struct.SET_MEMTI_FUNCARG """ -mptr is function argument (can not create arrays) +mptr is function argument (cannot create arrays) """ ida_struct.SET_MEMTI_MAY_DESTROY @@ -48234,7 +60031,7 @@ ida_typeinf.alloc_type_ordinal(): alloc_type_ordinal(ti) -> uint32 - {alloc_type_ordinals,ti,1} + \call2{alloc_type_ordinals,ti,1} @param ti (C++: til_t *) @@ -48382,7 +60179,7 @@ ida_typeinf.apply_tinfo_to_stkarg(): Helper function for the processor modules. to be called from - {use_stkarg_type} + \ph{use_stkarg_type} @param insn (C++: const insn_t &) @param x (C++: const op_t &) @@ -48466,6 +60263,16 @@ ida_typeinf.argloc_t.get_rrel(): get_rrel(self) -> rrel_t +ida_typeinf.argloc_t.has_reg(): + + has_reg(self) -> bool + + +ida_typeinf.argloc_t.has_stkoff(): + + has_stkoff(self) -> bool + + ida_typeinf.argloc_t.is_badloc(): is_badloc(self) -> bool @@ -48648,6 +60455,16 @@ ida_typeinf.argpart_t.get_rrel(): get_rrel(self) -> rrel_t +ida_typeinf.argpart_t.has_reg(): + + has_reg(self) -> bool + + +ida_typeinf.argpart_t.has_stkoff(): + + has_stkoff(self) -> bool + + ida_typeinf.argpart_t.is_badloc(): is_badloc(self) -> bool @@ -48765,6 +60582,127 @@ ida_typeinf.argpart_t.swap(): swap(self, r) +class ida_typeinf.argpartvec_t(): + + Proxy of C++ qvector<(argpart_t)> class + + +ida_typeinf.argpartvec_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_typeinf.argpartvec_t.at(): + + at(self, _idx) -> argpart_t + + +ida_typeinf.argpartvec_t.begin(): + + begin(self) -> argpart_t + begin(self) -> argpart_t + + +ida_typeinf.argpartvec_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.argpartvec_t.clear(): + + clear(self) + + +ida_typeinf.argpartvec_t.empty(): + + empty(self) -> bool + + +ida_typeinf.argpartvec_t.end(): + + end(self) -> argpart_t + end(self) -> argpart_t + + +ida_typeinf.argpartvec_t.erase(): + + erase(self, it) -> argpart_t + erase(self, first, last) -> argpart_t + + +ida_typeinf.argpartvec_t.extract(): + + extract(self) -> argpart_t + + +ida_typeinf.argpartvec_t.find(): + + find(self, x) -> argpart_t + find(self, x) -> argpart_t + + +ida_typeinf.argpartvec_t.grow(): + + grow(self, x=argpart_t()) + + +ida_typeinf.argpartvec_t.has(): + + has(self, x) -> bool + + +ida_typeinf.argpartvec_t.inject(): + + inject(self, s, len) + + +ida_typeinf.argpartvec_t.insert(): + + insert(self, it, x) -> argpart_t + + +ida_typeinf.argpartvec_t.pop_back(): + + pop_back(self) + + +ida_typeinf.argpartvec_t.push_back(): + + push_back(self, x) + push_back(self) -> argpart_t + + +ida_typeinf.argpartvec_t.qclear(): + + qclear(self) + + +ida_typeinf.argpartvec_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.argpartvec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.argpartvec_t.size(): + + size(self) -> size_t + + +ida_typeinf.argpartvec_t.swap(): + + swap(self, r) + + +ida_typeinf.argpartvec_t.truncate(): + + truncate(self) + + class ida_typeinf.array_type_data_t(): Proxy of C++ array_type_data_t class @@ -48963,14 +60901,6 @@ ida_typeinf.compact_til(): @return: true if any memory was freed -ida_typeinf.compare(): - - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - compare(a, b) -> int - - ida_typeinf.compare_tinfo(): compare_tinfo(t1, t2, tcflags) -> bool @@ -49042,7 +60972,7 @@ ida_typeinf.default_compiler(): default_compiler() -> comp_t - Get compiler specified by {inf,idainfo,cc}. + Get compiler specified by armem{inf,idainfo,cc}. ida_typeinf.del_named_type(): @@ -49093,8 +61023,8 @@ ida_typeinf.deref_ptr(): Dereference a pointer. - @param ptr_ea: in/out parameter in: address of the pointer out: the - pointed address (C++: ea_t *) + @param ptr_ea: in/out parameter in: address of the pointer out: + the pointed address (C++: ea_t *) @param tif: type of the pointer (C++: const tinfo_t &) @param closure_obj: closure object (not used yet) (C++: ea_t *) @return: success @@ -49153,11 +61083,148 @@ ida_typeinf.enum_member_t.swap(): ida_typeinf.enum_member_t.value: enum_member_t_value_get(self) -> uint64 +class ida_typeinf.enum_member_vec_t(): + + Proxy of C++ qvector<(enum_member_t)> class + + +ida_typeinf.enum_member_vec_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_typeinf.enum_member_vec_t.at(): + + at(self, _idx) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.begin(): + + begin(self) -> enum_member_t + begin(self) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.enum_member_vec_t.clear(): + + clear(self) + + +ida_typeinf.enum_member_vec_t.empty(): + + empty(self) -> bool + + +ida_typeinf.enum_member_vec_t.end(): + + end(self) -> enum_member_t + end(self) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.erase(): + + erase(self, it) -> enum_member_t + erase(self, first, last) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.extract(): + + extract(self) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.find(): + + find(self, x) -> enum_member_t + find(self, x) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.grow(): + + grow(self, x=enum_member_t()) + + +ida_typeinf.enum_member_vec_t.has(): + + has(self, x) -> bool + + +ida_typeinf.enum_member_vec_t.inject(): + + inject(self, s, len) + + +ida_typeinf.enum_member_vec_t.insert(): + + insert(self, it, x) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.pop_back(): + + pop_back(self) + + +ida_typeinf.enum_member_vec_t.push_back(): + + push_back(self, x) + push_back(self) -> enum_member_t + + +ida_typeinf.enum_member_vec_t.qclear(): + + qclear(self) + + +ida_typeinf.enum_member_vec_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.enum_member_vec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.enum_member_vec_t.size(): + + size(self) -> size_t + + +ida_typeinf.enum_member_vec_t.swap(): + + swap(self, r) + + +ida_typeinf.enum_member_vec_t.truncate(): + + truncate(self) + + class ida_typeinf.enum_type_data_t(): Proxy of C++ enum_type_data_t class +ida_typeinf.enum_type_data_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_typeinf.enum_type_data_t.at(): + + at(self, _idx) -> enum_member_t + + +ida_typeinf.enum_type_data_t.begin(): + + begin(self) -> enum_member_t + begin(self) -> enum_member_t + + ida_typeinf.enum_type_data_t.bte: enum_type_data_t_bte_get(self) -> bte_t @@ -49171,9 +61238,67 @@ ida_typeinf.enum_type_data_t.calc_nbytes(): calc_nbytes(self) -> int +ida_typeinf.enum_type_data_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.enum_type_data_t.clear(): + + clear(self) + + +ida_typeinf.enum_type_data_t.empty(): + + empty(self) -> bool + + +ida_typeinf.enum_type_data_t.end(): + + end(self) -> enum_member_t + end(self) -> enum_member_t + + +ida_typeinf.enum_type_data_t.erase(): + + erase(self, it) -> enum_member_t + erase(self, first, last) -> enum_member_t + + +ida_typeinf.enum_type_data_t.extract(): + + extract(self) -> enum_member_t + + +ida_typeinf.enum_type_data_t.find(): + + find(self, x) -> enum_member_t + find(self, x) -> enum_member_t + + ida_typeinf.enum_type_data_t.group_sizes: enum_type_data_t_group_sizes_get(self) -> intvec_t * +ida_typeinf.enum_type_data_t.grow(): + + grow(self, x=enum_member_t()) + + +ida_typeinf.enum_type_data_t.has(): + + has(self, x) -> bool + + +ida_typeinf.enum_type_data_t.inject(): + + inject(self, s, len) + + +ida_typeinf.enum_type_data_t.insert(): + + insert(self, it, x) -> enum_member_t + + ida_typeinf.enum_type_data_t.is_64bit(): is_64bit(self) -> bool @@ -49199,6 +61324,38 @@ ida_typeinf.enum_type_data_t.is_udec(): is_udec(self) -> bool +ida_typeinf.enum_type_data_t.pop_back(): + + pop_back(self) + + +ida_typeinf.enum_type_data_t.push_back(): + + push_back(self, x) + push_back(self) -> enum_member_t + + +ida_typeinf.enum_type_data_t.qclear(): + + qclear(self) + + +ida_typeinf.enum_type_data_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.enum_type_data_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.enum_type_data_t.size(): + + size(self) -> size_t + + ida_typeinf.enum_type_data_t.swap(): swap(self, r) @@ -49207,6 +61364,11 @@ ida_typeinf.enum_type_data_t.swap(): ida_typeinf.enum_type_data_t.taenum_bits: enum_type_data_t_taenum_bits_get(self) -> uint32 +ida_typeinf.enum_type_data_t.truncate(): + + truncate(self) + + ida_typeinf.extract_argloc(): extract_argloc(vloc, ptype, is_retval) -> bool @@ -50973,6 +63135,12 @@ ida_typeinf.reginfovec_t.add_unique(): add_unique(self, x) -> bool +ida_typeinf.reginfovec_t.append(): + + push_back(self, x) + push_back(self) -> reg_info_t + + ida_typeinf.reginfovec_t.at(): __getitem__(self, i) -> reg_info_t @@ -51108,6 +63276,211 @@ class ida_typeinf.regobjs_t(): Proxy of C++ regobjs_t class +ida_typeinf.regobjs_t.at(): + + at(self, _idx) -> regobj_t + + +ida_typeinf.regobjs_t.begin(): + + begin(self) -> regobj_t + begin(self) -> regobj_t + + +ida_typeinf.regobjs_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.regobjs_t.clear(): + + clear(self) + + +ida_typeinf.regobjs_t.empty(): + + empty(self) -> bool + + +ida_typeinf.regobjs_t.end(): + + end(self) -> regobj_t + end(self) -> regobj_t + + +ida_typeinf.regobjs_t.erase(): + + erase(self, it) -> regobj_t + erase(self, first, last) -> regobj_t + + +ida_typeinf.regobjs_t.extract(): + + extract(self) -> regobj_t + + +ida_typeinf.regobjs_t.grow(): + + grow(self, x=regobj_t()) + + +ida_typeinf.regobjs_t.inject(): + + inject(self, s, len) + + +ida_typeinf.regobjs_t.insert(): + + insert(self, it, x) -> regobj_t + + +ida_typeinf.regobjs_t.pop_back(): + + pop_back(self) + + +ida_typeinf.regobjs_t.push_back(): + + push_back(self, x) + push_back(self) -> regobj_t + + +ida_typeinf.regobjs_t.qclear(): + + qclear(self) + + +ida_typeinf.regobjs_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.regobjs_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.regobjs_t.size(): + + size(self) -> size_t + + +ida_typeinf.regobjs_t.swap(): + + swap(self, r) + + +ida_typeinf.regobjs_t.truncate(): + + truncate(self) + + +class ida_typeinf.regobjvec_t(): + + Proxy of C++ qvector<(regobj_t)> class + + +ida_typeinf.regobjvec_t.at(): + + at(self, _idx) -> regobj_t + + +ida_typeinf.regobjvec_t.begin(): + + begin(self) -> regobj_t + begin(self) -> regobj_t + + +ida_typeinf.regobjvec_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.regobjvec_t.clear(): + + clear(self) + + +ida_typeinf.regobjvec_t.empty(): + + empty(self) -> bool + + +ida_typeinf.regobjvec_t.end(): + + end(self) -> regobj_t + end(self) -> regobj_t + + +ida_typeinf.regobjvec_t.erase(): + + erase(self, it) -> regobj_t + erase(self, first, last) -> regobj_t + + +ida_typeinf.regobjvec_t.extract(): + + extract(self) -> regobj_t + + +ida_typeinf.regobjvec_t.grow(): + + grow(self, x=regobj_t()) + + +ida_typeinf.regobjvec_t.inject(): + + inject(self, s, len) + + +ida_typeinf.regobjvec_t.insert(): + + insert(self, it, x) -> regobj_t + + +ida_typeinf.regobjvec_t.pop_back(): + + pop_back(self) + + +ida_typeinf.regobjvec_t.push_back(): + + push_back(self, x) + push_back(self) -> regobj_t + + +ida_typeinf.regobjvec_t.qclear(): + + qclear(self) + + +ida_typeinf.regobjvec_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.regobjvec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.regobjvec_t.size(): + + size(self) -> size_t + + +ida_typeinf.regobjvec_t.swap(): + + swap(self, r) + + +ida_typeinf.regobjvec_t.truncate(): + + truncate(self) + + ida_typeinf.remove_abi_opts(): remove_abi_opts(abi_opts, user_level=False) -> bool @@ -51177,6 +63550,122 @@ class ida_typeinf.scattered_aloc_t(): Proxy of C++ scattered_aloc_t class +ida_typeinf.scattered_aloc_t.add_unique(): + + add_unique(self, x) -> bool + + +ida_typeinf.scattered_aloc_t.at(): + + at(self, _idx) -> argpart_t + + +ida_typeinf.scattered_aloc_t.begin(): + + begin(self) -> argpart_t + begin(self) -> argpart_t + + +ida_typeinf.scattered_aloc_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.scattered_aloc_t.clear(): + + clear(self) + + +ida_typeinf.scattered_aloc_t.empty(): + + empty(self) -> bool + + +ida_typeinf.scattered_aloc_t.end(): + + end(self) -> argpart_t + end(self) -> argpart_t + + +ida_typeinf.scattered_aloc_t.erase(): + + erase(self, it) -> argpart_t + erase(self, first, last) -> argpart_t + + +ida_typeinf.scattered_aloc_t.extract(): + + extract(self) -> argpart_t + + +ida_typeinf.scattered_aloc_t.find(): + + find(self, x) -> argpart_t + find(self, x) -> argpart_t + + +ida_typeinf.scattered_aloc_t.grow(): + + grow(self, x=argpart_t()) + + +ida_typeinf.scattered_aloc_t.has(): + + has(self, x) -> bool + + +ida_typeinf.scattered_aloc_t.inject(): + + inject(self, s, len) + + +ida_typeinf.scattered_aloc_t.insert(): + + insert(self, it, x) -> argpart_t + + +ida_typeinf.scattered_aloc_t.pop_back(): + + pop_back(self) + + +ida_typeinf.scattered_aloc_t.push_back(): + + push_back(self, x) + push_back(self) -> argpart_t + + +ida_typeinf.scattered_aloc_t.qclear(): + + qclear(self) + + +ida_typeinf.scattered_aloc_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.scattered_aloc_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.scattered_aloc_t.size(): + + size(self) -> size_t + + +ida_typeinf.scattered_aloc_t.swap(): + + swap(self, r) + + +ida_typeinf.scattered_aloc_t.truncate(): + + truncate(self) + + ida_typeinf.score_tinfo(): score_tinfo(tif) -> uint32 @@ -51480,6 +63969,11 @@ ida_typeinf.tinfo_t.convert_array_to_ptr(): convert_array_to_ptr(self) -> bool +ida_typeinf.tinfo_t.copy(): + + copy(self) -> tinfo_t + + ida_typeinf.tinfo_t.create_array(): create_array(self, p, decl_type=BT_ARRAY) -> bool @@ -51542,7 +64036,6 @@ ida_typeinf.tinfo_t.del_attrs(): ida_typeinf.tinfo_t.deserialize(): - deserialize(self, til, ptype, pfields=None, pfldcmts=None) -> bool deserialize(self, til, ptype, pfields=None, pfldcmts=None) -> bool deserialize(self, til, type, fields, cmts=None) -> bool @@ -52222,6 +64715,11 @@ ida_typeinf.tinfo_t.is_vararg_cc(): is_vararg_cc(self) -> bool +ida_typeinf.tinfo_t.is_varstruct(): + + is_varstruct(self) -> bool + + ida_typeinf.tinfo_t.is_vftable(): is_vftable(self) -> bool @@ -52968,8 +65466,9 @@ ida_typeinf.unpack_idcobj_from_idb(): unpack_idcobj_from_idb(obj, tif, ea, off0, pio_flags=0) -> error_t - Read a typed idc object from the database. + Collection of register objects. + Read a typed idc object from the database @param obj (C++: idc_value_t *) @param tif (C++: const tinfo_t &) @@ -53025,6 +65524,211 @@ class ida_typeinf.valstrs_t(): Proxy of C++ valstrs_t class +ida_typeinf.valstrs_t.at(): + + at(self, _idx) -> valstr_t + + +ida_typeinf.valstrs_t.begin(): + + begin(self) -> valstr_t + begin(self) -> valstr_t + + +ida_typeinf.valstrs_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.valstrs_t.clear(): + + clear(self) + + +ida_typeinf.valstrs_t.empty(): + + empty(self) -> bool + + +ida_typeinf.valstrs_t.end(): + + end(self) -> valstr_t + end(self) -> valstr_t + + +ida_typeinf.valstrs_t.erase(): + + erase(self, it) -> valstr_t + erase(self, first, last) -> valstr_t + + +ida_typeinf.valstrs_t.extract(): + + extract(self) -> valstr_t + + +ida_typeinf.valstrs_t.grow(): + + grow(self, x=valstr_t()) + + +ida_typeinf.valstrs_t.inject(): + + inject(self, s, len) + + +ida_typeinf.valstrs_t.insert(): + + insert(self, it, x) -> valstr_t + + +ida_typeinf.valstrs_t.pop_back(): + + pop_back(self) + + +ida_typeinf.valstrs_t.push_back(): + + push_back(self, x) + push_back(self) -> valstr_t + + +ida_typeinf.valstrs_t.qclear(): + + qclear(self) + + +ida_typeinf.valstrs_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.valstrs_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.valstrs_t.size(): + + size(self) -> size_t + + +ida_typeinf.valstrs_t.swap(): + + swap(self, r) + + +ida_typeinf.valstrs_t.truncate(): + + truncate(self) + + +class ida_typeinf.valstrvec_t(): + + Proxy of C++ qvector<(valstr_t)> class + + +ida_typeinf.valstrvec_t.at(): + + at(self, _idx) -> valstr_t + + +ida_typeinf.valstrvec_t.begin(): + + begin(self) -> valstr_t + begin(self) -> valstr_t + + +ida_typeinf.valstrvec_t.capacity(): + + capacity(self) -> size_t + + +ida_typeinf.valstrvec_t.clear(): + + clear(self) + + +ida_typeinf.valstrvec_t.empty(): + + empty(self) -> bool + + +ida_typeinf.valstrvec_t.end(): + + end(self) -> valstr_t + end(self) -> valstr_t + + +ida_typeinf.valstrvec_t.erase(): + + erase(self, it) -> valstr_t + erase(self, first, last) -> valstr_t + + +ida_typeinf.valstrvec_t.extract(): + + extract(self) -> valstr_t + + +ida_typeinf.valstrvec_t.grow(): + + grow(self, x=valstr_t()) + + +ida_typeinf.valstrvec_t.inject(): + + inject(self, s, len) + + +ida_typeinf.valstrvec_t.insert(): + + insert(self, it, x) -> valstr_t + + +ida_typeinf.valstrvec_t.pop_back(): + + pop_back(self) + + +ida_typeinf.valstrvec_t.push_back(): + + push_back(self, x) + push_back(self) -> valstr_t + + +ida_typeinf.valstrvec_t.qclear(): + + qclear(self) + + +ida_typeinf.valstrvec_t.reserve(): + + reserve(self, cnt) + + +ida_typeinf.valstrvec_t.resize(): + + resize(self, _newsize, x) + resize(self, _newsize) + + +ida_typeinf.valstrvec_t.size(): + + size(self) -> size_t + + +ida_typeinf.valstrvec_t.swap(): + + swap(self, r) + + +ida_typeinf.valstrvec_t.truncate(): + + truncate(self) + + ida_typeinf.verify_argloc(): verify_argloc(vloc, size, gaps) -> int @@ -53057,6 +65761,11 @@ ida_typeinf.write_tinfo_bitfield_value(): === ida_typeinf EPYDOC INJECTIONS === +ida_typeinf.ADDTIL_ABORTED +""" +til was not loaded (incompatible til rejected by user) +""" + ida_typeinf.ADDTIL_COMP """ ok, but til is not compatible with the current compiler @@ -53430,6 +66139,11 @@ ida_typeinf.PCN_DEC decimal """ +ida_typeinf.PCN_DECSEXT +""" +automatically extend sign of signed decimal numbers +""" + ida_typeinf.PCN_HEX """ hexadecimal @@ -53609,7 +66323,7 @@ multifunctional purpose ida_typeinf.SETCOMP_BY_USER """ -invoked by user, can not be replaced by module/loader +invoked by user, cannot be replaced by module/loader """ ida_typeinf.SETCOMP_ONLY_ABI @@ -53745,6 +66459,16 @@ ida_typeinf.TAENUM_64BIT enum: store 64-bit values """ +ida_typeinf.TAENUM_SIGNED +""" +enum: signed +""" + +ida_typeinf.TAENUM_UNSIGNED +""" +enum: unsigned +""" + ida_typeinf.TAFLD_BASECLASS """ field: do not include but inherit from the current field @@ -53820,9 +66544,15 @@ ida_typeinf.TAUDT_VFTABLE struct: is virtual function table """ +ida_typeinf.TA_FORMAT +""" +info about the 'format' argument 3 times pack_dd: 'format_functype_t' +, argument number of 'format', argument number of '...' +""" + ida_typeinf.TA_ORG_ARRDIM """ -the original array dimension (append_dd) +the original array dimension (pack_dd) """ ida_typeinf.TA_ORG_TYPEDEF @@ -55007,6 +67737,11 @@ ida_ua.outctx_t.retrieve_name(): retrieve_name(self, arg2, arg3) -> ssize_t +ida_ua.outctx_t.set_bin_state(): + + set_bin_state(self, value) + + ida_ua.outctx_t.set_comment_addr(): set_comment_addr(self, ea) @@ -55343,7 +68078,7 @@ pointer to asciiz string ida_ua.dt_tbyte """ -variable size ({tbyte_size}) +variable size (\\ph{tbyte_size}) """ ida_ua.dt_unicode @@ -55427,6 +68162,12 @@ ida_xref.casevec_t.add_unique(): add_unique(self, x) -> bool +ida_xref.casevec_t.append(): + + push_back(self, x) + push_back(self) -> qvector< signed-ea-like-numeric-type > & + + ida_xref.casevec_t.at(): __getitem__(self, i) -> qvector< signed-ea-like-numeric-type > const & @@ -55579,9 +68320,9 @@ ida_xref.del_cref(): @param to: linear address of referenced instruction (C++: ea_t) @param expand: policy to delete the referenced instruction 1: plan to delete the referenced instruction if it has no more - references. 0: don't delete the referenced instruction - even if no more cross-references point to it (C++: - bool) + references. 0: don't delete the referenced + instruction even if no more cross-references point to + it (C++: bool) ida_xref.del_dref(): @@ -55846,7 +68587,7 @@ ida_xref.XREF_USER """ User specified xref. This xref will not be deleted by IDA. This bit should be combined with the existing xref types ( 'cref_t' & 'dref_t' -) Can not be used for fl_F xrefs +) Cannot be used for fl_F xrefs """ === ida_xref EPYDOC INJECTIONS END === idc.AutoMark(): @@ -56205,7 +68946,7 @@ idc.add_struc_member(): -1 means to add at the end of the structure @param flag: type of the new member. Should be one of FF_BYTE..FF_PACKREAL (see above) combined with FF_DATA - @param typeid: if isStruc(flag) then typeid specifies the structure id for the member + @param typeid: if is_struct(flag) then typeid specifies the structure id for the member if is_off0(flag) then typeid specifies the offset base. if is_strlit(flag) then typeid specifies the string type (STRTYPE_...). if is_stroff(flag) then typeid specifies the structure id @@ -56294,9 +69035,10 @@ idc.attach_process(): attach_process(pid=pid_t(-1), event_id=-1) -> int - Attach the debugger to a running process. {Type, Asynchronous function - - available as Request, Notification, 'dbg_process_attach' }This - function shouldn't be called as a request if 'NO_PROCESS' is used. + Attach the debugger to a running process. \sq{Type, Asynchronous + function - available as Request, Notification, 'dbg_process_attach' + }This function shouldn't be called as a request if 'NO_PROCESS' is + used. @param pid: PID of the process to attach to. If NO_PROCESS , a dialog box will interactively ask the user for the process to @@ -56337,8 +69079,10 @@ idc.auto_wait(): auto_wait() -> bool - Process everything in the queues and return true. Return false if - Ctrl-Break was pressed. + Process everything in the queues and return true. + + @return: false if the user clicked cancel. (the wait box must be + displayed by the caller if desired) idc.batch(): @@ -56452,7 +69196,7 @@ idc.create_byte(): idc.create_custom_data(): - create_custdata(ea, length, dtid, fid) -> bool + create_custdata(ea, length, dtid, fid, force=False) -> bool Convert to custom data type. @@ -56462,6 +69206,7 @@ idc.create_custom_data(): @param length (C++: asize_t) @param dtid (C++: int) @param fid (C++: int) + @param force (C++: bool) idc.create_data(): @@ -56617,9 +69362,9 @@ idc.define_exception(): Convenience function: define new exception code. - @param code: exception code (can not be 0) (C++: uint) - @param name: exception name (can not be empty or NULL) (C++: const - char *) + @param code: exception code (cannot be 0) (C++: uint) + @param name: exception name (cannot be empty or NULL) (C++: const char + *) @param desc: exception description (maybe NULL) (C++: const char *) @param flags: combination of Exception info flags (C++: int) @return: failure message or NULL. You must call store_exceptions() @@ -56674,9 +69419,9 @@ idc.del_cref(): @param to: linear address of referenced instruction (C++: ea_t) @param expand: policy to delete the referenced instruction 1: plan to delete the referenced instruction if it has no more - references. 0: don't delete the referenced instruction - even if no more cross-references point to it (C++: - bool) + references. 0: don't delete the referenced + instruction even if no more cross-references point to + it (C++: bool) idc.del_dref(): @@ -56888,7 +69633,7 @@ idc.detach_process(): detach_process() -> bool - Detach the debugger from the debugged process. {Type, Asynchronous + Detach the debugger from the debugged process. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_process_detach' } @@ -56943,7 +69688,7 @@ idc.exit_process(): exit_process() -> bool - Terminate the debugging of the current process. {Type, Asynchronous + Terminate the debugging of the current process. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_process_exit' } @@ -57164,7 +69909,7 @@ idc.get_bpt_tev_ea(): Get the address associated to a read, read/write or execution trace - event. {Type, Synchronous function, Notification, none (synchronous + event. \sq{Type, Synchronous function, Notification, none (synchronous function)}Usually, a breakpoint is associated with a read, read/write or execution trace event. However, the returned address could be any address in the range of this breakpoint. If the breakpoint was deleted @@ -57195,7 +69940,7 @@ idc.get_call_tev_callee(): get_call_tev_callee(n) -> ea_t - Get the called function from a function call trace event. {Type, + Get the called function from a function call trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 @@ -57238,8 +69983,8 @@ idc.get_current_thread(): get_current_thread() -> thid_t - Get current thread ID. {Type, Synchronous function, Notification, none - (synchronous function)} + Get current thread ID. \sq{Type, Synchronous function, Notification, + none (synchronous function)} idc.get_db_byte(): @@ -58072,7 +70817,7 @@ idc.get_local_tinfo(): Get local type information as 'typeinfo' object @param ordinal: slot number (1...NumberOfLocalTypes) - @return: None on failure, or (type, fields, name) tuple. + @return: None on failure, or (type, fields) tuple. idc.get_manual_insn(): @@ -58661,8 +71406,8 @@ idc.get_process_state(): get_process_state() -> int - Return the state of the currently debugged process. {Type, Synchronous - function, Notification, none (synchronous function)} + Return the state of the currently debugged process. \sq{Type, + Synchronous function, Notification, none (synchronous function)} @return: one of Debugged process states @@ -58673,7 +71418,7 @@ idc.get_processes(): Take a snapshot of running processes and return their description. - {Type, Synchronous function, Notification, none (synchronous + \sq{Type, Synchronous function, Notification, none (synchronous function)} @param proclist (C++: procinfo_vec_t *) @@ -58686,8 +71431,8 @@ idc.get_qword(): Get one qword (64-bit) of the program at 'ea'. This function takes - into account order of bytes specified in {is_be()} This function works - only for 8bit byte processors. + into account order of bytes specified in \inf{is_be()} This function + works only for 8bit byte processors. @param ea (C++: ea_t) @@ -58711,7 +71456,7 @@ idc.get_ret_tev_return(): get_ret_tev_return(n) -> ea_t - Get the return address from a function return trace event. {Type, + Get the return address from a function return trace event. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of trace event, is in range 0.. get_bpt_qty() -1. 0 @@ -58843,7 +71588,7 @@ idc.get_step_trace_options(): get_step_trace_options() -> int - Get current step tracing options. {Type, Synchronous function, + Get current step tracing options. \sq{Type, Synchronous function, Notification, none (synchronous function)} @return: Step trace options @@ -58954,7 +71699,7 @@ idc.get_tev_qty(): get_tev_qty() -> int - Get number of trace events available in trace buffer. {Type, + Get number of trace events available in trace buffer. \sq{Type, Synchronous function, Notification, none (synchronous function)} @@ -58973,8 +71718,8 @@ idc.get_thread_qty(): get_thread_qty() -> int - Get number of threads. {Type, Synchronous function, Notification, none - (synchronous function)} + Get number of threads. \sq{Type, Synchronous function, Notification, + none (synchronous function)} idc.get_tinfo(): @@ -59025,8 +71770,8 @@ idc.get_wide_dword(): Get two wide words (4 'bytes') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This - function takes into account order of bytes specified in {is_be()}this - function works incorrectly if {nbits} > 16 + function takes into account order of bytes specified in + \inf{is_be()}this function works incorrectly if \ph{nbits} > 16 @param ea (C++: ea_t) @@ -59039,7 +71784,7 @@ idc.get_wide_word(): Get one wide word (2 'byte') of the program at 'ea'. Some processors may access more than 8bit quantity at an address. These processors have 32-bit byte organization from the IDA's point of view. This - function takes into account order of bytes specified in {is_be()} + function takes into account order of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @@ -59068,7 +71813,7 @@ idc.getn_thread(): getn_thread(n) -> thid_t - Get the ID of a thread. {Type, Synchronous function, Notification, + Get the ID of a thread. \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of thread, is in range 0.. get_thread_qty() -1 (C++: @@ -59081,7 +71826,7 @@ idc.getn_thread_name(): getn_thread_name(n) -> char const * - Get the NAME of a thread {Type, Synchronous function, Notification, + Get the NAME of a thread \sq{Type, Synchronous function, Notification, none (synchronous function)} @param n: number of thread, is in range 0.. get_thread_qty() -1 or -1 @@ -59378,7 +72123,7 @@ idc.op_man(): @param ea: linear address (C++: ea_t) @param n: number of operand (0, 1, 2) (C++: int) - @param op: text of operand NULL: do nothing (return 0) "" : delete + @param op: text of operand NULL: do nothing (return 0) "" : delete forced operand (C++: const char *) @return: success @@ -59573,7 +72318,7 @@ idc.patch_dword(): Patch a dword of the program. The original value of the dword is saved and can be obtained by 'get_original_dword()' . This function DOESN'T work for wide byte processors. This function takes into account order - of bytes specified in {is_be()} + of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @param x (C++: uint64) @@ -59587,7 +72332,7 @@ idc.patch_qword(): Patch a qword of the program. The original value of the qword is saved and can be obtained by 'get_original_qword()' . This function DOESN'T work for wide byte processors. This function takes into account order - of bytes specified in {is_be()} + of bytes specified in \inf{is_be()} @param ea (C++: ea_t) @param x (C++: uint64) @@ -59601,7 +72346,7 @@ idc.patch_word(): Patch a word of the program. The original value of the word is saved and can be obtained by 'get_original_word()' . This function works for wide byte processors too. This function takes into account order of - bytes specified in {is_be()} + bytes specified in \inf{is_be()} @param ea (C++: ea_t) @param x (C++: uint64) @@ -59888,7 +72633,7 @@ idc.resume_thread(): resume_thread(tid) -> int - Resume thread. {Type, Synchronous function - available as request, + Resume thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @param tid: thread id (C++: thid_t) @@ -59925,7 +72670,7 @@ idc.run_to(): is active, a new process is started. Technically, the debugger sets up a temporary breakpoint at the given address, and continues (or starts) the execution of the whole process. So, all threads continue their - execution! {Type, Asynchronous function - available as Request, + execution! \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_run_to' } @param ea: target address (C++: ea_t) @@ -59975,7 +72720,7 @@ idc.select_thread(): Select the given thread as the current debugged thread. All thread related execution functions will work on this thread. The process must - be suspended to select a new thread. {Type, Synchronous function - + be suspended to select a new thread. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} @param tid: ID of the thread to select (C++: thid_t) @@ -60088,8 +72833,8 @@ idc.set_cmt(): Set an indented comment. @param ea: linear address (C++: ea_t) - @param comm: comment string NULL: do nothing (return 0) "" : delete - comment (C++: const char *) + @param comm: comment string NULL: do nothing (return 0) "" : + delete comment (C++: const char *) @param rptble: is repeatable? (C++: bool) @return: success @@ -60404,7 +73149,7 @@ idc.set_member_type(): @param member_offset: offset of the member @param flag: new type of the member. Should be one of FF_BYTE..FF_PACKREAL (see above) combined with FF_DATA - @param typeid: if isStruc(flag) then typeid specifies the structure id for the member + @param typeid: if is_struct(flag) then typeid specifies the structure id for the member if is_off0(flag) then typeid specifies the offset base. if is_strlit(flag) then typeid specifies the string type (STRTYPE_...). if is_stroff(flag) then typeid specifies the structure id @@ -60440,11 +73185,11 @@ idc.set_processor_type(): set_processor_type(procname, level) -> bool - Set target processor type. Once a processor module is loaded, it can - not be replaced until we close the idb. + Set target processor type. Once a processor module is loaded, it + cannot be replaced until we close the idb. @param procname: name of processor type (one of names present in - {psnames}) (C++: const char *) + \ph{psnames}) (C++: const char *) @param level: SETPROC_ (C++: setproc_level_t) @return: success @@ -60579,8 +73324,8 @@ idc.set_selector(): the creation of the segment will fail. @param selector: number of selector to map if selector == BADSEL , - then return 0 (fail) if the selector has had a - mapping, old mapping is destroyed if the selector + then return 0 (fail) if the selector has had a + mapping, old mapping is destroyed if the selector number is equal to paragraph value, then the mapping is destroyed because we don't need to keep trivial mappings. (C++: sel_t) @@ -60597,8 +73342,8 @@ idc.set_step_trace_options(): set_step_trace_options(options) - Modify step tracing options. {Type, Synchronous function - available - as request, Notification, none (synchronous function)} + Modify step tracing options. \sq{Type, Synchronous function - + available as request, Notification, none (synchronous function)} @param options (C++: int) @@ -60709,7 +73454,7 @@ idc.start_process(): start_process(path=None, args=None, sdir=None) -> int - Start a process in the debugger. {Type, Asynchronous function - + Start a process in the debugger. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_process_start' }You can also use the 'run_to()' function to easily start the execution of a process until a given address is reached.For all parameters, a NULL value @@ -60727,7 +73472,7 @@ idc.step_into(): Execute one instruction in the current thread. Other threads are kept - suspended. {Type, Asynchronous function - available as Request, + suspended. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_step_into' } @@ -60737,7 +73482,7 @@ idc.step_over(): Execute one instruction in the current thread, but without entering - into functions. Others threads keep suspended. {Type, Asynchronous + into functions. Others threads keep suspended. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_step_over' } @@ -60748,7 +73493,7 @@ idc.step_until_ret(): Execute instructions in the current thread until a function return instruction is executed (aka "step out"). Other threads are kept - suspended. {Type, Asynchronous function - available as Request, + suspended. \sq{Type, Asynchronous function - available as Request, Notification, 'dbg_step_until_ret' } @@ -60757,8 +73502,8 @@ idc.suspend_process(): suspend_process() -> bool - Suspend the process in the debugger. { Type,Synchronous function (if - in a notification handler)Asynchronous function (everywhere + Suspend the process in the debugger. \sq{ Type,Synchronous function + (if in a notification handler)Asynchronous function (everywhere else)available as Request, Notification,none (if in a notification handler) 'dbg_suspend_process' (everywhere else) }The 'suspend_process()' function can be called from a notification handler @@ -60773,7 +73518,7 @@ idc.suspend_thread(): Suspend thread. Suspending a thread may deadlock the whole application - if the suspended was owning some synchronization objects. {Type, + if the suspended was owning some synchronization objects. \sq{Type, Synchronous function - available as request, Notification, none (synchronous function)} diff --git a/python.cfg b/python.cfg index cc249f4..65e6c69 100644 --- a/python.cfg +++ b/python.cfg @@ -19,4 +19,7 @@ AUTOIMPORT_COMPAT_IDA695 = YES // Is IDAPython namespace-aware? // If yes, then plugins, loaders & processor modules will each be loaded // within their own namespace, preventing namespace pollution. -NAMESPACE_AWARE = YES \ No newline at end of file +NAMESPACE_AWARE = YES + +// Should results be printed by 'sys.displayhook'? +REPL_USE_SYS_DISPLAYHOOK = YES diff --git a/python.cpp b/python.cpp index 458124a..e3e788f 100644 --- a/python.cpp +++ b/python.cpp @@ -23,7 +23,10 @@ #endif #ifdef __MAC__ #include +#undef SEG_DATA // avoid conflict between mach-o/loader.h and segment.hpp #endif +// Python defines snprintf macro so we need to allow it +#define USE_DANGEROUS_FUNCTIONS #include #include #include @@ -32,6 +35,13 @@ #include #include +#if defined (PY_MAJOR_VERSION) && (PY_MAJOR_VERSION < 3) +// in Python 2.x many APIs accept char * instead of const char * +GCC_DIAG_OFF(write-strings) +#else +#error remove me once we switch to Python 3 +#endif + #include "pywraps.hpp" #include "pywraps.cpp" @@ -49,7 +59,8 @@ #define S_IDAPYTHON "IDAPython" #define S_INIT_PY "init.py" static const char S_IDC_ARGS_VARNAME[] = "ARGV"; -static const char S_IDC_RUNPYTHON_STATEMENT[] = "RunPythonStatement"; +static const char S_IDC_EXEC_PYTHON[] = "exec_python"; +static const char S_IDC_EVAL_PYTHON[] = "eval_python"; static const char S_IDAPYTHON_DATA_NODE[] = "IDAPython_Data"; //------------------------------------------------------------------------- @@ -82,6 +93,11 @@ static qstring requested_plugin_path; // Plugin run() callback bool idaapi run(size_t); static PyObject *get_module_globals_from_path(const char *path); +static bool idaapi IDAPython_extlang_eval_expr( + idc_value_t *rv, + ea_t /*current_ea*/, + const char *expr, + qstring *errbuf); //lint -e818 could be pointer to const @@ -121,6 +137,7 @@ static bool g_use_local_python = false; static bool g_autoimport_compat_idaapi = true; static bool g_autoimport_compat_ida695 = true; static bool g_namespace_aware = true; +static bool g_repl_use_sys_displayhook = true; // Allowing the user to interrupt a script is not entirely trivial. // Imagine the following script, that is run in an IDB that uses @@ -294,7 +311,8 @@ int execution_t::on_trace(PyObject *obj, _frame *frame, int what, PyObject *arg) if ( user_cancelled() ) { LEXEC("on_trace()::INTERRUPTING\n"); - PyErr_SetString(PyExc_KeyboardInterrupt, "User interrupted"); + if ( PyErr_Occurred() == NULL ) + PyErr_SetString(PyExc_KeyboardInterrupt, "User interrupted"); return -1; } } @@ -318,28 +336,25 @@ int execution_t::on_trace(PyObject *obj, _frame *frame, int what, PyObject *arg) } //------------------------------------------------------------------------- -//lint -esym(1788, new_execution_t) is referenced only by its constructor or destructor -struct new_execution_t +void ida_export setup_new_execution( + new_execution_t *instance, + bool setup) { - bool created; - new_execution_t() + if ( setup ) { - created = g_ui_ready && execution.timeout > 0; - if ( created ) + instance->created = g_ui_ready && execution.timeout > 0; + if ( instance->created ) { PYW_GIL_CHECK_LOCKED_SCOPE(); execution.push(); } } - ~new_execution_t() + else { - if ( created ) - { - PYW_GIL_CHECK_LOCKED_SCOPE(); - execution.pop(); - } + PYW_GIL_CHECK_LOCKED_SCOPE(); + execution.pop(); } -}; +} //------------------------------------------------------------------------- void ida_export set_interruptible_state(bool interruptible) @@ -403,6 +418,26 @@ static PyObject *get_module_globals(const char *modname=NULL) return module == NULL ? NULL : PyModule_GetDict(module); } +//------------------------------------------------------------------------- +static ref_t _get_sys_displayhook() +{ + ref_t h; + if ( g_repl_use_sys_displayhook ) + { + ref_t py_sys(PyW_TryImportModule("sys")); + if ( py_sys != NULL ) + h = PyW_TryGetAttrString(py_sys.o, "displayhook"); + } + return h; +} + +//------------------------------------------------------------------------- +static const char *bomify(qstring *out) +{ + out->insert(0, UTF8_BOM, UTF8_BOM_SZ); + return out->c_str(); +} + //------------------------------------------------------------------------ static void PythonEvalOrExec( const char *str, @@ -411,7 +446,8 @@ static void PythonEvalOrExec( // Compile as an expression PYW_GIL_CHECK_LOCKED_SCOPE(); PyCompilerFlags cf = {0}; - newref_t py_code(Py_CompileStringFlags(str, filename, Py_eval_input, &cf)); + qstring qstr(str); + newref_t py_code(Py_CompileStringFlags(bomify(&qstr), filename, Py_eval_input, &cf)); if ( py_code == NULL || PyErr_Occurred() ) { // Not an expression? @@ -435,7 +471,13 @@ static void PythonEvalOrExec( } else { - if ( py_result.o != Py_None ) + ref_t sys_displayhook(_get_sys_displayhook()); + if ( sys_displayhook != NULL ) + { + //lint -esym(1788, res) is referenced only by its constructor or destructor + newref_t res(PyObject_CallFunctionObjArgs(sys_displayhook.o, py_result.o, NULL)); + } + else if ( py_result.o != Py_None ) { bool ok = false; if ( PyUnicode_Check(py_result.o) ) @@ -460,6 +502,8 @@ static void PythonEvalOrExec( } } +//lint -esym(1788, new_execution_t) is referenced only by its constructor or destructor + //------------------------------------------------------------------------ // Executes a simple string static bool idaapi IDAPython_extlang_eval_snippet( @@ -513,7 +557,7 @@ static error_t idaapi idc_runpythonstatement( static const char idc_runpythonstatement_args[] = { VT_STR, 0 }; static const ext_idcfunc_t idc_runpythonstatement_desc = { - S_IDC_RUNPYTHON_STATEMENT, + S_IDC_EXEC_PYTHON, idc_runpythonstatement, idc_runpythonstatement_args, NULL, @@ -521,6 +565,31 @@ static const ext_idcfunc_t idc_runpythonstatement_desc = 0 }; +//------------------------------------------------------------------------ +// Simple Python expression evaluator for IDC +static error_t idaapi idc_eval_python( + idc_value_t *argv, + idc_value_t *res) +{ + qstring errbuf; + const char *snippet = argv[0].c_str(); + bool ok = IDAPython_extlang_eval_expr(res, BADADDR, snippet, &errbuf); + if ( !ok ) + return throw_idc_exception(res, errbuf.c_str()); + return eOk; +} + +static const char idc_eval_python_args[] = { VT_STR, 0 }; +static const ext_idcfunc_t idc_eval_python_desc = +{ + S_IDC_EVAL_PYTHON, + idc_eval_python, + idc_eval_python_args, + NULL, + 0, + 0 +}; + //-------------------------------------------------------------------------- static const cfgopt_t opts[] = { @@ -530,6 +599,7 @@ static const cfgopt_t opts[] = cfgopt_t("AUTOIMPORT_COMPAT_IDAAPI", &g_autoimport_compat_idaapi, true), cfgopt_t("AUTOIMPORT_COMPAT_IDA695", &g_autoimport_compat_ida695, true), cfgopt_t("NAMESPACE_AWARE", &g_namespace_aware, true), + cfgopt_t("REPL_USE_SYS_DISPLAYHOOK", &g_repl_use_sys_displayhook, true), }; //------------------------------------------------------------------------- @@ -829,7 +899,8 @@ static bool idaapi IDAPython_extlang_call_func( module = PyImport_ImportModule(final_modname); if ( module == NULL ) { - errbuf->sprnt("couldn't import module %s", final_modname); + if ( errbuf != NULL ) + errbuf->sprnt("couldn't import module %s", final_modname); ok = false; break; } @@ -840,7 +911,8 @@ static bool idaapi IDAPython_extlang_call_func( PyObject *func = PyDict_GetItemString(globals, funcname); if ( func == NULL ) { - errbuf->sprnt("undefined function %s", name); + if ( errbuf != NULL ) + errbuf->sprnt("undefined function %s", name); ok = false; break; } @@ -865,13 +937,37 @@ static bool idaapi IDAPython_extlang_call_func( //------------------------------------------------------------------------- static void wrap_in_function(qstring *out, const qstring &body, const char *name) { - out->sprnt("def %s():\n", name); - // dont copy trailing whitespace - int i = body.length()-1; - while ( i >= 0 && qisspace(body.at(i)) ) - i--; - out->append(body.substr(0, i+1)); - out->replace("\n", "\n "); + qstrvec_t lines; + lines.push_back().sprnt("def %s():\n", name); + + qstring buf(body); + while ( !buf.empty() && qisspace(buf.last()) ) // dont copy trailing whitespace(s) + buf.remove_last(); + + char *ctx; + for ( char *p = qstrtok(buf.begin(), "\n", &ctx); + p != NULL; + p = qstrtok(NULL, "\n", &ctx) ) + { + static const char FROM_FUTURE_IMPORT_STMT[] = "from __future__ import"; + if ( strneq(p, FROM_FUTURE_IMPORT_STMT, sizeof(FROM_FUTURE_IMPORT_STMT)-1) ) + { + lines.insert(lines.begin(), p); + } + else + { + qstring &s = lines.push_back(); + s.append(" ", 4); + s.append(p); + } + } + out->qclear(); + for ( size_t i = 0; i < lines.size(); ++i ) + { + if ( i > 0 ) + out->append('\n'); + out->append(lines[i]); + } } //------------------------------------------------------------------------- @@ -886,7 +982,11 @@ static bool idaapi IDAPython_extlang_compile_expr( PyObject *globals = get_module_globals(); bool isfunc = false; - PyCodeObject *code = (PyCodeObject *)Py_CompileString(expr, "", Py_eval_input); + qstring qstr(expr); + PyCodeObject *code = (PyCodeObject *)Py_CompileString( + bomify(&qstr), + "", + Py_eval_input); if ( code == NULL ) { // try compiling as a list of statements @@ -894,6 +994,7 @@ static bool idaapi IDAPython_extlang_compile_expr( handle_python_error(errbuf); qstring func; wrap_in_function(&func, expr, name); + bomify(&func); code = (PyCodeObject *)Py_CompileString(func.c_str(), "", Py_file_input); if ( code == NULL ) { @@ -948,6 +1049,10 @@ static bool idaapi IDAPython_extlang_compile_file( // Load processor module callback for Python external language evaluator static bool idaapi IDAPython_extlang_load_procmod( idc_value_t *procobj, + // hook_cb_t **idp_notifier, + // void **idp_notifier_ud, + // hook_cb_t **idb_notifier, + // void **idb_notifier_ud, const char *path, qstring *errbuf) { @@ -956,7 +1061,7 @@ static bool idaapi IDAPython_extlang_load_procmod( { new_execution_t exec; PyObject *globals = get_module_globals_from_path(path); - ok = IDAPython_ExecFile(path, globals, errbuf, S_IDAAPI_LOADPROCMOD, procobj, true); + ok = IDAPython_ExecFile(path, globals, errbuf, S_IDAAPI_LOADPROCMOD, procobj, /*want_tuple=*/ true); } if ( ok && procobj->is_zero() ) { @@ -1590,12 +1695,32 @@ void convert_idc_args() PyObject_SetAttrString(py_mod.o, S_IDC_ARGS_VARNAME, py_args.o); } -#define DISPATCH_TO_MODULES(Method) \ - do \ - { \ - for ( size_t i = modules_callbacks.size(); i > 0; --i ) \ - modules_callbacks[i-1].Method(); \ - } while ( false ) +//------------------------------------------------------------------------- +enum module_lifecycle_notification_t +{ + mln_init = 0, + mln_term, + mln_closebase +}; +static void send_modules_lifecycle_notification(module_lifecycle_notification_t what) +{ + PYW_GIL_GET; + for ( size_t i = modules_callbacks.size(); i > 0; --i ) + { + const module_callbacks_t &m = modules_callbacks[i-1]; + switch ( what ) + { + case mln_init: m.init(); break; + case mln_term: m.term(); break; + case mln_closebase: m.closebase(); break; + } + if ( PyErr_Occurred() ) + { + msg("Error during module lifecycle notification:\n"); + PyErr_Print(); + } + } +} //------------------------------------------------------------------------ //lint -esym(715,va) Symbol not referenced @@ -1651,7 +1776,7 @@ static ssize_t idaapi on_idb_notification(void *, int code, va_list) // through all the tinfo_t objects that are embedded in SWIG wrappers, // (i.e., that were created from Python) and clear those. til_clear_python_tinfo_t_instances(); - DISPATCH_TO_MODULES(closebase); + send_modules_lifecycle_notification(mln_closebase); break; } return 0; @@ -1734,26 +1859,6 @@ static bool initsite(void) return true; } -//------------------------------------------------------------------------- -static void init_ida_modules() -{ - // char buf[QMAXPATH]; - // // IDA_MODULES must be passed as a define - // qstrncpy(buf, IDA_MODULES, sizeof(buf)); - // char *ctx; - // for ( char *module = qstrtok(buf, ",", &ctx); - // module != NULL; - // module = qstrtok(NULL, DELIMITER, &ctx) ) - // { - // deb(IDA_DEBUG_PLUGIN, "Initializing \"ida_%s\"\n", module); - // } - - // Load the 'ida_idaapi' module, that contains some important bits of code - // ref_t ida_idaapi(PyW_TryImportModule(S_PY_IDA_IDAAPI_MODNAME)); - - // ref_t sys(PyW_TryImportModule("sys")); -} - //------------------------------------------------------------------------- // Initialize the Python environment bool IDAPython_Init(void) @@ -1862,8 +1967,6 @@ bool IDAPython_Init(void) if ( !PyEval_ThreadsInitialized() ) PyEval_InitThreads(); - init_ida_modules(); - #ifdef Py_DEBUG msg("HexraysPython: Python compiled with DEBUG enabled.\n"); #endif @@ -1877,11 +1980,7 @@ bool IDAPython_Init(void) "IDAPYTHON_DYNLOAD_RELPATH = \"ida_%" FMT_Z "\"\n" "IDAPYTHON_COMPAT_AUTOIMPORT_MODULES = %s\n" "IDAPYTHON_COMPAT_695_API = %s\n", - VER_MAJOR, - VER_MINOR, - VER_PATCH, - VER_STATUS, - VER_SERIAL, + VER_MAJOR, VER_MINOR, VER_PATCH, VER_STATUS, VER_SERIAL, g_remove_cwd_sys_path ? "True" : "False", idadir(NULL), sizeof(ea_t)*8, @@ -1927,7 +2026,7 @@ bool IDAPython_Init(void) } // Init pywraps and notify_when - if ( !init_pywraps() || !pywraps_nw_init() ) + if ( !init_pywraps() ) { warning("IDAPython: init_pywraps() failed!"); remove_extlang(&extlang_python); @@ -1938,9 +2037,9 @@ bool IDAPython_Init(void) PyEval_SetTrace(tracefunc, NULL); #endif - - // Register a RunPythonStatement() function for IDC + // Register a exec_python() function for IDC add_idc_func(idc_runpythonstatement_desc); + add_idc_func(idc_eval_python_desc); // A script specified on the command line is run if ( g_run_when == RUN_ON_INIT ) @@ -1955,7 +2054,8 @@ bool IDAPython_Init(void) // Enable the CLI by default enable_python_cli(true); - pywraps_nw_notify(NW_INITIDA_SLOT); + // Let all modules perform possible initialization + send_modules_lifecycle_notification(mln_init); PyEval_ReleaseThread(PyThreadState_Get()); @@ -1963,6 +2063,27 @@ bool IDAPython_Init(void) return true; } +//------------------------------------------------------------------------- +#ifdef TESTABLE_BUILD +// "user-code-leniency" means that, even in TESTABLE_BUILD builds, +// IDAPython will accept that some things are left in an undesirable, +// but recuperable state (e.g., remaining hooks.) +// This should *ONLY* be used for tests that rely on user code that +// is in such a shape that it would require significant changes to +// have it perform proper cleanup, which means that it would have to +// diverge from the original user's code, which means that we +// would have to maintain our own branch of it, which is not +// the best idea of the world, overhead-wise. +static int _is_user_code_lenient = -1; +static bool is_user_code_lenient() +{ + if ( _is_user_code_lenient < 0 ) + _is_user_code_lenient = qgetenv("IDAPYTHON_USER_CODE_LENIENT"); + return _is_user_code_lenient > 0; +} + +#endif + //------------------------------------------------------------------------- // Cleaning up Python void IDAPython_Term(void) @@ -1981,7 +2102,7 @@ void IDAPython_Term(void) } // Let all modules perform possible de-initialization - DISPATCH_TO_MODULES(term); + send_modules_lifecycle_notification(mln_term); unhook_from_notification_point(HT_IDB, on_idb_notification); unhook_from_notification_point(HT_UI, on_ui_notification); @@ -1989,12 +2110,6 @@ void IDAPython_Term(void) unhook_from_notification_point(HT_UI, ui_debug_handler_cb); #endif - // Notify about IDA closing - pywraps_nw_notify(NW_TERMIDA_SLOT); - - // De-init notify_when - pywraps_nw_term(); - // Remove the CLI enable_python_cli(false); @@ -2005,6 +2120,7 @@ void IDAPython_Term(void) deinit_pywraps(); // Uninstall IDC function + del_idc_func(idc_eval_python_desc.name); del_idc_func(idc_runpythonstatement_desc.name); // Shut the interpreter down @@ -2012,9 +2128,14 @@ void IDAPython_Term(void) g_instance_initialized = false; #ifdef TESTABLE_BUILD - // Check that all hooks were unhooked - QASSERT(30509, hook_data_vec.empty()); + if ( !is_user_code_lenient() ) // Check that all hooks were unhooked + QASSERT(30509, hook_data_vec.empty()); #endif + for ( size_t i = hook_data_vec.size(); i > 0; --i ) + { + const hook_data_t &hd = hook_data_vec[i-1]; + idapython_unhook_from_notification_point(hd.type, hd.cb, hd.ud); + } } //------------------------------------------------------------------------- diff --git a/python/idautils.py b/python/idautils.py index 992ee8d..4fa6461 100644 --- a/python/idautils.py +++ b/python/idautils.py @@ -193,27 +193,27 @@ def XrefsTo(ea, flags=0): def Threads(): - """Returns all thread IDs""" + """Returns all thread IDs for the current debugee""" for i in xrange(0, idc.get_thread_qty()): yield idc.getn_thread(i) def Heads(start=None, end=None): """ - Get a list of heads (instructions or data) + Get a list of heads (instructions or data items) @param start: start address (default: inf.min_ea) @param end: end address (default: inf.max_ea) @return: list of heads between start and end """ - if not start: start = ida_ida.cvar.inf.min_ea - if not end: end = ida_ida.cvar.inf.max_ea + if start is None: start = ida_ida.cvar.inf.min_ea + if end is None: end = ida_ida.cvar.inf.max_ea ea = start if not idc.is_head(ida_bytes.get_flags(ea)): ea = ida_bytes.next_head(ea, end) - while ea != ida_idaapi.BADADDR: + while ea < end and ea != ida_idaapi.BADADDR: yield ea ea = ida_bytes.next_head(ea, end) @@ -225,15 +225,15 @@ def Functions(start=None, end=None): @param start: start address (default: inf.min_ea) @param end: end address (default: inf.max_ea) - @return: list of heads between start and end + @return: list of function entrypoints between start and end @note: The last function that starts before 'end' is included even if it extends beyond 'end'. Any function that has its chunks scattered in multiple segments will be reported multiple times, once in each segment as they are listed. """ - if not start: start = ida_ida.cvar.inf.min_ea - if not end: end = ida_ida.cvar.inf.max_ea + if start is None: start = ida_ida.cvar.inf.min_ea + if end is None: end = ida_ida.cvar.inf.max_ea # find first function head chunk in the range chunk = ida_funcs.get_fchunk(start) @@ -303,7 +303,7 @@ def Segments(): def Entries(): """ - Returns a list of entry points + Returns a list of entry points (exports) @return: List of tuples (index, ordinal, ea, name) """ @@ -317,7 +317,7 @@ def Entries(): def FuncItems(start): """ - Get a list of function items + Get a list of function items (instruction or data items inside function boundaries) @param start: address of the function diff --git a/python/idc.py b/python/idc.py index 14821d9..c1d944a 100644 --- a/python/idc.py +++ b/python/idc.py @@ -1473,7 +1473,7 @@ def func_contains(func_ea, ea): GN_VISIBLE = ida_name.GN_VISIBLE # replace forbidden characters by SUBSTCHAR GN_COLORED = ida_name.GN_COLORED # return colored name GN_DEMANGLED = ida_name.GN_DEMANGLED # return demangled name -GN_STRICT = ida_name.GN_STRICT # fail if can not demangle +GN_STRICT = ida_name.GN_STRICT # fail if cannot demangle GN_SHORT = ida_name.GN_SHORT # use short form of demangled name GN_LONG = ida_name.GN_LONG # use long form of demangled name GN_LOCAL = ida_name.GN_LOCAL # try to get local name first; if failed, get global @@ -1690,13 +1690,46 @@ GetCommentEx = ida_bytes.get_cmt get_cmt = GetCommentEx get_forced_operand = ida_bytes.get_forced_operand -STRTYPE_C = ida_nalt.STRTYPE_TERMCHR # C-style ASCII string -STRTYPE_PASCAL = ida_nalt.STRTYPE_PASCAL # Pascal-style ASCII string (length byte) -STRTYPE_LEN2 = ida_nalt.STRTYPE_LEN2 # Pascal-style, length is 2 bytes -STRTYPE_C_16 = ida_nalt.STRTYPE_C_16 # Unicode string -STRTYPE_LEN4 = ida_nalt.STRTYPE_LEN4 # Pascal-style, length is 4 bytes -STRTYPE_LEN2_16 = ida_nalt.STRTYPE_LEN2_16 # Pascal-style Unicode, length is 2 bytes -STRTYPE_LEN4_16 = ida_nalt.STRTYPE_LEN4_16 # Pascal-style Unicode, length is 4 bytes +BPU_1B = ida_nalt.BPU_1B +BPU_2B = ida_nalt.BPU_2B +BPU_4B = ida_nalt.BPU_4B + +STRWIDTH_1B = ida_nalt.STRWIDTH_1B +STRWIDTH_2B = ida_nalt.STRWIDTH_2B +STRWIDTH_4B = ida_nalt.STRWIDTH_4B +STRWIDTH_MASK = ida_nalt.STRWIDTH_MASK + +STRLYT_TERMCHR = ida_nalt.STRLYT_TERMCHR +STRLYT_PASCAL1 = ida_nalt.STRLYT_PASCAL1 +STRLYT_PASCAL2 = ida_nalt.STRLYT_PASCAL2 +STRLYT_PASCAL4 = ida_nalt.STRLYT_PASCAL4 +STRLYT_MASK = ida_nalt.STRLYT_MASK +STRLYT_SHIFT = ida_nalt.STRLYT_SHIFT + +# Character-terminated string. The termination characters +# are kept in the next bytes of string type. +STRTYPE_TERMCHR = ida_nalt.STRTYPE_TERMCHR +# C-style string. +STRTYPE_C = ida_nalt.STRTYPE_C +# Zero-terminated 16bit chars +STRTYPE_C_16 = ida_nalt.STRTYPE_C_16 +# Zero-terminated 32bit chars +STRTYPE_C_32 = ida_nalt.STRTYPE_C_32 +# Pascal-style, one-byte length prefix +STRTYPE_PASCAL = ida_nalt.STRTYPE_PASCAL +# Pascal-style, 16bit chars, one-byte length prefix +STRTYPE_PASCAL_16 = ida_nalt.STRTYPE_PASCAL_16 +# Pascal-style, two-byte length prefix +STRTYPE_LEN2 = ida_nalt.STRTYPE_LEN2 +# Pascal-style, 16bit chars, two-byte length prefix +STRTYPE_LEN2_16 = ida_nalt.STRTYPE_LEN2_16 +# Pascal-style, four-byte length prefix +STRTYPE_LEN4 = ida_nalt.STRTYPE_LEN4 +# Pascal-style, 16bit chars, four-byte length prefix +STRTYPE_LEN4_16 = ida_nalt.STRTYPE_LEN4_16 + +# alias +STRTYPE_C16 = STRTYPE_C_16 def get_strlit_contents(ea, length = -1, strtype = STRTYPE_C): """ @@ -1780,26 +1813,11 @@ def process_config_line(directive): # The following functions allow you to set/get common parameters. # Please note that not all parameters can be set directly. -def get_inf_attr(offset): - """ - """ - val = _IDC_GetAttr(ida_ida.cvar.inf, _INFMAP, offset) - if offset == INF_PROCNAME: - # procName is a character array - val = ida_idaapi.as_cstr(val) - return val - -def set_inf_attr(offset, value): - if offset == INF_PROCNAME: - raise NotImplementedError("Please use ida_idp.set_processor_type() to change processor") - # We really want to go through IDC's equivalent, because it might - # have side-effects (i.e., send a notification, etc...) - return eval_idc("set_inf_attr(%d, %d)" % (offset, value)) -INF_VERSION = 4 # short; Version of database -INF_PROCNAME = 6 # char[8]; Name of current processor -INF_GENFLAGS = 22 # ushort; General flags: +INF_VERSION = 0 # short; Version of database +INF_PROCNAME = 1 # char[8]; Name of current processor +INF_GENFLAGS = 2 # ushort; General flags: INFFL_AUTO = 0x01 # Autoanalysis is enabled? INFFL_ALLASM = 0x02 # May use constructs not supported by # the target assembler @@ -1809,7 +1827,7 @@ INFFL_READONLY = 0x10 # (internal) temporary interdiction t INFFL_CHKOPS = 0x20 # check manual operands? INFFL_NMOPS = 0x40 # allow non-matched operands? INFFL_GRAPH_VIEW= 0x80 # currently using graph options (\dto{graph}) -INF_LFLAGS = 24 # uint32; IDP-dependent flags +INF_LFLAGS = 3 # uint32; IDP-dependent flags LFLG_PC_FPP = 0x00000001 # decode floating point processor # instructions? LFLG_PC_FLAT = 0x00000002 # Flat model? @@ -1824,9 +1842,10 @@ LFLG_PACK = 0x00000200 # pack the database? LFLG_COMPRESS = 0x00000400 # compress the database? LFLG_KERNMODE = 0x00000800 # is kernel mode binary? -INF_CHANGE_COUNTER= 28 # uint32; database change counter; keeps track of byte and segment modifications +INF_DATABASE_CHANGE_COUNT= 4 # uint32; database change counter; keeps track of byte and segment modifications +INF_CHANGE_COUNTER=INF_DATABASE_CHANGE_COUNT -INF_FILETYPE = 32 # short; type of input file (see ida.hpp) +INF_FILETYPE = 5 # short; type of input file (see ida.hpp) FT_EXE_OLD = 0 # MS DOS EXE File (obsolete) FT_COM_OLD = 1 # MS DOS COM File (obsolete) FT_BIN = 2 # Binary File @@ -1853,12 +1872,12 @@ FT_EXE = 22 # MS DOS EXE File FT_COM = 23 # MS DOS COM File FT_AIXAR = 24 # AIX ar library FT_MACHO = 25 # Mac OS X Mach-O file -INF_OSTYPE = 34 # short; FLIRT: OS type the program is for +INF_OSTYPE = 6 # short; FLIRT: OS type the program is for OSTYPE_MSDOS= 0x0001 OSTYPE_WIN = 0x0002 OSTYPE_OS2 = 0x0004 OSTYPE_NETW = 0x0008 -INF_APPTYPE = 36 # short; FLIRT: Application type +INF_APPTYPE = 7 # short; FLIRT: Application type APPT_CONSOLE= 0x0001 # console APPT_GRAPHIC= 0x0002 # graphics APPT_PROGRAM= 0x0004 # EXE @@ -1868,10 +1887,10 @@ APPT_1THREAD= 0x0020 # Singlethread APPT_MTHREAD= 0x0040 # Multithread APPT_16BIT = 0x0080 # 16 bit application APPT_32BIT = 0x0100 # 32 bit application -INF_ASMTYPE = 38 # char; target assembler number (0..n) -INF_SPECSEGS = 39 +INF_ASMTYPE = 8 # char; target assembler number (0..n) +INF_SPECSEGS = 9 -INF_AF = 40 # uint32; Analysis flags: +INF_AF = 10 # uint32; Analysis flags: AF_CODE = 0x00000001 # Trace execution flow AF_MARKCODE = 0x00000002 # Mark typical code sequences as code AF_JUMPTBL = 0x00000004 # Locate and create jump tables @@ -1910,54 +1929,62 @@ AF_DODATA = 0x20000000 # Coagulate data segs at the final pa AF_DOCODE = 0x40000000 # Coagulate code segs at the final pass AF_FINAL = 0x80000000 # Final pass of analysis -INF_AF2 = 44 # uint32; Analysis flags 2 +INF_AF2 = 11 # uint32; Analysis flags 2 AF2_DOEH = 0x00000001 # Handle EH information AF2_DORTTI = 0x00000002 # Handle RTTI information +AF2_MACRO = 0x00000004 # Try to combine several instructions into a macro instruction -INF_BASEADDR = 48 # uval_t; base paragraph of the program -INF_START_SS = 52 # int32; value of SS at the start -INF_START_CS = 56 # int32; value of CS at the start -INF_START_IP = 60 # ea_t; IP register value at the start of +INF_BASEADDR = 12 # uval_t; base paragraph of the program +INF_START_SS = 13 # int32; value of SS at the start +INF_START_CS = 14 # int32; value of CS at the start +INF_START_IP = 15 # ea_t; IP register value at the start of # program execution -INF_START_EA = 64 # ea_t; Linear address of program entry point -INF_START_SP = 68 # ea_t; SP register value at the start of +INF_START_EA = 16 # ea_t; Linear address of program entry point +INF_START_SP = 17 # ea_t; SP register value at the start of # program execution -INF_MAIN = 72 # ea_t; address of main() -INF_MIN_EA = 76 # ea_t; The lowest address used +INF_MAIN = 18 # ea_t; address of main() +INF_MIN_EA = 19 # ea_t; The lowest address used # in the program -INF_MAX_EA = 80 # ea_t; The highest address used +INF_MAX_EA = 20 # ea_t; The highest address used # in the program - 1 -INF_OMIN_EA = 84 -INF_OMAX_EA = 88 -INF_LOW_OFF = 92 # ea_t; low limit of voids -INF_HIGH_OFF = 96 # ea_t; high limit of voids -INF_MAXREF = 100 # uval_t; max xref depth -INF_START_PRIVRANGE = 104 # uval_t; Range of addresses reserved for internal use. -INF_END_PRIVRANGE = 108 # uval_t; Initially (MAXADDR, MAXADDR+0x100000) +INF_OMIN_EA = 21 +INF_OMAX_EA = 22 +INF_LOWOFF = 23 # ea_t; low limit of voids +INF_LOW_OFF=INF_LOWOFF +INF_HIGHOFF = 24 # ea_t; high limit of voids +INF_HIGH_OFF=INF_HIGHOFF +INF_MAXREF = 25 # uval_t; max xref depth +INF_PRIVRANGE_START_EA = 27 # uval_t; Range of addresses reserved for internal use. +INF_START_PRIVRANGE=INF_PRIVRANGE_START_EA +INF_PRIVRANGE_END_EA = 28 # uval_t; Initially (MAXADDR, MAXADDR+0x100000) +INF_END_PRIVRANGE=INF_PRIVRANGE_END_EA -INF_NETDELTA = 112 # sval_t; Delta value to be added to all adresses for mapping to netnodes. +INF_NETDELTA = 29 # sval_t; Delta value to be added to all adresses for mapping to netnodes. # Initially 0. # CROSS REFERENCES -INF_XREFNUM = 116 # char; Number of references to generate +INF_XREFNUM = 30 # char; Number of references to generate # 0 - xrefs won't be generated at all -INF_TYPE_XREFS = 117 # char; Number of references to generate +INF_TYPE_XREFNUM = 31 # char; Number of references to generate # in the struct & enum windows # 0 - xrefs won't be generated at all -INF_REFCMTS = 118 # uchar; number of comment lines to +INF_TYPE_XREFS=INF_TYPE_XREFNUM +INF_REFCMTNUM = 32 # uchar; number of comment lines to # generate for refs to ASCII # string or demangled name # 0 - such comments won't be # generated at all -INF_XREFS = 119 # char; xrefs representation: +INF_REFCMTS=INF_REFCMTNUM +INF_XREFFLAG = 33 # char; xrefs representation: +INF_XREFS=INF_XREFFLAG SW_SEGXRF = 0x01 # show segments in xrefs? SW_XRFMRK = 0x02 # show xref type marks? SW_XRFFNC = 0x04 # show function offsets? SW_XRFVAL = 0x08 # show xref values? (otherwise-"...") # NAMES -INF_MAX_AUTONAME_LEN = 120 # ushort; max name length (without zero byte) -INF_NAMETYPE = 122 # char; dummy names represenation type +INF_MAX_AUTONAME_LEN = 34 # ushort; max name length (without zero byte) +INF_NAMETYPE = 35 # char; dummy names represenation type NM_REL_OFF = 0 NM_PTR_OFF = 1 NM_NAM_OFF = 2 @@ -1969,27 +1996,29 @@ NM_EA4 = 7 NM_EA8 = 8 NM_SHORT = 9 NM_SERIAL = 10 -INF_SHORT_DN = 124 # int32; short form of demangled names -INF_LONG_DN = 128 # int32; long form of demangled names +INF_SHORT_DEMNAMES = 36 # int32; short form of demangled names +INF_SHORT_DN=INF_SHORT_DEMNAMES +INF_LONG_DEMNAMES = 37 # int32; long form of demangled names # see demangle.h for definitions -INF_DEMNAMES = 132 # char; display demangled names as: +INF_LONG_DN=INF_LONG_DEMNAMES +INF_DEMNAMES = 38 # char; display demangled names as: DEMNAM_CMNT = 0 # comments DEMNAM_NAME = 1 # regular names DEMNAM_NONE = 2 # don't display DEMNAM_GCC3 = 4 # assume gcc3 names (valid for gnu compiler) DEMNAM_FIRST= 8 # override type info -INF_LISTNAMES = 133 # uchar; What names should be included in the list? +INF_LISTNAMES = 39 # uchar; What names should be included in the list? LN_NORMAL = 0x01 # normal names LN_PUBLIC = 0x02 # public names LN_AUTO = 0x04 # autogenerated names LN_WEAK = 0x08 # weak names # DISASSEMBLY LISTING DETAILS -INF_INDENT = 134 # char; Indention for instructions -INF_COMMENT = 135 # char; Indention for comments -INF_MARGIN = 136 # ushort; max length of data lines -INF_LENXREF = 138 # ushort; max length of line with xrefs -INF_OUTFLAGS = 140 # uint32; output flags +INF_INDENT = 40 # char; Indention for instructions +INF_COMMENT = 41 # char; Indention for comments +INF_MARGIN = 42 # ushort; max length of data lines +INF_LENXREF = 43 # ushort; max length of line with xrefs +INF_OUTFLAGS = 44 # uint32; output flags OFLG_SHOW_VOID = 0x0002 # Display void marks? OFLG_SHOW_AUTO = 0x0004 # Display autoanalysis indicator? OFLG_GEN_NULL = 0x0010 # Generate empty lines? @@ -1999,66 +2028,43 @@ OFLG_LZERO = 0x0080 # generate leading zeroes in numbers OFLG_GEN_ORG = 0x0100 # Generate 'org' directives? OFLG_GEN_ASSUME= 0x0200 # Generate 'assume' directives? OFLG_GEN_TRYBLKS = 0x0400 # Generate try/catch directives? -INF_CMTFLAG = 144 # char; comments: +INF_CMTFLG = 45 # char; comments: +INF_CMTFLAG=INF_CMTFLG SW_RPTCMT = 0x01 # show repeatable comments? SW_ALLCMT = 0x02 # comment all lines? SW_NOCMT = 0x04 # no comments at all SW_LINNUM = 0x08 # show source line numbers -INF_BORDER = 145 # char; Generate borders? -INF_BINPREF = 146 # short; # of instruction bytes to show +INF_LIMITER = 46 # char; Generate borders? +INF_BORDER=INF_LIMITER +INF_BIN_PREFIX_SIZE = 47 # short; # of instruction bytes to show # in line prefix -INF_PREFFLAG = 148 # char; line prefix type: +INF_BINPREF=INF_BIN_PREFIX_SIZE +INF_PREFFLAG = 48 # char; line prefix type: PREF_SEGADR = 0x01 # show segment addresses? PREF_FNCOFF = 0x02 # show function offsets? PREF_STACK = 0x04 # show stack pointer? # STRING LITERALS -INF_STRLIT_FLAGS= 149 # uchar; string literal flags +INF_STRLIT_FLAGS= 49 # uchar; string literal flags STRF_GEN = 0x01 # generate names? STRF_AUTO = 0x02 # names have 'autogenerated' bit? STRF_SERIAL = 0x04 # generate serial names? STRF_COMMENT = 0x10 # generate auto comment for string references? STRF_SAVECASE = 0x20 # preserve case of strings for identifiers -INF_STRLIT_BREAK= 150 # char; string literal line break symbol -INF_STRLIT_ZEROES= 151 # char; leading zeroes -INF_STRTYPE = 152 # int32; current ascii string type +INF_STRLIT_BREAK= 50 # char; string literal line break symbol +INF_STRLIT_ZEROES= 51 # char; leading zeroes +INF_STRTYPE = 52 # int32; current ascii string type # is considered as several bytes: # low byte: -BPU_1B = 1 -BPU_2B = 2 -BPU_4B = 4 -STRWIDTH_1B = 0 -STRWIDTH_2B = 1 -STRWIDTH_4B = 2 -STRWIDTH_MASK = 0x03 - -STRLYT_TERMCHR = 0 -STRLYT_PASCAL1 = 1 -STRLYT_PASCAL2 = 2 -STRLYT_PASCAL4 = 3 -STRLYT_MASK = 0xFC -STRLYT_SHIFT = 2 - -STRTYPE_TERMCHR = STRWIDTH_1B|STRLYT_TERMCHR<