Use "VGA_" prefix more consistently.

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

diff --git a/coregrind/amd64/core_arch.h b/coregrind/amd64/core_arch.h
index 681539012c26586eeecbf3c6e0e2e001b4933841..41816308b119b6e6b25864e1521660268ed2ea34 100644 (file)
--- a/coregrind/amd64/core_arch.h
+++ b/coregrind/amd64/core_arch.h
@@ -60,26 +60,26 @@
 #define VGA_PTHREQ_RET        guest_RDX
 
 // Register numbers, for vg_symtab2.c
-#define R_STACK_PTR           4
-#define R_FRAME_PTR           5
+#define VGA_R_STACK_PTR       4
+#define VGA_R_FRAME_PTR       5
 
 // Stack frame layout and linkage
-#define FIRST_STACK_FRAME(rbp)         (rbp)
-#define STACK_FRAME_RET(rbp)           (((UWord*)rbp)[1])
-#define STACK_FRAME_NEXT(rbp)          (((UWord*)rbp)[0])
+#define VGA_FIRST_STACK_FRAME(rbp)     (rbp)
+#define VGA_STACK_FRAME_RET(rbp)       (((UWord*)rbp)[1])
+#define VGA_STACK_FRAME_NEXT(rbp)      (((UWord*)rbp)[0])
 
 // Get stack pointer and frame pointer
-#define ARCH_GET_REAL_STACK_PTR(lval) do {   \
+#define VGA_GET_REAL_STACK_PTR(lval) do {   \
    asm("movq %%rsp, %0" : "=r" (lval));      \
 } while (0)
 
-#define ARCH_GET_REAL_FRAME_PTR(lval) do {   \
+#define VGA_GET_REAL_FRAME_PTR(lval) do {   \
    asm("movq %%rbp, %0" : "=r" (lval));      \
 } while (0)
 
 // On AMD64, it's ok to access up to 128 bytes below %rsp.
 // The signal handler needs to know this.
-#define ARCH_STACK_REDZONE_SIZE 128
+#define VGA_STACK_REDZONE_SIZE 128
 
 /* ---------------------------------------------------------------------
    Architecture-specific part of a ThreadState

diff --git a/coregrind/arm/core_arch.h b/coregrind/arm/core_arch.h
index 00d5dcfed6c9a4f0ee7d8d9679226ce0542096a6..dcddc98cfc9e1db7c60e6ba1df8b65828ab5080f 100644 (file)
--- a/coregrind/arm/core_arch.h
+++ b/coregrind/arm/core_arch.h
@@ -66,21 +66,21 @@
 #define VGA_PTHREQ_RET        guest_R0
 
 // Register numbers, for vg_symtab2.c
-#define R_STACK_PTR           13
-#define R_FRAME_PTR           11
+#define VGA_R_STACK_PTR       13
+#define VGA_R_FRAME_PTR       11
 
 // Stack frame layout and linkage
 // XXX ToDo: ???
-#define FIRST_STACK_FRAME(ebp)         (ebp)
-#define STACK_FRAME_RET(ebp)           (((UInt*)ebp)[1])
-#define STACK_FRAME_NEXT(ebp)          (((UInt*)ebp)[0])
+#define VGA_FIRST_STACK_FRAME(ebp)     (ebp)
+#define VGA_STACK_FRAME_RET(ebp)       (((UInt*)ebp)[1])
+#define VGA_STACK_FRAME_NEXT(ebp)      (((UInt*)ebp)[0])
 
 // Get stack pointer and frame pointer
-#define ARCH_GET_REAL_STACK_PTR(esp) do {   \
+#define VGA_GET_REAL_STACK_PTR(esp) do {   \
    I_die_here; \
 } while (0)
 
-#define ARCH_GET_REAL_FRAME_PTR(ebp) do {   \
+#define VGA_GET_REAL_FRAME_PTR(ebp) do {   \
    I_die_here; \
 } while (0)
 

diff --git a/coregrind/arm/signals.c b/coregrind/arm/signals.c
index 717a3845c0a70844f5b431bfc412eb112fcf5f41..206bbc3541b51ca6c89aa9b15af6a2551f1b007d 100644 (file)
--- a/coregrind/arm/signals.c
+++ b/coregrind/arm/signals.c
@@ -152,7 +152,7 @@ static void synth_ucontext(ThreadId tid, const vki_siginfo_t *si,
 
 #if 0
 #define SET_SIGNAL_ESP(zztid, zzval) \
-   SET_THREAD_REG(zztid, zzval, VGA_STACK_PTR, R_STACK_PTR, \
+   SET_THREAD_REG(zztid, zzval, VGA_STACK_PTR, VGA_R_STACK_PTR, \
                   post_reg_write_deliver_signal)
 #endif
 

diff --git a/coregrind/stacktrace.c b/coregrind/stacktrace.c
index fb6c8dc5d90f0e7b418621260510290e1572d5ca..c3784efd899c0fc30c614c596773ff934449416e 100644 (file)
--- a/coregrind/stacktrace.c
+++ b/coregrind/stacktrace.c
@@ -80,7 +80,7 @@ UInt VG_(get_StackTrace2) ( Addr* ips, UInt n_ips, Addr ip, Addr fp,
    } else {
       /* Get whatever we safely can ... */
       ips[0] = ip;
-      fp = FIRST_STACK_FRAME(fp);
+      fp = VGA_FIRST_STACK_FRAME(fp);
       for (i = 1; i < n_ips; i++) {
          if (!(fp_min <= fp && fp <= fp_max)) {
            if (debug)
@@ -92,8 +92,8 @@ UInt VG_(get_StackTrace2) ( Addr* ips, UInt n_ips, Addr ip, Addr fp,
          //   VG_(printf)("nonmonotonic\n");
          //    break; /* fp gone nonmonotonic */
          // }
-         ips[i] = STACK_FRAME_RET(fp);  /* ret addr */
-         fp     = STACK_FRAME_NEXT(fp);  /* old fp */
+         ips[i] = VGA_STACK_FRAME_RET(fp);  /* ret addr */
+         fp     = VGA_STACK_FRAME_NEXT(fp);  /* old fp */
         if (debug)
            VG_(printf)("     ips[%d]=%08p\n", i, ips[i]);
       }

diff --git a/coregrind/vg_mylibc.c b/coregrind/vg_mylibc.c
index 3f261fd81c7f416ff86ded8a6e2b5fab55d8b3c1..03fe1e6438d8857fd5ea60082e292723128568bf 100644 (file)
--- a/coregrind/vg_mylibc.c
+++ b/coregrind/vg_mylibc.c
@@ -1137,8 +1137,8 @@ static inline void get_and_pp_real_StackTrace(Addr ret)
    ThreadId tid = VG_(get_lwp_tid)(VG_(gettid)());
    ThreadState *tst = VG_(get_ThreadState)(tid);
 
-   ARCH_GET_REAL_STACK_PTR(sp);
-   ARCH_GET_REAL_FRAME_PTR(fp);
+   VGA_GET_REAL_STACK_PTR(sp);
+   VGA_GET_REAL_FRAME_PTR(fp);
 
    stacktop = (Addr)(tst->os_state.stack + tst->os_state.stacksize);
 

diff --git a/coregrind/vg_redir.c b/coregrind/vg_redir.c
index 79d1d55a59209fd0a46dc381e85a0617b65b549b..5461202d2203c16225281b3e775d1760029f93d7 100644 (file)
--- a/coregrind/vg_redir.c
+++ b/coregrind/vg_redir.c
@@ -533,14 +533,14 @@ void VG_(setup_code_redirect_table) ( void )
 //:: /* Called from generated code via helper */
 //:: void VG_(wrap_before)(ThreadState *tst, const FuncWrapper *wrapper)
 //:: {
-//::    Addr retaddr = ARCH_RETADDR(tst->arch);
-//::    Addr argp = (Addr)&ARCH_FUNC_ARG(tst->arch, 0);
+//::    Addr retaddr = VGA_RETADDR(tst->arch);
+//::    Addr argp = (Addr)&VGA_FUNC_ARG(tst->arch, 0);
 //::    void *nonce = NULL;
 //::    Bool mf = VG_(my_fault);
 //::    VG_(my_fault) = True;
 //:: 
 //::    if (wrapper->before) {
-//::       va_list args = ARCH_VA_LIST(tst->arch);
+//::       va_list args = VGA_VA_LIST(tst->arch);
 //::       nonce = (*wrapper->before)(args);
 //::    }
 //:: 

diff --git a/coregrind/vg_signals.c b/coregrind/vg_signals.c
index 3d1021072c788ecb502cb99175e9277435449ccb..431c2b744e62c953c7f9f251b22286203eeb32bf 100644 (file)
--- a/coregrind/vg_signals.c
+++ b/coregrind/vg_signals.c
@@ -1834,14 +1834,14 @@ void vg_sync_signalhandler ( Int sigNo, vki_siginfo_t *info, struct vki_ucontext
                         VG_(shadow_base), VG_(shadow_end));
       }
       if (info->si_code == 1 /* SEGV_MAPERR */
-         && fault >= (esp - ARCH_STACK_REDZONE_SIZE)
+         && fault >= (esp - VGA_STACK_REDZONE_SIZE)
           && fault < VG_(client_end)) {
         /* If the fault address is above esp but below the current known
            stack segment base, and it was a fault because there was
            nothing mapped there (as opposed to a permissions fault),
            then extend the stack segment. 
         */
-         Addr base = PGROUNDDN(esp - ARCH_STACK_REDZONE_SIZE);
+         Addr base = PGROUNDDN(esp - VGA_STACK_REDZONE_SIZE);
         if (VG_(extend_stack)(base, VG_(threads)[tid].stack_size)) {
            if (VG_(clo_trace_signals))
               VG_(message)(Vg_DebugMsg, 

diff --git a/coregrind/vg_symtab2.c b/coregrind/vg_symtab2.c
index 179c582fdaab459dc15c208ee375eab1b827c61d..e252ca311f5deebe19d6edc92ad954d53eddecaa 100644 (file)
--- a/coregrind/vg_symtab2.c
+++ b/coregrind/vg_symtab2.c
@@ -2139,7 +2139,7 @@ Variable *VG_(get_scope_variables)(ThreadId tid)
         case SyEBPrel:
         case SyESPrel:
            reg = *regaddr(tid, sym->kind == SyESPrel ? 
-                                R_STACK_PTR : R_FRAME_PTR);
+                                VGA_R_STACK_PTR : VGA_R_FRAME_PTR);
            if (debug)
               VG_(printf)("reg=%p+%d=%p\n", reg, sym->u.offset, reg+sym->u.offset);
            v->valuep = (Addr)(reg + sym->u.offset);

diff --git a/coregrind/x86/core_arch.h b/coregrind/x86/core_arch.h
index 63a2f546f9c85f90d289341d83ed030bb26f97a4..683c01ab2f91d8b55af685435b785b786b385f28 100644 (file)
--- a/coregrind/x86/core_arch.h
+++ b/coregrind/x86/core_arch.h
@@ -61,26 +61,26 @@
 
 
 // Register numbers, for vg_symtab2.c
-#define R_STACK_PTR           4
-#define R_FRAME_PTR           5
+#define VGA_R_STACK_PTR       4
+#define VGA_R_FRAME_PTR       5
 
 // Stack frame layout and linkage
-#define FIRST_STACK_FRAME(ebp)         (ebp)
-#define STACK_FRAME_RET(ebp)           (((UInt*)ebp)[1])
-#define STACK_FRAME_NEXT(ebp)          (((UInt*)ebp)[0])
+#define VGA_FIRST_STACK_FRAME(ebp)     (ebp)
+#define VGA_STACK_FRAME_RET(ebp)       (((UInt*)ebp)[1])
+#define VGA_STACK_FRAME_NEXT(ebp)      (((UInt*)ebp)[0])
 
 // Get stack pointer and frame pointer
-#define ARCH_GET_REAL_STACK_PTR(esp) do {   \
+#define VGA_GET_REAL_STACK_PTR(esp) do {   \
    asm("movl %%esp, %0" : "=r" (esp));       \
 } while (0)
 
-#define ARCH_GET_REAL_FRAME_PTR(ebp) do {   \
+#define VGA_GET_REAL_FRAME_PTR(ebp) do {   \
    asm("movl %%ebp, %0" : "=r" (ebp));       \
 } while (0)
 
 // On X86, any access below %esp is illegal.
 // The signal handler needs to know this.
-#define ARCH_STACK_REDZONE_SIZE 0
+#define VGA_STACK_REDZONE_SIZE 0
 
 //extern const Char VG_(helper_wrapper_before)[];      /* in dispatch.S */
 //extern const Char VG_(helper_wrapper_return)[];      /* in dispatch.S */

diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c
index 3013aeb172dc6fd5308f14d9ca356dc567e42c8d..c9c054793465a0af94b9ab4e1c2421e54faeda62 100644 (file)
--- a/helgrind/hg_main.c
+++ b/helgrind/hg_main.c
@@ -2080,8 +2080,8 @@ UCodeBlock* TL_(instrument) ( UCodeBlock* cb_in, Addr not_used )
            tl_assert(u_in->val2 < ntemps);
 
            stackref[u_in->val2] = (u_in->size == 4 &&
-                                   (u_in->val1 == R_STACK_PTR ||
-                                     u_in->val1 == R_FRAME_PTR));
+                                   (u_in->val1 == VGA_R_STACK_PTR ||
+                                     u_in->val1 == VGA_R_FRAME_PTR));
            VG_(copy_UInstr)(cb, u_in);
            break;