struct gstr; /* forward */
void expr_gstr_print(struct expr *e, struct gstr *gs);
-static inline int expr_is_yes(struct expr *e)
+static __inline__ int expr_is_yes(struct expr *e)
{
return !e || (e->type == E_SYMBOL && e->left.sym == &symbol_yes);
}
-static inline int expr_is_no(struct expr *e)
+static __inline__ int expr_is_no(struct expr *e)
{
return e && (e->type == E_SYMBOL && e->left.sym == &symbol_no);
}
struct symbol *prop_get_symbol(struct property *prop);
struct property *sym_get_env_prop(struct symbol *sym);
-static inline tristate sym_get_tristate_value(struct symbol *sym)
+static __inline__ tristate sym_get_tristate_value(struct symbol *sym)
{
return sym->curr.tri;
}
-static inline struct symbol *sym_get_choice_value(struct symbol *sym)
+static __inline__ struct symbol *sym_get_choice_value(struct symbol *sym)
{
return (struct symbol *)sym->curr.val;
}
-static inline bool sym_set_choice_value(struct symbol *ch, struct symbol *chval)
+static __inline__ bool sym_set_choice_value(struct symbol *ch, struct symbol *chval)
{
return sym_set_tristate_value(chval, yes);
}
-static inline bool sym_is_choice(struct symbol *sym)
+static __inline__ bool sym_is_choice(struct symbol *sym)
{
return sym->flags & SYMBOL_CHOICE ? true : false;
}
-static inline bool sym_is_choice_value(struct symbol *sym)
+static __inline__ bool sym_is_choice_value(struct symbol *sym)
{
return sym->flags & SYMBOL_CHOICEVAL ? true : false;
}
-static inline bool sym_is_optional(struct symbol *sym)
+static __inline__ bool sym_is_optional(struct symbol *sym)
{
return sym->flags & SYMBOL_OPTIONAL ? true : false;
}
-static inline bool sym_has_value(struct symbol *sym)
+static __inline__ bool sym_has_value(struct symbol *sym)
{
return sym->flags & SYMBOL_DEF_USER ? true : false;
}
#else
/* On no-mmu systems you can't have real private mappings. */
-static inline int msync (void *__addr, size_t __len, int __flags) { return 0; }
+static __inline__ int msync (void *__addr, size_t __len, int __flags) { return 0; }
#endif
/* On no-mmu systems, memory cannot be swapped out, so
* these functions will always succeed. */
-static inline int mlock (__const void *__addr, size_t __len) { return 0; }
-static inline int munlock (__const void *__addr, size_t __len) { return 0; }
-static inline int mlockall (int __flags) { return 0; }
-static inline int munlockall (void) { return 0; }
+static __inline__ int mlock (__const void *__addr, size_t __len) { return 0; }
+static __inline__ int munlock (__const void *__addr, size_t __len) { return 0; }
+static __inline__ int mlockall (int __flags) { return 0; }
+static __inline__ int munlockall (void) { return 0; }
#endif
#endif /* __UCLIBC_HAS_REALTIME__ */
extern int _dl_map_cache(void);
extern int _dl_unmap_cache(void);
#else
-static inline void _dl_map_cache(void) { }
-static inline void _dl_unmap_cache(void) { }
+static __inline__ void _dl_map_cache(void) { }
+static __inline__ void _dl_unmap_cache(void) { }
#endif
extern char * _dl_library_path;
extern char * _dl_not_lazy;
-static inline int _dl_symbol(char * name)
+static __inline__ int _dl_symbol(char * name)
{
if (name[0] != '_' || name[1] != 'd' || name[2] != 'l' || name[3] != '_')
return 0;
#ifdef __UCLIBC_HAS_SSP__
# include <sys/time.h>
# define __NR__dl_gettimeofday __NR_gettimeofday
-static inline _syscall2(int, _dl_gettimeofday, struct timeval *, tv,
+static __inline__ _syscall2(int, _dl_gettimeofday, struct timeval *, tv,
# ifdef __USE_BSD
struct timezone *, tz);
# else
GOT_BASE[1] = (unsigned long) MODULE; \
}
-static inline unsigned long arm_modulus(unsigned long m, unsigned long p)
+static __inline__ unsigned long arm_modulus(unsigned long m, unsigned long p)
{
unsigned long i,t,inc;
i=p; t=0;
first element of the GOT. We used to use the PIC register to do this
without a constant pool reference, but GCC 4.2 will use a pseudo-register
for the PIC base, so it may not be in r10. */
-static inline Elf32_Addr __attribute__ ((unused))
+static __inline__ Elf32_Addr __attribute__ ((unused))
elf_machine_dynamic (void)
{
Elf32_Addr dynamic;
}
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr __attribute__ ((unused))
+static __inline__ Elf32_Addr __attribute__ ((unused))
elf_machine_load_address (void)
{
extern void __dl_start __asm__ ("_dl_start");
return pcrel_addr - got_addr;
}
-static inline void
+static __inline__ void
elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
#if DYNAMIC_LOADER_IN_SIMULATOR
#define __NR___syscall_mmap2 __NR_mmap2
-static inline _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
+static __inline__ _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
size_t, len, int, prot, int, flags, int, fd, off_t, offset);
/* Make sure we don't get another definition of _dl_mmap from the
#endif
#include <elf.h>
-static inline void
+static __inline__ void
elf_machine_relative (DL_LOADADDR_TYPE load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
|| ((type) == R_CRIS_GLOB_DAT)) * ELF_RTYPE_CLASS_PLT) \
| (((type) == R_CRIS_COPY) * ELF_RTYPE_CLASS_COPY))
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_dynamic(void)
{
/* Don't just set this to an asm variable "r0" since that's not logical
there's some other symbol we could use, that we don't *have* to force a
GOT entry for. */
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_load_address(void)
{
Elf32_Addr gotaddr_diff;
return gotaddr_diff;
}
-static inline void
+static __inline__ void
elf_machine_relative(Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
/* This is the new hash function that is used by the ELF linker to generate the
* GNU hash table that each executable and library will have if --hash-style=[gnu,both]
* is passed to the linker. We need it to decode the GNU hash table. */
-static inline Elf_Symndx _dl_gnu_hash (const unsigned char *name)
+static __inline__ Elf_Symndx _dl_gnu_hash (const unsigned char *name)
{
unsigned long h = 5381;
unsigned char c;
/* This is the hash function that is used by the ELF linker to generate the
* hash table that each executable and library is required to have. We need
* it to decode the hash table. */
-static inline Elf_Symndx _dl_elf_hash(const unsigned char *name)
+static __inline__ Elf_Symndx _dl_elf_hash(const unsigned char *name)
{
unsigned long hash=0;
unsigned long tmp;
#if DYNAMIC_LOADER_IN_SIMULATOR
#define __NR___syscall_mmap2 __NR_mmap2
-static inline _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
+static __inline__ _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
size_t, len, int, prot, int, flags, int, fd, off_t, offset);
/* Make sure we don't get another definition of _dl_mmap from the
/* Return the link-time address of _DYNAMIC. Conveniently, this is the
first element of the GOT. This must be inlined in a function which
uses global data. */
-static inline Elf32_Addr elf_machine_dynamic (void) attribute_unused;
-static inline Elf32_Addr
+static __inline__ Elf32_Addr elf_machine_dynamic (void) attribute_unused;
+static __inline__ Elf32_Addr
elf_machine_dynamic (void)
{
register Elf32_Addr *got __asm__ ("%ebx");
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr elf_machine_load_address (void) attribute_unused;
-static inline Elf32_Addr
+static __inline__ Elf32_Addr elf_machine_load_address (void) attribute_unused;
+static __inline__ Elf32_Addr
elf_machine_load_address (void)
{
/* It doesn't matter what variable this is, the reference never makes
return addr;
}
-static inline void
+static __inline__ void
elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
/* Return the link-time address of _DYNAMIC. Conveniently, this is the
first element of the GOT. This must be inlined in a function which
uses global data. */
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_dynamic (void)
{
register Elf32_Addr *got __asm__ ("%a5");
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_load_address (void)
{
Elf32_Addr addr;
return addr;
}
-static inline void
+static __inline__ void
elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
#define OFFSET_GP_GOT 0x7ff0
-static inline ElfW(Addr) *
+static __inline__ ElfW(Addr) *
elf_mips_got_from_gpreg (ElfW(Addr) gpreg)
{
/* FIXME: the offset of gp from GOT may be system-dependent. */
/* Return the link-time address of _DYNAMIC. Conveniently, this is the
first element of the GOT. This must be inlined in a function which
uses global data. We assume its $gp points to the primary GOT. */
-static inline ElfW(Addr)
+static __inline__ ElfW(Addr)
elf_machine_dynamic (void)
{
register ElfW(Addr) gp __asm__ ("$28");
#endif
/* Return the run-time load address of the shared object. */
-static inline ElfW(Addr)
+static __inline__ ElfW(Addr)
elf_machine_load_address (void)
{
ElfW(Addr) addr;
return addr;
}
-static inline void
+static __inline__ void
elf_machine_relative (ElfW(Addr) load_off, const ElfW(Addr) rel_addr,
ElfW(Word) relative_count)
{
#define ELF_MACHINE_PLTREL_OVERLAP 1
/* Return the value of the GOT pointer. */
-static inline Elf32_Addr * __attribute__ ((const))
+static __inline__ Elf32_Addr * __attribute__ ((const))
ppc_got (void)
{
Elf32_Addr *got;
/* Return the link-time address of _DYNAMIC, stored as
the first value in the GOT. */
-static inline Elf32_Addr __attribute__ ((const))
+static __inline__ Elf32_Addr __attribute__ ((const))
elf_machine_dynamic (void)
{
return *ppc_got();
}
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr __attribute__ ((const))
+static __inline__ Elf32_Addr __attribute__ ((const))
elf_machine_load_address (void)
{
Elf32_Addr *branchaddr;
return runtime_dynamic - elf_machine_dynamic ();
}
-static inline void
+static __inline__ void
elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
return finaladdr;
}
-static inline int
+static __inline__ int
_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
{
PPC_ISYNC;
}
-static inline int
+static __inline__ int
_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
unsigned long rel_addr, unsigned long rel_size,
int (*reloc_fnc) (struct elf_resolve *tpnt, struct dyn_elf *scope,
struct elf_resolve;
extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
-static inline unsigned int
+static __inline__ unsigned int
_dl_urem(unsigned int n, unsigned int base)
{
int res;
/* Return the link-time address of _DYNAMIC. Conveniently, this is the
first element of the GOT. This must be inlined in a function which
uses global data. */
-static inline Elf32_Addr __attribute__ ((unused))
+static __inline__ Elf32_Addr __attribute__ ((unused))
elf_machine_dynamic (void)
{
register Elf32_Addr *got;
}
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr __attribute__ ((unused))
+static __inline__ Elf32_Addr __attribute__ ((unused))
elf_machine_load_address (void)
{
Elf32_Addr addr;
} \
}
-static inline void
+static __inline__ void
elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
/* Return the link-time address of _DYNAMIC. Conveniently, this is the
first element of the GOT. This must be inlined in a function which
uses global data. */
-static inline Elf32_Addr elf_machine_dynamic(void)
+static __inline__ Elf32_Addr elf_machine_dynamic(void)
{
register Elf32_Addr *got;
}
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr elf_machine_load_address(void)
+static __inline__ Elf32_Addr elf_machine_load_address(void)
{
Elf32_Addr addr;
} \
}
-static inline void
+static __inline__ void
elf_machine_relative(Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
#ifndef COMPILE_ASM
/* Cheap modulo implementation, taken from arm/ld_sysdep.h. */
-static inline unsigned long
+static __inline__ unsigned long
sparc_mod(unsigned long m, unsigned long p)
{
unsigned long i, t, inc;
/* Return the link-time address of _DYNAMIC. Conveniently, this is the
first element of the GOT. This must be inlined in a function which
uses global data. */
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_dynamic (void)
{
register Elf32_Addr *got __asm__ ("%l7");
}
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_load_address (void)
{
register Elf32_Addr *pc __asm__ ("%o7"), *got __asm ("%l7");
return (Elf32_Addr) got - *got + (pc[2] - pc[3]) * 4 - 4;
}
-static inline void
+static __inline__ void
elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
(((type) == R_XTENSA_JMP_SLOT) * ELF_RTYPE_CLASS_PLT)
/* Return the link-time address of _DYNAMIC. */
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_dynamic (void)
{
/* This function is only used while bootstrapping the runtime linker.
}
/* Return the run-time load address of the shared object. */
-static inline Elf32_Addr
+static __inline__ Elf32_Addr
elf_machine_load_address (void)
{
Elf32_Addr addr, tmp;
return addr - 3;
}
-static inline void
+static __inline__ void
elf_machine_relative (Elf32_Addr load_off, const Elf32_Addr rel_addr,
Elf32_Word relative_count)
{
}
-static inline int
+static __inline__ int
add_object (struct ftw_data *data, struct STAT *st)
{
struct known_object *newp = malloc (sizeof (struct known_object));
}
-static inline int
+static __inline__ int
find_object (struct ftw_data *data, struct STAT *st)
{
struct known_object obj;
}
-static inline int
+static __inline__ int
__attribute ((always_inline))
open_dir_stream (struct ftw_data *data, struct dir_data *dirp)
{
strong_alias(__re_compile_fastmap, re_compile_fastmap)
#endif
-static inline void
+static __inline__ void
__attribute ((always_inline))
re_set_fastmap (char *fastmap, int icase, int ch)
{
Seek the collating symbol entry correspondings to NAME.
Return the index of the symbol in the SYMB_TABLE. */
- auto inline int32_t
+ auto __inline__ int32_t
__attribute ((always_inline))
seek_collating_symbol_entry (name, name_len)
const unsigned char *name;
Look up the collation sequence value of BR_ELEM.
Return the value if succeeded, UINT_MAX otherwise. */
- auto inline unsigned int
+ auto __inline__ unsigned int
__attribute ((always_inline))
lookup_collation_sequence_value (br_elem)
bracket_elem_t *br_elem;
mbcset->range_ends, is a pointer argument sinse we may
update it. */
- auto inline reg_errcode_t
+ auto __inline__ reg_errcode_t
__attribute ((always_inline))
build_range_exp (sbcset, mbcset, range_alloc, start_elem, end_elem)
re_charset_t *mbcset;
COLL_SYM_ALLOC is the allocated size of mbcset->coll_sym, is a
pointer argument sinse we may update it. */
- auto inline reg_errcode_t
+ auto __inline__ reg_errcode_t
__attribute ((always_inline))
build_collating_symbol (sbcset, mbcset, coll_sym_alloc, name)
re_charset_t *mbcset;
return dfa->nodes_len++;
}
-static inline unsigned int
+static __inline__ unsigned int
internal_function
calc_state_hash (const re_node_set *nodes, unsigned int context)
{
/* Inline functions for bitset operation. */
-static inline void
+static __inline__ void
bitset_not (bitset_t set)
{
int bitset_i;
set[bitset_i] = ~set[bitset_i];
}
-static inline void
+static __inline__ void
bitset_merge (bitset_t dest, const bitset_t src)
{
int bitset_i;
dest[bitset_i] |= src[bitset_i];
}
-static inline void
+static __inline__ void
bitset_mask (bitset_t dest, const bitset_t src)
{
int bitset_i;
#ifdef RE_ENABLE_I18N
/* Inline functions for re_string. */
-static inline int
+static __inline__ int
internal_function __attribute ((pure))
re_string_char_size_at (const re_string_t *pstr, int idx)
{
return byte_idx;
}
-static inline wint_t
+static __inline__ wint_t
internal_function __attribute ((pure))
re_string_wchar_at (const re_string_t *pstr, int idx)
{
We must select appropriate initial state depending on the context,
since initial states may have constraints like "\<", "^", etc.. */
-static inline re_dfastate_t *
+static __inline__ re_dfastate_t *
__attribute ((always_inline)) internal_function
acquire_init_state_context (reg_errcode_t *err, const re_match_context_t *mctx,
int idx)
#ifdef __NR_msgctl
#define __NR___libc_msgctl __NR_msgctl
-static inline _syscall3(int, __libc_msgctl, int, msqid, int, cmd, struct msqid_ds *, buf);
+static __inline__ _syscall3(int, __libc_msgctl, int, msqid, int, cmd, struct msqid_ds *, buf);
#endif
/* Message queue control operation. */
int msgctl(int msqid, int cmd, struct msqid_ds *buf)
#ifdef __NR_semctl
#define __NR___semctl __NR_semctl
-static inline _syscall4(int, __semctl, int, semid, int, semnum, int, cmd, void *, arg);
+static __inline__ _syscall4(int, __semctl, int, semid, int, semnum, int, cmd, void *, arg);
#endif
int semctl(int semid, int semnum, int cmd, ...)
/* Provide operations to control over shared memory segments. */
#ifdef __NR_shmctl
#define __NR___libc_shmctl __NR_shmctl
-static inline _syscall3(int, __libc_shmctl, int, shmid, int, cmd, struct shmid_ds *, buf);
+static __inline__ _syscall3(int, __libc_shmctl, int, shmid, int, cmd, struct shmid_ds *, buf);
#endif
int shmctl(int shmid, int cmd, struct shmid_ds *buf)
{
#define W_CHUNK (100)
/* Result of w_newword will be ignored if it's the last word. */
-static inline char *w_newword(size_t * actlen, size_t * maxlen)
+static __inline__ char *w_newword(size_t * actlen, size_t * maxlen)
{
*actlen = *maxlen = 0;
return NULL;
}
/* Add a character to the buffer, allocating room for it if needed. */
-static inline char *w_addchar(char *buffer, size_t * actlen,
+static __inline__ char *w_addchar(char *buffer, size_t * actlen,
size_t * maxlen, char ch)
/* (lengths exclude trailing zero) */
{
return error;
}
#else
-static inline int
+static __inline__ int
parse_backtick(char **word, size_t * word_length, size_t * max_length,
const char *words, size_t * offset, int flags,
wordexp_t * pwordexp, const char *ifs,
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
-static inline int __attribute__ ((unused))
+static __inline__ int __attribute__ ((unused))
sigset_set_old_mask (sigset_t *set, int mask)
{
unsigned long int *ptr;
return 0;
}
-static inline int __attribute__ ((unused))
+static __inline__ int __attribute__ ((unused))
sigset_get_old_mask (const sigset_t *set)
{
return (unsigned int) set->__val[0];
static int rs_initialized;
static struct arc4_stream rs;
-static inline void arc4_init(struct arc4_stream *);
-static inline void arc4_addrandom(struct arc4_stream *, u_char *, int);
+static __inline__ void arc4_init(struct arc4_stream *);
+static __inline__ void arc4_addrandom(struct arc4_stream *, u_char *, int);
static void arc4_stir(struct arc4_stream *);
-static inline uint8_t arc4_getbyte(struct arc4_stream *);
-static inline uint32_t arc4_getword(struct arc4_stream *);
+static __inline__ uint8_t arc4_getbyte(struct arc4_stream *);
+static __inline__ uint32_t arc4_getword(struct arc4_stream *);
-static inline void
+static __inline__ void
arc4_init(as)
struct arc4_stream *as;
{
as->j = 0;
}
-static inline void
+static __inline__ void
arc4_addrandom(as, dat, datlen)
struct arc4_stream *as;
u_char *dat;
arc4_getbyte(as);
}
-static inline uint8_t
+static __inline__ uint8_t
arc4_getbyte(as)
struct arc4_stream *as;
{
return (as->s[(si + sj) & 0xff]);
}
-static inline uint32_t
+static __inline__ uint32_t
arc4_getword(as)
struct arc4_stream *as;
{
/* Delete the free-area FA from HEAP. */
-static inline void
+static __inline__ void
__heap_delete (struct heap *heap, struct heap_free_area *fa)
{
if (fa->next)
/* Link the free-area FA between the existing free-area's PREV and NEXT in
HEAP. PREV and NEXT may be 0; if PREV is 0, FA is installed as the
first free-area. */
-static inline void
+static __inline__ void
__heap_link_free_area (struct heap *heap, struct heap_free_area *fa,
struct heap_free_area *prev,
struct heap_free_area *next)
/* Update the mutual links between the free-areas PREV and FA in HEAP.
PREV may be 0, in which case FA is installed as the first free-area (but
FA may not be 0). */
-static inline void
+static __inline__ void
__heap_link_free_area_after (struct heap *heap,
struct heap_free_area *fa,
struct heap_free_area *prev)
free-area's PREV and NEXT in HEAP, and return a pointer to its header.
PREV and NEXT may be 0; if PREV is 0, MEM is installed as the first
free-area. */
-static inline struct heap_free_area *
+static __inline__ struct heap_free_area *
__heap_add_free_area (struct heap *heap, void *mem, size_t size,
struct heap_free_area *prev,
struct heap_free_area *next)
/* Allocate SIZE bytes from the front of the free-area FA in HEAP, and
return the amount actually allocated (which may be more than SIZE). */
-static inline size_t
+static __inline__ size_t
__heap_free_area_alloc (struct heap *heap,
struct heap_free_area *fa, size_t size)
{
/* Experimentally off - libc_hidden_proto(memset) */
-static inline int expand_byte_word(int c){
+static __inline__ int expand_byte_word(int c){
/* this does:
c = c << 8 | c;
c = c << 16 | c ;
/* When there is kernel support for more than 64 signals, we'll have to
switch to a new system call convention here. */
-static inline _syscall2(int, osf_sigprocmask, int, how, unsigned long int, setval);
+static __inline__ _syscall2(int, osf_sigprocmask, int, how, unsigned long int, setval);
libc_hidden_proto(sigprocmask)
int
libc_hidden_proto (mmap)
#if defined (__UCLIBC_MMAP_HAS_6_ARGS__) && defined (__NR_mmap)
#define __NR__mmap __NR_mmap
-static inline _syscall6 (__ptr_t, _mmap, __ptr_t, addr, size_t, len,
+static __inline__ _syscall6 (__ptr_t, _mmap, __ptr_t, addr, size_t, len,
int, prot, int, flags, int, fd, __off_t, offset);
__ptr_t mmap(__ptr_t addr, size_t len, int prot,
int flags, int fd, __off_t offset)
# define MMAP2_PAGE_SHIFT 12
#endif
-static inline _syscall6 (__ptr_t, _mmap, __ptr_t, addr, size_t, len,
+static __inline__ _syscall6 (__ptr_t, _mmap, __ptr_t, addr, size_t, len,
int, prot, int, flags, int, fd, __off_t, offset);
__ptr_t mmap(__ptr_t addr, size_t len, int prot,
int flags, int fd, __off_t offset)
}
#elif defined (__NR_mmap)
# define __NR__mmap __NR_mmap
-static inline _syscall1(__ptr_t, _mmap, unsigned long *, buffer);
+static __inline__ _syscall1(__ptr_t, _mmap, unsigned long *, buffer);
__ptr_t mmap(__ptr_t addr, size_t len, int prot,
int flags, int fd, __off_t offset)
{
libc_hidden_proto(__libc_fcntl64)
#define __NR___syscall_fcntl64 __NR_fcntl64
-static inline _syscall3(int, __syscall_fcntl64, int, fd, int, cmd, long, arg);
+static __inline__ _syscall3(int, __syscall_fcntl64, int, fd, int, cmd, long, arg);
int __libc_fcntl64(int fd, int cmd, ...)
{
long arg;
#ifndef INLINE_SYSCALL
#define INLINE_SYSCALL(name, nr, args...) __syscall_exit (args)
#define __NR___syscall_exit __NR_exit
-static inline _syscall1(void, __syscall_exit, int, status);
+static __inline__ _syscall1(void, __syscall_exit, int, status);
#endif
void attribute_noreturn _exit(int status)
libc_hidden_proto(chdir)
#define __NR___syscall_chdir __NR_chdir
-static inline _syscall1(int, __syscall_chdir, const char *, path);
+static __inline__ _syscall1(int, __syscall_chdir, const char *, path);
int chdir(const char *path)
{
return __syscall_chdir(path);
libc_hidden_proto(chmod)
#define __NR___syscall_chmod __NR_chmod
-static inline _syscall2(int, __syscall_chmod, const char *, path, __kernel_mode_t, mode);
+static __inline__ _syscall2(int, __syscall_chmod, const char *, path, __kernel_mode_t, mode);
int chmod(const char *path, mode_t mode)
{
#else
# define __NR___syscall_chown __NR_chown
-static inline _syscall3(int, __syscall_chown, const char *, path,
+static __inline__ _syscall3(int, __syscall_chown, const char *, path,
__kernel_uid_t, owner, __kernel_gid_t, group);
int chown(const char *path, uid_t owner, gid_t group)
#if defined __USE_BSD || (defined __USE_XOPEN && !defined __USE_XOPEN2K)
#define __NR___syscall_chroot __NR_chroot
-static inline _syscall1(int, __syscall_chroot, const char *, path);
+static __inline__ _syscall1(int, __syscall_chroot, const char *, path);
int chroot(const char *path)
{
#if defined(__UCLIBC_BROKEN_CREATE_MODULE__)
# define __NR___create_module __NR_create_module
-static inline _syscall2(long, __create_module, const char *, name, size_t, size);
+static __inline__ _syscall2(long, __create_module, const char *, name, size_t, size);
/* By checking the value of errno, we know if we have been fooled
* by the syscall2 macro making a very high address look like a
* negative, so we we fix it up here. */
# define __NR___create_module __NR_create_module
/* Alpha doesn't have the same problem, exactly, but a bug in older
kernels fails to clear the error flag. Clear it here explicitly. */
-static inline _syscall4(unsigned long, __create_module, const char *, name,
+static __inline__ _syscall4(unsigned long, __create_module, const char *, name,
size_t, size, size_t, dummy, size_t, err);
unsigned long create_module(const char *name, size_t size)
{
#include <sys/stat.h>
#define __NR___syscall_fchmod __NR_fchmod
-static inline _syscall2(int, __syscall_fchmod,
+static __inline__ _syscall2(int, __syscall_fchmod,
int, fildes, __kernel_mode_t, mode);
int fchmod(int fildes, mode_t mode)
#else
# define __NR___syscall_fchown __NR_fchown
-static inline _syscall3(int, __syscall_fchown, int, fd,
+static __inline__ _syscall3(int, __syscall_fchown, int, fd,
__kernel_uid_t, owner, __kernel_gid_t, group);
int fchown(int fd, uid_t owner, gid_t group)
#include <sys/file.h>
#define __NR___syscall_flock __NR_flock
-static inline _syscall2(int, __syscall_flock, int, fd, int, operation);
+static __inline__ _syscall2(int, __syscall_flock, int, fd, int, operation);
int flock(int fd, int operation)
{
libc_hidden_proto(fstat)
#define __NR___syscall_fstat __NR_fstat
-static inline _syscall2(int, __syscall_fstat, int, fd, struct kernel_stat *, buf);
+static __inline__ _syscall2(int, __syscall_fstat, int, fd, struct kernel_stat *, buf);
int fstat(int fd, struct stat *buf)
{
libc_hidden_proto(fstat64)
#define __NR___syscall_fstat64 __NR_fstat64
-static inline _syscall2(int, __syscall_fstat64,
+static __inline__ _syscall2(int, __syscall_fstat64,
int, filedes, struct kernel_stat64 *, buf);
int fstat64(int fd, struct stat64 *buf)
# define INLINE_SYSCALL(name, nr, args...) __syscall_ftruncate64 (args)
# define __NR___syscall_ftruncate64 __NR_ftruncate64
# if defined(__UCLIBC_TRUNCATE64_HAS_4_ARGS__)
-static inline _syscall4(int, __syscall_ftruncate64, int, fd, uint32_t, pad,
+static __inline__ _syscall4(int, __syscall_ftruncate64, int, fd, uint32_t, pad,
unsigned long, high_length, unsigned long, low_length);
# else
-static inline _syscall3(int, __syscall_ftruncate64, int, fd,
+static __inline__ _syscall3(int, __syscall_ftruncate64, int, fd,
unsigned long, high_length, unsigned long, low_length);
# endif
# endif
libc_hidden_proto(lseek)
#define __NR___syscall_getdents __NR_getdents
-static inline _syscall3(int, __syscall_getdents, int, fd, unsigned char *, kdirp, size_t, count);
+static __inline__ _syscall3(int, __syscall_getdents, int, fd, unsigned char *, kdirp, size_t, count);
ssize_t __getdents (int fd, char *buf, size_t nbytes)
{
# define __NR___syscall_getdents64 __NR_getdents64
-static inline _syscall3(int, __syscall_getdents64, int, fd, unsigned char *, dirp, size_t, count);
+static __inline__ _syscall3(int, __syscall_getdents64, int, fd, unsigned char *, dirp, size_t, count);
ssize_t __getdents64 (int fd, char *buf, size_t nbytes) attribute_hidden;
ssize_t __getdents64 (int fd, char *buf, size_t nbytes)
#elif defined(__NR_getegid)
# define __NR___syscall_getegid __NR_getegid
-static inline _syscall0(int, __syscall_getegid);
+static __inline__ _syscall0(int, __syscall_getegid);
gid_t getegid(void)
{
return (__syscall_getegid());
#elif defined(__NR_geteuid)
# define __NR___syscall_geteuid __NR_geteuid
-static inline _syscall0(int, __syscall_geteuid);
+static __inline__ _syscall0(int, __syscall_geteuid);
uid_t geteuid(void)
{
return (__syscall_geteuid());
#define MIN(a,b) (((a)<(b))?(a):(b))
#define __NR___syscall_getgroups __NR_getgroups
-static inline _syscall2(int, __syscall_getgroups,
+static __inline__ _syscall2(int, __syscall_getgroups,
int, size, __kernel_gid_t *, list);
int getgroups(int size, gid_t groups[])
#include <unistd.h>
#define __NR___syscall_getpgid __NR_getpgid
-static inline _syscall1(__kernel_pid_t, __syscall_getpgid, __kernel_pid_t, pid);
+static __inline__ _syscall1(__kernel_pid_t, __syscall_getpgid, __kernel_pid_t, pid);
pid_t getpgid(pid_t pid)
{
libc_hidden_proto(getpriority)
#define __NR___syscall_getpriority __NR_getpriority
-static inline _syscall2(int, __syscall_getpriority,
+static __inline__ _syscall2(int, __syscall_getpriority,
__priority_which_t, which, id_t, who);
/* The return value of __syscall_getpriority is biased by this value
#elif defined(__NR_getresgid)
# define __NR___syscall_getresgid __NR_getresgid
-static inline _syscall3(int, __syscall_getresgid, __kernel_gid_t *, rgid,
+static __inline__ _syscall3(int, __syscall_getresgid, __kernel_gid_t *, rgid,
__kernel_gid_t *, egid, __kernel_gid_t *, sgid);
int getresgid(gid_t * rgid, gid_t * egid, gid_t * sgid)
#elif defined(__NR_getresuid)
# define __NR___syscall_getresuid __NR_getresuid
-static inline _syscall3(int, __syscall_getresuid, __kernel_uid_t *, ruid,
+static __inline__ _syscall3(int, __syscall_getresuid, __kernel_uid_t *, ruid,
__kernel_uid_t *, euid, __kernel_uid_t *, suid);
int getresuid(uid_t * ruid, uid_t * euid, uid_t * suid)
libc_hidden_proto(getsid)
#define __NR___syscall_getsid __NR_getsid
-static inline _syscall1(__kernel_pid_t, __syscall_getsid, __kernel_pid_t, pid);
+static __inline__ _syscall1(__kernel_pid_t, __syscall_getsid, __kernel_pid_t, pid);
pid_t getsid(pid_t pid)
{
libc_hidden_proto(kill)
#define __NR___syscall_kill __NR_kill
-static inline _syscall2(int, __syscall_kill, __kernel_pid_t, pid, int, sig);
+static __inline__ _syscall2(int, __syscall_kill, __kernel_pid_t, pid, int, sig);
int kill(pid_t pid, int sig)
{
#include <unistd.h>
#include <sys/klog.h>
#define __NR__syslog __NR_syslog
-static inline _syscall3(int, _syslog, int, type, char *, buf, int, len);
+static __inline__ _syscall3(int, _syslog, int, type, char *, buf, int, len);
int klogctl(int type, char *buf, int len)
{
return (_syslog(type, buf, len));
#else
# define __NR___syscall_lchown __NR_lchown
-static inline _syscall3(int, __syscall_lchown, const char *, path,
+static __inline__ _syscall3(int, __syscall_lchown, const char *, path,
__kernel_uid_t, owner, __kernel_gid_t, group);
int lchown(const char *path, uid_t owner, gid_t group)
# ifndef INLINE_SYSCALL
# define INLINE_SYSCALL(name, nr, args...) __syscall_llseek (args)
# define __NR___syscall_llseek __NR__llseek
-static inline _syscall5(int, __syscall_llseek, int, fd, off_t, offset_hi,
+static __inline__ _syscall5(int, __syscall_llseek, int, fd, off_t, offset_hi,
off_t, offset_lo, loff_t *, result, int, whence);
# endif
libc_hidden_proto(lstat)
#define __NR___syscall_lstat __NR_lstat
-static inline _syscall2(int, __syscall_lstat,
+static __inline__ _syscall2(int, __syscall_lstat,
const char *, file_name, struct kernel_stat *, buf);
int lstat(const char *file_name, struct stat *buf)
libc_hidden_proto(lstat64)
# define __NR___syscall_lstat64 __NR_lstat64
-static inline _syscall2(int, __syscall_lstat64, const char *, file_name,
+static __inline__ _syscall2(int, __syscall_lstat64, const char *, file_name,
struct kernel_stat64 *, buf);
int lstat64(const char *file_name, struct stat64 *buf)
libc_hidden_proto(mkdir)
#define __NR___syscall_mkdir __NR_mkdir
-static inline _syscall2(int, __syscall_mkdir, const char *, pathname,
+static __inline__ _syscall2(int, __syscall_mkdir, const char *, pathname,
__kernel_mode_t, mode);
int mkdir(const char *pathname, mode_t mode)
libc_hidden_proto(mknod)
#define __NR___syscall_mknod __NR_mknod
-static inline _syscall3(int, __syscall_mknod, const char *, path,
+static __inline__ _syscall3(int, __syscall_mknod, const char *, path,
__kernel_mode_t, mode, __kernel_dev_t, dev);
int mknod(const char *path, mode_t mode, dev_t dev)
#else
# define __NR__mmap __NR_mmap
-static inline _syscall1(__ptr_t, _mmap, unsigned long *, buffer);
+static __inline__ _syscall1(__ptr_t, _mmap, unsigned long *, buffer);
__ptr_t mmap(__ptr_t addr, size_t len, int prot,
int flags, int fd, __off_t offset)
{
libc_hidden_proto(mmap)
#define __NR___syscall_mmap2 __NR_mmap2
-static inline _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
+static __inline__ _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
size_t, len, int, prot, int, flags, int, fd, off_t, offset);
/* Some architectures always use 12 as page shift for mmap2() eventhough the
# else
# define __NR___syscall_mmap2 __NR_mmap2
-static inline _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr, size_t, len,
+static __inline__ _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr, size_t, len,
int, prot, int, flags, int, fd, off_t, offset);
/* Some architectures always use 12 as page shift for mmap2() eventhough the
#ifdef __NR_nice
# define __NR___syscall_nice __NR_nice
-static inline _syscall1(int, __syscall_nice, int, incr);
+static __inline__ _syscall1(int, __syscall_nice, int, incr);
#else
libc_hidden_proto(setpriority)
-static inline int int_add_no_wrap(int a, int b)
+static __inline__ int int_add_no_wrap(int a, int b)
{
int s = a + b;
return s;
}
-static inline int __syscall_nice(int incr)
+static __inline__ int __syscall_nice(int incr)
{
int old_priority;
# if 1
extern __typeof(creat) __libc_creat;
#define __NR___syscall_open __NR_open
-static inline _syscall3(int, __syscall_open, const char *, file,
+static __inline__ _syscall3(int, __syscall_open, const char *, file,
int, flags, __kernel_mode_t, mode);
libc_hidden_proto(__libc_open)
#ifdef _syscall6 /* workaround until everyone has _syscall6() */
#define __NR___syscall_fadvise64_64 __NR_fadvise64_64
-static inline _syscall6(int, __syscall_fadvise64_64, int, fd,
+static __inline__ _syscall6(int, __syscall_fadvise64_64, int, fd,
unsigned long, high_offset, unsigned long, low_offset,
unsigned long, high_len, unsigned long, low_len,
int, advice);
#ifdef __NR_pread
# define __NR___syscall_pread __NR_pread
-static inline _syscall5(ssize_t, __syscall_pread, int, fd, void *, buf,
+static __inline__ _syscall5(ssize_t, __syscall_pread, int, fd, void *, buf,
size_t, count, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pread(int fd, void *buf, size_t count, off_t offset)
#ifdef __NR_pwrite
# define __NR___syscall_pwrite __NR_pwrite
-static inline _syscall5(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
+static __inline__ _syscall5(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
size_t, count, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pwrite(int fd, const void *buf, size_t count, off_t offset)
#if defined __NR_ptrace && defined __USE_BSD && defined __USE_MISC
#define __NR___syscall_ptrace __NR_ptrace
-static inline _syscall4(long, __syscall_ptrace, enum __ptrace_request, request,
+static __inline__ _syscall4(long, __syscall_ptrace, enum __ptrace_request, request,
__kernel_pid_t, pid, void*, addr, void*, data);
long int
# if __WORDSIZE == 64
-static inline _syscall3(ssize_t, __readahead, int, fd,
+static __inline__ _syscall3(ssize_t, __readahead, int, fd,
off_t, offset, size_t, count);
ssize_t readahead(int fd, off_t offset, size_t count)
# else
-static inline _syscall4(ssize_t, __readahead, int, fd,
+static __inline__ _syscall4(ssize_t, __readahead, int, fd,
off_t, high_offset, off_t, low_offset, size_t, count);
ssize_t readahead(int fd, off64_t offset, size_t count)
#include <sys/syscall.h>
#include <sys/reboot.h>
#define __NR__reboot __NR_reboot
-static inline _syscall3(int, _reboot, int, magic, int, magic2, int, flag);
+static __inline__ _syscall3(int, _reboot, int, magic, int, magic2, int, flag);
int reboot(int flag)
{
return (_reboot((int) 0xfee1dead, 672274793, flag));
#include <stdio.h>
#define __NR___syscall_rename __NR_rename
-static inline _syscall2(int, __syscall_rename, const char *, oldpath,
+static __inline__ _syscall2(int, __syscall_rename, const char *, oldpath,
const char *, newpath);
int rename(const char * oldpath, const char * newpath)
/* Experimentally off - libc_hidden_proto(memset) */
#define __NR___syscall_sched_getaffinity __NR_sched_getaffinity
-static inline _syscall3(int, __syscall_sched_getaffinity, __kernel_pid_t, pid,
+static __inline__ _syscall3(int, __syscall_sched_getaffinity, __kernel_pid_t, pid,
size_t, cpusetsize, cpu_set_t *, cpuset);
int sched_getaffinity(pid_t pid, size_t cpusetsize, cpu_set_t *cpuset)
#include <sys/syscall.h>
#define __NR___syscall_sched_getparam __NR_sched_getparam
-static inline _syscall2(int, __syscall_sched_getparam,
+static __inline__ _syscall2(int, __syscall_sched_getparam,
__kernel_pid_t, pid, struct sched_param *, p);
int sched_getparam(pid_t pid, struct sched_param *p)
#include <sys/syscall.h>
#define __NR___syscall_sched_getscheduler __NR_sched_getscheduler
-static inline _syscall1(int, __syscall_sched_getscheduler, __kernel_pid_t, pid);
+static __inline__ _syscall1(int, __syscall_sched_getscheduler, __kernel_pid_t, pid);
int sched_getscheduler(pid_t pid)
{
#include <sys/syscall.h>
#define __NR___syscall_sched_rr_get_interval __NR_sched_rr_get_interval
-static inline _syscall2(int, __syscall_sched_rr_get_interval,
+static __inline__ _syscall2(int, __syscall_sched_rr_get_interval,
__kernel_pid_t, pid, struct timespec *, tp);
int sched_rr_get_interval(pid_t pid, struct timespec *tp)
libc_hidden_proto(getpid)
#define __NR___syscall_sched_setaffinity __NR_sched_setaffinity
-static inline _syscall3(int, __syscall_sched_setaffinity, __kernel_pid_t, pid,
+static __inline__ _syscall3(int, __syscall_sched_setaffinity, __kernel_pid_t, pid,
size_t, cpusetsize, cpu_set_t *, cpuset);
static size_t __kernel_cpumask_size;
#include <sys/syscall.h>
#define __NR___syscall_sched_setparam __NR_sched_setparam
-static inline _syscall2(int, __syscall_sched_setparam,
+static __inline__ _syscall2(int, __syscall_sched_setparam,
__kernel_pid_t, pid, const struct sched_param *, p);
int sched_setparam(pid_t pid, const struct sched_param *p)
#include <sys/syscall.h>
#define __NR___syscall_sched_setscheduler __NR_sched_setscheduler
-static inline _syscall3(int, __syscall_sched_setscheduler,
+static __inline__ _syscall3(int, __syscall_sched_setscheduler,
__kernel_pid_t, pid, int, policy, const struct sched_param *, p);
int sched_setscheduler(pid_t pid, int policy, const struct sched_param *p)
#else
# define __NR___syscall_setfsgid __NR_setfsgid
-static inline _syscall1(int, __syscall_setfsgid, __kernel_gid_t, gid);
+static __inline__ _syscall1(int, __syscall_setfsgid, __kernel_gid_t, gid);
int setfsgid(gid_t gid)
{
#else
# define __NR___syscall_setfsuid __NR_setfsuid
-static inline _syscall1(int, __syscall_setfsuid, __kernel_uid_t, uid);
+static __inline__ _syscall1(int, __syscall_setfsuid, __kernel_uid_t, uid);
int setfsuid(uid_t uid)
{
#else
# define __NR___syscall_setgid __NR_setgid
-static inline _syscall1(int, __syscall_setgid, __kernel_gid_t, gid);
+static __inline__ _syscall1(int, __syscall_setgid, __kernel_gid_t, gid);
int setgid(gid_t gid)
{
libc_hidden_proto(sysconf)
#define __NR___syscall_setgroups __NR_setgroups
-static inline _syscall2(int, __syscall_setgroups,
+static __inline__ _syscall2(int, __syscall_setgroups,
size_t, size, const __kernel_gid_t *, list);
int setgroups(size_t size, const gid_t *groups)
libc_hidden_proto(setpgid)
#define __NR___syscall_setpgid __NR_setpgid
-static inline _syscall2(int, __syscall_setpgid,
+static __inline__ _syscall2(int, __syscall_setpgid,
__kernel_pid_t, pid, __kernel_pid_t, pgid);
int setpgid(pid_t pid, pid_t pgid)
#else
# define __NR___syscall_setregid __NR_setregid
-static inline _syscall2(int, __syscall_setregid,
+static __inline__ _syscall2(int, __syscall_setregid,
__kernel_gid_t, rgid, __kernel_gid_t, egid);
int setregid(gid_t rgid, gid_t egid)
#elif defined(__NR_setresgid)
# define __NR___syscall_setresgid __NR_setresgid
-static inline _syscall3(int, __syscall_setresgid,
+static __inline__ _syscall3(int, __syscall_setresgid,
__kernel_gid_t, rgid, __kernel_gid_t, egid, __kernel_gid_t, sgid);
libc_hidden_proto(setresgid)
#elif defined(__NR_setresuid)
# define __NR___syscall_setresuid __NR_setresuid
-static inline _syscall3(int, __syscall_setresuid,
+static __inline__ _syscall3(int, __syscall_setresuid,
__kernel_uid_t, rgid, __kernel_uid_t, egid, __kernel_uid_t, sgid);
libc_hidden_proto(setresuid)
#else
# define __NR___syscall_setreuid __NR_setreuid
-static inline _syscall2(int, __syscall_setreuid,
+static __inline__ _syscall2(int, __syscall_setreuid,
__kernel_uid_t, ruid, __kernel_uid_t, euid);
int setreuid(uid_t ruid, uid_t euid)
#else
# define __NR___syscall_setuid __NR_setuid
-static inline _syscall1(int, __syscall_setuid, __kernel_uid_t, uid);
+static __inline__ _syscall1(int, __syscall_setuid, __kernel_uid_t, uid);
int setuid(uid_t uid)
{
#ifdef __NR_rt_sigpending
# define __NR___rt_sigpending __NR_rt_sigpending
-static inline _syscall2(int, __rt_sigpending, sigset_t *, set, size_t, size);
+static __inline__ _syscall2(int, __rt_sigpending, sigset_t *, set, size_t, size);
int sigpending(sigset_t * set)
{
#ifdef __NR_rt_sigqueueinfo
# define __NR___libc_rt_sigqueueinfo __NR_rt_sigqueueinfo
-static inline _syscall3(int, __libc_rt_sigqueueinfo, pid_t, pid, int, sig, void*, value);
+static __inline__ _syscall3(int, __libc_rt_sigqueueinfo, pid_t, pid, int, sig, void*, value);
/* Return any pending signal or wait for one for the given time. */
int sigqueue (pid_t pid, int sig, const union sigval val)
#ifdef __NR_rt_sigsuspend
# define __NR___rt_sigsuspend __NR_rt_sigsuspend
-static inline _syscall2(int, __rt_sigsuspend, const sigset_t *, mask, size_t, size);
+static __inline__ _syscall2(int, __rt_sigsuspend, const sigset_t *, mask, size_t, size);
int __libc_sigsuspend(const sigset_t * mask)
{
}
#else
# define __NR___syscall_sigsuspend __NR_sigsuspend
-static inline _syscall3(int, __syscall_sigsuspend, int, a, unsigned long int, b,
+static __inline__ _syscall3(int, __syscall_sigsuspend, int, a, unsigned long int, b,
unsigned long int, c);
int __libc_sigsuspend(const sigset_t * set)
#define __NR___syscall_stat __NR_stat
#undef stat
-static inline _syscall2(int, __syscall_stat,
+static __inline__ _syscall2(int, __syscall_stat,
const char *, file_name, struct kernel_stat *, buf);
int stat(const char *file_name, struct stat *buf)
# include <sys/stat.h>
# include "xstatconv.h"
-static inline _syscall2(int, __syscall_stat64,
+static __inline__ _syscall2(int, __syscall_stat64,
const char *, file_name, struct kernel_stat64 *, buf);
int stat64(const char *file_name, struct stat64 *buf)
#ifndef INLINE_SYSCALL
#define INLINE_SYSCALL(name, nr, args...) __syscall_sync (args)
#define __NR___syscall_sync __NR_sync
-static inline _syscall0(void, __syscall_sync);
+static __inline__ _syscall0(void, __syscall_sync);
#endif
void sync(void)
#define INLINE_SYSCALL(name, nr, args...) __syscall_truncate64 (args)
#define __NR___syscall_truncate64 __NR_truncate64
#if defined(__UCLIBC_TRUNCATE64_HAS_4_ARGS__)
-static inline _syscall4(int, __syscall_truncate64, const char *, path,
+static __inline__ _syscall4(int, __syscall_truncate64, const char *, path,
uint32_t, pad, unsigned long, high_length, unsigned long, low_length);
#else
-static inline _syscall3(int, __syscall_truncate64, const char *, path,
+static __inline__ _syscall3(int, __syscall_truncate64, const char *, path,
unsigned long, high_length, unsigned long, low_length);
#endif
#endif
#include <sys/stat.h>
#define __NR___syscall_umask __NR_umask
-static inline _syscall1(__kernel_mode_t, __syscall_umask, __kernel_mode_t, mode);
+static __inline__ _syscall1(__kernel_mode_t, __syscall_umask, __kernel_mode_t, mode);
mode_t umask(mode_t mode)
{
#elif defined __NR_umount2
# define __NR___syscall_umount2 __NR_umount2
-static inline _syscall2(int, __syscall_umount2, const char *, special_file, int, flags);
+static __inline__ _syscall2(int, __syscall_umount2, const char *, special_file, int, flags);
int umount(const char *special_file)
{
#include <sys/sysmacros.h>
#define __NR___syscall_ustat __NR_ustat
-static inline _syscall2(int, __syscall_ustat,
+static __inline__ _syscall2(int, __syscall_ustat,
unsigned short int, kdev_t, struct ustat *, ubuf);
int ustat(dev_t dev, struct ustat *ubuf)
libc_hidden_proto(wait4)
#define __NR___syscall_wait4 __NR_wait4
-static inline _syscall4(int, __syscall_wait4, __kernel_pid_t, pid,
+static __inline__ _syscall4(int, __syscall_wait4, __kernel_pid_t, pid,
int *, status, int, opts, struct rusage *, rusage);
pid_t wait4(pid_t pid, int *status, int opts, struct rusage *rusage)
/* The following functions test for accrued exceptions.
* No trap is generated on an FP exception.
*/
-static inline feclearexcept(int __excepts)
+static __inline__ feclearexcept(int __excepts)
{
unsigned int enabled_excepts, disabled_excepts;
return ( G2en | (G2dis << 8) );
}
-static inline int feraiseexcept(int __excepts)
+static __inline__ int feraiseexcept(int __excepts)
{
__asm__ __volatile__("or G2, %0"
:/*no output*/
(__retval); \
})
-static inline int fegetexcept(int excepts)
+static __inline__ int fegetexcept(int excepts)
{
unsigned int tmp;
__asm__ __volatile__("mov %0, SR"
return tmp;
}
-static inline int fegetenv(fenv_t *envp)
+static __inline__ int fegetenv(fenv_t *envp)
{
__asm__ __volatile__("mov %0, SR\n\t
mov %1, SR\n\t
#include <signal.h>
#define __NR_e1newSP 224
-static inline _syscall1(int, e1newSP, unsigned long, SavedSP )
+static __inline__ _syscall1(int, e1newSP, unsigned long, SavedSP )
unsigned long jmpbuf_ptr;
libc_hidden_proto(mmap)
#define __NR___syscall_mmap2 __NR_mmap2
-static inline _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
+static __inline__ _syscall6(__ptr_t, __syscall_mmap2, __ptr_t, addr,
size_t, len, int, prot, int, flags, int, fd, off_t, offset);
/* This is always 12, even on architectures where PAGE_SHIFT != 12. */
# endif /* __UCLIBC_HAS_LFS__ */
# else /* O32 || N32 */
# define __NR___syscall_pread __NR_pread
-static inline _syscall6(ssize_t, __syscall_pread, int, fd, void *, buf,
+static __inline__ _syscall6(ssize_t, __syscall_pread, int, fd, void *, buf,
size_t, count, int, dummy, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pread(int fd, void *buf, size_t count, off_t offset)
# endif /* __UCLIBC_HAS_LFS__ */
# else /* O32 || N32 */
# define __NR___syscall_pwrite __NR_pwrite
-static inline _syscall6(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
+static __inline__ _syscall6(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
size_t, count, int, dummy, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pwrite(int fd, const void *buf, size_t count, off_t offset)
#ifdef __NR_pread
extern __typeof(pread) __libc_pread;
-# define __NR___syscall_pread __NR_pread
-static inline _syscall4(ssize_t, __syscall_pread, int, fd,
+# define __NR___syscall_pread __NR_pread
+static __inline__ _syscall4(ssize_t, __syscall_pread, int, fd,
void *, buf, size_t, count, off64_t, offset);
ssize_t __libc_pread(int fd, void *buf, size_t count, off_t offset)
#ifdef __NR_pwrite
extern __typeof(pwrite) __libc_pwrite;
-# define __NR___syscall_pwrite __NR_pwrite
-static inline _syscall4(ssize_t, __syscall_pwrite, int, fd,
+# define __NR___syscall_pwrite __NR_pwrite
+static __inline__ _syscall4(ssize_t, __syscall_pwrite, int, fd,
const void *, buf, size_t, count, off64_t, offset);
ssize_t __libc_pwrite(int fd, const void *buf, size_t count, off_t offset)
#ifdef __NR_pread
extern __typeof(pread) __libc_pread;
# define __NR___syscall_pread __NR_pread
-static inline _syscall6(ssize_t, __syscall_pread, int, fd, void *, buf,
+static __inline__ _syscall6(ssize_t, __syscall_pread, int, fd, void *, buf,
size_t, count, int, dummy, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pread(int fd, void *buf, size_t count, off_t offset)
#ifdef __NR_pwrite
extern __typeof(pwrite) __libc_pwrite;
# define __NR___syscall_pwrite __NR_pwrite
-static inline _syscall6(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
+static __inline__ _syscall6(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
size_t, count, int, dummy, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pwrite(int fd, const void *buf, size_t count, off_t offset)
# define __NR___syscall_pread __NR_pread
/* On Xtensa, 64-bit values are aligned in even/odd register pairs. */
-static inline _syscall6(ssize_t, __syscall_pread, int, fd, void *, buf,
+static __inline__ _syscall6(ssize_t, __syscall_pread, int, fd, void *, buf,
size_t, count, int, pad, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pread(int fd, void *buf, size_t count, off_t offset)
# define __NR___syscall_pwrite __NR_pwrite
/* On Xtensa, 64-bit values are aligned in even/odd register pairs. */
-static inline _syscall6(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
+static __inline__ _syscall6(ssize_t, __syscall_pwrite, int, fd, const void *, buf,
size_t, count, int, pad, off_t, offset_hi, off_t, offset_lo);
ssize_t __libc_pwrite(int fd, const void *buf, size_t count, off_t offset)
/* Return the handle corresponding to a thread id */
-static inline pthread_handle thread_handle(pthread_t id)
+static __inline__ pthread_handle thread_handle(pthread_t id)
{
return &__pthread_handles[id % PTHREAD_THREADS_MAX];
}
/* Validate a thread handle. Must have acquired h->h_spinlock before. */
-static inline int invalid_handle(pthread_handle h, pthread_t id)
+static __inline__ int invalid_handle(pthread_handle h, pthread_t id)
{
return h->h_descr == NULL || h->h_descr->p_tid != id;
}
extern pthread_descr __pthread_find_self (void) __attribute__ ((const));
-static inline pthread_descr thread_self (void) __attribute__ ((const));
-static inline pthread_descr thread_self (void)
+static __inline__ pthread_descr thread_self (void) __attribute__ ((const));
+static __inline__ pthread_descr thread_self (void)
{
#ifdef THREAD_SELF
return THREAD_SELF;
/* Stack segment numbers are also indices into the __pthread_handles array. */
/* Stack segment number 0 is reserved for the initial thread. */
-static inline pthread_descr thread_segment(int seg)
+static __inline__ pthread_descr thread_segment(int seg)
{
return (pthread_descr)(THREAD_STACK_START_ADDRESS - (seg - 1) * STACK_SIZE)
- 1;
/* Maximum value the semaphore can have. */
#define SEM_VALUE_MAX ((int) ((~0u) >> 1))
-static inline int sem_compare_and_swap(old_sem_t *sem, long oldval, long newval)
+static __inline__ int sem_compare_and_swap(old_sem_t *sem, long oldval, long newval)
{
return compare_and_swap(&sem->sem_status, oldval, newval, &sem->sem_spinlock);
}
}
//strong_alias (__pthread_atfork, pthread_atfork)
-static inline void pthread_call_handlers(struct handler_list * list)
+static __inline__ void pthread_call_handlers(struct handler_list * list)
{
for (/*nothing*/; list != NULL; list = list->next) (list->handler)();
}
linked through their p_nextwaiting field. The lists are kept
sorted by decreasing priority, and then decreasing waiting time. */
-static inline void enqueue(pthread_descr * q, pthread_descr th)
+static __inline__ void enqueue(pthread_descr * q, pthread_descr th)
{
int prio = th->p_priority;
for (; *q != NULL; q = &((*q)->p_nextwaiting)) {
*q = th;
}
-static inline pthread_descr dequeue(pthread_descr * q)
+static __inline__ pthread_descr dequeue(pthread_descr * q)
{
pthread_descr th;
th = *q;
return th;
}
-static inline int remove_from_queue(pthread_descr * q, pthread_descr th)
+static __inline__ int remove_from_queue(pthread_descr * q, pthread_descr th)
{
for (; *q != NULL; q = &((*q)->p_nextwaiting)) {
if (*q == th) {
return 0;
}
-static inline int queue_is_empty(pthread_descr * q)
+static __inline__ int queue_is_empty(pthread_descr * q)
{
return *q == NULL;
}
/* Primitives for controlling thread execution */
-static inline void restart(pthread_descr th)
+static __inline__ void restart(pthread_descr th)
{
/* See pthread.c */
#if __ASSUME_REALTIME_SIGNALS
#endif
}
-static inline void suspend(pthread_descr self)
+static __inline__ void suspend(pthread_descr self)
{
/* See pthread.c */
#if __ASSUME_REALTIME_SIGNALS
#endif
}
-static inline int timedsuspend(pthread_descr self,
+static __inline__ int timedsuspend(pthread_descr self,
const struct timespec *abstime)
{
/* See pthread.c */
static void __pthread_acquire(int * spinlock);
-static inline void __pthread_release(int * spinlock)
+static __inline__ void __pthread_release(int * spinlock)
{
WRITE_MEMORY_BARRIER();
*spinlock = __LT_SPINLOCK_INIT;
extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock);
-static inline int compare_and_swap(long * ptr, long oldval, long newval,
+static __inline__ int compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock)
{
if (__builtin_expect (__pthread_has_cas, 1))
#ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
-static inline int
+static __inline__ int
compare_and_swap_with_release_semantics (long * ptr, long oldval,
long newval, int * spinlock)
{
#endif
-static inline int compare_and_swap(long * ptr, long oldval, long newval,
+static __inline__ int compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock)
{
return __compare_and_swap(ptr, oldval, newval);
extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock);
-static inline int compare_and_swap(long * ptr, long oldval, long newval,
+static __inline__ int compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock)
{
return __pthread_compare_and_swap(ptr, oldval, newval, spinlock);
pthread_descr self);
extern int __pthread_unlock(struct _pthread_fastlock *lock);
-static inline void __pthread_init_lock(struct _pthread_fastlock * lock)
+static __inline__ void __pthread_init_lock(struct _pthread_fastlock * lock)
{
lock->__status = 0;
lock->__spinlock = __LT_SPINLOCK_INIT;
}
-static inline int __pthread_trylock (struct _pthread_fastlock * lock)
+static __inline__ int __pthread_trylock (struct _pthread_fastlock * lock)
{
#if defined TEST_FOR_COMPARE_AND_SWAP
if (!__pthread_has_cas)
extern void __pthread_alt_unlock(struct _pthread_fastlock *lock);
-static inline void __pthread_alt_init_lock(struct _pthread_fastlock * lock)
+static __inline__ void __pthread_alt_init_lock(struct _pthread_fastlock * lock)
{
lock->__status = 0;
lock->__spinlock = __LT_SPINLOCK_INIT;
}
-static inline int __pthread_alt_trylock (struct _pthread_fastlock * lock)
+static __inline__ int __pthread_alt_trylock (struct _pthread_fastlock * lock)
{
#if defined TEST_FOR_COMPARE_AND_SWAP
if (!__pthread_has_cas)
/* Operations on pthread_atomic, which is defined in internals.h */
-static inline long atomic_increment(struct pthread_atomic *pa)
+static __inline__ long atomic_increment(struct pthread_atomic *pa)
{
long oldval;
}
-static inline long atomic_decrement(struct pthread_atomic *pa)
+static __inline__ long atomic_decrement(struct pthread_atomic *pa)
{
long oldval;
}
-static inline void
+static __inline__ void
__pthread_set_own_extricate_if (pthread_descr self, pthread_extricate_if *peif)
{
/* Only store a non-null peif if the thread has cancellation enabled.
/* Copyright (C) 2000, 2002 Free Software Foundation, Inc.
This file is part of the GNU C Library.
Contributed by Maciej W. Rozycki <macro@ds2.pg.gda.pl>, 2000. */
-static inline int
+static __inline__ int
__NTH (_test_and_set (int *p, int v))
{
int r, t;
extern struct agent_list *__td_agent_list attribute_hidden;
/* Function used to test for correct thread agent pointer. */
-static inline int
+static __inline__ int
ta_ok (const td_thragent_t *ta)
{
struct agent_list *runp = __td_agent_list;
extern pthread_descr __pthread_find_self (void) __attribute__ ((pure));
-static inline pthread_descr thread_self (void) __attribute__ ((pure));
-static inline pthread_descr thread_self (void)
+static __inline__ pthread_descr thread_self (void) __attribute__ ((pure));
+static __inline__ pthread_descr thread_self (void)
{
#ifdef THREAD_SELF
return THREAD_SELF;
/* Return the handle corresponding to a thread id */
-static inline pthread_handle thread_handle(pthread_t id)
+static __inline__ pthread_handle thread_handle(pthread_t id)
{
return &__pthread_handles[id % PTHREAD_THREADS_MAX];
}
/* Validate a thread handle. Must have acquired h->h_spinlock before. */
-static inline int invalid_handle(pthread_handle h, pthread_t id)
+static __inline__ int invalid_handle(pthread_handle h, pthread_t id)
{
return h->h_descr == NULL || h->h_descr->p_tid != id || h->h_descr->p_terminated;
}
-static inline int nonexisting_handle(pthread_handle h, pthread_t id)
+static __inline__ int nonexisting_handle(pthread_handle h, pthread_t id)
{
return h->h_descr == NULL || h->h_descr->p_tid != id;
}
#if FLOATING_STACKS
# define thread_segment(seq) NULL
#else
-static inline pthread_descr thread_segment(int seg)
+static __inline__ pthread_descr thread_segment(int seg)
{
# ifdef _STACK_GROWS_UP
return (pthread_descr)(THREAD_STACK_START_ADDRESS + (seg - 1) * STACK_SIZE)
#endif
#ifndef NO_PTR_DEMANGLE
-static inline uintptr_t
+static __inline__ uintptr_t
demangle_ptr (uintptr_t x)
{
#ifdef PTR_DEMANGLE
#endif
#ifdef USE_TLS
-static inline void __attribute__((always_inline))
+static __inline__ void __attribute__((always_inline))
init_one_static_tls (pthread_descr descr, struct link_map *map)
{
# if TLS_TCB_AT_TP
linked through their p_nextwaiting field. The lists are kept
sorted by decreasing priority, and then decreasing waiting time. */
-static inline void enqueue(pthread_descr * q, pthread_descr th)
+static __inline__ void enqueue(pthread_descr * q, pthread_descr th)
{
int prio = th->p_priority;
ASSERT(th->p_nextwaiting == NULL);
*q = th;
}
-static inline pthread_descr dequeue(pthread_descr * q)
+static __inline__ pthread_descr dequeue(pthread_descr * q)
{
pthread_descr th;
th = *q;
return th;
}
-static inline int remove_from_queue(pthread_descr * q, pthread_descr th)
+static __inline__ int remove_from_queue(pthread_descr * q, pthread_descr th)
{
for (; *q != NULL; q = &((*q)->p_nextwaiting)) {
if (*q == th) {
return 0;
}
-static inline int queue_is_empty(pthread_descr * q)
+static __inline__ int queue_is_empty(pthread_descr * q)
{
return *q == NULL;
}
/* Primitives for controlling thread execution */
-static inline void restart(pthread_descr th)
+static __inline__ void restart(pthread_descr th)
{
/* See pthread.c */
#if __ASSUME_REALTIME_SIGNALS
#endif
}
-static inline void suspend(pthread_descr self)
+static __inline__ void suspend(pthread_descr self)
{
/* See pthread.c */
#if __ASSUME_REALTIME_SIGNALS
#endif
}
-static inline int timedsuspend(pthread_descr self,
+static __inline__ int timedsuspend(pthread_descr self,
const struct timespec *abstime)
{
/* See pthread.c */
static void __pthread_acquire(int * spinlock);
-static inline void __pthread_release(int * spinlock)
+static __inline__ void __pthread_release(int * spinlock)
{
WRITE_MEMORY_BARRIER();
*spinlock = __LT_SPINLOCK_INIT;
extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock);
-static inline int compare_and_swap(long * ptr, long oldval, long newval,
+static __inline__ int compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock)
{
if (__builtin_expect (__pthread_has_cas, 1))
#ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
-static inline int
+static __inline__ int
compare_and_swap_with_release_semantics (long * ptr, long oldval,
long newval, int * spinlock)
{
#endif
-static inline int compare_and_swap(long * ptr, long oldval, long newval,
+static __inline__ int compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock)
{
return __compare_and_swap(ptr, oldval, newval);
extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock);
-static inline int compare_and_swap(long * ptr, long oldval, long newval,
+static __inline__ int compare_and_swap(long * ptr, long oldval, long newval,
int * spinlock)
{
return __pthread_compare_and_swap(ptr, oldval, newval, spinlock);
pthread_descr self);
extern int __pthread_unlock(struct _pthread_fastlock *lock);
-static inline void __pthread_init_lock(struct _pthread_fastlock * lock)
+static __inline__ void __pthread_init_lock(struct _pthread_fastlock * lock)
{
lock->__status = 0;
lock->__spinlock = __LT_SPINLOCK_INIT;
}
-static inline int __pthread_trylock (struct _pthread_fastlock * lock)
+static __inline__ int __pthread_trylock (struct _pthread_fastlock * lock)
{
#if defined TEST_FOR_COMPARE_AND_SWAP
if (!__pthread_has_cas)
extern void __pthread_alt_unlock(struct _pthread_fastlock *lock);
-static inline void __pthread_alt_init_lock(struct _pthread_fastlock * lock)
+static __inline__ void __pthread_alt_init_lock(struct _pthread_fastlock * lock)
{
lock->__status = 0;
lock->__spinlock = __LT_SPINLOCK_INIT;
}
-static inline int __pthread_alt_trylock (struct _pthread_fastlock * lock)
+static __inline__ int __pthread_alt_trylock (struct _pthread_fastlock * lock)
{
#if defined TEST_FOR_COMPARE_AND_SWAP
if (!__pthread_has_cas)
/* Operations on pthread_atomic, which is defined in internals.h */
-static inline long atomic_increment(struct pthread_atomic *pa)
+static __inline__ long atomic_increment(struct pthread_atomic *pa)
{
long oldval;
}
-static inline long atomic_decrement(struct pthread_atomic *pa)
+static __inline__ long atomic_decrement(struct pthread_atomic *pa)
{
long oldval;
}
-static inline __attribute__((always_inline)) void
+static __inline__ __attribute__((always_inline)) void
__pthread_set_own_extricate_if (pthread_descr self, pthread_extricate_if *peif)
{
/* Only store a non-null peif if the thread has cancellation enabled.
/* Add new element at the head of the list. */
-static inline void
+static __inline__ void
list_add (list_t *newp, list_t *head)
{
head->next->prev = newp;
/* Add new element at the tail of the list. */
-static inline void
+static __inline__ void
list_add_tail (list_t *newp, list_t *head)
{
head->prev->next = newp;
/* Remove element from list. */
-static inline void
+static __inline__ void
list_del (list_t *elem)
{
elem->next->prev = elem->prev;
/* Join two lists. */
-static inline void
+static __inline__ void
list_splice (list_t *add, list_t *head)
{
/* Do nothing if the list which gets added is empty. */
/* Return pointer to timer structure corresponding to ID. */
-static inline struct timer_node *
+static __inline__ struct timer_node *
timer_id2ptr (timer_t timerid)
{
if (timerid >= 0 && timerid < TIMER_MAX)
}
/* Return ID of TIMER. */
-static inline int
+static __inline__ int
timer_ptr2id (struct timer_node *timer)
{
return timer - __timer_array;
}
/* Check whether timer is valid; global mutex must be held. */
-static inline int
+static __inline__ int
timer_valid (struct timer_node *timer)
{
return timer && timer->inuse == TIMER_INUSE;
/* Timer refcount functions; need global mutex. */
extern void __timer_dealloc (struct timer_node *timer);
-static inline void
+static __inline__ void
timer_addref (struct timer_node *timer)
{
timer->refcount++;
}
-static inline void
+static __inline__ void
timer_delref (struct timer_node *timer)
{
if (--timer->refcount == 0)
}
/* Timespec helper routines. */
-static inline int
+static __inline__ int
timespec_compare (const struct timespec *left, const struct timespec *right)
{
if (left->tv_sec < right->tv_sec)
return 0;
}
-static inline void
+static __inline__ void
timespec_add (struct timespec *sum, const struct timespec *left,
const struct timespec *right)
{
}
}
-static inline void
+static __inline__ void
timespec_sub (struct timespec *diff, const struct timespec *left,
const struct timespec *right)
{
/* We need one of the list functions in the other modules. */
-static inline void
+static __inline__ void
list_unlink_ip (struct list_links *list)
{
struct list_links *lnext = list->next, *lprev = list->prev;
/* List handling functions. */
-static inline void
+static __inline__ void
list_init (struct list_links *list)
{
list->next = list->prev = list;
}
-static inline void
+static __inline__ void
list_append (struct list_links *list, struct list_links *newp)
{
newp->prev = list->prev;
list->prev = newp;
}
-static inline void
+static __inline__ void
list_insbefore (struct list_links *list, struct list_links *newp)
{
list_append (list, newp);
* is already unlinked is disastrous rather than a noop.
*/
-static inline void
+static __inline__ void
list_unlink (struct list_links *list)
{
struct list_links *lnext = list->next, *lprev = list->prev;
lprev->next = lnext;
}
-static inline struct list_links *
+static __inline__ struct list_links *
list_first (struct list_links *list)
{
return list->next;
}
-static inline struct list_links *
+static __inline__ struct list_links *
list_null (struct list_links *list)
{
return list;
}
-static inline struct list_links *
+static __inline__ struct list_links *
list_next (struct list_links *list)
{
return list->next;
}
-static inline int
+static __inline__ int
list_isempty (struct list_links *list)
{
return list->next == list;
/* Functions build on top of the list functions. */
-static inline struct thread_node *
+static __inline__ struct thread_node *
thread_links2ptr (struct list_links *list)
{
return (struct thread_node *) ((char *) list
- offsetof (struct thread_node, links));
}
-static inline struct timer_node *
+static __inline__ struct timer_node *
timer_links2ptr (struct list_links *list)
{
return (struct timer_node *) ((char *) list
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-static inline int
+static __inline__ int
is_smp_system (void)
{
return 0;
/* Return any pending signal or wait for one for the given time. */
-static inline int
+static __inline__ int
do_sigwait (const sigset_t *set, int *sig)
{
int ret;
/* Test whether the machine has more than one processor. This is not the
best test but good enough. More complicated tests would require `malloc'
which is not available at that time. */
-static inline int
+static __inline__ int
is_smp_system (void)
{
static const int sysctl_args[] = { CTL_KERN, KERN_VERSION };
extern struct agent_list *__td_agent_list attribute_hidden;
/* Function used to test for correct thread agent pointer. */
-static inline int
+static __inline__ int
ta_ok (const td_thragent_t *ta)
{
struct agent_list *runp = __td_agent_list;
librt_hidden_proto(mq_setattr)
#define __NR___syscall_mq_getsetattr __NR_mq_getsetattr
-static inline _syscall3(int, __syscall_mq_getsetattr, int, mqdes,
+static __inline__ _syscall3(int, __syscall_mq_getsetattr, int, mqdes,
const void *, mqstat, void *, omqstat);
/*
#ifdef __NR_mq_notify
#define __NR___syscall_mq_notify __NR_mq_notify
-static inline _syscall2(int, __syscall_mq_notify, int, mqdes,
+static __inline__ _syscall2(int, __syscall_mq_notify, int, mqdes,
const void *, notification);
/* Register notification upon message arrival to an empty message queue */
#ifdef __NR_mq_open
#define __NR___syscall_mq_open __NR_mq_open
-static inline _syscall4(int, __syscall_mq_open, const char *, name,
+static __inline__ _syscall4(int, __syscall_mq_open, const char *, name,
int, oflag, __kernel_mode_t, mode, void *, attr);
/*
* Establish connection between a process and a message queue and
librt_hidden_proto(mq_timedreceive)
#ifdef __NR_mq_timedreceive
#define __NR___syscall_mq_timedreceive __NR_mq_timedreceive
-static inline _syscall5(int, __syscall_mq_timedreceive, int, mqdes,
+static __inline__ _syscall5(int, __syscall_mq_timedreceive, int, mqdes,
char *, msg_ptr, size_t, msg_len, unsigned int *,
msg_prio, const void *, abs_timeout);
#endif
librt_hidden_proto(mq_timedsend)
#ifdef __NR_mq_timedsend
#define __NR___syscall_mq_timedsend __NR_mq_timedsend
-static inline _syscall5(int, __syscall_mq_timedsend, int, mqdes,
+static __inline__ _syscall5(int, __syscall_mq_timedsend, int, mqdes,
const char *, msg_ptr, size_t, msg_len, unsigned int,
msg_prio, const void *, abs_timeout);
#endif
#ifdef __NR_mq_unlink
#define __NR___syscall_mq_unlink __NR_mq_unlink
-static inline _syscall1(int, __syscall_mq_unlink, const char *, name);
+static __inline__ _syscall1(int, __syscall_mq_unlink, const char *, name);
/* Remove message queue */
int mq_unlink(const char *name)
#endif
#define __NR___syscall_timer_create __NR_timer_create
-static inline _syscall3(int, __syscall_timer_create, clockid_t, clock_id,
+static __inline__ _syscall3(int, __syscall_timer_create, clockid_t, clock_id,
struct sigevent *, evp, kernel_timer_t *, ktimerid);
/* Create a per-process timer */
#ifdef __NR_timer_delete
#define __NR___syscall_timer_delete __NR_timer_delete
-static inline _syscall1(int, __syscall_timer_delete, kernel_timer_t, ktimerid);
+static __inline__ _syscall1(int, __syscall_timer_delete, kernel_timer_t, ktimerid);
/* Delete a per-process timer */
int timer_delete(timer_t timerid)
#ifdef __NR_timer_getoverrun
#define __NR___syscall_timer_getoverrun __NR_timer_getoverrun
-static inline _syscall1(int, __syscall_timer_getoverrun, kernel_timer_t,
+static __inline__ _syscall1(int, __syscall_timer_getoverrun, kernel_timer_t,
ktimerid);
/* Get the timer overrun count */
#ifdef __NR_timer_gettime
#define __NR___syscall_timer_gettime __NR_timer_gettime
-static inline _syscall2(int, __syscall_timer_gettime, kernel_timer_t, ktimerid,
+static __inline__ _syscall2(int, __syscall_timer_gettime, kernel_timer_t, ktimerid,
void *, value);
/* Get the amount of time left on a timer */
#ifdef __NR_timer_settime
#define __NR___syscall_timer_settime __NR_timer_settime
-static inline _syscall4(int, __syscall_timer_settime, kernel_timer_t, ktimerid,
+static __inline__ _syscall4(int, __syscall_timer_settime, kernel_timer_t, ktimerid,
int, flags, const void *, value, void *, ovalue);
/* Set the expiration time for a timer */
# include <byteswap.h>
#else
-static inline uint16_t bswap_16(uint16_t x)
+static __inline__ uint16_t bswap_16(uint16_t x)
{
return ((((x) & 0xff00) >> 8) | \
(((x) & 0x00ff) << 8));
}
-static inline uint32_t bswap_32(uint32_t x)
+static __inline__ uint32_t bswap_32(uint32_t x)
{
return ((((x) & 0xff000000) >> 24) | \
(((x) & 0x00ff0000) >> 8) | \
static int byteswap;
static int interpreter_already_found = 0;
-static inline uint32_t byteswap32_to_host(uint32_t value)
+static __inline__ uint32_t byteswap32_to_host(uint32_t value)
{
if (byteswap == 1) {
return (bswap_32(value));
return (value);
}
}
-static inline uint64_t byteswap64_to_host(uint64_t value)
+static __inline__ uint64_t byteswap64_to_host(uint64_t value)
{
if (byteswap == 1) {
return (bswap_64(value));
return 0;
}
#else
-static inline void map_cache(void)
+static __inline__ void map_cache(void)
{
}
-static inline void unmap_cache(void)
+static __inline__ void unmap_cache(void)
{
}
#endif
/* makefile will include elf.h for us */
static int byteswap;
-static inline uint32_t byteswap32_to_host(uint32_t value)
+static __inline__ uint32_t byteswap32_to_host(uint32_t value)
{
if (byteswap==1) {
return(bswap_32(value));
return(value);
}
}
-static inline uint64_t byteswap64_to_host(uint64_t value)
+static __inline__ uint64_t byteswap64_to_host(uint64_t value)
{
if (byteswap==1) {
return(bswap_64(value));
OSDN Git Service
