OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Replace some xmalloc-family functions with XNEW-family ones 

This patch is part of the make-gdb-buildable-in-C++ effort.  The idea is
to change some calls to the xmalloc family of functions to calls to the
equivalents in the XNEW family.  This avoids adding an explicit cast, so
it keeps the code a bit more readable.  Some of them also map relatively
well to a C++ equivalent (XNEW (struct foo) -> new foo), so it will be
possible to do scripted replacements if needed.

I only changed calls that were obviously allocating memory for one or
multiple "objects".  Allocation of variable sizes (such as strings or
buffer handling) will be for later (and won't use XNEW).

  - xmalloc (sizeof (struct foo)) -> XNEW (struct foo)
  - xmalloc (num * sizeof (struct foo)) -> XNEWVEC (struct foo, num)
  - xcalloc (1, sizeof (struct foo)) -> XCNEW (struct foo)
  - xcalloc (num, sizeof (struct foo)) -> XCNEWVEC (struct foo, num)
  - xrealloc (p, num * sizeof (struct foo) -> XRESIZEVEC (struct foo, p, num)
  - obstack_alloc (ob, sizeof (struct foo)) -> XOBNEW (ob, struct foo)
  - obstack_alloc (ob, num * sizeof (struct foo)) -> XOBNEWVEC (ob, struct foo, num)
  - alloca (sizeof (struct foo)) -> XALLOCA (struct foo)
  - alloca (num * sizeof (struct foo)) -> XALLOCAVEC (struct foo, num)

Some instances of xmalloc followed by memset to zero the buffer were
replaced by XCNEW or XCNEWVEC.

I regtested on x86-64, Ubuntu 14.04, but the patch touches many
architecture-specific files.  For those I'll have to rely on the
buildbot or people complaining that I broke their gdb.

gdb/ChangeLog:

	* aarch64-linux-nat.c (aarch64_add_process): Likewise.
	* aarch64-tdep.c (aarch64_gdbarch_init): Likewise.
	* ada-exp.y (write_ambiguous_var): Likewise.
	* ada-lang.c (resolve_subexp): Likewise.
	(user_select_syms): Likewise.
	(assign_aggregate): Likewise.
	(ada_evaluate_subexp): Likewise.
	(cache_symbol): Likewise.
	* addrmap.c (allocate_key): Likewise.
	(addrmap_create_mutable): Likewise.
	* aix-thread.c (sync_threadlists): Likewise.
	* alpha-tdep.c (alpha_push_dummy_call): Likewise.
	(alpha_gdbarch_init): Likewise.
	* amd64-windows-tdep.c (amd64_windows_push_arguments): Likewise.
	* arm-linux-nat.c (arm_linux_add_process): Likewise.
	* arm-linux-tdep.c (arm_linux_displaced_step_copy_insn): Likewise.
	* arm-tdep.c (push_stack_item): Likewise.
	(arm_displaced_step_copy_insn): Likewise.
	(arm_gdbarch_init): Likewise.
	(_initialize_arm_tdep): Likewise.
	* avr-tdep.c (push_stack_item): Likewise.
	* ax-general.c (new_agent_expr): Likewise.
	* block.c (block_initialize_namespace): Likewise.
	* breakpoint.c (alloc_counted_command_line): Likewise.
	(update_dprintf_command_list): Likewise.
	(parse_breakpoint_sals): Likewise.
	(decode_static_tracepoint_spec): Likewise.
	(until_break_command): Likewise.
	(clear_command): Likewise.
	(update_global_location_list): Likewise.
	(get_breakpoint_objfile_data) Likewise.
	* btrace.c (ftrace_new_function): Likewise.
	(btrace_set_insn_history): Likewise.
	(btrace_set_call_history): Likewise.
	* buildsym.c (add_symbol_to_list): Likewise.
	(record_pending_block): Likewise.
	(start_subfile): Likewise.
	(start_buildsym_compunit): Likewise.
	(push_subfile): Likewise.
	(end_symtab_get_static_block): Likewise.
	(buildsym_init): Likewise.
	* cli/cli-cmds.c (source_command): Likewise.
	* cli/cli-decode.c (add_cmd): Likewise.
	* cli/cli-script.c (build_command_line): Likewise.
	(setup_user_args): Likewise.
	(realloc_body_list): Likewise.
	(process_next_line): Likewise.
	(copy_command_lines): Likewise.
	* cli/cli-setshow.c (do_set_command): Likewise.
	* coff-pe-read.c (read_pe_exported_syms): Likewise.
	* coffread.c (coff_locate_sections): Likewise.
	(coff_symtab_read): Likewise.
	(coff_read_struct_type): Likewise.
	* common/cleanups.c (make_my_cleanup2): Likewise.
	* common/common-exceptions.c (throw_it): Likewise.
	* common/filestuff.c (make_cleanup_close): Likewise.
	* common/format.c (parse_format_string): Likewise.
	* common/queue.h (DEFINE_QUEUE_P): Likewise.
	* compile/compile-object-load.c (munmap_list_add): Likewise.
	(compile_object_load): Likewise.
	* compile/compile-object-run.c (compile_object_run): Likewise.
	* compile/compile.c (append_args): Likewise.
	* corefile.c (specify_exec_file_hook): Likewise.
	* cp-support.c (make_symbol_overload_list): Likewise.
	* cris-tdep.c (push_stack_item): Likewise.
	(cris_gdbarch_init): Likewise.
	* ctf.c (ctf_trace_file_writer_new): Likewise.
	* dbxread.c (init_header_files): Likewise.
	(add_new_header_file): Likewise.
	(init_bincl_list): Likewise.
	(dbx_end_psymtab): Likewise.
	(start_psymtab): Likewise.
	(dbx_end_psymtab): Likewise.
	* dcache.c (dcache_init): Likewise.
	* dictionary.c (dict_create_hashed): Likewise.
	(dict_create_hashed_expandable): Likewise.
	(dict_create_linear): Likewise.
	(dict_create_linear_expandable): Likewise.
	* dtrace-probe.c (dtrace_process_dof_probe): Likewise.
	* dummy-frame.c (register_dummy_frame_dtor): Likewise.
	* dwarf2-frame-tailcall.c (cache_new_ref1): Likewise.
	* dwarf2-frame.c (dwarf2_build_frame_info): Likewise.
	(decode_frame_entry_1): Likewise.
	* dwarf2expr.c (new_dwarf_expr_context): Likewise.
	* dwarf2loc.c (dwarf2_compile_expr_to_ax): Likewise.
	* dwarf2read.c (dwarf2_has_info): Likewise.
	(create_signatured_type_table_from_index): Likewise.
	(dwarf2_read_index): Likewise.
	(dw2_get_file_names_reader): Likewise.
	(create_all_type_units): Likewise.
	(read_cutu_die_from_dwo): Likewise.
	(init_tu_and_read_dwo_dies): Likewise.
	(init_cutu_and_read_dies): Likewise.
	(create_all_comp_units): Likewise.
	(queue_comp_unit): Likewise.
	(inherit_abstract_dies): Likewise.
	(read_call_site_scope): Likewise.
	(dwarf2_add_field): Likewise.
	(dwarf2_add_typedef): Likewise.
	(dwarf2_add_member_fn): Likewise.
	(attr_to_dynamic_prop): Likewise.
	(abbrev_table_alloc_abbrev): Likewise.
	(abbrev_table_read_table): Likewise.
	(add_include_dir): Likewise.
	(add_file_name): Likewise.
	(dwarf_decode_line_header): Likewise.
	(dwarf2_const_value_attr): Likewise.
	(dwarf_alloc_block): Likewise.
	(parse_macro_definition): Likewise.
	(set_die_type): Likewise.
	(write_psymtabs_to_index): Likewise.
	(create_cus_from_index): Likewise.
	(dwarf2_create_include_psymtab): Likewise.
	(process_psymtab_comp_unit_reader): Likewise.
	(build_type_psymtab_dependencies): Likewise.
	(read_comp_units_from_section): Likewise.
	(compute_compunit_symtab_includes): Likewise.
	(create_dwo_unit_in_dwp_v1): Likewise.
	(create_dwo_unit_in_dwp_v2): Likewise.
	(read_func_scope): Likewise.
	(process_structure_scope): Likewise.
	(mark_common_block_symbol_computed): Likewise.
	(load_partial_dies): Likewise.
	(dwarf2_symbol_mark_computed): Likewise.
	* elfread.c (elf_symfile_segments): Likewise.
	(elf_read_minimal_symbols): Likewise.
	* environ.c (make_environ): Likewise.
	* eval.c (evaluate_subexp_standard): Likewise.
	* event-loop.c (create_file_handler): Likewise.
	(create_async_signal_handler): Likewise.
	(create_async_event_handler): Likewise.
	(create_timer): Likewise.
	* exec.c (build_section_table): Likewise.
	* fbsd-nat.c (fbsd_remember_child): Likewise.
	* fork-child.c (fork_inferior): Likewise.
	* frv-tdep.c (new_variant): Likewise.
	* gdbarch.sh (gdbarch_alloc): Likewise.
	(append_name): Likewise.
	* gdbtypes.c (rank_function): Likewise.
	(copy_type_recursive): Likewise.
	(add_dyn_prop): Likewise.
	* gnu-nat.c (make_proc): Likewise.
	(make_inf): Likewise.
	(gnu_write_inferior): Likewise.
	* gnu-v3-abi.c (build_gdb_vtable_type): Likewise.
	(build_std_type_info_type): Likewise.
	* guile/scm-param.c (compute_enum_list): Likewise.
	* guile/scm-utils.c (gdbscm_parse_function_args): Likewise.
	* guile/scm-value.c (gdbscm_value_call): Likewise.
	* h8300-tdep.c (h8300_gdbarch_init): Likewise.
	* hppa-tdep.c (hppa_init_objfile_priv_data): Likewise.
	(read_unwind_info): Likewise.
	* ia64-tdep.c (ia64_gdbarch_init): Likewise.
	* infcall.c (dummy_frame_context_saver_setup): Likewise.
	(call_function_by_hand_dummy): Likewise.
	* infcmd.c (step_once): Likewise.
	(finish_forward): Likewise.
	(attach_command): Likewise.
	(notice_new_inferior): Likewise.
	* inferior.c (add_inferior_silent): Likewise.
	* infrun.c (add_displaced_stepping_state): Likewise.
	(save_infcall_control_state): Likewise.
	(save_inferior_ptid): Likewise.
	(_initialize_infrun): Likewise.
	* jit.c (bfd_open_from_target_memory): Likewise.
	(jit_gdbarch_data_init): Likewise.
	* language.c (add_language): Likewise.
	* linespec.c (decode_line_2): Likewise.
	* linux-nat.c (add_to_pid_list): Likewise.
	(add_initial_lwp): Likewise.
	* linux-thread-db.c (add_thread_db_info): Likewise.
	(record_thread): Likewise.
	(info_auto_load_libthread_db): Likewise.
	* m32c-tdep.c (m32c_gdbarch_init): Likewise.
	* m68hc11-tdep.c (m68hc11_gdbarch_init): Likewise.
	* m68k-tdep.c (m68k_gdbarch_init): Likewise.
	* m88k-tdep.c (m88k_analyze_prologue): Likewise.
	* macrocmd.c (macro_define_command): Likewise.
	* macroexp.c (gather_arguments): Likewise.
	* macroscope.c (sal_macro_scope): Likewise.
	* macrotab.c (new_macro_table): Likewise.
	* mdebugread.c (push_parse_stack): Likewise.
	(parse_partial_symbols): Likewise.
	(parse_symbol): Likewise.
	(psymtab_to_symtab_1): Likewise.
	(new_block): Likewise.
	(new_psymtab): Likewise.
	(mdebug_build_psymtabs): Likewise.
	(add_pending): Likewise.
	(elfmdebug_build_psymtabs): Likewise.
	* mep-tdep.c (mep_gdbarch_init): Likewise.
	* mi/mi-main.c (mi_execute_command): Likewise.
	* mi/mi-parse.c (mi_parse_argv): Likewise.
	* minidebug.c (lzma_open): Likewise.
	* minsyms.c (terminate_minimal_symbol_table): Likewise.
	* mips-linux-nat.c (mips_linux_insert_watchpoint): Likewise.
	* mips-tdep.c (mips_gdbarch_init): Likewise.
	* mn10300-tdep.c (mn10300_gdbarch_init): Likewise.
	* msp430-tdep.c (msp430_gdbarch_init): Likewise.
	* mt-tdep.c (mt_registers_info): Likewise.
	* nat/aarch64-linux.c (aarch64_linux_new_thread): Likewise.
	* nat/linux-btrace.c (linux_enable_bts): Likewise.
	(linux_enable_pt): Likewise.
	* nat/linux-osdata.c (linux_xfer_osdata_processes): Likewise.
	(linux_xfer_osdata_processgroups): Likewise.
	* nios2-tdep.c (nios2_gdbarch_init): Likewise.
	* nto-procfs.c (procfs_meminfo): Likewise.
	* objc-lang.c (start_msglist): Likewise.
	(selectors_info): Likewise.
	(classes_info): Likewise.
	(find_methods): Likewise.
	* objfiles.c (allocate_objfile): Likewise.
	(update_section_map): Likewise.
	* osabi.c (gdbarch_register_osabi): Likewise.
	(gdbarch_register_osabi_sniffer): Likewise.
	* parse.c (start_arglist): Likewise.
	* ppc-linux-nat.c (hwdebug_find_thread_points_by_tid): Likewise.
	(hwdebug_insert_point): Likewise.
	* printcmd.c (display_command): Likewise.
	(ui_printf): Likewise.
	* procfs.c (create_procinfo): Likewise.
	(load_syscalls): Likewise.
	(proc_get_LDT_entry): Likewise.
	(proc_update_threads): Likewise.
	* prologue-value.c (make_pv_area): Likewise.
	(pv_area_store): Likewise.
	* psymtab.c (extend_psymbol_list): Likewise.
	(init_psymbol_list): Likewise.
	(allocate_psymtab): Likewise.
	* python/py-inferior.c (add_thread_object): Likewise.
	* python/py-param.c (compute_enum_values): Likewise.
	* python/py-value.c (valpy_call): Likewise.
	* python/py-varobj.c (py_varobj_iter_next): Likewise.
	* python/python.c (ensure_python_env): Likewise.
	* record-btrace.c (record_btrace_start_replaying): Likewise.
	* record-full.c (record_full_reg_alloc): Likewise.
	(record_full_mem_alloc): Likewise.
	(record_full_end_alloc): Likewise.
	(record_full_core_xfer_partial): Likewise.
	* regcache.c (get_thread_arch_aspace_regcache): Likewise.
	* remote-fileio.c (remote_fileio_init_fd_map): Likewise.
	* remote-notif.c (remote_notif_state_allocate): Likewise.
	* remote.c (demand_private_info): Likewise.
	(remote_notif_stop_alloc_reply): Likewise.
	(remote_enable_btrace): Likewise.
	* reverse.c (save_bookmark_command): Likewise.
	* rl78-tdep.c (rl78_gdbarch_init): Likewise.
	* rx-tdep.c (rx_gdbarch_init): Likewise.
	* s390-linux-nat.c (s390_insert_watchpoint): Likewise.
	* ser-go32.c (dos_get_tty_state): Likewise.
	(dos_copy_tty_state): Likewise.
	* ser-mingw.c (ser_windows_open): Likewise.
	(ser_console_wait_handle): Likewise.
	(ser_console_get_tty_state): Likewise.
	(make_pipe_state): Likewise.
	(net_windows_open): Likewise.
	* ser-unix.c (hardwire_get_tty_state): Likewise.
	(hardwire_copy_tty_state): Likewise.
	* solib-aix.c (solib_aix_new_lm_info): Likewise.
	* solib-dsbt.c (dsbt_current_sos): Likewise.
	(dsbt_relocate_main_executable): Likewise.
	* solib-frv.c (frv_current_sos): Likewise.
	(frv_relocate_main_executable): Likewise.
	* solib-spu.c (spu_bfd_fopen): Likewise.
	* solib-svr4.c (lm_info_read): Likewise.
	(svr4_copy_library_list): Likewise.
	(svr4_default_sos): Likewise.
	* source.c (find_source_lines): Likewise.
	(line_info): Likewise.
	(add_substitute_path_rule): Likewise.
	* spu-linux-nat.c (spu_bfd_open): Likewise.
	* spu-tdep.c (info_spu_dma_cmdlist): Likewise.
	* stabsread.c (dbx_lookup_type): Likewise.
	(read_type): Likewise.
	(read_member_functions): Likewise.
	(read_struct_fields): Likewise.
	(read_baseclasses): Likewise.
	(read_args): Likewise.
	(_initialize_stabsread): Likewise.
	* stack.c (func_command): Likewise.
	* stap-probe.c (handle_stap_probe): Likewise.
	* symfile.c (addrs_section_sort): Likewise.
	(addr_info_make_relative): Likewise.
	(load_section_callback): Likewise.
	(add_symbol_file_command): Likewise.
	(init_filename_language_table): Likewise.
	* symtab.c (create_filename_seen_cache): Likewise.
	(sort_search_symbols_remove_dups): Likewise.
	(search_symbols): Likewise.
	* target.c (make_cleanup_restore_target_terminal): Likewise.
	* thread.c (new_thread): Likewise.
	(enable_thread_stack_temporaries): Likewise.
	(make_cleanup_restore_current_thread): Likewise.
	(thread_apply_all_command): Likewise.
	* tic6x-tdep.c (tic6x_gdbarch_init): Likewise.
	* top.c (gdb_readline_wrapper): Likewise.
	* tracefile-tfile.c (tfile_trace_file_writer_new): Likewise.
	* tracepoint.c (trace_find_line_command): Likewise.
	(all_tracepoint_actions_and_cleanup): Likewise.
	(make_cleanup_restore_current_traceframe): Likewise.
	(get_uploaded_tp): Likewise.
	(get_uploaded_tsv): Likewise.
	* tui/tui-data.c (tui_alloc_generic_win_info): Likewise.
	(tui_alloc_win_info): Likewise.
	(tui_alloc_content): Likewise.
	(tui_add_content_elements): Likewise.
	* tui/tui-disasm.c (tui_find_disassembly_address): Likewise.
	(tui_set_disassem_content): Likewise.
	* ui-file.c (ui_file_new): Likewise.
	(stdio_file_new): Likewise.
	(tee_file_new): Likewise.
	* utils.c (make_cleanup_restore_integer): Likewise.
	(add_internal_problem_command): Likewise.
	* v850-tdep.c (v850_gdbarch_init): Likewise.
	* valops.c (find_oload_champ): Likewise.
	* value.c (allocate_value_lazy): Likewise.
	(record_latest_value): Likewise.
	(create_internalvar): Likewise.
	* varobj.c (install_variable): Likewise.
	(new_variable): Likewise.
	(new_root_variable): Likewise.
	(cppush): Likewise.
	(_initialize_varobj): Likewise.
	* windows-nat.c (windows_make_so): Likewise.
	* x86-nat.c (x86_add_process): Likewise.
	* xcoffread.c (arrange_linetable): Likewise.
	(allocate_include_entry): Likewise.
	(process_linenos): Likewise.
	(SYMBOL_DUP): Likewise.
	(xcoff_start_psymtab): Likewise.
	(xcoff_end_psymtab): Likewise.
	* xml-support.c (gdb_xml_parse_attr_ulongest): Likewise.
	* xtensa-tdep.c (xtensa_register_type): Likewise.
	* gdbarch.c: Regenerate.
	* gdbarch.h: Regenerate.

gdb/gdbserver/ChangeLog:

	* ax.c (gdb_parse_agent_expr): Likewise.
	(compile_bytecodes): Likewise.
	* dll.c (loaded_dll): Likewise.
	* event-loop.c (append_callback_event): Likewise.
	(create_file_handler): Likewise.
	(create_file_event): Likewise.
	* hostio.c (handle_open): Likewise.
	* inferiors.c (add_thread): Likewise.
	(add_process): Likewise.
	* linux-aarch64-low.c (aarch64_linux_new_process): Likewise.
	* linux-arm-low.c (arm_new_process): Likewise.
	(arm_new_thread): Likewise.
	* linux-low.c (add_to_pid_list): Likewise.
	(linux_add_process): Likewise.
	(handle_extended_wait): Likewise.
	(add_lwp): Likewise.
	(enqueue_one_deferred_signal): Likewise.
	(enqueue_pending_signal): Likewise.
	(linux_resume_one_lwp_throw): Likewise.
	(linux_resume_one_thread): Likewise.
	(linux_read_memory): Likewise.
	(linux_write_memory): Likewise.
	* linux-mips-low.c (mips_linux_new_process): Likewise.
	(mips_linux_new_thread): Likewise.
	(mips_add_watchpoint): Likewise.
	* linux-x86-low.c (initialize_low_arch): Likewise.
	* lynx-low.c (lynx_add_process): Likewise.
	* mem-break.c (set_raw_breakpoint_at): Likewise.
	(set_breakpoint): Likewise.
	(add_condition_to_breakpoint): Likewise.
	(add_commands_to_breakpoint): Likewise.
	(clone_agent_expr): Likewise.
	(clone_one_breakpoint): Likewise.
	* regcache.c (new_register_cache): Likewise.
	* remote-utils.c (look_up_one_symbol): Likewise.
	* server.c (queue_stop_reply): Likewise.
	(start_inferior): Likewise.
	(queue_stop_reply_callback): Likewise.
	(handle_target_event): Likewise.
	* spu-low.c (fetch_ppc_memory): Likewise.
	(store_ppc_memory): Likewise.
	* target.c (set_target_ops): Likewise.
	* thread-db.c (thread_db_load_search): Likewise.
	(try_thread_db_load_1): Likewise.
	* tracepoint.c (add_tracepoint): Likewise.
	(add_tracepoint_action): Likewise.
	(create_trace_state_variable): Likewise.
	(cmd_qtdpsrc): Likewise.
	(cmd_qtro): Likewise.
	(add_while_stepping_state): Likewise.
	* win32-low.c (child_add_thread): Likewise.
	(get_image_name): Likewise.
This commit is contained in:
Simon Marchi 2015-08-26 17:16:07 -04:00
parent 17d8546e60
commit 8d7493201c
177 changed files with 906 additions and 675 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

338
gdb/ChangeLog
View File

@ -1,3 +1,341 @@
2015-08-26 Simon Marchi <simon.marchi@ericsson.com>
* aarch64-linux-nat.c (aarch64_add_process): Likewise.
* aarch64-tdep.c (aarch64_gdbarch_init): Likewise.
* ada-exp.y (write_ambiguous_var): Likewise.
* ada-lang.c (resolve_subexp): Likewise.
(user_select_syms): Likewise.
(assign_aggregate): Likewise.
(ada_evaluate_subexp): Likewise.
(cache_symbol): Likewise.
* addrmap.c (allocate_key): Likewise.
(addrmap_create_mutable): Likewise.
* aix-thread.c (sync_threadlists): Likewise.
* alpha-tdep.c (alpha_push_dummy_call): Likewise.
(alpha_gdbarch_init): Likewise.
* amd64-windows-tdep.c (amd64_windows_push_arguments): Likewise.
* arm-linux-nat.c (arm_linux_add_process): Likewise.
* arm-linux-tdep.c (arm_linux_displaced_step_copy_insn): Likewise.
* arm-tdep.c (push_stack_item): Likewise.
(arm_displaced_step_copy_insn): Likewise.
(arm_gdbarch_init): Likewise.
(_initialize_arm_tdep): Likewise.
* avr-tdep.c (push_stack_item): Likewise.
* ax-general.c (new_agent_expr): Likewise.
* block.c (block_initialize_namespace): Likewise.
* breakpoint.c (alloc_counted_command_line): Likewise.
(update_dprintf_command_list): Likewise.
(parse_breakpoint_sals): Likewise.
(decode_static_tracepoint_spec): Likewise.
(until_break_command): Likewise.
(clear_command): Likewise.
(update_global_location_list): Likewise.
(get_breakpoint_objfile_data) Likewise.
* btrace.c (ftrace_new_function): Likewise.
(btrace_set_insn_history): Likewise.
(btrace_set_call_history): Likewise.
* buildsym.c (add_symbol_to_list): Likewise.
(record_pending_block): Likewise.
(start_subfile): Likewise.
(start_buildsym_compunit): Likewise.
(push_subfile): Likewise.
(end_symtab_get_static_block): Likewise.
(buildsym_init): Likewise.
* cli/cli-cmds.c (source_command): Likewise.
* cli/cli-decode.c (add_cmd): Likewise.
* cli/cli-script.c (build_command_line): Likewise.
(setup_user_args): Likewise.
(realloc_body_list): Likewise.
(process_next_line): Likewise.
(copy_command_lines): Likewise.
* cli/cli-setshow.c (do_set_command): Likewise.
* coff-pe-read.c (read_pe_exported_syms): Likewise.
* coffread.c (coff_locate_sections): Likewise.
(coff_symtab_read): Likewise.
(coff_read_struct_type): Likewise.
* common/cleanups.c (make_my_cleanup2): Likewise.
* common/common-exceptions.c (throw_it): Likewise.
* common/filestuff.c (make_cleanup_close): Likewise.
* common/format.c (parse_format_string): Likewise.
* common/queue.h (DEFINE_QUEUE_P): Likewise.
* compile/compile-object-load.c (munmap_list_add): Likewise.
(compile_object_load): Likewise.
* compile/compile-object-run.c (compile_object_run): Likewise.
* compile/compile.c (append_args): Likewise.
* corefile.c (specify_exec_file_hook): Likewise.
* cp-support.c (make_symbol_overload_list): Likewise.
* cris-tdep.c (push_stack_item): Likewise.
(cris_gdbarch_init): Likewise.
* ctf.c (ctf_trace_file_writer_new): Likewise.
* dbxread.c (init_header_files): Likewise.
(add_new_header_file): Likewise.
(init_bincl_list): Likewise.
(dbx_end_psymtab): Likewise.
(start_psymtab): Likewise.
(dbx_end_psymtab): Likewise.
* dcache.c (dcache_init): Likewise.
* dictionary.c (dict_create_hashed): Likewise.
(dict_create_hashed_expandable): Likewise.
(dict_create_linear): Likewise.
(dict_create_linear_expandable): Likewise.
* dtrace-probe.c (dtrace_process_dof_probe): Likewise.
* dummy-frame.c (register_dummy_frame_dtor): Likewise.
* dwarf2-frame-tailcall.c (cache_new_ref1): Likewise.
* dwarf2-frame.c (dwarf2_build_frame_info): Likewise.
(decode_frame_entry_1): Likewise.
* dwarf2expr.c (new_dwarf_expr_context): Likewise.
* dwarf2loc.c (dwarf2_compile_expr_to_ax): Likewise.
* dwarf2read.c (dwarf2_has_info): Likewise.
(create_signatured_type_table_from_index): Likewise.
(dwarf2_read_index): Likewise.
(dw2_get_file_names_reader): Likewise.
(create_all_type_units): Likewise.
(read_cutu_die_from_dwo): Likewise.
(init_tu_and_read_dwo_dies): Likewise.
(init_cutu_and_read_dies): Likewise.
(create_all_comp_units): Likewise.
(queue_comp_unit): Likewise.
(inherit_abstract_dies): Likewise.
(read_call_site_scope): Likewise.
(dwarf2_add_field): Likewise.
(dwarf2_add_typedef): Likewise.
(dwarf2_add_member_fn): Likewise.
(attr_to_dynamic_prop): Likewise.
(abbrev_table_alloc_abbrev): Likewise.
(abbrev_table_read_table): Likewise.
(add_include_dir): Likewise.
(add_file_name): Likewise.
(dwarf_decode_line_header): Likewise.
(dwarf2_const_value_attr): Likewise.
(dwarf_alloc_block): Likewise.
(parse_macro_definition): Likewise.
(set_die_type): Likewise.
(write_psymtabs_to_index): Likewise.
(create_cus_from_index): Likewise.
(dwarf2_create_include_psymtab): Likewise.
(process_psymtab_comp_unit_reader): Likewise.
(build_type_psymtab_dependencies): Likewise.
(read_comp_units_from_section): Likewise.
(compute_compunit_symtab_includes): Likewise.
(create_dwo_unit_in_dwp_v1): Likewise.
(create_dwo_unit_in_dwp_v2): Likewise.
(read_func_scope): Likewise.
(process_structure_scope): Likewise.
(mark_common_block_symbol_computed): Likewise.
(load_partial_dies): Likewise.
(dwarf2_symbol_mark_computed): Likewise.
* elfread.c (elf_symfile_segments): Likewise.
(elf_read_minimal_symbols): Likewise.
* environ.c (make_environ): Likewise.
* eval.c (evaluate_subexp_standard): Likewise.
* event-loop.c (create_file_handler): Likewise.
(create_async_signal_handler): Likewise.
(create_async_event_handler): Likewise.
(create_timer): Likewise.
* exec.c (build_section_table): Likewise.
* fbsd-nat.c (fbsd_remember_child): Likewise.
* fork-child.c (fork_inferior): Likewise.
* frv-tdep.c (new_variant): Likewise.
* gdbarch.sh (gdbarch_alloc): Likewise.
(append_name): Likewise.
* gdbtypes.c (rank_function): Likewise.
(copy_type_recursive): Likewise.
(add_dyn_prop): Likewise.
* gnu-nat.c (make_proc): Likewise.
(make_inf): Likewise.
(gnu_write_inferior): Likewise.
* gnu-v3-abi.c (build_gdb_vtable_type): Likewise.
(build_std_type_info_type): Likewise.
* guile/scm-param.c (compute_enum_list): Likewise.
* guile/scm-utils.c (gdbscm_parse_function_args): Likewise.
* guile/scm-value.c (gdbscm_value_call): Likewise.
* h8300-tdep.c (h8300_gdbarch_init): Likewise.
* hppa-tdep.c (hppa_init_objfile_priv_data): Likewise.
(read_unwind_info): Likewise.
* ia64-tdep.c (ia64_gdbarch_init): Likewise.
* infcall.c (dummy_frame_context_saver_setup): Likewise.
(call_function_by_hand_dummy): Likewise.
* infcmd.c (step_once): Likewise.
(finish_forward): Likewise.
(attach_command): Likewise.
(notice_new_inferior): Likewise.
* inferior.c (add_inferior_silent): Likewise.
* infrun.c (add_displaced_stepping_state): Likewise.
(save_infcall_control_state): Likewise.
(save_inferior_ptid): Likewise.
(_initialize_infrun): Likewise.
* jit.c (bfd_open_from_target_memory): Likewise.
(jit_gdbarch_data_init): Likewise.
* language.c (add_language): Likewise.
* linespec.c (decode_line_2): Likewise.
* linux-nat.c (add_to_pid_list): Likewise.
(add_initial_lwp): Likewise.
* linux-thread-db.c (add_thread_db_info): Likewise.
(record_thread): Likewise.
(info_auto_load_libthread_db): Likewise.
* m32c-tdep.c (m32c_gdbarch_init): Likewise.
* m68hc11-tdep.c (m68hc11_gdbarch_init): Likewise.
* m68k-tdep.c (m68k_gdbarch_init): Likewise.
* m88k-tdep.c (m88k_analyze_prologue): Likewise.
* macrocmd.c (macro_define_command): Likewise.
* macroexp.c (gather_arguments): Likewise.
* macroscope.c (sal_macro_scope): Likewise.
* macrotab.c (new_macro_table): Likewise.
* mdebugread.c (push_parse_stack): Likewise.
(parse_partial_symbols): Likewise.
(parse_symbol): Likewise.
(psymtab_to_symtab_1): Likewise.
(new_block): Likewise.
(new_psymtab): Likewise.
(mdebug_build_psymtabs): Likewise.
(add_pending): Likewise.
(elfmdebug_build_psymtabs): Likewise.
* mep-tdep.c (mep_gdbarch_init): Likewise.
* mi/mi-main.c (mi_execute_command): Likewise.
* mi/mi-parse.c (mi_parse_argv): Likewise.
* minidebug.c (lzma_open): Likewise.
* minsyms.c (terminate_minimal_symbol_table): Likewise.
* mips-linux-nat.c (mips_linux_insert_watchpoint): Likewise.
* mips-tdep.c (mips_gdbarch_init): Likewise.
* mn10300-tdep.c (mn10300_gdbarch_init): Likewise.
* msp430-tdep.c (msp430_gdbarch_init): Likewise.
* mt-tdep.c (mt_registers_info): Likewise.
* nat/aarch64-linux.c (aarch64_linux_new_thread): Likewise.
* nat/linux-btrace.c (linux_enable_bts): Likewise.
(linux_enable_pt): Likewise.
* nat/linux-osdata.c (linux_xfer_osdata_processes): Likewise.
(linux_xfer_osdata_processgroups): Likewise.
* nios2-tdep.c (nios2_gdbarch_init): Likewise.
* nto-procfs.c (procfs_meminfo): Likewise.
* objc-lang.c (start_msglist): Likewise.
(selectors_info): Likewise.
(classes_info): Likewise.
(find_methods): Likewise.
* objfiles.c (allocate_objfile): Likewise.
(update_section_map): Likewise.
* osabi.c (gdbarch_register_osabi): Likewise.
(gdbarch_register_osabi_sniffer): Likewise.
* parse.c (start_arglist): Likewise.
* ppc-linux-nat.c (hwdebug_find_thread_points_by_tid): Likewise.
(hwdebug_insert_point): Likewise.
* printcmd.c (display_command): Likewise.
(ui_printf): Likewise.
* procfs.c (create_procinfo): Likewise.
(load_syscalls): Likewise.
(proc_get_LDT_entry): Likewise.
(proc_update_threads): Likewise.
* prologue-value.c (make_pv_area): Likewise.
(pv_area_store): Likewise.
* psymtab.c (extend_psymbol_list): Likewise.
(init_psymbol_list): Likewise.
(allocate_psymtab): Likewise.
* python/py-inferior.c (add_thread_object): Likewise.
* python/py-param.c (compute_enum_values): Likewise.
* python/py-value.c (valpy_call): Likewise.
* python/py-varobj.c (py_varobj_iter_next): Likewise.
* python/python.c (ensure_python_env): Likewise.
* record-btrace.c (record_btrace_start_replaying): Likewise.
* record-full.c (record_full_reg_alloc): Likewise.
(record_full_mem_alloc): Likewise.
(record_full_end_alloc): Likewise.
(record_full_core_xfer_partial): Likewise.
* regcache.c (get_thread_arch_aspace_regcache): Likewise.
* remote-fileio.c (remote_fileio_init_fd_map): Likewise.
* remote-notif.c (remote_notif_state_allocate): Likewise.
* remote.c (demand_private_info): Likewise.
(remote_notif_stop_alloc_reply): Likewise.
(remote_enable_btrace): Likewise.
* reverse.c (save_bookmark_command): Likewise.
* rl78-tdep.c (rl78_gdbarch_init): Likewise.
* rx-tdep.c (rx_gdbarch_init): Likewise.
* s390-linux-nat.c (s390_insert_watchpoint): Likewise.
* ser-go32.c (dos_get_tty_state): Likewise.
(dos_copy_tty_state): Likewise.
* ser-mingw.c (ser_windows_open): Likewise.
(ser_console_wait_handle): Likewise.
(ser_console_get_tty_state): Likewise.
(make_pipe_state): Likewise.
(net_windows_open): Likewise.
* ser-unix.c (hardwire_get_tty_state): Likewise.
(hardwire_copy_tty_state): Likewise.
* solib-aix.c (solib_aix_new_lm_info): Likewise.
* solib-dsbt.c (dsbt_current_sos): Likewise.
(dsbt_relocate_main_executable): Likewise.
* solib-frv.c (frv_current_sos): Likewise.
(frv_relocate_main_executable): Likewise.
* solib-spu.c (spu_bfd_fopen): Likewise.
* solib-svr4.c (lm_info_read): Likewise.
(svr4_copy_library_list): Likewise.
(svr4_default_sos): Likewise.
* source.c (find_source_lines): Likewise.
(line_info): Likewise.
(add_substitute_path_rule): Likewise.
* spu-linux-nat.c (spu_bfd_open): Likewise.
* spu-tdep.c (info_spu_dma_cmdlist): Likewise.
* stabsread.c (dbx_lookup_type): Likewise.
(read_type): Likewise.
(read_member_functions): Likewise.
(read_struct_fields): Likewise.
(read_baseclasses): Likewise.
(read_args): Likewise.
(_initialize_stabsread): Likewise.
* stack.c (func_command): Likewise.
* stap-probe.c (handle_stap_probe): Likewise.
* symfile.c (addrs_section_sort): Likewise.
(addr_info_make_relative): Likewise.
(load_section_callback): Likewise.
(add_symbol_file_command): Likewise.
(init_filename_language_table): Likewise.
* symtab.c (create_filename_seen_cache): Likewise.
(sort_search_symbols_remove_dups): Likewise.
(search_symbols): Likewise.
* target.c (make_cleanup_restore_target_terminal): Likewise.
* thread.c (new_thread): Likewise.
(enable_thread_stack_temporaries): Likewise.
(make_cleanup_restore_current_thread): Likewise.
(thread_apply_all_command): Likewise.
* tic6x-tdep.c (tic6x_gdbarch_init): Likewise.
* top.c (gdb_readline_wrapper): Likewise.
* tracefile-tfile.c (tfile_trace_file_writer_new): Likewise.
* tracepoint.c (trace_find_line_command): Likewise.
(all_tracepoint_actions_and_cleanup): Likewise.
(make_cleanup_restore_current_traceframe): Likewise.
(get_uploaded_tp): Likewise.
(get_uploaded_tsv): Likewise.
* tui/tui-data.c (tui_alloc_generic_win_info): Likewise.
(tui_alloc_win_info): Likewise.
(tui_alloc_content): Likewise.
(tui_add_content_elements): Likewise.
* tui/tui-disasm.c (tui_find_disassembly_address): Likewise.
(tui_set_disassem_content): Likewise.
* ui-file.c (ui_file_new): Likewise.
(stdio_file_new): Likewise.
(tee_file_new): Likewise.
* utils.c (make_cleanup_restore_integer): Likewise.
(add_internal_problem_command): Likewise.
* v850-tdep.c (v850_gdbarch_init): Likewise.
* valops.c (find_oload_champ): Likewise.
* value.c (allocate_value_lazy): Likewise.
(record_latest_value): Likewise.
(create_internalvar): Likewise.
* varobj.c (install_variable): Likewise.
(new_variable): Likewise.
(new_root_variable): Likewise.
(cppush): Likewise.
(_initialize_varobj): Likewise.
* windows-nat.c (windows_make_so): Likewise.
* x86-nat.c (x86_add_process): Likewise.
* xcoffread.c (arrange_linetable): Likewise.
(allocate_include_entry): Likewise.
(process_linenos): Likewise.
(SYMBOL_DUP): Likewise.
(xcoff_start_psymtab): Likewise.
(xcoff_end_psymtab): Likewise.
* xml-support.c (gdb_xml_parse_attr_ulongest): Likewise.
* xtensa-tdep.c (xtensa_register_type): Likewise.
* gdbarch.c: Regenerate.
* gdbarch.h: Regenerate.
2015-08-25 Don Breazeal <donb@codesourcery.com>
* infrun.c (follow_exec): Re-order operations for

2
gdb/aarch64-linux-nat.c
View File

@ -90,7 +90,7 @@ aarch64_add_process (pid_t pid)
{
struct aarch64_process_info *proc;
proc = xcalloc (1, sizeof (*proc));
proc = XCNEW (struct aarch64_process_info);
proc->pid = pid;
proc->next = aarch64_process_list;

2
gdb/aarch64-tdep.c
View File

@ -2773,7 +2773,7 @@ aarch64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
return best_arch->gdbarch;
}
tdep = xcalloc (1, sizeof (struct gdbarch_tdep));
tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
/* This should be low enough for everything. */

4
gdb/ada-exp.y
View File

@ -1163,8 +1163,8 @@ static void
write_ambiguous_var (struct parser_state *par_state,
const struct block *block, char *name, int len)
{
struct symbol *sym =
obstack_alloc (&temp_parse_space, sizeof (struct symbol));
struct symbol *sym = XOBNEW (&temp_parse_space, struct symbol);
memset (sym, 0, sizeof (struct symbol));
SYMBOL_DOMAIN (sym) = UNDEF_DOMAIN;
SYMBOL_LINKAGE_NAME (sym) = obstack_copy0 (&temp_parse_space, name, len);

9
gdb/ada-lang.c
View File

@ -3300,7 +3300,7 @@ resolve_subexp (struct expression **expp, int *pos, int deprocedure_p,
error (_("Unexpected operator during name resolution"));
}
argvec = (struct value * *) alloca (sizeof (struct value *) * (nargs + 1));
argvec = XALLOCAVEC (struct value *, nargs + 1);
for (i = 0; i < nargs; i += 1)
argvec[i] = resolve_subexp (expp, pos, 1, NULL);
argvec[i] = NULL;
@ -3741,7 +3741,7 @@ int
user_select_syms (struct block_symbol *syms, int nsyms, int max_results)
{
int i;
int *chosen = (int *) alloca (sizeof (int) * nsyms);
int *chosen = XALLOCAVEC (int , nsyms);
int n_chosen;
int first_choice = (max_results == 1) ? 1 : 2;
const char *select_mode = multiple_symbols_select_mode ();
@ -9790,7 +9790,7 @@ assign_aggregate (struct value *container,
num_specs = num_component_specs (exp, *pos - 3);
max_indices = 4 * num_specs + 4;
indices = alloca (max_indices * sizeof (indices[0]));
indices = XALLOCAVEC (LONGEST, max_indices);
indices[0] = indices[1] = low_index - 1;
indices[2] = indices[3] = high_index + 1;
num_indices = 4;
@ -10600,8 +10600,7 @@ ada_evaluate_subexp (struct type *expect_type, struct expression *exp,
/* Allocate arg vector, including space for the function to be
called in argvec[0] and a terminating NULL. */
nargs = longest_to_int (exp->elts[pc + 1].longconst);
argvec =
(struct value **) alloca (sizeof (struct value *) * (nargs + 2));
argvec = XALLOCAVEC (struct value *, nargs + 2);
if (exp->elts[*pos].opcode == OP_VAR_VALUE
&& SYMBOL_DOMAIN (exp->elts[pc + 5].symbol) == UNDEF_DOMAIN)

4
gdb/addrmap.c
View File

@ -244,7 +244,7 @@ struct addrmap_mutable
static splay_tree_key
allocate_key (struct addrmap_mutable *map, CORE_ADDR addr)
{
CORE_ADDR *key = obstack_alloc (map->obstack, sizeof (*key));
CORE_ADDR *key = XOBNEW (map->obstack, CORE_ADDR);
*key = addr;
return (splay_tree_key) key;
@ -567,7 +567,7 @@ splay_compare_CORE_ADDR_ptr (splay_tree_key ak, splay_tree_key bk)
struct addrmap *
addrmap_create_mutable (struct obstack *obstack)
{
struct addrmap_mutable *map = obstack_alloc (obstack, sizeof (*map));
struct addrmap_mutable *map = XOBNEW (obstack, struct addrmap_mutable);
map->addrmap.funcs = &addrmap_mutable_funcs;
map->obstack = obstack;

8
gdb/aix-thread.c
View File

@ -703,7 +703,7 @@ sync_threadlists (void)
pcount = 0;
psize = 1;
pbuf = (struct pd_thread *) xmalloc (psize * sizeof *pbuf);
pbuf = XNEWVEC (struct pd_thread, psize);
for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT)
{
@ -740,7 +740,7 @@ sync_threadlists (void)
gcount = 0;
iterate_over_threads (giter_count, &gcount);
g = gbuf = (struct thread_info **) xmalloc (gcount * sizeof *gbuf);
g = gbuf = XNEWVEC (struct thread_info *, gcount);
iterate_over_threads (giter_accum, &g);
qsort (gbuf, gcount, sizeof *gbuf, gcmp);
@ -757,7 +757,7 @@ sync_threadlists (void)
else if (gi == gcount)
{
thread = add_thread (ptid_build (infpid, 0, pbuf[pi].pthid));
thread->priv = xmalloc (sizeof (struct private_thread_info));
thread->priv = XNEW (struct private_thread_info);
thread->priv->pdtid = pbuf[pi].pdtid;
thread->priv->tid = pbuf[pi].tid;
pi++;
@ -789,7 +789,7 @@ sync_threadlists (void)
else
{
thread = add_thread (pptid);
thread->priv = xmalloc (sizeof (struct private_thread_info));
thread->priv = XNEW (struct private_thread_info);
thread->priv->pdtid = pdtid;
thread->priv->tid = tid;
pi++;

5
gdb/alpha-tdep.c
View File

@ -305,8 +305,7 @@ alpha_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
int len;
int offset;
};
struct alpha_arg *alpha_args
= (struct alpha_arg *) alloca (nargs * sizeof (struct alpha_arg));
struct alpha_arg *alpha_args = XALLOCAVEC (struct alpha_arg, nargs);
struct alpha_arg *m_arg;
gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];
int required_arg_regs;
@ -1754,7 +1753,7 @@ alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
if (arches != NULL)
return arches->gdbarch;
tdep = xmalloc (sizeof (struct gdbarch_tdep));
tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
/* Lowest text address. This is used by heuristic_proc_start()

4
gdb/amd64-windows-tdep.c
View File

@ -158,7 +158,7 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs,
{
int reg_idx = 0;
int i;
struct value **stack_args = alloca (nargs * sizeof (struct value *));
struct value **stack_args = XALLOCAVEC (struct value *, nargs);
int num_stack_args = 0;
int num_elements = 0;
int element = 0;
@ -169,7 +169,7 @@ amd64_windows_push_arguments (struct regcache *regcache, int nargs,
in inferior memory. So use a copy of the ARGS table, to avoid
modifying the original one. */
{
struct value **args1 = alloca (nargs * sizeof (struct value *));
struct value **args1 = XALLOCAVEC (struct value *, nargs);
memcpy (args1, args, nargs * sizeof (struct value *));
sp = amd64_windows_adjust_args_passed_by_pointer (args1, nargs, sp);

2
gdb/arm-linux-nat.c
View File

@ -791,7 +791,7 @@ arm_linux_add_process (pid_t pid)
{
struct arm_linux_process_info *proc;
proc = xcalloc (1, sizeof (*proc));
proc = XCNEW (struct arm_linux_process_info);
proc->pid = pid;
proc->next = arm_linux_process_list;

3
gdb/arm-linux-tdep.c
View File

@ -1100,8 +1100,7 @@ arm_linux_displaced_step_copy_insn (struct gdbarch *gdbarch,
CORE_ADDR from, CORE_ADDR to,
struct regcache *regs)
{
struct displaced_step_closure *dsc
= xmalloc (sizeof (struct displaced_step_closure));
struct displaced_step_closure *dsc = XNEW (struct displaced_step_closure);
/* Detect when we enter an (inaccessible by GDB) Linux kernel helper, and
stop at the return location. */

12
gdb/arm-tdep.c
View File

@ -3402,7 +3402,7 @@ static struct stack_item *
push_stack_item (struct stack_item *prev, const void *contents, int len)
{
struct stack_item *si;
si = xmalloc (sizeof (struct stack_item));
si = XNEW (struct stack_item);
si->data = xmalloc (len);
si->len = len;
si->prev = prev;
@ -8737,8 +8737,8 @@ arm_displaced_step_copy_insn (struct gdbarch *gdbarch,
CORE_ADDR from, CORE_ADDR to,
struct regcache *regs)
{
struct displaced_step_closure *dsc
= xmalloc (sizeof (struct displaced_step_closure));
struct displaced_step_closure *dsc = XNEW (struct displaced_step_closure);
arm_process_displaced_insn (gdbarch, from, to, regs, dsc);
arm_displaced_init_closure (gdbarch, from, to, dsc);
@ -10290,7 +10290,7 @@ arm_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
return best_arch->gdbarch;
}
tdep = xcalloc (1, sizeof (struct gdbarch_tdep));
tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
/* Record additional information about the architecture we are defining.
@ -10571,8 +10571,8 @@ _initialize_arm_tdep (void)
/* Initialize the array that will be passed to
add_setshow_enum_cmd(). */
valid_disassembly_styles
= xmalloc ((num_disassembly_options + 1) * sizeof (char *));
valid_disassembly_styles = XNEWVEC (const char *,
num_disassembly_options + 1);
for (i = 0; i < num_disassembly_options; i++)
{
numregs = get_arm_regnames (i, &setname, &setdesc, &regnames);

2
gdb/avr-tdep.c
View File

@ -1205,7 +1205,7 @@ static struct stack_item *
push_stack_item (struct stack_item *prev, const bfd_byte *contents, int len)
{
struct stack_item *si;
si = xmalloc (sizeof (struct stack_item));
si = XNEW (struct stack_item);
si->data = xmalloc (len);
si->len = len;
si->prev = prev;

2
gdb/ax-general.c
View File

@ -41,7 +41,7 @@ static void generic_ext (struct agent_expr *x, enum agent_op op, int n);
struct agent_expr *
new_agent_expr (struct gdbarch *gdbarch, CORE_ADDR scope)
{
struct agent_expr *x = xmalloc (sizeof (*x));
struct agent_expr *x = XNEW (struct agent_expr);
x->len = 0;
x->size = 1; /* Change this to a larger value once

3
gdb/block.c
View File

@ -351,8 +351,7 @@ block_initialize_namespace (struct block *block, struct obstack *obstack)
{
if (BLOCK_NAMESPACE (block) == NULL)
{
BLOCK_NAMESPACE (block)
= obstack_alloc (obstack, sizeof (struct block_namespace_info));
BLOCK_NAMESPACE (block) = XOBNEW (obstack, struct block_namespace_info);
BLOCK_NAMESPACE (block)->scope = NULL;
BLOCK_NAMESPACE (block)->using_decl = NULL;
}

25
gdb/breakpoint.c
View File

@ -725,11 +725,11 @@ clear_breakpoint_hit_counts (void)
static struct counted_command_line *
alloc_counted_command_line (struct command_line *commands)
{
struct counted_command_line *result
= xmalloc (sizeof (struct counted_command_line));
struct counted_command_line *result = XNEW (struct counted_command_line);
result->refc = 1;
result->commands = commands;
return result;
}
@ -3395,8 +3395,8 @@ get_breakpoint_objfile_data (struct objfile *objfile)
bp_objfile_data = objfile_data (objfile, breakpoint_objfile_key);
if (bp_objfile_data == NULL)
{
bp_objfile_data = obstack_alloc (&objfile->objfile_obstack,
sizeof (*bp_objfile_data));
bp_objfile_data =
XOBNEW (&objfile->objfile_obstack, struct breakpoint_objfile_data);
memset (bp_objfile_data, 0, sizeof (*bp_objfile_data));
set_objfile_data (objfile, breakpoint_objfile_key, bp_objfile_data);
@ -9081,8 +9081,7 @@ update_dprintf_command_list (struct breakpoint *b)
gdb_assert (printf_line != NULL);
/* Manufacture a printf sequence. */
{
struct command_line *printf_cmd_line
= xmalloc (sizeof (struct command_line));
struct command_line *printf_cmd_line = XNEW (struct command_line);
printf_cmd_line->control_type = simple_control;
printf_cmd_line->body_count = 0;
@ -9374,8 +9373,7 @@ parse_breakpoint_sals (const struct event_location *location,
CORE_ADDR pc;
init_sal (&sal); /* Initialize to zeroes. */
lsal.sals.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
lsal.sals.sals = XNEW (struct symtab_and_line);
/* Set sal's pspace, pc, symtab, and line to the values
corresponding to the last call to print_frame_info.
@ -9602,7 +9600,7 @@ decode_static_tracepoint_spec (const char **arg_p)
error (_("No known static tracepoint marker named %s"), marker_str);
sals.nelts = VEC_length(static_tracepoint_marker_p, markers);
sals.sals = xmalloc (sizeof *sals.sals * sals.nelts);
sals.sals = XNEWVEC (struct symtab_and_line, sals.nelts);
for (i = 0; i < sals.nelts; i++)
{
@ -11592,8 +11590,8 @@ until_break_command (char *arg, int from_tty, int anywhere)
if (target_can_async_p () && is_running (inferior_ptid))
{
struct until_break_command_continuation_args *args;
args = xmalloc (sizeof (*args));
struct until_break_command_continuation_args *args =
XNEW (struct until_break_command_continuation_args);
args->breakpoint = breakpoint;
args->breakpoint2 = breakpoint2;
@ -11827,8 +11825,7 @@ clear_command (char *arg, int from_tty)
}
else
{
sals.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
sals.sals = XNEW (struct symtab_and_line);
make_cleanup (xfree, sals.sals);
init_sal (&sal); /* Initialize to zeroes. */
@ -12245,7 +12242,7 @@ update_global_location_list (enum ugll_insert_mode insert_mode)
for (loc = b->loc; loc; loc = loc->next)
bp_location_count++;
bp_location = xmalloc (sizeof (*bp_location) * bp_location_count);
bp_location = XNEWVEC (struct bp_location *, bp_location_count);
locp = bp_location;
ALL_BREAKPOINTS (b)
for (loc = b->loc; loc; loc = loc->next)

6
gdb/btrace.c
View File

@ -193,7 +193,7 @@ ftrace_new_function (struct btrace_function *prev,
{
struct btrace_function *bfun;
bfun = xzalloc (sizeof (*bfun));
bfun = XCNEW (struct btrace_function);
bfun->msym = mfun;
bfun->sym = fun;
@ -2196,7 +2196,7 @@ btrace_set_insn_history (struct btrace_thread_info *btinfo,
const struct btrace_insn_iterator *end)
{
if (btinfo->insn_history == NULL)
btinfo->insn_history = xzalloc (sizeof (*btinfo->insn_history));
btinfo->insn_history = XCNEW (struct btrace_insn_history);
btinfo->insn_history->begin = *begin;
btinfo->insn_history->end = *end;
@ -2212,7 +2212,7 @@ btrace_set_call_history (struct btrace_thread_info *btinfo,
gdb_assert (begin->btinfo == end->btinfo);
if (btinfo->call_history == NULL)
btinfo->call_history = xzalloc (sizeof (*btinfo->call_history));
btinfo->call_history = XCNEW (struct btrace_call_history);
btinfo->call_history->begin = *begin;
btinfo->call_history->end = *end;

18
gdb/buildsym.c
View File

@ -232,7 +232,7 @@ add_symbol_to_list (struct symbol *symbol, struct pending **listhead)
}
else
{
link = (struct pending *) xmalloc (sizeof (struct pending));
link = XNEW (struct pending);
}
link->next = *listhead;
@ -550,8 +550,7 @@ record_pending_block (struct objfile *objfile, struct block *block,
if (pending_blocks == NULL)
obstack_init (&pending_block_obstack);
pblock = (struct pending_block *)
obstack_alloc (&pending_block_obstack, sizeof (struct pending_block));
pblock = XOBNEW (&pending_block_obstack, struct pending_block);
pblock->block = block;
if (opblock)
{
@ -705,7 +704,7 @@ start_subfile (const char *name)
/* This subfile is not known. Add an entry for it. */
subfile = (struct subfile *) xmalloc (sizeof (struct subfile));
subfile = XNEW (struct subfile);
memset (subfile, 0, sizeof (struct subfile));
subfile->buildsym_compunit = buildsym_compunit;
@ -773,8 +772,7 @@ start_buildsym_compunit (struct objfile *objfile, const char *comp_dir)
{
struct buildsym_compunit *bscu;
bscu = (struct buildsym_compunit *)
xmalloc (sizeof (struct buildsym_compunit));
bscu = XNEW (struct buildsym_compunit);
memset (bscu, 0, sizeof (struct buildsym_compunit));
bscu->objfile = objfile;
@ -866,8 +864,7 @@ patch_subfile_names (struct subfile *subfile, char *name)
void
push_subfile (void)
{
struct subfile_stack *tem
= (struct subfile_stack *) xmalloc (sizeof (struct subfile_stack));
struct subfile_stack *tem = XNEW (struct subfile_stack);
tem->next = subfile_stack;
subfile_stack = tem;
@ -1265,7 +1262,7 @@ end_symtab_get_static_block (CORE_ADDR end_addr, int expandable, int required)
for (pb = pending_blocks; pb != NULL; pb = pb->next)
count++;
barray = xmalloc (sizeof (*barray) * count);
barray = XNEWVEC (struct block *, count);
back_to = make_cleanup (xfree, barray);
bp = barray;
@ -1768,8 +1765,7 @@ buildsym_init (void)
if (context_stack == NULL)
{
context_stack_size = INITIAL_CONTEXT_STACK_SIZE;
context_stack = (struct context_stack *)
xmalloc (context_stack_size * sizeof (struct context_stack));
context_stack = XNEWVEC (struct context_stack, context_stack_size);
}
/* Ensure the really_free_pendings cleanup was called after

2
gdb/cli/cli-cmds.c
View File

@ -636,7 +636,7 @@ source_command (char *args, int from_tty)
{
struct cleanup *old_cleanups;
char *file = args;
int *old_source_verbose = xmalloc (sizeof(int));
int *old_source_verbose = XNEW (int);
int search_path = 0;
*old_source_verbose = source_verbose;

3
gdb/cli/cli-decode.c
View File

@ -192,8 +192,7 @@ struct cmd_list_element *
add_cmd (const char *name, enum command_class theclass, cmd_cfunc_ftype *fun,
const char *doc, struct cmd_list_element **list)
{
struct cmd_list_element *c
= (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element));
struct cmd_list_element *c = XNEW (struct cmd_list_element);
struct cmd_list_element *p, *iter;
/* Turn each alias of the old command into an alias of the new

27
gdb/cli/cli-script.c
View File

@ -109,15 +109,12 @@ build_command_line (enum command_control_type type, char *args)
error (_("if/while commands require arguments."));
gdb_assert (args != NULL);
cmd = (struct command_line *) xmalloc (sizeof (struct command_line));
cmd = XNEW (struct command_line);
cmd->next = NULL;
cmd->control_type = type;
cmd->body_count = 1;
cmd->body_list
= (struct command_line **) xmalloc (sizeof (struct command_line *)
* cmd->body_count);
memset (cmd->body_list, 0, sizeof (struct command_line *) * cmd->body_count);
cmd->body_list = XCNEWVEC (struct command_line *, cmd->body_count);
cmd->line = xstrdup (args);
return cmd;
@ -722,7 +719,7 @@ setup_user_args (char *p)
struct cleanup *old_chain;
unsigned int arg_count = 0;
args = (struct user_args *) xmalloc (sizeof (struct user_args));
args = XNEW (struct user_args);
memset (args, 0, sizeof (struct user_args));
args->next = user_args;
@ -918,11 +915,9 @@ realloc_body_list (struct command_line *command, int new_length)
if (new_length <= n)
return;
body_list = (struct command_line **)
xmalloc (sizeof (struct command_line *) * new_length);
body_list = XCNEWVEC (struct command_line *, new_length);
memcpy (body_list, command->body_list, sizeof (struct command_line *) * n);
memset (body_list + n, 0, sizeof (struct command_line *) * (new_length - n));
xfree (command->body_list);
command->body_list = body_list;
@ -1076,8 +1071,7 @@ process_next_line (char *p, struct command_line **command, int parse_commands,
}
else if (p_end - p == 10 && startswith (p, "loop_break"))
{
*command = (struct command_line *)
xmalloc (sizeof (struct command_line));
*command = XNEW (struct command_line);
(*command)->next = NULL;
(*command)->line = NULL;
(*command)->control_type = break_control;
@ -1086,8 +1080,7 @@ process_next_line (char *p, struct command_line **command, int parse_commands,
}
else if (p_end - p == 13 && startswith (p, "loop_continue"))
{
*command = (struct command_line *)
xmalloc (sizeof (struct command_line));
*command = XNEW (struct command_line);
(*command)->next = NULL;
(*command)->line = NULL;
(*command)->control_type = continue_control;
@ -1101,8 +1094,7 @@ process_next_line (char *p, struct command_line **command, int parse_commands,
if (!parse_commands || not_handled)
{
/* A normal command. */
*command = (struct command_line *)
xmalloc (sizeof (struct command_line));
*command = XNEW (struct command_line);
(*command)->next = NULL;
(*command)->line = savestring (p, p_end - p);
(*command)->control_type = simple_control;
@ -1414,7 +1406,7 @@ copy_command_lines (struct command_line *cmds)
if (cmds)
{
result = (struct command_line *) xmalloc (sizeof (struct command_line));
result = XNEW (struct command_line);
result->next = copy_command_lines (cmds->next);
result->line = xstrdup (cmds->line);
@ -1424,8 +1416,7 @@ copy_command_lines (struct command_line *cmds)
{
int i;
result->body_list = (struct command_line **)
xmalloc (sizeof (struct command_line *) * cmds->body_count);
result->body_list = XNEWVEC (struct command_line *, cmds->body_count);
for (i = 0; i < cmds->body_count; i++)
result->body_list[i] = copy_command_lines (cmds->body_list[i]);

4
gdb/cli/cli-setshow.c
View File

@ -475,8 +475,8 @@ do_set_command (const char *arg, int from_tty, struct cmd_list_element *c)
p = p->prefix;
}
cp = name = xmalloc (length);
cmds = xmalloc (sizeof (struct cmd_list_element *) * i);
cp = name = (char *) xmalloc (length);
cmds = XNEWVEC (struct cmd_list_element *, i);
/* Track back through filed 'prefix' and cache them in CMDS. */
for (i = 0, p = c; p != NULL; i++)

3
gdb/coff-pe-read.c
View File

@ -356,8 +356,7 @@ read_pe_exported_syms (struct objfile *objfile)
char const *target = bfd_get_target (objfile->obfd);
section_data = xzalloc (PE_SECTION_TABLE_SIZE
* sizeof (struct read_pe_section_data));
section_data = XCNEWVEC (struct read_pe_section_data, PE_SECTION_TABLE_SIZE);
make_cleanup (free_current_contents, &section_data);

11
gdb/coffread.c
View File

@ -253,8 +253,7 @@ coff_locate_sections (bfd *abfd, asection *sectp, void *csip)
{
struct stab_section_list *n, **pn;
n = ((struct stab_section_list *)
xmalloc (sizeof (struct stab_section_list)));
n = XNEW (struct stab_section_list);
n->section = sectp;
n->next = NULL;
for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next)
@ -841,9 +840,7 @@ coff_symtab_read (long symtab_offset, unsigned int nsyms,
if (type_vector) /* Get rid of previous one. */
xfree (type_vector);
type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
type_vector = (struct type **)
xmalloc (type_vector_length * sizeof (struct type *));
memset (type_vector, 0, type_vector_length * sizeof (struct type *));
type_vector = XCNEWVEC (struct type *, type_vector_length);
coff_start_symtab (objfile, "");
@ -2102,7 +2099,7 @@ coff_read_struct_type (int index, int length, int lastsym,
case C_MOU:
/* Get space to record the next field's data. */
newobj = (struct nextfield *) alloca (sizeof (struct nextfield));
newobj = XALLOCA (struct nextfield);
newobj->next = list;
list = newobj;
@ -2119,7 +2116,7 @@ coff_read_struct_type (int index, int length, int lastsym,
case C_FIELD:
/* Get space to record the next field's data. */
newobj = (struct nextfield *) alloca (sizeof (struct nextfield));
newobj = XALLOCA (struct nextfield);
newobj->next = list;
list = newobj;

3
gdb/common/cleanups.c
View File

@ -79,8 +79,7 @@ static struct cleanup *
make_my_cleanup2 (struct cleanup **pmy_chain, make_cleanup_ftype *function,
void *arg, void (*free_arg) (void *))
{
struct cleanup *newobj
= (struct cleanup *) xmalloc (sizeof (struct cleanup));
struct cleanup *newobj = XNEW (struct cleanup);
struct cleanup *old_chain = *pmy_chain;
newobj->next = *pmy_chain;

5
gdb/common/common-exceptions.c
View File

@ -336,9 +336,8 @@ throw_it (enum return_reason reason, enum errors error, const char *fmt,
int old_size = exception_messages_size;
exception_messages_size = depth + 10;
exception_messages = (char **) xrealloc (exception_messages,
exception_messages_size
* sizeof (char *));
exception_messages = XRESIZEVEC (char *, exception_messages,
exception_messages_size);
memset (exception_messages + old_size, 0,
(exception_messages_size - old_size) * sizeof (char *));
}

2
gdb/common/filestuff.c
View File

@ -420,7 +420,7 @@ do_close_cleanup (void *arg)
struct cleanup *
make_cleanup_close (int fd)
{
int *saved_fd = xmalloc (sizeof (fd));
int *saved_fd = XNEW (int);
*saved_fd = fd;
return make_cleanup_dtor (do_close_cleanup, saved_fd, xfree);

3
gdb/common/format.c
View File

@ -103,8 +103,7 @@ parse_format_string (const char **arg)
max_pieces = strlen (string) + 2;
pieces = (struct format_piece *)
xmalloc (max_pieces * sizeof (struct format_piece));
pieces = XNEWVEC (struct format_piece, max_pieces);
next_frag = 0;

6
gdb/common/queue.h
View File

@ -125,8 +125,7 @@ QUEUE(TYPE) \
void \
queue_ ## TYPE ## _enque (QUEUE (TYPE) *q, TYPE v) \
{ \
QUEUE_ELEM (TYPE) *p \
= xmalloc (sizeof (QUEUE_ELEM (TYPE))); \
QUEUE_ELEM (TYPE) *p = XNEW (QUEUE_ELEM (TYPE)); \
\
gdb_assert (q != NULL); \
p->data = v; \
@ -229,9 +228,8 @@ queue_ ## TYPE ## _iterate (QUEUE (TYPE) *q, \
QUEUE (TYPE) * \
queue_ ## TYPE ## _alloc (void (*free_func) (TYPE)) \
{ \
QUEUE (TYPE) *q; \
QUEUE (TYPE) *q = XNEW (QUEUE (TYPE)); \
\
q = (QUEUE (TYPE) *) xmalloc (sizeof (QUEUE (TYPE))); \
q->head = NULL; \
q->tail = NULL; \
q->free_func = free_func; \

4
gdb/compile/compile-object-load.c
View File

@ -46,7 +46,7 @@ struct munmap_list
static void
munmap_list_add (struct munmap_list **headp, CORE_ADDR addr, CORE_ADDR size)
{
struct munmap_list *head_new = xmalloc (sizeof (*head_new));
struct munmap_list *head_new = XNEW (struct munmap_list);
head_new->next = *headp;
*headp = head_new;
@ -827,7 +827,7 @@ compile_object_load (const char *object_file, const char *source_file,
discard_cleanups (cleanups_free_objfile);
retval = xmalloc (sizeof (*retval));
retval = XNEW (struct compile_module);
retval->objfile = objfile;
retval->source_file = xstrdup (source_file);
retval->func_sym = func_sym;

2
gdb/compile/compile-object-run.c
View File

@ -155,7 +155,7 @@ compile_object_run (struct compile_module *module)
func_val = value_from_pointer (lookup_pointer_type (func_type),
BLOCK_START (SYMBOL_BLOCK_VALUE (func_sym)));
vargs = alloca (sizeof (*vargs) * TYPE_NFIELDS (func_type));
vargs = XALLOCAVEC (struct value *, TYPE_NFIELDS (func_type));
if (TYPE_NFIELDS (func_type) >= 1)
{
gdb_assert (regs_addr != 0);

2
gdb/compile/compile.c
View File

@ -338,7 +338,7 @@ append_args (int *argcp, char ***argvp, int argc, char **argv)
{
int argi;
*argvp = xrealloc (*argvp, (*argcp + argc + 1) * sizeof (**argvp));
*argvp = XRESIZEVEC (char *, *argvp, (*argcp + argc + 1));
for (argi = 0; argi < argc; argi++)
(*argvp)[(*argcp)++] = xstrdup (argv[argi]);

3
gdb/corefile.c
View File

@ -107,8 +107,7 @@ specify_exec_file_hook (void (*hook) (const char *))
{
/* If this is the first extra hook, initialize the hook
array. */
exec_file_extra_hooks = (hook_type *)
xmalloc (sizeof (hook_type));
exec_file_extra_hooks = XNEW (hook_type);
exec_file_extra_hooks[0] = deprecated_exec_file_display_hook;
deprecated_exec_file_display_hook = call_extra_exec_file_hooks;
exec_file_hook_count = 1;

3
gdb/cp-support.c
View File

@ -1192,8 +1192,7 @@ make_symbol_overload_list (const char *func_name,
sym_return_val_size = 100;
sym_return_val_index = 0;
sym_return_val = xmalloc ((sym_return_val_size + 1) *
sizeof (struct symbol *));
sym_return_val = XNEWVEC (struct symbol *, sym_return_val_size + 1);
sym_return_val[0] = NULL;
old_cleanups = make_cleanup (xfree, sym_return_val);

5
gdb/cris-tdep.c
View File

@ -671,8 +671,7 @@ struct stack_item
static struct stack_item *
push_stack_item (struct stack_item *prev, const gdb_byte *contents, int len)
{
struct stack_item *si;
si = xmalloc (sizeof (struct stack_item));
struct stack_item *si = XNEW (struct stack_item);
si->data = xmalloc (len);
si->len = len;
si->prev = prev;
@ -4037,7 +4036,7 @@ cris_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
}
/* No matching architecture was found. Create a new one. */
tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->cris_version = usr_cmd_cris_version;

3
gdb/ctf.c
View File

@ -810,8 +810,7 @@ static const struct trace_file_write_ops ctf_write_ops =
struct trace_file_writer *
ctf_trace_file_writer_new (void)
{
struct ctf_trace_file_writer *writer
= xmalloc (sizeof (struct ctf_trace_file_writer));
struct ctf_trace_file_writer *writer = XNEW (struct ctf_trace_file_writer);
writer->base.ops = &ctf_write_ops;

27
gdb/dbxread.c
View File

@ -319,7 +319,7 @@ void
init_header_files (void)
{
n_allocated_this_object_header_files = 10;
this_object_header_files = (int *) xmalloc (10 * sizeof (int));
this_object_header_files = XNEWVEC (int, 10);
}
/* Add header file number I for this object file
@ -405,9 +405,7 @@ add_new_header_file (char *name, int instance)
hfile->name = xstrdup (name);
hfile->instance = instance;
hfile->length = 10;
hfile->vector
= (struct type **) xmalloc (10 * sizeof (struct type *));
memset (hfile->vector, 0, 10 * sizeof (struct type *));
hfile->vector = XCNEWVEC (struct type *, 10);
add_this_object_header_file (i);
}
@ -890,8 +888,8 @@ static void
init_bincl_list (int number, struct objfile *objfile)
{
bincls_allocated = number;
next_bincl = bincl_list = (struct header_file_location *)
xmalloc (bincls_allocated * sizeof (struct header_file_location));
next_bincl = bincl_list = XNEWVEC (struct header_file_location,
bincls_allocated);
}
/* Add a bincl to the list. */
@ -2170,8 +2168,8 @@ start_psymtab (struct objfile *objfile, char *filename, CORE_ADDR textlow,
start_psymtab_common (objfile, filename, textlow,
global_syms, static_syms);
result->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct symloc));
result->read_symtab_private =
XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (result) = ldsymoff;
result->read_symtab = dbx_read_symtab;
SYMBOL_SIZE (result) = symbol_size;
@ -2288,9 +2286,9 @@ dbx_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
pst->number_of_dependencies = number_dependencies;
if (number_dependencies)
{
pst->dependencies = (struct partial_symtab **)
obstack_alloc (&objfile->objfile_obstack,
number_dependencies * sizeof (struct partial_symtab *));
pst->dependencies = XOBNEWVEC (&objfile->objfile_obstack,
struct partial_symtab *,
number_dependencies);
memcpy (pst->dependencies, dependency_list,
number_dependencies * sizeof (struct partial_symtab *));
}
@ -2303,7 +2301,7 @@ dbx_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
allocate_psymtab (include_list[i], objfile);
subpst->read_symtab_private =
obstack_alloc (&objfile->objfile_obstack, sizeof (struct symloc));
XOBNEW (&objfile->objfile_obstack, struct symloc);
LDSYMOFF (subpst) =
LDSYMLEN (subpst) =
subpst->textlow =
@ -2311,9 +2309,8 @@ dbx_end_psymtab (struct objfile *objfile, struct partial_symtab *pst,
/* We could save slight bits of space by only making one of these,
shared by the entire set of include files. FIXME-someday. */
subpst->dependencies = (struct partial_symtab **)
obstack_alloc (&objfile->objfile_obstack,
sizeof (struct partial_symtab *));
subpst->dependencies =
XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;

4
gdb/dcache.c
View File

@ -444,9 +444,7 @@ dcache_splay_tree_compare (splay_tree_key a, splay_tree_key b)
DCACHE *
dcache_init (void)
{
DCACHE *dcache;
dcache = (DCACHE *) xmalloc (sizeof (*dcache));
DCACHE *dcache = XNEW (DCACHE);
dcache->tree = splay_tree_new (dcache_splay_tree_compare,
NULL,

14
gdb/dictionary.c
View File

@ -361,7 +361,7 @@ dict_create_hashed (struct obstack *obstack,
struct symbol **buckets;
const struct pending *list_counter;
retval = obstack_alloc (obstack, sizeof (struct dictionary));
retval = XOBNEW (obstack, struct dictionary);
DICT_VECTOR (retval) = &dict_hashed_vector;
/* Calculate the number of symbols, and allocate space for them. */
@ -373,7 +373,7 @@ dict_create_hashed (struct obstack *obstack,
}
nbuckets = DICT_HASHTABLE_SIZE (nsyms);
DICT_HASHED_NBUCKETS (retval) = nbuckets;
buckets = obstack_alloc (obstack, nbuckets * sizeof (struct symbol *));
buckets = XOBNEWVEC (obstack, struct symbol *, nbuckets);
memset (buckets, 0, nbuckets * sizeof (struct symbol *));
DICT_HASHED_BUCKETS (retval) = buckets;
@ -399,9 +399,8 @@ dict_create_hashed (struct obstack *obstack,
extern struct dictionary *
dict_create_hashed_expandable (void)
{
struct dictionary *retval;
struct dictionary *retval = XNEW (struct dictionary);
retval = xmalloc (sizeof (struct dictionary));
DICT_VECTOR (retval) = &dict_hashed_expandable_vector;
DICT_HASHED_NBUCKETS (retval) = DICT_EXPANDABLE_INITIAL_CAPACITY;
DICT_HASHED_BUCKETS (retval) = xcalloc (DICT_EXPANDABLE_INITIAL_CAPACITY,
@ -425,7 +424,7 @@ dict_create_linear (struct obstack *obstack,
struct symbol **syms;
const struct pending *list_counter;
retval = obstack_alloc (obstack, sizeof (struct dictionary));
retval = XOBNEW (obstack, struct dictionary);
DICT_VECTOR (retval) = &dict_linear_vector;
/* Calculate the number of symbols, and allocate space for them. */
@ -436,7 +435,7 @@ dict_create_linear (struct obstack *obstack,
nsyms += list_counter->nsyms;
}
DICT_LINEAR_NSYMS (retval) = nsyms;
syms = obstack_alloc (obstack, nsyms * sizeof (struct symbol *));
syms = XOBNEWVEC (obstack, struct symbol *, nsyms );
DICT_LINEAR_SYMS (retval) = syms;
/* Now fill in the symbols. Start filling in from the back, so as
@ -464,9 +463,8 @@ dict_create_linear (struct obstack *obstack,
struct dictionary *
dict_create_linear_expandable (void)
{
struct dictionary *retval;
struct dictionary *retval = XNEW (struct dictionary);
retval = xmalloc (sizeof (struct dictionary));
DICT_VECTOR (retval) = &dict_linear_expandable_vector;
DICT_LINEAR_NSYMS (retval) = 0;
DICT_LINEAR_EXPANDABLE_CAPACITY (retval)

4
gdb/dtrace-probe.c
View File

@ -386,8 +386,8 @@ dtrace_process_dof_probe (struct objfile *objfile,
{
uint32_t probe_offset
= ((uint32_t *) offtab)[DOF_UINT (dof, probe->dofpr_offidx) + i];
struct dtrace_probe *ret
= obstack_alloc (&objfile->per_bfd->storage_obstack, sizeof (*ret));
struct dtrace_probe *ret =
XOBNEW (&objfile->per_bfd->storage_obstack, struct dtrace_probe);
ret->p.pops = &dtrace_probe_ops;
ret->p.arch = gdbarch;

2
gdb/dummy-frame.c
View File

@ -241,7 +241,7 @@ register_dummy_frame_dtor (struct frame_id dummy_id, ptid_t ptid,
dp = lookup_dummy_frame (&id);
gdb_assert (dp != NULL);
d = *dp;
list = xmalloc (sizeof (*list));
list = XNEW (struct dummy_frame_dtor_list);
list->next = d->dtor_list;
d->dtor_list = list;
list->dtor = dtor;

4
gdb/dwarf2-frame-tailcall.c
View File

@ -91,11 +91,9 @@ cache_eq (const void *arg1, const void *arg2)
static struct tailcall_cache *
cache_new_ref1 (struct frame_info *next_bottom_frame)
{
struct tailcall_cache *cache;
struct tailcall_cache *cache = XCNEW (struct tailcall_cache);
void **slot;
cache = xzalloc (sizeof (*cache));
cache->next_bottom_frame = next_bottom_frame;
cache->refc = 1;

11
gdb/dwarf2-frame.c
View File

@ -1908,9 +1908,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
if (find_cie (cie_table, cie_pointer))
return end;
cie = (struct dwarf2_cie *)
obstack_alloc (&unit->objfile->objfile_obstack,
sizeof (struct dwarf2_cie));
cie = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_cie);
cie->initial_instructions = NULL;
cie->cie_pointer = cie_pointer;
@ -2089,9 +2087,7 @@ decode_frame_entry_1 (struct comp_unit *unit, const gdb_byte *start,
if (cie_pointer >= unit->dwarf_frame_size)
return NULL;
fde = (struct dwarf2_fde *)
obstack_alloc (&unit->objfile->objfile_obstack,
sizeof (struct dwarf2_fde));
fde = XOBNEW (&unit->objfile->objfile_obstack, struct dwarf2_fde);
fde->cie = find_cie (cie_table, cie_pointer);
if (fde->cie == NULL)
{
@ -2395,8 +2391,7 @@ dwarf2_build_frame_info (struct objfile *objfile)
}
/* Copy fde_table to obstack: it is needed at runtime. */
fde_table2 = (struct dwarf2_fde_table *)
obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
fde_table2 = XOBNEW (&objfile->objfile_obstack, struct dwarf2_fde_table);
if (fde_table.num_entries == 0)
{

5
gdb/dwarf2expr.c
View File

@ -94,11 +94,10 @@ new_dwarf_expr_context (void)
{
struct dwarf_expr_context *retval;
retval = xcalloc (1, sizeof (struct dwarf_expr_context));
retval = XCNEW (struct dwarf_expr_context);
retval->stack_len = 0;
retval->stack_allocated = 10;
retval->stack = xmalloc (retval->stack_allocated
* sizeof (struct dwarf_stack_value));
retval->stack = XNEWVEC (struct dwarf_stack_value, retval->stack_allocated);
retval->num_pieces = 0;
retval->pieces = 0;
retval->max_recursion_depth = 0x100;

2
gdb/dwarf2loc.c
View File

@ -2908,7 +2908,7 @@ dwarf2_compile_expr_to_ax (struct agent_expr *expr, struct axs_value *loc,
unsigned int addr_size_bits = 8 * addr_size;
int bits_big_endian = gdbarch_bits_big_endian (arch);
offsets = xmalloc ((op_end - op_ptr) * sizeof (int));
offsets = XNEWVEC (int, op_end - op_ptr);
cleanups = make_cleanup (xfree, offsets);
for (i = 0; i < op_end - op_ptr; ++i)

169
gdb/dwarf2read.c
View File

@ -2048,7 +2048,7 @@ dwarf2_has_info (struct objfile *objfile,
{
/* Initialize per-objfile state. */
struct dwarf2_per_objfile *data
= obstack_alloc (&objfile->objfile_obstack, sizeof (*data));
= XOBNEW (&objfile->objfile_obstack, struct dwarf2_per_objfile);
memset (data, 0, sizeof (*data));
set_objfile_data (objfile, dwarf2_objfile_data_key, data);
@ -2819,10 +2819,9 @@ create_cus_from_index (struct objfile *objfile,
struct dwz_file *dwz;
dwarf2_per_objfile->n_comp_units = (cu_list_elements + dwz_elements) / 2;
dwarf2_per_objfile->all_comp_units
= obstack_alloc (&objfile->objfile_obstack,
dwarf2_per_objfile->n_comp_units
* sizeof (struct dwarf2_per_cu_data *));
dwarf2_per_objfile->all_comp_units =
XOBNEWVEC (&objfile->objfile_obstack, struct dwarf2_per_cu_data *,
dwarf2_per_objfile->n_comp_units);
create_cus_from_index_list (objfile, cu_list, cu_list_elements,
&dwarf2_per_objfile->info, 0, 0);
@ -2849,9 +2848,8 @@ create_signatured_type_table_from_index (struct objfile *objfile,
dwarf2_per_objfile->n_type_units
= dwarf2_per_objfile->n_allocated_type_units
= elements / 3;
dwarf2_per_objfile->all_type_units
= xmalloc (dwarf2_per_objfile->n_type_units
* sizeof (struct signatured_type *));
dwarf2_per_objfile->all_type_units =
XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
sig_types_hash = allocate_signatured_type_table (objfile);
@ -3230,7 +3228,7 @@ dwarf2_read_index (struct objfile *objfile)
create_addrmap_from_index (objfile, &local_map);
map = obstack_alloc (&objfile->objfile_obstack, sizeof (struct mapped_index));
map = XOBNEW (&objfile->objfile_obstack, struct mapped_index);
*map = local_map;
dwarf2_per_objfile->index_table = map;
@ -3314,7 +3312,7 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
return;
}
qfn = obstack_alloc (&objfile->objfile_obstack, sizeof (*qfn));
qfn = XOBNEW (&objfile->objfile_obstack, struct quick_file_names);
qfn->hash.dwo_unit = cu->dwo_unit;
qfn->hash.line_offset.sect_off = line_offset;
gdb_assert (slot != NULL);
@ -3323,8 +3321,8 @@ dw2_get_file_names_reader (const struct die_reader_specs *reader,
find_file_and_directory (comp_unit_die, cu, &name, &comp_dir);
qfn->num_file_names = lh->num_file_names;
qfn->file_names = obstack_alloc (&objfile->objfile_obstack,
lh->num_file_names * sizeof (char *));
qfn->file_names =
XOBNEWVEC (&objfile->objfile_obstack, const char *, lh->num_file_names);
for (i = 0; i < lh->num_file_names; ++i)
qfn->file_names[i] = file_full_name (i + 1, lh, comp_dir);
qfn->real_names = NULL;
@ -4506,9 +4504,8 @@ dwarf2_create_include_psymtab (const char *name, struct partial_symtab *pst,
subpst->textlow = 0;
subpst->texthigh = 0;
subpst->dependencies = (struct partial_symtab **)
obstack_alloc (&objfile->objfile_obstack,
sizeof (struct partial_symtab *));
subpst->dependencies
= XOBNEW (&objfile->objfile_obstack, struct partial_symtab *);
subpst->dependencies[0] = pst;
subpst->number_of_dependencies = 1;
@ -4780,9 +4777,8 @@ create_all_type_units (struct objfile *objfile)
dwarf2_per_objfile->n_type_units
= dwarf2_per_objfile->n_allocated_type_units
= htab_elements (types_htab);
dwarf2_per_objfile->all_type_units
= xmalloc (dwarf2_per_objfile->n_type_units
* sizeof (struct signatured_type *));
dwarf2_per_objfile->all_type_units =
XNEWVEC (struct signatured_type *, dwarf2_per_objfile->n_type_units);
iter = &dwarf2_per_objfile->all_type_units[0];
htab_traverse_noresize (types_htab, add_signatured_type_cu_to_table, &iter);
gdb_assert (iter - &dwarf2_per_objfile->all_type_units[0]
@ -5130,8 +5126,7 @@ read_cutu_die_from_dwo (struct dwarf2_per_cu_data *this_cu,
else if (stub_comp_dir != NULL)
{
/* Reconstruct the comp_dir attribute to simplify the code below. */
comp_dir = (struct attribute *)
obstack_alloc (&cu->comp_unit_obstack, sizeof (*comp_dir));
comp_dir = XOBNEW (&cu->comp_unit_obstack, struct attribute);
comp_dir->name = DW_AT_comp_dir;
comp_dir->form = DW_FORM_string;
DW_STRING_IS_CANONICAL (comp_dir) = 0;
@ -5349,7 +5344,7 @@ init_tu_and_read_dwo_dies (struct dwarf2_per_cu_data *this_cu,
{
/* If !use_existing_cu, this_cu->cu must be NULL. */
gdb_assert (this_cu->cu == NULL);
cu = xmalloc (sizeof (*cu));
cu = XNEW (struct dwarf2_cu);
init_one_comp_unit (cu, this_cu);
/* If an error occurs while loading, release our storage. */
free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
@ -5486,7 +5481,7 @@ init_cutu_and_read_dies (struct dwarf2_per_cu_data *this_cu,
{
/* If !use_existing_cu, this_cu->cu must be NULL. */
gdb_assert (this_cu->cu == NULL);
cu = xmalloc (sizeof (*cu));
cu = XNEW (struct dwarf2_cu);
init_one_comp_unit (cu, this_cu);
/* If an error occurs while loading, release our storage. */
free_cu_cleanup = make_cleanup (free_heap_comp_unit, cu);
@ -6027,8 +6022,8 @@ process_psymtab_comp_unit_reader (const struct die_reader_specs *reader,
/* Fill in 'dependencies' here; we fill in 'users' in a
post-pass. */
pst->number_of_dependencies = len;
pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
len * sizeof (struct symtab *));
pst->dependencies =
XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
for (i = 0;
VEC_iterate (dwarf2_per_cu_ptr, cu->per_cu->imported_symtabs,
i, iter);
@ -6299,8 +6294,8 @@ build_type_psymtab_dependencies (void **slot, void *info)
gdb_assert (IS_TYPE_UNIT_GROUP (per_cu));
pst->number_of_dependencies = len;
pst->dependencies = obstack_alloc (&objfile->objfile_obstack,
len * sizeof (struct psymtab *));
pst->dependencies =
XOBNEWVEC (&objfile->objfile_obstack, struct partial_symtab *, len);
for (i = 0;
VEC_iterate (sig_type_ptr, tu_group->tus, i, iter);
++i)
@ -6565,8 +6560,7 @@ read_comp_units_from_section (struct objfile *objfile,
length = read_initial_length (abfd, info_ptr, &initial_length_size);
/* Save the compilation unit for later lookup. */
this_cu = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct dwarf2_per_cu_data));
this_cu = XOBNEW (&objfile->objfile_obstack, struct dwarf2_per_cu_data);
memset (this_cu, 0, sizeof (*this_cu));
this_cu->offset = offset;
this_cu->length = length + initial_length_size;
@ -6601,8 +6595,7 @@ create_all_comp_units (struct objfile *objfile)
n_comp_units = 0;
n_allocated = 10;
all_comp_units = xmalloc (n_allocated
* sizeof (struct dwarf2_per_cu_data *));
all_comp_units = XNEWVEC (struct dwarf2_per_cu_data *, n_allocated);
read_comp_units_from_section (objfile, &dwarf2_per_objfile->info, 0,
&n_allocated, &n_comp_units, &all_comp_units);
@ -6613,9 +6606,9 @@ create_all_comp_units (struct objfile *objfile)
&n_allocated, &n_comp_units,
&all_comp_units);
dwarf2_per_objfile->all_comp_units
= obstack_alloc (&objfile->objfile_obstack,
n_comp_units * sizeof (struct dwarf2_per_cu_data *));
dwarf2_per_objfile->all_comp_units = XOBNEWVEC (&objfile->objfile_obstack,
struct dwarf2_per_cu_data *,
n_comp_units);
memcpy (dwarf2_per_objfile->all_comp_units, all_comp_units,
n_comp_units * sizeof (struct dwarf2_per_cu_data *));
xfree (all_comp_units);
@ -7460,7 +7453,7 @@ queue_comp_unit (struct dwarf2_per_cu_data *per_cu,
struct dwarf2_queue_item *item;
per_cu->queued = 1;
item = xmalloc (sizeof (*item));
item = XNEW (struct dwarf2_queue_item);
item->per_cu = per_cu;
item->pretend_language = pretend_language;
item->next = NULL;
@ -7973,8 +7966,8 @@ compute_compunit_symtab_includes (struct dwarf2_per_cu_data *per_cu)
/* Now we have a transitive closure of all the included symtabs. */
len = VEC_length (compunit_symtab_ptr, result_symtabs);
cust->includes
= obstack_alloc (&dwarf2_per_objfile->objfile->objfile_obstack,
(len + 1) * sizeof (struct compunit_symtab *));
= XOBNEWVEC (&dwarf2_per_objfile->objfile->objfile_obstack,
struct compunit_symtab *, len + 1);
for (ix = 0;
VEC_iterate (compunit_symtab_ptr, result_symtabs, ix,
compunit_symtab_iter);
@ -10148,8 +10141,8 @@ create_dwo_unit_in_dwp_v1 (struct dwp_file *dwp_file,
dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
dwo_unit->dwo_file = dwo_file;
dwo_unit->signature = signature;
dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct dwarf2_section_info));
dwo_unit->section =
XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
*dwo_unit->section = sections.info_or_types;
/* dwo_unit->{offset,length,type_offset_in_tu} are set later. */
@ -10362,8 +10355,8 @@ create_dwo_unit_in_dwp_v2 (struct dwp_file *dwp_file,
dwo_unit = OBSTACK_ZALLOC (&objfile->objfile_obstack, struct dwo_unit);
dwo_unit->dwo_file = dwo_file;
dwo_unit->signature = signature;
dwo_unit->section = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct dwarf2_section_info));
dwo_unit->section =
XOBNEW (&objfile->objfile_obstack, struct dwarf2_section_info);
*dwo_unit->section = create_dwp_v2_section (is_debug_types
? &dwp_file->sections.types
: &dwp_file->sections.info,
@ -11223,7 +11216,7 @@ inherit_abstract_dies (struct die_info *die, struct dwarf2_cu *cu)
child_die = sibling_die (child_die);
die_children_count++;
}
offsets = xmalloc (sizeof (*offsets) * die_children_count);
offsets = XNEWVEC (sect_offset, die_children_count);
cleanups = make_cleanup (xfree, offsets);
offsets_end = offsets;
@ -11479,9 +11472,8 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
templ_func->n_template_arguments = VEC_length (symbolp, template_args);
templ_func->template_arguments
= obstack_alloc (&objfile->objfile_obstack,
(templ_func->n_template_arguments
* sizeof (struct symbol *)));
= XOBNEWVEC (&objfile->objfile_obstack, struct symbol *,
templ_func->n_template_arguments);
memcpy (templ_func->template_arguments,
VEC_address (symbolp, template_args),
(templ_func->n_template_arguments * sizeof (struct symbol *)));
@ -11689,7 +11681,7 @@ read_call_site_scope (struct die_info *die, struct dwarf2_cu *cu)
{
struct dwarf2_locexpr_baton *dlbaton;
dlbaton = obstack_alloc (&objfile->objfile_obstack, sizeof (*dlbaton));
dlbaton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
dlbaton->data = DW_BLOCK (attr)->data;
dlbaton->size = DW_BLOCK (attr)->size;
dlbaton->per_cu = cu->per_cu;
@ -12456,7 +12448,7 @@ dwarf2_add_field (struct field_info *fip, struct die_info *die,
const char *fieldname = "";
/* Allocate a new field list entry and link it in. */
new_field = (struct nextfield *) xmalloc (sizeof (struct nextfield));
new_field = XNEW (struct nextfield);
make_cleanup (xfree, new_field);
memset (new_field, 0, sizeof (struct nextfield));
@ -12642,7 +12634,7 @@ dwarf2_add_typedef (struct field_info *fip, struct die_info *die,
char *fieldname = "";
/* Allocate a new field list entry and link it in. */
new_field = xzalloc (sizeof (*new_field));
new_field = XCNEW (struct typedef_field_list);
make_cleanup (xfree, new_field);
gdb_assert (die->tag == DW_TAG_typedef);
@ -12846,7 +12838,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
/* Create a new member function field and chain it to the field list
entry. */
new_fnfield = (struct nextfnfield *) xmalloc (sizeof (struct nextfnfield));
new_fnfield = XNEW (struct nextfnfield);
make_cleanup (xfree, new_fnfield);
memset (new_fnfield, 0, sizeof (struct nextfnfield));
new_fnfield->next = flp->head;
@ -13303,9 +13295,9 @@ process_structure_scope (struct die_info *die, struct dwarf2_cu *cu)
TYPE_N_TEMPLATE_ARGUMENTS (type)
= VEC_length (symbolp, template_args);
TYPE_TEMPLATE_ARGUMENTS (type)
= obstack_alloc (&objfile->objfile_obstack,
(TYPE_N_TEMPLATE_ARGUMENTS (type)
* sizeof (struct symbol *)));
= XOBNEWVEC (&objfile->objfile_obstack,
struct symbol *,
TYPE_N_TEMPLATE_ARGUMENTS (type));
memcpy (TYPE_TEMPLATE_ARGUMENTS (type),
VEC_address (symbolp, template_args),
(TYPE_N_TEMPLATE_ARGUMENTS (type)
@ -13899,8 +13891,7 @@ mark_common_block_symbol_computed (struct symbol *sym,
gdb_assert (attr_form_is_block (member_loc)
|| attr_form_is_constant (member_loc));
baton = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct dwarf2_locexpr_baton));
baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
baton->per_cu = cu->per_cu;
gdb_assert (baton->per_cu);
@ -14813,7 +14804,7 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
if (attr_form_is_block (attr))
{
baton = obstack_alloc (obstack, sizeof (*baton));
baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = NULL;
baton->locexpr.per_cu = cu->per_cu;
baton->locexpr.size = DW_BLOCK (attr)->size;
@ -14841,7 +14832,7 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
case DW_AT_location:
if (attr_form_is_section_offset (target_attr))
{
baton = obstack_alloc (obstack, sizeof (*baton));
baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = die_type (target_die, target_cu);
fill_in_loclist_baton (cu, &baton->loclist, target_attr);
prop->data.baton = baton;
@ -14850,7 +14841,7 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
}
else if (attr_form_is_block (target_attr))
{
baton = obstack_alloc (obstack, sizeof (*baton));
baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = die_type (target_die, target_cu);
baton->locexpr.per_cu = cu->per_cu;
baton->locexpr.size = DW_BLOCK (target_attr)->size;
@ -14874,7 +14865,7 @@ attr_to_dynamic_prop (const struct attribute *attr, struct die_info *die,
&offset))
return 0;
baton = obstack_alloc (obstack, sizeof (*baton));
baton = XOBNEW (obstack, struct dwarf2_property_baton);
baton->referenced_type = read_type_die (target_die->parent,
target_cu);
baton->offset_info.offset = offset;
@ -15271,9 +15262,9 @@ abbrev_table_alloc_abbrev (struct abbrev_table *abbrev_table)
{
struct abbrev_info *abbrev;
abbrev = (struct abbrev_info *)
obstack_alloc (&abbrev_table->abbrev_obstack, sizeof (struct abbrev_info));
abbrev = XOBNEW (&abbrev_table->abbrev_obstack, struct abbrev_info);
memset (abbrev, 0, sizeof (struct abbrev_info));
return abbrev;
}
@ -15332,9 +15323,9 @@ abbrev_table_read_table (struct dwarf2_section_info *section,
abbrev_table = XNEW (struct abbrev_table);
abbrev_table->offset = offset;
obstack_init (&abbrev_table->abbrev_obstack);
abbrev_table->abbrevs = obstack_alloc (&abbrev_table->abbrev_obstack,
(ABBREV_HASH_SIZE
* sizeof (struct abbrev_info *)));
abbrev_table->abbrevs =
XOBNEWVEC (&abbrev_table->abbrev_obstack, struct abbrev_info *,
ABBREV_HASH_SIZE);
memset (abbrev_table->abbrevs, 0,
ABBREV_HASH_SIZE * sizeof (struct abbrev_info *));
@ -15344,7 +15335,7 @@ abbrev_table_read_table (struct dwarf2_section_info *section,
abbrev_ptr += bytes_read;
allocated_attrs = ATTR_ALLOC_CHUNK;
cur_attrs = xmalloc (allocated_attrs * sizeof (struct attr_abbrev));
cur_attrs = XNEWVEC (struct attr_abbrev, allocated_attrs);
/* Loop until we reach an abbrev number of 0. */
while (abbrev_number)
@ -15384,9 +15375,9 @@ abbrev_table_read_table (struct dwarf2_section_info *section,
abbrev_ptr += bytes_read;
}
cur_abbrev->attrs = obstack_alloc (&abbrev_table->abbrev_obstack,
(cur_abbrev->num_attrs
* sizeof (struct attr_abbrev)));
cur_abbrev->attrs =
XOBNEWVEC (&abbrev_table->abbrev_obstack, struct attr_abbrev,
cur_abbrev->num_attrs);
memcpy (cur_abbrev->attrs, cur_attrs,
cur_abbrev->num_attrs * sizeof (struct attr_abbrev));
@ -15522,8 +15513,7 @@ load_partial_dies (const struct die_reader_specs *reader,
hashtab_obstack_allocate,
dummy_obstack_deallocate);
part_die = obstack_alloc (&cu->comp_unit_obstack,
sizeof (struct partial_die_info));
part_die = XOBNEW (&cu->comp_unit_obstack, struct partial_die_info);
while (1)
{
@ -15723,8 +15713,7 @@ load_partial_dies (const struct die_reader_specs *reader,
*slot = part_die;
}
part_die = obstack_alloc (&cu->comp_unit_obstack,
sizeof (struct partial_die_info));
part_die = XOBNEW (&cu->comp_unit_obstack, struct partial_die_info);
/* For some DIEs we want to follow their children (if any). For C
we have no reason to follow the children of structures; for other
@ -17209,15 +17198,13 @@ add_include_dir (struct line_header *lh, const char *include_dir)
if (lh->include_dirs_size == 0)
{
lh->include_dirs_size = 1; /* for testing */
lh->include_dirs = xmalloc (lh->include_dirs_size
* sizeof (*lh->include_dirs));
lh->include_dirs = XNEWVEC (const char *, lh->include_dirs_size);
}
else if (lh->num_include_dirs >= lh->include_dirs_size)
{
lh->include_dirs_size *= 2;
lh->include_dirs = xrealloc (lh->include_dirs,
(lh->include_dirs_size
* sizeof (*lh->include_dirs)));
lh->include_dirs = XRESIZEVEC (const char *, lh->include_dirs,
lh->include_dirs_size);
}
lh->include_dirs[lh->num_include_dirs++] = include_dir;
@ -17242,8 +17229,7 @@ add_file_name (struct line_header *lh,
if (lh->file_names_size == 0)
{
lh->file_names_size = 1; /* for testing */
lh->file_names = xmalloc (lh->file_names_size
* sizeof (*lh->file_names));
lh->file_names = XNEWVEC (struct file_entry, lh->file_names_size);
}
else if (lh->num_file_names >= lh->file_names_size)
{
@ -17330,7 +17316,7 @@ dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
return 0;
}
lh = xmalloc (sizeof (*lh));
lh = XNEW (struct line_header);
memset (lh, 0, sizeof (*lh));
back_to = make_cleanup ((make_cleanup_ftype *) free_line_header,
(void *) lh);
@ -17390,8 +17376,7 @@ dwarf_decode_line_header (unsigned int offset, struct dwarf2_cu *cu)
line_ptr += 1;
lh->opcode_base = read_1_byte (abfd, line_ptr);
line_ptr += 1;
lh->standard_opcode_lengths
= xmalloc (lh->opcode_base * sizeof (lh->standard_opcode_lengths[0]));
lh->standard_opcode_lengths = XNEWVEC (unsigned char, lh->opcode_base);
lh->standard_opcode_lengths[0] = 1; /* This should never be used anyway. */
for (i = 1; i < lh->opcode_base; ++i)
@ -18764,7 +18749,7 @@ dwarf2_const_value_attr (const struct attribute *attr, struct type *type,
/* Symbols of this form are reasonably rare, so we just
piggyback on the existing location code rather than writing
a new implementation of symbol_computed_ops. */
*baton = obstack_alloc (obstack, sizeof (struct dwarf2_locexpr_baton));
*baton = XOBNEW (obstack, struct dwarf2_locexpr_baton);
(*baton)->per_cu = cu->per_cu;
gdb_assert ((*baton)->per_cu);
@ -20815,11 +20800,7 @@ decode_locdesc (struct dwarf_block *blk, struct dwarf2_cu *cu)
static struct dwarf_block *
dwarf_alloc_block (struct dwarf2_cu *cu)
{
struct dwarf_block *blk;
blk = (struct dwarf_block *)
obstack_alloc (&cu->comp_unit_obstack, sizeof (struct dwarf_block));
return (blk);
return XOBNEW (&cu->comp_unit_obstack, struct dwarf_block);
}
static struct die_info *
@ -21019,7 +21000,7 @@ parse_macro_definition (struct macro_source_file *file, int line,
char *name = copy_string (body, p - body);
int argc = 0;
int argv_size = 1;
char **argv = xmalloc (argv_size * sizeof (*argv));
char **argv = XNEWVEC (char *, argv_size);
p++;
@ -21879,8 +21860,7 @@ dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
{
struct dwarf2_loclist_baton *baton;
baton = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct dwarf2_loclist_baton));
baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_loclist_baton);
fill_in_loclist_baton (cu, baton, attr);
@ -21898,8 +21878,7 @@ dwarf2_symbol_mark_computed (const struct attribute *attr, struct symbol *sym,
{
struct dwarf2_locexpr_baton *baton;
baton = obstack_alloc (&objfile->objfile_obstack,
sizeof (struct dwarf2_locexpr_baton));
baton = XOBNEW (&objfile->objfile_obstack, struct dwarf2_locexpr_baton);
baton->per_cu = cu->per_cu;
gdb_assert (baton->per_cu);
@ -22365,7 +22344,8 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu)
complaint (&symfile_complaints,
_("A problem internal to GDB: DIE 0x%x has type already set"),
die->offset.sect_off);
*slot = obstack_alloc (&objfile->objfile_obstack, sizeof (**slot));
*slot = XOBNEW (&objfile->objfile_obstack,
struct dwarf2_per_cu_offset_and_type);
**slot = ofs;
return type;
}
@ -23282,9 +23262,8 @@ write_psymtabs_to_index (struct objfile *objfile, const char *dir)
eq_psymtab_cu_index,
NULL, xcalloc, xfree);
make_cleanup_htab_delete (cu_index_htab);
psymtab_cu_index_map = (struct psymtab_cu_index_map *)
xmalloc (sizeof (struct psymtab_cu_index_map)
* dwarf2_per_objfile->n_comp_units);
psymtab_cu_index_map = XNEWVEC (struct psymtab_cu_index_map,
dwarf2_per_objfile->n_comp_units);
make_cleanup (xfree, psymtab_cu_index_map);
/* The CU list is already sorted, so we don't need to do additional

4
gdb/elfread.c
View File

@ -95,7 +95,7 @@ elf_symfile_segments (bfd *abfd)
return NULL;
num_segments = 0;
segments = alloca (sizeof (Elf_Internal_Phdr *) * num_phdrs);
segments = XALLOCAVEC (Elf_Internal_Phdr *, num_phdrs);
for (i = 0; i < num_phdrs; i++)
if (phdrs[i].p_type == PT_LOAD)
segments[num_segments++] = &phdrs[i];
@ -1124,7 +1124,7 @@ elf_read_minimal_symbols (struct objfile *objfile, int symfile_flags,
long i;
make_cleanup (xfree, synthsyms);
synth_symbol_table = xmalloc (sizeof (asymbol *) * synthcount);
synth_symbol_table = XNEWVEC (asymbol *, synthcount);
for (i = 0; i < synthcount; i++)
synth_symbol_table[i] = synthsyms + i;
make_cleanup (xfree, synth_symbol_table);

2
gdb/environ.c
View File

@ -29,7 +29,7 @@ make_environ (void)
{
struct gdb_environ *e;
e = (struct gdb_environ *) xmalloc (sizeof (struct gdb_environ));
e = XNEW (struct gdb_environ);
e->allocated = 10;
e->vector = (char **) xmalloc ((e->allocated + 1) * sizeof (char *));

5
gdb/eval.c
View File

@ -998,7 +998,7 @@ evaluate_subexp_standard (struct type *expect_type,
return set;
}
argvec = (struct value **) alloca (sizeof (struct value *) * nargs);
argvec = XALLOCAVEC (struct value *, nargs);
for (tem = 0; tem < nargs; tem++)
{
/* Ensure that array expressions are coerced into pointer
@ -1082,8 +1082,7 @@ evaluate_subexp_standard (struct type *expect_type,
selector = exp->elts[pc + 1].longconst;
nargs = exp->elts[pc + 2].longconst;
argvec = (struct value **) alloca (sizeof (struct value *)
* (nargs + 5));
argvec = XALLOCAVEC (struct value *, nargs + 5);
(*pos) += 3;

11
gdb/event-loop.c
View File

@ -455,7 +455,7 @@ create_file_handler (int fd, int mask, handler_func * proc,
change the data associated with it. */
if (file_ptr == NULL)
{
file_ptr = (file_handler *) xmalloc (sizeof (file_handler));
file_ptr = XNEW (file_handler);
file_ptr->fd = fd;
file_ptr->ready_mask = 0;
file_ptr->next_file = gdb_notifier.first_file_handler;
@ -472,7 +472,7 @@ create_file_handler (int fd, int mask, handler_func * proc,
* sizeof (struct pollfd)));
else
gdb_notifier.poll_fds =
(struct pollfd *) xmalloc (sizeof (struct pollfd));
XNEW (struct pollfd);
(gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->fd = fd;
(gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->events = mask;
(gdb_notifier.poll_fds + gdb_notifier.num_fds - 1)->revents = 0;
@ -875,8 +875,7 @@ create_async_signal_handler (sig_handler_func * proc,
{
async_signal_handler *async_handler_ptr;
async_handler_ptr =
(async_signal_handler *) xmalloc (sizeof (async_signal_handler));
async_handler_ptr = XNEW (async_signal_handler);
async_handler_ptr->ready = 0;
async_handler_ptr->next_handler = NULL;
async_handler_ptr->proc = proc;
@ -990,7 +989,7 @@ create_async_event_handler (async_event_handler_func *proc,
{
async_event_handler *h;
h = xmalloc (sizeof (*h));
h = XNEW (struct async_event_handler);
h->ready = 0;
h->next_handler = NULL;
h->proc = proc;
@ -1090,7 +1089,7 @@ create_timer (int milliseconds, timer_handler_func * proc,
gettimeofday (&time_now, NULL);
timer_ptr = (struct gdb_timer *) xmalloc (sizeof (*timer_ptr));
timer_ptr = XNEW (struct gdb_timer);
timer_ptr->when.tv_sec = time_now.tv_sec + delta.tv_sec;
timer_ptr->when.tv_usec = time_now.tv_usec + delta.tv_usec;
/* Carry? */

2
gdb/exec.c
View File

@ -475,7 +475,7 @@ build_section_table (struct bfd *some_bfd, struct target_section **start,
count = bfd_count_sections (some_bfd);
if (*start)
xfree (* start);
*start = (struct target_section *) xmalloc (count * sizeof (**start));
*start = XNEWVEC (struct target_section, count);
*end = *start;
bfd_map_over_sections (some_bfd, add_to_section_table, (char *) end);
if (*end > *start + count)

4
gdb/fbsd-nat.c
View File

@ -257,9 +257,7 @@ static struct fbsd_fork_child_info *fbsd_pending_children;
static void
fbsd_remember_child (pid_t pid)
{
struct fbsd_fork_child_info *info;
info = xcalloc (1, sizeof *info);
struct fbsd_fork_child_info *info = XCNEW (struct fbsd_fork_child_info);
info->child = pid;
info->next = fbsd_pending_children;

2
gdb/fork-child.c
View File

@ -170,7 +170,7 @@ fork_inferior (char *exec_file_arg, char *allargs, char **env,
argument. */
int argc = (strlen (allargs) + 1) / 2 + 2;
argv = (char **) alloca (argc * sizeof (*argv));
argv = XALLOCAVEC (char *, argc);
argv[0] = exec_file;
breakup_args (allargs, &argv[1]);
}

5
gdb/frv-tdep.c
View File

@ -136,9 +136,8 @@ new_variant (void)
struct gdbarch_tdep *var;
int r;
var = xmalloc (sizeof (*var));
memset (var, 0, sizeof (*var));
var = XCNEW (struct gdbarch_tdep);
var->frv_abi = FRV_ABI_EABI;
var->num_gprs = 64;
var->num_fprs = 64;

4
gdb/gdbarch.c
View File

@ -345,7 +345,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
then use that to allocate the architecture vector. */
struct obstack *obstack = XNEW (struct obstack);
obstack_init (obstack);
gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
gdbarch = XOBNEW (obstack, struct gdbarch);
memset (gdbarch, 0, sizeof (*gdbarch));
gdbarch->obstack = obstack;
@ -4894,7 +4894,7 @@ static struct gdbarch_registration *gdbarch_registry = NULL;
static void
append_name (const char ***buf, int *nr, const char *name)
{
*buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
*buf = XRESIZEVEC (const char **, *buf, *nr + 1);
(*buf)[*nr] = name;
*nr += 1;
}

2
gdb/gdbarch.h
View File

@ -924,7 +924,7 @@ extern void set_gdbarch_max_insn_length (struct gdbarch *gdbarch, ULONGEST max_i
If your architecture doesn't need to adjust instructions before
single-stepping them, consider using simple_displaced_step_copy_insn
here.
If the instruction cannot execute out of line, return NULL. The
core falls back to stepping past the instruction in-line instead in
that case. */

4
gdb/gdbarch.sh
View File

@ -1741,7 +1741,7 @@ gdbarch_alloc (const struct gdbarch_info *info,
then use that to allocate the architecture vector. */
struct obstack *obstack = XNEW (struct obstack);
obstack_init (obstack);
gdbarch = obstack_alloc (obstack, sizeof (*gdbarch));
gdbarch = XOBNEW (obstack, struct gdbarch);
memset (gdbarch, 0, sizeof (*gdbarch));
gdbarch->obstack = obstack;
@ -2201,7 +2201,7 @@ static struct gdbarch_registration *gdbarch_registry = NULL;
static void
append_name (const char ***buf, int *nr, const char *name)
{
*buf = xrealloc (*buf, sizeof (char**) * (*nr + 1));
*buf = XRESIZEVEC (const char **, *buf, *nr + 1);
(*buf)[*nr] = name;
*nr += 1;
}

55
gdb/gdbserver/ChangeLog
View File

@ -1,3 +1,58 @@
2015-08-26 Simon Marchi <simon.marchi@ericsson.com>
* ax.c (gdb_parse_agent_expr): Likewise.
(compile_bytecodes): Likewise.
* dll.c (loaded_dll): Likewise.
* event-loop.c (append_callback_event): Likewise.
(create_file_handler): Likewise.
(create_file_event): Likewise.
* hostio.c (handle_open): Likewise.
* inferiors.c (add_thread): Likewise.
(add_process): Likewise.
* linux-aarch64-low.c (aarch64_linux_new_process): Likewise.
* linux-arm-low.c (arm_new_process): Likewise.
(arm_new_thread): Likewise.
* linux-low.c (add_to_pid_list): Likewise.
(linux_add_process): Likewise.
(handle_extended_wait): Likewise.
(add_lwp): Likewise.
(enqueue_one_deferred_signal): Likewise.
(enqueue_pending_signal): Likewise.
(linux_resume_one_lwp_throw): Likewise.
(linux_resume_one_thread): Likewise.
(linux_read_memory): Likewise.
(linux_write_memory): Likewise.
* linux-mips-low.c (mips_linux_new_process): Likewise.
(mips_linux_new_thread): Likewise.
(mips_add_watchpoint): Likewise.
* linux-x86-low.c (initialize_low_arch): Likewise.
* lynx-low.c (lynx_add_process): Likewise.
* mem-break.c (set_raw_breakpoint_at): Likewise.
(set_breakpoint): Likewise.
(add_condition_to_breakpoint): Likewise.
(add_commands_to_breakpoint): Likewise.
(clone_agent_expr): Likewise.
(clone_one_breakpoint): Likewise.
* regcache.c (new_register_cache): Likewise.
* remote-utils.c (look_up_one_symbol): Likewise.
* server.c (queue_stop_reply): Likewise.
(start_inferior): Likewise.
(queue_stop_reply_callback): Likewise.
(handle_target_event): Likewise.
* spu-low.c (fetch_ppc_memory): Likewise.
(store_ppc_memory): Likewise.
* target.c (set_target_ops): Likewise.
* thread-db.c (thread_db_load_search): Likewise.
(try_thread_db_load_1): Likewise.
* tracepoint.c (add_tracepoint): Likewise.
(add_tracepoint_action): Likewise.
(create_trace_state_variable): Likewise.
(cmd_qtdpsrc): Likewise.
(cmd_qtro): Likewise.
(add_while_stepping_state): Likewise.
* win32-low.c (child_add_thread): Likewise.
(get_image_name): Likewise.
2015-08-25 Yao Qi <yao.qi@linaro.org>
* linux-aarch64-low.c (aarch64_linux_new_thread): Remove.

4
gdb/gdbserver/ax.c
View File

@ -102,7 +102,7 @@ gdb_parse_agent_expr (char **actparm)
++act; /* skip the X */
act = unpack_varlen_hex (act, &xlen);
++act; /* skip a comma */
aexpr = xmalloc (sizeof (struct agent_expr));
aexpr = XNEW (struct agent_expr);
aexpr->length = xlen;
aexpr->bytes = xmalloc (xlen);
hex2bin (act, aexpr->bytes, xlen);
@ -430,7 +430,7 @@ compile_bytecodes (struct agent_expr *aexpr)
/* Record the compiled-code address of the bytecode, for use by
jump instructions. */
aentry = xmalloc (sizeof (struct bytecode_address));
aentry = XNEW (struct bytecode_address);
aentry->pc = pc;
aentry->address = current_insn_ptr;
aentry->goto_pc = -1;

3
gdb/gdbserver/dll.c
View File

@ -60,8 +60,7 @@ match_dll (struct inferior_list_entry *inf, void *arg)
void
loaded_dll (const char *name, CORE_ADDR base_addr)
{
struct dll_info *new_dll = xmalloc (sizeof (*new_dll));
memset (new_dll, 0, sizeof (*new_dll));
struct dll_info *new_dll = XCNEW (struct dll_info);
new_dll->entry.id = minus_one_ptid;

8
gdb/gdbserver/event-loop.c
View File

@ -197,9 +197,8 @@ process_event (void)
int
append_callback_event (callback_handler_func *proc, gdb_client_data data)
{
struct callback_event *event_ptr;
struct callback_event *event_ptr = XNEW (struct callback_event);
event_ptr = xmalloc (sizeof (*event_ptr));
event_ptr->id = callback_list.num_callbacks++;
event_ptr->proc = proc;
event_ptr->data = data;
@ -289,7 +288,7 @@ create_file_handler (gdb_fildes_t fd, int mask, handler_func *proc,
just change the data associated with it. */
if (file_ptr == NULL)
{
file_ptr = xmalloc (sizeof (*file_ptr));
file_ptr = XNEW (struct file_handler);
file_ptr->fd = fd;
file_ptr->ready_mask = 0;
file_ptr->next_file = gdb_notifier.first_file_handler;
@ -447,9 +446,10 @@ create_file_event (gdb_fildes_t fd)
{
gdb_event *file_event_ptr;
file_event_ptr = xmalloc (sizeof (gdb_event));
file_event_ptr = XNEW (gdb_event);
file_event_ptr->proc = handle_file_event;
file_event_ptr->fd = fd;
return file_event_ptr;
}

2
gdb/gdbserver/hostio.c
View File

@ -331,7 +331,7 @@ handle_open (char *own_buf)
}
/* Record the new file descriptor. */
new_fd = xmalloc (sizeof (struct fd_list));
new_fd = XNEW (struct fd_list);
new_fd->fd = fd;
new_fd->next = open_fds;
open_fds = new_fd;

8
gdb/gdbserver/inferiors.c
View File

@ -105,9 +105,7 @@ remove_inferior (struct inferior_list *list,
struct thread_info *
add_thread (ptid_t thread_id, void *target_data)
{
struct thread_info *new_thread = xmalloc (sizeof (*new_thread));
memset (new_thread, 0, sizeof (*new_thread));
struct thread_info *new_thread = XCNEW (struct thread_info);
new_thread->entry.id = thread_id;
new_thread->last_resume_kind = resume_continue;
@ -274,9 +272,7 @@ clear_inferiors (void)
struct process_info *
add_process (int pid, int attached)
{
struct process_info *process;
process = xcalloc (1, sizeof (*process));
struct process_info *process = XCNEW (struct process_info);
process->entry.id = pid_to_ptid (pid);
process->attached = attached;

2
gdb/gdbserver/linux-aarch64-low.c
View File

@ -431,7 +431,7 @@ ps_get_thread_area (const struct ps_prochandle *ph,
static struct arch_process_info *
aarch64_linux_new_process (void)
{
struct arch_process_info *info = xcalloc (1, sizeof (*info));
struct arch_process_info *info = XCNEW (struct arch_process_info);
aarch64_init_debug_reg_state (&info->debug_reg_state);

4
gdb/gdbserver/linux-arm-low.c
View File

@ -664,7 +664,7 @@ arm_stopped_data_address (void)
static struct arch_process_info *
arm_new_process (void)
{
struct arch_process_info *info = xcalloc (1, sizeof (*info));
struct arch_process_info *info = XCNEW (struct arch_process_info);
return info;
}
@ -672,7 +672,7 @@ arm_new_process (void)
static void
arm_new_thread (struct lwp_info *lwp)
{
struct arch_lwp_info *info = xcalloc (1, sizeof (*info));
struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
int i;
for (i = 0; i < MAX_BPTS; i++)

29
gdb/gdbserver/linux-low.c
View File

@ -208,7 +208,7 @@ struct simple_pid_list *stopped_pids;
static void
add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
{
struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
new_pid->pid = pid;
new_pid->status = status;
@ -409,7 +409,7 @@ linux_add_process (int pid, int attached)
struct process_info *proc;
proc = add_process (pid, attached);
proc->priv = xcalloc (1, sizeof (*proc->priv));
proc->priv = XCNEW (struct process_info_private);
if (the_low_target.new_process != NULL)
proc->priv->arch_private = the_low_target.new_process ();
@ -506,7 +506,7 @@ handle_extended_wait (struct lwp_info *event_lwp, int wstat)
&child_proc->raw_breakpoints,
parent_proc->breakpoints);
tdesc = xmalloc (sizeof (struct target_desc));
tdesc = XNEW (struct target_desc);
copy_target_description (tdesc, parent_proc->tdesc);
child_proc->tdesc = tdesc;
@ -760,7 +760,7 @@ add_lwp (ptid_t ptid)
{
struct lwp_info *lwp;
lwp = (struct lwp_info *) xcalloc (1, sizeof (*lwp));
lwp = XCNEW (struct lwp_info);
lwp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
@ -1984,10 +1984,10 @@ enqueue_one_deferred_signal (struct lwp_info *lwp, int *wstat)
}
}
p_sig = xmalloc (sizeof (*p_sig));
p_sig = XCNEW (struct pending_signals);
p_sig->prev = lwp->pending_signals_to_report;
p_sig->signal = WSTOPSIG (*wstat);
memset (&p_sig->info, 0, sizeof (siginfo_t));
ptrace (PTRACE_GETSIGINFO, lwpid_of (thread), (PTRACE_TYPE_ARG3) 0,
&p_sig->info);
@ -3761,9 +3761,8 @@ stop_all_lwps (int suspend, struct lwp_info *except)
static void
enqueue_pending_signal (struct lwp_info *lwp, int signal, siginfo_t *info)
{
struct pending_signals *p_sig;
struct pending_signals *p_sig = XNEW (struct pending_signals);
p_sig = xmalloc (sizeof (*p_sig));
p_sig->prev = lwp->pending_signals;
p_sig->signal = signal;
if (info == NULL)
@ -3817,8 +3816,8 @@ linux_resume_one_lwp_throw (struct lwp_info *lwp,
|| lwp->bp_reinsert != 0
|| fast_tp_collecting))
{
struct pending_signals *p_sig;
p_sig = xmalloc (sizeof (*p_sig));
struct pending_signals *p_sig = XNEW (struct pending_signals);
p_sig->prev = lwp->pending_signals;
p_sig->signal = signal;
if (info == NULL)
@ -4518,11 +4517,10 @@ linux_resume_one_thread (struct inferior_list_entry *entry, void *arg)
/* If we have a new signal, enqueue the signal. */
if (lwp->resume->sig != 0)
{
struct pending_signals *p_sig;
p_sig = xmalloc (sizeof (*p_sig));
struct pending_signals *p_sig = XCNEW (struct pending_signals);
p_sig->prev = lwp->pending_signals;
p_sig->signal = lwp->resume->sig;
memset (&p_sig->info, 0, sizeof (siginfo_t));
/* If this is the same signal we were previously stopped by,
make sure to queue its siginfo. We can ignore the return
@ -5276,7 +5274,7 @@ linux_read_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
count = ((((memaddr + len) - addr) + sizeof (PTRACE_XFER_TYPE) - 1)
/ sizeof (PTRACE_XFER_TYPE));
/* Allocate buffer of that many longwords. */
buffer = (PTRACE_XFER_TYPE *) alloca (count * sizeof (PTRACE_XFER_TYPE));
buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
/* Read all the longwords */
errno = 0;
@ -5321,8 +5319,7 @@ linux_write_memory (CORE_ADDR memaddr, const unsigned char *myaddr, int len)
/ sizeof (PTRACE_XFER_TYPE);
/* Allocate buffer of that many longwords. */
register PTRACE_XFER_TYPE *buffer = (PTRACE_XFER_TYPE *)
alloca (count * sizeof (PTRACE_XFER_TYPE));
register PTRACE_XFER_TYPE *buffer = XALLOCAVEC (PTRACE_XFER_TYPE, count);
int pid = lwpid_of (current_thread);

6
gdb/gdbserver/linux-mips-low.c
View File

@ -325,7 +325,7 @@ update_watch_registers_callback (struct inferior_list_entry *entry,
static struct arch_process_info *
mips_linux_new_process (void)
{
struct arch_process_info *info = xcalloc (1, sizeof (*info));
struct arch_process_info *info = XCNEW (struct arch_process_info);
return info;
}
@ -337,7 +337,7 @@ mips_linux_new_process (void)
static void
mips_linux_new_thread (struct lwp_info *lwp)
{
struct arch_lwp_info *info = xcalloc (1, sizeof (*info));
struct arch_lwp_info *info = XCNEW (struct arch_lwp_info);
info->watch_registers_changed = 1;
@ -353,7 +353,7 @@ mips_add_watchpoint (struct arch_process_info *private, CORE_ADDR addr,
struct mips_watchpoint *new_watch;
struct mips_watchpoint **pw;
new_watch = xmalloc (sizeof (struct mips_watchpoint));
new_watch = XNEW (struct mips_watchpoint);
new_watch->addr = addr;
new_watch->len = len;
new_watch->type = watch_type;

4
gdb/gdbserver/linux-x86-low.c
View File

@ -3305,7 +3305,7 @@ initialize_low_arch (void)
init_registers_x32_avx_linux ();
init_registers_x32_avx512_linux ();
tdesc_amd64_linux_no_xml = xmalloc (sizeof (struct target_desc));
tdesc_amd64_linux_no_xml = XNEW (struct target_desc);
copy_target_description (tdesc_amd64_linux_no_xml, tdesc_amd64_linux);
tdesc_amd64_linux_no_xml->xmltarget = xmltarget_amd64_linux_no_xml;
#endif
@ -3315,7 +3315,7 @@ initialize_low_arch (void)
init_registers_i386_avx512_linux ();
init_registers_i386_mpx_linux ();
tdesc_i386_linux_no_xml = xmalloc (sizeof (struct target_desc));
tdesc_i386_linux_no_xml = XNEW (struct target_desc);
copy_target_description (tdesc_i386_linux_no_xml, tdesc_i386_linux);
tdesc_i386_linux_no_xml->xmltarget = xmltarget_i386_linux_no_xml;

2
gdb/gdbserver/lynx-low.c
View File

@ -218,7 +218,7 @@ lynx_add_process (int pid, int attached)
proc = add_process (pid, attached);
proc->tdesc = lynx_tdesc;
proc->priv = xcalloc (1, sizeof (*proc->priv));
proc->priv = XCNEW (struct process_info_private);
proc->priv->last_wait_event_ptid = null_ptid;
return proc;

18
gdb/gdbserver/mem-break.c
View File

@ -404,7 +404,7 @@ set_raw_breakpoint_at (enum raw_bkpt_type type, CORE_ADDR where, int size,
return bp;
}
bp = xcalloc (1, sizeof (*bp));
bp = XCNEW (struct raw_breakpoint);
bp->pc = where;
bp->size = size;
bp->refcount = 1;
@ -755,7 +755,7 @@ set_breakpoint (enum bkpt_type type, enum raw_bkpt_type raw_type,
return NULL;
}
bp = xcalloc (1, sizeof (struct breakpoint));
bp = XCNEW (struct breakpoint);
bp->type = type;
bp->raw = raw;
@ -1169,7 +1169,7 @@ add_condition_to_breakpoint (struct breakpoint *bp,
struct point_cond_list *new_cond;
/* Create new condition. */
new_cond = xcalloc (1, sizeof (*new_cond));
new_cond = XCNEW (struct point_cond_list);
new_cond->cond = condition;
/* Add condition to the list. */
@ -1267,7 +1267,7 @@ add_commands_to_breakpoint (struct breakpoint *bp,
struct point_command_list *new_cmd;
/* Create new command. */
new_cmd = xcalloc (1, sizeof (*new_cmd));
new_cmd = XCNEW (struct point_command_list);
new_cmd->cmd = commands;
new_cmd->persistence = persist;
@ -1937,7 +1937,7 @@ clone_agent_expr (const struct agent_expr *src_ax)
{
struct agent_expr *ax;
ax = xcalloc (1, sizeof (*ax));
ax = XCNEW (struct agent_expr);
ax->length = src_ax->length;
ax->bytes = xcalloc (ax->length, 1);
memcpy (ax->bytes, src_ax->bytes, ax->length);
@ -1959,7 +1959,7 @@ clone_one_breakpoint (const struct breakpoint *src)
struct point_command_list *cmd_tail = NULL;
/* Clone the raw breakpoint. */
dest_raw = xcalloc (1, sizeof (*dest_raw));
dest_raw = XCNEW (struct raw_breakpoint);
dest_raw->raw_type = src->raw->raw_type;
dest_raw->refcount = src->raw->refcount;
dest_raw->pc = src->raw->pc;
@ -1968,7 +1968,7 @@ clone_one_breakpoint (const struct breakpoint *src)
dest_raw->inserted = src->raw->inserted;
/* Clone the high-level breakpoint. */
dest = xcalloc (1, sizeof (*dest));
dest = XCNEW (struct breakpoint);
dest->type = src->type;
dest->raw = dest_raw;
dest->handler = src->handler;
@ -1977,7 +1977,7 @@ clone_one_breakpoint (const struct breakpoint *src)
for (current_cond = src->cond_list; current_cond != NULL;
current_cond = current_cond->next)
{
new_cond = xcalloc (1, sizeof (*new_cond));
new_cond = XCNEW (struct point_cond_list);
new_cond->cond = clone_agent_expr (current_cond->cond);
APPEND_TO_LIST (&dest->cond_list, new_cond, cond_tail);
}
@ -1986,7 +1986,7 @@ clone_one_breakpoint (const struct breakpoint *src)
for (current_cmd = src->command_list; current_cmd != NULL;
current_cmd = current_cmd->next)
{
new_cmd = xcalloc (1, sizeof (*new_cmd));
new_cmd = XCNEW (struct point_command_list);
new_cmd->cmd = clone_agent_expr (current_cmd->cmd);
new_cmd->persistence = current_cmd->persistence;
APPEND_TO_LIST (&dest->command_list, new_cmd, cmd_tail);

3
gdb/gdbserver/regcache.c
View File

@ -159,11 +159,10 @@ init_register_cache (struct regcache *regcache,
struct regcache *
new_register_cache (const struct target_desc *tdesc)
{
struct regcache *regcache;
struct regcache *regcache = XCNEW (struct regcache);
gdb_assert (tdesc->registers_size != 0);
regcache = xmalloc (sizeof (*regcache));
return init_register_cache (regcache, tdesc, NULL);
}

2
gdb/gdbserver/remote-utils.c
View File

@ -1492,7 +1492,7 @@ look_up_one_symbol (const char *name, CORE_ADDR *addrp, int may_ask_gdb)
decode_address (addrp, p, q - p);
/* Save the symbol in our cache. */
sym = xmalloc (sizeof (*sym));
sym = XNEW (struct sym_cache);
sym->name = xstrdup (name);
sym->addr = *addrp;
sym->next = proc->symbol_cache;

9
gdb/gdbserver/server.c
View File

@ -137,7 +137,7 @@ DEFINE_QUEUE_P (notif_event_p);
static void
queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
{
struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif));
struct vstop_notif *new_notif = XNEW (struct vstop_notif);
new_notif->ptid = ptid;
new_notif->status = *status;
@ -206,7 +206,7 @@ start_inferior (char **argv)
count++;
for (i = 0; argv[i] != NULL; i++)
count++;
new_argv = alloca (sizeof (char *) * count);
new_argv = XALLOCAVEC (char *, count);
count = 0;
for (i = 0; wrapper_argv[i] != NULL; i++)
new_argv[count++] = wrapper_argv[i];
@ -2915,7 +2915,7 @@ queue_stop_reply_callback (struct inferior_list_entry *entry, void *arg)
manage the thread's last_status field. */
if (the_target->thread_stopped == NULL)
{
struct vstop_notif *new_notif = xmalloc (sizeof (*new_notif));
struct vstop_notif *new_notif = XNEW (struct vstop_notif);
new_notif->ptid = entry->id;
new_notif->status = thread->last_status;
@ -4282,8 +4282,7 @@ handle_target_event (int err, gdb_client_data client_data)
}
else
{
struct vstop_notif *vstop_notif
= xmalloc (sizeof (struct vstop_notif));
struct vstop_notif *vstop_notif = XNEW (struct vstop_notif);
vstop_notif->status = last_status;
vstop_notif->ptid = last_ptid;

4
gdb/gdbserver/spu-low.c
View File

@ -147,7 +147,7 @@ fetch_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
int tid = ptid_get_lwp (current_ptid);
buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
for (i = 0; i < count; i++, addr += sizeof (PTRACE_TYPE_RET))
if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[i])) != 0)
return ret;
@ -172,7 +172,7 @@ store_ppc_memory (CORE_ADDR memaddr, char *myaddr, int len)
int tid = ptid_get_lwp (current_ptid);
buffer = (PTRACE_TYPE_RET *) alloca (count * sizeof (PTRACE_TYPE_RET));
buffer = XALLOCAVEC (PTRACE_TYPE_RET, count);
if (addr != memaddr || len < (int) sizeof (PTRACE_TYPE_RET))
if ((ret = fetch_ppc_memory_1 (tid, addr, &buffer[0])) != 0)

2
gdb/gdbserver/target.c
View File

@ -181,7 +181,7 @@ start_non_stop (int nonstop)
void
set_target_ops (struct target_ops *target)
{
the_target = (struct target_ops *) xmalloc (sizeof (*the_target));
the_target = XNEW (struct target_ops);
memcpy (the_target, target, sizeof (*the_target));
}

4
gdb/gdbserver/thread-db.c
View File

@ -562,7 +562,7 @@ thread_db_load_search (void)
gdb_assert (proc->priv->thread_db == NULL);
tdb = xcalloc (1, sizeof (*tdb));
tdb = XCNEW (struct thread_db);
proc->priv->thread_db = tdb;
tdb->td_ta_new_p = &td_ta_new;
@ -607,7 +607,7 @@ try_thread_db_load_1 (void *handle)
gdb_assert (proc->priv->thread_db == NULL);
tdb = xcalloc (1, sizeof (*tdb));
tdb = XCNEW (struct thread_db);
proc->priv->thread_db = tdb;
tdb->handle = handle;

27
gdb/gdbserver/tracepoint.c
View File

@ -1803,7 +1803,7 @@ add_tracepoint (int num, CORE_ADDR addr)
{
struct tracepoint *tpoint, **tp_next;
tpoint = xmalloc (sizeof (struct tracepoint));
tpoint = XNEW (struct tracepoint);
tpoint->number = num;
tpoint->address = addr;
tpoint->numactions = 0;
@ -1938,11 +1938,11 @@ add_tracepoint_action (struct tracepoint *tpoint, char *packet)
{
case 'M':
{
struct collect_memory_action *maction;
struct collect_memory_action *maction =
XNEW (struct collect_memory_action);
ULONGEST basereg;
int is_neg;
maction = xmalloc (sizeof *maction);
maction->base.type = *act;
maction->base.ops = &m_tracepoint_action_ops;
action = &maction->base;
@ -1966,9 +1966,9 @@ add_tracepoint_action (struct tracepoint *tpoint, char *packet)
}
case 'R':
{
struct collect_registers_action *raction;
struct collect_registers_action *raction =
XNEW (struct collect_registers_action);
raction = xmalloc (sizeof *raction);
raction->base.type = *act;
raction->base.ops = &r_tracepoint_action_ops;
action = &raction->base;
@ -1982,9 +1982,9 @@ add_tracepoint_action (struct tracepoint *tpoint, char *packet)
}
case 'L':
{
struct collect_static_trace_data_action *raction;
struct collect_static_trace_data_action *raction =
XNEW (struct collect_static_trace_data_action);
raction = xmalloc (sizeof *raction);
raction->base.type = *act;
raction->base.ops = &l_tracepoint_action_ops;
action = &raction->base;
@ -1999,9 +1999,8 @@ add_tracepoint_action (struct tracepoint *tpoint, char *packet)
break;
case 'X':
{
struct eval_expr_action *xaction;
struct eval_expr_action *xaction = XNEW (struct eval_expr_action);
xaction = xmalloc (sizeof (*xaction));
xaction->base.type = *act;
xaction->base.ops = &x_tracepoint_action_ops;
action = &xaction->base;
@ -2088,7 +2087,7 @@ create_trace_state_variable (int num, int gdb)
return tsv;
/* Create a new variable. */
tsv = xmalloc (sizeof (struct trace_state_variable));
tsv = XNEW (struct trace_state_variable);
tsv->number = num;
tsv->initial_value = 0;
tsv->value = 0;
@ -2698,7 +2697,7 @@ cmd_qtdpsrc (char *own_buf)
nbytes = hex2bin (packet, (gdb_byte *) src, strlen (packet) / 2);
src[nbytes] = '\0';
newlast = xmalloc (sizeof (struct source_string));
newlast = XNEW (struct source_string);
newlast->type = srctype;
newlast->str = src;
newlast->next = NULL;
@ -2888,7 +2887,8 @@ cmd_qtro (char *own_buf)
packet = unpack_varlen_hex (packet, &start);
++packet; /* skip a comma */
packet = unpack_varlen_hex (packet, &end);
roreg = xmalloc (sizeof (struct readonly_region));
roreg = XNEW (struct readonly_region);
roreg->start = start;
roreg->end = end;
roreg->next = readonly_regions;
@ -4326,9 +4326,8 @@ static void
add_while_stepping_state (struct thread_info *tinfo,
int tp_number, CORE_ADDR tp_address)
{
struct wstep_state *wstep;
struct wstep_state *wstep = XNEW (struct wstep_state);
wstep = xmalloc (sizeof (*wstep));
wstep->next = tinfo->while_stepping;
wstep->tp_number = tp_number;

4
gdb/gdbserver/win32-low.c
View File

@ -214,7 +214,7 @@ child_add_thread (DWORD pid, DWORD tid, HANDLE h, void *tlb)
if ((th = thread_rec (ptid, FALSE)))
return th;
th = xcalloc (1, sizeof (*th));
th = XCNEW (win32_thread_info);
th->tid = tid;
th->h = h;
th->thread_local_base = (CORE_ADDR) (uintptr_t) tlb;
@ -1084,7 +1084,7 @@ get_image_name (HANDLE h, void *address, int unicode)
ReadProcessMemory (h, address_ptr, buf, len, &done);
else
{
WCHAR *unicode_address = (WCHAR *) alloca (len * sizeof (WCHAR));
WCHAR *unicode_address = XALLOCAVEC (WCHAR, len);
ReadProcessMemory (h, address_ptr, unicode_address, len * sizeof (WCHAR),
&done);

8
gdb/gdbtypes.c
View File

@ -3022,10 +3022,9 @@ rank_function (struct type **parms, int nparms,
struct value **args, int nargs)
{
int i;
struct badness_vector *bv;
struct badness_vector *bv = XNEW (struct badness_vector);
int min_len = nparms < nargs ? nparms : nargs;
bv = xmalloc (sizeof (struct badness_vector));
bv->length = nargs + 1; /* add 1 for the length-match rank. */
bv->rank = XNEWVEC (struct rank, nargs + 1);
@ -4386,8 +4385,7 @@ copy_type_recursive (struct objfile *objfile,
/* We must add the new type to the hash table immediately, in case
we encounter this type again during a recursive call below. */
stored
= obstack_alloc (&objfile->objfile_obstack, sizeof (struct type_pair));
stored = XOBNEW (&objfile->objfile_obstack, struct type_pair);
stored->old = type;
stored->newobj = new_type;
*slot = stored;
@ -4455,7 +4453,7 @@ copy_type_recursive (struct objfile *objfile,
/* For range types, copy the bounds information. */
if (TYPE_CODE (type) == TYPE_CODE_RANGE)
{
TYPE_RANGE_DATA (new_type) = xmalloc (sizeof (struct range_bounds));
TYPE_RANGE_DATA (new_type) = XNEW (struct range_bounds);
*TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type);
}

8
gdb/gnu-nat.c
View File

@ -539,7 +539,7 @@ make_proc (struct inf *inf, mach_port_t port, int tid)
{
error_t err;
mach_port_t prev_port = MACH_PORT_NULL;
struct proc *proc = xmalloc (sizeof (struct proc));
struct proc *proc = XNEW (struct proc);
proc->port = port;
proc->tid = tid;
@ -636,7 +636,7 @@ _proc_free (struct proc *proc)
static struct inf *
make_inf (void)
{
struct inf *inf = xmalloc (sizeof (struct inf));
struct inf *inf = XNEW (struct inf);
inf->task = 0;
inf->threads = 0;
@ -2419,9 +2419,7 @@ gnu_write_inferior (task_t task, CORE_ADDR addr,
}
/* Chain the regions for later use. */
region_element =
(struct vm_region_list *)
obstack_alloc (&region_obstack, sizeof (struct vm_region_list));
region_element = XOBNEW (&region_obstack, struct vm_region_list);
region_element->protection = protection;
region_element->start = region_address;

6
gdb/gnu-v3-abi.c
View File

@ -125,8 +125,7 @@ build_gdb_vtable_type (struct gdbarch *arch)
the alignment that type requires, and then use that here. */
/* Build the field list. */
field_list = xmalloc (sizeof (struct field [4]));
memset (field_list, 0, sizeof (struct field [4]));
field_list = XCNEWVEC (struct field, 4);
field = &field_list[0];
offset = 0;
@ -1025,8 +1024,7 @@ build_std_type_info_type (struct gdbarch *arch)
struct type *char_ptr_type
= make_pointer_type (make_cv_type (1, 0, char_type, NULL), NULL);
field_list = xmalloc (sizeof (struct field [2]));
memset (field_list, 0, sizeof (struct field [2]));
field_list = XCNEWVEC (struct field, 2);
field = &field_list[0];
offset = 0;

3
gdb/guile/scm-param.c
View File

@ -503,8 +503,7 @@ compute_enum_list (SCM enum_values_scm, int arg_pos, const char *func_name)
_("enumeration list is empty"));
}
enum_values = xmalloc ((size + 1) * sizeof (char *));
memset (enum_values, 0, (size + 1) * sizeof (char *));
enum_values = XCNEWVEC (char *, size + 1);
i = 0;
while (!scm_is_eq (enum_values_scm, SCM_EOL))

4
gdb/guile/scm-utils.c
View File

@ -432,8 +432,8 @@ gdbscm_parse_function_args (const char *func_name,
if (num_keywords > 0)
{
SCM *keyword_args = (SCM *) alloca (num_keywords * sizeof (SCM));
int *keyword_positions = (int *) alloca (num_keywords * sizeof (int));
SCM *keyword_args = XALLOCAVEC (SCM, num_keywords);
int *keyword_positions = XALLOCAVEC (int, num_keywords);
gdb_assert (*p == '#');
++p;

2
gdb/guile/scm-value.c
View File

@ -851,7 +851,7 @@ gdbscm_value_call (SCM self, SCM args)
SCM except_scm;
long i;
vargs = alloca (sizeof (struct value *) * args_count);
vargs = XALLOCAVEC (struct value *, args_count);
for (i = 0; i < args_count; i++)
{
SCM arg = scm_car (args);

2
gdb/h8300-tdep.c
View File

@ -1267,7 +1267,7 @@ h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
return arches->gdbarch;
#if 0
tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
tdep = XNEW (struct gdbarch_tdep);
#endif
if (info.bfd_arch_info->arch != bfd_arch_h8300)

2
gdb/ia64-tdep.c
View File

@ -3963,7 +3963,7 @@ ia64_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
if (arches != NULL)
return arches->gdbarch;
tdep = xzalloc (sizeof (struct gdbarch_tdep));
tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->size_of_register_frame = ia64_size_of_register_frame;

6
gdb/infcall.c
View File

@ -570,9 +570,9 @@ dummy_frame_context_saver_get_regs (struct dummy_frame_context_saver *saver)
struct dummy_frame_context_saver *
dummy_frame_context_saver_setup (struct frame_id dummy_id, ptid_t ptid)
{
struct dummy_frame_context_saver *saver;
struct dummy_frame_context_saver *saver =
XNEW (struct dummy_frame_context_saver);
saver = xmalloc (sizeof (*saver));
saver->retbuf = NULL;
saver->drop_done = 0;
register_dummy_frame_dtor (dummy_id, inferior_ptid,
@ -922,7 +922,7 @@ call_function_by_hand_dummy (struct value *function,
struct value **new_args;
/* Add the new argument to the front of the argument list. */
new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
new_args = XNEWVEC (struct value *, nargs + 1);
new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
struct_addr);
memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);

10
gdb/infcmd.c
View File

@ -1121,9 +1121,9 @@ step_once (int skip_subroutines, int single_inst, int count, int thread)
further stepping. */
if (target_can_async_p ())
{
struct step_1_continuation_args *args;
struct step_1_continuation_args *args =
XNEW (struct step_1_continuation_args);
args = xmalloc (sizeof (*args));
args->skip_subroutines = skip_subroutines;
args->single_inst = single_inst;
args->count = count;
@ -1790,7 +1790,7 @@ finish_forward (struct symbol *function, struct frame_info *frame)
/* We want to print return value, please... */
tp->control.proceed_to_finish = 1;
cargs = xmalloc (sizeof (*cargs));
cargs = XNEW (struct finish_command_continuation_args);
cargs->thread = thread;
cargs->breakpoint = breakpoint;
@ -2677,7 +2677,7 @@ attach_command (char *args, int from_tty)
/* sync_execution mode. Wait for stop. */
struct attach_command_continuation_args *a;
a = xmalloc (sizeof (*a));
a = XNEW (struct attach_command_continuation_args);
a->args = xstrdup (args);
a->from_tty = from_tty;
a->async_exec = async_exec;
@ -2745,7 +2745,7 @@ notice_new_inferior (ptid_t ptid, int leave_running, int from_tty)
{
struct attach_command_continuation_args *a;
a = xmalloc (sizeof (*a));
a = XNEW (struct attach_command_continuation_args);
a->args = xstrdup ("");
a->from_tty = from_tty;
a->async_exec = async_exec;

2
gdb/inferior.c
View File

@ -128,7 +128,7 @@ add_inferior_silent (int pid)
{
struct inferior *inf;
inf = xmalloc (sizeof (*inf));
inf = XNEW (struct inferior);
memset (inf, 0, sizeof (*inf));
inf->pid = pid;

22
gdb/infrun.c
View File

@ -1562,7 +1562,7 @@ add_displaced_stepping_state (int pid)
if (state->pid == pid)
return state;
state = xcalloc (1, sizeof (*state));
state = XCNEW (struct displaced_step_inferior_state);
state->pid = pid;
state->next = displaced_step_inferior_states;
displaced_step_inferior_states = state;
@ -8586,7 +8586,8 @@ struct infcall_control_state
struct infcall_control_state *
save_infcall_control_state (void)
{
struct infcall_control_state *inf_status = xmalloc (sizeof (*inf_status));
struct infcall_control_state *inf_status =
XNEW (struct infcall_control_state);
struct thread_info *tp = inferior_thread ();
struct inferior *inf = current_inferior ();
@ -8726,9 +8727,8 @@ restore_inferior_ptid (void *arg)
struct cleanup *
save_inferior_ptid (void)
{
ptid_t *saved_ptid_ptr;
ptid_t *saved_ptid_ptr = XNEW (ptid_t);
saved_ptid_ptr = xmalloc (sizeof (ptid_t));
*saved_ptid_ptr = inferior_ptid;
return make_cleanup (restore_inferior_ptid, saved_ptid_ptr);
}
@ -8914,15 +8914,11 @@ leave it stopped or free to run as needed."),
&showlist);
numsigs = (int) GDB_SIGNAL_LAST;
signal_stop = (unsigned char *) xmalloc (sizeof (signal_stop[0]) * numsigs);
signal_print = (unsigned char *)
xmalloc (sizeof (signal_print[0]) * numsigs);
signal_program = (unsigned char *)
xmalloc (sizeof (signal_program[0]) * numsigs);
signal_catch = (unsigned char *)
xmalloc (sizeof (signal_catch[0]) * numsigs);
signal_pass = (unsigned char *)
xmalloc (sizeof (signal_pass[0]) * numsigs);
signal_stop = XNEWVEC (unsigned char, numsigs);
signal_print = XNEWVEC (unsigned char, numsigs);
signal_program = XNEWVEC (unsigned char, numsigs);
signal_catch = XNEWVEC (unsigned char, numsigs);
signal_pass = XNEWVEC (unsigned char, numsigs);
for (i = 0; i < numsigs; i++)
{
signal_stop[i] = 1;

7
gdb/jit.c
View File

@ -136,7 +136,7 @@ mem_bfd_iovec_stat (struct bfd *abfd, void *stream, struct stat *sb)
static struct bfd *
bfd_open_from_target_memory (CORE_ADDR addr, ULONGEST size, char *target)
{
struct target_buffer *buffer = xmalloc (sizeof (struct target_buffer));
struct target_buffer *buffer = XNEW (struct target_buffer);
buffer->base = addr;
buffer->size = size;
@ -1458,10 +1458,11 @@ free_objfile_data (struct objfile *objfile, void *data)
static void *
jit_gdbarch_data_init (struct obstack *obstack)
{
struct jit_gdbarch_data_type *data;
struct jit_gdbarch_data_type *data =
XOBNEW (obstack, struct jit_gdbarch_data_type);
data = obstack_alloc (obstack, sizeof (struct jit_gdbarch_data_type));
data->unwinder_registered = 0;
return data;
}

3
gdb/language.c
View File

@ -556,8 +556,7 @@ add_language (const struct language_defn *lang)
if (!languages)
{
languages_allocsize = DEFAULT_ALLOCSIZE;
languages = (const struct language_defn **) xmalloc
(languages_allocsize * sizeof (*languages));
languages = XNEWVEC (const struct language_defn *, languages_allocsize);
}
if (languages_size >= languages_allocsize)
{

2
gdb/linespec.c
View File

@ -1332,7 +1332,7 @@ decode_line_2 (struct linespec_state *self,
/* Prepare ITEMS array. */
items_count = result->nelts;
items = xmalloc (sizeof (*items) * items_count);
items = XNEWVEC (struct decode_line_2_item, items_count);
make_cleanup (xfree, items);
for (i = 0; i < items_count; ++i)
{

4
gdb/linux-nat.c
View File

@ -336,7 +336,7 @@ lwp_stop_reason (struct lwp_info *lwp)
static void
add_to_pid_list (struct simple_pid_list **listp, int pid, int status)
{
struct simple_pid_list *new_pid = xmalloc (sizeof (struct simple_pid_list));
struct simple_pid_list *new_pid = XNEW (struct simple_pid_list);
new_pid->pid = pid;
new_pid->status = status;
@ -822,7 +822,7 @@ add_initial_lwp (ptid_t ptid)
gdb_assert (ptid_lwp_p (ptid));
lp = (struct lwp_info *) xmalloc (sizeof (struct lwp_info));
lp = XNEW (struct lwp_info);
memset (lp, 0, sizeof (struct lwp_info));

8
gdb/linux-thread-db.c
View File

@ -211,9 +211,8 @@ static void record_thread (struct thread_db_info *info,
static struct thread_db_info *
add_thread_db_info (void *handle)
{
struct thread_db_info *info;
struct thread_db_info *info = XCNEW (struct thread_db_info);
info = xcalloc (1, sizeof (*info));
info->pid = ptid_get_pid (inferior_ptid);
info->handle = handle;
@ -1308,8 +1307,7 @@ record_thread (struct thread_db_info *info,
return;
/* Construct the thread's private data. */
priv = xmalloc (sizeof (struct private_thread_info));
memset (priv, 0, sizeof (struct private_thread_info));
priv = XCNEW (struct private_thread_info);
priv->th = *th_p;
priv->tid = ti_p->ti_tid;
@ -1998,7 +1996,7 @@ info_auto_load_libthread_db (char *args, int from_tty)
if (info->filename != NULL)
info_count++;
array = xmalloc (sizeof (*array) * info_count);
array = XNEWVEC (struct thread_db_info *, info_count);
back_to = make_cleanup (xfree, array);
info_count = 0;

2
gdb/m32c-tdep.c
View File

@ -2638,7 +2638,7 @@ m32c_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
arches = gdbarch_list_lookup_by_info (arches->next, &info))
return arches->gdbarch;
tdep = xcalloc (1, sizeof (*tdep));
tdep = XCNEW (struct gdbarch_tdep);
arch = gdbarch_alloc (&info, tdep);
/* Essential types. */

2
gdb/m68hc11-tdep.c
View File

@ -1451,7 +1451,7 @@ m68hc11_gdbarch_init (struct gdbarch_info info,
}
/* Need a new architecture. Fill in a target specific vector. */
tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->elf_flags = elf_flags;

2
gdb/m68k-tdep.c
View File

@ -1185,7 +1185,7 @@ m68k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
return best_arch->gdbarch;
}
tdep = xzalloc (sizeof (struct gdbarch_tdep));
tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->fpregs_present = has_fp;
tdep->flavour = flavour;

8
gdb/m88k-tdep.c
View File

@ -533,11 +533,9 @@ m88k_analyze_prologue (struct gdbarch *gdbarch,
/* Provide a dummy cache if necessary. */
if (cache == NULL)
{
size_t sizeof_saved_regs =
(M88K_R31_REGNUM + 1) * sizeof (struct trad_frame_saved_reg);
cache = alloca (sizeof (struct m88k_frame_cache));
cache->saved_regs = alloca (sizeof_saved_regs);
cache->saved_regs
= XALLOCAVEC (struct trad_frame_saved_reg, M88K_R31_REGNUM + 1);
cache = XALLOCA (struct m88k_frame_cache);
/* We only initialize the members we care about. */
cache->saved_regs[M88K_R1_REGNUM].addr = -1;

2
gdb/macrocmd.c
View File

@ -387,7 +387,7 @@ macro_define_command (char *exp, int from_tty)
{
/* Function-like macro. */
int alloced = 5;
char **argv = (char **) xmalloc (alloced * sizeof (char *));
char **argv = XNEWVEC (char *, alloced);
new_macro.kind = macro_function_like;
new_macro.argc = 0;

Some files were not shown because too many files have changed in this diff Show More