return data;
}
-int strstart(const char *str, const char *val, const char **ptr)
+static int strstart(const char *str, const char *val, const char **ptr)
{
const char *p, *q;
p = str;
return 1;
}
-void pstrcpy(char *buf, int buf_size, const char *str)
+static void pstrcpy(char *buf, int buf_size, const char *str)
{
int c;
char *q = buf;
*q = '\0';
}
-void swab16s(uint16_t *p)
+static void swab16s(uint16_t *p)
{
*p = bswap16(*p);
}
-void swab32s(uint32_t *p)
+static void swab32s(uint32_t *p)
{
*p = bswap32(*p);
}
-void swab32ss(int32_t *p)
+static void swab32ss(int32_t *p)
{
*p = bswap32(*p);
}
-void swab64s(uint64_t *p)
+static void swab64s(uint64_t *p)
{
*p = bswap64(*p);
}
-void swab64ss(int64_t *p)
+static void swab64ss(int64_t *p)
{
*p = bswap64(*p);
}
-uint16_t get16(uint16_t *p)
+static uint16_t get16(uint16_t *p)
{
uint16_t val;
val = *p;
return val;
}
-uint32_t get32(uint32_t *p)
+static uint32_t get32(uint32_t *p)
{
uint32_t val;
val = *p;
return val;
}
-void put16(uint16_t *p, uint16_t val)
+static void put16(uint16_t *p, uint16_t val)
{
if (do_swap)
val = bswap16(val);
*p = val;
}
-void put32(uint32_t *p, uint32_t val)
+static void put32(uint32_t *p, uint32_t val)
{
if (do_swap)
val = bswap32(val);
struct elfhdr ehdr;
char *strtab;
-int elf_must_swap(struct elfhdr *h)
+static int elf_must_swap(struct elfhdr *h)
{
union {
uint32_t i;
(swaptest.b[0] == 0);
}
-void elf_swap_ehdr(struct elfhdr *h)
+static void elf_swap_ehdr(struct elfhdr *h)
{
swab16s(&h->e_type); /* Object file type */
swab16s(&h-> e_machine); /* Architecture */
swab16s(&h-> e_shstrndx); /* Section header string table index */
}
-void elf_swap_shdr(struct elf_shdr *h)
+static void elf_swap_shdr(struct elf_shdr *h)
{
swab32s(&h-> sh_name); /* Section name (string tbl index) */
swab32s(&h-> sh_type); /* Section type */
swabls(&h-> sh_entsize); /* Entry size if section holds table */
}
-void elf_swap_phdr(struct elf_phdr *h)
+static void elf_swap_phdr(struct elf_phdr *h)
{
swab32s(&h->p_type); /* Segment type */
swabls(&h->p_offset); /* Segment file offset */
swabls(&h->p_align); /* Segment alignment */
}
-void elf_swap_rel(ELF_RELOC *rel)
+static void elf_swap_rel(ELF_RELOC *rel)
{
swabls(&rel->r_offset);
swabls(&rel->r_info);
#endif
}
-struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum, const char *shstr,
- const char *name)
+static struct elf_shdr *find_elf_section(struct elf_shdr *shdr, int shnum,
+ const char *shstr, const char *name)
{
int i;
const char *shname;
return NULL;
}
-int find_reloc(int sh_index)
+static int find_reloc(int sh_index)
{
struct elf_shdr *sec;
int i;
}
/* load an elf object file */
-int load_object(const char *filename)
+static int load_object(const char *filename)
{
int fd;
struct elf_shdr *sec, *symtab_sec, *strtab_sec, *text_sec;
#endif /* CONFIG_FORMAT_MACH */
/* return true if the expression is a label reference */
-int get_reloc_expr(char *name, int name_size, const char *sym_name)
+static int get_reloc_expr(char *name, int name_size, const char *sym_name)
{
const char *p;
#define MAX_ARGS 3
/* generate op code */
-void gen_code(const char *name, host_ulong offset, host_ulong size,
- FILE *outfile, int gen_switch)
+static void gen_code(const char *name, host_ulong offset, host_ulong size,
+ FILE *outfile, int gen_switch)
{
int copy_size = 0;
uint8_t *p_start, *p_end;
}
}
-int gen_file(FILE *outfile, int out_type)
+static int gen_file(FILE *outfile, int out_type)
{
int i;
EXE_SYM *sym;
return 0;
}
-void usage(void)
+static void usage(void)
{
printf("dyngen (c) 2003 Fabrice Bellard\n"
"usage: dyngen [-o outfile] [-c] objfile\n"
static uint8_t static_code_gen_buffer[DEFAULT_CODE_GEN_BUFFER_SIZE];
#endif
-void code_gen_alloc(unsigned long tb_size)
+static void code_gen_alloc(unsigned long tb_size)
{
#ifdef USE_STATIC_CODE_GEN_BUFFER
code_gen_buffer = static_code_gen_buffer;
menelaus_update(s);
}
-void menelaus_reset(i2c_slave *i2c)
+static void menelaus_reset(i2c_slave *i2c)
{
struct menelaus_s *s = (struct menelaus_s *) i2c;
s->reg = 0x00;
qemu_free(s);
}
-int usb_serial_can_read(void *opaque)
+static int usb_serial_can_read(void *opaque)
{
USBSerialState *s = opaque;
return RECV_BUF - s->recv_used;
}
-void usb_serial_read(void *opaque, const uint8_t *buf, int size)
+static void usb_serial_read(void *opaque, const uint8_t *buf, int size)
{
USBSerialState *s = opaque;
int first_size = RECV_BUF - s->recv_ptr;
s->recv_used += size;
}
-void usb_serial_event(void *opaque, int event)
+static void usb_serial_event(void *opaque, int event)
{
USBSerialState *s = opaque;
return 0;
}
+#if defined(TARGET_I386)
int cpu_get_pic_interrupt(CPUState *env)
{
return -1;
}
+#endif
/* timers for rdtsc */
}
#endif /* TARGET_ALPHA */
-void usage(void)
+static void usage(void)
{
printf("qemu-" TARGET_ARCH " version " QEMU_VERSION ", Copyright (c) 2003-2008 Fabrice Bellard\n"
"usage: qemu-" TARGET_ARCH " [options] program [arguments...]\n"
d->sig[i] = tswapl(d1.sig[i]);
}
-void target_to_host_sigset_internal(sigset_t *d, const target_sigset_t *s)
+static void target_to_host_sigset_internal(sigset_t *d,
+ const target_sigset_t *s)
{
int i;
sigemptyset(d);
}
/* abort execution with signal */
-void __attribute((noreturn)) force_sig(int sig)
+static void __attribute((noreturn)) force_sig(int sig)
{
int host_sig;
host_sig = target_to_host_signal(sig);
#undef _syscall6
#define _syscall0(type,name) \
-type name (void) \
+static type name (void) \
{ \
return syscall(__NR_##name); \
}
#define _syscall1(type,name,type1,arg1) \
-type name (type1 arg1) \
+static type name (type1 arg1) \
{ \
return syscall(__NR_##name, arg1); \
}
#define _syscall2(type,name,type1,arg1,type2,arg2) \
-type name (type1 arg1,type2 arg2) \
+static type name (type1 arg1,type2 arg2) \
{ \
return syscall(__NR_##name, arg1, arg2); \
}
#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
-type name (type1 arg1,type2 arg2,type3 arg3) \
+static type name (type1 arg1,type2 arg2,type3 arg3) \
{ \
return syscall(__NR_##name, arg1, arg2, arg3); \
}
#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
+static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4) \
{ \
return syscall(__NR_##name, arg1, arg2, arg3, arg4); \
}
#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
type5,arg5) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
+static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
{ \
return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5); \
}
#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
type5,arg5,type6,arg6) \
-type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5,type6 arg6) \
+static type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5, \
+ type6 arg6) \
{ \
return syscall(__NR_##name, arg1, arg2, arg3, arg4, arg5, arg6); \
}
_syscall3(int, sys_getdents64, uint, fd, struct dirent64 *, dirp, uint, count);
#endif
_syscall2(int, sys_getpriority, int, which, int, who);
+#if !defined (__x86_64__)
_syscall5(int, _llseek, uint, fd, ulong, hi, ulong, lo,
loff_t *, res, uint, wh);
+#endif
#if defined(TARGET_NR_linkat) && defined(__NR_linkat)
_syscall5(int,sys_linkat,int,olddirfd,const char *,oldpath,
int,newdirfd,const char *,newpath,int,flags)
_syscall4(int,sys_utimensat,int,dirfd,const char *,pathname,
const struct timespec *,tsp,int,flags)
#endif
+#if defined(USE_NPTL)
#if defined(TARGET_NR_futex) && defined(__NR_futex)
_syscall6(int,sys_futex,int *,uaddr,int,op,int,val,
const struct timespec *,timeout,int *,uaddr2,int,val3)
-
+#endif
#endif
extern int personality(int);
}
/* specific and weird i386 syscalls */
-abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
- unsigned long bytecount)
+static abi_long do_modify_ldt(CPUX86State *env, int func, abi_ulong ptr,
+ unsigned long bytecount)
{
abi_long ret;
return ret;
}
-abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
+static abi_long do_set_thread_area(CPUX86State *env, abi_ulong ptr)
{
uint64_t *gdt_table = g2h(env->gdt.base);
struct target_modify_ldt_ldt_s ldt_info;
return 0;
}
-abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
+static abi_long do_get_thread_area(CPUX86State *env, abi_ulong ptr)
{
struct target_modify_ldt_ldt_s *target_ldt_info;
uint64_t *gdt_table = g2h(env->gdt.base);
}
#ifndef TARGET_ABI32
-abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
+static abi_long do_arch_prctl(CPUX86State *env, int code, abi_ulong addr)
{
abi_long ret;
abi_ulong val;
futexes locally would make futexes shared between multiple processes
tricky. However they're probably useless because guest atomic
operations won't work either. */
-int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
- target_ulong uaddr2, int val3)
+static int do_futex(target_ulong uaddr, int op, int val, target_ulong timeout,
+ target_ulong uaddr2, int val3)
{
struct timespec ts, *pts;
unsigned char ar_tip[4]; /* target IP address */
};
-void arp_input(const uint8_t *pkt, int pkt_len)
+static void arp_input(const uint8_t *pkt, int pkt_len)
{
struct ethhdr *eh = (struct ethhdr *)pkt;
struct arphdr *ah = (struct arphdr *)(pkt + ETH_HLEN);
s->pool_current = NULL;
}
-/* free all the pool */
-void tcg_pool_free(TCGContext *s)
-{
- TCGPool *p, *p1;
-
- for(p = s->pool_first; p != NULL; p = p1) {
- p1 = p->next;
- qemu_free(p);
- }
- s->pool_first = NULL;
- s->pool_cur = s->pool_end = NULL;
-}
-
void tcg_context_init(TCGContext *s)
{
int op, total_args, n;
}
#endif
-void tcg_reg_alloc_start(TCGContext *s)
+static void tcg_reg_alloc_start(TCGContext *s)
{
int i;
TCGTemp *ts;
/* Liveness analysis : update the opc_dead_iargs array to tell if a
given input arguments is dead. Instructions updating dead
temporaries are removed. */
-void tcg_liveness_analysis(TCGContext *s)
+static void tcg_liveness_analysis(TCGContext *s)
{
int i, op_index, op, nb_args, nb_iargs, nb_oargs, arg, nb_ops;
TCGArg *args;
}
/* parse target specific constraints */
-int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
+static int target_parse_constraint(TCGArgConstraint *ct, const char **pct_str)
{
const char *ct_str;
}
}
-void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)
+static void tcg_out_addi(TCGContext *s, int reg, tcg_target_long val)
{
if (val != 0)
tgen_arithi64(s, ARITH_ADD, reg, val);
}
}
-void pty_chr_timer(void *opaque)
+static void pty_chr_timer(void *opaque)
{
struct CharDriverState *chr = opaque;
PtyCharDriver *s = chr->opaque;