+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
{
struct aarch64_process_info *proc;
- proc = xcalloc (1, sizeof (*proc));
+ proc = XCNEW (struct aarch64_process_info);
proc->pid = pid;
proc->next = aarch64_process_list;
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. */
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);
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;
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 ();
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;
/* 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)
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;
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;
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)
{
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);
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++;
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++;
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;
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()
{
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;
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);
{
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;
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. */
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;
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);
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.
/* 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, ®names);
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;
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
{
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;
}
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;
}
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);
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;
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.
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++)
{
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;
}
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. */
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)
{
struct btrace_function *bfun;
- bfun = xzalloc (sizeof (*bfun));
+ bfun = XCNEW (struct btrace_function);
bfun->msym = mfun;
bfun->sym = fun;
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;
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;
}
else
{
- link = (struct pending *) xmalloc (sizeof (struct pending));
+ link = XNEW (struct pending);
}
link->next = *listhead;
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)
{
/* 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;
{
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;
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;
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;
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
{
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;
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
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;
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;
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;
}
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;
}
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;
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;
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);
{
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]);
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++)
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, §ion_data);
{
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)
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, "");
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;
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;
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;
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 *));
}
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);
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;
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; \
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; \
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;
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;
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);
{
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]);
{
/* 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;
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);
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;
}
/* 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;
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;
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
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);
}
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. */
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;
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 *));
}
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 =
/* 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;
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,
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. */
}
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;
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,
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. */
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
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)
{
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;
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;
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;
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;
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)
{
}
/* 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)
{
{
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;
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)
{
/* 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);
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);
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);
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;
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);
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;
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;
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]
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;
{
/* 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);
{
/* 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);
/* 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);
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)
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;
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);
&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);
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;
/* 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);
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. */
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,
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;
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 *)));
{
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;
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));
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);
/* 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;
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)
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);
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;
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;
}
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;
&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;
{
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;
}
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 *));
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)
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));
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)
{
*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
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;
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)
{
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);
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)
/* 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);
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 *
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++;
{
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);
{
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);
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;
}
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
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];
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);
{
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 *));
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
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;
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;
* 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;
{
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;
{
async_event_handler *h;
- h = xmalloc (sizeof (*h));
+ h = XNEW (struct async_event_handler);
h->ready = 0;
h->next_handler = NULL;
h->proc = 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? */
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)
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;
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]);
}
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;
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;
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;
}
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. */
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;
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;
}
+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.
++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);
/* 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;
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;
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;
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;
{
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;
}
}
/* 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;
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;
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;
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);
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;
}
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++)
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;
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 ();
&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;
{
struct lwp_info *lwp;
- lwp = (struct lwp_info *) xcalloc (1, sizeof (*lwp));
+ lwp = XCNEW (struct lwp_info);
lwp->waitstatus.kind = TARGET_WAITKIND_IGNORE;
}
}
- 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);
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)
|| 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)
/* 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
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;
/ 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);
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;
}
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;
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;
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
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;
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;
return bp;
}
- bp = xcalloc (1, sizeof (*bp));
+ bp = XCNEW (struct raw_breakpoint);
bp->pc = where;
bp->size = size;
bp->refcount = 1;
return NULL;
}
- bp = xcalloc (1, sizeof (struct breakpoint));
+ bp = XCNEW (struct breakpoint);
bp->type = type;
bp->raw = raw;
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. */
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;
{
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);
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;
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;
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);
}
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);
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);
}
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;
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;
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];
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;
}
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;
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;
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)
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));
}
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;
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;
{
struct tracepoint *tpoint, **tp_next;
- tpoint = xmalloc (sizeof (struct tracepoint));
+ tpoint = XNEW (struct tracepoint);
tpoint->number = num;
tpoint->address = addr;
tpoint->numactions = 0;
{
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;
}
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;
}
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;
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;
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;
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;
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;
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;
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;
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);
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);
/* 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;
/* 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);
}
{
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;
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;
}
/* Chain the regions for later use. */
- region_element =
- (struct vm_region_list *)
- obstack_alloc (®ion_obstack, sizeof (struct vm_region_list));
+ region_element = XOBNEW (®ion_obstack, struct vm_region_list);
region_element->protection = protection;
region_element->start = region_address;
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;
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;
_("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))
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;
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);
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)
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;
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,
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);
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;
/* 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;
/* 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;
{
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;
{
struct inferior *inf;
- inf = xmalloc (sizeof (*inf));
+ inf = XNEW (struct inferior);
memset (inf, 0, sizeof (*inf));
inf->pid = 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;
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 ();
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);
}
&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;
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;
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;
}
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)
{
/* 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)
{
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;
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));
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;
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;
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;
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. */
}
/* 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;
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;
/* 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;
{
/* 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;
args_len = 0;
args_size = 6;
- args = (struct macro_buffer *) xmalloc (sizeof (*args) * args_size);
+ args = XNEWVEC (struct macro_buffer, args_size);
for (;;)
{
if (COMPUNIT_MACRO_TABLE (cust) == NULL)
return NULL;
- ms = (struct macro_scope *) xmalloc (sizeof (*ms));
+ ms = XNEW (struct macro_scope);
main_file = macro_main (COMPUNIT_MACRO_TABLE (cust));
inclusion = macro_lookup_inclusion (main_file, sal.symtab->filename);
/* First, get storage for the `struct macro_table' itself. */
if (obstack)
- t = obstack_alloc (obstack, sizeof (*t));
+ t = XOBNEW (obstack, struct macro_table);
else
- t = xmalloc (sizeof (*t));
+ t = XNEW (struct macro_table);
memset (t, 0, sizeof (*t));
t->obstack = obstack;
if (top_stack && top_stack->prev)
newobj = top_stack->prev;
else
- newobj = (struct parse_stack *) xzalloc (sizeof (struct parse_stack));
+ newobj = XCNEW (struct parse_stack);
/* Initialize new frame with previous content. */
if (top_stack)
{
/* Allocate the map FDR -> PST.
Minor hack: -O3 images might claim some global data belongs
to FDR -1. We`ll go along with that. */
- fdr_to_pst = (struct pst_map *)
- xzalloc ((hdr->ifdMax + 1) * sizeof *fdr_to_pst);
+ fdr_to_pst = XCNEWVEC (struct pst_map, hdr->ifdMax + 1);
old_chain = make_cleanup (xfree, fdr_to_pst);
fdr_to_pst++;
{
hdr->ifdMax * sizeof (struct mdebug_pending *));
/* Pass 0 over external syms: swap them in. */
- ext_block = (EXTR *) xmalloc (hdr->iextMax * sizeof (EXTR));
+ ext_block = XNEWVEC (EXTR, hdr->iextMax);
make_cleanup (xfree, ext_block);
ext_out = (char *) debug_info->external_ext;
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
+ pr_block = XNEWVEC (PDR, fh->cpd);
old_chain = make_cleanup (xfree, pr_block);
pdr_ptr = ((char *) debug_info->external_pdr
PDR *pdr_in;
PDR *pdr_in_end;
- pr_block = (PDR *) xmalloc (fh->cpd * sizeof (PDR));
+ pr_block = XNEWVEC (PDR, fh->cpd);
old_chain = make_cleanup (xfree, pr_block);
/* FIXME: carlton/2003-09-11: This should use allocate_block to
allocate the block. Which, in turn, suggests that the block
should be allocated on an obstack. */
- struct block *retval = xzalloc (sizeof (struct block));
+ struct block *retval = XCNEW (struct block);
if (type == FUNCTION_BLOCK)
BLOCK_DICT (retval) = dict_create_linear_expandable ();
if (gdbarch_tdep (arches->gdbarch)->me_module == me_module)
return arches->gdbarch;
- tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
+ tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
/* Get a CGEN CPU descriptor for this architecture. */
if (do_timings)
{
- command->cmd_start = (struct mi_timestamp *)
- xmalloc (sizeof (struct mi_timestamp));
+ command->cmd_start = XNEW (struct mi_timestamp);
timestamp (command->cmd_start);
}
{
const char *chp = args;
int argc = 0;
- char **argv = xmalloc ((argc + 1) * sizeof (char *));
+ char **argv = XNEWVEC (char *, argc + 1);
argv[argc] = NULL;
while (1)
}
xfree (indexdata);
- lstream = xzalloc (sizeof (struct gdb_lzma_stream));
+ lstream = XCNEW (struct gdb_lzma_stream);
lstream->section = section;
lstream->index = index;
return -1;
/* It fit. Stick it on the end of the list. */
- new_watch = (struct mips_watchpoint *)
- xmalloc (sizeof (struct mips_watchpoint));
+ new_watch = XNEW (struct mips_watchpoint);
new_watch->addr = addr;
new_watch->len = len;
new_watch->type = type;
}
/* 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;
tdep->mips64_transfers_32bit_regs_p = mips64_transfers_32bit_regs_p;
if (arches != NULL)
return arches->gdbarch;
- tdep = xmalloc (sizeof (struct gdbarch_tdep));
+ tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
switch (info.bfd_arch_info->mach)
/* None found, create a new architecture from the information
provided. */
- tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
+ tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->elf_flags = elf_flags;
tdep->isa = isa;
regsize = register_size (gdbarch, regnum);
buff = alloca (regsize);
- bytes = alloca (regsize * sizeof (*bytes));
+ bytes = XALLOCAVEC (unsigned int, regsize);
deprecated_frame_register_read (frame, regnum, buff);
void
aarch64_linux_new_thread (struct lwp_info *lwp)
{
- struct arch_lwp_info *info = xcalloc (1, sizeof (*info));
+ struct arch_lwp_info *info = XNEW (struct arch_lwp_info);
/* Mark that all the hardware breakpoint/watchpoint register pairs
for this thread need to be initialized (with data from
__u64 data_offset;
int pid, pg;
- tinfo = xzalloc (sizeof (*tinfo));
+ tinfo = XCNEW (struct btrace_target_info);
tinfo->ptid = ptid;
tinfo->ptr_bits = linux_determine_kernel_ptr_bits ();
if (pid == 0)
pid = ptid_get_pid (ptid);
- tinfo = xzalloc (sizeof (*tinfo));
+ tinfo = XCNEW (struct btrace_target_info);
tinfo->ptid = ptid;
tinfo->ptr_bits = 0;
strcpy (user, "?");
/* Find CPU cores used by the process. */
- cores = (int *) xcalloc (num_cores, sizeof (int));
+ cores = XCNEWVEC (int, num_cores);
task_count = get_cores_used_by_process (pid, cores, num_cores);
cores_str = (char *) xcalloc (task_count, sizeof ("4294967295") + 1);
{
struct dirent *dp;
const size_t list_block_size = 512;
- PID_T *process_list = (PID_T *) xmalloc (list_block_size * 2 * sizeof (PID_T));
+ PID_T *process_list = XNEWVEC (PID_T, list_block_size * 2);
size_t process_count = 0;
size_t i;
/* None found, create a new architecture from the information
provided. */
- tdep = xcalloc (1, sizeof (struct gdbarch_tdep));
+ tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
/* longjmp support not enabled by default. */
return;
}
- mapinfos = xmalloc (num * sizeof (procfs_mapinfo));
+ mapinfos = XNEWVEC (procfs_mapping, num);
num_mapinfos = num;
mapinfo_p = mapinfos;
void
start_msglist(void)
{
- struct selname *newobj =
- (struct selname *) xmalloc (sizeof (struct selname));
+ struct selname *newobj = XNEW (struct selname);
newobj->next = selname_chain;
newobj->msglist_len = msglist_len;
printf_filtered (_("Selectors matching \"%s\":\n\n"),
regexp ? regexp : "*");
- sym_arr = alloca (matches * sizeof (struct symbol *));
+ sym_arr = XALLOCAVEC (struct symbol *, matches);
matches = 0;
ALL_MSYMBOLS (objfile, msymbol)
{
{
printf_filtered (_("Classes matching \"%s\":\n\n"),
regexp ? regexp : "*");
- sym_arr = alloca (matches * sizeof (struct symbol *));
+ sym_arr = XALLOCAVEC (struct symbol *, matches);
matches = 0;
ALL_MSYMBOLS (objfile, msymbol)
{
if (objc_csym == NULL)
{
- objc_csym = obstack_alloc (&objfile->objfile_obstack,
- sizeof (*objc_csym));
+ objc_csym = XOBNEW (&objfile->objfile_obstack, unsigned int);
*objc_csym = objfile_csym;
set_objfile_data (objfile, objc_objfile_data, objc_csym);
}
struct objfile *objfile;
char *expanded_name;
- objfile = (struct objfile *) xzalloc (sizeof (struct objfile));
+ objfile = XCNEW (struct objfile);
objfile->psymbol_cache = psymbol_bcache_init ();
/* We could use obstack_specify_allocation here instead, but
gdb_obstack.h specifies the alloc/dealloc functions. */
return;
}
- map = xmalloc (alloc_size * sizeof (*map));
+ map = XNEWVEC (struct obj_section *, alloc_size);
i = 0;
ALL_PSPACE_OBJFILES (pspace, objfile)
}
}
- (*handler_p)
- = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
+ (*handler_p) = XNEW (struct gdb_osabi_handler);
(*handler_p)->next = NULL;
(*handler_p)->arch_info = arch_info;
(*handler_p)->osabi = osabi;
{
struct gdb_osabi_sniffer *sniffer;
- sniffer =
- (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
+ sniffer = XNEW (struct gdb_osabi_sniffer);
sniffer->arch = arch;
sniffer->flavour = flavour;
sniffer->sniffer = sniffer_fn;
{
struct funcall *newobj;
- newobj = (struct funcall *) xmalloc (sizeof (struct funcall));
+ newobj = XNEW (struct funcall);
newobj->next = funcall_chain;
newobj->arglist_len = arglist_len;
arglist_len = 0;
if the wanted one does not exist? */
if (alloc_new)
{
- t = xmalloc (sizeof (struct thread_points));
- t->hw_breaks
- = xzalloc (max_slots_number * sizeof (struct hw_break_tuple));
+ t = XNEW (struct thread_points);
+ t->hw_breaks = XCNEWVEC (struct hw_break_tuple, max_slots_number);
t->tid = tid;
VEC_safe_push (thread_points_p, ppc_threads, t);
}
{
int i;
long slot;
- struct ppc_hw_breakpoint *p = xmalloc (sizeof (struct ppc_hw_breakpoint));
+ struct ppc_hw_breakpoint *p = XNEW (struct ppc_hw_breakpoint);
struct hw_break_tuple *hw_breaks;
struct cleanup *c = make_cleanup (xfree, p);
struct thread_points *t;
innermost_block = NULL;
expr = parse_expression (exp);
- newobj = (struct display *) xmalloc (sizeof (struct display));
+ newobj = XNEW (struct display);
newobj->exp_string = xstrdup (exp);
newobj->exp = expr;
int allocated_args = 20;
struct cleanup *old_cleanups;
- val_args = xmalloc (allocated_args * sizeof (struct value *));
+ val_args = XNEWVEC (struct value *, allocated_args);
old_cleanups = make_cleanup (free_current_contents, &val_args);
if (s == 0)
create it if it
doesn't exist yet? */
- pi = (procinfo *) xmalloc (sizeof (procinfo));
+ pi = XNEW (procinfo);
memset (pi, 0, sizeof (procinfo));
pi->pid = pid;
pi->tid = tid;
maxcall = syscalls[i].pr_number;
pi->num_syscalls = maxcall+1;
- pi->syscall_names = xmalloc (pi->num_syscalls * sizeof (char *));
+ pi->syscall_names = XNEWVEC (char *, pi->num_syscalls);
for (i = 0; i < pi->num_syscalls; i++)
pi->syscall_names[i] = NULL;
/* Allocate space for one LDT entry.
This alloc must persist, because we return a pointer to it. */
if (ldt_entry == NULL)
- ldt_entry = (struct ssd *) xmalloc (sizeof (struct ssd));
+ ldt_entry = XNEW (struct ssd);
/* Open the file descriptor for the LDT table. */
sprintf (pathname, "/proc/%d/ldt", pi->pid);
if ((nlwp = proc_get_nthreads (pi)) <= 1)
return 1; /* Process is not multi-threaded; nothing to do. */
- prstatus = xmalloc (sizeof (gdb_prstatus_t) * (nlwp + 1));
+ prstatus = XNEWVEC (gdb_prstatus_t, nlwp + 1);
old_chain = make_cleanup (xfree, prstatus);
if (ioctl (pi->ctl_fd, PIOCLSTATUS, prstatus) < 0)
if (nthreads < 2)
return 0; /* Nothing to do for 1 or fewer threads. */
- threads = xmalloc (nthreads * sizeof (tid_t));
+ threads = XNEWVEC (tid_t, nthreads);
if (ioctl (pi->ctl_fd, PIOCTLIST, threads) < 0)
proc_error (pi, "procfs: update_threads (PIOCTLIST)", __LINE__);
struct pv_area *
make_pv_area (int base_reg, int addr_bit)
{
- struct pv_area *a = (struct pv_area *) xmalloc (sizeof (*a));
+ struct pv_area *a = XNEW (struct pv_area);
memset (a, 0, sizeof (*a));
else
{
CORE_ADDR offset = addr.k;
- struct area_entry *e = (struct area_entry *) xmalloc (sizeof (*e));
+ struct area_entry *e = XNEW (struct area_entry);
e->offset = offset;
e->size = size;
if (listp->size == 0)
{
new_size = 255;
- listp->list = (struct partial_symbol **)
- xmalloc (new_size * sizeof (struct partial_symbol *));
+ listp->list = XNEWVEC (struct partial_symbol *, new_size);
}
else
{
if (objfile->global_psymbols.size > 0)
{
objfile->global_psymbols.next =
- objfile->global_psymbols.list = (struct partial_symbol **)
- xmalloc ((objfile->global_psymbols.size
- * sizeof (struct partial_symbol *)));
+ objfile->global_psymbols.list =
+ XNEWVEC (struct partial_symbol *, objfile->global_psymbols.size);
}
if (objfile->static_psymbols.size > 0)
{
objfile->static_psymbols.next =
- objfile->static_psymbols.list = (struct partial_symbol **)
- xmalloc ((objfile->static_psymbols.size
- * sizeof (struct partial_symbol *)));
+ objfile->static_psymbols.list =
+ XNEWVEC (struct partial_symbol *, objfile->static_psymbols.size);
}
}
inf_obj = (inferior_object *) thread_obj->inf_obj;
- entry = xmalloc (sizeof (struct threadlist_entry));
+ entry = XNEW (struct threadlist_entry);
entry->thread_obj = thread_obj;
entry->next = inf_obj->threads;
return 0;
}
- self->enumeration = xmalloc ((size + 1) * sizeof (char *));
+ self->enumeration = XCNEWVEC (const char *, size + 1);
back_to = make_cleanup (free_current_contents, &self->enumeration);
- memset (self->enumeration, 0, (size + 1) * sizeof (char *));
for (i = 0; i < size; ++i)
{
{
int i;
- vargs = alloca (sizeof (struct value *) * args_count);
+ vargs = XALLOCAVEC (struct value *, args_count);
for (i = 0; i < args_count; i++)
{
PyObject *item = PyTuple_GetItem (args, i);
error (_("Invalid item from the child list"));
}
- vitem = xmalloc (sizeof *vitem);
+ vitem = XNEW (struct varobj_item);
vitem->value = convert_value_from_python (py_v);
if (vitem->value == NULL)
gdbpy_print_stack ();
ensure_python_env (struct gdbarch *gdbarch,
const struct language_defn *language)
{
- struct python_env *env = xmalloc (sizeof *env);
+ struct python_env *env = XNEW (struct python_env);
/* We should not ever enter Python unless initialized. */
if (!gdb_python_initialized)
/* We start replaying at the end of the branch trace. This corresponds
to the current instruction. */
- replay = xmalloc (sizeof (*replay));
+ replay = XNEW (struct btrace_insn_iterator);
btrace_insn_end (replay, btinfo);
/* Skip gaps at the end of the trace. */
struct record_full_entry *rec;
struct gdbarch *gdbarch = get_regcache_arch (regcache);
- rec = xcalloc (1, sizeof (struct record_full_entry));
+ rec = XCNEW (struct record_full_entry);
rec->type = record_full_reg;
rec->u.reg.num = regnum;
rec->u.reg.len = register_size (gdbarch, regnum);
{
struct record_full_entry *rec;
- rec = xcalloc (1, sizeof (struct record_full_entry));
+ rec = XCNEW (struct record_full_entry);
rec->type = record_full_mem;
rec->u.mem.addr = addr;
rec->u.mem.len = len;
{
struct record_full_entry *rec;
- rec = xcalloc (1, sizeof (struct record_full_entry));
+ rec = XCNEW (struct record_full_entry);
rec->type = record_full_end;
return rec;
if (!entry)
{
/* Add a new entry. */
- entry = (struct record_full_core_buf_entry *)
- xmalloc
- (sizeof (struct record_full_core_buf_entry));
+ entry = XNEW (struct record_full_core_buf_entry);
entry->p = p;
if (!bfd_malloc_and_get_section
(p->the_bfd_section->owner,
new_regcache = regcache_xmalloc_1 (gdbarch, aspace, 0);
new_regcache->ptid = ptid;
- list = xmalloc (sizeof (struct regcache_list));
+ list = XNEW (struct regcache_list);
list->regcache = new_regcache;
list->next = current_regcache;
current_regcache = list;
if (!remote_fio_data.fd_map)
{
- remote_fio_data.fd_map = (int *) xmalloc (10 * sizeof (int));
+ remote_fio_data.fd_map = XNEWVEC (int, 10);
remote_fio_data.fd_map_size = 10;
remote_fio_data.fd_map[0] = FIO_FD_CONSOLE_IN;
remote_fio_data.fd_map[1] = FIO_FD_CONSOLE_OUT;
struct remote_notif_state *
remote_notif_state_allocate (void)
{
- struct remote_notif_state *notif_state = xzalloc (sizeof (*notif_state));
+ struct remote_notif_state *notif_state = XCNEW (struct remote_notif_state);
notif_state->notif_queue = QUEUE_alloc (notif_client_p, NULL);
if (!info->priv)
{
- info->priv = xmalloc (sizeof (*(info->priv)));
+ info->priv = XNEW (struct private_thread_info);
info->private_dtor = free_private_thread_info;
info->priv->core = -1;
info->priv->extra = 0;
static struct notif_event *
remote_notif_stop_alloc_reply (void)
{
- struct notif_event *r
- = (struct notif_event *) XNEW (struct stop_reply);
+ /* We cast to a pointer to the "base class". */
+ struct notif_event *r = (struct notif_event *) XNEW (struct stop_reply);
r->dtr = stop_reply_dtr;
target_pid_to_str (ptid));
}
- tinfo = xzalloc (sizeof (*tinfo));
+ tinfo = XCNEW (struct btrace_target_info);
tinfo->ptid = ptid;
/* If we fail to read the configuration, we lose some information, but the
error (_("target_get_bookmark failed."));
/* Set up a bookmark struct. */
- b = xcalloc (1, sizeof (struct bookmark));
+ b = XCNEW (struct bookmark);
b->number = ++bookmark_count;
init_sal (&b->sal);
b->pc = regcache_read_pc (get_current_regcache ());
/* None found, create a new architecture from the information
provided. */
- tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
+ tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->elf_flags = elf_flags;
/* None found, create a new architecture from the information
provided. */
- tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
+ tdep = XNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep);
tdep->elf_flags = elf_flags;
struct expression *cond)
{
struct lwp_info *lp;
- struct watch_area *area = xmalloc (sizeof (struct watch_area));
+ struct watch_area *area = XNEW (struct watch_area);
if (!area)
return -1;
return NULL;
}
- state = (struct dos_ttystate *) xmalloc (sizeof *state);
+ state = XNEW (struct dos_ttystate);
*state = *port;
return (serial_ttystate) state;
}
{
struct dos_ttystate *state;
- state = (struct dos_ttystate *) xmalloc (sizeof *state);
+ state = XNEW (struct dos_ttystate);
*state = *(struct dos_ttystate *) ttystate;
return (serial_ttystate) state;
return -1;
}
- state = xmalloc (sizeof (struct ser_windows_state));
- memset (state, 0, sizeof (struct ser_windows_state));
+ state = XCNEW (struct ser_windows_state);
scb->state = state;
/* Create a manual reset event to watch the input buffer. */
return;
}
- state = xmalloc (sizeof (struct ser_console_state));
- memset (state, 0, sizeof (struct ser_console_state));
+ state = XCNEW (struct ser_console_state);
scb->state = state;
if (is_tty)
{
struct ser_console_ttystate *state;
- state = (struct ser_console_ttystate *) xmalloc (sizeof *state);
+ state = XNEW (struct ser_console_ttystate);
state->is_a_tty = 1;
return state;
}
static struct pipe_state *
make_pipe_state (void)
{
- struct pipe_state *ps = XNEW (struct pipe_state);
+ struct pipe_state *ps = XCNEW (struct pipe_state);
- memset (ps, 0, sizeof (*ps));
ps->wait.read_event = INVALID_HANDLE_VALUE;
ps->wait.except_event = INVALID_HANDLE_VALUE;
ps->wait.start_select = INVALID_HANDLE_VALUE;
if (ret != 0)
return ret;
- state = xmalloc (sizeof (struct net_windows_state));
- memset (state, 0, sizeof (struct net_windows_state));
+ state = XCNEW (struct net_windows_state);
scb->state = state;
/* Associate an event with the socket. */
static serial_ttystate
hardwire_get_tty_state (struct serial *scb)
{
- struct hardwire_ttystate *state;
-
- state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
+ struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
if (get_tty_state (scb, state))
{
static serial_ttystate
hardwire_copy_tty_state (struct serial *scb, serial_ttystate ttystate)
{
- struct hardwire_ttystate *state;
+ struct hardwire_ttystate *state = XNEW (struct hardwire_ttystate);
- state = (struct hardwire_ttystate *) xmalloc (sizeof *state);
*state = *(struct hardwire_ttystate *) ttystate;
return (serial_ttystate) state;
static struct lm_info *
solib_aix_new_lm_info (struct lm_info *info)
{
- struct lm_info *result = xmalloc (sizeof (struct lm_info));
+ struct lm_info *result = XNEW (struct lm_info);
memcpy (result, info, sizeof (struct lm_info));
result->filename = xstrdup (info->filename);
break;
}
- sop = xcalloc (1, sizeof (struct so_list));
- sop->lm_info = xcalloc (1, sizeof (struct lm_info));
+ sop = XCNEW (struct so_list);
+ sop->lm_info = XCNEW (struct lm_info);
sop->lm_info->map = loadmap;
/* Fetch the name. */
addr = extract_unsigned_integer (lm_buf.l_name,
ldm = info->exec_loadmap;
xfree (info->main_executable_lm_info);
- info->main_executable_lm_info = xcalloc (1, sizeof (struct lm_info));
+ info->main_executable_lm_info = XCNEW (struct lm_info);
info->main_executable_lm_info->map = ldm;
new_offsets = xcalloc (symfile_objfile->num_sections,
break;
}
- sop = xcalloc (1, sizeof (struct so_list));
- sop->lm_info = xcalloc (1, sizeof (struct lm_info));
+ sop = XCNEW (struct so_list);
+ sop->lm_info = XCNEW (struct lm_info);
sop->lm_info->map = loadmap;
sop->lm_info->got_value = got_addr;
sop->lm_info->lm_addr = lm_addr;
if (main_executable_lm_info)
xfree (main_executable_lm_info);
- main_executable_lm_info = xcalloc (1, sizeof (struct lm_info));
+ main_executable_lm_info = XCNEW (struct lm_info);
main_executable_lm_info->map = ldm;
new_offsets = xcalloc (symfile_objfile->num_sections,
spu_bfd_fopen (char *name, CORE_ADDR addr)
{
bfd *nbfd;
+ CORE_ADDR *open_closure = XNEW (CORE_ADDR);
- CORE_ADDR *open_closure = xmalloc (sizeof (CORE_ADDR));
*open_closure = addr;
nbfd = gdb_bfd_openr_iovec (name, "elf32-spu",
{
struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr;
- lm_info = xzalloc (sizeof (*lm_info));
+ lm_info = XCNEW (struct lm_info);
lm_info->lm_addr = lm_addr;
lm_info->l_addr_inferior = extract_typed_address (&lm[lmo->l_addr_offset],
{
struct so_list *newobj;
- newobj = xmalloc (sizeof (struct so_list));
+ newobj = XNEW (struct so_list);
memcpy (newobj, src, sizeof (struct so_list));
- newobj->lm_info = xmalloc (sizeof (struct lm_info));
+ newobj->lm_info = XNEW (struct lm_info);
memcpy (newobj->lm_info, src->lm_info, sizeof (struct lm_info));
newobj->next = NULL;
newobj = XCNEW (struct so_list);
- newobj->lm_info = xzalloc (sizeof (struct lm_info));
+ newobj->lm_info = XCNEW (struct lm_info);
/* Nothing will ever check the other fields if we set l_addr_p. */
newobj->lm_info->l_addr = info->debug_loader_offset;
int size;
gdb_assert (s);
- line_charpos = (int *) xmalloc (lines_allocated * sizeof (int));
+ line_charpos = XNEWVEC (int, lines_allocated);
if (fstat (desc, &st) < 0)
perror_with_name (symtab_to_filename_for_display (s));
sal.line = current_source_line;
sals.nelts = 1;
- sals.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line));
+ sals.sals = XNEW (struct symtab_and_line);
sals.sals[0] = sal;
}
else
add_substitute_path_rule (char *from, char *to)
{
struct substitute_path_rule *rule;
- struct substitute_path_rule *new_rule;
+ struct substitute_path_rule *new_rule = XNEW (struct substitute_path_rule);
- new_rule = xmalloc (sizeof (struct substitute_path_rule));
new_rule->from = xstrdup (from);
new_rule->to = xstrdup (to);
new_rule->next = NULL;
struct bfd *nbfd;
asection *spu_name;
- ULONGEST *open_closure = xmalloc (sizeof (ULONGEST));
+ ULONGEST *open_closure = XNEW (ULONGEST);
*open_closure = addr;
nbfd = gdb_bfd_openr_iovec ("<in-memory>", "elf32-spu",
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
};
- int *seq = alloca (nr * sizeof (int));
+ int *seq = XALLOCAVEC (int, nr);
int done = 0;
struct cleanup *chain;
int i, j;
if (old_len == 0)
{
type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
- type_vector = (struct type **)
- xmalloc (type_vector_length * sizeof (struct type *));
+ type_vector = XNEWVEC (struct type *, type_vector_length);
}
while (index >= type_vector_length)
{
while (**pp && **pp != '#')
{
struct type *arg_type = read_type (pp, objfile);
- struct type_list *newobj = alloca (sizeof (*newobj));
+ struct type_list *newobj = XALLOCA (struct type_list);
newobj->type = arg_type;
newobj->next = arg_types;
arg_types = newobj;
look_ahead_type = NULL;
length = 0;
- new_fnlist = (struct next_fnfieldlist *)
- xmalloc (sizeof (struct next_fnfieldlist));
+ new_fnlist = XCNEW (struct next_fnfieldlist);
make_cleanup (xfree, new_fnlist);
- memset (new_fnlist, 0, sizeof (struct next_fnfieldlist));
if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
{
do
{
- new_sublist =
- (struct next_fnfield *) xmalloc (sizeof (struct next_fnfield));
+ new_sublist = XCNEW (struct next_fnfield);
make_cleanup (xfree, new_sublist);
- memset (new_sublist, 0, sizeof (struct next_fnfield));
/* Check for and handle cretinous dbx symbol name continuation! */
if (look_ahead_type == NULL)
/* Create a new fn_fieldlist for the destructors. */
- destr_fnlist = (struct next_fnfieldlist *)
- xmalloc (sizeof (struct next_fnfieldlist));
+ destr_fnlist = XCNEW (struct next_fnfieldlist);
make_cleanup (xfree, destr_fnlist);
- memset (destr_fnlist, 0, sizeof (struct next_fnfieldlist));
+
destr_fnlist->fn_fieldlist.name
= obconcat (&objfile->objfile_obstack, "~",
new_fnlist->fn_fieldlist.name, (char *) NULL);
- destr_fnlist->fn_fieldlist.fn_fields = (struct fn_field *)
- obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct fn_field) * has_destructor);
+ destr_fnlist->fn_fieldlist.fn_fields =
+ XOBNEWVEC (&objfile->objfile_obstack,
+ struct fn_field, has_destructor);
memset (destr_fnlist->fn_fieldlist.fn_fields, 0,
sizeof (struct fn_field) * has_destructor);
tmp_sublist = sublist;
{
STABS_CONTINUE (pp, objfile);
/* Get space to record the next field's data. */
- newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
+ newobj = XCNEW (struct nextfield);
make_cleanup (xfree, newobj);
- memset (newobj, 0, sizeof (struct nextfield));
+
newobj->next = fip->list;
fip->list = newobj;
for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
{
- newobj = (struct nextfield *) xmalloc (sizeof (struct nextfield));
+ newobj = XCNEW (struct nextfield);
make_cleanup (xfree, newobj);
- memset (newobj, 0, sizeof (struct nextfield));
+
newobj->next = fip->list;
fip->list = newobj;
FIELD_BITSIZE (newobj->field) = 0; /* This should be an unpacked
*varargsp = 0;
}
- rval = (struct field *) xmalloc (n * sizeof (struct field));
- memset (rval, 0, n * sizeof (struct field));
+ rval = XCNEWVEC (struct field, n);
for (i = 0; i < n; i++)
rval[i].type = types[i];
*nargsp = n;
undef_types_allocated = 20;
undef_types_length = 0;
- undef_types = (struct type **)
- xmalloc (undef_types_allocated * sizeof (struct type *));
+ undef_types = XNEWVEC (struct type *, undef_types_allocated);
noname_undefs_allocated = 20;
noname_undefs_length = 0;
- noname_undefs = (struct nat *)
- xmalloc (noname_undefs_allocated * sizeof (struct nat));
+ noname_undefs = XNEWVEC (struct nat, noname_undefs_allocated);
stab_register_index = register_symbol_register_impl (LOC_REGISTER,
&stab_register_funcs);
frame = parse_frame_specification ("0");
sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
cleanups = make_cleanup (xfree, sals.sals);
- func_bounds = (struct function_bounds *) xmalloc (
- sizeof (struct function_bounds) * sals.nelts);
+ func_bounds = XNEWVEC (struct function_bounds, sals.nelts);
make_cleanup (xfree, func_bounds);
for (i = 0; (i < sals.nelts && !found); i++)
{
const char *probe_args = NULL;
struct stap_probe *ret;
- ret = obstack_alloc (&objfile->per_bfd->storage_obstack, sizeof (*ret));
+ ret = XOBNEW (&objfile->per_bfd->storage_obstack, struct stap_probe);
ret->p.pops = &stap_probe_ops;
ret->p.arch = gdbarch;
int i;
/* `+ 1' for the NULL terminator. */
- array = xmalloc (sizeof (*array) * (addrs->num_sections + 1));
+ array = XNEWVEC (struct other_sections *, addrs->num_sections + 1);
for (i = 0; i < addrs->num_sections; i++)
array[i] = &addrs->other[i];
array[i] = NULL;
/* Now create ADDRS_TO_ABFD_ADDRS from ADDRS_SORTED and
ABFD_ADDRS_SORTED. */
- addrs_to_abfd_addrs = xzalloc (sizeof (*addrs_to_abfd_addrs)
- * addrs->num_sections);
+ addrs_to_abfd_addrs = XCNEWVEC (struct other_sections *, addrs->num_sections);
make_cleanup (xfree, addrs_to_abfd_addrs);
while (*addrs_sorted)
new_request = VEC_safe_push (memory_write_request_s,
args->requests, NULL);
memset (new_request, 0, sizeof (struct memory_write_request));
- section_data = xcalloc (1, sizeof (struct load_progress_section_data));
+ section_data = XCNEW (struct load_progress_section_data);
new_request->begin = bfd_section_lma (abfd, asec) + args->load_offset;
new_request->end = new_request->begin + size; /* FIXME Should size
be in instead? */
struct cleanup *my_cleanups = make_cleanup (null_cleanup, NULL);
num_sect_opts = 16;
- sect_opts = (struct sect_opt *) xmalloc (num_sect_opts
- * sizeof (struct sect_opt));
+ sect_opts = XNEWVEC (struct sect_opt, num_sect_opts);
dont_repeat ();
{
fl_table_size = 20;
fl_table_next = 0;
- filename_language_table =
- xmalloc (fl_table_size * sizeof (*filename_language_table));
+ filename_language_table = XNEWVEC (filename_language, fl_table_size);
+
add_filename_language (".c", language_c);
add_filename_language (".d", language_d);
add_filename_language (".C", language_cplus);
static struct filename_seen_cache *
create_filename_seen_cache (void)
{
- struct filename_seen_cache *cache;
+ struct filename_seen_cache *cache = XNEW (struct filename_seen_cache);
- cache = XNEW (struct filename_seen_cache);
cache->tab = htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE,
filename_hash, filename_eq,
NULL, xcalloc, xfree);
gdb_assert (found != NULL && nfound > 0);
/* Build an array out of the list so we can easily sort them. */
- symbols = (struct symbol_search **) xmalloc (sizeof (struct symbol_search *)
- * nfound);
+ symbols = XNEWVEC (struct symbol_search *, nfound);
+
symp = found;
for (i = 0; i < nfound; i++)
{
&& SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
{
/* match */
- struct symbol_search *psr = (struct symbol_search *)
- xmalloc (sizeof (struct symbol_search));
+ struct symbol_search *psr = XCNEW (struct symbol_search);
+
psr->block = i;
psr->symbol = sym;
- memset (&psr->msymbol, 0, sizeof (psr->msymbol));
psr->next = NULL;
if (tail == NULL)
found = psr;
.symbol == NULL)
{
/* match */
- struct symbol_search *psr = (struct symbol_search *)
- xmalloc (sizeof (struct symbol_search));
+ struct symbol_search *psr = XNEW (struct symbol_search);
psr->block = i;
psr->msymbol.minsym = msymbol;
psr->msymbol.objfile = objfile;
struct cleanup *
make_cleanup_restore_target_terminal (void)
{
- enum terminal_state *ts = xmalloc (sizeof (*ts));
+ enum terminal_state *ts = XNEW (enum terminal_state);
*ts = terminal_state;
static struct thread_info *
new_thread (ptid_t ptid)
{
- struct thread_info *tp;
-
- tp = xcalloc (1, sizeof (*tp));
+ struct thread_info *tp = XCNEW (struct thread_info);
tp->ptid = ptid;
tp->num = ++highest_thread_num;
tp->stack_temporaries_enabled = 1;
tp->stack_temporaries = NULL;
- data = (ptid_t *) xmalloc (sizeof (ptid_t));
+ data = XNEW (ptid_t);
*data = ptid;
c = make_cleanup (disable_thread_stack_temporaries, data);
{
struct thread_info *tp;
struct frame_info *frame;
- struct current_thread_cleanup *old;
+ struct current_thread_cleanup *old = XNEW (struct current_thread_cleanup);
- old = xmalloc (sizeof (struct current_thread_cleanup));
old->inferior_ptid = inferior_ptid;
old->inf_id = current_inferior ()->num;
old->was_removable = current_inferior ()->removable;
/* Save a copy of the thread_list in case we execute detach
command. */
- tp_array = xmalloc (sizeof (struct thread_info *) * tc);
+ tp_array = XNEWVEC (struct thread_info *, tc);
make_cleanup (xfree, tp_array);
ALL_NON_EXITED_THREADS (tp)
return arches->gdbarch;
}
- tdep = xcalloc (1, sizeof (struct gdbarch_tdep));
+ tdep = XCNEW (struct gdbarch_tdep);
tdep->has_gp = has_gp;
gdbarch = gdbarch_alloc (&info, tdep);
struct gdb_readline_wrapper_cleanup *cleanup;
char *retval;
- cleanup = xmalloc (sizeof (*cleanup));
+ cleanup = XNEW (struct gdb_readline_wrapper_cleanup);
cleanup->handler_orig = input_handler;
input_handler = gdb_readline_wrapper_line;
tfile_trace_file_writer_new (void)
{
struct tfile_trace_file_writer *writer
- = xmalloc (sizeof (struct tfile_trace_file_writer));
+ = XNEW (struct tfile_trace_file_writer);
writer->base.ops = &tfile_write_ops;
writer->fp = NULL;
{
sal = find_pc_line (get_frame_pc (get_current_frame ()), 0);
sals.nelts = 1;
- sals.sals = (struct symtab_and_line *)
- xmalloc (sizeof (struct symtab_and_line));
+ sals.sals = XNEW (struct symtab_and_line);
sals.sals[0] = sal;
}
else
make_cleanup (xfree, default_collect_line);
validate_actionline (default_collect_line, t);
- default_collect_action = xmalloc (sizeof (struct command_line));
+ default_collect_action = XNEW (struct command_line);
make_cleanup (xfree, default_collect_action);
default_collect_action->next = actions;
default_collect_action->line = default_collect_line;
struct cleanup *
make_cleanup_restore_current_traceframe (void)
{
- struct current_traceframe_cleanup *old;
+ struct current_traceframe_cleanup *old =
+ XNEW (struct current_traceframe_cleanup);
- old = xmalloc (sizeof (struct current_traceframe_cleanup));
old->traceframe_number = traceframe_number;
return make_cleanup_dtor (do_restore_current_traceframe_cleanup, old,
for (utp = *utpp; utp; utp = utp->next)
if (utp->number == num && utp->addr == addr)
return utp;
- utp = (struct uploaded_tp *) xmalloc (sizeof (struct uploaded_tp));
- memset (utp, 0, sizeof (struct uploaded_tp));
+
+ utp = XCNEW (struct uploaded_tp);
utp->number = num;
utp->addr = addr;
utp->actions = NULL;
utp->cmd_strings = NULL;
utp->next = *utpp;
*utpp = utp;
+
return utp;
}
for (utsv = *utsvp; utsv; utsv = utsv->next)
if (utsv->number == num)
return utsv;
- utsv = (struct uploaded_tsv *) xmalloc (sizeof (struct uploaded_tsv));
- memset (utsv, 0, sizeof (struct uploaded_tsv));
+
+ utsv = XCNEW (struct uploaded_tsv);
utsv->number = num;
utsv->next = *utsvp;
*utsvp = utsv;
+
return utsv;
}
struct tui_gen_win_info *
tui_alloc_generic_win_info (void)
{
- struct tui_gen_win_info *win;
+ struct tui_gen_win_info *win = XNEW (struct tui_gen_win_info);
- if ((win = XNEW (struct tui_gen_win_info)) != NULL)
+ if (win != NULL)
tui_init_generic_part (win);
return win;
struct tui_win_info *
tui_alloc_win_info (enum tui_win_type type)
{
- struct tui_win_info *win_info;
+ struct tui_win_info *win_info = XNEW (struct tui_win_info);
- win_info = XNEW (struct tui_win_info);
if (win_info != NULL)
{
win_info->generic.type = type;
char *element_block_ptr;
int i;
- content = xmalloc (sizeof (struct tui_win_element *) *num_elements);
+ content = XNEWVEC (struct tui_win_element *, num_elements);
if (content != NULL)
{
/*
{
for (i = index_start; (i < num_elements + index_start); i++)
{
- if ((element_ptr = XNEW (struct tui_win_element)) != NULL)
+ element_ptr = XNEW (struct tui_win_element);
+ if (element_ptr != NULL)
{
win_info->content[i] = (void *) element_ptr;
init_content_element (element_ptr, win_info->type);
if (max_lines <= 1)
return pc;
- asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * max_lines);
+ asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines);
memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
new_low = pc;
hilite. */
/* Get temporary table that will hold all strings (addr & insn). */
- asm_lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
- * max_lines);
+ asm_lines = XALLOCAVEC (struct tui_asm_line, max_lines);
memset (asm_lines, 0, sizeof (struct tui_asm_line) * max_lines);
tui_disassemble (gdbarch, asm_lines, pc, max_lines);
struct ui_file *
ui_file_new (void)
{
- struct ui_file *file = xmalloc (sizeof (struct ui_file));
+ struct ui_file *file = XNEW (struct ui_file);
file->magic = &ui_file_magic;
set_ui_file_data (file, NULL, null_file_delete);
stdio_file_new (FILE *file, int close_p)
{
struct ui_file *ui_file = ui_file_new ();
- struct stdio_file *stdio = xmalloc (sizeof (struct stdio_file));
+ struct stdio_file *stdio = XNEW (struct stdio_file);
stdio->magic = &stdio_file_magic;
stdio->file = file;
struct ui_file *two, int close_two)
{
struct ui_file *ui_file = ui_file_new ();
- struct tee_file *tee = xmalloc (sizeof (struct tee_file));
+ struct tee_file *tee = XNEW (struct tee_file);
tee->magic = &tee_file_magic;
tee->one = one;
struct cleanup *
make_cleanup_restore_integer (int *variable)
{
- struct restore_integer_closure *c =
- xmalloc (sizeof (struct restore_integer_closure));
+ struct restore_integer_closure *c = XNEW (struct restore_integer_closure);
c->variable = variable;
c->value = *variable;
char *set_doc;
char *show_doc;
- set_cmd_list = xmalloc (sizeof (*set_cmd_list));
- show_cmd_list = xmalloc (sizeof (*set_cmd_list));
+ set_cmd_list = XNEW (struct cmd_list_element *);
+ show_cmd_list = XNEW (struct cmd_list_element *);
*set_cmd_list = NULL;
*show_cmd_list = NULL;
return arches->gdbarch;
}
- tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
+ tdep = XNEW (struct gdbarch_tdep);
tdep->e_flags = e_flags;
tdep->e_machine = e_machine;
else
nparms = TYPE_NFIELDS (SYMBOL_TYPE (oload_syms[ix]));
- parm_types = (struct type **)
- xmalloc (nparms * (sizeof (struct type *)));
+ parm_types = XNEWVEC (struct type *, nparms);
for (jj = 0; jj < nparms; jj++)
parm_types[jj] = (fns_ptr != NULL
? (TYPE_FN_FIELD_ARGS (fns_ptr, ix)[jj].type)
description correctly. */
check_typedef (type);
- val = (struct value *) xzalloc (sizeof (struct value));
+ val = XCNEW (struct value);
val->contents = NULL;
val->next = all_values;
all_values = val;
i = value_history_count % VALUE_HISTORY_CHUNK;
if (i == 0)
{
- struct value_history_chunk *newobj
- = (struct value_history_chunk *)
+ struct value_history_chunk *newobj = XCNEW (struct value_history_chunk);
- xmalloc (sizeof (struct value_history_chunk));
- memset (newobj->values, 0, sizeof newobj->values);
newobj->next = value_history_chain;
value_history_chain = newobj;
}
struct internalvar *
create_internalvar (const char *name)
{
- struct internalvar *var;
+ struct internalvar *var = XNEW (struct internalvar);
- var = (struct internalvar *) xmalloc (sizeof (struct internalvar));
var->name = concat (name, (char *)NULL);
var->kind = INTERNALVAR_VOID;
var->next = internalvars;
error (_("Duplicate variable object name"));
/* Add varobj to hash table. */
- newvl = xmalloc (sizeof (struct vlist));
+ newvl = XNEW (struct vlist);
newvl->next = *(varobj_table + index);
newvl->var = var;
*(varobj_table + index) = newvl;
{
struct varobj *var;
- var = (struct varobj *) xmalloc (sizeof (struct varobj));
+ var = XNEW (struct varobj);
var->name = NULL;
var->path_expr = NULL;
var->obj_name = NULL;
var->print_value = NULL;
var->frozen = 0;
var->not_fetched = 0;
- var->dynamic
- = (struct varobj_dynamic *) xmalloc (sizeof (struct varobj_dynamic));
+ var->dynamic = XNEW (struct varobj_dynamic);
var->dynamic->children_requested = 0;
var->from = -1;
var->to = -1;
{
struct varobj *var = new_variable ();
- var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
+ var->root = XNEW (struct varobj_root);
var->root->lang_ops = NULL;
var->root->exp = NULL;
var->root->valid_block = NULL;
{
struct cpstack *s;
- s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
+ s = XNEW (struct cpstack);
s->name = name;
s->next = *pstack;
*pstack = s;
void
_initialize_varobj (void)
{
- int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
-
- varobj_table = xmalloc (sizeof_table);
- memset (varobj_table, 0, sizeof_table);
+ varobj_table = XCNEWVEC (struct vlist *, VAROBJ_TABLE_SIZE);
add_setshow_zuinteger_cmd ("varobj", class_maintenance,
&varobjdebug,
}
#endif
so = XCNEW (struct so_list);
- so->lm_info = (struct lm_info *) xmalloc (sizeof (struct lm_info));
+ so->lm_info = XNEW (struct lm_info);
so->lm_info->load_addr = load_addr;
strcpy (so->so_original_name, name);
#ifndef __CYGWIN__
static struct x86_process_info *
x86_add_process (pid_t pid)
{
- struct x86_process_info *proc;
+ struct x86_process_info *proc = XCNEW (struct x86_process_info);
- proc = xcalloc (1, sizeof (*proc));
proc->pid = pid;
-
proc->next = x86_process_list;
x86_process_list = proc;
#define NUM_OF_FUNCTIONS 20
fentry_size = NUM_OF_FUNCTIONS;
- fentry = (struct linetable_entry *)
- xmalloc (fentry_size * sizeof (struct linetable_entry));
+ fentry = XNEWVEC (struct linetable_entry, fentry_size);
for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
{
{
if (inclTable == NULL)
{
- inclTable = (InclTable *)
- xmalloc (sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
- memset (inclTable,
- '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
+ inclTable = XCNEWVEC (InclTable, INITIAL_INCLUDE_TABLE_LENGTH);
inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
inclIndx = 0;
}
else if (inclIndx >= inclLength)
{
inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
- inclTable = (InclTable *)
- xrealloc (inclTable, sizeof (InclTable) * inclLength);
+ inclTable = XRESIZEVEC (InclTable, inclTable, inclLength);
memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
'\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
}
{
/* Have a new subfile for the include file. */
- tmpSubfile = inclTable[ii].subfile =
- (struct subfile *) xmalloc (sizeof (struct subfile));
+ tmpSubfile = inclTable[ii].subfile = XNEW (struct subfile);
memset (tmpSubfile, '\0', sizeof (struct subfile));
firstLine = &(inclTable[ii].funStartLine);
}
#define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
- (SYMBOL2) = (struct symbol *) \
- obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); \
+ (SYMBOL2) = XOBNEW (&objfile->objfile_obstack, struct symbol); \
*(SYMBOL2) = *(SYMBOL1);
0,
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);
((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
result->read_symtab = xcoff_read_symtab;
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 *));
}
/* 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;
gdb_xml_error (parser, _("Can't convert %s=\"%s\" to an integer"),
attribute->name, value);
- ret = xmalloc (sizeof (result));
+ ret = XNEW (ULONGEST);
memcpy (ret, &result, sizeof (result));
return ret;
}
if (tp == NULL)
{
char *name = xstrprintf ("int%d", size * 8);
- tp = xmalloc (sizeof (struct ctype_cache));
+
+ tp = XNEW (struct ctype_cache);
tp->next = tdep->type_entries;
tdep->type_entries = tp;
tp->size = size;
projects / thirdparty / binutils-gdb.git / commitdiff
