2015-09-25 Simon Marchi <simon.marchi@ericsson.com>
+ * aarch64-tdep.c (aarch64_make_prologue_cache): Add cast(s).
+ (aarch64_make_stub_cache): Likewise.
+ (value_of_aarch64_user_reg): Likewise.
+ * ada-lang.c (ada_inferior_data_cleanup): Likewise.
+ (get_ada_inferior_data): Likewise.
+ (get_ada_pspace_data): Likewise.
+ (ada_pspace_data_cleanup): Likewise.
+ (ada_complete_symbol_matcher): Likewise.
+ (ada_exc_search_name_matches): Likewise.
+ * ada-tasks.c (get_ada_tasks_pspace_data): Likewise.
+ (get_ada_tasks_inferior_data): Likewise.
+ * addrmap.c (addrmap_mutable_foreach_worker): Likewise.
+ (splay_obstack_alloc): Likewise.
+ (splay_obstack_free): Likewise.
+ * alpha-linux-tdep.c (alpha_linux_supply_gregset): Likewise.
+ (alpha_linux_collect_gregset): Likewise.
+ (alpha_linux_supply_fpregset): Likewise.
+ (alpha_linux_collect_fpregset): Likewise.
+ * alpha-mdebug-tdep.c (alpha_mdebug_frame_unwind_cache): Likewise.
+ * alpha-tdep.c (alpha_lds): Likewise.
+ (alpha_sts): Likewise.
+ (alpha_sigtramp_frame_unwind_cache): Likewise.
+ (alpha_heuristic_frame_unwind_cache): Likewise.
+ (alpha_supply_int_regs): Likewise.
+ (alpha_fill_int_regs): Likewise.
+ (alpha_supply_fp_regs): Likewise.
+ (alpha_fill_fp_regs): Likewise.
+ * alphanbsd-tdep.c (alphanbsd_supply_fpregset): Likewise.
+ (alphanbsd_aout_supply_gregset): Likewise.
+ (alphanbsd_supply_gregset): Likewise.
+ * amd64-linux-tdep.c (amd64_linux_init_abi): Likewise.
+ (amd64_x32_linux_init_abi): Likewise.
+ * amd64-nat.c (amd64_supply_native_gregset): Likewise.
+ (amd64_collect_native_gregset): Likewise.
+ * amd64-tdep.c (amd64_frame_cache): Likewise.
+ (amd64_sigtramp_frame_cache): Likewise.
+ (amd64_epilogue_frame_cache): Likewise.
+ (amd64_supply_fxsave): Likewise.
+ (amd64_supply_xsave): Likewise.
+ (amd64_collect_fxsave): Likewise.
+ (amd64_collect_xsave): Likewise.
+ * amd64-windows-tdep.c (amd64_windows_frame_cache): Likewise.
+ * amd64obsd-tdep.c (amd64obsd_trapframe_cache): Likewise.
+ * arm-linux-tdep.c (arm_linux_supply_gregset): Likewise.
+ (arm_linux_collect_gregset): Likewise.
+ (arm_linux_supply_nwfpe): Likewise.
+ (arm_linux_collect_nwfpe): Likewise.
+ (arm_linux_supply_vfp): Likewise.
+ (arm_linux_collect_vfp): Likewise.
+ * arm-tdep.c (arm_find_mapping_symbol): Likewise.
+ (arm_prologue_unwind_stop_reason): Likewise.
+ (arm_prologue_this_id): Likewise.
+ (arm_prologue_prev_register): Likewise.
+ (arm_exidx_data_free): Likewise.
+ (arm_find_exidx_entry): Likewise.
+ (arm_stub_this_id): Likewise.
+ (arm_m_exception_this_id): Likewise.
+ (arm_m_exception_prev_register): Likewise.
+ (arm_normal_frame_base): Likewise.
+ (gdb_print_insn_arm): Likewise.
+ (arm_objfile_data_free): Likewise.
+ (arm_record_special_symbol): Likewise.
+ (value_of_arm_user_reg): Likewise.
+ * armbsd-tdep.c (armbsd_supply_fpregset): Likewise.
+ (armbsd_supply_gregset): Likewise.
+ * auto-load.c (auto_load_pspace_data_cleanup): Likewise.
+ (get_auto_load_pspace_data): Likewise.
+ (hash_loaded_script_entry): Likewise.
+ (eq_loaded_script_entry): Likewise.
+ (clear_section_scripts): Likewise.
+ (collect_matching_scripts): Likewise.
+ * auxv.c (auxv_inferior_data_cleanup): Likewise.
+ (get_auxv_inferior_data): Likewise.
+ * avr-tdep.c (avr_frame_unwind_cache): Likewise.
+ * ax-general.c (do_free_agent_expr_cleanup): Likewise.
+ * bfd-target.c (target_bfd_xfer_partial): Likewise.
+ (target_bfd_xclose): Likewise.
+ (target_bfd_get_section_table): Likewise.
+ * bfin-tdep.c (bfin_frame_cache): Likewise.
+ * block.c (find_block_in_blockvector): Likewise.
+ (call_site_for_pc): Likewise.
+ (block_find_non_opaque_type_preferred): Likewise.
+ * break-catch-sig.c (signal_catchpoint_insert_location): Likewise.
+ (signal_catchpoint_remove_location): Likewise.
+ (signal_catchpoint_breakpoint_hit): Likewise.
+ (signal_catchpoint_print_one): Likewise.
+ (signal_catchpoint_print_mention): Likewise.
+ (signal_catchpoint_print_recreate): Likewise.
+ * break-catch-syscall.c (get_catch_syscall_inferior_data): Likewise.
+ * breakpoint.c (do_cleanup_counted_command_line): Likewise.
+ (bp_location_compare_addrs): Likewise.
+ (get_first_locp_gte_addr): Likewise.
+ (check_tracepoint_command): Likewise.
+ (do_map_commands_command): Likewise.
+ (get_breakpoint_objfile_data): Likewise.
+ (free_breakpoint_probes): Likewise.
+ (do_captured_breakpoint_query): Likewise.
+ (compare_breakpoints): Likewise.
+ (bp_location_compare): Likewise.
+ (bpstat_remove_breakpoint_callback): Likewise.
+ (do_delete_breakpoint_cleanup): Likewise.
+ * bsd-uthread.c (bsd_uthread_set_supply_uthread): Likewise.
+ (bsd_uthread_set_collect_uthread): Likewise.
+ (bsd_uthread_activate): Likewise.
+ (bsd_uthread_fetch_registers): Likewise.
+ (bsd_uthread_store_registers): Likewise.
+ * btrace.c (check_xml_btrace_version): Likewise.
+ (parse_xml_btrace_block): Likewise.
+ (parse_xml_btrace_pt_config_cpu): Likewise.
+ (parse_xml_btrace_pt_raw): Likewise.
+ (parse_xml_btrace_pt): Likewise.
+ (parse_xml_btrace_conf_bts): Likewise.
+ (parse_xml_btrace_conf_pt): Likewise.
+ (do_btrace_data_cleanup): Likewise.
+ * c-typeprint.c (find_typedef_for_canonicalize): Likewise.
+ * charset.c (cleanup_iconv): Likewise.
+ (do_cleanup_iterator): Likewise.
+ * cli-out.c (cli_uiout_dtor): Likewise.
+ (cli_table_begin): Likewise.
+ (cli_table_body): Likewise.
+ (cli_table_end): Likewise.
+ (cli_table_header): Likewise.
+ (cli_begin): Likewise.
+ (cli_end): Likewise.
+ (cli_field_int): Likewise.
+ (cli_field_skip): Likewise.
+ (cli_field_string): Likewise.
+ (cli_field_fmt): Likewise.
+ (cli_spaces): Likewise.
+ (cli_text): Likewise.
+ (cli_message): Likewise.
+ (cli_wrap_hint): Likewise.
+ (cli_flush): Likewise.
+ (cli_redirect): Likewise.
+ (out_field_fmt): Likewise.
+ (field_separator): Likewise.
+ (cli_out_set_stream): Likewise.
+ * cli/cli-cmds.c (compare_symtabs): Likewise.
+ * cli/cli-dump.c (call_dump_func): Likewise.
+ (restore_section_callback): Likewise.
+ * cli/cli-script.c (clear_hook_in_cleanup): Likewise.
+ (do_restore_user_call_depth): Likewise.
+ (do_free_command_lines_cleanup): Likewise.
+ * coff-pe-read.c (get_section_vmas): Likewise.
+ (pe_as16): Likewise.
+ (pe_as32): Likewise.
+ * coffread.c (coff_symfile_read): Likewise.
+ * common/agent.c (agent_look_up_symbols): Likewise.
+ * common/filestuff.c (do_close_cleanup): Likewise.
+ * common/format.c (free_format_pieces_cleanup): Likewise.
+ * common/vec.c (vec_o_reserve): Likewise.
+ * compile/compile-c-support.c (print_one_macro): Likewise.
+ * compile/compile-c-symbols.c (hash_symbol_error): Likewise.
+ (eq_symbol_error): Likewise.
+ (del_symbol_error): Likewise.
+ (error_symbol_once): Likewise.
+ (gcc_convert_symbol): Likewise.
+ (gcc_symbol_address): Likewise.
+ (hash_symname): Likewise.
+ (eq_symname): Likewise.
+ * compile/compile-c-types.c (hash_type_map_instance): Likewise.
+ (eq_type_map_instance): Likewise.
+ (insert_type): Likewise.
+ (convert_type): Likewise.
+ * compile/compile-object-load.c (munmap_listp_free_cleanup): Likewise.
+ (setup_sections): Likewise.
+ (link_hash_table_free): Likewise.
+ (copy_sections): Likewise.
+ * compile/compile-object-run.c (do_module_cleanup): Likewise.
+ * compile/compile.c (compile_print_value): Likewise.
+ (do_rmdir): Likewise.
+ (cleanup_compile_instance): Likewise.
+ (cleanup_unlink_file): Likewise.
+ * completer.c (free_completion_tracker): Likewise.
+ * corelow.c (add_to_spuid_list): Likewise.
+ * cp-namespace.c (reset_directive_searched): Likewise.
+ * cp-support.c (reset_directive_searched): Likewise.
+ * cris-tdep.c (cris_sigtramp_frame_unwind_cache): Likewise.
+ (cris_frame_unwind_cache): Likewise.
+ * d-lang.c (builtin_d_type): Likewise.
+ * d-namespace.c (reset_directive_searched): Likewise.
+ * dbxread.c (dbx_free_symfile_info): Likewise.
+ (do_free_bincl_list_cleanup): Likewise.
+ * disasm.c (hash_dis_line_entry): Likewise.
+ (eq_dis_line_entry): Likewise.
+ (dis_asm_print_address): Likewise.
+ (fprintf_disasm): Likewise.
+ (do_ui_file_delete): Likewise.
+ * doublest.c (convert_floatformat_to_doublest): Likewise.
+ * dummy-frame.c (pop_dummy_frame_bpt): Likewise.
+ (dummy_frame_prev_register): Likewise.
+ (dummy_frame_this_id): Likewise.
+ * dwarf2-frame-tailcall.c (cache_hash): Likewise.
+ (cache_eq): Likewise.
+ (cache_find): Likewise.
+ (tailcall_frame_this_id): Likewise.
+ (dwarf2_tailcall_prev_register_first): Likewise.
+ (tailcall_frame_prev_register): Likewise.
+ (tailcall_frame_dealloc_cache): Likewise.
+ (tailcall_frame_prev_arch): Likewise.
+ * dwarf2-frame.c (dwarf2_frame_state_free): Likewise.
+ (dwarf2_frame_set_init_reg): Likewise.
+ (dwarf2_frame_init_reg): Likewise.
+ (dwarf2_frame_set_signal_frame_p): Likewise.
+ (dwarf2_frame_signal_frame_p): Likewise.
+ (dwarf2_frame_set_adjust_regnum): Likewise.
+ (dwarf2_frame_adjust_regnum): Likewise.
+ (clear_pointer_cleanup): Likewise.
+ (dwarf2_frame_cache): Likewise.
+ (find_cie): Likewise.
+ (dwarf2_frame_find_fde): Likewise.
+ * dwarf2expr.c (dwarf_expr_address_type): Likewise.
+ (free_dwarf_expr_context_cleanup): Likewise.
+ * dwarf2loc.c (locexpr_find_frame_base_location): Likewise.
+ (locexpr_get_frame_base): Likewise.
+ (loclist_find_frame_base_location): Likewise.
+ (loclist_get_frame_base): Likewise.
+ (dwarf_expr_dwarf_call): Likewise.
+ (dwarf_expr_get_base_type): Likewise.
+ (dwarf_expr_push_dwarf_reg_entry_value): Likewise.
+ (dwarf_expr_get_obj_addr): Likewise.
+ (entry_data_value_coerce_ref): Likewise.
+ (entry_data_value_copy_closure): Likewise.
+ (entry_data_value_free_closure): Likewise.
+ (get_frame_address_in_block_wrapper): Likewise.
+ (dwarf2_evaluate_property): Likewise.
+ (dwarf2_compile_property_to_c): Likewise.
+ (needs_frame_read_addr_from_reg): Likewise.
+ (needs_frame_get_reg_value): Likewise.
+ (needs_frame_frame_base): Likewise.
+ (needs_frame_frame_cfa): Likewise.
+ (needs_frame_tls_address): Likewise.
+ (needs_frame_dwarf_call): Likewise.
+ (needs_dwarf_reg_entry_value): Likewise.
+ (get_ax_pc): Likewise.
+ (locexpr_read_variable): Likewise.
+ (locexpr_read_variable_at_entry): Likewise.
+ (locexpr_read_needs_frame): Likewise.
+ (locexpr_describe_location): Likewise.
+ (locexpr_tracepoint_var_ref): Likewise.
+ (locexpr_generate_c_location): Likewise.
+ (loclist_read_variable): Likewise.
+ (loclist_read_variable_at_entry): Likewise.
+ (loclist_describe_location): Likewise.
+ (loclist_tracepoint_var_ref): Likewise.
+ (loclist_generate_c_location): Likewise.
+ * dwarf2read.c (line_header_hash_voidp): Likewise.
+ (line_header_eq_voidp): Likewise.
+ (dwarf2_has_info): Likewise.
+ (dwarf2_get_section_info): Likewise.
+ (locate_dwz_sections): Likewise.
+ (hash_file_name_entry): Likewise.
+ (eq_file_name_entry): Likewise.
+ (delete_file_name_entry): Likewise.
+ (dw2_setup): Likewise.
+ (dw2_get_file_names_reader): Likewise.
+ (dw2_find_pc_sect_compunit_symtab): Likewise.
+ (hash_signatured_type): Likewise.
+ (eq_signatured_type): Likewise.
+ (add_signatured_type_cu_to_table): Likewise.
+ (create_debug_types_hash_table): Likewise.
+ (lookup_dwo_signatured_type): Likewise.
+ (lookup_dwp_signatured_type): Likewise.
+ (lookup_signatured_type): Likewise.
+ (hash_type_unit_group): Likewise.
+ (eq_type_unit_group): Likewise.
+ (get_type_unit_group): Likewise.
+ (process_psymtab_comp_unit_reader): Likewise.
+ (sort_tu_by_abbrev_offset): Likewise.
+ (process_skeletonless_type_unit): Likewise.
+ (psymtabs_addrmap_cleanup): Likewise.
+ (dwarf2_read_symtab): Likewise.
+ (psymtab_to_symtab_1): Likewise.
+ (die_hash): Likewise.
+ (die_eq): Likewise.
+ (load_full_comp_unit_reader): Likewise.
+ (reset_die_in_process): Likewise.
+ (free_cu_line_header): Likewise.
+ (handle_DW_AT_stmt_list): Likewise.
+ (hash_dwo_file): Likewise.
+ (eq_dwo_file): Likewise.
+ (hash_dwo_unit): Likewise.
+ (eq_dwo_unit): Likewise.
+ (create_dwo_cu_reader): Likewise.
+ (create_dwo_unit_in_dwp_v1): Likewise.
+ (create_dwo_unit_in_dwp_v2): Likewise.
+ (lookup_dwo_unit_in_dwp): Likewise.
+ (dwarf2_locate_dwo_sections): Likewise.
+ (dwarf2_locate_common_dwp_sections): Likewise.
+ (dwarf2_locate_v2_dwp_sections): Likewise.
+ (hash_dwp_loaded_cutus): Likewise.
+ (eq_dwp_loaded_cutus): Likewise.
+ (lookup_dwo_cutu): Likewise.
+ (abbrev_table_free_cleanup): Likewise.
+ (dwarf2_free_abbrev_table): Likewise.
+ (find_partial_die_in_comp_unit): Likewise.
+ (free_line_header_voidp): Likewise.
+ (follow_die_offset): Likewise.
+ (follow_die_sig_1): Likewise.
+ (free_heap_comp_unit): Likewise.
+ (free_stack_comp_unit): Likewise.
+ (dwarf2_free_objfile): Likewise.
+ (per_cu_offset_and_type_hash): Likewise.
+ (per_cu_offset_and_type_eq): Likewise.
+ (get_die_type_at_offset): Likewise.
+ (partial_die_hash): Likewise.
+ (partial_die_eq): Likewise.
+ (dwarf2_per_objfile_free): Likewise.
+ (hash_strtab_entry): Likewise.
+ (eq_strtab_entry): Likewise.
+ (add_string): Likewise.
+ (hash_symtab_entry): Likewise.
+ (eq_symtab_entry): Likewise.
+ (delete_symtab_entry): Likewise.
+ (cleanup_mapped_symtab): Likewise.
+ (add_indices_to_cpool): Likewise.
+ (hash_psymtab_cu_index): Likewise.
+ (eq_psymtab_cu_index): Likewise.
+ (add_address_entry_worker): Likewise.
+ (unlink_if_set): Likewise.
+ (write_one_signatured_type): Likewise.
+ (save_gdb_index_command): Likewise.
+ * elfread.c (elf_symtab_read): Likewise.
+ (elf_gnu_ifunc_cache_hash): Likewise.
+ (elf_gnu_ifunc_cache_eq): Likewise.
+ (elf_gnu_ifunc_record_cache): Likewise.
+ (elf_gnu_ifunc_resolve_by_cache): Likewise.
+ (elf_get_probes): Likewise.
+ (probe_key_free): Likewise.
+ * f-lang.c (builtin_f_type): Likewise.
+ * frame-base.c (frame_base_append_sniffer): Likewise.
+ (frame_base_set_default): Likewise.
+ (frame_base_find_by_frame): Likewise.
+ * frame-unwind.c (frame_unwind_prepend_unwinder): Likewise.
+ (frame_unwind_append_unwinder): Likewise.
+ (frame_unwind_find_by_frame): Likewise.
+ * frame.c (frame_addr_hash): Likewise.
+ (frame_addr_hash_eq): Likewise.
+ (frame_stash_find): Likewise.
+ (do_frame_register_read): Likewise.
+ (unwind_to_current_frame): Likewise.
+ (frame_cleanup_after_sniffer): Likewise.
+ * frv-linux-tdep.c (frv_linux_sigtramp_frame_cache): Likewise.
+ * frv-tdep.c (frv_frame_unwind_cache): Likewise.
+ * ft32-tdep.c (ft32_frame_cache): Likewise.
+ * gcore.c (do_bfd_delete_cleanup): Likewise.
+ (gcore_create_callback): Likewise.
+ * gdb_bfd.c (hash_bfd): Likewise.
+ (eq_bfd): Likewise.
+ (gdb_bfd_open): Likewise.
+ (free_one_bfd_section): Likewise.
+ (gdb_bfd_ref): Likewise.
+ (gdb_bfd_unref): Likewise.
+ (get_section_descriptor): Likewise.
+ (gdb_bfd_map_section): Likewise.
+ (gdb_bfd_crc): Likewise.
+ (gdb_bfd_mark_parent): Likewise.
+ (gdb_bfd_record_inclusion): Likewise.
+ (gdb_bfd_requires_relocations): Likewise.
+ (print_one_bfd): Likewise.
+ * gdbtypes.c (type_pair_hash): Likewise.
+ (type_pair_eq): Likewise.
+ (builtin_type): Likewise.
+ (objfile_type): Likewise.
+ * gnu-v3-abi.c (vtable_ptrdiff_type): Likewise.
+ (vtable_address_point_offset): Likewise.
+ (gnuv3_get_vtable): Likewise.
+ (hash_value_and_voffset): Likewise.
+ (eq_value_and_voffset): Likewise.
+ (compare_value_and_voffset): Likewise.
+ (compute_vtable_size): Likewise.
+ (gnuv3_get_typeid_type): Likewise.
+ * go-lang.c (builtin_go_type): Likewise.
+ * guile/scm-block.c (bkscm_hash_block_smob): Likewise.
+ (bkscm_eq_block_smob): Likewise.
+ (bkscm_objfile_block_map): Likewise.
+ (bkscm_del_objfile_blocks): Likewise.
+ * guile/scm-breakpoint.c (bpscm_build_bp_list): Likewise.
+ * guile/scm-disasm.c (gdbscm_disasm_read_memory_worker): Likewise.
+ (gdbscm_disasm_print_address): Likewise.
+ * guile/scm-frame.c (frscm_hash_frame_smob): Likewise.
+ (frscm_eq_frame_smob): Likewise.
+ (frscm_inferior_frame_map): Likewise.
+ (frscm_del_inferior_frames): Likewise.
+ * guile/scm-gsmob.c (gdbscm_add_objfile_ref): Likewise.
+ * guile/scm-objfile.c (ofscm_handle_objfile_deleted): Likewise.
+ (ofscm_objfile_smob_from_objfile): Likewise.
+ * guile/scm-ports.c (ioscm_write): Likewise.
+ (ioscm_file_port_delete): Likewise.
+ (ioscm_file_port_rewind): Likewise.
+ (ioscm_file_port_put): Likewise.
+ (ioscm_file_port_write): Likewise.
+ * guile/scm-progspace.c (psscm_handle_pspace_deleted): Likewise.
+ (psscm_pspace_smob_from_pspace): Likewise.
+ * guile/scm-safe-call.c (scscm_recording_pre_unwind_handler): Likewise.
+ (scscm_recording_unwind_handler): Likewise.
+ (gdbscm_with_catch): Likewise.
+ (scscm_call_0_body): Likewise.
+ (scscm_call_1_body): Likewise.
+ (scscm_call_2_body): Likewise.
+ (scscm_call_3_body): Likewise.
+ (scscm_call_4_body): Likewise.
+ (scscm_apply_1_body): Likewise.
+ (scscm_eval_scheme_string): Likewise.
+ (gdbscm_safe_eval_string): Likewise.
+ (scscm_source_scheme_script): Likewise.
+ (gdbscm_safe_source_script): Likewise.
+ * guile/scm-string.c (gdbscm_call_scm_to_stringn): Likewise.
+ (gdbscm_call_scm_from_stringn): Likewise.
+ * guile/scm-symbol.c (syscm_hash_symbol_smob): Likewise.
+ (syscm_eq_symbol_smob): Likewise.
+ (syscm_get_symbol_map): Likewise.
+ (syscm_del_objfile_symbols): Likewise.
+ * guile/scm-symtab.c (stscm_hash_symtab_smob): Likewise.
+ (stscm_eq_symtab_smob): Likewise.
+ (stscm_objfile_symtab_map): Likewise.
+ (stscm_del_objfile_symtabs): Likewise.
+ * guile/scm-type.c (tyscm_hash_type_smob): Likewise.
+ (tyscm_eq_type_smob): Likewise.
+ (tyscm_type_map): Likewise.
+ (tyscm_copy_type_recursive): Likewise.
+ (save_objfile_types): Likewise.
+ * guile/scm-utils.c (extract_arg): Likewise.
+ * h8300-tdep.c (h8300_frame_cache): Likewise.
+ * hppa-linux-tdep.c (hppa_linux_sigtramp_frame_unwind_cache): Likewise.
+ * hppa-tdep.c (compare_unwind_entries): Likewise.
+ (find_unwind_entry): Likewise.
+ (hppa_frame_cache): Likewise.
+ (hppa_stub_frame_unwind_cache): Likewise.
+ * hppanbsd-tdep.c (hppanbsd_supply_gregset): Likewise.
+ * hppaobsd-tdep.c (hppaobsd_supply_gregset): Likewise.
+ (hppaobsd_supply_fpregset): Likewise.
+ * i386-cygwin-tdep.c (core_process_module_section): Likewise.
+ * i386-linux-tdep.c (i386_linux_init_abi): Likewise.
+ * i386-tdep.c (i386_frame_cache): Likewise.
+ (i386_epilogue_frame_cache): Likewise.
+ (i386_sigtramp_frame_cache): Likewise.
+ (i386_supply_gregset): Likewise.
+ (i386_collect_gregset): Likewise.
+ (i386_gdbarch_init): Likewise.
+ * i386obsd-tdep.c (i386obsd_aout_supply_regset): Likewise.
+ (i386obsd_trapframe_cache): Likewise.
+ * i387-tdep.c (i387_supply_fsave): Likewise.
+ (i387_collect_fsave): Likewise.
+ (i387_supply_fxsave): Likewise.
+ (i387_collect_fxsave): Likewise.
+ (i387_supply_xsave): Likewise.
+ (i387_collect_xsave): Likewise.
+ * ia64-tdep.c (ia64_frame_cache): Likewise.
+ (ia64_sigtramp_frame_cache): Likewise.
+ * infcmd.c (attach_command_continuation): Likewise.
+ (attach_command_continuation_free_args): Likewise.
+ * inferior.c (restore_inferior): Likewise.
+ (delete_thread_of_inferior): Likewise.
+ * inflow.c (inflow_inferior_data_cleanup): Likewise.
+ (get_inflow_inferior_data): Likewise.
+ (inflow_inferior_exit): Likewise.
+ * infrun.c (displaced_step_clear_cleanup): Likewise.
+ (restore_current_uiout_cleanup): Likewise.
+ (release_stop_context_cleanup): Likewise.
+ (do_restore_infcall_suspend_state_cleanup): Likewise.
+ (do_restore_infcall_control_state_cleanup): Likewise.
+ (restore_inferior_ptid): Likewise.
+ * inline-frame.c (block_starting_point_at): Likewise.
+ * iq2000-tdep.c (iq2000_frame_cache): Likewise.
+ * jit.c (get_jit_objfile_data): Likewise.
+ (get_jit_program_space_data): Likewise.
+ (jit_object_close_impl): Likewise.
+ (jit_find_objf_with_entry_addr): Likewise.
+ (jit_breakpoint_deleted): Likewise.
+ (jit_unwind_reg_set_impl): Likewise.
+ (jit_unwind_reg_get_impl): Likewise.
+ (jit_dealloc_cache): Likewise.
+ (jit_frame_sniffer): Likewise.
+ (jit_frame_prev_register): Likewise.
+ (jit_prepend_unwinder): Likewise.
+ (jit_inferior_exit_hook): Likewise.
+ (free_objfile_data): Likewise.
+ * jv-lang.c (jv_per_objfile_free): Likewise.
+ (get_dynamics_objfile): Likewise.
+ (get_java_class_symtab): Likewise.
+ (builtin_java_type): Likewise.
+ * language.c (language_string_char_type): Likewise.
+ (language_bool_type): Likewise.
+ (language_lookup_primitive_type): Likewise.
+ (language_lookup_primitive_type_as_symbol): Likewise.
+ * linespec.c (hash_address_entry): Likewise.
+ (eq_address_entry): Likewise.
+ (iterate_inline_only): Likewise.
+ (iterate_name_matcher): Likewise.
+ (decode_line_2_compare_items): Likewise.
+ (collect_one_symbol): Likewise.
+ (compare_symbols): Likewise.
+ (compare_msymbols): Likewise.
+ (add_symtabs_to_list): Likewise.
+ (collect_symbols): Likewise.
+ (compare_msyms): Likewise.
+ (add_minsym): Likewise.
+ (cleanup_linespec_result): Likewise.
+ * linux-fork.c (inferior_call_waitpid_cleanup): Likewise.
+ * linux-nat.c (delete_lwp_cleanup): Likewise.
+ (count_events_callback): Likewise.
+ (select_event_lwp_callback): Likewise.
+ (resume_stopped_resumed_lwps): Likewise.
+ * linux-tdep.c (get_linux_gdbarch_data): Likewise.
+ (invalidate_linux_cache_inf): Likewise.
+ (get_linux_inferior_data): Likewise.
+ (linux_find_memory_regions_thunk): Likewise.
+ (linux_make_mappings_callback): Likewise.
+ (linux_corefile_thread_callback): Likewise.
+ (find_mapping_size): Likewise.
+ * linux-thread-db.c (find_new_threads_callback): Likewise.
+ * lm32-tdep.c (lm32_frame_cache): Likewise.
+ * m2-lang.c (builtin_m2_type): Likewise.
+ * m32c-tdep.c (m32c_analyze_frame_prologue): Likewise.
+ * m32r-linux-tdep.c (m32r_linux_sigtramp_frame_cache): Likewise.
+ (m32r_linux_supply_gregset): Likewise.
+ (m32r_linux_collect_gregset): Likewise.
+ * m32r-tdep.c (m32r_frame_unwind_cache): Likewise.
+ * m68hc11-tdep.c (m68hc11_frame_unwind_cache): Likewise.
+ * m68k-tdep.c (m68k_frame_cache): Likewise.
+ * m68kbsd-tdep.c (m68kbsd_supply_fpregset): Likewise.
+ (m68kbsd_supply_gregset): Likewise.
+ * m68klinux-tdep.c (m68k_linux_sigtramp_frame_cache): Likewise.
+ * m88k-tdep.c (m88k_frame_cache): Likewise.
+ (m88k_supply_gregset): Likewise.
+
+2015-09-25 Simon Marchi <simon.marchi@ericsson.com>
+
* aarch64-linux-tdep.c (aarch64_stap_parse_special_token): Add cast
to allocation result assignment.
* ada-exp.y (write_object_renaming): Likewise.
struct aarch64_prologue_cache *cache;
if (*this_cache != NULL)
- return *this_cache;
+ return (struct aarch64_prologue_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct aarch64_prologue_cache);
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
struct aarch64_prologue_cache *cache;
if (*this_cache != NULL)
- return *this_cache;
+ return (struct aarch64_prologue_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct aarch64_prologue_cache);
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
static struct value *
value_of_aarch64_user_reg (struct frame_info *frame, const void *baton)
{
- const int *reg_p = baton;
+ const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, frame);
}
{
struct ada_inferior_data *data;
- data = inferior_data (inf, ada_inferior_data);
+ data = (struct ada_inferior_data *) inferior_data (inf, ada_inferior_data);
if (data != NULL)
xfree (data);
}
{
struct ada_inferior_data *data;
- data = inferior_data (inf, ada_inferior_data);
+ data = (struct ada_inferior_data *) inferior_data (inf, ada_inferior_data);
if (data == NULL)
{
data = XCNEW (struct ada_inferior_data);
{
struct ada_pspace_data *data;
- data = program_space_data (pspace, ada_pspace_data_handle);
+ data = ((struct ada_pspace_data *)
+ program_space_data (pspace, ada_pspace_data_handle));
if (data == NULL)
{
data = XCNEW (struct ada_pspace_data);
static void
ada_pspace_data_cleanup (struct program_space *pspace, void *data)
{
- struct ada_pspace_data *pspace_data = data;
+ struct ada_pspace_data *pspace_data = (struct ada_pspace_data *) data;
if (pspace_data->sym_cache != NULL)
ada_free_symbol_cache (pspace_data->sym_cache);
static int
ada_complete_symbol_matcher (const char *name, void *user_data)
{
- struct add_partial_datum *data = user_data;
+ struct add_partial_datum *data = (struct add_partial_datum *) user_data;
return symbol_completion_match (name, data->text, data->text_len,
data->wild_match, data->encoded) != NULL;
static int
ada_exc_search_name_matches (const char *search_name, void *user_data)
{
- regex_t *preg = user_data;
+ regex_t *preg = (regex_t *) user_data;
if (preg == NULL)
return 1;
{
struct ada_tasks_pspace_data *data;
- data = program_space_data (pspace, ada_tasks_pspace_data_handle);
+ data = ((struct ada_tasks_pspace_data *)
+ program_space_data (pspace, ada_tasks_pspace_data_handle));
if (data == NULL)
{
data = XCNEW (struct ada_tasks_pspace_data);
{
struct ada_tasks_inferior_data *data;
- data = inferior_data (inf, ada_tasks_inferior_data_handle);
+ data = ((struct ada_tasks_inferior_data *)
+ inferior_data (inf, ada_tasks_inferior_data_handle));
if (data == NULL)
{
data = XCNEW (struct ada_tasks_inferior_data);
static int
addrmap_mutable_foreach_worker (splay_tree_node node, void *data)
{
- struct mutable_foreach_data *foreach_data = data;
+ struct mutable_foreach_data *foreach_data
+ = (struct mutable_foreach_data *) data;
return foreach_data->fn (foreach_data->data,
addrmap_node_key (node),
static void *
splay_obstack_alloc (int size, void *closure)
{
- struct addrmap_mutable *map = closure;
+ struct addrmap_mutable *map = (struct addrmap_mutable *) closure;
splay_tree_node n;
/* We should only be asked to allocate nodes and larger things.
static void
splay_obstack_free (void *obj, void *closure)
{
- struct addrmap_mutable *map = closure;
- splay_tree_node n = obj;
+ struct addrmap_mutable *map = (struct addrmap_mutable *) closure;
+ splay_tree_node n = (splay_tree_node) obj;
/* We've asserted in the allocation function that we only allocate
nodes or larger things, so it should be safe to put whatever
struct regcache *regcache,
int regnum, const void *gregs, size_t len)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
gdb_assert (len >= 32 * 8);
alpha_supply_int_regs (regcache, regnum, regs, regs + 31 * 8,
const struct regcache *regcache,
int regnum, void *gregs, size_t len)
{
- gdb_byte *regs = gregs;
+ gdb_byte *regs = (gdb_byte *) gregs;
gdb_assert (len >= 32 * 8);
alpha_fill_int_regs (regcache, regnum, regs, regs + 31 * 8,
struct regcache *regcache,
int regnum, const void *fpregs, size_t len)
{
- const gdb_byte *regs = fpregs;
+ const gdb_byte *regs = (const gdb_byte *) fpregs;
gdb_assert (len >= 32 * 8);
alpha_supply_fp_regs (regcache, regnum, regs, regs + 31 * 8);
const struct regcache *regcache,
int regnum, void *fpregs, size_t len)
{
- gdb_byte *regs = fpregs;
+ gdb_byte *regs = (gdb_byte *) fpregs;
gdb_assert (len >= 32 * 8);
alpha_fill_fp_regs (regcache, regnum, regs, regs + 31 * 8);
int ireg, returnreg;
if (*this_prologue_cache)
- return *this_prologue_cache;
+ return (struct alpha_mdebug_unwind_cache *) *this_prologue_cache;
info = FRAME_OBSTACK_ZALLOC (struct alpha_mdebug_unwind_cache);
*this_prologue_cache = info;
alpha_lds (struct gdbarch *gdbarch, void *out, const void *in)
{
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- ULONGEST mem = extract_unsigned_integer (in, 4, byte_order);
+ ULONGEST mem
+ = extract_unsigned_integer ((const gdb_byte *) in, 4, byte_order);
ULONGEST frac = (mem >> 0) & 0x7fffff;
ULONGEST sign = (mem >> 31) & 1;
ULONGEST exp_msb = (mem >> 30) & 1;
}
reg = (sign << 63) | (exp << 52) | (frac << 29);
- store_unsigned_integer (out, 8, byte_order, reg);
+ store_unsigned_integer ((gdb_byte *) out, 8, byte_order, reg);
}
/* Similarly, this represents exactly the conversion performed by
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
ULONGEST reg, mem;
- reg = extract_unsigned_integer (in, 8, byte_order);
+ reg = extract_unsigned_integer ((const gdb_byte *) in, 8, byte_order);
mem = ((reg >> 32) & 0xc0000000) | ((reg >> 29) & 0x3fffffff);
- store_unsigned_integer (out, 4, byte_order, mem);
+ store_unsigned_integer ((gdb_byte *) out, 4, byte_order, mem);
}
/* The alpha needs a conversion between register and memory format if the
struct gdbarch_tdep *tdep;
if (*this_prologue_cache)
- return *this_prologue_cache;
+ return (struct alpha_sigtramp_unwind_cache *) *this_prologue_cache;
info = FRAME_OBSTACK_ZALLOC (struct alpha_sigtramp_unwind_cache);
*this_prologue_cache = info;
int frame_reg, frame_size, return_reg, reg;
if (*this_prologue_cache)
- return *this_prologue_cache;
+ return (struct alpha_heuristic_unwind_cache *) *this_prologue_cache;
info = FRAME_OBSTACK_ZALLOC (struct alpha_heuristic_unwind_cache);
*this_prologue_cache = info;
alpha_supply_int_regs (struct regcache *regcache, int regno,
const void *r0_r30, const void *pc, const void *unique)
{
- const gdb_byte *regs = r0_r30;
+ const gdb_byte *regs = (const gdb_byte *) r0_r30;
int i;
for (i = 0; i < 31; ++i)
alpha_fill_int_regs (const struct regcache *regcache,
int regno, void *r0_r30, void *pc, void *unique)
{
- gdb_byte *regs = r0_r30;
+ gdb_byte *regs = (gdb_byte *) r0_r30;
int i;
for (i = 0; i < 31; ++i)
alpha_supply_fp_regs (struct regcache *regcache, int regno,
const void *f0_f30, const void *fpcr)
{
- const gdb_byte *regs = f0_f30;
+ const gdb_byte *regs = (const gdb_byte *) f0_f30;
int i;
for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
alpha_fill_fp_regs (const struct regcache *regcache,
int regno, void *f0_f30, void *fpcr)
{
- gdb_byte *regs = f0_f30;
+ gdb_byte *regs = (gdb_byte *) f0_f30;
int i;
for (i = ALPHA_FP0_REGNUM; i < ALPHA_FP0_REGNUM + 31; ++i)
struct regcache *regcache,
int regnum, const void *fpregs, size_t len)
{
- const gdb_byte *regs = fpregs;
+ const gdb_byte *regs = (const gdb_byte *) fpregs;
int i;
gdb_assert (len >= ALPHANBSD_SIZEOF_FPREGS);
struct regcache *regcache,
int regnum, const void *gregs, size_t len)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
int i;
/* Table to map a GDB register number to a trapframe register index. */
struct regcache *regcache,
int regnum, const void *gregs, size_t len)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
int i;
if (len >= ALPHANBSD_SIZEOF_GREGS + ALPHANBSD_SIZEOF_FPREGS)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
const struct target_desc *tdesc = info.target_desc;
- struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info;
+ struct tdesc_arch_data *tdesc_data
+ = (struct tdesc_arch_data *) info.tdep_info;
const struct tdesc_feature *feature;
int valid_p;
}
static void
-amd64_x32_linux_init_abi(struct gdbarch_info info, struct gdbarch *gdbarch)
+amd64_x32_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
const struct target_desc *tdesc = info.target_desc;
- struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info;
+ struct tdesc_arch_data *tdesc_data
+ = (struct tdesc_arch_data *) info.tdep_info;
const struct tdesc_feature *feature;
int valid_p;
amd64_supply_native_gregset (struct regcache *regcache,
const void *gregs, int regnum)
{
- const char *regs = gregs;
+ const char *regs = (const char *) gregs;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int num_regs = amd64_native_gregset64_num_regs;
int i;
amd64_collect_native_gregset (const struct regcache *regcache,
void *gregs, int regnum)
{
- char *regs = gregs;
+ char *regs = (char *) gregs;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
int num_regs = amd64_native_gregset64_num_regs;
int i;
struct amd64_frame_cache *cache;
if (*this_cache)
- return *this_cache;
+ return (struct amd64_frame_cache *) *this_cache;
cache = amd64_alloc_frame_cache ();
*this_cache = cache;
int i;
if (*this_cache)
- return *this_cache;
+ return (struct amd64_frame_cache *) *this_cache;
cache = amd64_alloc_frame_cache ();
gdb_byte buf[8];
if (*this_cache)
- return *this_cache;
+ return (struct amd64_frame_cache *) *this_cache;
cache = amd64_alloc_frame_cache ();
*this_cache = cache;
if (fxsave
&& gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 64)
{
- const gdb_byte *regs = fxsave;
+ const gdb_byte *regs = (const gdb_byte *) fxsave;
if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
regcache_raw_supply (regcache, I387_FISEG_REGNUM (tdep), regs + 12);
if (xsave
&& gdbarch_bfd_arch_info (gdbarch)->bits_per_word == 64)
{
- const gdb_byte *regs = xsave;
+ const gdb_byte *regs = (const gdb_byte *) xsave;
if (regnum == -1 || regnum == I387_FISEG_REGNUM (tdep))
regcache_raw_supply (regcache, I387_FISEG_REGNUM (tdep),
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- gdb_byte *regs = fxsave;
+ gdb_byte *regs = (gdb_byte *) fxsave;
i387_collect_fxsave (regcache, regnum, fxsave);
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- gdb_byte *regs = xsave;
+ gdb_byte *regs = (gdb_byte *) xsave;
i387_collect_xsave (regcache, regnum, xsave, gcore);
CORE_ADDR unwind_info = 0;
if (*this_cache)
- return *this_cache;
+ return (struct amd64_windows_frame_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct amd64_windows_frame_cache);
*this_cache = cache;
int i;
if (*this_cache)
- return *this_cache;
+ return (struct trad_frame_cache *) *this_cache;
cache = trad_frame_cache_zalloc (this_frame);
*this_cache = cache;
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- const gdb_byte *gregs = gregs_buf;
+ const gdb_byte *gregs = (const gdb_byte *) gregs_buf;
int regno;
CORE_ADDR reg_pc;
gdb_byte pc_buf[INT_REGISTER_SIZE];
const struct regcache *regcache,
int regnum, void *gregs_buf, size_t len)
{
- gdb_byte *gregs = gregs_buf;
+ gdb_byte *gregs = (gdb_byte *) gregs_buf;
int regno;
for (regno = ARM_A1_REGNUM; regno < ARM_PC_REGNUM; regno++)
struct regcache *regcache,
int regnum, const void *regs_buf, size_t len)
{
- const gdb_byte *regs = regs_buf;
+ const gdb_byte *regs = (const gdb_byte *) regs_buf;
int regno;
if (regnum == ARM_FPS_REGNUM || regnum == -1)
const struct regcache *regcache,
int regnum, void *regs_buf, size_t len)
{
- gdb_byte *regs = regs_buf;
+ gdb_byte *regs = (gdb_byte *) regs_buf;
int regno;
for (regno = ARM_F0_REGNUM; regno <= ARM_F7_REGNUM; regno++)
struct regcache *regcache,
int regnum, const void *regs_buf, size_t len)
{
- const gdb_byte *regs = regs_buf;
+ const gdb_byte *regs = (const gdb_byte *) regs_buf;
int regno;
if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
const struct regcache *regcache,
int regnum, void *regs_buf, size_t len)
{
- gdb_byte *regs = regs_buf;
+ gdb_byte *regs = (gdb_byte *) regs_buf;
int regno;
if (regnum == ARM_FPSCR_REGNUM || regnum == -1)
0 };
unsigned int idx;
- data = objfile_data (sec->objfile, arm_objfile_data_key);
+ data = (struct arm_per_objfile *) objfile_data (sec->objfile,
+ arm_objfile_data_key);
if (data != NULL)
{
map = data->section_maps[sec->the_bfd_section->index];
if (*this_cache == NULL)
*this_cache = arm_make_prologue_cache (this_frame);
- cache = *this_cache;
+ cache = (struct arm_prologue_cache *) *this_cache;
/* This is meant to halt the backtrace at "_start". */
pc = get_frame_pc (this_frame);
if (*this_cache == NULL)
*this_cache = arm_make_prologue_cache (this_frame);
- cache = *this_cache;
+ cache = (struct arm_prologue_cache *) *this_cache;
/* Use function start address as part of the frame ID. If we cannot
identify the start address (due to missing symbol information),
if (*this_cache == NULL)
*this_cache = arm_make_prologue_cache (this_frame);
- cache = *this_cache;
+ cache = (struct arm_prologue_cache *) *this_cache;
/* If we are asked to unwind the PC, then we need to return the LR
instead. The prologue may save PC, but it will point into this
static void
arm_exidx_data_free (struct objfile *objfile, void *arg)
{
- struct arm_exidx_data *data = arg;
+ struct arm_exidx_data *data = (struct arm_exidx_data *) arg;
unsigned int i;
for (i = 0; i < objfile->obfd->section_count; i++)
struct arm_exidx_entry map_key = { memaddr - obj_section_addr (sec), 0 };
unsigned int idx;
- data = objfile_data (sec->objfile, arm_exidx_data_key);
+ data = ((struct arm_exidx_data *)
+ objfile_data (sec->objfile, arm_exidx_data_key));
if (data != NULL)
{
map = data->section_maps[sec->the_bfd_section->index];
if (*this_cache == NULL)
*this_cache = arm_make_stub_cache (this_frame);
- cache = *this_cache;
+ cache = (struct arm_prologue_cache *) *this_cache;
*this_id = frame_id_build (cache->prev_sp, get_frame_pc (this_frame));
}
if (*this_cache == NULL)
*this_cache = arm_m_exception_cache (this_frame);
- cache = *this_cache;
+ cache = (struct arm_prologue_cache *) *this_cache;
/* Our frame ID for a stub frame is the current SP and LR. */
*this_id = frame_id_build (cache->prev_sp,
if (*this_cache == NULL)
*this_cache = arm_m_exception_cache (this_frame);
- cache = *this_cache;
+ cache = (struct arm_prologue_cache *) *this_cache;
/* The value was already reconstructed into PREV_SP. */
if (prev_regnum == ARM_SP_REGNUM)
if (*this_cache == NULL)
*this_cache = arm_make_prologue_cache (this_frame);
- cache = *this_cache;
+ cache = (struct arm_prologue_cache *) *this_cache;
return cache->prev_sp - cache->framesize;
}
static int
gdb_print_insn_arm (bfd_vma memaddr, disassemble_info *info)
{
- struct gdbarch *gdbarch = info->application_data;
+ struct gdbarch *gdbarch = (struct gdbarch *) info->application_data;
if (arm_pc_is_thumb (gdbarch, memaddr))
{
static void
arm_objfile_data_free (struct objfile *objfile, void *arg)
{
- struct arm_per_objfile *data = arg;
+ struct arm_per_objfile *data = (struct arm_per_objfile *) arg;
unsigned int i;
for (i = 0; i < objfile->obfd->section_count; i++)
if (name[1] != 'a' && name[1] != 't' && name[1] != 'd')
return;
- data = objfile_data (objfile, arm_objfile_data_key);
+ data = (struct arm_per_objfile *) objfile_data (objfile,
+ arm_objfile_data_key);
if (data == NULL)
{
data = OBSTACK_ZALLOC (&objfile->objfile_obstack,
static struct value *
value_of_arm_user_reg (struct frame_info *frame, const void *baton)
{
- const int *reg_p = baton;
+ const int *reg_p = (const int *) baton;
return value_of_register (*reg_p, frame);
}
\f
struct regcache *regcache,
int regnum, const void *fpregs, size_t len)
{
- const gdb_byte *regs = fpregs;
+ const gdb_byte *regs = (const gdb_byte *) fpregs;
int i;
gdb_assert (len >= ARMBSD_SIZEOF_FPREGS);
struct regcache *regcache,
int regnum, const void *gregs, size_t len)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
int i;
gdb_assert (len >= ARMBSD_SIZEOF_GREGS);
static void
auto_load_pspace_data_cleanup (struct program_space *pspace, void *arg)
{
- struct auto_load_pspace_info *info = arg;
+ struct auto_load_pspace_info *info = (struct auto_load_pspace_info *) arg;
if (info->loaded_script_files)
htab_delete (info->loaded_script_files);
{
struct auto_load_pspace_info *info;
- info = program_space_data (pspace, auto_load_pspace_data);
+ info = ((struct auto_load_pspace_info *)
+ program_space_data (pspace, auto_load_pspace_data));
if (info == NULL)
{
info = XCNEW (struct auto_load_pspace_info);
static hashval_t
hash_loaded_script_entry (const void *data)
{
- const struct loaded_script *e = data;
+ const struct loaded_script *e = (const struct loaded_script *) data;
return htab_hash_string (e->name) ^ htab_hash_pointer (e->language);
}
static int
eq_loaded_script_entry (const void *a, const void *b)
{
- const struct loaded_script *ea = a;
- const struct loaded_script *eb = b;
+ const struct loaded_script *ea = (const struct loaded_script *) a;
+ const struct loaded_script *eb = (const struct loaded_script *) b;
return strcmp (ea->name, eb->name) == 0 && ea->language == eb->language;
}
struct program_space *pspace = current_program_space;
struct auto_load_pspace_info *info;
- info = program_space_data (pspace, auto_load_pspace_data);
+ info = ((struct auto_load_pspace_info *)
+ program_space_data (pspace, auto_load_pspace_data));
if (info != NULL && info->loaded_script_files != NULL)
{
htab_delete (info->loaded_script_files);
static int
collect_matching_scripts (void **slot, void *info)
{
- struct loaded_script *script = *slot;
- struct collect_matching_scripts_data *data = info;
+ struct loaded_script *script = (struct loaded_script *) *slot;
+ struct collect_matching_scripts_data *data
+ = (struct collect_matching_scripts_data *) info;
if (script->language == data->language && re_exec (script->name))
VEC_safe_push (loaded_script_ptr, *data->scripts_p, script);
{
struct auxv_info *info;
- info = inferior_data (inf, auxv_inferior_data);
+ info = (struct auxv_info *) inferior_data (inf, auxv_inferior_data);
if (info != NULL)
{
xfree (info->data);
struct auxv_info *info;
struct inferior *inf = current_inferior ();
- info = inferior_data (inf, auxv_inferior_data);
+ info = (struct auxv_info *) inferior_data (inf, auxv_inferior_data);
if (info == NULL)
{
info = XCNEW (struct auxv_info);
int i;
if (*this_prologue_cache)
- return *this_prologue_cache;
+ return (struct avr_unwind_cache *) *this_prologue_cache;
info = FRAME_OBSTACK_ZALLOC (struct avr_unwind_cache);
*this_prologue_cache = info;
static void
do_free_agent_expr_cleanup (void *x)
{
- free_agent_expr (x);
+ free_agent_expr ((struct agent_expr *) x);
}
struct cleanup *
{
case TARGET_OBJECT_MEMORY:
{
- struct target_bfd_data *data = ops->to_data;
+ struct target_bfd_data *data = (struct target_bfd_data *) ops->to_data;
return section_table_xfer_memory_partial (readbuf, writebuf,
offset, len, xfered_len,
data->table.sections,
static struct target_section_table *
target_bfd_get_section_table (struct target_ops *ops)
{
- struct target_bfd_data *data = ops->to_data;
+ struct target_bfd_data *data = (struct target_bfd_data *) ops->to_data;
return &data->table;
}
static void
target_bfd_xclose (struct target_ops *t)
{
- struct target_bfd_data *data = t->to_data;
+ struct target_bfd_data *data = (struct target_bfd_data *) t->to_data;
gdb_bfd_unref (data->bfd);
xfree (data->table.sections);
int i;
if (*this_cache)
- return *this_cache;
+ return (struct bfin_frame_cache *) *this_cache;
cache = bfin_alloc_frame_cache ();
*this_cache = cache;
/* If we have an addrmap mapping code addresses to blocks, then use
that. */
if (BLOCKVECTOR_MAP (bl))
- return addrmap_find (BLOCKVECTOR_MAP (bl), pc);
+ return (struct block *) addrmap_find (BLOCKVECTOR_MAP (bl), pc);
/* Otherwise, use binary search to find the last block that starts
before PC.
: MSYMBOL_PRINT_NAME (msym.minsym)));
}
- return *slot;
+ return (struct call_site *) *slot;
}
/* Return the blockvector immediately containing the innermost lexical block
int
block_find_non_opaque_type_preferred (struct symbol *sym, void *data)
{
- struct symbol **best = data;
+ struct symbol **best = (struct symbol **) data;
if (!TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
return 1;
static int
signal_catchpoint_insert_location (struct bp_location *bl)
{
- struct signal_catchpoint *c = (void *) bl->owner;
+ struct signal_catchpoint *c = (struct signal_catchpoint *) bl->owner;
int i;
if (c->signals_to_be_caught != NULL)
static int
signal_catchpoint_remove_location (struct bp_location *bl)
{
- struct signal_catchpoint *c = (void *) bl->owner;
+ struct signal_catchpoint *c = (struct signal_catchpoint *) bl->owner;
int i;
if (c->signals_to_be_caught != NULL)
CORE_ADDR bp_addr,
const struct target_waitstatus *ws)
{
- const struct signal_catchpoint *c = (void *) bl->owner;
+ const struct signal_catchpoint *c
+ = (const struct signal_catchpoint *) bl->owner;
gdb_signal_type signal_number;
if (ws->kind != TARGET_WAITKIND_STOPPED)
signal_catchpoint_print_one (struct breakpoint *b,
struct bp_location **last_loc)
{
- struct signal_catchpoint *c = (void *) b;
+ struct signal_catchpoint *c = (struct signal_catchpoint *) b;
struct value_print_options opts;
struct ui_out *uiout = current_uiout;
static void
signal_catchpoint_print_mention (struct breakpoint *b)
{
- struct signal_catchpoint *c = (void *) b;
+ struct signal_catchpoint *c = (struct signal_catchpoint *) b;
if (c->signals_to_be_caught)
{
static void
signal_catchpoint_print_recreate (struct breakpoint *b, struct ui_file *fp)
{
- struct signal_catchpoint *c = (void *) b;
+ struct signal_catchpoint *c = (struct signal_catchpoint *) b;
fprintf_unfiltered (fp, "catch signal");
{
struct catch_syscall_inferior_data *inf_data;
- inf_data = inferior_data (inf, catch_syscall_inferior_data);
+ inf_data = ((struct catch_syscall_inferior_data *)
+ inferior_data (inf, catch_syscall_inferior_data));
if (inf_data == NULL)
{
inf_data = XCNEW (struct catch_syscall_inferior_data);
static void
do_cleanup_counted_command_line (void *arg)
{
- decref_counted_command_line (arg);
+ decref_counted_command_line ((struct counted_command_line **) arg);
}
/* Create a cleanup that calls decref_counted_command_line on the
static int
bp_location_compare_addrs (const void *ap, const void *bp)
{
- struct bp_location *a = *(void **) ap;
- struct bp_location *b = *(void **) bp;
+ const struct bp_location *a = *(const struct bp_location **) ap;
+ const struct bp_location *b = *(const struct bp_location **) bp;
if (a->address == b->address)
return 0;
dummy_loc.address = address;
/* Find a close match to the first location at ADDRESS. */
- locp_found = bsearch (&dummy_locp, bp_location, bp_location_count,
- sizeof (struct bp_location **),
- bp_location_compare_addrs);
+ locp_found = ((struct bp_location **)
+ bsearch (&dummy_locp, bp_location, bp_location_count,
+ sizeof (struct bp_location **),
+ bp_location_compare_addrs));
/* Nothing was found, nothing left to do. */
if (locp_found == NULL)
void
check_tracepoint_command (char *line, void *closure)
{
- struct breakpoint *b = closure;
+ struct breakpoint *b = (struct breakpoint *) closure;
validate_actionline (line, b);
}
static void
do_map_commands_command (struct breakpoint *b, void *data)
{
- struct commands_info *info = data;
+ struct commands_info *info = (struct commands_info *) data;
if (info->cmd == NULL)
{
{
struct breakpoint_objfile_data *bp_objfile_data;
- bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
+ bp_objfile_data = ((struct breakpoint_objfile_data *)
+ objfile_data (objfile, breakpoint_objfile_key));
if (bp_objfile_data == NULL)
{
bp_objfile_data =
static void
free_breakpoint_probes (struct objfile *obj, void *data)
{
- struct breakpoint_objfile_data *bp_objfile_data = data;
+ struct breakpoint_objfile_data *bp_objfile_data
+ = (struct breakpoint_objfile_data *) data;
VEC_free (probe_p, bp_objfile_data->longjmp_probes);
VEC_free (probe_p, bp_objfile_data->exception_probes);
static int
do_captured_breakpoint_query (struct ui_out *uiout, void *data)
{
- struct captured_breakpoint_query_args *args = data;
+ struct captured_breakpoint_query_args *args
+ = (struct captured_breakpoint_query_args *) data;
struct breakpoint *b;
struct bp_location *dummy_loc = NULL;
static int
compare_breakpoints (const void *a, const void *b)
{
- const breakpoint_p *ba = a;
+ const breakpoint_p *ba = (const breakpoint_p *) a;
uintptr_t ua = (uintptr_t) *ba;
- const breakpoint_p *bb = b;
+ const breakpoint_p *bb = (const breakpoint_p *) b;
uintptr_t ub = (uintptr_t) *bb;
if ((*ba)->number < (*bb)->number)
static int
bp_location_compare (const void *ap, const void *bp)
{
- struct bp_location *a = *(void **) ap;
- struct bp_location *b = *(void **) bp;
+ const struct bp_location *a = *(const struct bp_location **) ap;
+ const struct bp_location *b = *(const struct bp_location **) bp;
if (a->address != b->address)
return (a->address > b->address) - (a->address < b->address);
static int
bpstat_remove_breakpoint_callback (struct thread_info *th, void *data)
{
- struct breakpoint *bpt = data;
+ struct breakpoint *bpt = (struct breakpoint *) data;
bpstat_remove_bp_location (th->control.stop_bpstat, bpt);
return 0;
static void
do_delete_breakpoint_cleanup (void *b)
{
- delete_breakpoint (b);
+ delete_breakpoint ((struct breakpoint *) b);
}
struct cleanup *
void (*supply_uthread) (struct regcache *,
int, CORE_ADDR))
{
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+
ops->supply_uthread = supply_uthread;
}
void (*collect_uthread) (const struct regcache *,
int, CORE_ADDR))
{
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
+
ops->collect_uthread = collect_uthread;
}
bsd_uthread_activate (struct objfile *objfile)
{
struct gdbarch *gdbarch = target_gdbarch ();
- struct bsd_uthread_ops *ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
/* Skip if the thread stratum has already been activated. */
if (bsd_uthread_active)
struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *uthread_ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
CORE_ADDR addr = ptid_get_tid (inferior_ptid);
struct target_ops *beneath = find_target_beneath (ops);
CORE_ADDR active_addr;
struct regcache *regcache, int regnum)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- struct bsd_uthread_ops *uthread_ops = gdbarch_data (gdbarch, bsd_uthread_data);
+ struct bsd_uthread_ops *uthread_ops
+ = (struct bsd_uthread_ops *) gdbarch_data (gdbarch, bsd_uthread_data);
struct target_ops *beneath = find_target_beneath (ops);
CORE_ADDR addr = ptid_get_tid (inferior_ptid);
CORE_ADDR active_addr;
const struct gdb_xml_element *element,
void *user_data, VEC (gdb_xml_value_s) *attributes)
{
- const char *version = xml_find_attribute (attributes, "version")->value;
+ const char *version
+ = (const char *) xml_find_attribute (attributes, "version")->value;
if (strcmp (version, "1.0") != 0)
gdb_xml_error (parser, _("Unsupported btrace version: \"%s\""), version);
struct btrace_block *block;
ULONGEST *begin, *end;
- btrace = user_data;
+ btrace = (struct btrace_data *) user_data;
switch (btrace->format)
{
gdb_xml_error (parser, _("Btrace format error."));
}
- begin = xml_find_attribute (attributes, "begin")->value;
- end = xml_find_attribute (attributes, "end")->value;
+ begin = (long unsigned int *) xml_find_attribute (attributes, "begin")->value;
+ end = (long unsigned int *) xml_find_attribute (attributes, "end")->value;
block = VEC_safe_push (btrace_block_s, btrace->variant.bts.blocks, NULL);
block->begin = *begin;
const char *vendor;
ULONGEST *family, *model, *stepping;
- vendor = xml_find_attribute (attributes, "vendor")->value;
- family = xml_find_attribute (attributes, "family")->value;
- model = xml_find_attribute (attributes, "model")->value;
- stepping = xml_find_attribute (attributes, "stepping")->value;
+ vendor = (const char *) xml_find_attribute (attributes, "vendor")->value;
+ family = (ULONGEST *) xml_find_attribute (attributes, "family")->value;
+ model = (ULONGEST *) xml_find_attribute (attributes, "model")->value;
+ stepping = (ULONGEST *) xml_find_attribute (attributes, "stepping")->value;
- btrace = user_data;
+ btrace = (struct btrace_data *) user_data;
if (strcmp (vendor, "GenuineIntel") == 0)
btrace->variant.pt.config.cpu.vendor = CV_INTEL;
{
struct btrace_data *btrace;
- btrace = user_data;
+ btrace = (struct btrace_data *) user_data;
parse_xml_raw (parser, body_text, &btrace->variant.pt.data,
&btrace->variant.pt.size);
}
{
struct btrace_data *btrace;
- btrace = user_data;
+ btrace = (struct btrace_data *) user_data;
btrace->format = BTRACE_FORMAT_PT;
btrace->variant.pt.config.cpu.vendor = CV_UNKNOWN;
btrace->variant.pt.data = NULL;
struct btrace_config *conf;
struct gdb_xml_value *size;
- conf = user_data;
+ conf = (struct btrace_config *) user_data;
conf->format = BTRACE_FORMAT_BTS;
conf->bts.size = 0;
struct btrace_config *conf;
struct gdb_xml_value *size;
- conf = user_data;
+ conf = (struct btrace_config *) user_data;
conf->format = BTRACE_FORMAT_PT;
conf->pt.size = 0;
static void
do_btrace_data_cleanup (void *arg)
{
- btrace_data_fini (arg);
+ btrace_data_fini ((struct btrace_data *) arg);
}
/* See btrace.h. */
static const char *
find_typedef_for_canonicalize (struct type *t, void *data)
{
- return find_typedef_in_hash (data, t);
+ return find_typedef_in_hash ((const struct type_print_options *) data, t);
}
/* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
static void
cleanup_iconv (void *p)
{
- iconv_t *descp = p;
+ iconv_t *descp = (iconv_t *) p;
iconv_close (*descp);
}
static void
do_cleanup_iterator (void *p)
{
- struct wchar_iterator *iter = p;
+ struct wchar_iterator *iter = (struct wchar_iterator *) p;
iconv_close (iter->desc);
xfree (iter->out);
static void
cli_uiout_dtor (struct ui_out *ui_out)
{
- cli_out_data *data = ui_out_data (ui_out);
+ cli_out_data *data = (cli_out_data *) ui_out_data (ui_out);
VEC_free (ui_filep, data->streams);
xfree (data);
int nr_rows,
const char *tblid)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (nr_rows == 0)
data->suppress_output = 1;
static void
cli_table_body (struct ui_out *uiout)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
static void
cli_table_end (struct ui_out *uiout)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
data->suppress_output = 0;
}
const char *col_name,
const char *colhdr)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
int level,
const char *id)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
enum ui_out_type type,
int level)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
const char *fldname, int value)
{
char buffer[20]; /* FIXME: how many chars long a %d can become? */
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
enum ui_align alignment,
const char *fldname)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
{
int before = 0;
int after = 0;
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
const char *format,
va_list args)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
struct ui_file *stream;
if (data->suppress_output)
static void
cli_spaces (struct ui_out *uiout, int numspaces)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
struct ui_file *stream;
if (data->suppress_output)
static void
cli_text (struct ui_out *uiout, const char *string)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
struct ui_file *stream;
if (data->suppress_output)
cli_message (struct ui_out *uiout, int verbosity,
const char *format, va_list args)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
static void
cli_wrap_hint (struct ui_out *uiout, char *identstring)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (data->suppress_output)
return;
static void
cli_flush (struct ui_out *uiout)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
struct ui_file *stream = VEC_last (ui_filep, data->streams);
gdb_flush (stream);
static int
cli_redirect (struct ui_out *uiout, struct ui_file *outstream)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
if (outstream != NULL)
VEC_safe_push (ui_filep, data->streams, outstream);
const char *fldname,
const char *format,...)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
struct ui_file *stream = VEC_last (ui_filep, data->streams);
va_list args;
static void
field_separator (void)
{
- cli_out_data *data = ui_out_data (current_uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (current_uiout);
struct ui_file *stream = VEC_last (ui_filep, data->streams);
fputc_filtered (' ', stream);
struct ui_file *
cli_out_set_stream (struct ui_out *uiout, struct ui_file *stream)
{
- cli_out_data *data = ui_out_data (uiout);
+ cli_out_data *data = (cli_out_data *) ui_out_data (uiout);
struct ui_file *old;
old = VEC_pop (ui_filep, data->streams);
static int
compare_symtabs (const void *a, const void *b)
{
- const struct symtab_and_line *sala = a;
- const struct symtab_and_line *salb = b;
+ const struct symtab_and_line *sala = (const struct symtab_and_line *) a;
+ const struct symtab_and_line *salb = (const struct symtab_and_line *) b;
const char *dira = SYMTAB_DIRNAME (sala->symtab);
const char *dirb = SYMTAB_DIRNAME (salb->symtab);
int r;
static void
call_dump_func (struct cmd_list_element *c, char *args, int from_tty)
{
- struct dump_context *d = get_cmd_context (c);
+ struct dump_context *d = (struct dump_context *) get_cmd_context (c);
d->func (args, d->mode);
}
static void
restore_section_callback (bfd *ibfd, asection *isec, void *args)
{
- struct callback_data *data = args;
+ struct callback_data *data = (struct callback_data *) args;
bfd_vma sec_start = bfd_section_vma (ibfd, isec);
bfd_size_type size = bfd_section_size (ibfd, isec);
bfd_vma sec_end = sec_start + size;
static void
clear_hook_in_cleanup (void *data)
{
- struct cmd_list_element *c = data;
+ struct cmd_list_element *c = (struct cmd_list_element *) data;
c->hook_in = 0; /* Allow hook to work again once it is complete. */
}
static void
do_restore_user_call_depth (void * call_depth)
{
- int *depth = call_depth;
+ int *depth = (int *) call_depth;
(*depth)--;
if ((*depth) == 0)
static void
do_free_command_lines_cleanup (void *arg)
{
- free_command_lines (arg);
+ free_command_lines ((struct command_line **) arg);
}
struct cleanup *
static void
get_section_vmas (bfd *abfd, asection *sectp, void *context)
{
- struct pe_sections_info *data = context;
+ struct pe_sections_info *data = (struct pe_sections_info *) context;
struct read_pe_section_data *sections = data->sections;
int sectix = get_pe_section_index (sectp->name, sections,
data->nb_sections);
static unsigned int
pe_as16 (void *ptr)
{
- unsigned char *b = ptr;
+ unsigned char *b = (unsigned char *) ptr;
return b[0] + (b[1] << 8);
}
static unsigned int
pe_as32 (void *ptr)
{
- unsigned char *b = ptr;
+ unsigned char *b = (unsigned char *) ptr;
return b[0] + (b[1] << 8) + (b[2] << 16) + (b[3] << 24);
}
struct cleanup *back_to, *cleanup_minimal_symbols;
int stabstrsize;
- info = objfile_data (objfile, coff_objfile_data_key);
+ info = (struct coff_symfile_info *) objfile_data (objfile,
+ coff_objfile_data_key);
dbxinfo = DBX_SYMFILE_INFO (objfile);
symfile_bfd = abfd; /* Kludge for swap routines. */
{
CORE_ADDR *addrp =
(CORE_ADDR *) ((char *) &ipa_sym_addrs + symbol_list[i].offset);
+ struct objfile *objfile = (struct objfile *) arg;
if (find_minimal_symbol_address (symbol_list[i].name, addrp,
- arg) != 0)
+ objfile) != 0)
{
DEBUG_AGENT ("symbol `%s' not found\n", symbol_list[i].name);
return -1;
static void
do_close_cleanup (void *arg)
{
- int *fd = arg;
+ int *fd = (int *) arg;
close (*fd);
}
void
free_format_pieces_cleanup (void *ptr)
{
- void **location = ptr;
+ struct format_piece **location = (struct format_piece **) ptr;
if (location == NULL)
return;
void *
vec_o_reserve (void *vec, int reserve, size_t vec_offset, size_t elt_size)
{
- struct vec_prefix *pfx = vec;
+ struct vec_prefix *pfx = (struct vec_prefix *) vec;
unsigned alloc = calculate_allocation (pfx, reserve);
if (!alloc)
struct macro_source_file *source, int line,
void *user_data)
{
- struct ui_file *file = user_data;
+ struct ui_file *file = (struct ui_file *) user_data;
/* Don't print command-line defines. They will be supplied another
way. */
static hashval_t
hash_symbol_error (const void *a)
{
- const struct symbol_error *se = a;
+ const struct symbol_error *se = (const struct symbol_error *) a;
return htab_hash_pointer (se->sym);
}
static int
eq_symbol_error (const void *a, const void *b)
{
- const struct symbol_error *sea = a;
- const struct symbol_error *seb = b;
+ const struct symbol_error *sea = (const struct symbol_error *) a;
+ const struct symbol_error *seb = (const struct symbol_error *) b;
return sea->sym == seb->sym;
}
static void
del_symbol_error (void *a)
{
- struct symbol_error *se = a;
+ struct symbol_error *se = (struct symbol_error *) a;
xfree (se->message);
xfree (se);
return;
search.sym = sym;
- err = htab_find (context->symbol_err_map, &search);
+ err = (struct symbol_error *) htab_find (context->symbol_err_map, &search);
if (err == NULL || err->message == NULL)
return;
enum gcc_c_oracle_request request,
const char *identifier)
{
- struct compile_c_instance *context = datum;
+ struct compile_c_instance *context = (struct compile_c_instance *) datum;
domain_enum domain;
int found = 0;
gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
const char *identifier)
{
- struct compile_c_instance *context = datum;
+ struct compile_c_instance *context = (struct compile_c_instance *) datum;
gcc_address result = 0;
int found = 0;
static hashval_t
hash_symname (const void *a)
{
- const struct symbol *sym = a;
+ const struct symbol *sym = (const struct symbol *) a;
return htab_hash_string (SYMBOL_NATURAL_NAME (sym));
}
static int
eq_symname (const void *a, const void *b)
{
- const struct symbol *syma = a;
- const struct symbol *symb = b;
+ const struct symbol *syma = (const struct symbol *) a;
+ const struct symbol *symb = (const struct symbol *) b;
return strcmp (SYMBOL_NATURAL_NAME (syma), SYMBOL_NATURAL_NAME (symb)) == 0;
}
static hashval_t
hash_type_map_instance (const void *p)
{
- const struct type_map_instance *inst = p;
+ const struct type_map_instance *inst = (const struct type_map_instance *) p;
return htab_hash_pointer (inst->type);
}
static int
eq_type_map_instance (const void *a, const void *b)
{
- const struct type_map_instance *insta = a;
- const struct type_map_instance *instb = b;
+ const struct type_map_instance *insta = (const struct type_map_instance *) a;
+ const struct type_map_instance *instb = (const struct type_map_instance *) b;
return insta->type == instb->type;
}
inst.gcc_type = gcc_type;
slot = htab_find_slot (context->type_map, &inst, INSERT);
- add = *slot;
+ add = (struct type_map_instance *) *slot;
/* The type might have already been inserted in order to handle
recursive types. */
if (add != NULL && add->gcc_type != gcc_type)
type = check_typedef (type);
inst.type = type;
- found = htab_find (context->type_map, &inst);
+ found = (struct type_map_instance *) htab_find (context->type_map, &inst);
if (found != NULL)
return found->gcc_type;
static void
munmap_listp_free_cleanup (void *headp_voidp)
{
- struct munmap_list **headp = headp_voidp;
+ struct munmap_list **headp = (struct munmap_list **) headp_voidp;
munmap_list_free (*headp);
}
static void
setup_sections (bfd *abfd, asection *sect, void *data_voidp)
{
- struct setup_sections_data *data = data_voidp;
+ struct setup_sections_data *data = (struct setup_sections_data *) data_voidp;
CORE_ADDR alignment;
unsigned prot;
static void
link_hash_table_free (void *d)
{
- struct link_hash_table_cleanup_data *data = d;
+ struct link_hash_table_cleanup_data *data
+ = (struct link_hash_table_cleanup_data *) d;
if (data->abfd->is_linker_output)
(*data->abfd->link.hash->hash_table_free) (data->abfd);
static void
copy_sections (bfd *abfd, asection *sect, void *data)
{
- asymbol **symbol_table = data;
+ asymbol **symbol_table = (asymbol **) data;
bfd_byte *sect_data, *sect_data_got;
struct cleanup *cleanups;
struct bfd_link_info link_info;
static void
do_module_cleanup (void *arg, int registers_valid)
{
- struct do_module_cleanup *data = arg;
+ struct do_module_cleanup *data = (struct do_module_cleanup *) arg;
struct objfile *objfile;
if (data->executedp != NULL)
void
compile_print_value (struct value *val, void *data_voidp)
{
- const struct format_data *fmtp = data_voidp;
+ const struct format_data *fmtp = (const struct format_data *) data_voidp;
print_value (val, fmtp);
}
static void
do_rmdir (void *arg)
{
- const char *dir = arg;
+ const char *dir = (const char *) arg;
char *zap;
int wstat;
static void
cleanup_compile_instance (void *arg)
{
- struct compile_instance *inst = arg;
+ struct compile_instance *inst = (struct compile_instance *) arg;
inst->destroy (inst);
}
static void
cleanup_unlink_file (void *arg)
{
- const char *filename = arg;
+ const char *filename = (const char *) arg;
unlink (filename);
}
static void
free_completion_tracker (void *p)
{
- completion_tracker_t *tracker_ptr = p;
+ completion_tracker_t *tracker_ptr = (completion_tracker_t *) p;
htab_delete (*tracker_ptr);
*tracker_ptr = NULL;
static void
add_to_spuid_list (bfd *abfd, asection *asect, void *list_p)
{
- struct spuid_list *list = list_p;
+ struct spuid_list *list = (struct spuid_list *) list_p;
enum bfd_endian byte_order
= bfd_big_endian (abfd) ? BFD_ENDIAN_BIG : BFD_ENDIAN_LITTLE;
int fd, pos = 0;
static void
reset_directive_searched (void *data)
{
- struct using_direct *direct = data;
+ struct using_direct *direct = (struct using_direct *) data;
direct->searched = 0;
}
static void
reset_directive_searched (void *data)
{
- struct using_direct *direct = data;
+ struct using_direct *direct = (struct using_direct *) data;
direct->searched = 0;
}
int i;
if ((*this_cache))
- return (*this_cache);
+ return (struct cris_unwind_cache *) (*this_cache);
info = FRAME_OBSTACK_ZALLOC (struct cris_unwind_cache);
(*this_cache) = info;
struct cris_unwind_cache *info;
if ((*this_prologue_cache))
- return (*this_prologue_cache);
+ return (struct cris_unwind_cache *) (*this_prologue_cache);
info = FRAME_OBSTACK_ZALLOC (struct cris_unwind_cache);
(*this_prologue_cache) = info;
const struct builtin_d_type *
builtin_d_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, d_type_data);
+ return (const struct builtin_d_type *) gdbarch_data (gdbarch, d_type_data);
}
/* Provide a prototype to silence -Wmissing-prototypes. */
static void
reset_directive_searched (void *data)
{
- struct using_direct *direct = data;
+ struct using_direct *direct = (struct using_direct *) data;
direct->searched = 0;
}
static void
dbx_free_symfile_info (struct objfile *objfile, void *arg)
{
- struct dbx_symfile_info *dbx = arg;
+ struct dbx_symfile_info *dbx = (struct dbx_symfile_info *) arg;
if (dbx->header_files != NULL)
{
static void
do_free_bincl_list_cleanup (void *objfile)
{
- free_bincl_list (objfile);
+ free_bincl_list ((struct objfile *) objfile);
}
static struct cleanup *
static hashval_t
hash_dis_line_entry (const void *item)
{
- const struct dis_line_entry *dle = item;
+ const struct dis_line_entry *dle = (const struct dis_line_entry *) item;
return htab_hash_pointer (dle->symtab) + dle->line;
}
static int
eq_dis_line_entry (const void *item_lhs, const void *item_rhs)
{
- const struct dis_line_entry *lhs = item_lhs;
- const struct dis_line_entry *rhs = item_rhs;
+ const struct dis_line_entry *lhs = (const struct dis_line_entry *) item_lhs;
+ const struct dis_line_entry *rhs = (const struct dis_line_entry *) item_rhs;
return (lhs->symtab == rhs->symtab
&& lhs->line == rhs->line);
static void
dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
{
- struct gdbarch *gdbarch = info->application_data;
+ struct gdbarch *gdbarch = (struct gdbarch *) info->application_data;
- print_address (gdbarch, addr, info->stream);
+ print_address (gdbarch, addr, (struct ui_file *) info->stream);
}
static int
va_list args;
va_start (args, format);
- vfprintf_filtered (stream, format, args);
+ vfprintf_filtered ((struct ui_file *) stream, format, args);
va_end (args);
/* Something non -ve. */
return 0;
static void
do_ui_file_delete (void *arg)
{
- ui_file_delete (arg);
+ ui_file_delete ((struct ui_file *) arg);
}
/* Return the length in bytes of the instruction at address MEMADDR in
/* For non-numbers, reuse libiberty's logic to find the correct
format. We do not lose any precision in this case by passing
through a double. */
- kind = floatformat_classify (fmt, from);
+ kind = floatformat_classify (fmt, (const bfd_byte *) from);
if (kind == float_infinite || kind == float_nan)
{
double dto;
static int
pop_dummy_frame_bpt (struct breakpoint *b, void *dummy_voidp)
{
- struct dummy_frame *dummy = dummy_voidp;
+ struct dummy_frame *dummy = (struct dummy_frame *) dummy_voidp;
if (b->thread == pid_to_thread_id (dummy->id.ptid)
&& b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id))
void **this_prologue_cache,
int regnum)
{
- struct dummy_frame_cache *cache = (*this_prologue_cache);
+ struct dummy_frame_cache *cache
+ = (struct dummy_frame_cache *) *this_prologue_cache;
struct gdbarch *gdbarch = get_frame_arch (this_frame);
struct value *reg_val;
struct frame_id *this_id)
{
/* The dummy-frame sniffer always fills in the cache. */
- struct dummy_frame_cache *cache = (*this_prologue_cache);
+ struct dummy_frame_cache *cache
+ = (struct dummy_frame_cache *) *this_prologue_cache;
gdb_assert (cache != NULL);
(*this_id) = cache->this_id;
static hashval_t
cache_hash (const void *arg)
{
- const struct tailcall_cache *cache = arg;
+ const struct tailcall_cache *cache = (const struct tailcall_cache *) arg;
return htab_hash_pointer (cache->next_bottom_frame);
}
static int
cache_eq (const void *arg1, const void *arg2)
{
- const struct tailcall_cache *cache1 = arg1;
- const struct tailcall_cache *cache2 = arg2;
+ const struct tailcall_cache *cache1 = (const struct tailcall_cache *) arg1;
+ const struct tailcall_cache *cache2 = (const struct tailcall_cache *) arg2;
return cache1->next_bottom_frame == cache2->next_bottom_frame;
}
if (slot == NULL)
return NULL;
- cache = *slot;
+ cache = (struct tailcall_cache *) *slot;
gdb_assert (cache != NULL);
return cache;
}
tailcall_frame_this_id (struct frame_info *this_frame, void **this_cache,
struct frame_id *this_id)
{
- struct tailcall_cache *cache = *this_cache;
+ struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
struct frame_info *next_frame;
/* Tail call does not make sense for a sentinel frame. */
void **tailcall_cachep, int regnum)
{
struct gdbarch *this_gdbarch = get_frame_arch (this_frame);
- struct tailcall_cache *cache = *tailcall_cachep;
+ struct tailcall_cache *cache = (struct tailcall_cache *) *tailcall_cachep;
CORE_ADDR addr;
if (regnum == gdbarch_pc_regnum (this_gdbarch))
tailcall_frame_prev_register (struct frame_info *this_frame,
void **this_cache, int regnum)
{
- struct tailcall_cache *cache = *this_cache;
+ struct tailcall_cache *cache = (struct tailcall_cache *) *this_cache;
struct value *val;
gdb_assert (this_frame != cache->next_bottom_frame);
static void
tailcall_frame_dealloc_cache (struct frame_info *self, void *this_cache)
{
- struct tailcall_cache *cache = this_cache;
+ struct tailcall_cache *cache = (struct tailcall_cache *) this_cache;
cache_unref (cache);
}
tailcall_frame_prev_arch (struct frame_info *this_frame,
void **this_prologue_cache)
{
- struct tailcall_cache *cache = *this_prologue_cache;
+ struct tailcall_cache *cache = (struct tailcall_cache *) *this_prologue_cache;
return get_frame_arch (cache->next_bottom_frame);
}
static void
dwarf2_frame_state_free (void *p)
{
- struct dwarf2_frame_state *fs = p;
+ struct dwarf2_frame_state *fs = (struct dwarf2_frame_state *) p;
dwarf2_frame_state_free_regs (fs->initial.prev);
dwarf2_frame_state_free_regs (fs->regs.prev);
struct dwarf2_frame_state_reg *,
struct frame_info *))
{
- struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+ struct dwarf2_frame_ops *ops
+ = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
ops->init_reg = init_reg;
}
struct dwarf2_frame_state_reg *reg,
struct frame_info *this_frame)
{
- struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+ struct dwarf2_frame_ops *ops
+ = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
ops->init_reg (gdbarch, regnum, reg, this_frame);
}
int (*signal_frame_p) (struct gdbarch *,
struct frame_info *))
{
- struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+ struct dwarf2_frame_ops *ops
+ = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
ops->signal_frame_p = signal_frame_p;
}
dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
struct frame_info *this_frame)
{
- struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+ struct dwarf2_frame_ops *ops
+ = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
if (ops->signal_frame_p == NULL)
return 0;
int (*adjust_regnum) (struct gdbarch *,
int, int))
{
- struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+ struct dwarf2_frame_ops *ops
+ = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
ops->adjust_regnum = adjust_regnum;
}
dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
int regnum, int eh_frame_p)
{
- struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
+ struct dwarf2_frame_ops *ops
+ = (struct dwarf2_frame_ops *) gdbarch_data (gdbarch, dwarf2_frame_data);
if (ops->adjust_regnum == NULL)
return regnum;
static void
clear_pointer_cleanup (void *arg)
{
- void **ptr = arg;
+ void **ptr = (void **) arg;
*ptr = NULL;
}
const gdb_byte *instr;
if (*this_cache)
- return *this_cache;
+ return (struct dwarf2_frame_cache *) *this_cache;
/* Allocate a new cache. */
cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
return NULL;
}
- p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
- sizeof (cie_table->entries[0]), bsearch_cie_cmp);
+ p_cie = ((struct dwarf2_cie **)
+ bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
+ sizeof (cie_table->entries[0]), bsearch_cie_cmp));
if (p_cie != NULL)
return *p_cie;
return NULL;
CORE_ADDR offset;
CORE_ADDR seek_pc;
- fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
+ fde_table = ((struct dwarf2_fde_table *)
+ objfile_data (objfile, dwarf2_frame_objfile_data));
if (fde_table == NULL)
{
dwarf2_build_frame_info (objfile);
- fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
+ fde_table = ((struct dwarf2_fde_table *)
+ objfile_data (objfile, dwarf2_frame_objfile_data));
}
gdb_assert (fde_table != NULL);
continue;
seek_pc = *pc - offset;
- p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
- sizeof (fde_table->entries[0]), bsearch_fde_cmp);
+ p_fde = ((struct dwarf2_fde **)
+ bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
+ sizeof (fde_table->entries[0]), bsearch_fde_cmp));
if (p_fde != NULL)
{
*pc = (*p_fde)->initial_location + offset;
static struct type *
dwarf_expr_address_type (struct dwarf_expr_context *ctx)
{
- struct dwarf_gdbarch_types *types = gdbarch_data (ctx->gdbarch,
- dwarf_arch_cookie);
+ struct dwarf_gdbarch_types *types
+ = (struct dwarf_gdbarch_types *) gdbarch_data (ctx->gdbarch,
+ dwarf_arch_cookie);
int ndx;
if (ctx->addr_size == 2)
static void
free_dwarf_expr_context_cleanup (void *arg)
{
- free_dwarf_expr_context (arg);
+ free_dwarf_expr_context ((struct dwarf_expr_context *) arg);
}
/* Return a cleanup that calls free_dwarf_expr_context. */
locexpr_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length)
{
- struct dwarf2_locexpr_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
+ struct dwarf2_locexpr_baton *symbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc);
*length = symbaton->size;
*start = symbaton->data;
gdbarch = get_frame_arch (frame);
type = builtin_type (gdbarch)->builtin_data_ptr;
- dlbaton = SYMBOL_LOCATION_BATON (framefunc);
+ dlbaton = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (framefunc);
SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location
(framefunc, get_frame_pc (frame), &start, &length);
loclist_find_frame_base_location (struct symbol *framefunc, CORE_ADDR pc,
const gdb_byte **start, size_t *length)
{
- struct dwarf2_loclist_baton *symbaton = SYMBOL_LOCATION_BATON (framefunc);
+ struct dwarf2_loclist_baton *symbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc);
*start = dwarf2_find_location_expression (symbaton, length, pc);
}
gdbarch = get_frame_arch (frame);
type = builtin_type (gdbarch)->builtin_data_ptr;
- dlbaton = SYMBOL_LOCATION_BATON (framefunc);
+ dlbaton = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (framefunc);
SYMBOL_BLOCK_OPS (framefunc)->find_frame_base_location
(framefunc, get_frame_pc (frame), &start, &length);
static void
dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
{
- struct dwarf_expr_baton *debaton = ctx->baton;
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) ctx->baton;
per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
ctx->funcs->get_frame_pc, ctx->baton);
dwarf_expr_get_base_type (struct dwarf_expr_context *ctx,
cu_offset die_offset)
{
- struct dwarf_expr_baton *debaton = ctx->baton;
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) ctx->baton;
return dwarf2_get_die_type (die_offset, debaton->per_cu);
}
size_t size;
gdb_assert (ctx->funcs == &dwarf_expr_ctx_funcs);
- debaton = ctx->baton;
+ debaton = (struct dwarf_expr_baton *) ctx->baton;
frame = debaton->frame;
caller_frame = get_prev_frame (frame);
static CORE_ADDR
dwarf_expr_get_obj_addr (void *baton)
{
- struct dwarf_expr_baton *debaton = baton;
+ struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
gdb_assert (debaton != NULL);
if (TYPE_CODE (checked_type) != TYPE_CODE_REF)
return NULL;
- target_val = value_computed_closure (value);
+ target_val = (struct value *) value_computed_closure (value);
value_incref (target_val);
return target_val;
}
static void *
entry_data_value_copy_closure (const struct value *v)
{
- struct value *target_val = value_computed_closure (v);
+ struct value *target_val = (struct value *) value_computed_closure (v);
value_incref (target_val);
return target_val;
static void
entry_data_value_free_closure (struct value *v)
{
- struct value *target_val = value_computed_closure (v);
+ struct value *target_val = (struct value *) value_computed_closure (v);
value_free (target_val);
}
static CORE_ADDR
get_frame_address_in_block_wrapper (void *baton)
{
- return get_frame_address_in_block (baton);
+ return get_frame_address_in_block ((struct frame_info *) baton);
}
/* An implementation of an lval_funcs method to indirect through a
{
case PROP_LOCEXPR:
{
- const struct dwarf2_property_baton *baton = prop->data.baton;
+ const struct dwarf2_property_baton *baton
+ = (const struct dwarf2_property_baton *) prop->data.baton;
if (dwarf2_locexpr_baton_eval (&baton->locexpr, frame,
addr_stack ? addr_stack->addr : 0,
case PROP_LOCLIST:
{
- struct dwarf2_property_baton *baton = prop->data.baton;
+ struct dwarf2_property_baton *baton
+ = (struct dwarf2_property_baton *) prop->data.baton;
CORE_ADDR pc = get_frame_address_in_block (frame);
const gdb_byte *data;
struct value *val;
case PROP_ADDR_OFFSET:
{
- struct dwarf2_property_baton *baton = prop->data.baton;
+ struct dwarf2_property_baton *baton
+ = (struct dwarf2_property_baton *) prop->data.baton;
struct property_addr_info *pinfo;
struct value *val;
CORE_ADDR pc,
struct symbol *sym)
{
- struct dwarf2_property_baton *baton = prop->data.baton;
+ struct dwarf2_property_baton *baton
+ = (struct dwarf2_property_baton *) prop->data.baton;
const gdb_byte *data;
size_t size;
struct dwarf2_per_cu_data *per_cu;
static CORE_ADDR
needs_frame_read_addr_from_reg (void *baton, int regnum)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return 1;
static struct value *
needs_frame_get_reg_value (void *baton, struct type *type, int regnum)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return value_zero (type, not_lval);
needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
{
static gdb_byte lit0 = DW_OP_lit0;
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
*start = &lit0;
*length = 1;
static CORE_ADDR
needs_frame_frame_cfa (void *baton)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return 1;
static CORE_ADDR
needs_frame_tls_address (void *baton, CORE_ADDR offset)
{
- struct needs_frame_baton *nf_baton = baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) baton;
nf_baton->needs_frame = 1;
return 1;
static void
needs_frame_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset)
{
- struct needs_frame_baton *nf_baton = ctx->baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) ctx->baton;
per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
ctx->funcs->get_frame_pc, ctx->baton);
enum call_site_parameter_kind kind,
union call_site_parameter_u kind_u, int deref_size)
{
- struct needs_frame_baton *nf_baton = ctx->baton;
+ struct needs_frame_baton *nf_baton = (struct needs_frame_baton *) ctx->baton;
nf_baton->needs_frame = 1;
static CORE_ADDR
get_ax_pc (void *baton)
{
- struct agent_expr *expr = baton;
+ struct agent_expr *expr = (struct agent_expr *) baton;
return expr->scope;
}
static struct value *
locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
struct value *val;
val = dwarf2_evaluate_loc_desc (SYMBOL_TYPE (symbol), frame, dlbaton->data,
static struct value *
locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
return value_of_dwarf_block_entry (SYMBOL_TYPE (symbol), frame, dlbaton->data,
dlbaton->size);
static int
locexpr_read_needs_frame (struct symbol *symbol)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
return dwarf2_loc_desc_needs_frame (dlbaton->data, dlbaton->size,
dlbaton->per_cu);
locexpr_describe_location (struct symbol *symbol, CORE_ADDR addr,
struct ui_file *stream)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
int offset_size = dwarf2_per_cu_offset_size (dlbaton->per_cu);
locexpr_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
struct agent_expr *ax, struct axs_value *value)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (symbol);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
if (dlbaton->size == 0)
unsigned char *registers_used,
CORE_ADDR pc, const char *result_name)
{
- struct dwarf2_locexpr_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
+ struct dwarf2_locexpr_baton *dlbaton
+ = (struct dwarf2_locexpr_baton *) SYMBOL_LOCATION_BATON (sym);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
if (dlbaton->size == 0)
static struct value *
loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
struct value *val;
const gdb_byte *data;
size_t size;
static struct value *
loclist_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
const gdb_byte *data;
size_t size;
CORE_ADDR pc;
loclist_describe_location (struct symbol *symbol, CORE_ADDR addr,
struct ui_file *stream)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
const gdb_byte *loc_ptr, *buf_end;
struct objfile *objfile = dwarf2_per_cu_objfile (dlbaton->per_cu);
struct gdbarch *gdbarch = get_objfile_arch (objfile);
loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
struct agent_expr *ax, struct axs_value *value)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (symbol);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (symbol);
const gdb_byte *data;
size_t size;
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
unsigned char *registers_used,
CORE_ADDR pc, const char *result_name)
{
- struct dwarf2_loclist_baton *dlbaton = SYMBOL_LOCATION_BATON (sym);
+ struct dwarf2_loclist_baton *dlbaton
+ = (struct dwarf2_loclist_baton *) SYMBOL_LOCATION_BATON (sym);
unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
const gdb_byte *data;
size_t size;
static hashval_t
line_header_hash_voidp (const void *item)
{
- const struct line_header *ofs = item;
+ const struct line_header *ofs = (const struct line_header *) item;
return line_header_hash (ofs);
}
static int
line_header_eq_voidp (const void *item_lhs, const void *item_rhs)
{
- const struct line_header *ofs_lhs = item_lhs;
- const struct line_header *ofs_rhs = item_rhs;
+ const struct line_header *ofs_lhs = (const struct line_header *) item_lhs;
+ const struct line_header *ofs_rhs = (const struct line_header *) item_rhs;
return (ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off
&& ofs_lhs->offset_in_dwz == ofs_rhs->offset_in_dwz);
dwarf2_has_info (struct objfile *objfile,
const struct dwarf2_debug_sections *names)
{
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile = ((struct dwarf2_per_objfile *)
+ objfile_data (objfile, dwarf2_objfile_data_key));
if (!dwarf2_per_objfile)
{
/* Initialize per-objfile state. */
bfd_size_type *sizep)
{
struct dwarf2_per_objfile *data
- = objfile_data (objfile, dwarf2_objfile_data_key);
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
struct dwarf2_section_info *info;
/* We may see an objfile without any DWARF, in which case we just
static void
locate_dwz_sections (bfd *abfd, asection *sectp, void *arg)
{
- struct dwz_file *dwz_file = arg;
+ struct dwz_file *dwz_file = (struct dwz_file *) arg;
/* Note that we only support the standard ELF names, because .dwz
is ELF-only (at the time of writing). */
static hashval_t
hash_file_name_entry (const void *e)
{
- const struct quick_file_names *file_data = e;
+ const struct quick_file_names *file_data
+ = (const struct quick_file_names *) e;
return hash_stmt_list_entry (&file_data->hash);
}
static int
eq_file_name_entry (const void *a, const void *b)
{
- const struct quick_file_names *ea = a;
- const struct quick_file_names *eb = b;
+ const struct quick_file_names *ea = (const struct quick_file_names *) a;
+ const struct quick_file_names *eb = (const struct quick_file_names *) b;
return eq_stmt_list_entry (&ea->hash, &eb->hash);
}
static void
delete_file_name_entry (void *e)
{
- struct quick_file_names *file_data = e;
+ struct quick_file_names *file_data = (struct quick_file_names *) e;
int i;
for (i = 0; i < file_data->num_file_names; ++i)
static void
dw2_setup (struct objfile *objfile)
{
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile = ((struct dwarf2_per_objfile *)
+ objfile_data (objfile, dwarf2_objfile_data_key));
gdb_assert (dwarf2_per_objfile);
}
&find_entry, INSERT);
if (*slot != NULL)
{
- lh_cu->v.quick->file_names = *slot;
+ lh_cu->v.quick->file_names = (struct quick_file_names *) *slot;
return;
}
if (!objfile->psymtabs_addrmap)
return NULL;
- data = addrmap_find (objfile->psymtabs_addrmap, pc);
+ data = (struct dwarf2_per_cu_data *) addrmap_find (objfile->psymtabs_addrmap,
+ pc);
if (!data)
return NULL;
static hashval_t
hash_signatured_type (const void *item)
{
- const struct signatured_type *sig_type = item;
+ const struct signatured_type *sig_type
+ = (const struct signatured_type *) item;
/* This drops the top 32 bits of the signature, but is ok for a hash. */
return sig_type->signature;
static int
eq_signatured_type (const void *item_lhs, const void *item_rhs)
{
- const struct signatured_type *lhs = item_lhs;
- const struct signatured_type *rhs = item_rhs;
+ const struct signatured_type *lhs = (const struct signatured_type *) item_lhs;
+ const struct signatured_type *rhs = (const struct signatured_type *) item_rhs;
return lhs->signature == rhs->signature;
}
static int
add_signatured_type_cu_to_table (void **slot, void *datum)
{
- struct signatured_type *sigt = *slot;
- struct signatured_type ***datap = datum;
+ struct signatured_type *sigt = (struct signatured_type *) *slot;
+ struct signatured_type ***datap = (struct signatured_type ***) datum;
**datap = sigt;
++*datap;
if (dwo_file)
{
- const struct dwo_unit *dup_tu = *slot;
+ const struct dwo_unit *dup_tu
+ = (const struct dwo_unit *) *slot;
dup_offset = dup_tu->offset;
}
else
{
- const struct signatured_type *dup_tu = *slot;
+ const struct signatured_type *dup_tu
+ = (const struct signatured_type *) *slot;
dup_offset = dup_tu->per_cu.offset;
}
find_sig_entry.signature = sig;
slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
&find_sig_entry, INSERT);
- sig_entry = *slot;
+ sig_entry = (struct signatured_type *) *slot;
/* We can get here with the TU already read, *or* in the process of being
read. Don't reassign the global entry to point to this DWO if that's
if (dwo_file->tus == NULL)
return NULL;
find_dwo_entry.signature = sig;
- dwo_entry = htab_find (dwo_file->tus, &find_dwo_entry);
+ dwo_entry = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_entry);
if (dwo_entry == NULL)
return NULL;
find_sig_entry.signature = sig;
slot = htab_find_slot (dwarf2_per_objfile->signatured_types,
&find_sig_entry, INSERT);
- sig_entry = *slot;
+ sig_entry = (struct signatured_type *) *slot;
/* Have we already tried to read this TU?
Note: sig_entry can be NULL if the skeleton TU was removed (thus it
if (dwarf2_per_objfile->signatured_types == NULL)
return NULL;
find_entry.signature = sig;
- entry = htab_find (dwarf2_per_objfile->signatured_types, &find_entry);
+ entry = ((struct signatured_type *)
+ htab_find (dwarf2_per_objfile->signatured_types, &find_entry));
return entry;
}
}
static hashval_t
hash_type_unit_group (const void *item)
{
- const struct type_unit_group *tu_group = item;
+ const struct type_unit_group *tu_group
+ = (const struct type_unit_group *) item;
return hash_stmt_list_entry (&tu_group->hash);
}
static int
eq_type_unit_group (const void *item_lhs, const void *item_rhs)
{
- const struct type_unit_group *lhs = item_lhs;
- const struct type_unit_group *rhs = item_rhs;
+ const struct type_unit_group *lhs = (const struct type_unit_group *) item_lhs;
+ const struct type_unit_group *rhs = (const struct type_unit_group *) item_rhs;
return eq_stmt_list_entry (&lhs->hash, &rhs->hash);
}
&type_unit_group_for_lookup, INSERT);
if (*slot != NULL)
{
- tu_group = *slot;
+ tu_group = (struct type_unit_group *) *slot;
gdb_assert (tu_group != NULL);
}
else
struct partial_symtab *pst;
int has_pc_info;
const char *filename;
- struct process_psymtab_comp_unit_data *info = data;
+ struct process_psymtab_comp_unit_data *info
+ = (struct process_psymtab_comp_unit_data *) data;
if (comp_unit_die->tag == DW_TAG_partial_unit && !info->want_partial_unit)
return;
static int
sort_tu_by_abbrev_offset (const void *ap, const void *bp)
{
- const struct tu_abbrev_offset * const *a = ap;
- const struct tu_abbrev_offset * const *b = bp;
+ const struct tu_abbrev_offset * const *a
+ = (const struct tu_abbrev_offset * const*) ap;
+ const struct tu_abbrev_offset * const *b
+ = (const struct tu_abbrev_offset * const*) bp;
unsigned int aoff = (*a)->abbrev_offset.sect_off;
unsigned int boff = (*b)->abbrev_offset.sect_off;
process_skeletonless_type_unit (void **slot, void *info)
{
struct dwo_unit *dwo_unit = (struct dwo_unit *) *slot;
- struct objfile *objfile = info;
+ struct objfile *objfile = (struct objfile *) info;
struct signatured_type find_entry, *entry;
/* If this TU doesn't exist in the global table, add it and read it in. */
static void
psymtabs_addrmap_cleanup (void *o)
{
- struct objfile *objfile = o;
+ struct objfile *objfile = (struct objfile *) o;
objfile->psymtabs_addrmap = NULL;
}
}
/* Restore our global data. */
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
/* If this psymtab is constructed from a debug-only objfile, the
has_section_at_zero flag will not necessarily be correct. We
if (objfile->separate_debug_objfile_backlink)
{
struct dwarf2_per_objfile *dpo_backlink
- = objfile_data (objfile->separate_debug_objfile_backlink,
- dwarf2_objfile_data_key);
+ = ((struct dwarf2_per_objfile *)
+ objfile_data (objfile->separate_debug_objfile_backlink,
+ dwarf2_objfile_data_key));
dwarf2_per_objfile->has_section_at_zero
= dpo_backlink->has_section_at_zero;
psymtab_to_symtab_1 (pst->dependencies[i]);
}
- per_cu = pst->read_symtab_private;
+ per_cu = (struct dwarf2_per_cu_data *) pst->read_symtab_private;
if (per_cu == NULL)
{
static hashval_t
die_hash (const void *item)
{
- const struct die_info *die = item;
+ const struct die_info *die = (const struct die_info *) item;
return die->offset.sect_off;
}
static int
die_eq (const void *item_lhs, const void *item_rhs)
{
- const struct die_info *die_lhs = item_lhs;
- const struct die_info *die_rhs = item_rhs;
+ const struct die_info *die_lhs = (const struct die_info *) item_lhs;
+ const struct die_info *die_rhs = (const struct die_info *) item_rhs;
return die_lhs->offset.sect_off == die_rhs->offset.sect_off;
}
void *data)
{
struct dwarf2_cu *cu = reader->cu;
- enum language *language_ptr = data;
+ enum language *language_ptr = (enum language *) data;
gdb_assert (cu->die_hash == NULL);
cu->die_hash =
static void
reset_die_in_process (void *arg)
{
- struct die_info *die = arg;
+ struct die_info *die = (struct die_info *) arg;
die->in_process = 0;
}
static void
free_cu_line_header (void *arg)
{
- struct dwarf2_cu *cu = arg;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) arg;
free_line_header (cu->line_header);
cu->line_header = NULL;
if (die->tag == DW_TAG_partial_unit && slot != NULL)
{
gdb_assert (*slot != NULL);
- cu->line_header = *slot;
+ cu->line_header = (struct line_header *) *slot;
return;
}
}
static hashval_t
hash_dwo_file (const void *item)
{
- const struct dwo_file *dwo_file = item;
+ const struct dwo_file *dwo_file = (const struct dwo_file *) item;
hashval_t hash;
hash = htab_hash_string (dwo_file->dwo_name);
static int
eq_dwo_file (const void *item_lhs, const void *item_rhs)
{
- const struct dwo_file *lhs = item_lhs;
- const struct dwo_file *rhs = item_rhs;
+ const struct dwo_file *lhs = (const struct dwo_file *) item_lhs;
+ const struct dwo_file *rhs = (const struct dwo_file *) item_rhs;
if (strcmp (lhs->dwo_name, rhs->dwo_name) != 0)
return 0;
static hashval_t
hash_dwo_unit (const void *item)
{
- const struct dwo_unit *dwo_unit = item;
+ const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
/* This drops the top 32 bits of the id, but is ok for a hash. */
return dwo_unit->signature;
static int
eq_dwo_unit (const void *item_lhs, const void *item_rhs)
{
- const struct dwo_unit *lhs = item_lhs;
- const struct dwo_unit *rhs = item_rhs;
+ const struct dwo_unit *lhs = (const struct dwo_unit *) item_lhs;
+ const struct dwo_unit *rhs = (const struct dwo_unit *) item_rhs;
/* The signature is assumed to be unique within the DWO file.
So while object file CU dwo_id's always have the value zero,
struct objfile *objfile = dwarf2_per_objfile->objfile;
sect_offset offset = cu->per_cu->offset;
struct dwarf2_section_info *section = cu->per_cu->section;
- struct create_dwo_cu_data *data = datap;
+ struct create_dwo_cu_data *data = (struct create_dwo_cu_data *) datap;
struct dwo_file *dwo_file = data->dwo_file;
struct dwo_unit *dwo_unit = &data->dwo_unit;
struct attribute *attr;
fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
virtual_dwo_name);
}
- dwo_file = *dwo_file_slot;
+ dwo_file = (struct dwo_file *) *dwo_file_slot;
}
do_cleanups (cleanups);
fprintf_unfiltered (gdb_stdlog, "Using existing virtual DWO: %s\n",
virtual_dwo_name);
}
- dwo_file = *dwo_file_slot;
+ dwo_file = (struct dwo_file *) *dwo_file_slot;
}
do_cleanups (cleanups);
&find_dwo_cu, INSERT);
if (*slot != NULL)
- return *slot;
+ return (struct dwo_unit *) *slot;
/* Use a for loop so that we don't loop forever on bad debug info. */
for (i = 0; i < dwp_htab->nr_slots; ++i)
comp_dir, signature,
is_debug_types);
}
- return *slot;
+ return (struct dwo_unit *) *slot;
}
if (signature_in_table == 0)
return NULL;
static void
dwarf2_locate_dwo_sections (bfd *abfd, asection *sectp, void *dwo_sections_ptr)
{
- struct dwo_sections *dwo_sections = dwo_sections_ptr;
+ struct dwo_sections *dwo_sections = (struct dwo_sections *) dwo_sections_ptr;
const struct dwop_section_names *names = &dwop_section_names;
if (section_is_p (sectp->name, &names->abbrev_dwo))
dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
void *dwp_file_ptr)
{
- struct dwp_file *dwp_file = dwp_file_ptr;
+ struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
const struct dwop_section_names *names = &dwop_section_names;
unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
static void
dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
{
- struct dwp_file *dwp_file = dwp_file_ptr;
+ struct dwp_file *dwp_file = (struct dwp_file *) dwp_file_ptr;
const struct dwop_section_names *names = &dwop_section_names;
unsigned int elf_section_nr = elf_section_data (sectp)->this_idx;
static hashval_t
hash_dwp_loaded_cutus (const void *item)
{
- const struct dwo_unit *dwo_unit = item;
+ const struct dwo_unit *dwo_unit = (const struct dwo_unit *) item;
/* This drops the top 32 bits of the signature, but is ok for a hash. */
return dwo_unit->signature;
static int
eq_dwp_loaded_cutus (const void *a, const void *b)
{
- const struct dwo_unit *dua = a;
- const struct dwo_unit *dub = b;
+ const struct dwo_unit *dua = (const struct dwo_unit *) a;
+ const struct dwo_unit *dub = (const struct dwo_unit *) b;
return dua->signature == dub->signature;
}
*dwo_file_slot = open_and_init_dwo_file (this_unit, dwo_name, comp_dir);
}
/* NOTE: This will be NULL if unable to open the file. */
- dwo_file = *dwo_file_slot;
+ dwo_file = (struct dwo_file *) *dwo_file_slot;
if (dwo_file != NULL)
{
memset (&find_dwo_cutu, 0, sizeof (find_dwo_cutu));
find_dwo_cutu.signature = signature;
- dwo_cutu = htab_find (dwo_file->tus, &find_dwo_cutu);
+ dwo_cutu
+ = (struct dwo_unit *) htab_find (dwo_file->tus, &find_dwo_cutu);
}
else if (!is_debug_types && dwo_file->cu)
{
static void
abbrev_table_free_cleanup (void *table_ptr)
{
- struct abbrev_table **abbrev_table_ptr = table_ptr;
+ struct abbrev_table **abbrev_table_ptr = (struct abbrev_table **) table_ptr;
if (*abbrev_table_ptr != NULL)
abbrev_table_free (*abbrev_table_ptr);
static void
dwarf2_free_abbrev_table (void *ptr_to_cu)
{
- struct dwarf2_cu *cu = ptr_to_cu;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) ptr_to_cu;
if (cu->abbrev_table != NULL)
abbrev_table_free (cu->abbrev_table);
struct partial_die_info part_die;
part_die.offset = offset;
- lookup_die = htab_find_with_hash (cu->partial_dies, &part_die,
- offset.sect_off);
+ lookup_die = ((struct partial_die_info *)
+ htab_find_with_hash (cu->partial_dies, &part_die,
+ offset.sect_off));
return lookup_die;
}
static void
free_line_header_voidp (void *arg)
{
- struct line_header *lh = arg;
+ struct line_header *lh = (struct line_header *) arg;
free_line_header (lh);
}
*ref_cu = target_cu;
temp_die.offset = offset;
- return htab_find_with_hash (target_cu->die_hash, &temp_die, offset.sect_off);
+ return (struct die_info *) htab_find_with_hash (target_cu->die_hash,
+ &temp_die, offset.sect_off);
}
/* Follow reference attribute ATTR of SRC_DIE.
gdb_assert (sig_cu != NULL);
gdb_assert (sig_type->type_offset_in_section.sect_off != 0);
temp_die.offset = sig_type->type_offset_in_section;
- die = htab_find_with_hash (sig_cu->die_hash, &temp_die,
- temp_die.offset.sect_off);
+ die = (struct die_info *) htab_find_with_hash (sig_cu->die_hash, &temp_die,
+ temp_die.offset.sect_off);
if (die)
{
/* For .gdb_index version 7 keep track of included TUs.
static void
free_heap_comp_unit (void *data)
{
- struct dwarf2_cu *cu = data;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) data;
gdb_assert (cu->per_cu != NULL);
cu->per_cu->cu = NULL;
static void
free_stack_comp_unit (void *data)
{
- struct dwarf2_cu *cu = data;
+ struct dwarf2_cu *cu = (struct dwarf2_cu *) data;
gdb_assert (cu->per_cu != NULL);
cu->per_cu->cu = NULL;
void
dwarf2_free_objfile (struct objfile *objfile)
{
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
if (dwarf2_per_objfile == NULL)
return;
static hashval_t
per_cu_offset_and_type_hash (const void *item)
{
- const struct dwarf2_per_cu_offset_and_type *ofs = item;
+ const struct dwarf2_per_cu_offset_and_type *ofs
+ = (const struct dwarf2_per_cu_offset_and_type *) item;
return (uintptr_t) ofs->per_cu + ofs->offset.sect_off;
}
static int
per_cu_offset_and_type_eq (const void *item_lhs, const void *item_rhs)
{
- const struct dwarf2_per_cu_offset_and_type *ofs_lhs = item_lhs;
- const struct dwarf2_per_cu_offset_and_type *ofs_rhs = item_rhs;
+ const struct dwarf2_per_cu_offset_and_type *ofs_lhs
+ = (const struct dwarf2_per_cu_offset_and_type *) item_lhs;
+ const struct dwarf2_per_cu_offset_and_type *ofs_rhs
+ = (const struct dwarf2_per_cu_offset_and_type *) item_rhs;
return (ofs_lhs->per_cu == ofs_rhs->per_cu
&& ofs_lhs->offset.sect_off == ofs_rhs->offset.sect_off);
ofs.per_cu = per_cu;
ofs.offset = offset;
- slot = htab_find (dwarf2_per_objfile->die_type_hash, &ofs);
+ slot = ((struct dwarf2_per_cu_offset_and_type *)
+ htab_find (dwarf2_per_objfile->die_type_hash, &ofs));
if (slot)
return slot->type;
else
static hashval_t
partial_die_hash (const void *item)
{
- const struct partial_die_info *part_die = item;
+ const struct partial_die_info *part_die
+ = (const struct partial_die_info *) item;
return part_die->offset.sect_off;
}
static int
partial_die_eq (const void *item_lhs, const void *item_rhs)
{
- const struct partial_die_info *part_die_lhs = item_lhs;
- const struct partial_die_info *part_die_rhs = item_rhs;
+ const struct partial_die_info *part_die_lhs
+ = (const struct partial_die_info *) item_lhs;
+ const struct partial_die_info *part_die_rhs
+ = (const struct partial_die_info *) item_rhs;
return part_die_lhs->offset.sect_off == part_die_rhs->offset.sect_off;
}
static void
dwarf2_per_objfile_free (struct objfile *objfile, void *d)
{
- struct dwarf2_per_objfile *data = d;
+ struct dwarf2_per_objfile *data = (struct dwarf2_per_objfile *) d;
int ix;
/* Make sure we don't accidentally use dwarf2_per_objfile while
static hashval_t
hash_strtab_entry (const void *e)
{
- const struct strtab_entry *entry = e;
+ const struct strtab_entry *entry = (const struct strtab_entry *) e;
return mapped_index_string_hash (INT_MAX, entry->str);
}
static int
eq_strtab_entry (const void *a, const void *b)
{
- const struct strtab_entry *ea = a;
- const struct strtab_entry *eb = b;
+ const struct strtab_entry *ea = (const struct strtab_entry *) a;
+ const struct strtab_entry *eb = (const struct strtab_entry *) b;
return !strcmp (ea->str, eb->str);
}
entry.str = str;
slot = htab_find_slot (table, &entry, INSERT);
if (*slot)
- result = *slot;
+ result = (struct strtab_entry *) *slot;
else
{
result = XNEW (struct strtab_entry);
static hashval_t
hash_symtab_entry (const void *e)
{
- const struct symtab_index_entry *entry = e;
+ const struct symtab_index_entry *entry
+ = (const struct symtab_index_entry *) e;
return iterative_hash (VEC_address (offset_type, entry->cu_indices),
sizeof (offset_type) * VEC_length (offset_type,
entry->cu_indices),
static int
eq_symtab_entry (const void *a, const void *b)
{
- const struct symtab_index_entry *ea = a;
- const struct symtab_index_entry *eb = b;
+ const struct symtab_index_entry *ea = (const struct symtab_index_entry *) a;
+ const struct symtab_index_entry *eb = (const struct symtab_index_entry *) b;
int len = VEC_length (offset_type, ea->cu_indices);
if (len != VEC_length (offset_type, eb->cu_indices))
return 0;
static void
delete_symtab_entry (void *p)
{
- struct symtab_index_entry *entry = p;
+ struct symtab_index_entry *entry = (struct symtab_index_entry *) p;
VEC_free (offset_type, entry->cu_indices);
xfree (entry);
}
static void
cleanup_mapped_symtab (void *p)
{
- struct mapped_symtab *symtab = p;
+ struct mapped_symtab *symtab = (struct mapped_symtab *) p;
/* The contents of the array are freed when the other hash table is
destroyed. */
xfree (symtab->data);
}
else
{
- struct symtab_index_entry *old_entry = *slot;
+ struct symtab_index_entry *old_entry
+ = (struct symtab_index_entry *) *slot;
entry->index_offset = old_entry->index_offset;
entry = old_entry;
}
static hashval_t
hash_psymtab_cu_index (const void *item)
{
- const struct psymtab_cu_index_map *map = item;
+ const struct psymtab_cu_index_map *map
+ = (const struct psymtab_cu_index_map *) item;
return htab_hash_pointer (map->psymtab);
}
static int
eq_psymtab_cu_index (const void *item_lhs, const void *item_rhs)
{
- const struct psymtab_cu_index_map *lhs = item_lhs;
- const struct psymtab_cu_index_map *rhs = item_rhs;
+ const struct psymtab_cu_index_map *lhs
+ = (const struct psymtab_cu_index_map *) item_lhs;
+ const struct psymtab_cu_index_map *rhs
+ = (const struct psymtab_cu_index_map *) item_rhs;
return lhs->psymtab == rhs->psymtab;
}
static int
add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
{
- struct addrmap_index_data *data = datap;
- struct partial_symtab *pst = obj;
+ struct addrmap_index_data *data = (struct addrmap_index_data *) datap;
+ struct partial_symtab *pst = (struct partial_symtab *) obj;
if (data->previous_valid)
add_address_entry (data->objfile, data->addr_obstack,
{
struct psymtab_cu_index_map find_map, *map;
find_map.psymtab = pst;
- map = htab_find (data->cu_index_htab, &find_map);
+ map = ((struct psymtab_cu_index_map *)
+ htab_find (data->cu_index_htab, &find_map));
gdb_assert (map != NULL);
data->previous_cu_index = map->cu_index;
data->previous_valid = 1;
static void
unlink_if_set (void *p)
{
- char **filename = p;
+ char **filename = (char **) p;
if (*filename)
unlink (*filename);
}
static int
write_one_signatured_type (void **slot, void *d)
{
- struct signatured_type_index_data *info = d;
+ struct signatured_type_index_data *info
+ = (struct signatured_type_index_data *) d;
struct signatured_type *entry = (struct signatured_type *) *slot;
struct partial_symtab *psymtab = entry->per_cu.v.psymtab;
gdb_byte val[8];
if (stat (objfile_name (objfile), &st) < 0)
continue;
- dwarf2_per_objfile = objfile_data (objfile, dwarf2_objfile_data_key);
+ dwarf2_per_objfile
+ = (struct dwarf2_per_objfile *) objfile_data (objfile,
+ dwarf2_objfile_data_key);
if (dwarf2_per_objfile)
{
continue;
if (sym->flags & BSF_FILE)
{
- filesymname = bcache (sym->name, strlen (sym->name) + 1,
- objfile->per_bfd->filename_cache);
+ filesymname
+ = (const char *) bcache (sym->name, strlen (sym->name) + 1,
+ objfile->per_bfd->filename_cache);
}
else if (sym->flags & BSF_SECTION_SYM)
continue;
static hashval_t
elf_gnu_ifunc_cache_hash (const void *a_voidp)
{
- const struct elf_gnu_ifunc_cache *a = a_voidp;
+ const struct elf_gnu_ifunc_cache *a
+ = (const struct elf_gnu_ifunc_cache *) a_voidp;
return htab_hash_string (a->name);
}
static int
elf_gnu_ifunc_cache_eq (const void *a_voidp, const void *b_voidp)
{
- const struct elf_gnu_ifunc_cache *a = a_voidp;
- const struct elf_gnu_ifunc_cache *b = b_voidp;
+ const struct elf_gnu_ifunc_cache *a
+ = (const struct elf_gnu_ifunc_cache *) a_voidp;
+ const struct elf_gnu_ifunc_cache *b
+ = (const struct elf_gnu_ifunc_cache *) b_voidp;
return strcmp (a->name, b->name) == 0;
}
if (strcmp (bfd_get_section_name (objfile->obfd, sect), ".plt") == 0)
return 0;
- htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
+ htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
if (htab == NULL)
{
htab = htab_create_alloc_ex (1, elf_gnu_ifunc_cache_hash,
slot = htab_find_slot (htab, entry_p, INSERT);
if (*slot != NULL)
{
- struct elf_gnu_ifunc_cache *entry_found_p = *slot;
+ struct elf_gnu_ifunc_cache *entry_found_p
+ = (struct elf_gnu_ifunc_cache *) *slot;
struct gdbarch *gdbarch = get_objfile_arch (objfile);
if (entry_found_p->addr != addr)
struct elf_gnu_ifunc_cache *entry_p;
void **slot;
- htab = objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
+ htab = (htab_t) objfile_data (objfile, elf_objfile_gnu_ifunc_cache_data);
if (htab == NULL)
continue;
slot = htab_find_slot (htab, entry_p, NO_INSERT);
if (slot == NULL)
continue;
- entry_p = *slot;
+ entry_p = (struct elf_gnu_ifunc_cache *) *slot;
gdb_assert (entry_p != NULL);
if (addr_p)
VEC (probe_p) *probes_per_bfd;
/* Have we parsed this objfile's probes already? */
- probes_per_bfd = bfd_data (objfile->obfd, probe_key);
+ probes_per_bfd = (VEC (probe_p) *) bfd_data (objfile->obfd, probe_key);
if (!probes_per_bfd)
{
probe_key_free (bfd *abfd, void *d)
{
int ix;
- VEC (probe_p) *probes = d;
+ VEC (probe_p) *probes = (VEC (probe_p) *) d;
struct probe *probe;
for (ix = 0; VEC_iterate (probe_p, probes, ix, probe); ix++)
const struct builtin_f_type *
builtin_f_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, f_type_data);
+ return (const struct builtin_f_type *) gdbarch_data (gdbarch, f_type_data);
}
void
frame_base_append_sniffer (struct gdbarch *gdbarch,
frame_base_sniffer_ftype *sniffer)
{
- struct frame_base_table *table = gdbarch_data (gdbarch, frame_base_data);
+ struct frame_base_table *table
+ = (struct frame_base_table *) gdbarch_data (gdbarch, frame_base_data);
(*table->tail)
= GDBARCH_OBSTACK_ZALLOC (gdbarch, struct frame_base_table_entry);
frame_base_set_default (struct gdbarch *gdbarch,
const struct frame_base *default_base)
{
- struct frame_base_table *table = gdbarch_data (gdbarch, frame_base_data);
+ struct frame_base_table *table
+ = (struct frame_base_table *) gdbarch_data (gdbarch, frame_base_data);
table->default_base = default_base;
}
frame_base_find_by_frame (struct frame_info *this_frame)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- struct frame_base_table *table = gdbarch_data (gdbarch, frame_base_data);
+ struct frame_base_table *table
+ = (struct frame_base_table *) gdbarch_data (gdbarch, frame_base_data);
struct frame_base_table_entry *entry;
for (entry = table->head; entry != NULL; entry = entry->next)
frame_unwind_prepend_unwinder (struct gdbarch *gdbarch,
const struct frame_unwind *unwinder)
{
- struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data);
+ struct frame_unwind_table *table
+ = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
struct frame_unwind_table_entry *entry;
/* Insert the new entry at the start of the list. */
frame_unwind_append_unwinder (struct gdbarch *gdbarch,
const struct frame_unwind *unwinder)
{
- struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data);
+ struct frame_unwind_table *table
+ = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
struct frame_unwind_table_entry **ip;
/* Find the end of the list and insert the new entry there. */
frame_unwind_find_by_frame (struct frame_info *this_frame, void **this_cache)
{
struct gdbarch *gdbarch = get_frame_arch (this_frame);
- struct frame_unwind_table *table = gdbarch_data (gdbarch, frame_unwind_data);
+ struct frame_unwind_table *table
+ = (struct frame_unwind_table *) gdbarch_data (gdbarch, frame_unwind_data);
struct frame_unwind_table_entry *entry;
const struct frame_unwind *unwinder_from_target;
static hashval_t
frame_addr_hash (const void *ap)
{
- const struct frame_info *frame = ap;
+ const struct frame_info *frame = (const struct frame_info *) ap;
const struct frame_id f_id = frame->this_id.value;
hashval_t hash = 0;
static int
frame_addr_hash_eq (const void *a, const void *b)
{
- const struct frame_info *f_entry = a;
- const struct frame_info *f_element = b;
+ const struct frame_info *f_entry = (const struct frame_info *) a;
+ const struct frame_info *f_element = (const struct frame_info *) b;
return frame_id_eq (f_entry->this_id.value,
f_element->this_id.value);
struct frame_info *frame;
dummy.this_id.value = id;
- frame = htab_find (frame_stash, &dummy);
+ frame = (struct frame_info *) htab_find (frame_stash, &dummy);
return frame;
}
static enum register_status
do_frame_register_read (void *src, int regnum, gdb_byte *buf)
{
- if (!deprecated_frame_register_read (src, regnum, buf))
+ if (!deprecated_frame_register_read ((struct frame_info *) src, regnum, buf))
return REG_UNAVAILABLE;
else
return REG_VALID;
static int
unwind_to_current_frame (struct ui_out *ui_out, void *args)
{
- struct frame_info *frame = get_prev_frame (args);
+ struct frame_info *frame = get_prev_frame ((struct frame_info *) args);
/* A sentinel frame can fail to unwind, e.g., because its PC value
lands in somewhere like start. */
static void
frame_cleanup_after_sniffer (void *arg)
{
- struct frame_info *frame = arg;
+ struct frame_info *frame = (struct frame_info *) arg;
/* The sniffer should not allocate a prologue cache if it did not
match this frame. */
struct frame_id this_id;
if (*this_cache)
- return *this_cache;
+ return (struct trad_frame_cache *) *this_cache;
cache = trad_frame_cache_zalloc (this_frame);
struct frv_unwind_cache *info;
if ((*this_prologue_cache))
- return (*this_prologue_cache);
+ return (struct frv_unwind_cache *) (*this_prologue_cache);
info = FRAME_OBSTACK_ZALLOC (struct frv_unwind_cache);
(*this_prologue_cache) = info;
int i;
if (*this_cache)
- return *this_cache;
+ return (struct ft32_frame_cache *) *this_cache;
cache = ft32_alloc_frame_cache ();
*this_cache = cache;
static void
do_bfd_delete_cleanup (void *arg)
{
- bfd *obfd = arg;
+ bfd *obfd = (bfd *) arg;
const char *filename = obfd->filename;
- gdb_bfd_unref (arg);
+ gdb_bfd_unref ((bfd *) arg);
unlink (filename);
}
gcore_create_callback (CORE_ADDR vaddr, unsigned long size, int read,
int write, int exec, int modified, void *data)
{
- bfd *obfd = data;
+ bfd *obfd = (bfd *) data;
asection *osec;
flagword flags = SEC_ALLOC | SEC_HAS_CONTENTS | SEC_LOAD;
static hashval_t
hash_bfd (const void *b)
{
- const bfd *abfd = b;
+ const bfd *abfd = (const struct bfd *) b;
/* It is simplest to just hash the filename. */
return htab_hash_string (bfd_get_filename (abfd));
static int
eq_bfd (const void *a, const void *b)
{
- const bfd *abfd = a;
- const struct gdb_bfd_cache_search *s = b;
- struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
+ const bfd *abfd = (const struct bfd *) a;
+ const struct gdb_bfd_cache_search *s
+ = (const struct gdb_bfd_cache_search *) b;
+ struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
return (gdata->mtime == s->mtime
&& gdata->size == s->size
/* Note that we cannot use htab_find_slot_with_hash here, because
opening the BFD may fail; and this would violate hashtab
invariants. */
- abfd = htab_find_with_hash (gdb_bfd_cache, &search, hash);
+ abfd = (struct bfd *) htab_find_with_hash (gdb_bfd_cache, &search, hash);
if (bfd_sharing && abfd != NULL)
{
if (debug_bfd_cache)
static void
free_one_bfd_section (bfd *abfd, asection *sectp, void *ignore)
{
- struct gdb_bfd_section_data *sect = bfd_get_section_userdata (abfd, sectp);
+ struct gdb_bfd_section_data *sect
+ = (struct gdb_bfd_section_data *) bfd_get_section_userdata (abfd, sectp);
if (sect != NULL && sect->data != NULL)
{
if (abfd == NULL)
return;
- gdata = bfd_usrdata (abfd);
+ gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
if (debug_bfd_cache)
fprintf_unfiltered (gdb_stdlog,
if (abfd == NULL)
return;
- gdata = bfd_usrdata (abfd);
+ gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
gdb_assert (gdata->refc >= 1);
gdata->refc -= 1;
{
struct gdb_bfd_section_data *result;
- result = bfd_get_section_userdata (section->owner, section);
+ result = ((struct gdb_bfd_section_data *)
+ bfd_get_section_userdata (section->owner, section));
if (result == NULL)
{
done:
gdb_assert (descriptor->data != NULL);
*size = descriptor->size;
- return descriptor->data;
+ return (const gdb_byte *) descriptor->data;
}
/* Return 32-bit CRC for ABFD. If successful store it to *FILE_CRC_RETURN and
int
gdb_bfd_crc (struct bfd *abfd, unsigned long *crc_out)
{
- struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
+ struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
if (!gdata->crc_computed)
gdata->crc_computed = get_file_crc (abfd, &gdata->crc);
/* No need to stash the filename here, because we also keep a
reference on the parent archive. */
- gdata = bfd_usrdata (child);
+ gdata = (struct gdb_bfd_data *) bfd_usrdata (child);
if (gdata->archive_bfd == NULL)
{
gdata->archive_bfd = parent;
struct gdb_bfd_data *gdata;
gdb_bfd_ref (includee);
- gdata = bfd_usrdata (includer);
+ gdata = (struct gdb_bfd_data *) bfd_usrdata (includer);
VEC_safe_push (bfdp, gdata->included_bfds, includee);
}
int
gdb_bfd_requires_relocations (bfd *abfd)
{
- struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
+ struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
if (gdata->relocation_computed == 0)
{
static int
print_one_bfd (void **slot, void *data)
{
- bfd *abfd = *slot;
- struct gdb_bfd_data *gdata = bfd_usrdata (abfd);
- struct ui_out *uiout = data;
+ bfd *abfd = (struct bfd *) *slot;
+ struct gdb_bfd_data *gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
+ struct ui_out *uiout = (struct ui_out *) data;
struct cleanup *inner;
inner = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2015-09-25 Simon Marchi <simon.marchi@ericsson.com>
+ * dll.c (match_dll): Add cast(s).
+ (unloaded_dll): Likewise.
+ * linux-low.c (second_thread_of_pid_p): Likewise.
+ (delete_lwp_callback): Likewise.
+ (count_events_callback): Likewise.
+ (select_event_lwp_callback): Likewise.
+ (linux_set_resume_request): Likewise.
+ * server.c (accumulate_file_name_length): Likewise.
+ (emit_dll_description): Likewise.
+ (handle_qxfer_threads_worker): Likewise.
+ (visit_actioned_threads): Likewise.
+ * thread-db.c (any_thread_of): Likewise.
+ * tracepoint.c (same_process_p): Likewise.
+ (match_blocktype): Likewise.
+ (build_traceframe_info_xml): Likewise.
+
+2015-09-25 Simon Marchi <simon.marchi@ericsson.com>
+
* ax.c (gdb_parse_agent_expr): Add cast to allocation result
assignment.
(gdb_unparse_agent_expr): Likewise.
static int
match_dll (struct inferior_list_entry *inf, void *arg)
{
- struct dll_info *iter = (void *) inf;
- struct dll_info *key = arg;
+ struct dll_info *iter = (struct dll_info *) inf;
+ struct dll_info *key = (struct dll_info *) arg;
if (key->base_addr != UNSPECIFIED_CORE_ADDR
&& iter->base_addr == key->base_addr)
key_dll.name = (char *) name;
key_dll.base_addr = base_addr;
- dll = (void *) find_inferior (&all_dlls, match_dll, &key_dll);
+ dll = (struct dll_info *) find_inferior (&all_dlls, match_dll, &key_dll);
if (dll == NULL)
/* For some inferiors we might get unloaded_dll events without having
static int
second_thread_of_pid_p (struct inferior_list_entry *entry, void *args)
{
- struct counter *counter = args;
+ struct counter *counter = (struct counter *) args;
if (ptid_get_pid (entry->id) == counter->pid)
{
{
struct thread_info *thread = (struct thread_info *) entry;
struct lwp_info *lwp = get_thread_lwp (thread);
- struct process_info *process = proc;
+ struct process_info *process = (struct process_info *) proc;
if (pid_of (thread) == pid_of (process))
delete_lwp (lwp);
{
struct thread_info *thread = (struct thread_info *) entry;
struct lwp_info *lp = get_thread_lwp (thread);
- int *count = data;
+ int *count = (int *) data;
gdb_assert (count != NULL);
{
struct thread_info *thread = (struct thread_info *) entry;
struct lwp_info *lp = get_thread_lwp (thread);
- int *selector = data;
+ int *selector = (int *) data;
gdb_assert (selector != NULL);
int ndx;
struct thread_resume_array *r;
- r = arg;
+ r = (struct thread_resume_array *) arg;
for (ndx = 0; ndx < r->n; ndx++)
{
accumulate_file_name_length (struct inferior_list_entry *inf, void *arg)
{
struct dll_info *dll = (struct dll_info *) inf;
- unsigned int *total_len = arg;
+ unsigned int *total_len = (unsigned int *) arg;
/* Over-estimate the necessary memory. Assume that every character
in the library name must be escaped. */
emit_dll_description (struct inferior_list_entry *inf, void *arg)
{
struct dll_info *dll = (struct dll_info *) inf;
- char **p_ptr = arg;
+ char **p_ptr = (char **) arg;
char *p = *p_ptr;
char *name;
handle_qxfer_threads_worker (struct inferior_list_entry *inf, void *arg)
{
struct thread_info *thread = (struct thread_info *) inf;
- struct buffer *buffer = arg;
+ struct buffer *buffer = (struct buffer *) arg;
ptid_t ptid = thread_to_gdb_id (thread);
char ptid_s[100];
int core = target_core_of_thread (ptid);
static int
visit_actioned_threads (struct inferior_list_entry *entry, void *datap)
{
- struct visit_actioned_threads_data *data = datap;
+ struct visit_actioned_threads_data *data
+ = (struct visit_actioned_threads_data *) datap;
const struct thread_resume *actions = data->actions;
size_t num_actions = data->num_actions;
visit_actioned_threads_callback_ftype *callback = data->callback;
static int
any_thread_of (struct inferior_list_entry *entry, void *args)
{
- int *pid_p = args;
+ int *pid_p = (int *) args;
if (ptid_get_pid (entry->id) == *pid_p)
return 1;
static int
same_process_p (struct inferior_list_entry *entry, void *data)
{
- int *pid = data;
+ int *pid = (int *) data;
return ptid_get_pid (entry->id) == *pid;
}
static int
match_blocktype (char blocktype, unsigned char *dataptr, void *data)
{
- char *wantedp = data;
+ char *wantedp = (char *) data;
if (*wantedp == blocktype)
return 1;
static int
build_traceframe_info_xml (char blocktype, unsigned char *dataptr, void *data)
{
- struct buffer *buffer = data;
+ struct buffer *buffer = (struct buffer *) data;
switch (blocktype)
{
static hashval_t
type_pair_hash (const void *item)
{
- const struct type_pair *pair = item;
+ const struct type_pair *pair = (const struct type_pair *) item;
return htab_hash_pointer (pair->old);
}
static int
type_pair_eq (const void *item_lhs, const void *item_rhs)
{
- const struct type_pair *lhs = item_lhs, *rhs = item_rhs;
+ const struct type_pair *lhs = (const struct type_pair *) item_lhs;
+ const struct type_pair *rhs = (const struct type_pair *) item_rhs;
return lhs->old == rhs->old;
}
const struct builtin_type *
builtin_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, gdbtypes_data);
+ return (const struct builtin_type *) gdbarch_data (gdbarch, gdbtypes_data);
}
static void *
{
struct gdbarch *gdbarch;
struct objfile_type *objfile_type
- = objfile_data (objfile, objfile_type_data);
+ = (struct objfile_type *) objfile_data (objfile, objfile_type_data);
if (objfile_type)
return objfile_type;
static struct type *
vtable_ptrdiff_type (struct gdbarch *gdbarch)
{
- struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
+ struct type *vtable_type
+ = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
/* The "offset_to_top" field has the appropriate (ptrdiff_t) type. */
return TYPE_FIELD_TYPE (vtable_type, vtable_field_offset_to_top);
static int
vtable_address_point_offset (struct gdbarch *gdbarch)
{
- struct type *vtable_type = gdbarch_data (gdbarch, vtable_type_gdbarch_data);
+ struct type *vtable_type
+ = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
return (TYPE_FIELD_BITPOS (vtable_type, vtable_field_virtual_functions)
/ TARGET_CHAR_BIT);
gnuv3_get_vtable (struct gdbarch *gdbarch,
struct type *container_type, CORE_ADDR container_addr)
{
- struct type *vtable_type = gdbarch_data (gdbarch,
- vtable_type_gdbarch_data);
+ struct type *vtable_type
+ = (struct type *) gdbarch_data (gdbarch, vtable_type_gdbarch_data);
struct type *vtable_pointer_type;
struct value *vtable_pointer;
CORE_ADDR vtable_address;
static hashval_t
hash_value_and_voffset (const void *p)
{
- const struct value_and_voffset *o = p;
+ const struct value_and_voffset *o = (const struct value_and_voffset *) p;
return value_address (o->value) + value_embedded_offset (o->value);
}
static int
eq_value_and_voffset (const void *a, const void *b)
{
- const struct value_and_voffset *ova = a;
- const struct value_and_voffset *ovb = b;
+ const struct value_and_voffset *ova = (const struct value_and_voffset *) a;
+ const struct value_and_voffset *ovb = (const struct value_and_voffset *) b;
return (value_address (ova->value) + value_embedded_offset (ova->value)
== value_address (ovb->value) + value_embedded_offset (ovb->value));
static int
compare_value_and_voffset (const void *a, const void *b)
{
- const struct value_and_voffset * const *ova = a;
+ const struct value_and_voffset * const *ova
+ = (const struct value_and_voffset * const *) a;
CORE_ADDR addra = (value_address ((*ova)->value)
+ value_embedded_offset ((*ova)->value));
- const struct value_and_voffset * const *ovb = b;
+ const struct value_and_voffset * const *ovb
+ = (const struct value_and_voffset * const *) b;
CORE_ADDR addrb = (value_address ((*ovb)->value)
+ value_embedded_offset ((*ovb)->value));
search_vo.value = value;
slot = htab_find_slot (offset_hash, &search_vo, INSERT);
if (*slot)
- current_vo = *slot;
+ current_vo = (struct value_and_voffset *) *slot;
else
{
current_vo = XNEW (struct value_and_voffset);
typeinfo = lookup_symbol ("std::type_info", NULL, STRUCT_DOMAIN,
NULL).symbol;
if (typeinfo == NULL)
- typeinfo_type = gdbarch_data (gdbarch, std_type_info_gdbarch_data);
+ typeinfo_type
+ = (struct type *) gdbarch_data (gdbarch, std_type_info_gdbarch_data);
else
typeinfo_type = SYMBOL_TYPE (typeinfo);
const struct builtin_go_type *
builtin_go_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, go_type_data);
+ return (const struct builtin_go_type *) gdbarch_data (gdbarch, go_type_data);
}
extern initialize_file_ftype _initialize_go_language;
static hashval_t
bkscm_hash_block_smob (const void *p)
{
- const block_smob *b_smob = p;
+ const block_smob *b_smob = (const block_smob *) p;
return htab_hash_pointer (b_smob->block);
}
static int
bkscm_eq_block_smob (const void *ap, const void *bp)
{
- const block_smob *a = ap;
- const block_smob *b = bp;
+ const block_smob *a = (const block_smob *) ap;
+ const block_smob *b = (const block_smob *) bp;
return (a->block == b->block
&& a->block != NULL);
static htab_t
bkscm_objfile_block_map (struct objfile *objfile)
{
- htab_t htab = objfile_data (objfile, bkscm_objfile_data_key);
+ htab_t htab = (htab_t) objfile_data (objfile, bkscm_objfile_data_key);
if (htab == NULL)
{
static void
bkscm_del_objfile_blocks (struct objfile *objfile, void *datum)
{
- htab_t htab = datum;
+ htab_t htab = (htab_t) datum;
if (htab != NULL)
{
static int
bpscm_build_bp_list (struct breakpoint *bp, void *arg)
{
- SCM *list = arg;
+ SCM *list = (SCM *) arg;
breakpoint_smob *bp_smob = bp->scm_bp_object;
/* Lazily create wrappers for breakpoints created outside Scheme. */
static void *
gdbscm_disasm_read_memory_worker (void *datap)
{
- struct gdbscm_disasm_read_data *data = datap;
+ struct gdbscm_disasm_read_data *data
+ = (struct gdbscm_disasm_read_data *) datap;
struct disassemble_info *dinfo = data->dinfo;
- struct gdbscm_disasm_data *disasm_data = dinfo->application_data;
+ struct gdbscm_disasm_data *disasm_data
+ = (struct gdbscm_disasm_data *) dinfo->application_data;
SCM seekto, newpos, port = disasm_data->port;
size_t bytes_read;
static void
gdbscm_disasm_print_address (bfd_vma addr, struct disassemble_info *info)
{
- struct gdbscm_disasm_data *data = info->application_data;
+ struct gdbscm_disasm_data *data
+ = (struct gdbscm_disasm_data *) info->application_data;
struct gdbarch *gdbarch = data->gdbarch;
- print_address (gdbarch, addr, info->stream);
+ print_address (gdbarch, addr, (struct ui_file *) info->stream);
}
/* Subroutine of gdbscm_arch_disassemble to simplify it.
static hashval_t
frscm_hash_frame_smob (const void *p)
{
- const frame_smob *f_smob = p;
+ const frame_smob *f_smob = (const frame_smob *) p;
const struct frame_id *fid = &f_smob->frame_id;
hashval_t hash = htab_hash_pointer (f_smob->inferior);
static int
frscm_eq_frame_smob (const void *ap, const void *bp)
{
- const frame_smob *a = ap;
- const frame_smob *b = bp;
+ const frame_smob *a = (const frame_smob *) ap;
+ const frame_smob *b = (const frame_smob *) bp;
return (frame_id_eq (a->frame_id, b->frame_id)
&& a->inferior == b->inferior
static htab_t
frscm_inferior_frame_map (struct inferior *inferior)
{
- htab_t htab = inferior_data (inferior, frscm_inferior_data_key);
+ htab_t htab = (htab_t) inferior_data (inferior, frscm_inferior_data_key);
if (htab == NULL)
{
static void
frscm_del_inferior_frames (struct inferior *inferior, void *datum)
{
- htab_t htab = datum;
+ htab_t htab = (htab_t) datum;
if (htab != NULL)
{
g_smob->prev = NULL;
if (objfile != NULL)
{
- g_smob->next = objfile_data (objfile, data_key);
+ g_smob->next = (chained_gdb_smob *) objfile_data (objfile, data_key);
if (g_smob->next)
g_smob->next->prev = g_smob;
set_objfile_data (objfile, data_key, g_smob);
static void
ofscm_handle_objfile_deleted (struct objfile *objfile, void *datum)
{
- objfile_smob *o_smob = datum;
+ objfile_smob *o_smob = (objfile_smob *) datum;
gdb_assert (o_smob->objfile == objfile);
{
objfile_smob *o_smob;
- o_smob = objfile_data (objfile, ofscm_objfile_data_key);
+ o_smob = (objfile_smob *) objfile_data (objfile, ofscm_objfile_data_key);
if (o_smob == NULL)
{
SCM o_scm = ofscm_make_objfile_smob ();
TRY
{
if (scm_is_eq (port, error_port_scm))
- fputsn_filtered (data, size, gdb_stderr);
+ fputsn_filtered ((const char *) data, size, gdb_stderr);
else
- fputsn_filtered (data, size, gdb_stdout);
+ fputsn_filtered ((const char *) data, size, gdb_stdout);
}
CATCH (except, RETURN_MASK_ALL)
{
static void
ioscm_file_port_delete (struct ui_file *file)
{
- ioscm_file_port *stream = ui_file_data (file);
+ ioscm_file_port *stream = (ioscm_file_port *) ui_file_data (file);
if (stream->magic != &file_port_magic)
internal_error (__FILE__, __LINE__,
static void
ioscm_file_port_rewind (struct ui_file *file)
{
- ioscm_file_port *stream = ui_file_data (file);
+ ioscm_file_port *stream = (ioscm_file_port *) ui_file_data (file);
if (stream->magic != &file_port_magic)
internal_error (__FILE__, __LINE__,
ui_file_put_method_ftype *write,
void *dest)
{
- ioscm_file_port *stream = ui_file_data (file);
+ ioscm_file_port *stream = (ioscm_file_port *) ui_file_data (file);
if (stream->magic != &file_port_magic)
internal_error (__FILE__, __LINE__,
const char *buffer,
long length_buffer)
{
- ioscm_file_port *stream = ui_file_data (file);
+ ioscm_file_port *stream = (ioscm_file_port *) ui_file_data (file);
if (stream->magic != &file_port_magic)
internal_error (__FILE__, __LINE__,
static void
psscm_handle_pspace_deleted (struct program_space *pspace, void *datum)
{
- pspace_smob *p_smob = datum;
+ pspace_smob *p_smob = (pspace_smob *) datum;
gdb_assert (p_smob->pspace == pspace);
{
pspace_smob *p_smob;
- p_smob = program_space_data (pspace, psscm_pspace_data_key);
+ p_smob = (pspace_smob *) program_space_data (pspace, psscm_pspace_data_key);
if (p_smob == NULL)
{
SCM p_scm = psscm_make_pspace_smob ();
static SCM
scscm_recording_pre_unwind_handler (void *datap, SCM key, SCM args)
{
- struct with_catch_data *data = datap;
+ struct with_catch_data *data = (struct with_catch_data *) datap;
excp_matcher_func *matcher = data->excp_matcher;
if (matcher != NULL && matcher (key))
static SCM
scscm_recording_unwind_handler (void *datap, SCM key, SCM args)
{
- struct with_catch_data *data = datap;
+ struct with_catch_data *data = (struct with_catch_data *) datap;
/* We need to record the stack in the exception since we're about to
throw and lose the location that got the exception. We do this by
static void *
gdbscm_with_catch (void *data)
{
- struct with_catch_data *d = data;
+ struct with_catch_data *d = (struct with_catch_data *) data;
d->catch_result
= scm_c_catch (SCM_BOOL_T,
static SCM
scscm_call_0_body (void *argsp)
{
- SCM *args = argsp;
+ SCM *args = (SCM *) argsp;
return scm_call_0 (args[0]);
}
static SCM
scscm_call_1_body (void *argsp)
{
- SCM *args = argsp;
+ SCM *args = (SCM *) argsp;
return scm_call_1 (args[0], args[1]);
}
static SCM
scscm_call_2_body (void *argsp)
{
- SCM *args = argsp;
+ SCM *args = (SCM *) argsp;
return scm_call_2 (args[0], args[1], args[2]);
}
static SCM
scscm_call_3_body (void *argsp)
{
- SCM *args = argsp;
+ SCM *args = (SCM *) argsp;
return scm_call_3 (args[0], args[1], args[2], args[3]);
}
static SCM
scscm_call_4_body (void *argsp)
{
- SCM *args = argsp;
+ SCM *args = (SCM *) argsp;
return scm_call_4 (args[0], args[1], args[2], args[3], args[4]);
}
static SCM
scscm_apply_1_body (void *argsp)
{
- SCM *args = argsp;
+ SCM *args = (SCM *) argsp;
return scm_apply_1 (args[0], args[1], args[2]);
}
static void *
scscm_eval_scheme_string (void *datap)
{
- struct eval_scheme_string_data *data = datap;
+ struct eval_scheme_string_data *data
+ = (struct eval_scheme_string_data *) datap;
SCM result = scm_c_eval_string (data->string);
if (data->display_result && !scm_is_eq (result, SCM_UNSPECIFIED))
result = gdbscm_with_guile (scscm_eval_scheme_string, (void *) &data);
if (result != NULL)
- return xstrdup (result);
+ return xstrdup ((char *) result);
return NULL;
}
\f
static void *
scscm_source_scheme_script (void *data)
{
- const char *filename = data;
+ const char *filename = (const char *) data;
/* The Guile docs don't specify what the result is.
Maybe it's SCM_UNSPECIFIED, but the docs should specify that. :-) */
xfree (abs_filename);
if (result != NULL)
- return xstrdup (result);
+ return xstrdup ((char *) result);
return NULL;
}
\f
static SCM
gdbscm_call_scm_to_stringn (void *datap)
{
- struct scm_to_stringn_data *data = datap;
+ struct scm_to_stringn_data *data = (struct scm_to_stringn_data *) datap;
data->result = scm_to_stringn (data->string, data->lenp, data->charset,
data->conversion_kind);
static SCM
gdbscm_call_scm_from_stringn (void *datap)
{
- struct scm_from_stringn_data *data = datap;
+ struct scm_from_stringn_data *data = (struct scm_from_stringn_data *) datap;
data->result = scm_from_stringn (data->string, data->len, data->charset,
data->conversion_kind);
static hashval_t
syscm_hash_symbol_smob (const void *p)
{
- const symbol_smob *s_smob = p;
+ const symbol_smob *s_smob = (const symbol_smob *) p;
return htab_hash_pointer (s_smob->symbol);
}
static int
syscm_eq_symbol_smob (const void *ap, const void *bp)
{
- const symbol_smob *a = ap;
- const symbol_smob *b = bp;
+ const symbol_smob *a = (const symbol_smob *) ap;
+ const symbol_smob *b = (const symbol_smob *) bp;
return (a->symbol == b->symbol
&& a->symbol != NULL);
{
struct objfile *objfile = symbol_objfile (symbol);
- htab = objfile_data (objfile, syscm_objfile_data_key);
+ htab = (htab_t) objfile_data (objfile, syscm_objfile_data_key);
if (htab == NULL)
{
htab = gdbscm_create_eqable_gsmob_ptr_map (syscm_hash_symbol_smob,
else
{
struct gdbarch *gdbarch = symbol_arch (symbol);
- struct syscm_gdbarch_data *data = gdbarch_data (gdbarch,
+ struct syscm_gdbarch_data *data
+ = (struct syscm_gdbarch_data *) gdbarch_data (gdbarch,
syscm_gdbarch_data_key);
htab = data->htab;
static void
syscm_del_objfile_symbols (struct objfile *objfile, void *datum)
{
- htab_t htab = datum;
+ htab_t htab = (htab_t) datum;
if (htab != NULL)
{
static hashval_t
stscm_hash_symtab_smob (const void *p)
{
- const symtab_smob *st_smob = p;
+ const symtab_smob *st_smob = (const symtab_smob *) p;
return htab_hash_pointer (st_smob->symtab);
}
static int
stscm_eq_symtab_smob (const void *ap, const void *bp)
{
- const symtab_smob *a = ap;
- const symtab_smob *b = bp;
+ const symtab_smob *a = (const symtab_smob *) ap;
+ const symtab_smob *b = (const symtab_smob *) bp;
return (a->symtab == b->symtab
&& a->symtab != NULL);
stscm_objfile_symtab_map (struct symtab *symtab)
{
struct objfile *objfile = SYMTAB_OBJFILE (symtab);
- htab_t htab = objfile_data (objfile, stscm_objfile_data_key);
+ htab_t htab = (htab_t) objfile_data (objfile, stscm_objfile_data_key);
if (htab == NULL)
{
static void
stscm_del_objfile_symtabs (struct objfile *objfile, void *datum)
{
- htab_t htab = datum;
+ htab_t htab = (htab_t) datum;
if (htab != NULL)
{
static hashval_t
tyscm_hash_type_smob (const void *p)
{
- const type_smob *t_smob = p;
+ const type_smob *t_smob = (const type_smob *) p;
return htab_hash_pointer (t_smob->type);
}
static int
tyscm_eq_type_smob (const void *ap, const void *bp)
{
- const type_smob *a = ap;
- const type_smob *b = bp;
+ const type_smob *a = (const type_smob *) ap;
+ const type_smob *b = (const type_smob *) bp;
return (a->type == b->type
&& a->type != NULL);
if (objfile == NULL)
return global_types_map;
- htab = objfile_data (objfile, tyscm_objfile_data_key);
+ htab = (htab_t) objfile_data (objfile, tyscm_objfile_data_key);
if (htab == NULL)
{
htab = gdbscm_create_eqable_gsmob_ptr_map (tyscm_hash_type_smob,
tyscm_copy_type_recursive (void **slot, void *info)
{
type_smob *t_smob = (type_smob *) *slot;
- htab_t copied_types = info;
+ htab_t copied_types = (htab_t) info;
struct objfile *objfile = TYPE_OBJFILE (t_smob->type);
htab_t htab;
eqable_gdb_smob **new_slot;
static void
save_objfile_types (struct objfile *objfile, void *datum)
{
- htab_t htab = datum;
+ htab_t htab = (htab_t) datum;
htab_t copied_types;
if (!gdb_scheme_initialized)
{
case 's':
{
- char **arg_ptr = argp;
+ char **arg_ptr = (char **) argp;
CHECK_TYPE (gdbscm_is_true (scm_string_p (arg)), arg, position,
func_name, _("string"));
}
case 't':
{
- int *arg_ptr = argp;
+ int *arg_ptr = (int *) argp;
/* While in Scheme, anything non-#f is "true", we're strict. */
CHECK_TYPE (gdbscm_is_bool (arg), arg, position, func_name,
}
case 'i':
{
- int *arg_ptr = argp;
+ int *arg_ptr = (int *) argp;
CHECK_TYPE (scm_is_signed_integer (arg, INT_MIN, INT_MAX),
arg, position, func_name, _("int"));
}
case 'u':
{
- int *arg_ptr = argp;
+ int *arg_ptr = (int *) argp;
CHECK_TYPE (scm_is_unsigned_integer (arg, 0, UINT_MAX),
arg, position, func_name, _("unsigned int"));
}
case 'l':
{
- long *arg_ptr = argp;
+ long *arg_ptr = (long *) argp;
CHECK_TYPE (scm_is_signed_integer (arg, LONG_MIN, LONG_MAX),
arg, position, func_name, _("long"));
}
case 'n':
{
- unsigned long *arg_ptr = argp;
+ unsigned long *arg_ptr = (unsigned long *) argp;
CHECK_TYPE (scm_is_unsigned_integer (arg, 0, ULONG_MAX),
arg, position, func_name, _("unsigned long"));
}
case 'L':
{
- LONGEST *arg_ptr = argp;
+ LONGEST *arg_ptr = (LONGEST *) argp;
CHECK_TYPE (scm_is_signed_integer (arg, INT64_MIN, INT64_MAX),
arg, position, func_name, _("LONGEST"));
}
case 'U':
{
- ULONGEST *arg_ptr = argp;
+ ULONGEST *arg_ptr = (ULONGEST *) argp;
CHECK_TYPE (scm_is_unsigned_integer (arg, 0, UINT64_MAX),
arg, position, func_name, _("ULONGEST"));
}
case 'O':
{
- SCM *arg_ptr = argp;
+ SCM *arg_ptr = (SCM *) argp;
*arg_ptr = arg;
break;
CORE_ADDR current_pc;
if (*this_cache)
- return *this_cache;
+ return (struct h8300_frame_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache);
h8300_init_frame_cache (gdbarch, cache);
int i;
if (*this_cache)
- return *this_cache;
+ return (struct hppa_linux_sigtramp_unwind_cache *) *this_cache;
info = FRAME_OBSTACK_ZALLOC (struct hppa_linux_sigtramp_unwind_cache);
*this_cache = info;
static int
compare_unwind_entries (const void *arg1, const void *arg2)
{
- const struct unwind_table_entry *a = arg1;
- const struct unwind_table_entry *b = arg2;
+ const struct unwind_table_entry *a = (const struct unwind_table_entry *) arg1;
+ const struct unwind_table_entry *b = (const struct unwind_table_entry *) arg2;
if (a->region_start > b->region_start)
return 1;
{
struct hppa_unwind_info *ui;
ui = NULL;
- priv = objfile_data (objfile, hppa_objfile_priv_data);
+ priv = ((struct hppa_objfile_private *)
+ objfile_data (objfile, hppa_objfile_priv_data));
if (priv)
ui = ((struct hppa_objfile_private *) priv)->unwind_info;
if (!ui)
{
read_unwind_info (objfile);
- priv = objfile_data (objfile, hppa_objfile_priv_data);
+ priv = ((struct hppa_objfile_private *)
+ objfile_data (objfile, hppa_objfile_priv_data));
if (priv == NULL)
error (_("Internal error reading unwind information."));
ui = ((struct hppa_objfile_private *) priv)->unwind_info;
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, "base=%s (cached) }",
paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
- return (*this_cache);
+ return (struct hppa_frame_cache *) (*this_cache);
}
cache = FRAME_OBSTACK_ZALLOC (struct hppa_frame_cache);
(*this_cache) = cache;
{
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, "base=NULL (no unwind entry) }");
- return (*this_cache);
+ return (struct hppa_frame_cache *) (*this_cache);
}
/* Turn the Entry_GR field into a bitmask. */
{
error (_("Cannot read instruction at %s."),
paddress (gdbarch, pc));
- return (*this_cache);
+ return (struct hppa_frame_cache *) (*this_cache);
}
inst = extract_unsigned_integer (buf4, sizeof buf4, byte_order);
if (hppa_debug)
fprintf_unfiltered (gdb_stdlog, "base=%s }",
paddress (gdbarch, ((struct hppa_frame_cache *)*this_cache)->base));
- return (*this_cache);
+ return (struct hppa_frame_cache *) (*this_cache);
}
static void
struct unwind_table_entry *u;
if (*this_cache)
- return *this_cache;
+ return (struct hppa_stub_unwind_cache *) *this_cache;
info = FRAME_OBSTACK_ZALLOC (struct hppa_stub_unwind_cache);
*this_cache = info;
struct regcache *regcache,
int regnum, const void *gregs, size_t len)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
int i;
gdb_assert (len >= HPPANBSD_SIZEOF_GREGS);
int regnum, const void *gregs, size_t len)
{
gdb_byte zero[4] = { 0 };
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
size_t offset;
int i;
int regnum, const void *fpregs, size_t len)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- const gdb_byte *regs = fpregs;
+ const gdb_byte *regs = (const gdb_byte *) fpregs;
int i;
gdb_assert (len >= HPPAOBSD_SIZEOF_FPREGS);
static void
core_process_module_section (bfd *abfd, asection *sect, void *obj)
{
- struct cpms_data *data = obj;
+ struct cpms_data *data = (struct cpms_data *) obj;
enum bfd_endian byte_order = gdbarch_byte_order (data->gdbarch);
char *module_name;
{
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
const struct target_desc *tdesc = info.target_desc;
- struct tdesc_arch_data *tdesc_data = (void *) info.tdep_info;
+ struct tdesc_arch_data *tdesc_data
+ = (struct tdesc_arch_data *) info.tdep_info;
const struct tdesc_feature *feature;
int valid_p;
struct i386_frame_cache *cache;
if (*this_cache)
- return *this_cache;
+ return (struct i386_frame_cache *) *this_cache;
cache = i386_alloc_frame_cache ();
*this_cache = cache;
CORE_ADDR sp;
if (*this_cache)
- return *this_cache;
+ return (struct i386_frame_cache *) *this_cache;
cache = i386_alloc_frame_cache ();
*this_cache = cache;
gdb_byte buf[4];
if (*this_cache)
- return *this_cache;
+ return (struct i386_frame_cache *) *this_cache;
cache = i386_alloc_frame_cache ();
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
int i;
gdb_assert (len >= tdep->sizeof_gregset);
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- gdb_byte *regs = gregs;
+ gdb_byte *regs = (gdb_byte *) gregs;
int i;
gdb_assert (len >= tdep->sizeof_gregset);
set_gdbarch_insn_is_jump (gdbarch, i386_insn_is_jump);
/* Hook in ABI-specific overrides, if they have been registered. */
- info.tdep_info = (void *) tdesc_data;
+ info.tdep_info = (struct gdbarch_tdep_info *) tdesc_data;
gdbarch_init_osabi (info, gdbarch);
if (!i386_validate_tdesc_p (tdep, tdesc_data))
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
const struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- const gdb_byte *gregs = regs;
+ const gdb_byte *gregs = (const gdb_byte *) regs;
gdb_assert (len >= tdep->sizeof_gregset + I387_SIZEOF_FSAVE);
int i;
if (*this_cache)
- return *this_cache;
+ return (struct trad_frame_cache *) *this_cache;
cache = trad_frame_cache_zalloc (this_frame);
*this_cache = cache;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
- const gdb_byte *regs = fsave;
+ const gdb_byte *regs = (const gdb_byte *) fsave;
int i;
gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
i387_collect_fsave (const struct regcache *regcache, int regnum, void *fsave)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
- gdb_byte *regs = fsave;
+ gdb_byte *regs = (gdb_byte *) fsave;
int i;
gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
i387_supply_fxsave (struct regcache *regcache, int regnum, const void *fxsave)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
- const gdb_byte *regs = fxsave;
+ const gdb_byte *regs = (const gdb_byte *) fxsave;
int i;
gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
i387_collect_fxsave (const struct regcache *regcache, int regnum, void *fxsave)
{
struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache));
- gdb_byte *regs = fxsave;
+ gdb_byte *regs = (gdb_byte *) fxsave;
int i;
gdb_assert (tdep->st0_regnum >= I386_ST0_REGNUM);
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- const gdb_byte *regs = xsave;
+ const gdb_byte *regs = (const gdb_byte *) xsave;
int i;
unsigned int clear_bv;
static const gdb_byte zero[MAX_REGISTER_SIZE] = { 0 };
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
- gdb_byte *regs = xsave;
+ gdb_byte *regs = (gdb_byte *) xsave;
int i;
enum
{
CORE_ADDR cfm, psr;
if (*this_cache)
- return *this_cache;
+ return (struct ia64_frame_cache *) *this_cache;
cache = ia64_alloc_frame_cache ();
*this_cache = cache;
gdb_byte buf[8];
if (*this_cache)
- return *this_cache;
+ return (struct ia64_frame_cache *) *this_cache;
cache = ia64_alloc_frame_cache ();
static void
attach_command_continuation (void *args, int err)
{
- struct attach_command_continuation_args *a = args;
+ struct attach_command_continuation_args *a
+ = (struct attach_command_continuation_args *) args;
if (err)
return;
static void
attach_command_continuation_free_args (void *args)
{
- struct attach_command_continuation_args *a = args;
+ struct attach_command_continuation_args *a
+ = (struct attach_command_continuation_args *) args;
xfree (a->args);
xfree (a);
static void
restore_inferior (void *arg)
{
- struct inferior *saved_inferior = arg;
+ struct inferior *saved_inferior = (struct inferior *) arg;
set_current_inferior (saved_inferior);
}
static int
delete_thread_of_inferior (struct thread_info *tp, void *data)
{
- struct delete_thread_of_inferior_arg *arg = data;
+ struct delete_thread_of_inferior_arg *arg
+ = (struct delete_thread_of_inferior_arg *) data;
if (ptid_get_pid (tp->ptid) == arg->pid)
{
static void
inflow_inferior_data_cleanup (struct inferior *inf, void *arg)
{
- struct terminal_info *info = arg;
+ struct terminal_info *info = (struct terminal_info *) arg;
xfree (info->run_terminal);
xfree (info->ttystate);
{
struct terminal_info *info;
- info = inferior_data (inf, inflow_inferior_data);
+ info = (struct terminal_info *) inferior_data (inf, inflow_inferior_data);
if (info == NULL)
{
info = XCNEW (struct terminal_info);
{
struct terminal_info *info;
- info = inferior_data (inf, inflow_inferior_data);
+ info = (struct terminal_info *) inferior_data (inf, inflow_inferior_data);
if (info != NULL)
{
xfree (info->run_terminal);
static void
displaced_step_clear_cleanup (void *arg)
{
- struct displaced_step_inferior_state *state = arg;
+ struct displaced_step_inferior_state *state
+ = (struct displaced_step_inferior_state *) arg;
displaced_step_clear (state);
}
static void
restore_current_uiout_cleanup (void *arg)
{
- struct ui_out *saved_uiout = arg;
+ struct ui_out *saved_uiout = (struct ui_out *) arg;
current_uiout = saved_uiout;
}
static void
release_stop_context_cleanup (void *arg)
{
- struct stop_context *sc = arg;
+ struct stop_context *sc = (struct stop_context *) arg;
if (sc->thread != NULL)
sc->thread->refcount--;
static void
do_restore_infcall_suspend_state_cleanup (void *state)
{
- restore_infcall_suspend_state (state);
+ restore_infcall_suspend_state ((struct infcall_suspend_state *) state);
}
struct cleanup *
static void
do_restore_infcall_control_state_cleanup (void *sts)
{
- restore_infcall_control_state (sts);
+ restore_infcall_control_state ((struct infcall_control_state *) sts);
}
struct cleanup *
static void
restore_inferior_ptid (void *arg)
{
- ptid_t *saved_ptid_ptr = arg;
+ ptid_t *saved_ptid_ptr = (ptid_t *) arg;
inferior_ptid = *saved_ptid_ptr;
xfree (arg);
if (BLOCKVECTOR_MAP (bv) == NULL)
return 0;
- new_block = addrmap_find (BLOCKVECTOR_MAP (bv), pc - 1);
+ new_block = (struct block *) addrmap_find (BLOCKVECTOR_MAP (bv), pc - 1);
if (new_block == NULL)
return 1;
int i;
if (*this_cache)
- return *this_cache;
+ return (struct iq2000_frame_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct iq2000_frame_cache);
iq2000_init_frame_cache (cache);
{
struct jit_objfile_data *objf_data;
- objf_data = objfile_data (objf, jit_objfile_data);
+ objf_data = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
if (objf_data == NULL)
{
objf_data = XCNEW (struct jit_objfile_data);
{
struct jit_program_space_data *ps_data;
- ps_data = program_space_data (current_program_space, jit_program_space_data);
+ ps_data
+ = ((struct jit_program_space_data *)
+ program_space_data (current_program_space, jit_program_space_data));
if (ps_data == NULL)
{
ps_data = XCNEW (struct jit_program_space_data);
struct objfile *objfile;
jit_dbg_reader_data *priv_data;
- priv_data = cb->priv_data;
+ priv_data = (jit_dbg_reader_data *) cb->priv_data;
objfile = allocate_objfile (NULL, "<< JIT compiled code >>",
OBJF_NOT_FILENAME);
{
struct jit_objfile_data *objf_data;
- objf_data = objfile_data (objf, jit_objfile_data);
+ objf_data
+ = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
if (objf_data != NULL && objf_data->addr == entry_addr)
return objf;
}
{
struct jit_program_space_data *ps_data;
- ps_data = program_space_data (iter->pspace, jit_program_space_data);
+ ps_data = ((struct jit_program_space_data *)
+ program_space_data (iter->pspace, jit_program_space_data));
if (ps_data != NULL && ps_data->jit_breakpoint == iter->owner)
{
ps_data->cached_code_address = 0;
struct jit_unwind_private *priv;
int gdb_reg;
- priv = cb->priv_data;
+ priv = (struct jit_unwind_private *) cb->priv_data;
gdb_reg = gdbarch_dwarf2_reg_to_regnum (get_frame_arch (priv->this_frame),
dwarf_regnum);
int gdb_reg, size;
struct gdbarch *frame_arch;
- priv = cb->priv_data;
+ priv = (struct jit_unwind_private *) cb->priv_data;
frame_arch = get_frame_arch (priv->this_frame);
gdb_reg = gdbarch_dwarf2_reg_to_regnum (frame_arch, regnum);
static void
jit_dealloc_cache (struct frame_info *this_frame, void *cache)
{
- struct jit_unwind_private *priv_data = cache;
+ struct jit_unwind_private *priv_data = (struct jit_unwind_private *) cache;
struct gdbarch *frame_arch;
int i;
gdb_assert (!*cache);
*cache = XCNEW (struct jit_unwind_private);
- priv_data = *cache;
+ priv_data = (struct jit_unwind_private *) *cache;
priv_data->registers =
XCNEWVEC (struct gdb_reg_value *,
gdbarch_num_regs (get_frame_arch (this_frame)));
static struct value *
jit_frame_prev_register (struct frame_info *this_frame, void **cache, int reg)
{
- struct jit_unwind_private *priv = *cache;
+ struct jit_unwind_private *priv = (struct jit_unwind_private *) *cache;
struct gdb_reg_value *value;
if (priv == NULL)
{
struct jit_gdbarch_data_type *data;
- data = gdbarch_data (gdbarch, jit_gdbarch_data);
+ data
+ = (struct jit_gdbarch_data_type *) gdbarch_data (gdbarch, jit_gdbarch_data);
if (!data->unwinder_registered)
{
frame_unwind_prepend_unwinder (gdbarch, &jit_frame_unwind);
ALL_OBJFILES_SAFE (objf, temp)
{
- struct jit_objfile_data *objf_data = objfile_data (objf,
- jit_objfile_data);
+ struct jit_objfile_data *objf_data
+ = (struct jit_objfile_data *) objfile_data (objf, jit_objfile_data);
if (objf_data != NULL && objf_data->addr != 0)
jit_unregister_code (objf);
static void
free_objfile_data (struct objfile *objfile, void *data)
{
- struct jit_objfile_data *objf_data = data;
+ struct jit_objfile_data *objf_data = (struct jit_objfile_data *) data;
if (objf_data->register_code != NULL)
{
struct jit_program_space_data *ps_data;
- ps_data = program_space_data (objfile->pspace, jit_program_space_data);
+ ps_data
+ = ((struct jit_program_space_data *)
+ program_space_data (objfile->pspace, jit_program_space_data));
if (ps_data != NULL && ps_data->objfile == objfile)
ps_data->objfile = NULL;
}
static void
jv_per_objfile_free (struct objfile *objfile, void *data)
{
- struct jv_per_objfile_data *jv_data = data;
+ struct jv_per_objfile_data *jv_data = (struct jv_per_objfile_data *) data;
struct objfile *dynamics_objfile;
- dynamics_objfile = program_space_data (current_program_space,
- jv_dynamics_progspace_key);
+ dynamics_objfile
+ = (struct objfile *) program_space_data (current_program_space,
+ jv_dynamics_progspace_key);
gdb_assert (objfile == dynamics_objfile);
if (jv_data->dict)
{
struct objfile *dynamics_objfile;
- dynamics_objfile = program_space_data (current_program_space,
- jv_dynamics_progspace_key);
+ dynamics_objfile
+ = (struct objfile *) program_space_data (current_program_space,
+ jv_dynamics_progspace_key);
if (dynamics_objfile == NULL)
{
BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
/* Arrange to free the dict. */
- jv_data = objfile_data (objfile, jv_dynamics_objfile_data_key);
+ jv_data = ((struct jv_per_objfile_data *)
+ objfile_data (objfile, jv_dynamics_objfile_data_key));
jv_data->dict = BLOCK_DICT (bl);
}
return class_symtab;
const struct builtin_java_type *
builtin_java_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, java_type_data);
+ return ((const struct builtin_java_type *)
+ gdbarch_data (gdbarch, java_type_data));
}
void
language_string_char_type (const struct language_defn *la,
struct gdbarch *gdbarch)
{
- struct language_gdbarch *ld = gdbarch_data (gdbarch,
- language_gdbarch_data);
+ struct language_gdbarch *ld
+ = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
return ld->arch_info[la->la_language].string_char_type;
}
language_bool_type (const struct language_defn *la,
struct gdbarch *gdbarch)
{
- struct language_gdbarch *ld = gdbarch_data (gdbarch,
- language_gdbarch_data);
+ struct language_gdbarch *ld
+ = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
if (ld->arch_info[la->la_language].bool_type_symbol)
{
struct gdbarch *gdbarch,
const char *name)
{
- struct language_gdbarch *ld = gdbarch_data (gdbarch,
- language_gdbarch_data);
+ struct language_gdbarch *ld =
+ (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
struct type **typep;
typep = language_lookup_primitive_type_1 (&ld->arch_info[la->la_language],
struct gdbarch *gdbarch,
const char *name)
{
- struct language_gdbarch *ld = gdbarch_data (gdbarch,
- language_gdbarch_data);
+ struct language_gdbarch *ld
+ = (struct language_gdbarch *) gdbarch_data (gdbarch, language_gdbarch_data);
struct language_arch_info *lai = &ld->arch_info[la->la_language];
struct type **typep;
struct symbol *sym;
static hashval_t
hash_address_entry (const void *p)
{
- const struct address_entry *aep = p;
+ const struct address_entry *aep = (const struct address_entry *) p;
hashval_t hash;
hash = iterative_hash_object (aep->pspace, 0);
static int
eq_address_entry (const void *a, const void *b)
{
- const struct address_entry *aea = a;
- const struct address_entry *aeb = b;
+ const struct address_entry *aea = (const struct address_entry *) a;
+ const struct address_entry *aeb = (const struct address_entry *) b;
return aea->pspace == aeb->pspace && aea->addr == aeb->addr;
}
{
if (SYMBOL_INLINED (sym))
{
- struct symbol_and_data_callback *cad = d;
+ struct symbol_and_data_callback *cad
+ = (struct symbol_and_data_callback *) d;
return cad->callback (sym, cad->data);
}
static int
iterate_name_matcher (const char *name, void *d)
{
- const struct symbol_matcher_data *data = d;
+ const struct symbol_matcher_data *data
+ = (const struct symbol_matcher_data *) d;
if (data->symbol_name_cmp (name, data->lookup_name) == 0)
return 1; /* Expand this symbol's symbol table. */
static int
decode_line_2_compare_items (const void *ap, const void *bp)
{
- const struct decode_line_2_item *a = ap;
- const struct decode_line_2_item *b = bp;
+ const struct decode_line_2_item *a = (const struct decode_line_2_item *) ap;
+ const struct decode_line_2_item *b = (const struct decode_line_2_item *) bp;
int retval;
retval = strcmp (a->displayform, b->displayform);
static int
collect_one_symbol (struct symbol *sym, void *d)
{
- struct decode_compound_collector *collector = d;
+ struct decode_compound_collector *collector
+ = (struct decode_compound_collector *) d;
void **slot;
struct type *t;
static int
compare_symbols (const void *a, const void *b)
{
- struct symbol * const *sa = a;
- struct symbol * const *sb = b;
+ struct symbol * const *sa = (struct symbol * const*) a;
+ struct symbol * const *sb = (struct symbol * const*) b;
uintptr_t uia, uib;
uia = (uintptr_t) SYMTAB_PSPACE (symbol_symtab (*sa));
static int
compare_msymbols (const void *a, const void *b)
{
- const struct bound_minimal_symbol *sa = a;
- const struct bound_minimal_symbol *sb = b;
+ const struct bound_minimal_symbol *sa
+ = (const struct bound_minimal_symbol *) a;
+ const struct bound_minimal_symbol *sb
+ = (const struct bound_minimal_symbol *) b;
uintptr_t uia, uib;
uia = (uintptr_t) sa->objfile->pspace;
static int
add_symtabs_to_list (struct symtab *symtab, void *d)
{
- struct symtab_collector *data = d;
+ struct symtab_collector *data = (struct symtab_collector *) d;
void **slot;
slot = htab_find_slot (data->symtab_table, symtab, INSERT);
static int
collect_symbols (struct symbol *sym, void *data)
{
- struct collect_info *info = data;
+ struct collect_info *info = (struct collect_info *) data;
/* In list mode, add all matching symbols, regardless of class.
This allows the user to type "list a_global_variable". */
static int
compare_msyms (const void *a, const void *b)
{
- const bound_minimal_symbol_d *moa = a;
- const bound_minimal_symbol_d *mob = b;
+ const bound_minimal_symbol_d *moa = (const bound_minimal_symbol_d *) a;
+ const bound_minimal_symbol_d *mob = (const bound_minimal_symbol_d *) b;
enum minimal_symbol_type ta = MSYMBOL_TYPE (moa->minsym);
enum minimal_symbol_type tb = MSYMBOL_TYPE (mob->minsym);
static void
add_minsym (struct minimal_symbol *minsym, void *d)
{
- struct collect_minsyms *info = d;
+ struct collect_minsyms *info = (struct collect_minsyms *) d;
bound_minimal_symbol_d mo;
mo.minsym = minsym;
static void
cleanup_linespec_result (void *a)
{
- destroy_linespec_result (a);
+ destroy_linespec_result ((struct linespec_result *) a);
}
/* See the comment in linespec.h. */
static void
inferior_call_waitpid_cleanup (void *fp)
{
- struct fork_info *oldfp = fp;
+ struct fork_info *oldfp = (struct fork_info *) fp;
if (oldfp)
{
static void
delete_lwp_cleanup (void *lp_voidp)
{
- struct lwp_info *lp = lp_voidp;
+ struct lwp_info *lp = (struct lwp_info *) lp_voidp;
delete_lwp (lp->ptid);
}
static int
count_events_callback (struct lwp_info *lp, void *data)
{
- int *count = data;
+ int *count = (int *) data;
gdb_assert (count != NULL);
static int
select_event_lwp_callback (struct lwp_info *lp, void *data)
{
- int *selector = data;
+ int *selector = (int *) data;
gdb_assert (selector != NULL);
static int
resume_stopped_resumed_lwps (struct lwp_info *lp, void *data)
{
- ptid_t *wait_ptid_p = data;
+ ptid_t *wait_ptid_p = (ptid_t *) data;
if (!lp->stopped)
{
static struct linux_gdbarch_data *
get_linux_gdbarch_data (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, linux_gdbarch_data_handle);
+ return ((struct linux_gdbarch_data *)
+ gdbarch_data (gdbarch, linux_gdbarch_data_handle));
}
/* Per-inferior data key. */
{
struct linux_info *info;
- info = inferior_data (inf, linux_inferior_data);
+ info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
if (info != NULL)
{
xfree (info);
struct linux_info *info;
struct inferior *inf = current_inferior ();
- info = inferior_data (inf, linux_inferior_data);
+ info = (struct linux_info *) inferior_data (inf, linux_inferior_data);
if (info == NULL)
{
info = XCNEW (struct linux_info);
int read, int write, int exec, int modified,
const char *filename, void *arg)
{
- struct linux_find_memory_regions_data *data = arg;
+ struct linux_find_memory_regions_data *data
+ = (struct linux_find_memory_regions_data *) arg;
return data->func (vaddr, size, read, write, exec, modified, data->obfd);
}
int read, int write, int exec, int modified,
const char *filename, void *data)
{
- struct linux_make_mappings_data *map_data = data;
+ struct linux_make_mappings_data *map_data
+ = (struct linux_make_mappings_data *) data;
gdb_byte buf[sizeof (ULONGEST)];
if (*filename == '\0' || inode == 0)
static int
linux_corefile_thread_callback (struct thread_info *info, void *data)
{
- struct linux_corefile_thread_data *args = data;
+ struct linux_corefile_thread_data *args
+ = (struct linux_corefile_thread_data *) data;
/* It can be current thread
which cannot be removed by update_thread_list. */
int read, int write, int exec, int modified,
void *data)
{
- struct mem_range *range = data;
+ struct mem_range *range = (struct mem_range *) data;
if (vaddr == range->start)
{
td_err_e err;
ptid_t ptid;
struct thread_info *tp;
- struct callback_data *cb_data = data;
+ struct callback_data *cb_data = (struct callback_data *) data;
struct thread_db_info *info = cb_data->info;
err = info->td_thr_get_info_p (th_p, &ti);
int i;
if ((*this_prologue_cache))
- return (*this_prologue_cache);
+ return (struct lm32_frame_cache *) (*this_prologue_cache);
info = FRAME_OBSTACK_ZALLOC (struct lm32_frame_cache);
(*this_prologue_cache) = info;
const struct builtin_m2_type *
builtin_m2_type (struct gdbarch *gdbarch)
{
- return gdbarch_data (gdbarch, m2_type_data);
+ return (const struct builtin_m2_type *) gdbarch_data (gdbarch, m2_type_data);
}
*this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct m32c_prologue);
m32c_analyze_prologue (get_frame_arch (this_frame),
- func_start, stop_addr, *this_prologue_cache);
+ func_start, stop_addr,
+ (struct m32c_prologue *) *this_prologue_cache);
}
- return *this_prologue_cache;
+ return (struct m32c_prologue *) *this_prologue_cache;
}
int regnum;
if ((*this_cache) != NULL)
- return (*this_cache);
+ return (struct m32r_frame_cache *) (*this_cache);
cache = FRAME_OBSTACK_ZALLOC (struct m32r_frame_cache);
(*this_cache) = cache;
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
struct regcache *regcache, int regnum,
const void *gregs, size_t size)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
enum bfd_endian byte_order =
gdbarch_byte_order (get_regcache_arch (regcache));
ULONGEST psw, bbpsw;
const struct regcache *regcache,
int regnum, void *gregs, size_t size)
{
- gdb_byte *regs = gregs;
+ gdb_byte *regs = (gdb_byte *) gregs;
int i;
enum bfd_endian byte_order =
gdbarch_byte_order (get_regcache_arch (regcache));
if ((*this_prologue_cache))
- return (*this_prologue_cache);
+ return (struct m32r_unwind_cache *) (*this_prologue_cache);
info = FRAME_OBSTACK_ZALLOC (struct m32r_unwind_cache);
(*this_prologue_cache) = info;
int i;
if ((*this_prologue_cache))
- return (*this_prologue_cache);
+ return (struct m68hc11_unwind_cache *) (*this_prologue_cache);
info = FRAME_OBSTACK_ZALLOC (struct m68hc11_unwind_cache);
(*this_prologue_cache) = info;
int i;
if (*this_cache)
- return *this_cache;
+ return (struct m68k_frame_cache *) *this_cache;
cache = m68k_alloc_frame_cache ();
*this_cache = cache;
int regnum, const void *fpregs, size_t len)
{
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- const gdb_byte *regs = fpregs;
+ const gdb_byte *regs = (const gdb_byte *) fpregs;
int i;
gdb_assert (len >= M68KBSD_SIZEOF_FPREGS);
struct regcache *regcache,
int regnum, const void *gregs, size_t len)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
int i;
gdb_assert (len >= M68KBSD_SIZEOF_GREGS);
int i;
if (*this_cache)
- return *this_cache;
+ return (struct trad_frame_cache *) *this_cache;
cache = trad_frame_cache_zalloc (this_frame);
CORE_ADDR frame_sp;
if (*this_cache)
- return *this_cache;
+ return (struct m88k_frame_cache *) *this_cache;
cache = FRAME_OBSTACK_ZALLOC (struct m88k_frame_cache);
cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
struct regcache *regcache,
int regnum, const void *gregs, size_t len)
{
- const gdb_byte *regs = gregs;
+ const gdb_byte *regs = (const gdb_byte *) gregs;
int i;
for (i = 0; i < M88K_NUM_REGS; i++)
+2015-09-25 Simon Marchi <simon.marchi@ericsson.com>
+
+ * gdb.gdb/selftest.exp (do_steps_and_nexts): Adjust expected
+ source line.
+
2015-09-24 Sandra Loosemore <sandra@codesourcery.com>
* gdb.cp/classes.exp (test_enums): Generalize regexp to allow
# me with GCC 3.1 on i686-pc-linux-gnu when I compile with
# optimization.
gdb_test_multiple "list" "list" {
- -re ".*context = data.*$gdb_prompt $" {
+ -re ".*context = \\(struct captured_main_args \\*\\) data.*$gdb_prompt $" {
set description "step over context initialization"
set command "step"
}
projects / platform / upstream / binutils.git / commitdiff