FreeChainXenon/binutils-gdb
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

replace XCALLOC with XCNEWVEC or XCNEW

Browse source 
This removes XCALLOC and replaces it either with XCNEWVEC, or, if the
number of elements being requested was 1, with XCNEW.

2014-01-13  Tom Tromey  <tromey@redhat.com>

	* defs.h (XCALLOC): Remove.
	* bcache.c (bcache_xmalloc): Use XCNEW, not XCALLOC.
	(print_bcache_statistics): Use XCNEWVEC, not XCALLOC.
	* dwarf2loc.c (allocate_piece_closure): Likewise.
	* elfread.c (elf_symfile_segments): Likewise.
	(elf_symfile_segments): Likewise.
	* gdbtypes.c (copy_type_recursive): Likewise.
	* i386-tdep.c (i386_gdbarch_init): Use XCNEW, not XCALLOC.
	* jit.c (jit_frame_sniffer): Use XCNEWVEC, not XCALLOC.
	* minsyms.c (prim_record_minimal_symbol_full): Use XCNEW, not
	XCALLOC.
	* mt-tdep.c (mt_gdbarch_init): Likewise.
	* opencl-lang.c (allocate_lval_closure): Use XCNEWVEC, not
	XCALLOC.
	* psymtab.c (psymbol_compare): Use XCNEW, not XCALLOC.
	* regcache.c (regcache_xmalloc_1): Use XCNEWVEC, not XCALLOC.
	* registry.c (registry_alloc_data): Likewise.
	* rs6000-tdep.c (rs6000_gdbarch_init): Use XCNEW, not XCALLOC.
	* s390-linux-tdep.c (s390_gdbarch_init): Likewise.
	* serial.c (serial_fdopen_ops): Likewise.
	* solib-aix.c (solib_aix_get_section_offsets): Use XCNEWVEC, not
	XCALLOC.
	* spu-tdep.c (spu_gdbarch_init): Use XCNEW, not XCALLOC.
	* symfile.c (default_symfile_segments): Use XCNEW and XCNEWVEC,
	not XCALLOC.
This commit is contained in:
Tom Tromey 2013-12-28 15:32:27 -07:00
parent 70ba0933ad
commit fc270c357a
20 changed files with 56 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

28
gdb/ChangeLog
View file

@ -1,3 +1,31 @@
2014-01-13 Tom Tromey <tromey@redhat.com>
* defs.h (XCALLOC): Remove.
* bcache.c (bcache_xmalloc): Use XCNEW, not XCALLOC.
(print_bcache_statistics): Use XCNEWVEC, not XCALLOC.
* dwarf2loc.c (allocate_piece_closure): Likewise.
* elfread.c (elf_symfile_segments): Likewise.
(elf_symfile_segments): Likewise.
* gdbtypes.c (copy_type_recursive): Likewise.
* i386-tdep.c (i386_gdbarch_init): Use XCNEW, not XCALLOC.
* jit.c (jit_frame_sniffer): Use XCNEWVEC, not XCALLOC.
* minsyms.c (prim_record_minimal_symbol_full): Use XCNEW, not
XCALLOC.
* mt-tdep.c (mt_gdbarch_init): Likewise.
* opencl-lang.c (allocate_lval_closure): Use XCNEWVEC, not
XCALLOC.
* psymtab.c (psymbol_compare): Use XCNEW, not XCALLOC.
* regcache.c (regcache_xmalloc_1): Use XCNEWVEC, not XCALLOC.
* registry.c (registry_alloc_data): Likewise.
* rs6000-tdep.c (rs6000_gdbarch_init): Use XCNEW, not XCALLOC.
* s390-linux-tdep.c (s390_gdbarch_init): Likewise.
* serial.c (serial_fdopen_ops): Likewise.
* solib-aix.c (solib_aix_get_section_offsets): Use XCNEWVEC, not
XCALLOC.
* spu-tdep.c (spu_gdbarch_init): Use XCNEW, not XCALLOC.
* symfile.c (default_symfile_segments): Use XCNEW and XCNEWVEC,
not XCALLOC.
2014-01-13 Tom Tromey <tromey@redhat.com> 2014-01-13 Tom Tromey <tromey@redhat.com>
* defs.h (XMALLOC): Remove. * defs.h (XMALLOC): Remove.

6
gdb/bcache.c
View file

@ -313,7 +313,7 @@ bcache_xmalloc (unsigned long (*hash_function)(const void *, int length),
int length)) int length))
{ {
/* Allocate the bcache pre-zeroed. */ /* Allocate the bcache pre-zeroed. */
struct bcache *b = XCALLOC (1, struct bcache); struct bcache *b = XCNEW (struct bcache);
if (hash_function) if (hash_function)
b->hash_function = hash_function; b->hash_function = hash_function;
@ -372,8 +372,8 @@ print_bcache_statistics (struct bcache *c, char *type)
lengths, and measure chain lengths. */ lengths, and measure chain lengths. */
{ {
unsigned int b; unsigned int b;
int *chain_length = XCALLOC (c->num_buckets + 1, int); int *chain_length = XCNEWVEC (int, c->num_buckets + 1);
int *entry_size = XCALLOC (c->unique_count + 1, int); int *entry_size = XCNEWVEC (int, c->unique_count + 1);
int stringi = 0; int stringi = 0;
occupied_buckets = 0; occupied_buckets = 0;

5
gdb/defs.h
View file

@ -553,11 +553,6 @@ enum val_prettyformat
extern int longest_to_int (LONGEST); extern int longest_to_int (LONGEST);
/* Utility macros to allocate typed memory. Avoids errors like:
struct foo *foo = xmalloc (sizeof struct bar); and memset (foo,
sizeof (struct foo), 0). */
#define XCALLOC(NMEMB, TYPE) ((TYPE*) xcalloc ((NMEMB), sizeof (TYPE)))
#include "common-utils.h" #include "common-utils.h"
/* List of known OS ABIs. If you change this, make sure to update the /* List of known OS ABIs. If you change this, make sure to update the

2
gdb/dwarf2loc.c
View file

@ -1421,7 +1421,7 @@ allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
c->per_cu = per_cu; c->per_cu = per_cu;
c->n_pieces = n_pieces; c->n_pieces = n_pieces;
c->addr_size = addr_size; c->addr_size = addr_size;
c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece); c->pieces = XCNEWVEC (struct dwarf_expr_piece, n_pieces);
memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece)); memcpy (c->pieces, pieces, n_pieces * sizeof (struct dwarf_expr_piece));
for (i = 0; i < n_pieces; ++i) for (i = 0; i < n_pieces; ++i)

6
gdb/elfread.c
View file

@ -107,8 +107,8 @@ elf_symfile_segments (bfd *abfd)
data = XCNEW (struct symfile_segment_data); data = XCNEW (struct symfile_segment_data);
data->num_segments = num_segments; data->num_segments = num_segments;
data->segment_bases = XCALLOC (num_segments, CORE_ADDR); data->segment_bases = XCNEWVEC (CORE_ADDR, num_segments);
data->segment_sizes = XCALLOC (num_segments, CORE_ADDR); data->segment_sizes = XCNEWVEC (CORE_ADDR, num_segments);
for (i = 0; i < num_segments; i++) for (i = 0; i < num_segments; i++)
{ {
@ -117,7 +117,7 @@ elf_symfile_segments (bfd *abfd)
} }
num_sections = bfd_count_sections (abfd); num_sections = bfd_count_sections (abfd);
data->segment_info = XCALLOC (num_sections, int); data->segment_info = XCNEWVEC (int, num_sections);
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
{ {

2
gdb/gdbtypes.c
View file

@ -3700,7 +3700,7 @@ copy_type_recursive (struct objfile *objfile,
int i, nfields; int i, nfields;
nfields = TYPE_NFIELDS (type); nfields = TYPE_NFIELDS (type);
TYPE_FIELDS (new_type) = XCALLOC (nfields, struct field); TYPE_FIELDS (new_type) = XCNEWVEC (struct field, nfields);
for (i = 0; i < nfields; i++) for (i = 0; i < nfields; i++)
{ {
TYPE_FIELD_ARTIFICIAL (new_type, i) = TYPE_FIELD_ARTIFICIAL (new_type, i) =

2
gdb/i386-tdep.c
View file

@ -7819,7 +7819,7 @@ i386_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
return arches->gdbarch; return arches->gdbarch;
/* Allocate space for the new architecture. */ /* Allocate space for the new architecture. */
tdep = XCALLOC (1, struct gdbarch_tdep); tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep); gdbarch = gdbarch_alloc (&info, tdep);
/* General-purpose registers. */ /* General-purpose registers. */

4
gdb/jit.c
View file

@ -1184,8 +1184,8 @@ jit_frame_sniffer (const struct frame_unwind *self,
*cache = XCNEW (struct jit_unwind_private); *cache = XCNEW (struct jit_unwind_private);
priv_data = *cache; priv_data = *cache;
priv_data->registers = priv_data->registers =
XCALLOC (gdbarch_num_regs (get_frame_arch (this_frame)), XCNEWVEC (struct gdb_reg_value *,
struct gdb_reg_value *); gdbarch_num_regs (get_frame_arch (this_frame)));
priv_data->this_frame = this_frame; priv_data->this_frame = this_frame;
callbacks.priv_data = priv_data; callbacks.priv_data = priv_data;

2
gdb/minsyms.c
View file

@ -935,7 +935,7 @@ prim_record_minimal_symbol_full (const char *name, int name_len, int copy_name,
if (msym_bunch_index == BUNCH_SIZE) if (msym_bunch_index == BUNCH_SIZE)
{ {
new = XCALLOC (1, struct msym_bunch); new = XCNEW (struct msym_bunch);
msym_bunch_index = 0; msym_bunch_index = 0;
new->next = msym_bunch; new->next = msym_bunch;
msym_bunch = new; msym_bunch = new;

2
gdb/mt-tdep.c
View file

@ -1149,7 +1149,7 @@ mt_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
/* None found, create a new architecture from the information /* None found, create a new architecture from the information
provided. */ provided. */
tdep = XCALLOC (1, struct gdbarch_tdep); tdep = XCNEW (struct gdbarch_tdep);
gdbarch = gdbarch_alloc (&info, tdep); gdbarch = gdbarch_alloc (&info, tdep);
set_gdbarch_float_format (gdbarch, floatformats_ieee_single); set_gdbarch_float_format (gdbarch, floatformats_ieee_single);

2
gdb/opencl-lang.c
View file

@ -160,7 +160,7 @@ allocate_lval_closure (int *indices, int n, struct value *val)
c->refc = 1; c->refc = 1;
c->n = n; c->n = n;
c->indices = XCALLOC (n, int); c->indices = XCNEWVEC (int, n);
memcpy (c->indices, indices, n * sizeof (int)); memcpy (c->indices, indices, n * sizeof (int));
value_incref (val); /* Increment the reference counter of the value. */ value_incref (val); /* Increment the reference counter of the value. */
c->val = val; c->val = val;

2
gdb/psymtab.c
View file

@ -1530,7 +1530,7 @@ psymbol_compare (const void *addr1, const void *addr2, int length)
struct psymbol_bcache * struct psymbol_bcache *
psymbol_bcache_init (void) psymbol_bcache_init (void)
{ {
struct psymbol_bcache *bcache = XCALLOC (1, struct psymbol_bcache); struct psymbol_bcache *bcache = XCNEW (struct psymbol_bcache);
bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare); bcache->bcache = bcache_xmalloc (psymbol_hash, psymbol_compare);
return bcache; return bcache;
} }

8
gdb/regcache.c
View file

@ -223,16 +223,16 @@ regcache_xmalloc_1 (struct gdbarch *gdbarch, struct address_space *aspace,
if (readonly_p) if (readonly_p)
{ {
regcache->registers regcache->registers
= XCALLOC (descr->sizeof_cooked_registers, gdb_byte); = XCNEWVEC (gdb_byte, descr->sizeof_cooked_registers);
regcache->register_status regcache->register_status
= XCALLOC (descr->sizeof_cooked_register_status, signed char); = XCNEWVEC (signed char, descr->sizeof_cooked_register_status);
} }
else else
{ {
regcache->registers regcache->registers
= XCALLOC (descr->sizeof_raw_registers, gdb_byte); = XCNEWVEC (gdb_byte, descr->sizeof_raw_registers);
regcache->register_status regcache->register_status
= XCALLOC (descr->sizeof_raw_register_status, signed char); = XCNEWVEC (signed char, descr->sizeof_raw_register_status);
} }
regcache->aspace = aspace; regcache->aspace = aspace;
regcache->ptid = minus_one_ptid; regcache->ptid = minus_one_ptid;

2
gdb/registry.c
View file

@ -51,7 +51,7 @@ registry_alloc_data (struct registry_data_registry *registry,
{ {
gdb_assert (fields->data == NULL); gdb_assert (fields->data == NULL);
fields->num_data = registry->num_registrations; fields->num_data = registry->num_registrations;
fields->data = XCALLOC (fields->num_data, void *); fields->data = XCNEWVEC (void *, fields->num_data);
} }
void void

2
gdb/rs6000-tdep.c
View file

@ -3954,7 +3954,7 @@ rs6000_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
- "set arch" trust blindly - "set arch" trust blindly
- GDB startup useless but harmless */ - GDB startup useless but harmless */
tdep = XCALLOC (1, struct gdbarch_tdep); tdep = XCNEW (struct gdbarch_tdep);
tdep->wordsize = wordsize; tdep->wordsize = wordsize;
tdep->soft_float = soft_float; tdep->soft_float = soft_float;
tdep->vector_abi = vector_abi; tdep->vector_abi = vector_abi;

2
gdb/s390-linux-tdep.c
View file

@ -3196,7 +3196,7 @@ s390_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
} }
/* Otherwise create a new gdbarch for the specified machine type. */ /* Otherwise create a new gdbarch for the specified machine type. */
tdep = XCALLOC (1, struct gdbarch_tdep); tdep = XCNEW (struct gdbarch_tdep);
tdep->abi = tdep_abi; tdep->abi = tdep_abi;
gdbarch = gdbarch_alloc (&info, tdep); gdbarch = gdbarch_alloc (&info, tdep);

2
gdb/serial.c
View file

@ -263,7 +263,7 @@ serial_fdopen_ops (const int fd, const struct serial_ops *ops)
if (!ops) if (!ops)
return NULL; return NULL;
scb = XCALLOC (1, struct serial); scb = XCNEW (struct serial);
scb->ops = ops; scb->ops = ops;

2
gdb/solib-aix.c
View file

@ -470,7 +470,7 @@ solib_aix_get_section_offsets (struct objfile *objfile,
bfd *abfd = objfile->obfd; bfd *abfd = objfile->obfd;
int i; int i;
offsets = XCALLOC (objfile->num_sections, struct section_offsets); offsets = XCNEWVEC (struct section_offsets, objfile->num_sections);
/* .text */ /* .text */

2
gdb/spu-tdep.c
View file

@ -2658,7 +2658,7 @@ spu_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
} }
/* None found, so create a new architecture. */ /* None found, so create a new architecture. */
tdep = XCALLOC (1, struct gdbarch_tdep); tdep = XCNEW (struct gdbarch_tdep);
tdep->id = id; tdep->id = id;
gdbarch = gdbarch_alloc (&info, tdep); gdbarch = gdbarch_alloc (&info, tdep);

6
gdb/symfile.c
View file

@ -801,11 +801,11 @@ default_symfile_segments (bfd *abfd)
data = XCNEW (struct symfile_segment_data); data = XCNEW (struct symfile_segment_data);
data->num_segments = 1; data->num_segments = 1;
data->segment_bases = XCALLOC (1, CORE_ADDR); data->segment_bases = XCNEW (CORE_ADDR);
data->segment_sizes = XCALLOC (1, CORE_ADDR); data->segment_sizes = XCNEW (CORE_ADDR);
num_sections = bfd_count_sections (abfd); num_sections = bfd_count_sections (abfd);
data->segment_info = XCALLOC (num_sections, int); data->segment_info = XCNEWVEC (int, num_sections);
for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next) for (i = 0, sect = abfd->sections; sect != NULL; i++, sect = sect->next)
{ {