-/* ANSI and traditional C compatability macros
+/* Compiler compatibility macros
Copyright (C) 1991-2022 Free Software Foundation, Inc.
This file is part of the GNU C Library.
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
-/* ANSI and traditional C compatibility macros
-
- ANSI C is assumed if __STDC__ is #defined.
-
- Macro ANSI C definition Traditional C definition
- ----- ---- - ---------- ----------- - ----------
- PTR `void *' `char *'
- const not defined `'
- volatile not defined `'
- signed not defined `'
-
- For ease of writing code which uses GCC extensions but needs to be
+/* For ease of writing code which uses GCC extensions but needs to be
portable to other compilers, we provide the GCC_VERSION macro that
simplifies testing __GNUC__ and __GNUC_MINOR__ together, and various
wrappers around __attribute__. Also, __extension__ will be #defined
#define GCC_VERSION (__GNUC__ * 1000 + __GNUC_MINOR__)
#endif /* GCC_VERSION */
-/* All known AIX compilers implement these things (but don't always
- define __STDC__). The RISC/OS MIPS compiler defines these things
- in SVR4 mode, but does not define __STDC__. */
-/* eraxxon@alumni.rice.edu: The Compaq C++ compiler, unlike many other
- C++ compilers, does not define __STDC__, though it acts as if this
- was so. (Verified versions: 5.7, 6.2, 6.3, 6.5) */
-
-#define PTR void *
-
-#undef const
-#undef volatile
-#undef signed
-
/* inline requires special treatment; it's in C99, and GCC >=2.7 supports
it too, but it's not in C89. */
#undef inline
/* Is the format actually the sum of two smaller floating point
formats (IBM long double, as described in
- gcc/config/rs6000/darwin-ldouble-format)? If so, this is the
+ libgcc/config/rs6000/ibm-ldouble-format)? If so, this is the
smaller format in question, and the fields sign_start through
intbit describe the first half. If not, this is NULL. */
const struct floatformat *split_half;
#ifndef _MD5_H
#define _MD5_H 1
+#ifdef USE_SYSTEM_MD5
+#include_next <md5.h>
+#else
+
#include <stdio.h>
#if defined HAVE_LIMITS_H || _LIBC
}
#endif
+#endif // USE_SYSTEM_MD5
+
#endif
/* @undocumented C_alloca */
-PTR
+void *
C_alloca (size_t size)
{
auto char probe; /* Probes stack depth: */
{
register header *np = hp->h.next;
- free ((PTR) hp); /* Collect garbage. */
+ free ((void *) hp); /* Collect garbage. */
hp = np; /* -> next header. */
}
/* User storage begins just after header. */
- return (PTR) ((char *) new_storage + sizeof (header));
+ return (void *) ((char *) new_storage + sizeof (header));
}
}
#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
+void *
calloc (size_t nelem, size_t elsize)
{
- register PTR ptr;
+ register void *ptr;
if (nelem == 0 || elsize == 0)
nelem = elsize = 1;
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
/* 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;
}
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)
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)
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;
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)
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)
(*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)
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;
}
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)
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;
}
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;
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;
}
/* 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);
/* 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));
}
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)
/* 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);
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));
}
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)
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)
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))
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)
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;
*/
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 */)
/* 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;
#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;
#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;
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;
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;
#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;
}
#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)
#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
if (ret == NULL)
return NULL;
- ret->chunks = (PTR) malloc (CHUNK_SIZE);
+ ret->chunks = (void *) malloc (CHUNK_SIZE);
if (ret->chunks == NULL)
{
free (ret);
/* Allocate space from an objalloc structure. */
-PTR
+void *
_objalloc_alloc (struct objalloc *o, unsigned long original_len)
{
unsigned long len = 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)
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
{
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);
}
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;
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;
q = next;
}
- o->chunks = (PTR) p;
+ o->chunks = (void *) p;
while (p->current_ptr != NULL)
p = p->next;
#define LONG_MAX ((long)(ULONG_MAX >> 1)) /* 0x7FFFFFFF for 32-bits*/
#ifdef __STDC__
-# define PTR void *
# ifndef NULL
# define NULL (void *) 0
# endif
#else
-# define PTR char *
# ifndef NULL
# define NULL (void *) 0
# endif
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;
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;
/* Rust symbols (v0) use only [_0-9a-zA-Z] characters. */
for (p = rdm.sym; *p; p++)
{
+ /* Rust v0 symbols can have '.' suffixes, ignore those. */
+ if (rdm.version == 0 && *p == '.')
+ break;
+
rdm.sym_len++;
if (*p == '_' || ISALNUM (*p))
continue;
- /* Legacy Rust symbols can also contain [.:$] characters. */
- if (rdm.version == -1 && (*p == '$' || *p == '.' || *p == ':'))
+ /* Legacy Rust symbols can also contain [.:$] characters.
+ Or @ in the .suffix (which will be skipped, see below). */
+ if (rdm.version == -1 && (*p == '$' || *p == '.' || *p == ':'
+ || *p == '@'))
continue;
return 0;
/* Legacy Rust symbols need to be handled separately. */
if (rdm.version == -1)
{
- /* Legacy Rust symbols always end with E. */
+ /* Legacy Rust symbols always end with E. But can be followed by a
+ .suffix (which we want to ignore). */
+ int dot_suffix = 1;
+ while (rdm.sym_len > 0 &&
+ !(dot_suffix && rdm.sym[rdm.sym_len - 1] == 'E'))
+ {
+ dot_suffix = rdm.sym[rdm.sym_len - 1] == '.';
+ rdm.sym_len--;
+ }
+
if (!(rdm.sym_len > 0 && rdm.sym[rdm.sym_len - 1] == 'E'))
return 0;
rdm.sym_len--;
not handle objects with more than SHN_LORESERVE sections
correctly. All large section indexes were offset by
0x100. There is more information at
- http://sourceware.org/bugzilla/show_bug.cgi?id-5900 .
+ https://sourceware.org/PR5900 .
Fortunately these object files are easy to detect, as the
GNU binutils always put the section header string table
near the end of the list of sections. Thus if the
{
sh_info = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
shdr, sh_info, Elf_Word);
- if (sh_info < SHN_LORESERVE
- || sh_info > SHN_HIRESERVE)
- sh_info = sh_map[sh_info];
+ sh_info = sh_map[sh_info];
ELF_SET_FIELD (type_functions, ei_class, Shdr,
shdr, sh_info, Elf_Word, sh_info);
}
sh_link = ELF_FETCH_FIELD (type_functions, ei_class, Shdr,
shdr, sh_link, Elf_Word);
- if (sh_link < SHN_LORESERVE
- || sh_link > SHN_HIRESERVE)
- sh_link = sh_map[sh_link];
+ sh_link = sh_map[sh_link];
ELF_SET_FIELD (type_functions, ei_class, Shdr,
shdr, sh_link, Elf_Word, sh_link);
}
#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 *
#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)
#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)
#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
#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)
#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
--format=auto
_RNvNvMCs4fqI2P2rA04_13const_genericINtB4_3FooKpE3foo3FOO
<const_generic::Foo<_>>::foo::FOO
+#
+# Suffixes
+#
+--format=rust
+_RNvMs0_NtCs5l0EXMQXRMU_21rustc_data_structures17obligation_forestINtB5_16ObligationForestNtNtNtCsdozMG8X9FIu_21rustc_trait_selection6traits7fulfill26PendingPredicateObligationE22register_obligation_atB1v_.llvm.8517020237817239694
+<rustc_data_structures::obligation_forest::ObligationForest<rustc_trait_selection::traits::fulfill::PendingPredicateObligation>>::register_obligation_at
+--format=rust
+_ZN4core3ptr85drop_in_place$LT$std..rt..lang_start$LT$$LP$$RP$$GT$..$u7b$$u7b$closure$u7d$$u7d$$GT$17h27f14859c664490dE.llvm.8091179795805947855
+core::ptr::drop_in_place<std::rt::lang_start<()>::{{closure}}>
+# old style rustc llvm thinlto
+--format=rust
+_ZN9backtrace3foo17hbb467fcdaea5d79bE.llvm.A5310EB9
+backtrace::foo
+--format=rust
+_ZN9backtrace3foo17hbb467fcdaea5d79bE.llvm.A5310EB9@@16
+backtrace::foo
+# new style rustc llvm thinlto
+--format=rust
+_RC3foo.llvm.9D1C9369
+foo
+--format=rust
+_RC3foo.llvm.9D1C9369@@16
+foo
+--format=rust
+_RNvC9backtrace3foo.llvm.A5310EB9
+backtrace::foo
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#else
-extern PTR malloc ();
+extern void *malloc ();
#endif
#include "libiberty.h"
#include "vprintf-support.h"
#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')
#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);
xexit (1);
}
-PTR
+void *
xmalloc (size_t size)
{
- PTR newmem;
+ void *newmem;
if (size == 0)
size = 1;
return (newmem);
}
-PTR
+void *
xcalloc (size_t nelem, size_t elsize)
{
- PTR newmem;
+ void *newmem;
if (nelem == 0 || elsize == 0)
nelem = elsize = 1;
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;
# 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);
}
projects / thirdparty / binutils-gdb.git / commitdiff
