From: Nicholas Nethercote Date: Sat, 26 Mar 2005 02:57:36 +0000 (+0000) Subject: Use "VGO_" prefix for various OS-specific exports. X-Git-Tag: svn/VALGRIND_3_0_0~881 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=b08a041b56007ed5ebb4af221be63f70de5ab038;p=thirdparty%2Fvalgrind.git Use "VGO_" prefix for various OS-specific exports. git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3437 --- diff --git a/coregrind/core.h b/coregrind/core.h index 56e7d801a0..ad7e0235ca 100644 --- a/coregrind/core.h +++ b/coregrind/core.h @@ -1154,9 +1154,9 @@ void VG_(record_fd_open)(ThreadId tid, Int fd, char *pathname); // Templates for generating the PRE and POST macros. For ones that must be // publically visible, use an empty 'qual', 'prefix' should start with -// "vgArch_", and there should be corresponding global declarations (like -// the GEN_SYSCALL_WRAPPER ones below). Otherwise, use "static" for 'qual', -// and "vgArch_" should not be in the 'prefix'. +// "vgArch_" or similar, and there should be corresponding global +// declarations (like the GEN_SYSCALL_WRAPPER ones below). Otherwise, use +// "static" for 'qual', and "vgArch_" should not be in the 'prefix'. #define PRE_TEMPLATE(qual, prefix, name, f) \ qual UInt prefix##_##name##_flags = f; \ qual void prefix##_##name##_before(ThreadId tid, ThreadState *tst) diff --git a/coregrind/linux/core_os.h b/coregrind/linux/core_os.h index d7553ea856..ce44d4486f 100644 --- a/coregrind/linux/core_os.h +++ b/coregrind/linux/core_os.h @@ -34,61 +34,61 @@ // Macros for adding Linux-specific, arch-independent wrappers to a syscall // table. -#define LINX_(const, name) SYS_WRAPPER_ENTRY_X_(vgArch_linux, const, name) -#define LINXY(const, name) SYS_WRAPPER_ENTRY_XY(vgArch_linux, const, name) +#define LINX_(const, name) SYS_WRAPPER_ENTRY_X_(vgOS_linux, const, name) +#define LINXY(const, name) SYS_WRAPPER_ENTRY_XY(vgOS_linux, const, name) // The following syscall wrappers are Linux-specific, but arch-independent. -#define LINUX_SYSCALL_WRAPPER(x) \ - extern UInt VGA_(linux_##x##_flags); \ - extern void VGA_(linux_##x##_before)(ThreadId tid, ThreadState *tst); \ - extern void VGA_(linux_##x##_after) (ThreadId tid, ThreadState *tst) - -LINUX_SYSCALL_WRAPPER(sys_exit_group); - -LINUX_SYSCALL_WRAPPER(sys_mount); -LINUX_SYSCALL_WRAPPER(sys_oldumount); -LINUX_SYSCALL_WRAPPER(sys_umount); - -LINUX_SYSCALL_WRAPPER(sys_llseek); -LINUX_SYSCALL_WRAPPER(sys_adjtimex); - -LINUX_SYSCALL_WRAPPER(sys_setfsuid16); -LINUX_SYSCALL_WRAPPER(sys_setfsgid16); -LINUX_SYSCALL_WRAPPER(sys_setresuid16); // man page says "non-standard"; -LINUX_SYSCALL_WRAPPER(sys_getresuid16); -LINUX_SYSCALL_WRAPPER(sys_setresgid16); // man page says "non-standard" -LINUX_SYSCALL_WRAPPER(sys_getresgid16); - -LINUX_SYSCALL_WRAPPER(sys_setfsuid); -LINUX_SYSCALL_WRAPPER(sys_setfsgid); -LINUX_SYSCALL_WRAPPER(sys_setresuid); // man page says "non-standard" -LINUX_SYSCALL_WRAPPER(sys_getresuid); -LINUX_SYSCALL_WRAPPER(sys_setresgid); // man page says "non-standard" -LINUX_SYSCALL_WRAPPER(sys_getresgid); - -LINUX_SYSCALL_WRAPPER(sys_ioperm); -LINUX_SYSCALL_WRAPPER(sys_syslog); -LINUX_SYSCALL_WRAPPER(sys_vhangup); -LINUX_SYSCALL_WRAPPER(sys_sysinfo); -LINUX_SYSCALL_WRAPPER(sys_personality); -LINUX_SYSCALL_WRAPPER(sys_sysctl); -LINUX_SYSCALL_WRAPPER(sys_prctl); - -LINUX_SYSCALL_WRAPPER(sys_sendfile); -LINUX_SYSCALL_WRAPPER(sys_sendfile64); -LINUX_SYSCALL_WRAPPER(sys_futex); - -LINUX_SYSCALL_WRAPPER(sys_epoll_create); -LINUX_SYSCALL_WRAPPER(sys_epoll_ctl); -LINUX_SYSCALL_WRAPPER(sys_epoll_wait); - -LINUX_SYSCALL_WRAPPER(sys_tgkill); - -LINUX_SYSCALL_WRAPPER(sys_io_setup); -LINUX_SYSCALL_WRAPPER(sys_io_destroy); -LINUX_SYSCALL_WRAPPER(sys_io_getevents); -LINUX_SYSCALL_WRAPPER(sys_io_submit); -LINUX_SYSCALL_WRAPPER(sys_io_cancel); +#define VGO_LINUX_SYSCALL_WRAPPER(x) \ + extern UInt VGO_(linux_##x##_flags); \ + extern void VGO_(linux_##x##_before)(ThreadId tid, ThreadState *tst); \ + extern void VGO_(linux_##x##_after) (ThreadId tid, ThreadState *tst) + +VGO_LINUX_SYSCALL_WRAPPER(sys_exit_group); + +VGO_LINUX_SYSCALL_WRAPPER(sys_mount); +VGO_LINUX_SYSCALL_WRAPPER(sys_oldumount); +VGO_LINUX_SYSCALL_WRAPPER(sys_umount); + +VGO_LINUX_SYSCALL_WRAPPER(sys_llseek); +VGO_LINUX_SYSCALL_WRAPPER(sys_adjtimex); + +VGO_LINUX_SYSCALL_WRAPPER(sys_setfsuid16); +VGO_LINUX_SYSCALL_WRAPPER(sys_setfsgid16); +VGO_LINUX_SYSCALL_WRAPPER(sys_setresuid16); // man page says "non-standard"; +VGO_LINUX_SYSCALL_WRAPPER(sys_getresuid16); +VGO_LINUX_SYSCALL_WRAPPER(sys_setresgid16); // man page says "non-standard" +VGO_LINUX_SYSCALL_WRAPPER(sys_getresgid16); + +VGO_LINUX_SYSCALL_WRAPPER(sys_setfsuid); +VGO_LINUX_SYSCALL_WRAPPER(sys_setfsgid); +VGO_LINUX_SYSCALL_WRAPPER(sys_setresuid); // man page says "non-standard" +VGO_LINUX_SYSCALL_WRAPPER(sys_getresuid); +VGO_LINUX_SYSCALL_WRAPPER(sys_setresgid); // man page says "non-standard" +VGO_LINUX_SYSCALL_WRAPPER(sys_getresgid); + +VGO_LINUX_SYSCALL_WRAPPER(sys_ioperm); +VGO_LINUX_SYSCALL_WRAPPER(sys_syslog); +VGO_LINUX_SYSCALL_WRAPPER(sys_vhangup); +VGO_LINUX_SYSCALL_WRAPPER(sys_sysinfo); +VGO_LINUX_SYSCALL_WRAPPER(sys_personality); +VGO_LINUX_SYSCALL_WRAPPER(sys_sysctl); +VGO_LINUX_SYSCALL_WRAPPER(sys_prctl); + +VGO_LINUX_SYSCALL_WRAPPER(sys_sendfile); +VGO_LINUX_SYSCALL_WRAPPER(sys_sendfile64); +VGO_LINUX_SYSCALL_WRAPPER(sys_futex); + +VGO_LINUX_SYSCALL_WRAPPER(sys_epoll_create); +VGO_LINUX_SYSCALL_WRAPPER(sys_epoll_ctl); +VGO_LINUX_SYSCALL_WRAPPER(sys_epoll_wait); + +VGO_LINUX_SYSCALL_WRAPPER(sys_tgkill); + +VGO_LINUX_SYSCALL_WRAPPER(sys_io_setup); +VGO_LINUX_SYSCALL_WRAPPER(sys_io_destroy); +VGO_LINUX_SYSCALL_WRAPPER(sys_io_getevents); +VGO_LINUX_SYSCALL_WRAPPER(sys_io_submit); +VGO_LINUX_SYSCALL_WRAPPER(sys_io_cancel); #define FUTEX_SEMA 0 @@ -105,12 +105,12 @@ typedef struct { extern Int __futex_down_slow(vg_sema_t *, int, struct vki_timespec *); extern Int __futex_up_slow(vg_sema_t *); -void VG_(sema_init)(vg_sema_t *); -static inline void VG_(sema_deinit)(vg_sema_t *) +void VGO_(sema_init)(vg_sema_t *); +static inline void VGO_(sema_deinit)(vg_sema_t *) { } -static inline void VG_(sema_down)(vg_sema_t *futx) +static inline void VGO_(sema_down)(vg_sema_t *futx) { Int val, woken = 0; @@ -135,7 +135,7 @@ static inline void VG_(sema_down)(vg_sema_t *futx) /* If __futex_up increments count from 0 -> 1, noone was waiting. Otherwise, set to 1 and tell kernel to wake them up. */ -static inline void VG_(sema_up)(vg_sema_t *futx) +static inline void VGO_(sema_up)(vg_sema_t *futx) { if (!__futex_up(&futx->count)) __futex_up_slow(futx); @@ -149,10 +149,10 @@ typedef struct { Int owner_thread; /* who currently has it */ } vg_sema_t; -void VG_(sema_init)(vg_sema_t *); -void VG_(sema_deinit)(vg_sema_t *); -void VG_(sema_down)(vg_sema_t *sema); -void VG_(sema_up)(vg_sema_t *sema); +void VGO_(sema_init)(vg_sema_t *); +void VGO_(sema_deinit)(vg_sema_t *); +void VGO_(sema_down)(vg_sema_t *sema); +void VGO_(sema_up)(vg_sema_t *sema); #endif /* FUTEX_SEMA */ diff --git a/coregrind/linux/sema.c b/coregrind/linux/sema.c index 67b2494a96..e15392d17b 100644 --- a/coregrind/linux/sema.c +++ b/coregrind/linux/sema.c @@ -43,7 +43,7 @@ int __futex_up_slow(vg_sema_t *futx) return sys_futex(&futx->count, VKI_FUTEX_WAKE, 1, NULL); } -void VG_(sema_init)(vg_sema_t *sema) +void VGO_(sema_init)(vg_sema_t *sema) { sema->count = 1; __futex_commit(); @@ -55,7 +55,7 @@ void VG_(sema_init)(vg_sema_t *sema) Slower but more portable pipe-based token passing scheme. */ -void VG_(sema_init)(vg_sema_t *sema) +void VGO_(sema_init)(vg_sema_t *sema) { VG_(pipe)(sema->pipe); sema->pipe[0] = VG_(safe_fd)(sema->pipe[0]); @@ -67,7 +67,7 @@ void VG_(sema_init)(vg_sema_t *sema) VG_(write)(sema->pipe[1], "T", 1); } -void VG_(sema_deinit)(vg_sema_t *sema) +void VGO_(sema_deinit)(vg_sema_t *sema) { VG_(close)(sema->pipe[0]); VG_(close)(sema->pipe[1]); @@ -75,7 +75,7 @@ void VG_(sema_deinit)(vg_sema_t *sema) } /* get a token */ -void VG_(sema_down)(vg_sema_t *sema) +void VGO_(sema_down)(vg_sema_t *sema) { Char buf[2] = { 'x' }; Int ret; @@ -96,7 +96,7 @@ void VG_(sema_down)(vg_sema_t *sema) } /* put token back */ -void VG_(sema_up)(vg_sema_t *sema) +void VGO_(sema_up)(vg_sema_t *sema) { Int ret; diff --git a/coregrind/linux/syscalls.c b/coregrind/linux/syscalls.c index e0edc4afe8..172be91ec1 100644 --- a/coregrind/linux/syscalls.c +++ b/coregrind/linux/syscalls.c @@ -37,8 +37,8 @@ // Nb: See the comment above the generic PRE/POST wrappers in // coregrind/vg_syscalls.c for notes about how they work. -#define PRE(name, f) PRE_TEMPLATE( , vgArch_linux, name, f) -#define POST(name) POST_TEMPLATE( , vgArch_linux, name) +#define PRE(name, f) PRE_TEMPLATE( , vgOS_linux, name, f) +#define POST(name) POST_TEMPLATE( , vgOS_linux, name) PRE(sys_exit_group, Special) { diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c index 05efde522f..0599f4bf67 100644 --- a/coregrind/vg_scheduler.c +++ b/coregrind/vg_scheduler.c @@ -262,7 +262,7 @@ void VG_(set_running)(ThreadId tid) tst->status = VgTs_Runnable; - VG_(sema_down)(&run_sema); + VGO_(sema_down)(&run_sema); if (running_tid != VG_INVALID_THREADID) VG_(printf)("tid %d found %d running\n", tid, running_tid); vg_assert(running_tid == VG_INVALID_THREADID); @@ -324,7 +324,7 @@ void VG_(set_sleeping)(ThreadId tid, ThreadStatus sleepstate) /* Release the run_sema; this will reschedule any runnable thread. */ - VG_(sema_up)(&run_sema); + VGO_(sema_up)(&run_sema); if (VG_(clo_trace_sched)) { Char buf[50]; @@ -368,7 +368,7 @@ void VG_(exit_thread)(ThreadId tid) /* There should still be a valid exitreason for this thread */ vg_assert(VG_(threads)[tid].exitreason != VgSrc_None); - VG_(sema_up)(&run_sema); + VGO_(sema_up)(&run_sema); } /* Kill a thread. This interrupts whatever a thread is doing, and @@ -608,9 +608,9 @@ static void sched_fork_cleanup(ThreadId me) } /* re-init and take the sema */ - VG_(sema_deinit)(&run_sema); - VG_(sema_init)(&run_sema); - VG_(sema_down)(&run_sema); + VGO_(sema_deinit)(&run_sema); + VGO_(sema_init)(&run_sema); + VGO_(sema_down)(&run_sema); } @@ -624,7 +624,7 @@ void VG_(scheduler_init) ( void ) Int i; ThreadId tid_main; - VG_(sema_init)(&run_sema); + VGO_(sema_init)(&run_sema); for (i = 0 /* NB; not 1 */; i < VG_N_THREADS; i++) { VG_(threads)[i].sig_queue = NULL; diff --git a/include/tool_asm.h b/include/tool_asm.h index 65c2d5ecf8..61f1b0cfce 100644 --- a/include/tool_asm.h +++ b/include/tool_asm.h @@ -42,8 +42,8 @@ name can safely be used across different macros. */ #define VG_(str) VGAPPEND(vgPlain_,str) #define VGA_(str) VGAPPEND(vgArch_,str) -#define VGO_(str) VGAPPEND(vgOS,str) -#define VGP_(str) VGAPPEND(vgPlatform,str) +#define VGO_(str) VGAPPEND(vgOS_,str) +#define VGP_(str) VGAPPEND(vgPlatform_,str) /* Tool-specific ones. Note that final name still starts with "vg". */ #define TL_(str) VGAPPEND(vgTool_,str)