+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * debuginfod-client.c (debuginfod_begin): Remove cast of calloc return
+ value.
+
2021-08-28 Mark Wielaard <mjw@redhat.com>
* debuginfod.cxx (parse_opt): Turn the -d arg ":memory:" into
{
debuginfod_client *client;
size_t size = sizeof (struct debuginfod_client);
- client = (debuginfod_client *) calloc (1, size);
+ client = calloc (1, size);
if (client != NULL)
{
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * dynamicsizehash.c (INIT(NAME)): Remove cast of calloc return value.
+ * dynamicsizehash_concurrent.c (INIT(NAME)): Remove cast of malloc
+ return value.
+
2021-08-23 Saleem Abdulrasool <abdulras@google.com>
* system.h: Remove inline definition for error and error_message_count
#ifdef ITERATE
htab->first = NULL;
#endif
- htab->table = (void *) calloc ((init_size + 1), sizeof (htab->table[0]));
+ htab->table = calloc ((init_size + 1), sizeof (htab->table[0]));
if (htab->table == NULL)
return -1;
pthread_rwlock_init(&htab->resize_rwl, NULL);
- htab->table = (void *) malloc ((init_size + 1) * sizeof (htab->table[0]));
+ htab->table = malloc ((init_size + 1) * sizeof (htab->table[0]));
if (htab->table == NULL)
return -1;
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * asm_align.c (__libasm_ensure_section_space): Remove casts of calloc
+ return values.
+ * asm_begin.c (asm_begin): Remove cast of malloc return value.
+ * asm_fill.c (asm_fill): Likewise.
+ * asm_newabssym.c (asm_newabssym): Likewise.
+ * asm_newcomsym.c (asm_newcomsym): Likewise.
+ * asm_newscn.c (asm_newscn): Likewise.
+ * asm_newscngrp.c (asm_newscngrp): Likewise.
+ * asm_newsubscn.c (asm_newsubscn): Likewise.
+ * asm_newsym.c (asm_newsym): Likewise.
+ * disasm_begin.c (disasm_begin): Likewise.
+
2021-04-19 Martin Liska <mliska@suse.cz>
* libasmP.h (asm_emit_symbol_p): Use startswith.
/* This is the first block. */
size = MAX (2 * len, 960);
- asmscn->content = (struct AsmData *) calloc (1, sizeof (struct AsmData)
- + size);
+ asmscn->content = calloc (1, sizeof (struct AsmData) + size);
if (asmscn->content == NULL)
return -1;
size = MAX (2 *len, MIN (32768, 2 * asmscn->offset));
- newp = (struct AsmData *) calloc (1, sizeof (struct AsmData) + size);
+ newp = calloc (1, sizeof (struct AsmData) + size);
if (newp == NULL)
return -1;
right away. Instead we create a temporary file in the same
directory which, if everything goes alright, will replace a
possibly existing file with the given name. */
- AsmCtx_t *result
- = (AsmCtx_t *) malloc (sizeof (AsmCtx_t) + 2 * fname_len + 9);
+ AsmCtx_t *result = malloc (sizeof (AsmCtx_t) + 2 * fname_len + 9);
if (result == NULL)
return NULL;
else
{
/* Allocate appropriate memory. */
- pattern = (struct FillPattern *) malloc (sizeof (struct FillPattern)
- + len);
+ pattern = malloc (sizeof (struct FillPattern) + len);
if (pattern == NULL)
return -1;
rwlock_wrlock (ctx->lock);
- result = (AsmSym_t *) malloc (sizeof (AsmSym_t));
+ result = malloc (sizeof (AsmSym_t));
if (result == NULL)
return NULL;
rwlock_wrlock (ctx->lock);
- result = (AsmSym_t *) malloc (sizeof (AsmSym_t));
+ result = malloc (sizeof (AsmSym_t));
if (result == NULL)
return NULL;
rwlock_wrlock (ctx->lock);
/* This is a new section. */
- result = (AsmScn_t *) malloc (sizeof (AsmScn_t) + scnname_len);
+ result = malloc (sizeof (AsmScn_t) + scnname_len);
if (result != NULL)
{
/* Add the name. */
return NULL;
}
- result = (AsmScnGrp_t *) malloc (sizeof (AsmScnGrp_t) + grpname_len);
+ result = malloc (sizeof (AsmScnGrp_t) + grpname_len);
if (result == NULL)
return NULL;
runp = runp->subnext;
}
- newp = (AsmScn_t *) malloc (sizeof (AsmScn_t));
+ newp = malloc (sizeof (AsmScn_t));
if (newp == NULL)
return NULL;
size_t name_len = strlen (name) + 1;
- result = (AsmSym_t *) malloc (sizeof (AsmSym_t) + name_len);
+ result = malloc (sizeof (AsmSym_t) + name_len);
if (result == NULL)
return NULL;
return NULL;
}
- DisasmCtx_t *ctx = (DisasmCtx_t *) malloc (sizeof (DisasmCtx_t));
+ DisasmCtx_t *ctx = malloc (sizeof (DisasmCtx_t));
if (ctx == NULL)
{
__libasm_seterrno (ASM_E_NOMEM);
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * dwarf_begin_elf.c (valid_p): Remove casts of malloc return values.
+ (dwarf_begin_elf): Remove cast of calloc return value.
+ * dwarf_getpubnames.c (get_offsets): Remove casts of realloc return
+ values.
+ * dwarf_getsrclines.c (read_srclines): Remove cast of malloc return
+ value.
+
2021-04-19 Martin Liska <mliska@suse.cz>
* dwarf_begin_elf.c (check_section): Use startswith.
inside the .debug_loc or .debug_loclists section. */
if (result != NULL && result->sectiondata[IDX_debug_loc] != NULL)
{
- result->fake_loc_cu = (Dwarf_CU *) malloc (sizeof (Dwarf_CU));
+ result->fake_loc_cu = malloc (sizeof (Dwarf_CU));
if (unlikely (result->fake_loc_cu == NULL))
{
Dwarf_Sig8_Hash_free (&result->sig8_hash);
if (result != NULL && result->sectiondata[IDX_debug_loclists] != NULL)
{
- result->fake_loclists_cu = (Dwarf_CU *) malloc (sizeof (Dwarf_CU));
+ result->fake_loclists_cu = malloc (sizeof (Dwarf_CU));
if (unlikely (result->fake_loclists_cu == NULL))
{
Dwarf_Sig8_Hash_free (&result->sig8_hash);
inside the .debug_addr section, if it exists. */
if (result != NULL && result->sectiondata[IDX_debug_addr] != NULL)
{
- result->fake_addr_cu = (Dwarf_CU *) malloc (sizeof (Dwarf_CU));
+ result->fake_addr_cu = malloc (sizeof (Dwarf_CU));
if (unlikely (result->fake_addr_cu == NULL))
{
Dwarf_Sig8_Hash_free (&result->sig8_hash);
assert (sizeof (struct Dwarf) < mem_default_size);
/* Allocate the data structure. */
- Dwarf *result = (Dwarf *) calloc (1, sizeof (Dwarf));
+ Dwarf *result = calloc (1, sizeof (Dwarf));
if (unlikely (result == NULL)
|| unlikely (Dwarf_Sig8_Hash_init (&result->sig8_hash, 11) < 0))
{
if (cnt >= allocated)
{
allocated = MAX (10, 2 * allocated);
- struct pubnames_s *newmem
- = (struct pubnames_s *) realloc (mem, allocated * entsize);
+ struct pubnames_s *newmem = realloc (mem, allocated * entsize);
if (newmem == NULL)
{
__libdw_seterrno (DWARF_E_NOMEM);
return -1;
}
- dbg->pubnames_sets = (struct pubnames_s *) realloc (mem, cnt * entsize);
+ dbg->pubnames_sets = realloc (mem, cnt * entsize);
dbg->pubnames_nsets = cnt;
return 0;
{
if (ndirlist > SIZE_MAX / sizeof (*dirarray))
goto no_mem;
- dirarray = (struct dirlist *) malloc (ndirlist * sizeof (*dirarray));
+ dirarray = malloc (ndirlist * sizeof (*dirarray));
if (unlikely (dirarray == NULL))
{
no_mem:
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * dwelf_strtab.c (dwelf_strtab_init): Remove cast of calloc return
+ value.
+ (morememory): Remove cast of malloc return value.
+
2020-12-12 Dmitry V. Levin <ldv@altlinux.org>
* libdwelf.h: Fix spelling typos in comments.
assert (sizeof (struct memoryblock) < ps - MALLOC_OVERHEAD);
}
- Dwelf_Strtab *ret
- = (Dwelf_Strtab *) calloc (1, sizeof (struct Dwelf_Strtab));
+ Dwelf_Strtab *ret = calloc (1, sizeof (struct Dwelf_Strtab));
if (ret != NULL)
{
ret->nullstr = nullstr;
/* Allocate nearest multiple of pagesize >= len. */
len = ((len / ps) + (len % ps != 0)) * ps - MALLOC_OVERHEAD;
- struct memoryblock *newmem = (struct memoryblock *) malloc (len);
+ struct memoryblock *newmem = malloc (len);
if (newmem == NULL)
return 1;
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * linux-pid-attach.c (read_cached_memory): Remove cast of malloc
+ return value.
+
2021-06-09 Omar Sandoval <osandov@fb.com>
* link_map.c (read_addrs): Fix potential NULL pointer dereference.
if (mem_cache == NULL)
{
size_t mem_cache_size = sizeof (struct __libdwfl_remote_mem_cache);
- mem_cache = (struct __libdwfl_remote_mem_cache *) malloc (mem_cache_size);
+ mem_cache = malloc (mem_cache_size);
if (mem_cache == NULL)
return false;
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * eblopenbackend.c (openbackend): Remove cast of calloc return value.
+
2021-04-19 Martin Liska <mliska@suse.cz>
* eblobjnotetypename.c (ebl_object_note_type_name): Use startswith.
/* First allocate the data structure for the result. We do this
here since this assures that the structure is always large
enough. */
- result = (Ebl *) calloc (1, sizeof (Ebl));
+ result = calloc (1, sizeof (Ebl));
if (result == NULL)
{
// XXX uncomment
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * common.h (allocate_elf): Remove cast of calloc return value.
+ * elf_newdata.c (elf_newdata): Likewise.
+ * elf_getscn.c (elf_getscn): Remove casts of calloc return values.
+ * elf_newscn.c (elf_newscn): Likewise.
+ * elf32_updatefile.c (__elfw2): Remove casts of malloc return values.
+ * elf_getdata.c (convert_data): Likewise.
+ (__libelf_set_rawdata_wrlock): Remove cast of malloc return value.
+ * elf_begin.c (read_long_names): Remove cast of malloc return value.
+ * elf_readall.c (__libelf_readall): Likewise.
+ * elf_getarsym.c (elf_getarsym): Remove casts of malloc and realloc
+ return values.
+
2021-07-19 Mark Wielaard <mark@klomp.org>
* elf_strptr.c (validate_str): Check last char is zero first before
allocate_elf (int fildes, void *map_address, int64_t offset, size_t maxsize,
Elf_Cmd cmd, Elf *parent, Elf_Kind kind, size_t extra)
{
- Elf *result = (Elf *) calloc (1, sizeof (Elf) + extra);
+ Elf *result = calloc (1, sizeof (Elf) + extra);
if (result == NULL)
__libelf_seterrno (ELF_E_NOMEM);
else
return 1;
Elf_ScnList *list = &elf->state.ELFW(elf,LIBELFBITS).scns;
- Elf_Scn **scns = (Elf_Scn **) malloc (shnum * sizeof (Elf_Scn *));
+ Elf_Scn **scns = malloc (shnum * sizeof (Elf_Scn *));
if (unlikely (scns == NULL))
{
__libelf_seterrno (ELF_E_NOMEM);
/* Get all sections into the array and sort them. */
Elf_ScnList *list = &elf->state.ELFW(elf,LIBELFBITS).scns;
- Elf_Scn **scns = (Elf_Scn **) malloc (shnum * sizeof (Elf_Scn *));
+ Elf_Scn **scns = malloc (shnum * sizeof (Elf_Scn *));
if (unlikely (scns == NULL))
{
free (shdr_data_mem);
/* Due to the stupid format of the long name table entry (which are not
NUL terminted) we have to provide an appropriate representation anyhow.
Therefore we always make a copy which has the appropriate form. */
- newp = (char *) malloc (len);
+ newp = malloc (len);
if (newp != NULL)
{
char *runp;
/* Now we can allocate the arrays needed to store the index. */
size_t ar_sym_len = (n + 1) * sizeof (Elf_Arsym);
- elf->state.ar.ar_sym = (Elf_Arsym *) malloc (ar_sym_len);
+ elf->state.ar.ar_sym = malloc (ar_sym_len);
if (elf->state.ar.ar_sym != NULL)
{
void *file_data; /* unit32_t[n] or uint64_t[n] */
file_data = temp_data;
ar_sym_len += index_size - n * w;
- Elf_Arsym *newp = (Elf_Arsym *) realloc (elf->state.ar.ar_sym,
- ar_sym_len);
+ Elf_Arsym *newp = realloc (elf->state.ar.ar_sym, ar_sym_len);
if (newp == NULL)
{
free (elf->state.ar.ar_sym);
scn->data_base = scn->rawdata_base;
else
{
- scn->data_base = (char *) malloc (size);
+ scn->data_base = malloc (size);
if (scn->data_base == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
{
xfct_t fp;
- scn->data_base = (char *) malloc (size);
+ scn->data_base = malloc (size);
if (scn->data_base == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
rawdata_source = scn->rawdata_base;
else
{
- rawdata_source = (char *) malloc (size);
+ rawdata_source = malloc (size);
if (rawdata_source == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
/* We have to read the data from the file. Allocate the needed
memory. */
- scn->rawdata_base = scn->rawdata.d.d_buf
- = (char *) malloc (size);
+ scn->rawdata_base = scn->rawdata.d.d_buf = malloc (size);
if (scn->rawdata.d.d_buf == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
Elf_Scn *scn0 = &runp->data[0];
if (elf->class == ELFCLASS32)
{
- scn0->shdr.e32 = (Elf32_Shdr *) calloc (1, sizeof (Elf32_Shdr));
+ scn0->shdr.e32 = calloc (1, sizeof (Elf32_Shdr));
if (scn0->shdr.e32 == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
}
else
{
- scn0->shdr.e64 = (Elf64_Shdr *) calloc (1, sizeof (Elf64_Shdr));
+ scn0->shdr.e64 = calloc (1, sizeof (Elf64_Shdr));
if (scn0->shdr.e64 == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
}
/* Create a new, empty data descriptor. */
- result = (Elf_Data_List *) calloc (1, sizeof (Elf_Data_List));
+ result = calloc (1, sizeof (Elf_Data_List));
if (result == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
1
#endif
)
- newp = (Elf_ScnList *) calloc (sizeof (Elf_ScnList)
- + ((elf->state.elf.scnincr *= 2)
- * sizeof (Elf_Scn)), 1);
+ newp = calloc (sizeof (Elf_ScnList)
+ + ((elf->state.elf.scnincr *= 2)
+ * sizeof (Elf_Scn)), 1);
if (newp == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
/* Create a section header for this section. */
if (elf->class == ELFCLASS32)
{
- result->shdr.e32 = (Elf32_Shdr *) calloc (1, sizeof (Elf32_Shdr));
+ result->shdr.e32 = calloc (1, sizeof (Elf32_Shdr));
if (result->shdr.e32 == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
}
else
{
- result->shdr.e64 = (Elf64_Shdr *) calloc (1, sizeof (Elf64_Shdr));
+ result->shdr.e64 = calloc (1, sizeof (Elf64_Shdr));
if (result->shdr.e64 == NULL)
{
__libelf_seterrno (ELF_E_NOMEM);
}
/* Allocate all the memory we need. */
- mem = (char *) malloc (elf->maximum_size);
+ mem = malloc (elf->maximum_size);
if (mem != NULL)
{
/* Read the file content. */
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * elflint.c (check_sections): Remove cast of xcalloc return value.
+ * findtextrel.c (process_file): Remove casts of malloc and realloc
+ return values.
+ * nm.c (get_local_names, show_symbols_sysv, show_symbols): Remove
+ casts of xmalloc return values.
+ * readelf.c (print_hash_info, handle_sysv_hash, handle_sysv_hash64,
+ handle_gnu_hash): Remove cast of xcalloc return value.
+ (print_debug_units): Remove casts of xmalloc return values.
+ * strip.c (handle_elf): Remove casts of xcalloc and xmalloc return
+ values.
+
2021-09-05 Dmitry V. Levin <ldv@altlinux.org>
* Makefile.am (AM_LDFLAGS): Add $(STACK_USAGE_NO_ERROR).
return;
/* Allocate array to count references in section groups. */
- scnref = (int *) xcalloc (shnum, sizeof (int));
+ scnref = xcalloc (shnum, sizeof (int));
/* Check the zeroth section first. It must not have any contents
and the section header must contain nonzero value at most in the
/* Get the address ranges for the loaded segments. */
size_t nsegments_max = 10;
size_t nsegments = 0;
- struct segments *segments
- = (struct segments *) malloc (nsegments_max * sizeof (segments[0]));
+ struct segments *segments = malloc (nsegments_max * sizeof (segments[0]));
if (segments == NULL)
error (1, errno, _("while reading ELF file"));
{
nsegments_max *= 2;
segments
- = (struct segments *) realloc (segments,
- nsegments_max
- * sizeof (segments[0]));
+ = realloc (segments, nsegments_max * sizeof (segments[0]));
if (segments == NULL)
{
error (0, 0, _("\
}
/* We have all the information. Create a record. */
- struct local_name *newp
- = (struct local_name *) xmalloc (sizeof (*newp));
+ struct local_name *newp = xmalloc (sizeof (*newp));
newp->name = name;
newp->file = dwarf_filesrc (files, fileidx, NULL, NULL);
newp->lineno = lineno;
bool scnnames_malloced = shnum * sizeof (const char *) > 128 * 1024;
const char **scnnames;
if (scnnames_malloced)
- scnnames = (const char **) xmalloc (sizeof (const char *) * shnum);
+ scnnames = xmalloc (sizeof (const char *) * shnum);
else
scnnames = (const char **) alloca (sizeof (const char *) * shnum);
/* Get the section header string table index. */
if (nentries * sizeof (GElf_SymX) < MAX_STACK_ALLOC)
sym_mem = (GElf_SymX *) alloca (nentries * sizeof (GElf_SymX));
else
- sym_mem = (GElf_SymX *) xmalloc (nentries * sizeof (GElf_SymX));
+ sym_mem = xmalloc (nentries * sizeof (GElf_SymX));
/* Iterate over all symbols. */
#ifdef USE_DEMANGLE
uint_fast32_t maxlength, Elf32_Word nbucket,
uint_fast32_t nsyms, uint32_t *lengths, const char *extrastr)
{
- uint32_t *counts = (uint32_t *) xcalloc (maxlength + 1, sizeof (uint32_t));
+ uint32_t *counts = xcalloc (maxlength + 1, sizeof (uint32_t));
for (Elf32_Word cnt = 0; cnt < nbucket; ++cnt)
++counts[lengths[cnt]];
Elf32_Word *bucket = &((Elf32_Word *) data->d_buf)[2];
Elf32_Word *chain = &((Elf32_Word *) data->d_buf)[2 + nbucket];
- uint32_t *lengths = (uint32_t *) xcalloc (nbucket, sizeof (uint32_t));
+ uint32_t *lengths = xcalloc (nbucket, sizeof (uint32_t));
uint_fast32_t maxlength = 0;
uint_fast32_t nsyms = 0;
Elf64_Xword *bucket = &((Elf64_Xword *) data->d_buf)[2];
Elf64_Xword *chain = &((Elf64_Xword *) data->d_buf)[2 + nbucket];
- uint32_t *lengths = (uint32_t *) xcalloc (nbucket, sizeof (uint32_t));
+ uint32_t *lengths = xcalloc (nbucket, sizeof (uint32_t));
uint_fast32_t maxlength = 0;
uint_fast32_t nsyms = 0;
if (used_buf > data->d_size)
goto invalid_data;
- lengths = (uint32_t *) xcalloc (nbucket, sizeof (uint32_t));
+ lengths = xcalloc (nbucket, sizeof (uint32_t));
Elf32_Word *bitmask = &((Elf32_Word *) data->d_buf)[4];
Elf32_Word *bucket = &((Elf32_Word *) data->d_buf)[4 + bitmask_words];
return;
int maxdies = 20;
- Dwarf_Die *dies = (Dwarf_Die *) xmalloc (maxdies * sizeof (Dwarf_Die));
+ Dwarf_Die *dies = xmalloc (maxdies * sizeof (Dwarf_Die));
/* New compilation unit. */
Dwarf_Half version;
/* Make room for the next level's DIE. */
if (level + 1 == maxdies)
- dies = (Dwarf_Die *) xrealloc (dies,
- (maxdies += 10)
- * sizeof (Dwarf_Die));
+ dies = xrealloc (dies, (maxdies += 10) * sizeof (Dwarf_Die));
int res = dwarf_child (&dies[level], &dies[level + 1]);
if (res > 0)
the debug file if the file would not contain any
information. */
size_t debug_fname_len = strlen (debug_fname);
- tmp_debug_fname = (char *) xmalloc (debug_fname_len + sizeof (".XXXXXX"));
+ tmp_debug_fname = xmalloc (debug_fname_len + sizeof (".XXXXXX"));
strcpy (mempcpy (tmp_debug_fname, debug_fname, debug_fname_len),
".XXXXXX");
table. Maybe some weird tool created an ELF file without one.
The other one is used for the debug link section. */
if ((shnum + 2) * sizeof (struct shdr_info) > MAX_STACK_ALLOC)
- shdr_info = (struct shdr_info *) xcalloc (shnum + 2,
- sizeof (struct shdr_info));
+ shdr_info = xcalloc (shnum + 2, sizeof (struct shdr_info));
else
{
shdr_info = (struct shdr_info *) alloca ((shnum + 2)
}
shdr_info[cnt].newsymidx
- = (Elf32_Word *) xcalloc (shdr_info[cnt].data->d_size
- / elsize, sizeof (Elf32_Word));
+ = xcalloc (shdr_info[cnt].data->d_size / elsize,
+ sizeof (Elf32_Word));
bool last_was_local = true;
size_t destidx;
+2021-09-06 Dmitry V. Levin <ldv@altlinux.org>
+
+ * elfcopy.c (copy_elf): Remove cast of malloc return value.
+
2021-09-07 Mark Wielaard <mark@klomp.org>
* run-debuginfod-archive-groom.sh: Wait for initial scan and groom
exit (1);
}
- offs = (GElf_Off *) malloc (shnum * sizeof (GElf_Off));
+ offs = malloc (shnum * sizeof (GElf_Off));
if (offs == NULL)
{
printf ("couldn't allocate memory for offs\n");
projects / platform / upstream / elfutils.git / commitdiff