On Tue, May 10, 2022 at 5:37 AM Martin Liška <mli...@suse.cz> wrote: > > Hi. > > As noticed by Alan, we can stop using the non-ANSI C specific macro (PTR). > Let's removed its usafe in libiberty. > > Patch can bootstrap on x86_64-linux-gnu and survives regression tests. > > Ready to be installed? > Thanks, > Martin > > include/ChangeLog: > > * hashtab.h (HTAB_EMPTY_ENTRY): Use void * instead PTR. > (HTAB_DELETED_ENTRY): Likewise. > > libiberty/ChangeLog: > > * alloca.c (C_alloca): Use void * instead PTR. > * calloc.c (malloc): Likewise. > (bzero): Likewise. > (calloc): Likewise. > * hashtab.c (find_empty_slot_for_expand): Likewise. > (eq_pointer): Likewise. > (htab_create_alloc_ex): Likewise. > (htab_create_typed_alloc): Likewise. > (htab_set_functions_ex): Likewise. > (htab_delete): Likewise. > (htab_empty): Likewise. > (htab_expand): Likewise. > (htab_find_with_hash): Likewise. > (htab_find): Likewise. > (htab_find_slot_with_hash): Likewise. > (htab_find_slot): Likewise. > (htab_remove_elt): Likewise. > (htab_remove_elt_with_hash): Likewise. > (htab_clear_slot): Likewise. > (htab_traverse_noresize): Likewise. > (htab_traverse): Likewise. > (htab_hash_string): Likewise. > (iterative_hash): Likewise. > (hash_pointer): Likewise. > * memchr.c (memchr): Likewise. > * memcmp.c (memcmp): Likewise. > * memcpy.c (memcpy): Likewise. > * memmove.c (memmove): Likewise. > * mempcpy.c (memcpy): Likewise. > (mempcpy): Likewise. > * memset.c (memset): Likewise. > * objalloc.c (malloc): Likewise. > (free): Likewise. > (objalloc_create): Likewise. > (_objalloc_alloc): Likewise. > (objalloc_free_block): Likewise. > * random.c (PTR): Likewise. > (void): Likewise. > (initstate): Likewise. > (setstate): Likewise. > * regex.c: Likewise. > * spaces.c (malloc): Likewise. > (free): Likewise. > * stpcpy.c (memcpy): Likewise. > * strdup.c (malloc): Likewise. > (memcpy): Likewise. > * strerror.c (malloc): Likewise. > (memset): Likewise. > * strndup.c (malloc): Likewise. > (memcpy): Likewise. > * strsignal.c (malloc): Likewise. > (memset): Likewise. > * vasprintf.c (malloc): Likewise. > * vprintf-support.c: Likewise. > * xatexit.c (malloc): Likewise. > * xmalloc.c (xmalloc): Likewise. > (xcalloc): Likewise. > (xrealloc): Likewise. > * xmemdup.c (xmemdup): Likewise. > --- > include/hashtab.h | 4 +- > libiberty/alloca.c | 7 ++- > libiberty/calloc.c | 9 ++-- > libiberty/hashtab.c | 92 ++++++++++++++++++------------------- > libiberty/memchr.c | 5 +- > libiberty/memcmp.c | 2 +- > libiberty/memcpy.c | 3 +- > libiberty/memmove.c | 3 +- > libiberty/mempcpy.c | 5 +- > libiberty/memset.c | 3 +- > libiberty/objalloc.c | 23 +++++----- > libiberty/random.c | 14 +++--- > libiberty/regex.c | 8 ++-- > libiberty/spaces.c | 4 +- > libiberty/stpcpy.c | 2 +- > libiberty/strdup.c | 4 +- > libiberty/strerror.c | 4 +- > libiberty/strndup.c | 4 +- > libiberty/strsignal.c | 4 +- > libiberty/vasprintf.c | 2 +- > libiberty/vprintf-support.c | 2 +- > libiberty/xatexit.c | 2 +- > libiberty/xmalloc.c | 15 +++--- > libiberty/xmemdup.c | 7 ++- > 24 files changed, 106 insertions(+), 122 deletions(-) > > diff --git a/include/hashtab.h b/include/hashtab.h > index 7117eee2afb..e74d2226e08 100644 > --- a/include/hashtab.h > +++ b/include/hashtab.h > @@ -79,12 +79,12 @@ typedef void (*htab_free_with_arg) (void *, void *); > > /* This macro defines reserved value for empty table entry. */ > > -#define HTAB_EMPTY_ENTRY ((PTR) 0) > +#define HTAB_EMPTY_ENTRY ((void *) 0) > > /* This macro defines reserved value for table entry which contained > a deleted element. */ > > -#define HTAB_DELETED_ENTRY ((PTR) 1) > +#define HTAB_DELETED_ENTRY ((void *) 1) > > /* Hash tables are of the following type. The structure > (implementation) of this type is not needed for using the hash > diff --git a/libiberty/alloca.c b/libiberty/alloca.c > index 9b2e9cb12b6..46f920517e1 100644 > --- a/libiberty/alloca.c > +++ b/libiberty/alloca.c > @@ -158,8 +158,7 @@ static header *last_alloca_header = NULL; /* -> last > alloca header. */ > > /* @undocumented C_alloca */ > > -PTR > -C_alloca (size_t size) > +void *C_alloca (size_t size)
Hi, please preserve existing style when possible when making this replacement; ISTR there are some tools (like for generating libiberty's documentation) that depend on the return type being on a separate line... If all of the relevant Makefile targets still work after this change, well, fine, but... well, just something to consider... > { > auto char probe; /* Probes stack depth: */ > register char *depth = ADDRESS_FUNCTION (probe); > @@ -181,7 +180,7 @@ C_alloca (size_t size) > { > register header *np = hp->h.next; > > - free ((PTR) hp); /* Collect garbage. */ > + free ((void *) hp); /* Collect garbage. */ > > hp = np; /* -> next header. */ > } > @@ -210,7 +209,7 @@ C_alloca (size_t size) > > /* User storage begins just after header. */ > > - return (PTR) ((char *) new_storage + sizeof (header)); > + return (void *) ((char *) new_storage + sizeof (header)); > } > } > > diff --git a/libiberty/calloc.c b/libiberty/calloc.c > index f4bd27b1cd2..fbb2f1d35cb 100644 > --- a/libiberty/calloc.c > +++ b/libiberty/calloc.c > @@ -16,13 +16,12 @@ Uses @code{malloc} to allocate storage for @var{nelem} > objects of > #include <stddef.h> > > /* For systems with larger pointers than ints, this must be declared. */ > -PTR malloc (size_t); > -void bzero (PTR, size_t); > +void *malloc (size_t); > +void bzero (void *, size_t); > > -PTR > -calloc (size_t nelem, size_t elsize) > +void *calloc (size_t nelem, size_t elsize) > { > - register PTR ptr; > + register void *ptr; > > if (nelem == 0 || elsize == 0) > nelem = elsize = 1; > diff --git a/libiberty/hashtab.c b/libiberty/hashtab.c > index d3cc86b75d6..d721e1a0c1d 100644 > --- a/libiberty/hashtab.c > +++ b/libiberty/hashtab.c > @@ -73,7 +73,7 @@ static hashval_t htab_mod_m2 (hashval_t, htab_t); > static hashval_t hash_pointer (const void *); > static int eq_pointer (const void *, const void *); > static int htab_expand (htab_t); > -static PTR *find_empty_slot_for_expand (htab_t, hashval_t); > +static void **find_empty_slot_for_expand (htab_t, hashval_t); > > /* At some point, we could make these be NULL, and modify the > hash-table routines to handle NULL specially; that would avoid > @@ -196,7 +196,7 @@ higher_prime_index (unsigned long n) > /* Returns non-zero if P1 and P2 are equal. */ > > static int > -eq_pointer (const PTR p1, const PTR p2) > +eq_pointer (const void *p1, const void *p2) > { > return p1 == p2; > } > @@ -304,7 +304,7 @@ htab_create_alloc_ex (size_t size, htab_hash hash_f, > htab_eq eq_f, > result = (htab_t) (*alloc_f) (alloc_arg, 1, sizeof (struct htab)); > if (result == NULL) > return NULL; > - result->entries = (PTR *) (*alloc_f) (alloc_arg, size, sizeof (PTR)); > + result->entries = (void **) (*alloc_f) (alloc_arg, size, sizeof (void *)); > if (result->entries == NULL) > { > if (free_f != NULL) > @@ -357,7 +357,7 @@ htab_create_typed_alloc (size_t size, htab_hash hash_f, > htab_eq eq_f, > result = (htab_t) (*alloc_tab_f) (1, sizeof (struct htab)); > if (result == NULL) > return NULL; > - result->entries = (PTR *) (*alloc_f) (size, sizeof (PTR)); > + result->entries = (void **) (*alloc_f) (size, sizeof (void *)); > if (result->entries == NULL) > { > if (free_f != NULL) > @@ -379,7 +379,7 @@ htab_create_typed_alloc (size_t size, htab_hash hash_f, > htab_eq eq_f, > > void > htab_set_functions_ex (htab_t htab, htab_hash hash_f, htab_eq eq_f, > - htab_del del_f, PTR alloc_arg, > + htab_del del_f, void *alloc_arg, > htab_alloc_with_arg alloc_f, htab_free_with_arg > free_f) > { > htab->hash_f = hash_f; > @@ -412,7 +412,7 @@ void > htab_delete (htab_t htab) > { > size_t size = htab_size (htab); > - PTR *entries = htab->entries; > + void **entries = htab->entries; > int i; > > if (htab->del_f) > @@ -438,7 +438,7 @@ void > htab_empty (htab_t htab) > { > size_t size = htab_size (htab); > - PTR *entries = htab->entries; > + void **entries = htab->entries; > int i; > > if (htab->del_f) > @@ -447,9 +447,9 @@ htab_empty (htab_t htab) > (*htab->del_f) (entries[i]); > > /* Instead of clearing megabyte, downsize the table. */ > - if (size > 1024*1024 / sizeof (PTR)) > + if (size > 1024*1024 / sizeof (void *)) > { > - int nindex = higher_prime_index (1024 / sizeof (PTR)); > + int nindex = higher_prime_index (1024 / sizeof (void *)); > int nsize = prime_tab[nindex].prime; > > if (htab->free_f != NULL) > @@ -457,15 +457,15 @@ htab_empty (htab_t htab) > else if (htab->free_with_arg_f != NULL) > (*htab->free_with_arg_f) (htab->alloc_arg, htab->entries); > if (htab->alloc_with_arg_f != NULL) > - htab->entries = (PTR *) (*htab->alloc_with_arg_f) (htab->alloc_arg, > nsize, > - sizeof (PTR *)); > + htab->entries = (void **) (*htab->alloc_with_arg_f) (htab->alloc_arg, > nsize, > + sizeof (void **)); > else > - htab->entries = (PTR *) (*htab->alloc_f) (nsize, sizeof (PTR *)); > + htab->entries = (void **) (*htab->alloc_f) (nsize, sizeof (void **)); > htab->size = nsize; > htab->size_prime_index = nindex; > } > else > - memset (entries, 0, size * sizeof (PTR)); > + memset (entries, 0, size * sizeof (void *)); > htab->n_deleted = 0; > htab->n_elements = 0; > } > @@ -477,12 +477,12 @@ htab_empty (htab_t htab) > This function also assumes there are no deleted entries in the table. > HASH is the hash value for the element to be inserted. */ > > -static PTR * > +static void ** > find_empty_slot_for_expand (htab_t htab, hashval_t hash) > { > hashval_t index = htab_mod (hash, htab); > size_t size = htab_size (htab); > - PTR *slot = htab->entries + index; > + void **slot = htab->entries + index; > hashval_t hash2; > > if (*slot == HTAB_EMPTY_ENTRY) > @@ -516,10 +516,10 @@ find_empty_slot_for_expand (htab_t htab, hashval_t hash) > static int > htab_expand (htab_t htab) > { > - PTR *oentries; > - PTR *olimit; > - PTR *p; > - PTR *nentries; > + void **oentries; > + void **olimit; > + void **p; > + void **nentries; > size_t nsize, osize, elts; > unsigned int oindex, nindex; > > @@ -543,10 +543,10 @@ htab_expand (htab_t htab) > } > > if (htab->alloc_with_arg_f != NULL) > - nentries = (PTR *) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize, > - sizeof (PTR *)); > + nentries = (void **) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize, > + sizeof (void **)); > else > - nentries = (PTR *) (*htab->alloc_f) (nsize, sizeof (PTR *)); > + nentries = (void **) (*htab->alloc_f) (nsize, sizeof (void **)); > if (nentries == NULL) > return 0; > htab->entries = nentries; > @@ -558,11 +558,11 @@ htab_expand (htab_t htab) > p = oentries; > do > { > - PTR x = *p; > + void *x = *p; > > if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > { > - PTR *q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x)); > + void **q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x)); > > *q = x; > } > @@ -581,12 +581,11 @@ htab_expand (htab_t htab) > /* This function searches for a hash table entry equal to the given > element. It cannot be used to insert or delete an element. */ > > -PTR > -htab_find_with_hash (htab_t htab, const PTR element, hashval_t hash) > +void *htab_find_with_hash (htab_t htab, const void *element, hashval_t hash) > { > hashval_t index, hash2; > size_t size; > - PTR entry; > + void *entry; > > htab->searches++; > size = htab_size (htab); > @@ -615,8 +614,7 @@ htab_find_with_hash (htab_t htab, const PTR element, > hashval_t hash) > /* Like htab_find_slot_with_hash, but compute the hash value from the > element. */ > > -PTR > -htab_find (htab_t htab, const PTR element) > +void *htab_find (htab_t htab, const void *element) > { > return htab_find_with_hash (htab, element, (*htab->hash_f) (element)); > } > @@ -629,14 +627,14 @@ htab_find (htab_t htab, const PTR element) > slot. When inserting an entry, NULL may be returned if memory > allocation fails. */ > > -PTR * > -htab_find_slot_with_hash (htab_t htab, const PTR element, > +void ** > +htab_find_slot_with_hash (htab_t htab, const void *element, > hashval_t hash, enum insert_option insert) > { > - PTR *first_deleted_slot; > + void **first_deleted_slot; > hashval_t index, hash2; > size_t size; > - PTR entry; > + void *entry; > > size = htab_size (htab); > if (insert == INSERT && size * 3 <= htab->n_elements * 4) > @@ -697,8 +695,8 @@ htab_find_slot_with_hash (htab_t htab, const PTR element, > /* Like htab_find_slot_with_hash, but compute the hash value from the > element. */ > > -PTR * > -htab_find_slot (htab_t htab, const PTR element, enum insert_option insert) > +void ** > +htab_find_slot (htab_t htab, const void *element, enum insert_option insert) > { > return htab_find_slot_with_hash (htab, element, (*htab->hash_f) (element), > insert); > @@ -709,7 +707,7 @@ htab_find_slot (htab_t htab, const PTR element, enum > insert_option insert) > element in the hash table, this function does nothing. */ > > void > -htab_remove_elt (htab_t htab, const PTR element) > +htab_remove_elt (htab_t htab, const void *element) > { > htab_remove_elt_with_hash (htab, element, (*htab->hash_f) (element)); > } > @@ -720,9 +718,9 @@ htab_remove_elt (htab_t htab, const PTR element) > function does nothing. */ > > void > -htab_remove_elt_with_hash (htab_t htab, const PTR element, hashval_t hash) > +htab_remove_elt_with_hash (htab_t htab, const void *element, hashval_t hash) > { > - PTR *slot; > + void **slot; > > slot = htab_find_slot_with_hash (htab, element, hash, NO_INSERT); > if (slot == NULL) > @@ -740,7 +738,7 @@ htab_remove_elt_with_hash (htab_t htab, const PTR > element, hashval_t hash) > again. */ > > void > -htab_clear_slot (htab_t htab, PTR *slot) > +htab_clear_slot (htab_t htab, void **slot) > { > if (slot < htab->entries || slot >= htab->entries + htab_size (htab) > || *slot == HTAB_EMPTY_ENTRY || *slot == HTAB_DELETED_ENTRY) > @@ -759,17 +757,17 @@ htab_clear_slot (htab_t htab, PTR *slot) > argument. */ > > void > -htab_traverse_noresize (htab_t htab, htab_trav callback, PTR info) > +htab_traverse_noresize (htab_t htab, htab_trav callback, void *info) > { > - PTR *slot; > - PTR *limit; > + void **slot; > + void **limit; > > slot = htab->entries; > limit = slot + htab_size (htab); > > do > { > - PTR x = *slot; > + void *x = *slot; > > if (x != HTAB_EMPTY_ENTRY && x != HTAB_DELETED_ENTRY) > if (!(*callback) (slot, info)) > @@ -782,7 +780,7 @@ htab_traverse_noresize (htab_t htab, htab_trav callback, > PTR info) > too empty to improve effectivity of subsequent calls. */ > > void > -htab_traverse (htab_t htab, htab_trav callback, PTR info) > +htab_traverse (htab_t htab, htab_trav callback, void *info) > { > size_t size = htab_size (htab); > if (htab_elements (htab) * 8 < size && size > 32) > @@ -829,7 +827,7 @@ htab_collisions (htab_t htab) > function they just started using for Perl's hashes. */ > > hashval_t > -htab_hash_string (const PTR p) > +htab_hash_string (const void *p) > { > const unsigned char *str = (const unsigned char *) p; > hashval_t r = 0; > @@ -926,7 +924,7 @@ acceptable. Do NOT use for cryptographic purposes. > */ > > hashval_t > -iterative_hash (const PTR k_in /* the key */, > +iterative_hash (const void *k_in /* the key */, > register size_t length /* the length of the key */, > register hashval_t initval /* the previous hash, or > an arbitrary value */) > @@ -990,7 +988,7 @@ iterative_hash (const PTR k_in /* the key */, > /* Returns a hash code for pointer P. Simplified version of evahash */ > > static hashval_t > -hash_pointer (const PTR p) > +hash_pointer (const void *p) > { > intptr_t v = (intptr_t) p; > unsigned a, b, c; > diff --git a/libiberty/memchr.c b/libiberty/memchr.c > index 7448ab9e71c..10c6d7d426b 100644 > --- a/libiberty/memchr.c > +++ b/libiberty/memchr.c > @@ -18,15 +18,14 @@ returned. > #include <ansidecl.h> > #include <stddef.h> > > -PTR > -memchr (register const PTR src_void, int c, size_t length) > +void *memchr (register const void *src_void, int c, size_t length) > { > const unsigned char *src = (const unsigned char *)src_void; > > while (length-- > 0) > { > if (*src == c) > - return (PTR)src; > + return (void *)src; > src++; > } > return NULL; > diff --git a/libiberty/memcmp.c b/libiberty/memcmp.c > index 37db60f3826..5b1af020e6c 100644 > --- a/libiberty/memcmp.c > +++ b/libiberty/memcmp.c > @@ -20,7 +20,7 @@ as if comparing unsigned char arrays. > #include <stddef.h> > > int > -memcmp (const PTR str1, const PTR str2, size_t count) > +memcmp (const void *str1, const void *str2, size_t count) > { > register const unsigned char *s1 = (const unsigned char*)str1; > register const unsigned char *s2 = (const unsigned char*)str2; > diff --git a/libiberty/memcpy.c b/libiberty/memcpy.c > index 7f67d0bd1f2..cbb54efc7e8 100644 > --- a/libiberty/memcpy.c > +++ b/libiberty/memcpy.c > @@ -18,8 +18,7 @@ Copies @var{length} bytes from memory region @var{in} to > region > > void bcopy (const void*, void*, size_t); > > -PTR > -memcpy (PTR out, const PTR in, size_t length) > +void *memcpy (void *out, const void *in, size_t length) > { > bcopy(in, out, length); > return out; > diff --git a/libiberty/memmove.c b/libiberty/memmove.c > index ebda7cbb41c..b9308f6d1e7 100644 > --- a/libiberty/memmove.c > +++ b/libiberty/memmove.c > @@ -18,8 +18,7 @@ Copies @var{count} bytes from memory area @var{from} to > memory area > > void bcopy (const void*, void*, size_t); > > -PTR > -memmove (PTR s1, const PTR s2, size_t n) > +void *memmove (void *s1, const void *s2, size_t n) > { > bcopy (s2, s1, n); > return s1; > diff --git a/libiberty/mempcpy.c b/libiberty/mempcpy.c > index 34d9b2f4297..fc820131102 100644 > --- a/libiberty/mempcpy.c > +++ b/libiberty/mempcpy.c > @@ -33,10 +33,9 @@ Copies @var{length} bytes from memory region @var{in} to > region > #include <ansidecl.h> > #include <stddef.h> > > -extern PTR memcpy (PTR, const PTR, size_t); > +extern void *memcpy (void *, const void *, size_t); > > -PTR > -mempcpy (PTR dst, const PTR src, size_t len) > +void *mempcpy (void *dst, const void *src, size_t len) > { > return (char *) memcpy (dst, src, len) + len; > } > diff --git a/libiberty/memset.c b/libiberty/memset.c > index 47666896127..eae816a7426 100644 > --- a/libiberty/memset.c > +++ b/libiberty/memset.c > @@ -16,8 +16,7 @@ Sets the first @var{count} bytes of @var{s} to the constant > byte > #include <ansidecl.h> > #include <stddef.h> > > -PTR > -memset (PTR dest, register int val, register size_t len) > +void *memset (void *dest, register int val, register size_t len) > { > register unsigned char *ptr = (unsigned char*)dest; > while (len-- > 0) > diff --git a/libiberty/objalloc.c b/libiberty/objalloc.c > index cf5de1fcb2d..3a778a299f9 100644 > --- a/libiberty/objalloc.c > +++ b/libiberty/objalloc.c > @@ -37,8 +37,8 @@ Boston, MA 02110-1301, USA. */ > #include <stdlib.h> > #else > /* For systems with larger pointers than ints, this must be declared. */ > -extern PTR malloc (size_t); > -extern void free (PTR); > +extern void *malloc (size_t); > +extern void free (void *); > #endif > > #endif > @@ -92,7 +92,7 @@ objalloc_create (void) > if (ret == NULL) > return NULL; > > - ret->chunks = (PTR) malloc (CHUNK_SIZE); > + ret->chunks = (void *) malloc (CHUNK_SIZE); > if (ret->chunks == NULL) > { > free (ret); > @@ -111,8 +111,7 @@ objalloc_create (void) > > /* Allocate space from an objalloc structure. */ > > -PTR > -_objalloc_alloc (struct objalloc *o, unsigned long original_len) > +void *_objalloc_alloc (struct objalloc *o, unsigned long original_len) > { > unsigned long len = original_len; > > @@ -132,7 +131,7 @@ _objalloc_alloc (struct objalloc *o, unsigned long > original_len) > { > o->current_ptr += len; > o->current_space -= len; > - return (PTR) (o->current_ptr - len); > + return (void *) (o->current_ptr - len); > } > > if (len >= BIG_REQUEST) > @@ -148,9 +147,9 @@ _objalloc_alloc (struct objalloc *o, unsigned long > original_len) > chunk->next = (struct objalloc_chunk *) o->chunks; > chunk->current_ptr = o->current_ptr; > > - o->chunks = (PTR) chunk; > + o->chunks = (void *) chunk; > > - return (PTR) (ret + CHUNK_HEADER_SIZE); > + return (void *) (ret + CHUNK_HEADER_SIZE); > } > else > { > @@ -165,7 +164,7 @@ _objalloc_alloc (struct objalloc *o, unsigned long > original_len) > o->current_ptr = (char *) chunk + CHUNK_HEADER_SIZE; > o->current_space = CHUNK_SIZE - CHUNK_HEADER_SIZE; > > - o->chunks = (PTR) chunk; > + o->chunks = (void *) chunk; > > return objalloc_alloc (o, len); > } > @@ -195,7 +194,7 @@ objalloc_free (struct objalloc *o) > recently allocated blocks. */ > > void > -objalloc_free_block (struct objalloc *o, PTR block) > +objalloc_free_block (struct objalloc *o, void *block) > { > struct objalloc_chunk *p, *small; > char *b = (char *) block; > @@ -257,7 +256,7 @@ objalloc_free_block (struct objalloc *o, PTR block) > > if (first == NULL) > first = p; > - o->chunks = (PTR) first; > + o->chunks = (void *) first; > > /* Now start allocating from this small block again. */ > o->current_ptr = b; > @@ -287,7 +286,7 @@ objalloc_free_block (struct objalloc *o, PTR block) > q = next; > } > > - o->chunks = (PTR) p; > + o->chunks = (void *) p; > > while (p->current_ptr != NULL) > p = p->next; > diff --git a/libiberty/random.c b/libiberty/random.c > index b1d3c6c6ae4..03fe2a5dea8 100644 > --- a/libiberty/random.c > +++ b/libiberty/random.c > @@ -68,12 +68,12 @@ control over the state of the random number generator. > #define LONG_MAX ((long)(ULONG_MAX >> 1)) /* 0x7FFFFFFF for > 32-bits*/ > > #ifdef __STDC__ > -# define PTR void * > +# define void *void * > # ifndef NULL > # define NULL (void *) 0 > # endif > #else > -# define PTR char * > +# define void *char * > # ifndef NULL > # define NULL (void *) 0 > # endif > @@ -254,10 +254,9 @@ srandom (unsigned int x) > Note: The first thing we do is save the current state, if any, just like > setstate so that it doesn't matter when initstate is called. > Returns a pointer to the old state. */ > -PTR > -initstate (unsigned int seed, PTR arg_state, unsigned long n) > +void *initstate (unsigned int seed, void *arg_state, unsigned long n) > { > - PTR ostate = (PTR) &state[-1]; > + void *ostate = (void *) &state[-1]; > > if (rand_type == TYPE_0) > state[-1] = rand_type; > @@ -320,13 +319,12 @@ initstate (unsigned int seed, PTR arg_state, unsigned > long n) > same state as the current state > Returns a pointer to the old state information. */ > > -PTR > -setstate (PTR arg_state) > +void *setstate (void *arg_state) > { > register long int *new_state = (long int *) arg_state; > register int type = new_state[0] % MAX_TYPES; > register int rear = new_state[0] / MAX_TYPES; > - PTR ostate = (PTR) &state[-1]; > + void *ostate = (void *) &state[-1]; > > if (rand_type == TYPE_0) > state[-1] = rand_type; > diff --git a/libiberty/regex.c b/libiberty/regex.c > index 84af5276ae8..c1738c989ab 100644 > --- a/libiberty/regex.c > +++ b/libiberty/regex.c > @@ -384,8 +384,8 @@ typedef unsigned long int uintptr_t; > # endif /* not using relocating allocator */ > > > -/* True if `size1' is non-NULL and PTR is pointing anywhere inside > - `string1' or just past its end. This works if PTR is NULL, which is > +/* True if `size1' is non-NULL and void *is pointing anywhere inside > + `string1' or just past its end. This works if void *is NULL, which is > a good thing. */ > # define FIRST_STRING_P(ptr) \ > (size1 && string1 <= (ptr) && (ptr) <= string1 + size1) > @@ -5256,7 +5256,7 @@ PREFIX(re_search_2) (struct re_pattern_buffer *bufp, > const char *string1, > } > > #ifdef WCHAR > -/* This converts PTR, a pointer into one of the search wchar_t strings > +/* This converts void *, a pointer into one of the search wchar_t strings > `string1' and `string2' into an multibyte string offset from the > beginning of that string. We use mbs_offset to optimize. > See convert_mbs_to_wcs. */ > @@ -5266,7 +5266,7 @@ PREFIX(re_search_2) (struct re_pattern_buffer *bufp, > const char *string1, > : ((regoff_t)((mbs_offset2 != NULL? mbs_offset2[(ptr)-string2] : 0) \ > + csize1))) > #else /* BYTE */ > -/* This converts PTR, a pointer into one of the search strings `string1' > +/* This converts void *, a pointer into one of the search strings `string1' > and `string2' into an offset from the beginning of that string. */ > # define POINTER_TO_OFFSET(ptr) \ > (FIRST_STRING_P (ptr) \ > diff --git a/libiberty/spaces.c b/libiberty/spaces.c > index 50d15882ee6..2b6971c4b93 100644 > --- a/libiberty/spaces.c > +++ b/libiberty/spaces.c > @@ -40,8 +40,8 @@ valid until at least the next call. > #include <unixlib.h> > #else > /* For systems with larger pointers than ints, these must be declared. */ > -extern PTR malloc (size_t); > -extern void free (PTR); > +extern void *malloc (size_t); > +extern void free (void *); > #endif > > const char * > diff --git a/libiberty/stpcpy.c b/libiberty/stpcpy.c > index 880e4fca7c7..2d3eb4c71cd 100644 > --- a/libiberty/stpcpy.c > +++ b/libiberty/stpcpy.c > @@ -33,7 +33,7 @@ Copies the string @var{src} into @var{dst}. Returns a > pointer to > #include <stddef.h> > > extern size_t strlen (const char *); > -extern PTR memcpy (PTR, const PTR, size_t); > +extern void *memcpy (void *, const void *, size_t); > > char * > stpcpy (char *dst, const char *src) > diff --git a/libiberty/strdup.c b/libiberty/strdup.c > index 78c2093b61a..8a4188eadfb 100644 > --- a/libiberty/strdup.c > +++ b/libiberty/strdup.c > @@ -13,8 +13,8 @@ Returns a pointer to a copy of @var{s} in memory obtained > from > #include <stddef.h> > > extern size_t strlen (const char*); > -extern PTR malloc (size_t); > -extern PTR memcpy (PTR, const PTR, size_t); > +extern void *malloc (size_t); > +extern void *memcpy (void *, const void *, size_t); > > char * > strdup(const char *s) > diff --git a/libiberty/strerror.c b/libiberty/strerror.c > index cc7692c1d69..07db71698d9 100644 > --- a/libiberty/strerror.c > +++ b/libiberty/strerror.c > @@ -30,13 +30,13 @@ > #ifdef HAVE_STDLIB_H > #include <stdlib.h> > #else > -extern PTR malloc (); > +extern void *malloc (); > #endif > > #ifdef HAVE_STRING_H > #include <string.h> > #else > -extern PTR memset (); > +extern void *memset (); > #endif > > #ifndef MAX > diff --git a/libiberty/strndup.c b/libiberty/strndup.c > index 5992ee9cfa1..cfbb381ad0d 100644 > --- a/libiberty/strndup.c > +++ b/libiberty/strndup.c > @@ -34,8 +34,8 @@ memory was available. The result is always NUL terminated. > #include <stddef.h> > > extern size_t strnlen (const char *s, size_t maxlen); > -extern PTR malloc (size_t); > -extern PTR memcpy (PTR, const PTR, size_t); > +extern void *malloc (size_t); > +extern void *memcpy (void *, const void *, size_t); > > char * > strndup (const char *s, size_t n) > diff --git a/libiberty/strsignal.c b/libiberty/strsignal.c > index 666b1b4f15e..36b41f17e12 100644 > --- a/libiberty/strsignal.c > +++ b/libiberty/strsignal.c > @@ -26,13 +26,13 @@ > #ifdef HAVE_STDLIB_H > #include <stdlib.h> > #else > -extern PTR malloc (); > +extern void *malloc (); > #endif > > #ifdef HAVE_STRING_H > #include <string.h> > #else > -extern PTR memset (); > +extern void *memset (); > #endif > > /* Undefine the macro we used to hide the definition of sys_siglist > diff --git a/libiberty/vasprintf.c b/libiberty/vasprintf.c > index e2717d83f37..c8c0152865b 100644 > --- a/libiberty/vasprintf.c > +++ b/libiberty/vasprintf.c > @@ -33,7 +33,7 @@ Floor, Boston, MA 02110-1301, USA. */ > #ifdef HAVE_STDLIB_H > #include <stdlib.h> > #else > -extern PTR malloc (); > +extern void *malloc (); > #endif > #include "libiberty.h" > #include "vprintf-support.h" > diff --git a/libiberty/vprintf-support.c b/libiberty/vprintf-support.c > index 231e584bbc1..92aedce1edd 100644 > --- a/libiberty/vprintf-support.c > +++ b/libiberty/vprintf-support.c > @@ -49,7 +49,7 @@ libiberty_vprintf_buffer_size (const char *format, va_list > args) > #ifdef va_copy > va_copy (ap, args); > #else > - memcpy ((PTR) &ap, (PTR) &args, sizeof (va_list)); > + memcpy ((void *) &ap, (void *) &args, sizeof (va_list)); > #endif > > while (*p != '\0') > diff --git a/libiberty/xatexit.c b/libiberty/xatexit.c > index 6fdad9ed806..8a985cab4bc 100644 > --- a/libiberty/xatexit.c > +++ b/libiberty/xatexit.c > @@ -37,7 +37,7 @@ failure. If you use @code{xatexit} to register functions, > you must use > #include <unixlib.h> > #else > /* For systems with larger pointers than ints, this must be declared. */ > -PTR malloc (size_t); > +void *malloc (size_t); > #endif > > static void xatexit_cleanup (void); > diff --git a/libiberty/xmalloc.c b/libiberty/xmalloc.c > index e7d52683d35..252899b3931 100644 > --- a/libiberty/xmalloc.c > +++ b/libiberty/xmalloc.c > @@ -139,10 +139,9 @@ xmalloc_failed (size_t size) > xexit (1); > } > > -PTR > -xmalloc (size_t size) > +void *xmalloc (size_t size) > { > - PTR newmem; > + void *newmem; > > if (size == 0) > size = 1; > @@ -153,10 +152,9 @@ xmalloc (size_t size) > return (newmem); > } > > -PTR > -xcalloc (size_t nelem, size_t elsize) > +void *xcalloc (size_t nelem, size_t elsize) > { > - PTR newmem; > + void *newmem; > > if (nelem == 0 || elsize == 0) > nelem = elsize = 1; > @@ -168,10 +166,9 @@ xcalloc (size_t nelem, size_t elsize) > return (newmem); > } > > -PTR > -xrealloc (PTR oldmem, size_t size) > +void *xrealloc (void *oldmem, size_t size) > { > - PTR newmem; > + void *newmem; > > if (size == 0) > size = 1; > diff --git a/libiberty/xmemdup.c b/libiberty/xmemdup.c > index 4602afd7d9f..0cd3a24095e 100644 > --- a/libiberty/xmemdup.c > +++ b/libiberty/xmemdup.c > @@ -31,11 +31,10 @@ allocated, the remaining memory is zeroed. > # endif > #endif > > -PTR > -xmemdup (const PTR input, size_t copy_size, size_t alloc_size) > +void *xmemdup (const void *input, size_t copy_size, size_t alloc_size) > { > - PTR output = xmalloc (alloc_size); > + void *output = xmalloc (alloc_size); > if (alloc_size > copy_size) > memset ((char *) output + copy_size, 0, alloc_size - copy_size); > - return (PTR) memcpy (output, input, copy_size); > + return (void *) memcpy (output, input, copy_size); > } > -- > 2.36.0 >