From 9a3c826307ae6ad4dd6fbd72431e7d9d4947f1dd Mon Sep 17 00:00:00 2001
From: Simon Marchi <simon.marchi@ericsson.com>
Date: Fri, 25 Sep 2015 14:08:07 -0400
Subject: [PATCH] Add some more casts (1/2)

Note: I needed to split this patch in two, otherwise it's too big for
the mailing list.

This patch adds explicit casts to situations where a void pointer is
assigned to a pointer to the "real" type.  Building in C++ mode requires
those assignments to use an explicit cast.  This includes, for example:

 - callback arguments (cleanups, comparison functions, ...)
 - data attached to some object (objfile, program space, etc) in the form
   of a void pointer
 - "user data" passed to some function

This patch comes from the commit "(mostly) auto-generated patch to insert
casts needed for C++", taken from Pedro's C++ branch.

Only files built on x86 with --enable-targets=all are modified, so the
native files for other arches will need to be dealt with separately.

I built-tested this with --enable-targets=all and reg-tested.  To my
surprise, a test case (selftest.exp) had to be adjusted.

Here's the ChangeLog entry.  Again, this was relatively quick to make
despite the length, thanks to David Malcom's script, although I don't
believe it's very useful information in that particular case...

gdb/ChangeLog:

	* 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.

gdb/gdbserver/ChangeLog:

	* 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.

gdb/testsuite/ChangeLog:

	* gdb.gdb/selftest.exp (do_steps_and_nexts): Adjust expected
	source line.
---
 gdb/ChangeLog                      | 529 +++++++++++++++++++++++++++++++++++++
 gdb/aarch64-tdep.c                 |   6 +-
 gdb/ada-lang.c                     |  13 +-
 gdb/ada-tasks.c                    |   6 +-
 gdb/addrmap.c                      |   9 +-
 gdb/alpha-linux-tdep.c             |   8 +-
 gdb/alpha-mdebug-tdep.c            |   2 +-
 gdb/alpha-tdep.c                   |  21 +-
 gdb/alphanbsd-tdep.c               |   6 +-
 gdb/amd64-linux-tdep.c             |   8 +-
 gdb/amd64-nat.c                    |   4 +-
 gdb/amd64-tdep.c                   |  14 +-
 gdb/amd64-windows-tdep.c           |   2 +-
 gdb/amd64obsd-tdep.c               |   2 +-
 gdb/arm-linux-tdep.c               |  12 +-
 gdb/arm-tdep.c                     |  31 ++-
 gdb/armbsd-tdep.c                  |   4 +-
 gdb/auto-load.c                    |  19 +-
 gdb/auxv.c                         |   4 +-
 gdb/avr-tdep.c                     |   2 +-
 gdb/ax-general.c                   |   2 +-
 gdb/bfd-target.c                   |   6 +-
 gdb/bfin-tdep.c                    |   2 +-
 gdb/block.c                        |   6 +-
 gdb/break-catch-sig.c              |  13 +-
 gdb/break-catch-syscall.c          |   3 +-
 gdb/breakpoint.c                   |  38 +--
 gdb/bsd-uthread.c                  |  17 +-
 gdb/btrace.c                       |  29 +-
 gdb/c-typeprint.c                  |   2 +-
 gdb/charset.c                      |   4 +-
 gdb/cli-out.c                      |  40 +--
 gdb/cli/cli-cmds.c                 |   4 +-
 gdb/cli/cli-dump.c                 |   4 +-
 gdb/cli/cli-script.c               |   6 +-
 gdb/coff-pe-read.c                 |   6 +-
 gdb/coffread.c                     |   3 +-
 gdb/common/agent.c                 |   3 +-
 gdb/common/filestuff.c             |   2 +-
 gdb/common/format.c                |   2 +-
 gdb/common/vec.c                   |   2 +-
 gdb/compile/compile-c-support.c    |   2 +-
 gdb/compile/compile-c-symbols.c    |  20 +-
 gdb/compile/compile-c-types.c      |  10 +-
 gdb/compile/compile-object-load.c  |   9 +-
 gdb/compile/compile-object-run.c   |   2 +-
 gdb/compile/compile.c              |   8 +-
 gdb/completer.c                    |   2 +-
 gdb/corelow.c                      |   2 +-
 gdb/cp-namespace.c                 |   2 +-
 gdb/cp-support.c                   |   2 +-
 gdb/cris-tdep.c                    |   4 +-
 gdb/d-lang.c                       |   2 +-
 gdb/d-namespace.c                  |   2 +-
 gdb/dbxread.c                      |   4 +-
 gdb/disasm.c                       |  14 +-
 gdb/doublest.c                     |   2 +-
 gdb/dummy-frame.c                  |   8 +-
 gdb/dwarf2-frame-tailcall.c        |  18 +-
 gdb/dwarf2-frame.c                 |  40 +--
 gdb/dwarf2expr.c                   |   7 +-
 gdb/dwarf2loc.c                    |  87 +++---
 gdb/dwarf2read.c                   | 239 ++++++++++-------
 gdb/elfread.c                      |  27 +-
 gdb/f-lang.c                       |   2 +-
 gdb/frame-base.c                   |   9 +-
 gdb/frame-unwind.c                 |   9 +-
 gdb/frame.c                        |  14 +-
 gdb/frv-linux-tdep.c               |   2 +-
 gdb/frv-tdep.c                     |   2 +-
 gdb/ft32-tdep.c                    |   2 +-
 gdb/gcore.c                        |   6 +-
 gdb/gdb_bfd.c                      |  37 +--
 gdb/gdbserver/ChangeLog            |  18 ++
 gdb/gdbserver/dll.c                |   6 +-
 gdb/gdbserver/linux-low.c          |  10 +-
 gdb/gdbserver/server.c             |   9 +-
 gdb/gdbserver/thread-db.c          |   2 +-
 gdb/gdbserver/tracepoint.c         |   6 +-
 gdb/gdbtypes.c                     |   9 +-
 gdb/gnu-v3-abi.c                   |  27 +-
 gdb/go-lang.c                      |   2 +-
 gdb/guile/scm-block.c              |  10 +-
 gdb/guile/scm-breakpoint.c         |   2 +-
 gdb/guile/scm-disasm.c             |  11 +-
 gdb/guile/scm-frame.c              |  10 +-
 gdb/guile/scm-gsmob.c              |   2 +-
 gdb/guile/scm-objfile.c            |   4 +-
 gdb/guile/scm-ports.c              |  12 +-
 gdb/guile/scm-progspace.c          |   4 +-
 gdb/guile/scm-safe-call.c          |  27 +-
 gdb/guile/scm-string.c             |   4 +-
 gdb/guile/scm-symbol.c             |  13 +-
 gdb/guile/scm-symtab.c             |  10 +-
 gdb/guile/scm-type.c               |  12 +-
 gdb/guile/scm-utils.c              |  18 +-
 gdb/h8300-tdep.c                   |   2 +-
 gdb/hppa-linux-tdep.c              |   2 +-
 gdb/hppa-tdep.c                    |  20 +-
 gdb/hppanbsd-tdep.c                |   2 +-
 gdb/hppaobsd-tdep.c                |   4 +-
 gdb/i386-cygwin-tdep.c             |   2 +-
 gdb/i386-linux-tdep.c              |   3 +-
 gdb/i386-tdep.c                    |  12 +-
 gdb/i386obsd-tdep.c                |   4 +-
 gdb/i387-tdep.c                    |  12 +-
 gdb/ia64-tdep.c                    |   4 +-
 gdb/infcmd.c                       |   6 +-
 gdb/inferior.c                     |   5 +-
 gdb/inflow.c                       |   6 +-
 gdb/infrun.c                       |  13 +-
 gdb/inline-frame.c                 |   2 +-
 gdb/iq2000-tdep.c                  |   2 +-
 gdb/jit.c                          |  37 +--
 gdb/jv-lang.c                      |  18 +-
 gdb/language.c                     |  16 +-
 gdb/linespec.c                     |  41 +--
 gdb/linux-fork.c                   |   2 +-
 gdb/linux-nat.c                    |   8 +-
 gdb/linux-tdep.c                   |  18 +-
 gdb/linux-thread-db.c              |   2 +-
 gdb/lm32-tdep.c                    |   2 +-
 gdb/m2-lang.c                      |   2 +-
 gdb/m32c-tdep.c                    |   5 +-
 gdb/m32r-linux-tdep.c              |   6 +-
 gdb/m32r-tdep.c                    |   2 +-
 gdb/m68hc11-tdep.c                 |   2 +-
 gdb/m68k-tdep.c                    |   2 +-
 gdb/m68kbsd-tdep.c                 |   4 +-
 gdb/m68klinux-tdep.c               |   2 +-
 gdb/m88k-tdep.c                    |   4 +-
 gdb/testsuite/ChangeLog            |   5 +
 gdb/testsuite/gdb.gdb/selftest.exp |   2 +-
 133 files changed, 1352 insertions(+), 649 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index fb66ae8..1baed6a 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,534 @@
 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.
diff --git a/gdb/aarch64-tdep.c b/gdb/aarch64-tdep.c
index da61e54..5b5e1ad 100644
--- a/gdb/aarch64-tdep.c
+++ b/gdb/aarch64-tdep.c
@@ -846,7 +846,7 @@ aarch64_make_prologue_cache (struct frame_info *this_frame, void **this_cache)
   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);
@@ -971,7 +971,7 @@ aarch64_make_stub_cache (struct frame_info *this_frame, void **this_cache)
   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);
@@ -2464,7 +2464,7 @@ aarch64_pseudo_write (struct gdbarch *gdbarch, struct regcache *regcache,
 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);
 }
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index 0b463e2..a229fa1 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -398,7 +398,7 @@ ada_inferior_data_cleanup (struct inferior *inf, void *arg)
 {
   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);
 }
@@ -416,7 +416,7 @@ get_ada_inferior_data (struct inferior *inf)
 {
   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);
@@ -459,7 +459,8 @@ get_ada_pspace_data (struct program_space *pspace)
 {
   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);
@@ -474,7 +475,7 @@ get_ada_pspace_data (struct program_space *pspace)
 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);
@@ -6370,7 +6371,7 @@ struct add_partial_datum
 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;
@@ -13131,7 +13132,7 @@ sort_remove_dups_ada_exceptions_list (VEC(ada_exc_info) **exceptions,
 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;
diff --git a/gdb/ada-tasks.c b/gdb/ada-tasks.c
index fbe67aa..e2194dd 100644
--- a/gdb/ada-tasks.c
+++ b/gdb/ada-tasks.c
@@ -248,7 +248,8 @@ get_ada_tasks_pspace_data (struct program_space *pspace)
 {
   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);
@@ -275,7 +276,8 @@ get_ada_tasks_inferior_data (struct inferior *inf)
 {
   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);
diff --git a/gdb/addrmap.c b/gdb/addrmap.c
index a526167..0324edc 100644
--- a/gdb/addrmap.c
+++ b/gdb/addrmap.c
@@ -479,7 +479,8 @@ struct mutable_foreach_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),
@@ -514,7 +515,7 @@ static const struct addrmap_funcs addrmap_mutable_funcs =
 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.
@@ -536,8 +537,8 @@ splay_obstack_alloc (int size, void *closure)
 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
diff --git a/gdb/alpha-linux-tdep.c b/gdb/alpha-linux-tdep.c
index 27bd452..3263049 100644
--- a/gdb/alpha-linux-tdep.c
+++ b/gdb/alpha-linux-tdep.c
@@ -163,7 +163,7 @@ alpha_linux_supply_gregset (const struct regset *regset,
 			    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,
@@ -180,7 +180,7 @@ alpha_linux_collect_gregset (const struct regset *regset,
 			     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,
@@ -196,7 +196,7 @@ alpha_linux_supply_fpregset (const struct regset *regset,
 			     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);
@@ -212,7 +212,7 @@ alpha_linux_collect_fpregset (const struct regset *regset,
 			      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);
diff --git a/gdb/alpha-mdebug-tdep.c b/gdb/alpha-mdebug-tdep.c
index a8a511b..a32088b 100644
--- a/gdb/alpha-mdebug-tdep.c
+++ b/gdb/alpha-mdebug-tdep.c
@@ -197,7 +197,7 @@ alpha_mdebug_frame_unwind_cache (struct frame_info *this_frame,
   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;
diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 7654096..0696b6e 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -185,7 +185,8 @@ static void
 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;
@@ -205,7 +206,7 @@ alpha_lds (struct gdbarch *gdbarch, void *out, const void *in)
     }
 
   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
@@ -217,9 +218,9 @@ alpha_sts (struct gdbarch *gdbarch, void *out, const void *in)
   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
@@ -889,7 +890,7 @@ alpha_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
   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;
@@ -1239,7 +1240,7 @@ alpha_heuristic_frame_unwind_cache (struct frame_info *this_frame,
   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;
@@ -1498,7 +1499,7 @@ void
 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)
@@ -1523,7 +1524,7 @@ void
 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)
@@ -1541,7 +1542,7 @@ void
 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)
@@ -1557,7 +1558,7 @@ void
 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)
diff --git a/gdb/alphanbsd-tdep.c b/gdb/alphanbsd-tdep.c
index 69be265..8e07c55 100644
--- a/gdb/alphanbsd-tdep.c
+++ b/gdb/alphanbsd-tdep.c
@@ -53,7 +53,7 @@ alphanbsd_supply_fpregset (const struct regset *regset,
 			   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);
@@ -77,7 +77,7 @@ alphanbsd_aout_supply_gregset (const struct regset *regset,
 			       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.  */
@@ -121,7 +121,7 @@ alphanbsd_supply_gregset (const struct regset *regset,
 			  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)
diff --git a/gdb/amd64-linux-tdep.c b/gdb/amd64-linux-tdep.c
index 14c1065..021dca6 100644
--- a/gdb/amd64-linux-tdep.c
+++ b/gdb/amd64-linux-tdep.c
@@ -1845,7 +1845,8 @@ amd64_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;
 
@@ -2057,11 +2058,12 @@ amd64_linux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch)
 }
 
 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;
 
diff --git a/gdb/amd64-nat.c b/gdb/amd64-nat.c
index 6a1690e..884f04d 100644
--- a/gdb/amd64-nat.c
+++ b/gdb/amd64-nat.c
@@ -88,7 +88,7 @@ void
 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;
@@ -119,7 +119,7 @@ void
 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;
diff --git a/gdb/amd64-tdep.c b/gdb/amd64-tdep.c
index a2179ce..f0720c8 100644
--- a/gdb/amd64-tdep.c
+++ b/gdb/amd64-tdep.c
@@ -2471,7 +2471,7 @@ amd64_frame_cache (struct frame_info *this_frame, void **this_cache)
   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;
@@ -2590,7 +2590,7 @@ amd64_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
   int i;
 
   if (*this_cache)
-    return *this_cache;
+    return (struct amd64_frame_cache *) *this_cache;
 
   cache = amd64_alloc_frame_cache ();
 
@@ -2766,7 +2766,7 @@ amd64_epilogue_frame_cache (struct frame_info *this_frame, void **this_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;
@@ -3182,7 +3182,7 @@ amd64_supply_fxsave (struct regcache *regcache, int regnum,
   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);
@@ -3205,7 +3205,7 @@ amd64_supply_xsave (struct regcache *regcache, int regnum,
   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),
@@ -3227,7 +3227,7 @@ amd64_collect_fxsave (const struct regcache *regcache, int regnum,
 {
   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);
 
@@ -3248,7 +3248,7 @@ amd64_collect_xsave (const struct regcache *regcache, int regnum,
 {
   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);
 
diff --git a/gdb/amd64-windows-tdep.c b/gdb/amd64-windows-tdep.c
index 8b6e52b..296bdb2 100644
--- a/gdb/amd64-windows-tdep.c
+++ b/gdb/amd64-windows-tdep.c
@@ -1025,7 +1025,7 @@ amd64_windows_frame_cache (struct frame_info *this_frame, void **this_cache)
   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;
diff --git a/gdb/amd64obsd-tdep.c b/gdb/amd64obsd-tdep.c
index 46bf7c5..4effa08 100644
--- a/gdb/amd64obsd-tdep.c
+++ b/gdb/amd64obsd-tdep.c
@@ -363,7 +363,7 @@ amd64obsd_trapframe_cache (struct frame_info *this_frame, void **this_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;
diff --git a/gdb/arm-linux-tdep.c b/gdb/arm-linux-tdep.c
index 46d59ba..b7c5b99 100644
--- a/gdb/arm-linux-tdep.c
+++ b/gdb/arm-linux-tdep.c
@@ -506,7 +506,7 @@ arm_linux_supply_gregset (const struct regset *regset,
 {
   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];
@@ -542,7 +542,7 @@ arm_linux_collect_gregset (const struct regset *regset,
 			   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++)
@@ -649,7 +649,7 @@ arm_linux_supply_nwfpe (const struct regset *regset,
 			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)
@@ -666,7 +666,7 @@ arm_linux_collect_nwfpe (const struct regset *regset,
 			 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++)
@@ -687,7 +687,7 @@ arm_linux_supply_vfp (const struct regset *regset,
 		      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)
@@ -704,7 +704,7 @@ arm_linux_collect_vfp (const struct regset *regset,
 			 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)
diff --git a/gdb/arm-tdep.c b/gdb/arm-tdep.c
index cb47fa76..4c99ddf 100644
--- a/gdb/arm-tdep.c
+++ b/gdb/arm-tdep.c
@@ -333,7 +333,8 @@ arm_find_mapping_symbol (CORE_ADDR memaddr, CORE_ADDR *start)
 					    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];
@@ -2028,7 +2029,7 @@ arm_prologue_unwind_stop_reason (struct frame_info *this_frame,
 
   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);
@@ -2056,7 +2057,7 @@ arm_prologue_this_id (struct frame_info *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),
@@ -2080,7 +2081,7 @@ arm_prologue_prev_register (struct frame_info *this_frame,
 
   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
@@ -2160,7 +2161,7 @@ struct arm_exidx_data
 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++)
@@ -2435,7 +2436,8 @@ arm_find_exidx_entry (CORE_ADDR memaddr, CORE_ADDR *start)
       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];
@@ -2960,7 +2962,7 @@ arm_stub_this_id (struct frame_info *this_frame,
 
   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));
 }
@@ -3054,7 +3056,7 @@ arm_m_exception_this_id (struct frame_info *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,
@@ -3074,7 +3076,7 @@ arm_m_exception_prev_register (struct frame_info *this_frame,
 
   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)
@@ -3127,7 +3129,7 @@ arm_normal_frame_base (struct frame_info *this_frame, void **this_cache)
 
   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;
 }
@@ -8770,7 +8772,7 @@ arm_displaced_step_fixup (struct gdbarch *gdbarch,
 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))
     {
@@ -9598,7 +9600,7 @@ arm_coff_make_msymbol_special(int val, struct minimal_symbol *msym)
 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++)
@@ -9618,7 +9620,8 @@ arm_record_special_symbol (struct gdbarch *gdbarch, struct objfile *objfile,
   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,
@@ -9822,7 +9825,7 @@ arm_pseudo_write (struct gdbarch *gdbarch, struct regcache *regcache,
 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);
 }
 
diff --git a/gdb/armbsd-tdep.c b/gdb/armbsd-tdep.c
index c043b51..1b9bad7 100644
--- a/gdb/armbsd-tdep.c
+++ b/gdb/armbsd-tdep.c
@@ -50,7 +50,7 @@ armbsd_supply_fpregset (const struct regset *regset,
 			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);
@@ -71,7 +71,7 @@ armbsd_supply_gregset (const struct regset *regset,
 		       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);
diff --git a/gdb/auto-load.c b/gdb/auto-load.c
index 119c673..49a8b61 100644
--- a/gdb/auto-load.c
+++ b/gdb/auto-load.c
@@ -580,7 +580,7 @@ static const struct program_space_data *auto_load_pspace_data;
 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);
@@ -597,7 +597,8 @@ get_auto_load_pspace_data (struct program_space *pspace)
 {
   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);
@@ -612,7 +613,7 @@ get_auto_load_pspace_data (struct program_space *pspace)
 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);
 }
@@ -622,8 +623,8 @@ hash_loaded_script_entry (const void *data)
 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;
 }
@@ -762,7 +763,8 @@ clear_section_scripts (void)
   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);
@@ -1249,8 +1251,9 @@ struct collect_matching_scripts_data
 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);
diff --git a/gdb/auxv.c b/gdb/auxv.c
index f99da36..1f22d8a 100644
--- a/gdb/auxv.c
+++ b/gdb/auxv.c
@@ -320,7 +320,7 @@ auxv_inferior_data_cleanup (struct inferior *inf, void *arg)
 {
   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);
@@ -355,7 +355,7 @@ get_auxv_inferior_data (struct target_ops *ops)
   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);
diff --git a/gdb/avr-tdep.c b/gdb/avr-tdep.c
index aaa2921..4fcae53 100644
--- a/gdb/avr-tdep.c
+++ b/gdb/avr-tdep.c
@@ -987,7 +987,7 @@ avr_frame_unwind_cache (struct frame_info *this_frame,
   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;
diff --git a/gdb/ax-general.c b/gdb/ax-general.c
index 49afee6..e5dc240 100644
--- a/gdb/ax-general.c
+++ b/gdb/ax-general.c
@@ -73,7 +73,7 @@ free_agent_expr (struct agent_expr *x)
 static void
 do_free_agent_expr_cleanup (void *x)
 {
-  free_agent_expr (x);
+  free_agent_expr ((struct agent_expr *) x);
 }
 
 struct cleanup *
diff --git a/gdb/bfd-target.c b/gdb/bfd-target.c
index b7cd8e6..ee93c3b 100644
--- a/gdb/bfd-target.c
+++ b/gdb/bfd-target.c
@@ -48,7 +48,7 @@ target_bfd_xfer_partial (struct target_ops *ops,
     {
     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,
@@ -63,14 +63,14 @@ target_bfd_xfer_partial (struct target_ops *ops,
 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);
diff --git a/gdb/bfin-tdep.c b/gdb/bfin-tdep.c
index 4532e1b..3afa7bc 100644
--- a/gdb/bfin-tdep.c
+++ b/gdb/bfin-tdep.c
@@ -292,7 +292,7 @@ bfin_frame_cache (struct frame_info *this_frame, void **this_cache)
   int i;
 
   if (*this_cache)
-    return *this_cache;
+    return (struct bfin_frame_cache *) *this_cache;
 
   cache = bfin_alloc_frame_cache ();
   *this_cache = cache;
diff --git a/gdb/block.c b/gdb/block.c
index 3195baa..a1fb3ad 100644
--- a/gdb/block.c
+++ b/gdb/block.c
@@ -140,7 +140,7 @@ find_block_in_blockvector (const struct blockvector *bl, CORE_ADDR pc)
   /* 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.
@@ -246,7 +246,7 @@ call_site_for_pc (struct gdbarch *gdbarch, CORE_ADDR pc)
 		    : MSYMBOL_PRINT_NAME (msym.minsym)));
     }
 
-  return *slot;
+  return (struct call_site *) *slot;
 }
 
 /* Return the blockvector immediately containing the innermost lexical block
@@ -870,7 +870,7 @@ block_find_non_opaque_type (struct symbol *sym, void *data)
 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;
diff --git a/gdb/break-catch-sig.c b/gdb/break-catch-sig.c
index 419d226..f117bd5 100644
--- a/gdb/break-catch-sig.c
+++ b/gdb/break-catch-sig.c
@@ -107,7 +107,7 @@ signal_catchpoint_dtor (struct breakpoint *b)
 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)
@@ -139,7 +139,7 @@ signal_catchpoint_insert_location (struct bp_location *bl)
 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)
@@ -180,7 +180,8 @@ signal_catchpoint_breakpoint_hit (const struct bp_location *bl,
 				  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)
@@ -238,7 +239,7 @@ static void
 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;
 
@@ -296,7 +297,7 @@ signal_catchpoint_print_one (struct breakpoint *b,
 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)
     {
@@ -330,7 +331,7 @@ signal_catchpoint_print_mention (struct breakpoint *b)
 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");
 
diff --git a/gdb/break-catch-syscall.c b/gdb/break-catch-syscall.c
index 1718f49..7ae115f 100644
--- a/gdb/break-catch-syscall.c
+++ b/gdb/break-catch-syscall.c
@@ -85,7 +85,8 @@ get_catch_syscall_inferior_data (struct inferior *inf)
 {
   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);
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index c09d56a..2c901ff 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -766,7 +766,7 @@ decref_counted_command_line (struct counted_command_line **cmdp)
 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
@@ -925,8 +925,8 @@ show_condition_evaluation_mode (struct ui_file *file, int from_tty,
 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;
@@ -951,9 +951,10 @@ get_first_locp_gte_addr (CORE_ADDR address)
   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)
@@ -1323,7 +1324,7 @@ breakpoint_set_task (struct breakpoint *b, int task)
 void
 check_tracepoint_command (char *line, void *closure)
 {
-  struct breakpoint *b = closure;
+  struct breakpoint *b = (struct breakpoint *) closure;
 
   validate_actionline (line, b);
 }
@@ -1354,7 +1355,7 @@ struct commands_info
 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)
     {
@@ -3393,7 +3394,8 @@ get_breakpoint_objfile_data (struct objfile *objfile)
 {
   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 =
@@ -3408,7 +3410,8 @@ get_breakpoint_objfile_data (struct objfile *objfile)
 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);
@@ -6651,7 +6654,8 @@ struct captured_breakpoint_query_args
 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;
 
@@ -11852,9 +11856,9 @@ tcatch_command (char *arg, int from_tty)
 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)
@@ -12074,8 +12078,8 @@ breakpoint_auto_delete (bpstat bs)
 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);
@@ -12676,7 +12680,7 @@ bpstat_remove_bp_location (bpstat bps, struct breakpoint *bpt)
 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;
@@ -13780,7 +13784,7 @@ delete_breakpoint (struct breakpoint *bpt)
 static void
 do_delete_breakpoint_cleanup (void *b)
 {
-  delete_breakpoint (b);
+  delete_breakpoint ((struct breakpoint *) b);
 }
 
 struct cleanup *
diff --git a/gdb/bsd-uthread.c b/gdb/bsd-uthread.c
index a5abb63..f9cb6d4 100644
--- a/gdb/bsd-uthread.c
+++ b/gdb/bsd-uthread.c
@@ -68,7 +68,9 @@ bsd_uthread_set_supply_uthread (struct gdbarch *gdbarch,
 				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;
 }
 
@@ -80,7 +82,9 @@ bsd_uthread_set_collect_uthread (struct gdbarch *gdbarch,
 			 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;
 }
 
@@ -161,7 +165,8 @@ static int
 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)
@@ -283,7 +288,8 @@ bsd_uthread_fetch_registers (struct target_ops *ops,
 			     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;
@@ -310,7 +316,8 @@ bsd_uthread_store_registers (struct target_ops *ops,
 			     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;
diff --git a/gdb/btrace.c b/gdb/btrace.c
index 4292dc7..da0b517 100644
--- a/gdb/btrace.c
+++ b/gdb/btrace.c
@@ -1384,7 +1384,8 @@ check_xml_btrace_version (struct gdb_xml_parser *parser,
 			  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);
@@ -1401,7 +1402,7 @@ parse_xml_btrace_block (struct gdb_xml_parser *parser,
   struct btrace_block *block;
   ULONGEST *begin, *end;
 
-  btrace = user_data;
+  btrace = (struct btrace_data *) user_data;
 
   switch (btrace->format)
     {
@@ -1417,8 +1418,8 @@ parse_xml_btrace_block (struct gdb_xml_parser *parser,
       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;
@@ -1477,12 +1478,12 @@ parse_xml_btrace_pt_config_cpu (struct gdb_xml_parser *parser,
   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;
@@ -1501,7 +1502,7 @@ parse_xml_btrace_pt_raw (struct gdb_xml_parser *parser,
 {
   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);
 }
@@ -1515,7 +1516,7 @@ parse_xml_btrace_pt (struct gdb_xml_parser *parser,
 {
   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;
@@ -1610,7 +1611,7 @@ parse_xml_btrace_conf_bts (struct gdb_xml_parser *parser,
   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;
 
@@ -1629,7 +1630,7 @@ parse_xml_btrace_conf_pt (struct gdb_xml_parser *parser,
   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;
 
@@ -2250,7 +2251,7 @@ btrace_is_empty (struct thread_info *tp)
 static void
 do_btrace_data_cleanup (void *arg)
 {
-  btrace_data_fini (arg);
+  btrace_data_fini ((struct btrace_data *) arg);
 }
 
 /* See btrace.h.  */
diff --git a/gdb/c-typeprint.c b/gdb/c-typeprint.c
index 708ace0..1af477c 100644
--- a/gdb/c-typeprint.c
+++ b/gdb/c-typeprint.c
@@ -50,7 +50,7 @@ static void c_type_print_modifier (struct type *,
 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,
diff --git a/gdb/charset.c b/gdb/charset.c
index afd9220..ee1ae20 100644
--- a/gdb/charset.c
+++ b/gdb/charset.c
@@ -468,7 +468,7 @@ host_hex_value (char c)
 static void
 cleanup_iconv (void *p)
 {
-  iconv_t *descp = p;
+  iconv_t *descp = (iconv_t *) p;
   iconv_close (*descp);
 }
 
@@ -617,7 +617,7 @@ make_wchar_iterator (const gdb_byte *input, size_t bytes,
 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);
diff --git a/gdb/cli-out.c b/gdb/cli-out.c
index 2a83169..df26d3b 100644
--- a/gdb/cli-out.c
+++ b/gdb/cli-out.c
@@ -44,7 +44,7 @@ static void out_field_fmt (struct ui_out *uiout, int fldno,
 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);
@@ -59,7 +59,7 @@ cli_table_begin (struct ui_out *uiout, int nbrofcols,
 		 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;
@@ -74,7 +74,7 @@ cli_table_begin (struct ui_out *uiout, int nbrofcols,
 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;
@@ -87,7 +87,7 @@ cli_table_body (struct ui_out *uiout)
 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;
 }
@@ -99,7 +99,7 @@ cli_table_header (struct ui_out *uiout, int width, enum ui_align alignment,
 		  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;
@@ -117,7 +117,7 @@ cli_begin (struct ui_out *uiout,
 	   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;
@@ -130,7 +130,7 @@ cli_end (struct ui_out *uiout,
 	 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;
@@ -144,7 +144,7 @@ cli_field_int (struct ui_out *uiout, int fldno, int width,
 	       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;
@@ -162,7 +162,7 @@ cli_field_skip (struct ui_out *uiout, int fldno, int width,
 		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;
@@ -185,7 +185,7 @@ cli_field_string (struct ui_out *uiout,
 {
   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;
@@ -233,7 +233,7 @@ cli_field_fmt (struct ui_out *uiout, int fldno,
 	       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)
@@ -249,7 +249,7 @@ cli_field_fmt (struct ui_out *uiout, int fldno,
 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)
@@ -262,7 +262,7 @@ cli_spaces (struct ui_out *uiout, int numspaces)
 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)
@@ -276,7 +276,7 @@ static void ATTRIBUTE_PRINTF (3, 0)
 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;
@@ -292,7 +292,7 @@ cli_message (struct ui_out *uiout, int verbosity,
 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;
@@ -302,7 +302,7 @@ cli_wrap_hint (struct ui_out *uiout, char *identstring)
 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);
@@ -315,7 +315,7 @@ cli_flush (struct ui_out *uiout)
 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);
@@ -336,7 +336,7 @@ out_field_fmt (struct ui_out *uiout, int fldno,
 	       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;
 
@@ -351,7 +351,7 @@ out_field_fmt (struct ui_out *uiout, int fldno,
 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);
@@ -409,7 +409,7 @@ cli_out_new (struct ui_file *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);
diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
index 424bf5e..6753c70 100644
--- a/gdb/cli/cli-cmds.c
+++ b/gdb/cli/cli-cmds.c
@@ -1554,8 +1554,8 @@ ambiguous_line_spec (struct symtabs_and_lines *sals)
 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;
diff --git a/gdb/cli/cli-dump.c b/gdb/cli/cli-dump.c
index aabe3e3..931bb4a 100644
--- a/gdb/cli/cli-dump.c
+++ b/gdb/cli/cli-dump.c
@@ -392,7 +392,7 @@ struct dump_context
 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);
 }
@@ -447,7 +447,7 @@ struct callback_data {
 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;
diff --git a/gdb/cli/cli-script.c b/gdb/cli/cli-script.c
index 624a493..6a3c068 100644
--- a/gdb/cli/cli-script.c
+++ b/gdb/cli/cli-script.c
@@ -307,7 +307,7 @@ print_command_lines (struct ui_out *uiout, struct command_line *cmd,
 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.  */
 }
@@ -341,7 +341,7 @@ execute_cmd_post_hook (struct cmd_list_element *c)
 static void
 do_restore_user_call_depth (void * call_depth)
 {	
-  int *depth = call_depth;
+  int *depth = (int *) call_depth;
 
   (*depth)--;
   if ((*depth) == 0)
@@ -1390,7 +1390,7 @@ free_command_lines (struct command_line **lptr)
 static void
 do_free_command_lines_cleanup (void *arg)
 {
-  free_command_lines (arg);
+  free_command_lines ((struct command_line **) arg);
 }
 
 struct cleanup *
diff --git a/gdb/coff-pe-read.c b/gdb/coff-pe-read.c
index 2d780b9..a7e4f2b 100644
--- a/gdb/coff-pe-read.c
+++ b/gdb/coff-pe-read.c
@@ -125,7 +125,7 @@ struct pe_sections_info
 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);
@@ -313,7 +313,7 @@ pe_get32 (bfd *abfd, int where)
 static unsigned int
 pe_as16 (void *ptr)
 {
-  unsigned char *b = ptr;
+  unsigned char *b = (unsigned char *) ptr;
 
   return b[0] + (b[1] << 8);
 }
@@ -321,7 +321,7 @@ pe_as16 (void *ptr)
 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);
 }
diff --git a/gdb/coffread.c b/gdb/coffread.c
index 9d20eebdc..ba94421 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -572,7 +572,8 @@ coff_symfile_read (struct objfile *objfile, int symfile_flags)
   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.  */
 
diff --git a/gdb/common/agent.c b/gdb/common/agent.c
index 5bb18641..5c30729 100644
--- a/gdb/common/agent.c
+++ b/gdb/common/agent.c
@@ -93,9 +93,10 @@ agent_look_up_symbols (void *arg)
     {
       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;
diff --git a/gdb/common/filestuff.c b/gdb/common/filestuff.c
index 4348527..798a411 100644
--- a/gdb/common/filestuff.c
+++ b/gdb/common/filestuff.c
@@ -410,7 +410,7 @@ gdb_pipe_cloexec (int filedes[2])
 static void
 do_close_cleanup (void *arg)
 {
-  int *fd = arg;
+  int *fd = (int *) arg;
 
   close (*fd);
 }
diff --git a/gdb/common/format.c b/gdb/common/format.c
index 52c6b81..65c1fb4 100644
--- a/gdb/common/format.c
+++ b/gdb/common/format.c
@@ -381,7 +381,7 @@ free_format_pieces (struct format_piece *pieces)
 void
 free_format_pieces_cleanup (void *ptr)
 {
-  void **location = ptr;
+  struct format_piece **location = (struct format_piece **) ptr;
 
   if (location == NULL)
     return;
diff --git a/gdb/common/vec.c b/gdb/common/vec.c
index ce7bc6e..6b7f25e 100644
--- a/gdb/common/vec.c
+++ b/gdb/common/vec.c
@@ -90,7 +90,7 @@ vec_p_reserve (void *vec, int reserve)
 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)
diff --git a/gdb/compile/compile-c-support.c b/gdb/compile/compile-c-support.c
index 39f06c6..07f0fbd 100644
--- a/gdb/compile/compile-c-support.c
+++ b/gdb/compile/compile-c-support.c
@@ -124,7 +124,7 @@ print_one_macro (const char *name, const struct macro_definition *macro,
 		 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.  */
diff --git a/gdb/compile/compile-c-symbols.c b/gdb/compile/compile-c-symbols.c
index 355b063..f5ca15c 100644
--- a/gdb/compile/compile-c-symbols.c
+++ b/gdb/compile/compile-c-symbols.c
@@ -51,7 +51,7 @@ struct symbol_error
 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);
 }
@@ -61,8 +61,8 @@ hash_symbol_error (const void *a)
 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;
 }
@@ -72,7 +72,7 @@ eq_symbol_error (const void *a, const void *b)
 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);
@@ -113,7 +113,7 @@ error_symbol_once (struct compile_c_instance *context,
     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;
 
@@ -421,7 +421,7 @@ gcc_convert_symbol (void *datum,
 		    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;
 
@@ -484,7 +484,7 @@ gcc_address
 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;
 
@@ -547,7 +547,7 @@ gcc_symbol_address (void *datum, struct gcc_c_context *gcc_context,
 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));
 }
@@ -558,8 +558,8 @@ hash_symname (const void *a)
 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;
 }
diff --git a/gdb/compile/compile-c-types.c b/gdb/compile/compile-c-types.c
index 77fbd68..60f9bd4 100644
--- a/gdb/compile/compile-c-types.c
+++ b/gdb/compile/compile-c-types.c
@@ -39,7 +39,7 @@ struct type_map_instance
 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);
 }
@@ -49,8 +49,8 @@ hash_type_map_instance (const void *p)
 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;
 }
@@ -75,7 +75,7 @@ insert_type (struct compile_c_instance *context, struct type *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)
@@ -386,7 +386,7 @@ convert_type (struct compile_c_instance *context, struct type *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;
 
diff --git a/gdb/compile/compile-object-load.c b/gdb/compile/compile-object-load.c
index ea1a19a..ce30e70 100644
--- a/gdb/compile/compile-object-load.c
+++ b/gdb/compile/compile-object-load.c
@@ -79,7 +79,7 @@ munmap_list_free (struct munmap_list *head)
 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);
 }
@@ -111,7 +111,7 @@ struct setup_sections_data
 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;
 
@@ -336,7 +336,8 @@ struct link_hash_table_cleanup_data
 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);
@@ -348,7 +349,7 @@ link_hash_table_free (void *d)
 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;
diff --git a/gdb/compile/compile-object-run.c b/gdb/compile/compile-object-run.c
index 6bc96b9..e5d2b643 100644
--- a/gdb/compile/compile-object-run.c
+++ b/gdb/compile/compile-object-run.c
@@ -61,7 +61,7 @@ static dummy_frame_dtor_ftype do_module_cleanup;
 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)
diff --git a/gdb/compile/compile.c b/gdb/compile/compile.c
index 3d710ed..7560028 100644
--- a/gdb/compile/compile.c
+++ b/gdb/compile/compile.c
@@ -169,7 +169,7 @@ compile_code_command (char *arg, int from_tty)
 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);
 }
@@ -214,7 +214,7 @@ compile_print_command (char *arg_param, int from_tty)
 static void
 do_rmdir (void *arg)
 {
-  const char *dir = arg;
+  const char *dir = (const char *) arg;
   char *zap;
   int wstat;
 
@@ -431,7 +431,7 @@ get_args (const struct compile_instance *compiler, struct gdbarch *gdbarch,
 static void
 cleanup_compile_instance (void *arg)
 {
-  struct compile_instance *inst = arg;
+  struct compile_instance *inst = (struct compile_instance *) arg;
 
   inst->destroy (inst);
 }
@@ -441,7 +441,7 @@ cleanup_compile_instance (void *arg)
 static void
 cleanup_unlink_file (void *arg)
 {
-  const char *filename = arg;
+  const char *filename = (const char *) arg;
 
   unlink (filename);
 }
diff --git a/gdb/completer.c b/gdb/completer.c
index f13289a..210a078 100644
--- a/gdb/completer.c
+++ b/gdb/completer.c
@@ -985,7 +985,7 @@ new_completion_tracker (void)
 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;
diff --git a/gdb/corelow.c b/gdb/corelow.c
index 5462e02..f7a8bb3 100644
--- a/gdb/corelow.c
+++ b/gdb/corelow.c
@@ -656,7 +656,7 @@ struct spuid_list
 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;
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index acd4845..989544b 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -343,7 +343,7 @@ cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
 static void
 reset_directive_searched (void *data)
 {
-  struct using_direct *direct = data;
+  struct using_direct *direct = (struct using_direct *) data;
   direct->searched = 0;
 }
 
diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index 0e3c948..a14455a 100644
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -1339,7 +1339,7 @@ make_symbol_overload_list_adl (struct type **arg_types, int nargs,
 static void
 reset_directive_searched (void *data)
 {
-  struct using_direct *direct = data;
+  struct using_direct *direct = (struct using_direct *) data;
   direct->searched = 0;
 }
 
diff --git a/gdb/cris-tdep.c b/gdb/cris-tdep.c
index 88a6441..73e4048 100644
--- a/gdb/cris-tdep.c
+++ b/gdb/cris-tdep.c
@@ -320,7 +320,7 @@ cris_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
   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;
@@ -704,7 +704,7 @@ cris_frame_unwind_cache (struct frame_info *this_frame,
   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;
diff --git a/gdb/d-lang.c b/gdb/d-lang.c
index 2fc5080..0fbc2fa 100644
--- a/gdb/d-lang.c
+++ b/gdb/d-lang.c
@@ -322,7 +322,7 @@ static struct gdbarch_data *d_type_data;
 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.  */
diff --git a/gdb/d-namespace.c b/gdb/d-namespace.c
index e142e11..9e00710 100644
--- a/gdb/d-namespace.c
+++ b/gdb/d-namespace.c
@@ -356,7 +356,7 @@ d_lookup_nested_symbol (struct type *parent_type,
 static void
 reset_directive_searched (void *data)
 {
-  struct using_direct *direct = data;
+  struct using_direct *direct = (struct using_direct *) data;
   direct->searched = 0;
 }
 
diff --git a/gdb/dbxread.c b/gdb/dbxread.c
index 1f003b2..7f422ad 100644
--- a/gdb/dbxread.c
+++ b/gdb/dbxread.c
@@ -729,7 +729,7 @@ dbx_symfile_finish (struct objfile *objfile)
 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)
     {
@@ -942,7 +942,7 @@ free_bincl_list (struct objfile *objfile)
 static void
 do_free_bincl_list_cleanup (void *objfile)
 {
-  free_bincl_list (objfile);
+  free_bincl_list ((struct objfile *) objfile);
 }
 
 static struct cleanup *
diff --git a/gdb/disasm.c b/gdb/disasm.c
index 2b65c6a..6e3d6c1 100644
--- a/gdb/disasm.c
+++ b/gdb/disasm.c
@@ -59,7 +59,7 @@ struct dis_line_entry
 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;
 }
@@ -69,8 +69,8 @@ hash_dis_line_entry (const void *item)
 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);
@@ -139,9 +139,9 @@ dis_asm_memory_error (int status, bfd_vma memaddr,
 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
@@ -713,7 +713,7 @@ fprintf_disasm (void *stream, const char *format, ...)
   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;
@@ -806,7 +806,7 @@ gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
 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
diff --git a/gdb/doublest.c b/gdb/doublest.c
index e8e39af..0babb10 100644
--- a/gdb/doublest.c
+++ b/gdb/doublest.c
@@ -183,7 +183,7 @@ convert_floatformat_to_doublest (const struct floatformat *fmt,
   /* 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;
diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c
index b6993a2..2aacf5b 100644
--- a/gdb/dummy-frame.c
+++ b/gdb/dummy-frame.c
@@ -128,7 +128,7 @@ remove_dummy_frame (struct dummy_frame **dummy_ptr)
 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))
@@ -337,7 +337,8 @@ dummy_frame_prev_register (struct frame_info *this_frame,
 			   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;
 
@@ -367,7 +368,8 @@ dummy_frame_this_id (struct frame_info *this_frame,
 		     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;
diff --git a/gdb/dwarf2-frame-tailcall.c b/gdb/dwarf2-frame-tailcall.c
index e4a8112..952bc14 100644
--- a/gdb/dwarf2-frame-tailcall.c
+++ b/gdb/dwarf2-frame-tailcall.c
@@ -68,7 +68,7 @@ struct tailcall_cache
 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);
 }
@@ -78,8 +78,8 @@ cache_hash (const void *arg)
 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;
 }
@@ -160,7 +160,7 @@ cache_find (struct frame_info *fi)
   if (slot == NULL)
     return NULL;
 
-  cache = *slot;
+  cache = (struct tailcall_cache *) *slot;
   gdb_assert (cache != NULL);
   return cache;
 }
@@ -209,7 +209,7 @@ static void
 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.  */
@@ -264,7 +264,7 @@ dwarf2_tailcall_prev_register_first (struct frame_info *this_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))
@@ -293,7 +293,7 @@ static struct value *
 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);
@@ -430,7 +430,7 @@ dwarf2_tailcall_sniffer_first (struct frame_info *this_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);
 }
@@ -442,7 +442,7 @@ static struct gdbarch *
 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);
 }
diff --git a/gdb/dwarf2-frame.c b/gdb/dwarf2-frame.c
index 0613d06..200b044 100644
--- a/gdb/dwarf2-frame.c
+++ b/gdb/dwarf2-frame.c
@@ -275,7 +275,7 @@ dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
 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);
@@ -782,7 +782,8 @@ dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
 					     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;
 }
@@ -794,7 +795,8 @@ dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
 		       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);
 }
@@ -807,7 +809,8 @@ dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
 				 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;
 }
@@ -819,7 +822,8 @@ static int
 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;
@@ -834,7 +838,8 @@ dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
 				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;
 }
@@ -846,7 +851,8 @@ static int
 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;
@@ -1010,7 +1016,7 @@ struct dwarf2_frame_cache
 static void
 clear_pointer_cleanup (void *arg)
 {
-  void **ptr = arg;
+  void **ptr = (void **) arg;
 
   *ptr = NULL;
 }
@@ -1029,7 +1035,7 @@ dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
   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);
@@ -1720,8 +1726,9 @@ find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
       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;
@@ -1770,11 +1777,13 @@ dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
       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);
 
@@ -1789,8 +1798,9 @@ dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
         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;
diff --git a/gdb/dwarf2expr.c b/gdb/dwarf2expr.c
index 819a5f1..2ac60b7 100644
--- a/gdb/dwarf2expr.c
+++ b/gdb/dwarf2expr.c
@@ -64,8 +64,9 @@ dwarf_gdbarch_types_init (struct gdbarch *gdbarch)
 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)
@@ -119,7 +120,7 @@ free_dwarf_expr_context (struct dwarf_expr_context *ctx)
 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.  */
diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c
index c2c0c59..3e652f9 100644
--- a/gdb/dwarf2loc.c
+++ b/gdb/dwarf2loc.c
@@ -375,7 +375,8 @@ static void
 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;
@@ -401,7 +402,7 @@ locexpr_get_frame_base (struct symbol *framefunc, struct frame_info *frame)
 
   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);
@@ -432,7 +433,8 @@ static void
 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);
 }
@@ -457,7 +459,7 @@ loclist_get_frame_base (struct symbol *framefunc, struct frame_info *frame)
 
   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);
@@ -559,7 +561,7 @@ per_cu_dwarf_call (struct dwarf_expr_context *ctx, cu_offset die_offset,
 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);
@@ -571,7 +573,7 @@ static struct type *
 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);
 }
@@ -1263,7 +1265,7 @@ dwarf_expr_push_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
   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);
 
@@ -1315,7 +1317,7 @@ dwarf_expr_get_addr_index (void *baton, unsigned int index)
 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);
 
@@ -1338,7 +1340,7 @@ entry_data_value_coerce_ref (const struct value *value)
   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;
 }
@@ -1348,7 +1350,7 @@ entry_data_value_coerce_ref (const struct value *value)
 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;
@@ -1359,7 +1361,7 @@ entry_data_value_copy_closure (const struct value *v)
 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);
 }
@@ -2068,7 +2070,7 @@ check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
 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
@@ -2549,7 +2551,8 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,
     {
     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,
@@ -2568,7 +2571,8 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,
 
     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;
@@ -2594,7 +2598,8 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,
 
     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;
 
@@ -2629,7 +2634,8 @@ dwarf2_compile_property_to_c (struct ui_file *stream,
 			      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;
@@ -2667,7 +2673,7 @@ struct needs_frame_baton
 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;
@@ -2679,7 +2685,7 @@ needs_frame_read_addr_from_reg (void *baton, int regnum)
 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);
@@ -2697,7 +2703,7 @@ static void
 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;
@@ -2710,7 +2716,7 @@ needs_frame_frame_base (void *baton, const gdb_byte **start, size_t * length)
 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;
@@ -2720,7 +2726,7 @@ needs_frame_frame_cfa (void *baton)
 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;
@@ -2731,7 +2737,7 @@ needs_frame_tls_address (void *baton, CORE_ADDR offset)
 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);
@@ -2744,7 +2750,7 @@ needs_dwarf_reg_entry_value (struct dwarf_expr_context *ctx,
 			     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;
 
@@ -2911,7 +2917,7 @@ access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
 static CORE_ADDR
 get_ax_pc (void *baton)
 {
-  struct agent_expr *expr = baton;
+  struct agent_expr *expr = (struct agent_expr *) baton;
 
   return expr->scope;
 }
@@ -3601,7 +3607,8 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
 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,
@@ -3617,7 +3624,8 @@ locexpr_read_variable (struct symbol *symbol, struct frame_info *frame)
 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);
@@ -3627,7 +3635,8 @@ locexpr_read_variable_at_entry (struct symbol *symbol, struct frame_info *frame)
 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);
@@ -4292,7 +4301,8 @@ static void
 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);
@@ -4310,7 +4320,8 @@ static void
 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)
@@ -4329,7 +4340,8 @@ locexpr_generate_c_location (struct symbol *sym, struct ui_file *stream,
 			     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)
@@ -4362,7 +4374,8 @@ const struct symbol_computed_ops dwarf2_locexpr_funcs = {
 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;
@@ -4386,7 +4399,8 @@ loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
 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;
@@ -4422,7 +4436,8 @@ static void
 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);
@@ -4511,7 +4526,8 @@ static void
 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);
@@ -4532,7 +4548,8 @@ loclist_generate_c_location (struct symbol *sym, struct ui_file *stream,
 			     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;
diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 4aa2f6d..5b12342 100644
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -1962,7 +1962,7 @@ line_header_hash (const struct line_header *ofs)
 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);
 }
@@ -1972,8 +1972,8 @@ line_header_hash_voidp (const void *item)
 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);
@@ -2043,7 +2043,8 @@ int
 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.  */
@@ -2376,7 +2377,8 @@ dwarf2_get_section_info (struct objfile *objfile,
                          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
@@ -2412,7 +2414,7 @@ dwarf2_get_section_info (struct objfile *objfile,
 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).  */
@@ -2609,7 +2611,8 @@ eq_stmt_list_entry (const struct stmt_list_hash *lhs,
 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);
 }
@@ -2619,8 +2622,8 @@ hash_file_name_entry (const void *e)
 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);
 }
@@ -2630,7 +2633,7 @@ eq_file_name_entry (const void *a, const void *b)
 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)
@@ -3245,7 +3248,8 @@ dwarf2_read_index (struct objfile *objfile)
 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);
 }
 
@@ -3300,7 +3304,7 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
 			     &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;
 	}
 
@@ -4092,7 +4096,8 @@ dw2_find_pc_sect_compunit_symtab (struct objfile *objfile,
   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;
 
@@ -4550,7 +4555,8 @@ dwarf2_build_include_psymtabs (struct dwarf2_cu *cu,
 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;
@@ -4559,8 +4565,8 @@ hash_signatured_type (const void *item)
 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;
 }
@@ -4584,8 +4590,8 @@ allocate_signatured_type_table (struct objfile *objfile)
 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;
@@ -4723,13 +4729,15 @@ create_debug_types_hash_table (struct dwo_file *dwo_file,
 
 	      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;
 		}
@@ -4908,7 +4916,7 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
   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
@@ -4930,7 +4938,7 @@ lookup_dwo_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
   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;
 
@@ -4971,7 +4979,7 @@ lookup_dwp_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
   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
@@ -5016,7 +5024,8 @@ lookup_signatured_type (struct dwarf2_cu *cu, ULONGEST sig)
       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;
     }
 }
@@ -5741,7 +5750,8 @@ init_cutu_and_read_dies_simple (struct dwarf2_per_cu_data *this_cu,
 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);
 }
@@ -5749,8 +5759,8 @@ hash_type_unit_group (const void *item)
 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);
 }
@@ -5864,7 +5874,7 @@ get_type_unit_group (struct dwarf2_cu *cu, const struct attribute *stmt_list)
 			 &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
@@ -5940,7 +5950,8 @@ process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
   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;
@@ -6139,8 +6150,10 @@ struct tu_abbrev_offset
 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;
 
@@ -6329,7 +6342,7 @@ static int
 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.  */
@@ -6399,7 +6412,7 @@ process_skeletonless_type_units (struct objfile *objfile)
 static void
 psymtabs_addrmap_cleanup (void *o)
 {
-  struct objfile *objfile = o;
+  struct objfile *objfile = (struct objfile *) o;
 
   objfile->psymtabs_addrmap = NULL;
 }
@@ -7407,7 +7420,9 @@ dwarf2_read_symtab (struct partial_symtab *self,
 	}
 
       /* 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
@@ -7416,8 +7431,9 @@ dwarf2_read_symtab (struct partial_symtab *self,
       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;
@@ -7637,7 +7653,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst)
         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)
     {
@@ -7656,7 +7672,7 @@ psymtab_to_symtab_1 (struct partial_symtab *pst)
 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;
 }
@@ -7667,8 +7683,8 @@ die_hash (const void *item)
 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;
 }
@@ -7685,7 +7701,7 @@ load_full_comp_unit_reader (const struct die_reader_specs *reader,
 			    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 =
@@ -8218,7 +8234,7 @@ process_imported_unit_die (struct die_info *die, struct dwarf2_cu *cu)
 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;
 }
@@ -9016,7 +9032,7 @@ read_import_statement (struct die_info *die, struct dwarf2_cu *cu)
 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;
@@ -9127,7 +9143,7 @@ handle_DW_AT_stmt_list (struct die_info *die, struct dwarf2_cu *cu,
       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;
 	}
     }
@@ -9401,7 +9417,7 @@ read_type_unit_scope (struct die_info *die, struct dwarf2_cu *cu)
 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);
@@ -9413,8 +9429,8 @@ hash_dwo_file (const void *item)
 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;
@@ -9461,7 +9477,7 @@ lookup_dwo_file_slot (const char *dwo_name, const char *comp_dir)
 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;
@@ -9470,8 +9486,8 @@ hash_dwo_unit (const void *item)
 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,
@@ -9518,7 +9534,7 @@ create_dwo_cu_reader (const struct die_reader_specs *reader,
   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;
@@ -10135,7 +10151,7 @@ create_dwo_unit_in_dwp_v1 (struct dwp_file *dwp_file,
 	  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);
 
@@ -10350,7 +10366,7 @@ create_dwo_unit_in_dwp_v2 (struct dwp_file *dwp_file,
 	  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);
 
@@ -10394,7 +10410,7 @@ lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir,
 			 &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)
@@ -10421,7 +10437,7 @@ lookup_dwo_unit_in_dwp (struct dwp_file *dwp_file, const char *comp_dir,
 						 comp_dir, signature,
 						 is_debug_types);
 	    }
-	  return *slot;
+	  return (struct dwo_unit *) *slot;
 	}
       if (signature_in_table == 0)
 	return NULL;
@@ -10542,7 +10558,7 @@ open_dwo_file (const char *file_name, const char *comp_dir)
 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))
@@ -10647,7 +10663,7 @@ static void
 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;
 
@@ -10682,7 +10698,7 @@ dwarf2_locate_common_dwp_sections (bfd *abfd, asection *sectp,
 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;
 
@@ -10739,7 +10755,7 @@ dwarf2_locate_v2_dwp_sections (bfd *abfd, asection *sectp, void *dwp_file_ptr)
 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;
@@ -10750,8 +10766,8 @@ hash_dwp_loaded_cutus (const void *item)
 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;
 }
@@ -10969,7 +10985,7 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
 	  *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)
 	{
@@ -10981,7 +10997,8 @@ lookup_dwo_cutu (struct dwarf2_per_cu_data *this_unit,
 
 	      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)
 	    {
@@ -15424,7 +15441,7 @@ abbrev_table_free (struct abbrev_table *abbrev_table)
 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);
@@ -15446,7 +15463,7 @@ dwarf2_read_abbrevs (struct dwarf2_cu *cu,
 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);
@@ -15988,8 +16005,9 @@ find_partial_die_in_comp_unit (sect_offset offset, struct dwarf2_cu *cu)
   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;
 }
@@ -17187,7 +17205,7 @@ free_line_header (struct line_header *lh)
 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);
 }
@@ -20006,7 +20024,8 @@ follow_die_offset (sect_offset offset, int offset_in_dwz,
 
   *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.
@@ -20312,8 +20331,8 @@ follow_die_sig_1 (struct die_info *src_die, struct signatured_type *sig_type,
   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.
@@ -22103,7 +22122,7 @@ prepare_one_comp_unit (struct dwarf2_cu *cu, struct die_info *comp_unit_die,
 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;
@@ -22121,7 +22140,7 @@ free_heap_comp_unit (void *data)
 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;
@@ -22225,7 +22244,9 @@ free_one_cached_comp_unit (struct dwarf2_per_cu_data *target_per_cu)
 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;
@@ -22268,7 +22289,8 @@ struct dwarf2_per_cu_offset_and_type
 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;
 }
@@ -22278,8 +22300,10 @@ per_cu_offset_and_type_hash (const void *item)
 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);
@@ -22373,7 +22397,8 @@ get_die_type_at_offset (sect_offset offset,
 
   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
@@ -22465,7 +22490,8 @@ dwarf2_clear_marks (struct dwarf2_per_cu_data *per_cu)
 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;
 }
@@ -22476,8 +22502,10 @@ partial_die_hash (const void *item)
 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;
 }
@@ -22503,7 +22531,7 @@ show_dwarf_cmd (char *args, int from_tty)
 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
@@ -22548,7 +22576,7 @@ struct strtab_entry
 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);
 }
 
@@ -22557,8 +22585,8 @@ hash_strtab_entry (const void *e)
 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);
 }
 
@@ -22584,7 +22612,7 @@ add_string (htab_t table, struct obstack *cpool, const char *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);
@@ -22621,7 +22649,8 @@ struct mapped_symtab
 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),
@@ -22633,8 +22662,8 @@ hash_symtab_entry (const void *e)
 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;
@@ -22648,7 +22677,7 @@ eq_symtab_entry (const void *a, const void *b)
 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);
 }
@@ -22679,7 +22708,7 @@ create_mapped_symtab (void)
 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);
@@ -22856,7 +22885,8 @@ add_indices_to_cpool (htab_t symbol_hash_table, struct obstack *cpool,
     }
   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;
     }
@@ -22924,7 +22954,8 @@ struct psymtab_cu_index_map
 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);
 }
@@ -22932,8 +22963,10 @@ hash_psymtab_cu_index (const void *item)
 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;
 }
@@ -22980,8 +23013,8 @@ add_address_entry (struct objfile *objfile, struct obstack *obstack,
 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,
@@ -22993,7 +23026,8 @@ add_address_entry_worker (void *datap, CORE_ADDR start_addr, void *obj)
     {
       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;
@@ -23123,7 +23157,7 @@ write_obstack (FILE *file, struct obstack *obstack)
 static void
 unlink_if_set (void *p)
 {
-  char **filename = p;
+  char **filename = (char **) p;
   if (*filename)
     unlink (*filename);
 }
@@ -23144,7 +23178,8 @@ struct signatured_type_index_data
 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];
@@ -23411,7 +23446,9 @@ save_gdb_index_command (char *arg, int from_tty)
     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)
       {
 
diff --git a/gdb/elfread.c b/gdb/elfread.c
index a018cdd..138d316 100644
--- a/gdb/elfread.c
+++ b/gdb/elfread.c
@@ -338,8 +338,9 @@ elf_symtab_read (struct objfile *objfile, int type,
 	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;
@@ -638,7 +639,8 @@ struct elf_gnu_ifunc_cache
 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);
 }
@@ -648,8 +650,10 @@ elf_gnu_ifunc_cache_hash (const void *a_voidp)
 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;
 }
@@ -687,7 +691,7 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
   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,
@@ -708,7 +712,8 @@ elf_gnu_ifunc_record_cache (const char *name, CORE_ADDR addr)
   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)
@@ -747,7 +752,7 @@ elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p)
       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;
 
@@ -758,7 +763,7 @@ elf_gnu_ifunc_resolve_by_cache (const char *name, CORE_ADDR *addr_p)
       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)
@@ -1326,7 +1331,7 @@ elf_get_probes (struct objfile *objfile)
   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)
     {
@@ -1358,7 +1363,7 @@ static void
 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++)
diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index e4deeb9..9101330 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -343,7 +343,7 @@ static struct gdbarch_data *f_type_data;
 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
diff --git a/gdb/frame-base.c b/gdb/frame-base.c
index 47327ca..d91cd42 100644
--- a/gdb/frame-base.c
+++ b/gdb/frame-base.c
@@ -82,7 +82,8 @@ 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);
@@ -94,7 +95,8 @@ void
 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;
 }
@@ -103,7 +105,8 @@ const struct frame_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)
diff --git a/gdb/frame-unwind.c b/gdb/frame-unwind.c
index bba1ae7..586aa4f 100644
--- a/gdb/frame-unwind.c
+++ b/gdb/frame-unwind.c
@@ -64,7 +64,8 @@ void
 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.  */
@@ -78,7 +79,8 @@ void
 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.  */
@@ -140,7 +142,8 @@ void
 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;
 
diff --git a/gdb/frame.c b/gdb/frame.c
index 8b804cd..93bb7f6 100644
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -162,7 +162,7 @@ static htab_t frame_stash;
 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;
 
@@ -189,8 +189,8 @@ frame_addr_hash (const void *ap)
 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);
@@ -246,7 +246,7 @@ frame_stash_find (struct frame_id id)
   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;
 }
 
@@ -930,7 +930,7 @@ get_frame_func (struct frame_info *this_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;
@@ -1447,7 +1447,7 @@ frame_obstack_zalloc (unsigned long size)
 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.  */
@@ -2703,7 +2703,7 @@ frame_stop_reason_symbol_string (enum unwind_stop_reason reason)
 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.  */
diff --git a/gdb/frv-linux-tdep.c b/gdb/frv-linux-tdep.c
index 8775d19..6950b6c 100644
--- a/gdb/frv-linux-tdep.c
+++ b/gdb/frv-linux-tdep.c
@@ -271,7 +271,7 @@ frv_linux_sigtramp_frame_cache (struct frame_info *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);
 
diff --git a/gdb/frv-tdep.c b/gdb/frv-tdep.c
index 19ff87e..984c6e8 100644
--- a/gdb/frv-tdep.c
+++ b/gdb/frv-tdep.c
@@ -1099,7 +1099,7 @@ frv_frame_unwind_cache (struct frame_info *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;
diff --git a/gdb/ft32-tdep.c b/gdb/ft32-tdep.c
index 7c6efbb..e834279 100644
--- a/gdb/ft32-tdep.c
+++ b/gdb/ft32-tdep.c
@@ -436,7 +436,7 @@ ft32_frame_cache (struct frame_info *this_frame, void **this_cache)
   int i;
 
   if (*this_cache)
-    return *this_cache;
+    return (struct ft32_frame_cache *) *this_cache;
 
   cache = ft32_alloc_frame_cache ();
   *this_cache = cache;
diff --git a/gdb/gcore.c b/gdb/gcore.c
index 44b9d0c..a883e89 100644
--- a/gdb/gcore.c
+++ b/gdb/gcore.c
@@ -137,10 +137,10 @@ write_gcore_file (bfd *obfd)
 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);
 }
 
@@ -417,7 +417,7 @@ static int
 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;
 
diff --git a/gdb/gdb_bfd.c b/gdb/gdb_bfd.c
index af5560d..c45ebe3 100644
--- a/gdb/gdb_bfd.c
+++ b/gdb/gdb_bfd.c
@@ -155,7 +155,7 @@ struct gdb_bfd_cache_search
 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));
@@ -167,9 +167,10 @@ hash_bfd (const void *b)
 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
@@ -417,7 +418,7 @@ gdb_bfd_open (const char *name, const char *target, int fd)
   /* 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)
@@ -457,7 +458,8 @@ gdb_bfd_open (const char *name, const char *target, int fd)
 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)
     {
@@ -506,7 +508,7 @@ gdb_bfd_ref (struct bfd *abfd)
   if (abfd == NULL)
     return;
 
-  gdata = bfd_usrdata (abfd);
+  gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
 
   if (debug_bfd_cache)
     fprintf_unfiltered (gdb_stdlog,
@@ -563,7 +565,7 @@ gdb_bfd_unref (struct bfd *abfd)
   if (abfd == NULL)
     return;
 
-  gdata = bfd_usrdata (abfd);
+  gdata = (struct gdb_bfd_data *) bfd_usrdata (abfd);
   gdb_assert (gdata->refc >= 1);
 
   gdata->refc -= 1;
@@ -627,7 +629,8 @@ get_section_descriptor (asection *section)
 {
   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)
     {
@@ -710,7 +713,7 @@ gdb_bfd_map_section (asection *sectp, bfd_size_type *size)
  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
@@ -755,7 +758,7 @@ get_file_crc (bfd *abfd, unsigned long *file_crc_return)
 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);
@@ -846,7 +849,7 @@ gdb_bfd_mark_parent (bfd *child, bfd *parent)
   /* 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;
@@ -877,7 +880,7 @@ gdb_bfd_record_inclusion (bfd *includer, bfd *includee)
   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);
 }
 
@@ -929,7 +932,7 @@ gdb_bfd_count_sections (bfd *abfd)
 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)
     {
@@ -955,9 +958,9 @@ gdb_bfd_requires_relocations (bfd *abfd)
 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);
diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog
index d6ce174..95e370c 100644
--- a/gdb/gdbserver/ChangeLog
+++ b/gdb/gdbserver/ChangeLog
@@ -1,5 +1,23 @@
 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.
diff --git a/gdb/gdbserver/dll.c b/gdb/gdbserver/dll.c
index c4f838c..608cf23 100644
--- a/gdb/gdbserver/dll.c
+++ b/gdb/gdbserver/dll.c
@@ -41,8 +41,8 @@ free_one_dll (struct inferior_list_entry *inf)
 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)
@@ -83,7 +83,7 @@ unloaded_dll (const char *name, CORE_ADDR 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
diff --git a/gdb/gdbserver/linux-low.c b/gdb/gdbserver/linux-low.c
index 12a2332..3a1a6ae 100644
--- a/gdb/gdbserver/linux-low.c
+++ b/gdb/gdbserver/linux-low.c
@@ -1089,7 +1089,7 @@ struct counter
 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)
     {
@@ -1429,7 +1429,7 @@ delete_lwp_callback (struct inferior_list_entry *entry, void *proc)
 {
   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);
@@ -2633,7 +2633,7 @@ count_events_callback (struct inferior_list_entry *entry, void *data)
 {
   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);
 
@@ -2668,7 +2668,7 @@ select_event_lwp_callback (struct inferior_list_entry *entry, void *data)
 {
   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);
 
@@ -4152,7 +4152,7 @@ linux_set_resume_request (struct inferior_list_entry *entry, void *arg)
   int ndx;
   struct thread_resume_array *r;
 
-  r = arg;
+  r = (struct thread_resume_array *) arg;
 
   for (ndx = 0; ndx < r->n; ndx++)
     {
diff --git a/gdb/gdbserver/server.c b/gdb/gdbserver/server.c
index 53763e5..e25b7c7 100644
--- a/gdb/gdbserver/server.c
+++ b/gdb/gdbserver/server.c
@@ -1280,7 +1280,7 @@ static void
 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.  */
@@ -1294,7 +1294,7 @@ static void
 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;
 
@@ -1450,7 +1450,7 @@ static void
 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);
@@ -2459,7 +2459,8 @@ struct visit_actioned_threads_data
 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;
diff --git a/gdb/gdbserver/thread-db.c b/gdb/gdbserver/thread-db.c
index f5fdf10..ffe722d 100644
--- a/gdb/gdbserver/thread-db.c
+++ b/gdb/gdbserver/thread-db.c
@@ -874,7 +874,7 @@ thread_db_init (int use_events)
 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;
diff --git a/gdb/gdbserver/tracepoint.c b/gdb/gdbserver/tracepoint.c
index 1b3a5d0..b6c70c9 100644
--- a/gdb/gdbserver/tracepoint.c
+++ b/gdb/gdbserver/tracepoint.c
@@ -3947,7 +3947,7 @@ cmd_qtstmat (char *packet)
 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;
 }
@@ -5066,7 +5066,7 @@ agent_tsv_read (struct eval_agent_expr_context *ctx, int n)
 static int
 match_blocktype (char blocktype, unsigned char *dataptr, void *data)
 {
-  char *wantedp = data;
+  char *wantedp = (char *) data;
 
   if (*wantedp == blocktype)
     return 1;
@@ -5412,7 +5412,7 @@ traceframe_read_sdata (int tfnum, ULONGEST offset,
 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)
     {
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 063dcf2..b406550 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -4308,7 +4308,7 @@ struct type_pair
 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);
 }
@@ -4316,7 +4316,8 @@ type_pair_hash (const void *item)
 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;
 }
@@ -4780,7 +4781,7 @@ static struct gdbarch_data *gdbtypes_data;
 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 *
@@ -4925,7 +4926,7 @@ objfile_type (struct objfile *objfile)
 {
   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;
diff --git a/gdb/gnu-v3-abi.c b/gdb/gnu-v3-abi.c
index b493112..b962cd3 100644
--- a/gdb/gnu-v3-abi.c
+++ b/gdb/gnu-v3-abi.c
@@ -174,7 +174,8 @@ build_gdb_vtable_type (struct gdbarch *arch)
 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);
@@ -186,7 +187,8 @@ vtable_ptrdiff_type (struct gdbarch *gdbarch)
 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);
@@ -246,8 +248,8 @@ static struct value *
 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;
@@ -778,7 +780,7 @@ DEF_VEC_P (value_and_voffset_p);
 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);
 }
@@ -788,8 +790,8 @@ hash_value_and_voffset (const void *p)
 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));
@@ -800,10 +802,12 @@ eq_value_and_voffset (const void *a, const void *b)
 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));
 
@@ -841,7 +845,7 @@ compute_vtable_size (htab_t offset_hash,
   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);
@@ -1064,7 +1068,8 @@ gnuv3_get_typeid_type (struct gdbarch *gdbarch)
   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);
 
diff --git a/gdb/go-lang.c b/gdb/go-lang.c
index 509704c..f6d731b 100644
--- a/gdb/go-lang.c
+++ b/gdb/go-lang.c
@@ -655,7 +655,7 @@ static struct gdbarch_data *go_type_data;
 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;
diff --git a/gdb/guile/scm-block.c b/gdb/guile/scm-block.c
index c4b367f..87dbd1a 100644
--- a/gdb/guile/scm-block.c
+++ b/gdb/guile/scm-block.c
@@ -85,7 +85,7 @@ static const struct objfile_data *bkscm_objfile_data_key;
 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);
 }
@@ -95,8 +95,8 @@ bkscm_hash_block_smob (const void *p)
 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);
@@ -108,7 +108,7 @@ bkscm_eq_block_smob (const void *ap, const void *bp)
 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)
     {
@@ -347,7 +347,7 @@ bkscm_mark_block_invalid (void **slot, void *info)
 static void
 bkscm_del_objfile_blocks (struct objfile *objfile, void *datum)
 {
-  htab_t htab = datum;
+  htab_t htab = (htab_t) datum;
 
   if (htab != NULL)
     {
diff --git a/gdb/guile/scm-breakpoint.c b/gdb/guile/scm-breakpoint.c
index eea9b46..83574a3 100644
--- a/gdb/guile/scm-breakpoint.c
+++ b/gdb/guile/scm-breakpoint.c
@@ -509,7 +509,7 @@ gdbscm_delete_breakpoint_x (SCM self)
 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.  */
diff --git a/gdb/guile/scm-disasm.c b/gdb/guile/scm-disasm.c
index fe37a38..d1572c7 100644
--- a/gdb/guile/scm-disasm.c
+++ b/gdb/guile/scm-disasm.c
@@ -79,9 +79,11 @@ dascm_make_insn (CORE_ADDR pc, const char *assembly, int insn_len)
 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;
 
@@ -141,10 +143,11 @@ gdbscm_disasm_memory_error (int status, bfd_vma memaddr,
 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.
diff --git a/gdb/guile/scm-frame.c b/gdb/guile/scm-frame.c
index 38e1448..24e26e8 100644
--- a/gdb/guile/scm-frame.c
+++ b/gdb/guile/scm-frame.c
@@ -84,7 +84,7 @@ static const struct inferior_data *frscm_inferior_data_key;
 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);
 
@@ -104,8 +104,8 @@ frscm_hash_frame_smob (const void *p)
 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
@@ -118,7 +118,7 @@ frscm_eq_frame_smob (const void *ap, const void *bp)
 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)
     {
@@ -379,7 +379,7 @@ frscm_mark_frame_invalid (void **slot, void *info)
 static void
 frscm_del_inferior_frames (struct inferior *inferior, void *datum)
 {
-  htab_t htab = datum;
+  htab_t htab = (htab_t) datum;
 
   if (htab != NULL)
     {
diff --git a/gdb/guile/scm-gsmob.c b/gdb/guile/scm-gsmob.c
index 52368e9..504ea6c 100644
--- a/gdb/guile/scm-gsmob.c
+++ b/gdb/guile/scm-gsmob.c
@@ -193,7 +193,7 @@ gdbscm_add_objfile_ref (struct objfile *objfile,
   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);
diff --git a/gdb/guile/scm-objfile.c b/gdb/guile/scm-objfile.c
index 0af151d..f85975e 100644
--- a/gdb/guile/scm-objfile.c
+++ b/gdb/guile/scm-objfile.c
@@ -116,7 +116,7 @@ ofscm_release_objfile (objfile_smob *o_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);
 
@@ -148,7 +148,7 @@ ofscm_objfile_smob_from_objfile (struct 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 ();
diff --git a/gdb/guile/scm-ports.c b/gdb/guile/scm-ports.c
index 280e6d4..90bdb39 100644
--- a/gdb/guile/scm-ports.c
+++ b/gdb/guile/scm-ports.c
@@ -269,9 +269,9 @@ ioscm_write (SCM port, const void *data, size_t size)
   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)
     {
@@ -430,7 +430,7 @@ gdbscm_error_port (void)
 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__,
@@ -441,7 +441,7 @@ ioscm_file_port_delete (struct ui_file *file)
 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__,
@@ -455,7 +455,7 @@ ioscm_file_port_put (struct ui_file *file,
 		     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__,
@@ -469,7 +469,7 @@ ioscm_file_port_write (struct ui_file *file,
 		       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__,
diff --git a/gdb/guile/scm-progspace.c b/gdb/guile/scm-progspace.c
index a95e834..32c3206 100644
--- a/gdb/guile/scm-progspace.c
+++ b/gdb/guile/scm-progspace.c
@@ -126,7 +126,7 @@ psscm_release_pspace (pspace_smob *p_smob)
 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);
 
@@ -158,7 +158,7 @@ psscm_pspace_smob_from_pspace (struct program_space *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 ();
diff --git a/gdb/guile/scm-safe-call.c b/gdb/guile/scm-safe-call.c
index 6052214..62aec0f 100644
--- a/gdb/guile/scm-safe-call.c
+++ b/gdb/guile/scm-safe-call.c
@@ -97,7 +97,7 @@ scscm_nop_unwind_handler (void *data, SCM key, SCM args)
 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))
@@ -126,7 +126,7 @@ scscm_recording_pre_unwind_handler (void *datap, SCM key, SCM args)
 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
@@ -147,7 +147,7 @@ scscm_recording_unwind_handler (void *datap, SCM key, SCM args)
 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,
@@ -230,7 +230,7 @@ gdbscm_call_guile (SCM (*func) (void *), void *data,
 static SCM
 scscm_call_0_body (void *argsp)
 {
-  SCM *args = argsp;
+  SCM *args = (SCM *) argsp;
 
   return scm_call_0 (args[0]);
 }
@@ -248,7 +248,7 @@ gdbscm_safe_call_0 (SCM proc, excp_matcher_func *ok_excps)
 static SCM
 scscm_call_1_body (void *argsp)
 {
-  SCM *args = argsp;
+  SCM *args = (SCM *) argsp;
 
   return scm_call_1 (args[0], args[1]);
 }
@@ -266,7 +266,7 @@ gdbscm_safe_call_1 (SCM proc, SCM arg0, excp_matcher_func *ok_excps)
 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]);
 }
@@ -284,7 +284,7 @@ gdbscm_safe_call_2 (SCM proc, SCM arg0, SCM arg1, excp_matcher_func *ok_excps)
 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]);
 }
@@ -303,7 +303,7 @@ gdbscm_safe_call_3 (SCM proc, SCM arg1, SCM arg2, SCM arg3,
 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]);
 }
@@ -322,7 +322,7 @@ gdbscm_safe_call_4 (SCM proc, SCM arg1, SCM arg2, SCM arg3, SCM arg4,
 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]);
 }
@@ -372,7 +372,8 @@ struct eval_scheme_string_data
 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))
@@ -402,7 +403,7 @@ gdbscm_safe_eval_string (const char *string, int display_result)
   result = gdbscm_with_guile (scscm_eval_scheme_string, (void *) &data);
 
   if (result != NULL)
-    return xstrdup (result);
+    return xstrdup ((char *) result);
   return NULL;
 }
 
@@ -413,7 +414,7 @@ gdbscm_safe_eval_string (const char *string, int display_result)
 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. :-) */
@@ -451,7 +452,7 @@ gdbscm_safe_source_script (const char *filename)
 
   xfree (abs_filename);
   if (result != NULL)
-    return xstrdup (result);
+    return xstrdup ((char *) result);
   return NULL;
 }
 
diff --git a/gdb/guile/scm-string.c b/gdb/guile/scm-string.c
index c55da90..e6cb1d1 100644
--- a/gdb/guile/scm-string.c
+++ b/gdb/guile/scm-string.c
@@ -93,7 +93,7 @@ struct scm_to_stringn_data
 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);
@@ -161,7 +161,7 @@ struct scm_from_stringn_data
 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);
diff --git a/gdb/guile/scm-symbol.c b/gdb/guile/scm-symbol.c
index f711a02..81e4d50 100644
--- a/gdb/guile/scm-symbol.c
+++ b/gdb/guile/scm-symbol.c
@@ -65,7 +65,7 @@ struct syscm_gdbarch_data
 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);
 }
@@ -75,8 +75,8 @@ syscm_hash_symbol_smob (const void *p)
 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);
@@ -105,7 +105,7 @@ syscm_get_symbol_map (struct symbol *symbol)
     {
       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,
@@ -116,7 +116,8 @@ syscm_get_symbol_map (struct symbol *symbol)
   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;
@@ -311,7 +312,7 @@ syscm_mark_symbol_invalid (void **slot, void *info)
 static void
 syscm_del_objfile_symbols (struct objfile *objfile, void *datum)
 {
-  htab_t htab = datum;
+  htab_t htab = (htab_t) datum;
 
   if (htab != NULL)
     {
diff --git a/gdb/guile/scm-symtab.c b/gdb/guile/scm-symtab.c
index 6d16b27..6b6edca 100644
--- a/gdb/guile/scm-symtab.c
+++ b/gdb/guile/scm-symtab.c
@@ -86,7 +86,7 @@ static const struct objfile_data *stscm_objfile_data_key;
 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);
 }
@@ -96,8 +96,8 @@ stscm_hash_symtab_smob (const void *p)
 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);
@@ -110,7 +110,7 @@ static htab_t
 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)
     {
@@ -292,7 +292,7 @@ stscm_mark_symtab_invalid (void **slot, void *info)
 static void
 stscm_del_objfile_symtabs (struct objfile *objfile, void *datum)
 {
-  htab_t htab = datum;
+  htab_t htab = (htab_t) datum;
 
   if (htab != NULL)
     {
diff --git a/gdb/guile/scm-type.c b/gdb/guile/scm-type.c
index 11b355d..642ce15 100644
--- a/gdb/guile/scm-type.c
+++ b/gdb/guile/scm-type.c
@@ -139,7 +139,7 @@ tyscm_type_name (struct type *type, SCM *excp)
 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);
 }
@@ -149,8 +149,8 @@ tyscm_hash_type_smob (const void *p)
 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);
@@ -170,7 +170,7 @@ tyscm_type_map (struct type *type)
   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,
@@ -353,7 +353,7 @@ static int
 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;
@@ -388,7 +388,7 @@ tyscm_copy_type_recursive (void **slot, void *info)
 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)
diff --git a/gdb/guile/scm-utils.c b/gdb/guile/scm-utils.c
index da45a05..872a1ee 100644
--- a/gdb/guile/scm-utils.c
+++ b/gdb/guile/scm-utils.c
@@ -201,7 +201,7 @@ extract_arg (char format_char, SCM arg, void *argp,
     {
     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"));
@@ -210,7 +210,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     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,
@@ -220,7 +220,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     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"));
@@ -229,7 +229,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     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"));
@@ -238,7 +238,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     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"));
@@ -247,7 +247,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     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"));
@@ -256,7 +256,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     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"));
@@ -265,7 +265,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     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"));
@@ -274,7 +274,7 @@ extract_arg (char format_char, SCM arg, void *argp,
       }
     case 'O':
       {
-	SCM *arg_ptr = argp;
+	SCM *arg_ptr = (SCM *) argp;
 
 	*arg_ptr = arg;
 	break;
diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c
index a8cfc52..f4b97c1 100644
--- a/gdb/h8300-tdep.c
+++ b/gdb/h8300-tdep.c
@@ -432,7 +432,7 @@ h8300_frame_cache (struct frame_info *this_frame, void **this_cache)
   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);
diff --git a/gdb/hppa-linux-tdep.c b/gdb/hppa-linux-tdep.c
index 6dc2e84..0b05c37 100644
--- a/gdb/hppa-linux-tdep.c
+++ b/gdb/hppa-linux-tdep.c
@@ -205,7 +205,7 @@ hppa_linux_sigtramp_frame_unwind_cache (struct frame_info *this_frame,
   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;
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index cf894ee..78462d3 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -223,8 +223,8 @@ hppa_init_objfile_priv_data (struct objfile *objfile)
 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;
@@ -504,14 +504,16 @@ find_unwind_entry (CORE_ADDR pc)
   {
     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;
@@ -1904,7 +1906,7 @@ hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
       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;
@@ -1916,7 +1918,7 @@ hppa_frame_cache (struct frame_info *this_frame, void **this_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.  */
@@ -2006,7 +2008,7 @@ hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
 	  {
 	    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);
@@ -2279,7 +2281,7 @@ hppa_frame_cache (struct frame_info *this_frame, void **this_cache)
   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
@@ -2453,7 +2455,7 @@ hppa_stub_frame_unwind_cache (struct frame_info *this_frame,
   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;
diff --git a/gdb/hppanbsd-tdep.c b/gdb/hppanbsd-tdep.c
index 767db62..33ae55a 100644
--- a/gdb/hppanbsd-tdep.c
+++ b/gdb/hppanbsd-tdep.c
@@ -165,7 +165,7 @@ hppanbsd_supply_gregset (const struct regset *regset,
 			 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);
diff --git a/gdb/hppaobsd-tdep.c b/gdb/hppaobsd-tdep.c
index c9bc1bf..1f5278d 100644
--- a/gdb/hppaobsd-tdep.c
+++ b/gdb/hppaobsd-tdep.c
@@ -44,7 +44,7 @@ hppaobsd_supply_gregset (const struct regset *regset,
 			 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;
 
@@ -114,7 +114,7 @@ hppaobsd_supply_fpregset (const struct regset *regset,
 			  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);
diff --git a/gdb/i386-cygwin-tdep.c b/gdb/i386-cygwin-tdep.c
index cb70258..1c9dc91 100644
--- a/gdb/i386-cygwin-tdep.c
+++ b/gdb/i386-cygwin-tdep.c
@@ -98,7 +98,7 @@ struct cpms_data
 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;
diff --git a/gdb/i386-linux-tdep.c b/gdb/i386-linux-tdep.c
index 898beda..d02c527 100644
--- a/gdb/i386-linux-tdep.c
+++ b/gdb/i386-linux-tdep.c
@@ -745,7 +745,8 @@ i386_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;
 
diff --git a/gdb/i386-tdep.c b/gdb/i386-tdep.c
index d4df18e..2ac2f15 100644
--- a/gdb/i386-tdep.c
+++ b/gdb/i386-tdep.c
@@ -2050,7 +2050,7 @@ i386_frame_cache (struct frame_info *this_frame, void **this_cache)
   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;
@@ -2220,7 +2220,7 @@ i386_epilogue_frame_cache (struct frame_info *this_frame, void **this_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;
@@ -2407,7 +2407,7 @@ i386_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
   gdb_byte buf[4];
 
   if (*this_cache)
-    return *this_cache;
+    return (struct i386_frame_cache *) *this_cache;
 
   cache = i386_alloc_frame_cache ();
 
@@ -3732,7 +3732,7 @@ i386_supply_gregset (const struct regset *regset, struct regcache *regcache,
 {
   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);
@@ -3757,7 +3757,7 @@ i386_collect_gregset (const struct regset *regset,
 {
   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);
@@ -8478,7 +8478,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
   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))
diff --git a/gdb/i386obsd-tdep.c b/gdb/i386obsd-tdep.c
index f344a97..8684b07 100644
--- a/gdb/i386obsd-tdep.c
+++ b/gdb/i386obsd-tdep.c
@@ -141,7 +141,7 @@ i386obsd_aout_supply_regset (const struct regset *regset,
 {
   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);
 
@@ -348,7 +348,7 @@ i386obsd_trapframe_cache (struct frame_info *this_frame, void **this_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;
diff --git a/gdb/i387-tdep.c b/gdb/i387-tdep.c
index ad9fa08..9bc45fb 100644
--- a/gdb/i387-tdep.c
+++ b/gdb/i387-tdep.c
@@ -449,7 +449,7 @@ i387_supply_fsave (struct regcache *regcache, int regnum, const void *fsave)
   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);
@@ -502,7 +502,7 @@ void
 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);
@@ -595,7 +595,7 @@ void
 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);
@@ -678,7 +678,7 @@ void
 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);
@@ -896,7 +896,7 @@ i387_supply_xsave (struct regcache *regcache, int 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 };
@@ -1269,7 +1269,7 @@ i387_collect_xsave (const struct regcache *regcache, int regnum,
 {
   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
     {
diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index a468be9..46a114c 100644
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -1853,7 +1853,7 @@ ia64_frame_cache (struct frame_info *this_frame, void **this_cache)
   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;
@@ -2240,7 +2240,7 @@ ia64_sigtramp_frame_cache (struct frame_info *this_frame, void **this_cache)
   gdb_byte buf[8];
 
   if (*this_cache)
-    return *this_cache;
+    return (struct ia64_frame_cache *) *this_cache;
 
   cache = ia64_alloc_frame_cache ();
 
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index 4713490..c4d7d8b 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -2690,7 +2690,8 @@ struct attach_command_continuation_args
 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;
@@ -2701,7 +2702,8 @@ attach_command_continuation (void *args, int err)
 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);
diff --git a/gdb/inferior.c b/gdb/inferior.c
index 04e9a28..ae8b2a1 100644
--- a/gdb/inferior.c
+++ b/gdb/inferior.c
@@ -74,7 +74,7 @@ set_current_inferior (struct inferior *inf)
 static void
 restore_inferior (void *arg)
 {
-  struct inferior *saved_inferior = arg;
+  struct inferior *saved_inferior = (struct inferior *) arg;
 
   set_current_inferior (saved_inferior);
 }
@@ -171,7 +171,8 @@ struct delete_thread_of_inferior_arg
 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)
     {
diff --git a/gdb/inflow.c b/gdb/inflow.c
index cdc47a0..d38a43d 100644
--- a/gdb/inflow.c
+++ b/gdb/inflow.c
@@ -506,7 +506,7 @@ static const struct inferior_data *inflow_inferior_data;
 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);
@@ -521,7 +521,7 @@ get_inflow_inferior_data (struct inferior *inf)
 {
   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);
@@ -542,7 +542,7 @@ inflow_inferior_exit (struct inferior *inf)
 {
   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);
diff --git a/gdb/infrun.c b/gdb/infrun.c
index ec88621..cf91370 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -1692,7 +1692,8 @@ displaced_step_clear (struct displaced_step_inferior_state *displaced)
 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);
 }
@@ -7835,7 +7836,7 @@ print_stop_location (struct target_waitstatus *ws)
 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;
 }
@@ -7941,7 +7942,7 @@ save_stop_context (void)
 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--;
@@ -8727,7 +8728,7 @@ restore_infcall_suspend_state (struct infcall_suspend_state *inf_state)
 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 *
@@ -8869,7 +8870,7 @@ restore_infcall_control_state (struct infcall_control_state *inf_status)
 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 *
@@ -8903,7 +8904,7 @@ discard_infcall_control_state (struct infcall_control_state *inf_status)
 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);
diff --git a/gdb/inline-frame.c b/gdb/inline-frame.c
index e5d7360..aa041d9 100644
--- a/gdb/inline-frame.c
+++ b/gdb/inline-frame.c
@@ -283,7 +283,7 @@ block_starting_point_at (CORE_ADDR pc, const struct block *block)
   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;
 
diff --git a/gdb/iq2000-tdep.c b/gdb/iq2000-tdep.c
index f979591..efeb244 100644
--- a/gdb/iq2000-tdep.c
+++ b/gdb/iq2000-tdep.c
@@ -372,7 +372,7 @@ iq2000_frame_cache (struct frame_info *this_frame, void **this_cache)
   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);
diff --git a/gdb/jit.c b/gdb/jit.c
index 6302052..fbc0d02 100644
--- a/gdb/jit.c
+++ b/gdb/jit.c
@@ -285,7 +285,7 @@ get_jit_objfile_data (struct objfile *objf)
 {
   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);
@@ -315,7 +315,9 @@ get_jit_program_space_data (void)
 {
   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);
@@ -791,7 +793,7 @@ jit_object_close_impl (struct gdb_symbol_callbacks *cb,
   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);
@@ -989,7 +991,8 @@ jit_find_objf_with_entry_addr (CORE_ADDR entry_addr)
     {
       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;
     }
@@ -1011,7 +1014,8 @@ jit_breakpoint_deleted (struct breakpoint *b)
     {
       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;
@@ -1100,7 +1104,7 @@ jit_unwind_reg_set_impl (struct gdb_unwind_callbacks *cb, int dwarf_regnum,
   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);
@@ -1133,7 +1137,7 @@ jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int 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);
@@ -1153,7 +1157,7 @@ jit_unwind_reg_get_impl (struct gdb_unwind_callbacks *cb, int 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;
 
@@ -1196,7 +1200,7 @@ jit_frame_sniffer (const struct frame_unwind *self,
   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)));
@@ -1258,7 +1262,7 @@ jit_frame_this_id (struct frame_info *this_frame, void **cache,
 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)
@@ -1303,7 +1307,8 @@ jit_prepend_unwinder (struct gdbarch *gdbarch)
 {
   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);
@@ -1391,8 +1396,8 @@ jit_inferior_exit_hook (struct inferior *inf)
 
   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);
@@ -1443,13 +1448,15 @@ jit_event_handler (struct gdbarch *gdbarch)
 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;
     }
diff --git a/gdb/jv-lang.c b/gdb/jv-lang.c
index 43e2c6b..b8432e3 100644
--- a/gdb/jv-lang.c
+++ b/gdb/jv-lang.c
@@ -79,11 +79,12 @@ struct jv_per_objfile_data
 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)
@@ -106,8 +107,9 @@ get_dynamics_objfile (struct gdbarch *gdbarch)
 {
   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)
     {
@@ -165,7 +167,8 @@ get_java_class_symtab (struct gdbarch *gdbarch)
       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;
@@ -1236,7 +1239,8 @@ static struct gdbarch_data *java_type_data;
 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
diff --git a/gdb/language.c b/gdb/language.c
index b6fe77e..6a10539 100644
--- a/gdb/language.c
+++ b/gdb/language.c
@@ -975,8 +975,8 @@ struct type *
 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;
 }
@@ -985,8 +985,8 @@ struct 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)
     {
@@ -1029,8 +1029,8 @@ language_lookup_primitive_type (const struct language_defn *la,
 				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],
@@ -1106,8 +1106,8 @@ language_lookup_primitive_type_as_symbol (const struct language_defn *la,
 					  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;
diff --git a/gdb/linespec.c b/gdb/linespec.c
index a61b08a..b2233b9 100644
--- a/gdb/linespec.c
+++ b/gdb/linespec.c
@@ -868,7 +868,7 @@ add_sal_to_sals (struct linespec_state *self,
 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);
@@ -880,8 +880,8 @@ hash_address_entry (const void *p)
 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;
 }
@@ -929,7 +929,8 @@ iterate_inline_only (struct symbol *sym, void *d)
 {
   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);
     }
@@ -953,7 +954,8 @@ struct symbol_matcher_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.  */
@@ -1294,8 +1296,8 @@ struct decode_line_2_item
 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);
@@ -2809,7 +2811,8 @@ struct decode_compound_collector
 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;
 
@@ -2889,8 +2892,8 @@ lookup_prefix_sym (struct linespec_state *state, VEC (symtab_ptr) *file_symtabs,
 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));
@@ -2917,8 +2920,10 @@ compare_symbols (const void *a, const void *b)
 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;
@@ -3099,7 +3104,7 @@ struct symtab_collector
 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);
@@ -3522,7 +3527,7 @@ linespec_parse_variable (struct linespec_state *self, const char *variable)
 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".  */
@@ -3630,8 +3635,8 @@ classify_mtype (enum minimal_symbol_type t)
 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);
 
@@ -3644,7 +3649,7 @@ compare_msyms (const void *a, const void *b)
 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;
@@ -3898,7 +3903,7 @@ destroy_linespec_result (struct linespec_result *ls)
 static void
 cleanup_linespec_result (void *a)
 {
-  destroy_linespec_result (a);
+  destroy_linespec_result ((struct linespec_result *) a);
 }
 
 /* See the comment in linespec.h.  */
diff --git a/gdb/linux-fork.c b/gdb/linux-fork.c
index fdea247..9a469d4 100644
--- a/gdb/linux-fork.c
+++ b/gdb/linux-fork.c
@@ -415,7 +415,7 @@ linux_fork_detach (const char *args, int from_tty)
 static void
 inferior_call_waitpid_cleanup (void *fp)
 {
-  struct fork_info *oldfp = fp;
+  struct fork_info *oldfp = (struct fork_info *) fp;
 
   if (oldfp)
     {
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index c6dbc01..6423ecc 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -438,7 +438,7 @@ num_lwps (int pid)
 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);
 }
@@ -2719,7 +2719,7 @@ running_callback (struct lwp_info *lp, void *data)
 static int
 count_events_callback (struct lwp_info *lp, void *data)
 {
-  int *count = data;
+  int *count = (int *) data;
 
   gdb_assert (count != NULL);
 
@@ -2758,7 +2758,7 @@ lwp_status_pending_p (struct lwp_info *lp)
 static int
 select_event_lwp_callback (struct lwp_info *lp, void *data)
 {
-  int *selector = data;
+  int *selector = (int *) data;
 
   gdb_assert (selector != NULL);
 
@@ -3641,7 +3641,7 @@ linux_nat_wait_1 (struct target_ops *ops,
 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)
     {
diff --git a/gdb/linux-tdep.c b/gdb/linux-tdep.c
index 86d9eef..9dc342d 100644
--- a/gdb/linux-tdep.c
+++ b/gdb/linux-tdep.c
@@ -171,7 +171,8 @@ init_linux_gdbarch_data (struct gdbarch *gdbarch)
 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.  */
@@ -203,7 +204,7 @@ invalidate_linux_cache_inf (struct inferior *inf)
 {
   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);
@@ -230,7 +231,7 @@ get_linux_inferior_data (void)
   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);
@@ -1306,7 +1307,8 @@ linux_find_memory_regions_thunk (ULONGEST vaddr, ULONGEST size,
 				 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);
 }
@@ -1454,7 +1456,8 @@ linux_make_mappings_callback (ULONGEST vaddr, ULONGEST size,
 			      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)
@@ -1665,7 +1668,8 @@ struct linux_corefile_thread_data
 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.  */
@@ -2252,7 +2256,7 @@ find_mapping_size (CORE_ADDR vaddr, unsigned long size,
 		   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)
     {
diff --git a/gdb/linux-thread-db.c b/gdb/linux-thread-db.c
index 91bd0dc..66e9595 100644
--- a/gdb/linux-thread-db.c
+++ b/gdb/linux-thread-db.c
@@ -1566,7 +1566,7 @@ find_new_threads_callback (const td_thrhandle_t *th_p, void *data)
   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);
diff --git a/gdb/lm32-tdep.c b/gdb/lm32-tdep.c
index 779575c..25a7e1e 100644
--- a/gdb/lm32-tdep.c
+++ b/gdb/lm32-tdep.c
@@ -422,7 +422,7 @@ lm32_frame_cache (struct frame_info *this_frame, void **this_prologue_cache)
   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;
diff --git a/gdb/m2-lang.c b/gdb/m2-lang.c
index fb93c64..2a1e166 100644
--- a/gdb/m2-lang.c
+++ b/gdb/m2-lang.c
@@ -425,7 +425,7 @@ static struct gdbarch_data *m2_type_data;
 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);
 }
 
 
diff --git a/gdb/m32c-tdep.c b/gdb/m32c-tdep.c
index 3b7a585..f2d060a 100644
--- a/gdb/m32c-tdep.c
+++ b/gdb/m32c-tdep.c
@@ -1875,10 +1875,11 @@ m32c_analyze_frame_prologue (struct frame_info *this_frame,
 
       *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;
 }
 
 
diff --git a/gdb/m32r-linux-tdep.c b/gdb/m32r-linux-tdep.c
index 83d31fd..4abda5e 100644
--- a/gdb/m32r-linux-tdep.c
+++ b/gdb/m32r-linux-tdep.c
@@ -230,7 +230,7 @@ m32r_linux_sigtramp_frame_cache (struct frame_info *this_frame,
   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);
@@ -351,7 +351,7 @@ m32r_linux_supply_gregset (const struct regset *regset,
 			   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;
@@ -394,7 +394,7 @@ m32r_linux_collect_gregset (const struct regset *regset,
 			    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));
diff --git a/gdb/m32r-tdep.c b/gdb/m32r-tdep.c
index ba93322..9b89ad9 100644
--- a/gdb/m32r-tdep.c
+++ b/gdb/m32r-tdep.c
@@ -540,7 +540,7 @@ m32r_frame_unwind_cache (struct frame_info *this_frame,
 
 
   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;
diff --git a/gdb/m68hc11-tdep.c b/gdb/m68hc11-tdep.c
index df7cd0c..a9c425c 100644
--- a/gdb/m68hc11-tdep.c
+++ b/gdb/m68hc11-tdep.c
@@ -792,7 +792,7 @@ m68hc11_frame_unwind_cache (struct frame_info *this_frame,
   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;
diff --git a/gdb/m68k-tdep.c b/gdb/m68k-tdep.c
index 285a831..01e67b9 100644
--- a/gdb/m68k-tdep.c
+++ b/gdb/m68k-tdep.c
@@ -882,7 +882,7 @@ m68k_frame_cache (struct frame_info *this_frame, void **this_cache)
   int i;
 
   if (*this_cache)
-    return *this_cache;
+    return (struct m68k_frame_cache *) *this_cache;
 
   cache = m68k_alloc_frame_cache ();
   *this_cache = cache;
diff --git a/gdb/m68kbsd-tdep.c b/gdb/m68kbsd-tdep.c
index ae0cecf..ff1da70 100644
--- a/gdb/m68kbsd-tdep.c
+++ b/gdb/m68kbsd-tdep.c
@@ -59,7 +59,7 @@ m68kbsd_supply_fpregset (const struct regset *regset,
 			 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);
@@ -81,7 +81,7 @@ m68kbsd_supply_gregset (const struct regset *regset,
 			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);
diff --git a/gdb/m68klinux-tdep.c b/gdb/m68klinux-tdep.c
index c60a879..02579b1 100644
--- a/gdb/m68klinux-tdep.c
+++ b/gdb/m68klinux-tdep.c
@@ -263,7 +263,7 @@ m68k_linux_sigtramp_frame_cache (struct frame_info *this_frame,
   int i;
 
   if (*this_cache)
-    return *this_cache;
+    return (struct trad_frame_cache *) *this_cache;
 
   cache = trad_frame_cache_zalloc (this_frame);
 
diff --git a/gdb/m88k-tdep.c b/gdb/m88k-tdep.c
index abfd082..94ea409 100644
--- a/gdb/m88k-tdep.c
+++ b/gdb/m88k-tdep.c
@@ -652,7 +652,7 @@ m88k_frame_cache (struct frame_info *this_frame, void **this_cache)
   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);
@@ -782,7 +782,7 @@ m88k_supply_gregset (const struct regset *regset,
 		     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++)
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 85b6126..7d52ba0 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+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
diff --git a/gdb/testsuite/gdb.gdb/selftest.exp b/gdb/testsuite/gdb.gdb/selftest.exp
index a170f73..8b1298f 100644
--- a/gdb/testsuite/gdb.gdb/selftest.exp
+++ b/gdb/testsuite/gdb.gdb/selftest.exp
@@ -40,7 +40,7 @@ proc do_steps_and_nexts {} {
 	# 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"
 	    }
-- 
2.7.4