Use VGP_ prefix more consistently for platform-specific exports.

git-svn-id: svn://svn.valgrind.org/valgrind/trunk@3436

diff --git a/coregrind/amd64-linux/core_platform.h b/coregrind/amd64-linux/core_platform.h
index 9cedd5192bd8d99d3f35f6683b51e536c149dcb0..fe86079580cb0fabf10f7cbad3d30752bcb3ddeb 100644 (file)
--- a/coregrind/amd64-linux/core_platform.h
+++ b/coregrind/amd64-linux/core_platform.h
@@ -40,18 +40,17 @@
    ------------------------------------------------------------------ */
 
 // Accessors for the ThreadArchState
-#define PLATFORM_SYSCALL_NUM     guest_RAX
-#define PLATFORM_SYSCALL_ARG1    guest_RDI
-#define PLATFORM_SYSCALL_ARG2    guest_RSI
-#define PLATFORM_SYSCALL_ARG3    guest_RDX
-#define PLATFORM_SYSCALL_ARG4    guest_R10
-#define PLATFORM_SYSCALL_ARG5    guest_R8
-#define PLATFORM_SYSCALL_ARG6    guest_R9
-#define PLATFORM_SYSCALL_RET     guest_RAX
+#define VGP_SYSCALL_NUM       guest_RAX
+#define VGP_SYSCALL_ARG1      guest_RDI
+#define VGP_SYSCALL_ARG2      guest_RSI
+#define VGP_SYSCALL_ARG3      guest_RDX
+#define VGP_SYSCALL_ARG4      guest_R10
+#define VGP_SYSCALL_ARG5      guest_R8
+#define VGP_SYSCALL_ARG6      guest_R9
+#define VGP_SYSCALL_RET       guest_RAX
 
 // Setting a syscall result
-#define PLATFORM_SET_SYSCALL_RESULT(regs, val)     \
-   ((regs).vex.guest_RAX = (val))
+#define VGP_SET_SYSCALL_RESULT(regs, val)    ((regs).vex.guest_RAX = (val))
 
 // Setting thread regs and shadow regs from within the core
 #define SET_SYSCALL_RETVAL(zztid, zzval) \
@@ -85,22 +84,22 @@ extern Addr VG_(do_useseg) ( UInt seg_selector, Addr virtual_addr );
    ucontext stuff
    ------------------------------------------------------------------ */
 
-#define UCONTEXT_INSTR_PTR(uc)   ((uc)->uc_mcontext.rip)
-#define UCONTEXT_STACK_PTR(uc)   ((uc)->uc_mcontext.rsp)
-#define UCONTEXT_FRAME_PTR(uc)   ((uc)->uc_mcontext.rbp)
-#define UCONTEXT_SYSCALL_NUM(uc) ((uc)->uc_mcontext.rax)
-#define UCONTEXT_SYSCALL_RET(uc) ((uc)->uc_mcontext.rax)
+#define VGP_UCONTEXT_INSTR_PTR(uc)     ((uc)->uc_mcontext.rip)
+#define VGP_UCONTEXT_STACK_PTR(uc)     ((uc)->uc_mcontext.rsp)
+#define VGP_UCONTEXT_FRAME_PTR(uc)     ((uc)->uc_mcontext.rbp)
+#define VGP_UCONTEXT_SYSCALL_NUM(uc)   ((uc)->uc_mcontext.rax)
+#define VGP_UCONTEXT_SYSCALL_RET(uc)   ((uc)->uc_mcontext.rax)
 
 /* ---------------------------------------------------------------------
    mmap() stuff
    ------------------------------------------------------------------ */
 
-#define PLATFORM_DO_MMAP(ret, start, length, prot, flags, fd, offset) { \
+#define VGP_DO_MMAP(ret, start, length, prot, flags, fd, offset) { \
    ret = VG_(do_syscall6)(__NR_mmap, (UWord)(start), (length),          \
                          (prot), (flags), (fd), (offset));              \
 } while (0)
 
-#define PLATFORM_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do {\
+#define VGP_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do {\
    I_die_here; \
 } while (0)
 
@@ -109,8 +108,8 @@ extern Addr VG_(do_useseg) ( UInt seg_selector, Addr virtual_addr );
    state, but does need to pass though "val". */
 #include <setjmp.h>       /* for jmp_buf         */
 
-#define SETJMP(env)            setjmp(env)
-#define LONGJMP(env, val)      longjmp(env, val)
+#define VGP_SETJMP(env)       setjmp(env)
+#define VGP_LONGJMP(env, val) longjmp(env, val)
 
 #endif   // __AMD64_LINUX_CORE_PLATFORM_H
 

diff --git a/coregrind/amd64-linux/syscalls.c b/coregrind/amd64-linux/syscalls.c
index 05323e3989ac7ca51b848619715cba0983078390..da358286e56df57d9203f68a43818ca226369208 100644 (file)
--- a/coregrind/amd64-linux/syscalls.c
+++ b/coregrind/amd64-linux/syscalls.c
@@ -110,11 +110,11 @@ void VGA_(interrupted_syscall)(ThreadId tid,
 
    ThreadState *tst = VG_(get_ThreadState)(tid);
    ThreadArchState *th_regs = &tst->arch;
-   Word ip = UCONTEXT_INSTR_PTR(uc);
+   Word ip = VGP_UCONTEXT_INSTR_PTR(uc);
 
    if (debug)
       VG_(printf)("interrupted_syscall: ip=%p; restart=%d eax=%d\n", 
-                 ip, restart, UCONTEXT_SYSCALL_NUM(uc));
+                 ip, restart, VGP_UCONTEXT_SYSCALL_NUM(uc));
 
    if (ip < VGA_(blksys_setup) || ip >= VGA_(blksys_finished)) {
       VG_(printf)("  not in syscall (%p - %p)\n", VGA_(blksys_setup), VGA_(blksys_finished));
@@ -136,7 +136,7 @@ void VGA_(interrupted_syscall)(ThreadId tid,
       if (restart)
         VGA_(restart_syscall)(th_regs);
       else {
-        th_regs->vex.PLATFORM_SYSCALL_RET = -VKI_EINTR;
+        th_regs->vex.VGP_SYSCALL_RET = -VKI_EINTR;
         VG_(post_syscall)(tid);
       }
    } else if (ip >= VGA_(blksys_complete) && ip < VGA_(blksys_committed)) {
@@ -144,8 +144,8 @@ void VGA_(interrupted_syscall)(ThreadId tid,
         The saved real CPU %rax has the result, which we need to move
         to RAX. */
       if (debug)
-        VG_(printf)("  completed: ret=%d\n", UCONTEXT_SYSCALL_RET(uc));
-      th_regs->vex.PLATFORM_SYSCALL_RET = UCONTEXT_SYSCALL_RET(uc);
+        VG_(printf)("  completed: ret=%d\n", VGP_UCONTEXT_SYSCALL_RET(uc));
+      th_regs->vex.VGP_SYSCALL_RET = VGP_UCONTEXT_SYSCALL_RET(uc);
       VG_(post_syscall)(tid);
    } else if (ip >= VGA_(blksys_committed) && ip < VGA_(blksys_finished)) {
       /* Result committed, but the signal mask has not been restored;
@@ -344,7 +344,7 @@ static Int do_clone(ThreadId ptid,
    */
    VGA_(setup_child)( &ctst->arch, &ptst->arch );
 
-   PLATFORM_SET_SYSCALL_RESULT(ctst->arch, 0);
+   VGP_SET_SYSCALL_RESULT(ctst->arch, 0);
    if (rsp != 0)
       ctst->arch.vex.guest_RSP = rsp;
 

diff --git a/coregrind/arm-linux/core_platform.h b/coregrind/arm-linux/core_platform.h
index 1cd1a3f23e018f00bba1096551fcf5681df75d8c..69dbe9d9eb1ed7f0278a9fb51b59d1789d2e876e 100644 (file)
--- a/coregrind/arm-linux/core_platform.h
+++ b/coregrind/arm-linux/core_platform.h
@@ -40,17 +40,17 @@
    ------------------------------------------------------------------ */
 
 // Accessors for the ThreadArchState
-#define PLATFORM_SYSCALL_NUM     guest_SYSCALLNO
-#define PLATFORM_SYSCALL_ARG1    guest_R0
-#define PLATFORM_SYSCALL_ARG2    guest_R1
-#define PLATFORM_SYSCALL_ARG3    guest_R2
-#define PLATFORM_SYSCALL_ARG4    guest_R3
-#define PLATFORM_SYSCALL_ARG5    guest_R4
-#define PLATFORM_SYSCALL_ARG6    guest_R5
-#define PLATFORM_SYSCALL_RET     guest_R0 // ToDo XXX ????????
-
-#define PLATFORM_SET_SYSCALL_RESULT(regs, val)     \
-   ((regs).vex.guest_R0 = (val))    // ToDo XXX ????????
+#define VGP_SYSCALL_NUM       guest_SYSCALLNO
+#define VGP_SYSCALL_ARG1      guest_R0
+#define VGP_SYSCALL_ARG2      guest_R1
+#define VGP_SYSCALL_ARG3      guest_R2
+#define VGP_SYSCALL_ARG4      guest_R3
+#define VGP_SYSCALL_ARG5      guest_R4
+#define VGP_SYSCALL_ARG6      guest_R5
+#define VGP_SYSCALL_RET       guest_R0 // ToDo XXX ????????
+
+// ToDo XXX ????????
+#define VGP_SET_SYSCALL_RESULT(regs, val)    ((regs).vex.guest_R0 = (val))
 
 // Setting thread regs and shadow regs from within the core
 // XXX ToDo: not sure about this
@@ -62,20 +62,20 @@
    ucontext stuff
    ------------------------------------------------------------------ */
 
-#define UCONTEXT_INSTR_PTR(uc)   ((uc)->uc_mcontext.arm_pc)
-#define UCONTEXT_STACK_PTR(uc)   ((uc)->uc_mcontext.arm_sp)
-#define UCONTEXT_FRAME_PTR(uc)   ((uc)->uc_mcontext.arm_fp)
-#define UCONTEXT_SYSCALL_NUM(uc) ((uc)->uc_mcontext.arm_r0)
+#define VGP_UCONTEXT_INSTR_PTR(uc)     ((uc)->uc_mcontext.arm_pc)
+#define VGP_UCONTEXT_STACK_PTR(uc)     ((uc)->uc_mcontext.arm_sp)
+#define VGP_UCONTEXT_FRAME_PTR(uc)     ((uc)->uc_mcontext.arm_fp)
+#define VGP_UCONTEXT_SYSCALL_NUM(uc)   ((uc)->uc_mcontext.arm_r0)
 
 /* ---------------------------------------------------------------------
    mmap() stuff
    ------------------------------------------------------------------ */
 
-#define PLATFORM_DO_MMAP(ret, start, length, prot, flags, fd, offset) { \
+#define VGP_DO_MMAP(ret, start, length, prot, flags, fd, offset) { \
    I_die_here; \
 } while (0)
 
-#define PLATFORM_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do { \
+#define VGP_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do { \
    I_die_here; \
 } while (0)
 

diff --git a/coregrind/core.h b/coregrind/core.h
index 16000413fd630081af636fd61d28a86b0abc203c..56e7d801a0637d82e8600b332c7d3a310f191527 100644 (file)
--- a/coregrind/core.h
+++ b/coregrind/core.h
@@ -1187,9 +1187,9 @@ void VG_(record_fd_open)(ThreadId tid, Int fd, char *pathname);
 #define ARG5    SYSCALL_ARG5(tst->arch)
 #define ARG6    SYSCALL_ARG6(tst->arch)
 
-#define SET_RESULT(val)                                \
-   do { PLATFORM_SET_SYSCALL_RESULT(tst->arch, (val)); \
-        tst->syscall_result_set = True;                \
+#define SET_RESULT(val)                            \
+   do { VGP_SET_SYSCALL_RESULT(tst->arch, (val));  \
+        tst->syscall_result_set = True;            \
    } while (0)
 
 #define PRINT(format, args...)  \
@@ -1736,24 +1736,24 @@ extern void VG_(user_assert_fail) ( const Char* expr, const Char* file,
 // ---------------------------------------------------------------------
 
 // Accessors for the ThreadArchState
-#define SYSCALL_NUM(regs)  ((regs).vex.PLATFORM_SYSCALL_NUM)
-#define SYSCALL_ARG1(regs) ((regs).vex.PLATFORM_SYSCALL_ARG1)
-#define SYSCALL_ARG2(regs) ((regs).vex.PLATFORM_SYSCALL_ARG2)
-#define SYSCALL_ARG3(regs) ((regs).vex.PLATFORM_SYSCALL_ARG3)
-#define SYSCALL_ARG4(regs) ((regs).vex.PLATFORM_SYSCALL_ARG4)
-#define SYSCALL_ARG5(regs) ((regs).vex.PLATFORM_SYSCALL_ARG5)
-#define SYSCALL_ARG6(regs) ((regs).vex.PLATFORM_SYSCALL_ARG6)
-#define SYSCALL_RET(regs)  ((regs).vex.PLATFORM_SYSCALL_RET)
+#define SYSCALL_NUM(regs)  ((regs).vex.VGP_SYSCALL_NUM)
+#define SYSCALL_ARG1(regs) ((regs).vex.VGP_SYSCALL_ARG1)
+#define SYSCALL_ARG2(regs) ((regs).vex.VGP_SYSCALL_ARG2)
+#define SYSCALL_ARG3(regs) ((regs).vex.VGP_SYSCALL_ARG3)
+#define SYSCALL_ARG4(regs) ((regs).vex.VGP_SYSCALL_ARG4)
+#define SYSCALL_ARG5(regs) ((regs).vex.VGP_SYSCALL_ARG5)
+#define SYSCALL_ARG6(regs) ((regs).vex.VGP_SYSCALL_ARG6)
+#define SYSCALL_RET(regs)  ((regs).vex.VGP_SYSCALL_RET)
 
 // Offsets for the shadow state
-#define O_SYSCALL_NUM   (offsetof(VexGuestArchState, PLATFORM_SYSCALL_NUM))
-#define O_SYSCALL_ARG1  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG1))
-#define O_SYSCALL_ARG2  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG2))
-#define O_SYSCALL_ARG3  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG3))
-#define O_SYSCALL_ARG4  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG4))
-#define O_SYSCALL_ARG5  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG5))
-#define O_SYSCALL_ARG6  (offsetof(VexGuestArchState, PLATFORM_SYSCALL_ARG6))
-#define O_SYSCALL_RET   (offsetof(VexGuestArchState, PLATFORM_SYSCALL_RET))
+#define O_SYSCALL_NUM   (offsetof(VexGuestArchState, VGP_SYSCALL_NUM))
+#define O_SYSCALL_ARG1  (offsetof(VexGuestArchState, VGP_SYSCALL_ARG1))
+#define O_SYSCALL_ARG2  (offsetof(VexGuestArchState, VGP_SYSCALL_ARG2))
+#define O_SYSCALL_ARG3  (offsetof(VexGuestArchState, VGP_SYSCALL_ARG3))
+#define O_SYSCALL_ARG4  (offsetof(VexGuestArchState, VGP_SYSCALL_ARG4))
+#define O_SYSCALL_ARG5  (offsetof(VexGuestArchState, VGP_SYSCALL_ARG5))
+#define O_SYSCALL_ARG6  (offsetof(VexGuestArchState, VGP_SYSCALL_ARG6))
+#define O_SYSCALL_RET   (offsetof(VexGuestArchState, VGP_SYSCALL_RET))
 
 struct SyscallTableEntry {
    UInt  *flags_ptr;

diff --git a/coregrind/vg_memory.c b/coregrind/vg_memory.c
index 680c3decb0cb92bdd5dc03a6b0037c47736d5224..421f70d98313000cca61315c288a486cb42934dc 100644 (file)
--- a/coregrind/vg_memory.c
+++ b/coregrind/vg_memory.c
@@ -956,9 +956,9 @@ void VG_(pad_address_space)(Addr start)
    
    while (s && addr <= VG_(valgrind_last)) {
       if (addr < s->addr) {
-         PLATFORM_DO_MMAP(ret, addr, s->addr - addr, 0,
-                          VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS,
-                          -1, 0);
+         VGP_DO_MMAP(ret, addr, s->addr - addr, 0,
+                     VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS,
+                     -1, 0);
       }
       addr = s->addr + s->len;
       i++;
@@ -966,9 +966,9 @@ void VG_(pad_address_space)(Addr start)
    }
 
    if (addr <= VG_(valgrind_last)) {
-      PLATFORM_DO_MMAP(ret, addr, VG_(valgrind_last) - addr + 1, 0,
-                       VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS,
-                       -1, 0);
+      VGP_DO_MMAP(ret, addr, VG_(valgrind_last) - addr + 1, 0,
+                  VKI_MAP_FIXED | VKI_MAP_PRIVATE | VKI_MAP_ANONYMOUS,
+                  -1, 0);
    }
 }
 

diff --git a/coregrind/vg_mylibc.c b/coregrind/vg_mylibc.c
index 03fe1e6438d8857fd5ea60082e292723128568bf..3240992931199e5f964068e3fe578d5597fce303 100644 (file)
--- a/coregrind/vg_mylibc.c
+++ b/coregrind/vg_mylibc.c
@@ -282,9 +282,8 @@ static Addr mmap_inner(void *start, SizeT length, UInt prot, UInt flags,
 {
    Int ret;
    
-   PLATFORM_DO_MMAP(ret, start, length, prot,
-                    flags & ~(VKI_MAP_NOSYMS|VKI_MAP_CLIENT),
-                    fd, offset);
+   VGP_DO_MMAP(ret, start, length, prot,
+               flags & ~(VKI_MAP_NOSYMS|VKI_MAP_CLIENT), fd, offset);
    return ret;
 }
 

diff --git a/coregrind/vg_scheduler.c b/coregrind/vg_scheduler.c
index 66eba36655521a3d16819cab7d6dd93ccadd1934..05efde522f8b4eeebc7569a3eae77646d41b8811 100644 (file)
--- a/coregrind/vg_scheduler.c
+++ b/coregrind/vg_scheduler.c
@@ -427,7 +427,7 @@ void VG_(resume_scheduler)(ThreadId tid)
       /* Can't continue; must longjmp back to the scheduler and thus
          enter the sighandler immediately. */
    
-      LONGJMP(tst->sched_jmpbuf, True);
+      VGP_LONGJMP(tst->sched_jmpbuf, True);
    }
 }
 
@@ -435,7 +435,7 @@ void VG_(resume_scheduler)(ThreadId tid)
    do {                                                                        \
       ThreadState * volatile _qq_tst = VG_(get_ThreadState)(tid);      \
                                                                        \
-      (jumped) = SETJMP(_qq_tst->sched_jmpbuf);                                \
+      (jumped) = VGP_SETJMP(_qq_tst->sched_jmpbuf);                     \
       if ((jumped) == 0) {                                             \
         vg_assert(!_qq_tst->sched_jmpbuf_valid);                       \
         _qq_tst->sched_jmpbuf_valid = True;                            \

diff --git a/coregrind/vg_signals.c b/coregrind/vg_signals.c
index 431c2b744e62c953c7f9f251b22286203eeb32bf..4ed12695b83c1b2283a35eee43d080567661dfef 100644 (file)
--- a/coregrind/vg_signals.c
+++ b/coregrind/vg_signals.c
@@ -1805,7 +1805,7 @@ void vg_sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext
       VG_(message)(Vg_DebugMsg, "signal %d arrived ... si_code=%d, EIP=%p, eip=%p",
                    sigNo, info->si_code, 
                   INSTR_PTR(VG_(threads)[tid].arch), 
-                  UCONTEXT_INSTR_PTR(uc) );
+                  VGP_UCONTEXT_INSTR_PTR(uc) );
    }
    vg_assert(sigNo >= 1 && sigNo <= VG_(max_signal));
 
@@ -1913,7 +1913,7 @@ void vg_sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext
                   sigNo, signame(sigNo));
 
       buf[0] = 0;
-      context_ip = UCONTEXT_INSTR_PTR(uc);
+      context_ip = VGP_UCONTEXT_INSTR_PTR(uc);
       if (1 && !VG_(get_fnname)(context_ip, buf+2, sizeof(buf)-5)) {
         Int len;
 
@@ -1928,7 +1928,7 @@ void vg_sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext
                   "si_code=%x Fault EIP: %p%s; Faulting address: %p",
                   info->si_code, context_ip, buf, info->_sifields._sigfault._addr);
       VG_(message)(Vg_DebugMsg, 
-                  "  sp=%p\n", UCONTEXT_STACK_PTR(uc));
+                  "  sp=%p\n", VGP_UCONTEXT_STACK_PTR(uc));
 
       if (0)
         VG_(kill_self)(sigNo);         /* generate a core dump */
@@ -1937,9 +1937,9 @@ void vg_sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext
         tid = VG_(master_tid);
       tst = VG_(get_ThreadState)(tid);
       VG_(get_StackTrace2)(ips, VG_(clo_backtrace_size), 
-                           UCONTEXT_INSTR_PTR(uc),
-                           UCONTEXT_FRAME_PTR(uc),
-                           UCONTEXT_STACK_PTR(uc),
+                           VGP_UCONTEXT_INSTR_PTR(uc),
+                           VGP_UCONTEXT_FRAME_PTR(uc),
+                           VGP_UCONTEXT_STACK_PTR(uc),
                            (Addr)(tst->os_state.stack + tst->os_state.stacksize));
       VG_(core_panic_at)("Killed by fatal signal", ips);
    }

diff --git a/coregrind/vg_syscalls.c b/coregrind/vg_syscalls.c
index b0b1c756dce9c2a786b078797f9904962fa52006..e048d1601bfad0f9defd9d3bbcb09a7413891d3e 100644 (file)
--- a/coregrind/vg_syscalls.c
+++ b/coregrind/vg_syscalls.c
@@ -4408,7 +4408,7 @@ PRE(old_mmap, Special)
    UInt a1, a2, a3, a4, a5, a6;
 
    PRE_REG_READ1(long, "old_mmap", struct mmap_arg_struct *, args);
-   PLATFORM_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6);
+   VGP_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6);
 
    PRINT("old_mmap ( %p, %llu, %d, %d, %d, %d )",
          a1, (ULong)a2, a3, a4, a5, a6 );
@@ -4444,7 +4444,7 @@ PRE(old_mmap, Special)
    }
 
    if (RES != -VKI_ENOMEM) {
-      PLATFORM_DO_MMAP(RES, a1, a2, a3, a4, a5, a6);
+      VGP_DO_MMAP(RES, a1, a2, a3, a4, a5, a6);
       SET_RESULT(RES);
 
       if (!VG_(is_kerror)(RES)) {

diff --git a/coregrind/x86-linux/core_platform.h b/coregrind/x86-linux/core_platform.h
index c4af70f6b0b7f3e6ca6180937f07fe4d53f43fdf..036c052f0c8ce61bcb861102787b11b3942b26a3 100644 (file)
--- a/coregrind/x86-linux/core_platform.h
+++ b/coregrind/x86-linux/core_platform.h
@@ -40,18 +40,17 @@
    ------------------------------------------------------------------ */
 
 // Accessors for the ThreadArchState
-#define PLATFORM_SYSCALL_NUM     guest_EAX
-#define PLATFORM_SYSCALL_ARG1    guest_EBX
-#define PLATFORM_SYSCALL_ARG2    guest_ECX
-#define PLATFORM_SYSCALL_ARG3    guest_EDX
-#define PLATFORM_SYSCALL_ARG4    guest_ESI
-#define PLATFORM_SYSCALL_ARG5    guest_EDI
-#define PLATFORM_SYSCALL_ARG6    guest_EBP
-#define PLATFORM_SYSCALL_RET     guest_EAX
+#define VGP_SYSCALL_NUM       guest_EAX
+#define VGP_SYSCALL_ARG1      guest_EBX
+#define VGP_SYSCALL_ARG2      guest_ECX
+#define VGP_SYSCALL_ARG3      guest_EDX
+#define VGP_SYSCALL_ARG4      guest_ESI
+#define VGP_SYSCALL_ARG5      guest_EDI
+#define VGP_SYSCALL_ARG6      guest_EBP
+#define VGP_SYSCALL_RET       guest_EAX
 
 // Setting a syscall result
-#define PLATFORM_SET_SYSCALL_RESULT(regs, val)     \
-   ((regs).vex.guest_EAX = (val))
+#define VGP_SET_SYSCALL_RESULT(regs, val)    ((regs).vex.guest_EAX = (val))
 
 // Setting thread regs and shadow regs from within the core
 #define SET_SYSCALL_RETVAL(zztid, zzval) \
@@ -83,17 +82,17 @@ extern Addr VG_(do_useseg) ( UInt seg_selector, Addr virtual_addr );
    ucontext stuff
    ------------------------------------------------------------------ */
 
-#define UCONTEXT_INSTR_PTR(uc)   ((uc)->uc_mcontext.eip)
-#define UCONTEXT_STACK_PTR(uc)   ((uc)->uc_mcontext.esp)
-#define UCONTEXT_FRAME_PTR(uc)   ((uc)->uc_mcontext.ebp)
-#define UCONTEXT_SYSCALL_NUM(uc) ((uc)->uc_mcontext.eax)
-#define UCONTEXT_SYSCALL_RET(uc) ((uc)->uc_mcontext.eax)
+#define VGP_UCONTEXT_INSTR_PTR(uc)     ((uc)->uc_mcontext.eip)
+#define VGP_UCONTEXT_STACK_PTR(uc)     ((uc)->uc_mcontext.esp)
+#define VGP_UCONTEXT_FRAME_PTR(uc)     ((uc)->uc_mcontext.ebp)
+#define VGP_UCONTEXT_SYSCALL_NUM(uc)   ((uc)->uc_mcontext.eax)
+#define VGP_UCONTEXT_SYSCALL_RET(uc)   ((uc)->uc_mcontext.eax)
 
 /* ---------------------------------------------------------------------
    mmap() stuff
    ------------------------------------------------------------------ */
 
-#define PLATFORM_DO_MMAP(ret, start, length, prot, flags, fd, offset) { \
+#define VGP_DO_MMAP(ret, start, length, prot, flags, fd, offset) {      \
    UWord __args[6];                                                     \
                                                                         \
    __args[0] = (UWord)(start);                                          \
@@ -106,7 +105,7 @@ extern Addr VG_(do_useseg) ( UInt seg_selector, Addr virtual_addr );
    ret = VG_(do_syscall1)(__NR_mmap, (UWord)(&(__args[0])) );           \
 } while (0)
 
-#define PLATFORM_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do {\
+#define VGP_GET_MMAP_ARGS(tst, a1, a2, a3, a4, a5, a6) do {     \
    UInt *arg_block = (UInt*)SYSCALL_ARG1(tst->arch);            \
    PRE_MEM_READ( "old_mmap(args)", (Addr)arg_block, 6*sizeof(UWord) );\
    a1 = arg_block[0];                                           \
@@ -189,8 +188,8 @@ static __inline__ void __futex_commit(void)
    state, but does need to pass though "val". */
 #include <setjmp.h>       /* for jmp_buf         */
 
-#define SETJMP(env)            setjmp(env)
-#define LONGJMP(env, val)      longjmp(env, val)
+#define VGP_SETJMP(env)       setjmp(env)
+#define VGP_LONGJMP(env, val) longjmp(env, val)
 
 #endif   // __X86_LINUX_CORE_PLATFORM_H
 

diff --git a/coregrind/x86-linux/syscalls.c b/coregrind/x86-linux/syscalls.c
index 998c90ce6c32cd7b236ea6ddb4964ee22456f1a8..b4f7fc8182105d48b5de48c037a3cd577bc10ece 100644 (file)
--- a/coregrind/x86-linux/syscalls.c
+++ b/coregrind/x86-linux/syscalls.c
@@ -108,11 +108,11 @@ void VGA_(interrupted_syscall)(ThreadId tid,
 
    ThreadState *tst = VG_(get_ThreadState)(tid);
    ThreadArchState *th_regs = &tst->arch;
-   Word eip = UCONTEXT_INSTR_PTR(uc);
+   Word eip = VGP_UCONTEXT_INSTR_PTR(uc);
 
    if (debug)
       VG_(printf)("interrupted_syscall: eip=%p; restart=%d eax=%d\n", 
-                 eip, restart, UCONTEXT_SYSCALL_NUM(uc));
+                 eip, restart, VGP_UCONTEXT_SYSCALL_NUM(uc));
 
    if (eip < VGA_(blksys_setup) || eip >= VGA_(blksys_finished)) {
       VG_(printf)("  not in syscall (%p - %p)\n", VGA_(blksys_setup), VGA_(blksys_finished));
@@ -134,7 +134,7 @@ void VGA_(interrupted_syscall)(ThreadId tid,
       if (restart)
         VGA_(restart_syscall)(th_regs);
       else {
-        th_regs->vex.PLATFORM_SYSCALL_RET = -VKI_EINTR;
+        th_regs->vex.VGP_SYSCALL_RET = -VKI_EINTR;
         VG_(post_syscall)(tid);
       }
    } else if (eip >= VGA_(blksys_complete) && eip < VGA_(blksys_committed)) {
@@ -142,8 +142,8 @@ void VGA_(interrupted_syscall)(ThreadId tid,
         The saved real CPU %eax has the result, which we need to move
         to EAX. */
       if (debug)
-        VG_(printf)("  completed: ret=%d\n", UCONTEXT_SYSCALL_RET(uc));
-      th_regs->vex.PLATFORM_SYSCALL_RET = UCONTEXT_SYSCALL_RET(uc);
+        VG_(printf)("  completed: ret=%d\n", VGP_UCONTEXT_SYSCALL_RET(uc));
+      th_regs->vex.VGP_SYSCALL_RET = VGP_UCONTEXT_SYSCALL_RET(uc);
       VG_(post_syscall)(tid);
    } else if (eip >= VGA_(blksys_committed) && eip < VGA_(blksys_finished)) {
       /* Result committed, but the signal mask has not been restored;
@@ -336,7 +336,7 @@ static Int do_clone(ThreadId ptid,
    */
    VGA_(setup_child)( &ctst->arch, &ptst->arch );
 
-   PLATFORM_SET_SYSCALL_RESULT(ctst->arch, 0);
+   VGP_SET_SYSCALL_RESULT(ctst->arch, 0);
    if (esp != 0)
       ctst->arch.vex.guest_ESP = esp;