x86: rename the struct pt_regs members for 32/64-bit consistency

We have a lot of code which differs only by the naming of specific
members of structures that contain registers.  In order to enable
additional unifications, this patch drops the e- or r- size prefix
from the register names in struct pt_regs, and drops the x- prefixes
for segment registers on the 32-bit side.

This patch also performs the equivalent renames in some additional
places that might be candidates for unification in the future.

Signed-off-by: H. Peter Anvin <hpa@zytor.com>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

10 files changed, 147 insertions, 93 deletions

diff --git a/include/asm-x86/compat.h b/include/asm-x86/compat.h
index 66ba7987184a..b270ee04959e 100644
--- a/include/asm-x86/compat.h
+++ b/include/asm-x86/compat.h
@@ -207,7 +207,7 @@ static inline compat_uptr_t ptr_to_compat(void __user *uptr)
 static __inline__ void __user *compat_alloc_user_space(long len)
 {
         struct pt_regs *regs = task_pt_regs(current);
-        return (void __user *)regs->rsp - len; 
+        return (void __user *)regs->sp - len;
 }
 
 static inline int is_compat_task(void)
diff --git a/include/asm-x86/elf.h b/include/asm-x86/elf.h
index 60f5101d9483..5e5705bf082a 100644
--- a/include/asm-x86/elf.h
+++ b/include/asm-x86/elf.h
@@ -99,32 +99,32 @@ typedef struct user_fxsr_struct elf_fpxregset_t;
    just to make things more deterministic.
  */
 #define ELF_PLAT_INIT(_r, load_addr)    do { \
-        _r->ebx = 0; _r->ecx = 0; _r->edx = 0; \
-        _r->esi = 0; _r->edi = 0; _r->ebp = 0; \
-        _r->eax = 0; \
+        _r->bx = 0; _r->cx = 0; _r->dx = 0; \
+        _r->si = 0; _r->di = 0; _r->bp = 0; \
+        _r->ax = 0; \
 } while (0)
 
 /* regs is struct pt_regs, pr_reg is elf_gregset_t (which is
    now struct_user_regs, they are different) */
 
 #define ELF_CORE_COPY_REGS(pr_reg, regs)                \
-        pr_reg[0] = regs->ebx;                          \
-        pr_reg[1] = regs->ecx;                          \
-        pr_reg[2] = regs->edx;                          \
-        pr_reg[3] = regs->esi;                          \
-        pr_reg[4] = regs->edi;                          \
-        pr_reg[5] = regs->ebp;                          \
-        pr_reg[6] = regs->eax;                          \
-        pr_reg[7] = regs->xds & 0xffff;                 \
-        pr_reg[8] = regs->xes & 0xffff;                 \
-        pr_reg[9] = regs->xfs & 0xffff;                 \
+        pr_reg[0] = regs->bx;                           \
+        pr_reg[1] = regs->cx;                           \
+        pr_reg[2] = regs->dx;                           \
+        pr_reg[3] = regs->si;                           \
+        pr_reg[4] = regs->di;                           \
+        pr_reg[5] = regs->bp;                           \
+        pr_reg[6] = regs->ax;                           \
+        pr_reg[7] = regs->ds & 0xffff;                  \
+        pr_reg[8] = regs->es & 0xffff;                  \
+        pr_reg[9] = regs->fs & 0xffff;                  \
         savesegment(gs,pr_reg[10]);                     \
-        pr_reg[11] = regs->orig_eax;                    \
-        pr_reg[12] = regs->eip;                         \
-        pr_reg[13] = regs->xcs & 0xffff;                \
-        pr_reg[14] = regs->eflags;                      \
-        pr_reg[15] = regs->esp;                         \
-        pr_reg[16] = regs->xss & 0xffff;
+        pr_reg[11] = regs->orig_ax;                     \
+        pr_reg[12] = regs->ip;                          \
+        pr_reg[13] = regs->cs & 0xffff;                 \
+        pr_reg[14] = regs->flags;                       \
+        pr_reg[15] = regs->sp;                          \
+        pr_reg[16] = regs->ss & 0xffff;
 
 #define ELF_PLATFORM    (utsname()->machine)
 #define set_personality_64bit() do { } while (0)
@@ -142,9 +142,9 @@ extern unsigned int vdso_enabled;
 
 #define ELF_PLAT_INIT(_r, load_addr)    do {              \
         struct task_struct *cur = current;                \
-        (_r)->rbx = 0; (_r)->rcx = 0; (_r)->rdx = 0;      \
-        (_r)->rsi = 0; (_r)->rdi = 0; (_r)->rbp = 0;      \
-        (_r)->rax = 0;                                    \
+        (_r)->bx = 0; (_r)->cx = 0; (_r)->dx = 0;         \
+        (_r)->si = 0; (_r)->di = 0; (_r)->bp = 0;         \
+        (_r)->ax = 0;                                     \
         (_r)->r8 = 0;                                     \
         (_r)->r9 = 0;                                     \
         (_r)->r10 = 0;                                    \
@@ -169,22 +169,22 @@ extern unsigned int vdso_enabled;
         (pr_reg)[1] = (regs)->r14;                              \
         (pr_reg)[2] = (regs)->r13;                              \
         (pr_reg)[3] = (regs)->r12;                              \
-        (pr_reg)[4] = (regs)->rbp;                              \
-        (pr_reg)[5] = (regs)->rbx;                              \
+        (pr_reg)[4] = (regs)->bp;                               \
+        (pr_reg)[5] = (regs)->bx;                               \
         (pr_reg)[6] = (regs)->r11;                              \
         (pr_reg)[7] = (regs)->r10;                              \
         (pr_reg)[8] = (regs)->r9;                               \
         (pr_reg)[9] = (regs)->r8;                               \
-        (pr_reg)[10] = (regs)->rax;                             \
-        (pr_reg)[11] = (regs)->rcx;                             \
-        (pr_reg)[12] = (regs)->rdx;                             \
-        (pr_reg)[13] = (regs)->rsi;                             \
-        (pr_reg)[14] = (regs)->rdi;                             \
-        (pr_reg)[15] = (regs)->orig_rax;                        \
-        (pr_reg)[16] = (regs)->rip;                             \
+        (pr_reg)[10] = (regs)->ax;                              \
+        (pr_reg)[11] = (regs)->cx;                              \
+        (pr_reg)[12] = (regs)->dx;                              \
+        (pr_reg)[13] = (regs)->si;                              \
+        (pr_reg)[14] = (regs)->di;                              \
+        (pr_reg)[15] = (regs)->orig_ax;                 \
+        (pr_reg)[16] = (regs)->ip;                              \
         (pr_reg)[17] = (regs)->cs;                              \
-        (pr_reg)[18] = (regs)->eflags;                          \
-        (pr_reg)[19] = (regs)->rsp;                             \
+        (pr_reg)[18] = (regs)->flags;                           \
+        (pr_reg)[19] = (regs)->sp;                              \
         (pr_reg)[20] = (regs)->ss;                              \
         (pr_reg)[21] = current->thread.fs;                      \
         (pr_reg)[22] = current->thread.gs;                      \
diff --git a/include/asm-x86/kexec_32.h b/include/asm-x86/kexec_32.h
index 4b9dc9e6b701..ff39d2f88022 100644
--- a/include/asm-x86/kexec_32.h
+++ b/include/asm-x86/kexec_32.h
@@ -45,7 +45,7 @@
 /* We can also handle crash dumps from 64 bit kernel. */
 #define vmcore_elf_check_arch_cross(x) ((x)->e_machine == EM_X86_64)
 
-/* CPU does not save ss and esp on stack if execution is already
+/* CPU does not save ss and sp on stack if execution is already
  * running in kernel mode at the time of NMI occurrence. This code
  * fixes it.
  */
@@ -53,16 +53,16 @@ static inline void crash_fixup_ss_esp(struct pt_regs *newregs,
                                         struct pt_regs *oldregs)
 {
         memcpy(newregs, oldregs, sizeof(*newregs));
-        newregs->esp = (unsigned long)&(oldregs->esp);
+        newregs->sp = (unsigned long)&(oldregs->sp);
         __asm__ __volatile__(
                         "xorl %%eax, %%eax\n\t"
                         "movw %%ss, %%ax\n\t"
-                        :"=a"(newregs->xss));
+                        :"=a"(newregs->ss));
 }
 
 /*
  * This function is responsible for capturing register states if coming
- * via panic otherwise just fix up the ss and esp if coming via kernel
+ * via panic otherwise just fix up the ss and sp if coming via kernel
  * mode exception.
  */
 static inline void crash_setup_regs(struct pt_regs *newregs,
@@ -71,21 +71,21 @@ static inline void crash_setup_regs(struct pt_regs *newregs,
        if (oldregs)
                crash_fixup_ss_esp(newregs, oldregs);
        else {
-               __asm__ __volatile__("movl %%ebx,%0" : "=m"(newregs->ebx));
-               __asm__ __volatile__("movl %%ecx,%0" : "=m"(newregs->ecx));
-               __asm__ __volatile__("movl %%edx,%0" : "=m"(newregs->edx));
-               __asm__ __volatile__("movl %%esi,%0" : "=m"(newregs->esi));
-               __asm__ __volatile__("movl %%edi,%0" : "=m"(newregs->edi));
-               __asm__ __volatile__("movl %%ebp,%0" : "=m"(newregs->ebp));
-               __asm__ __volatile__("movl %%eax,%0" : "=m"(newregs->eax));
-               __asm__ __volatile__("movl %%esp,%0" : "=m"(newregs->esp));
-               __asm__ __volatile__("movw %%ss, %%ax;" :"=a"(newregs->xss));
-               __asm__ __volatile__("movw %%cs, %%ax;" :"=a"(newregs->xcs));
-               __asm__ __volatile__("movw %%ds, %%ax;" :"=a"(newregs->xds));
-               __asm__ __volatile__("movw %%es, %%ax;" :"=a"(newregs->xes));
-               __asm__ __volatile__("pushfl; popl %0" :"=m"(newregs->eflags));
+               __asm__ __volatile__("movl %%ebx,%0" : "=m"(newregs->bx));
+               __asm__ __volatile__("movl %%ecx,%0" : "=m"(newregs->cx));
+               __asm__ __volatile__("movl %%edx,%0" : "=m"(newregs->dx));
+               __asm__ __volatile__("movl %%esi,%0" : "=m"(newregs->si));
+               __asm__ __volatile__("movl %%edi,%0" : "=m"(newregs->di));
+               __asm__ __volatile__("movl %%ebp,%0" : "=m"(newregs->bp));
+               __asm__ __volatile__("movl %%eax,%0" : "=m"(newregs->ax));
+               __asm__ __volatile__("movl %%esp,%0" : "=m"(newregs->sp));
+               __asm__ __volatile__("movl %%ss, %%eax;" :"=a"(newregs->ss));
+               __asm__ __volatile__("movl %%cs, %%eax;" :"=a"(newregs->cs));
+               __asm__ __volatile__("movl %%ds, %%eax;" :"=a"(newregs->ds));
+               __asm__ __volatile__("movl %%es, %%eax;" :"=a"(newregs->es));
+               __asm__ __volatile__("pushfl; popl %0" :"=m"(newregs->flags));
 
-               newregs->eip = (unsigned long)current_text_addr();
+               newregs->ip = (unsigned long)current_text_addr();
        }
 }
 asmlinkage NORET_TYPE void
diff --git a/include/asm-x86/kexec_64.h b/include/asm-x86/kexec_64.h
index 738e581b67f8..b5f989b15c0b 100644
--- a/include/asm-x86/kexec_64.h
+++ b/include/asm-x86/kexec_64.h
@@ -60,14 +60,14 @@ static inline void crash_setup_regs(struct pt_regs *newregs,
         if (oldregs)
                 memcpy(newregs, oldregs, sizeof(*newregs));
         else {
-                __asm__ __volatile__("movq %%rbx,%0" : "=m"(newregs->rbx));
-                __asm__ __volatile__("movq %%rcx,%0" : "=m"(newregs->rcx));
-                __asm__ __volatile__("movq %%rdx,%0" : "=m"(newregs->rdx));
-                __asm__ __volatile__("movq %%rsi,%0" : "=m"(newregs->rsi));
-                __asm__ __volatile__("movq %%rdi,%0" : "=m"(newregs->rdi));
-                __asm__ __volatile__("movq %%rbp,%0" : "=m"(newregs->rbp));
-                __asm__ __volatile__("movq %%rax,%0" : "=m"(newregs->rax));
-                __asm__ __volatile__("movq %%rsp,%0" : "=m"(newregs->rsp));
+                __asm__ __volatile__("movq %%rbx,%0" : "=m"(newregs->bx));
+                __asm__ __volatile__("movq %%rcx,%0" : "=m"(newregs->cx));
+                __asm__ __volatile__("movq %%rdx,%0" : "=m"(newregs->dx));
+                __asm__ __volatile__("movq %%rsi,%0" : "=m"(newregs->si));
+                __asm__ __volatile__("movq %%rdi,%0" : "=m"(newregs->di));
+                __asm__ __volatile__("movq %%rbp,%0" : "=m"(newregs->bp));
+                __asm__ __volatile__("movq %%rax,%0" : "=m"(newregs->ax));
+                __asm__ __volatile__("movq %%rsp,%0" : "=m"(newregs->sp));
                 __asm__ __volatile__("movq %%r8,%0" : "=m"(newregs->r8));
                 __asm__ __volatile__("movq %%r9,%0" : "=m"(newregs->r9));
                 __asm__ __volatile__("movq %%r10,%0" : "=m"(newregs->r10));
@@ -78,9 +78,9 @@ static inline void crash_setup_regs(struct pt_regs *newregs,
                 __asm__ __volatile__("movq %%r15,%0" : "=m"(newregs->r15));
                 __asm__ __volatile__("movl %%ss, %%eax;" :"=a"(newregs->ss));
                 __asm__ __volatile__("movl %%cs, %%eax;" :"=a"(newregs->cs));
-                __asm__ __volatile__("pushfq; popq %0" :"=m"(newregs->eflags));
+                __asm__ __volatile__("pushfq; popq %0" :"=m"(newregs->flags));
 
-                newregs->rip = (unsigned long)current_text_addr();
+                newregs->ip = (unsigned long)current_text_addr();
         }
 }
 
diff --git a/include/asm-x86/kprobes_32.h b/include/asm-x86/kprobes_32.h
index 9fe8f3bddfd5..2f38315bc39f 100644
--- a/include/asm-x86/kprobes_32.h
+++ b/include/asm-x86/kprobes_32.h
@@ -84,7 +84,7 @@ struct kprobe_ctlblk {
  */
 static inline void restore_interrupts(struct pt_regs *regs)
 {
-        if (regs->eflags & IF_MASK)
+        if (regs->flags & IF_MASK)
                 local_irq_enable();
 }
 
diff --git a/include/asm-x86/kprobes_64.h b/include/asm-x86/kprobes_64.h
index 743d76218fc9..8c919d35cdd3 100644
--- a/include/asm-x86/kprobes_64.h
+++ b/include/asm-x86/kprobes_64.h
@@ -77,7 +77,7 @@ struct kprobe_ctlblk {
  */
 static inline void restore_interrupts(struct pt_regs *regs)
 {
-        if (regs->eflags & IF_MASK)
+        if (regs->flags & IF_MASK)
                 local_irq_enable();
 }
 
diff --git a/include/asm-x86/mce.h b/include/asm-x86/mce.h
index e6ff507a73b0..94f1fd79e22a 100644
--- a/include/asm-x86/mce.h
+++ b/include/asm-x86/mce.h
@@ -13,7 +13,7 @@
 #define MCG_CTL_P        (1UL<<8)   /* MCG_CAP register available */
 
 #define MCG_STATUS_RIPV  (1UL<<0)   /* restart ip valid */
-#define MCG_STATUS_EIPV  (1UL<<1)   /* eip points to correct instruction */
+#define MCG_STATUS_EIPV  (1UL<<1)   /* ip points to correct instruction */
 #define MCG_STATUS_MCIP  (1UL<<2)   /* machine check in progress */
 
 #define MCI_STATUS_VAL   (1UL<<63)  /* valid error */
@@ -30,7 +30,7 @@ struct mce {
         __u64 misc;
         __u64 addr;
         __u64 mcgstatus;
-        __u64 rip;
+        __u64 ip;
         __u64 tsc;      /* cpu time stamp counter */
         __u64 res1;     /* for future extension */
         __u64 res2;     /* dito. */
diff --git a/include/asm-x86/processor_32.h b/include/asm-x86/processor_32.h
index 3c67eacb3168..c85400fe58c4 100644
--- a/include/asm-x86/processor_32.h
+++ b/include/asm-x86/processor_32.h
@@ -398,14 +398,14 @@ struct thread_struct {
 
 #define start_thread(regs, new_eip, new_esp) do {               \
         __asm__("movl %0,%%gs": :"r" (0));                      \
-        regs->xfs = 0;                                          \
+        regs->fs = 0;                                           \
         set_fs(USER_DS);                                        \
-        regs->xds = __USER_DS;                                  \
-        regs->xes = __USER_DS;                                  \
-        regs->xss = __USER_DS;                                  \
-        regs->xcs = __USER_CS;                                  \
-        regs->eip = new_eip;                                    \
-        regs->esp = new_esp;                                    \
+        regs->ds = __USER_DS;                                   \
+        regs->es = __USER_DS;                                   \
+        regs->ss = __USER_DS;                                   \
+        regs->cs = __USER_CS;                                   \
+        regs->ip = new_eip;                                     \
+        regs->sp = new_esp;                                     \
 } while (0)
 
 /* Forward declaration, a strange C thing */
@@ -440,7 +440,7 @@ unsigned long get_wchan(struct task_struct *p);
  * is accessable even if the CPU haven't stored the SS/ESP registers
  * on the stack (interrupt gate does not save these registers
  * when switching to the same priv ring).
- * Therefore beware: accessing the xss/esp fields of the
+ * Therefore beware: accessing the ss/esp fields of the
  * "struct pt_regs" is possible, but they may contain the
  * completely wrong values.
  */
@@ -451,8 +451,8 @@ unsigned long get_wchan(struct task_struct *p);
        __regs__ - 1;                                                   \
 })
 
-#define KSTK_EIP(task) (task_pt_regs(task)->eip)
-#define KSTK_ESP(task) (task_pt_regs(task)->esp)
+#define KSTK_EIP(task) (task_pt_regs(task)->ip)
+#define KSTK_ESP(task) (task_pt_regs(task)->sp)
 
 
 struct microcode_header {
diff --git a/include/asm-x86/processor_64.h b/include/asm-x86/processor_64.h
index e7bea4fed642..797770113e6d 100644
--- a/include/asm-x86/processor_64.h
+++ b/include/asm-x86/processor_64.h
@@ -258,12 +258,12 @@ struct thread_struct {
 #define start_thread(regs,new_rip,new_rsp) do { \
         asm volatile("movl %0,%%fs; movl %0,%%es; movl %0,%%ds": :"r" (0));      \
         load_gs_index(0);                                                       \
-        (regs)->rip = (new_rip);                                                 \
-        (regs)->rsp = (new_rsp);                                                 \
+        (regs)->ip = (new_rip);                                          \
+        (regs)->sp = (new_rsp);                                          \
         write_pda(oldrsp, (new_rsp));                                            \
         (regs)->cs = __USER_CS;                                                  \
         (regs)->ss = __USER_DS;                                                  \
-        (regs)->eflags = 0x200;                                                  \
+        (regs)->flags = 0x200;                                                   \
         set_fs(USER_DS);                                                         \
 } while(0) 
 
@@ -297,7 +297,7 @@ extern long kernel_thread(int (*fn)(void *), void * arg, unsigned long flags);
 
 extern unsigned long get_wchan(struct task_struct *p);
 #define task_pt_regs(tsk) ((struct pt_regs *)(tsk)->thread.rsp0 - 1)
-#define KSTK_EIP(tsk) (task_pt_regs(tsk)->rip)
+#define KSTK_EIP(tsk) (task_pt_regs(tsk)->ip)
 #define KSTK_ESP(tsk) -1 /* sorry. doesn't work for syscall. */
 
 
diff --git a/include/asm-x86/ptrace.h b/include/asm-x86/ptrace.h
index 04204f359298..9187b2fab754 100644
--- a/include/asm-x86/ptrace.h
+++ b/include/asm-x86/ptrace.h
@@ -10,6 +10,8 @@
 /* this struct defines the way the registers are stored on the
    stack during a system call. */
 
+#ifndef __KERNEL__
+
 struct pt_regs {
         long ebx;
         long ecx;
@@ -21,7 +23,7 @@ struct pt_regs {
         int  xds;
         int  xes;
         int  xfs;
-        /* int  xgs; */
+        /* int  gs; */
         long orig_eax;
         long eip;
         int  xcs;
@@ -30,7 +32,27 @@ struct pt_regs {
         int  xss;
 };
 
-#ifdef __KERNEL__
+#else /* __KERNEL__ */
+
+struct pt_regs {
+        long bx;
+        long cx;
+        long dx;
+        long si;
+        long di;
+        long bp;
+        long ax;
+        int  ds;
+        int  es;
+        int  fs;
+        /* int  gs; */
+        long orig_ax;
+        long ip;
+        int  cs;
+        long flags;
+        long sp;
+        int  ss;
+};
 
 #include <asm/vm86.h>
 #include <asm/segment.h>
@@ -47,27 +69,30 @@ extern void send_sigtrap(struct task_struct *tsk, struct pt_regs *regs, int erro
  */
 static inline int user_mode(struct pt_regs *regs)
 {
-        return (regs->xcs & SEGMENT_RPL_MASK) == USER_RPL;
+        return (regs->cs & SEGMENT_RPL_MASK) == USER_RPL;
 }
 static inline int user_mode_vm(struct pt_regs *regs)
 {
-        return ((regs->xcs & SEGMENT_RPL_MASK) | (regs->eflags & VM_MASK)) >= USER_RPL;
+        return ((regs->cs & SEGMENT_RPL_MASK) |
+                (regs->flags & VM_MASK)) >= USER_RPL;
 }
 static inline int v8086_mode(struct pt_regs *regs)
 {
-        return (regs->eflags & VM_MASK);
+        return (regs->flags & VM_MASK);
 }
 
-#define instruction_pointer(regs) ((regs)->eip)
-#define frame_pointer(regs) ((regs)->ebp)
+#define instruction_pointer(regs) ((regs)->ip)
+#define frame_pointer(regs) ((regs)->bp)
 #define stack_pointer(regs) ((unsigned long)(regs))
-#define regs_return_value(regs) ((regs)->eax)
+#define regs_return_value(regs) ((regs)->ax)
 
 extern unsigned long profile_pc(struct pt_regs *regs);
 #endif /* __KERNEL__ */
 
 #else /* __i386__ */
 
+#ifndef __KERNEL__
+
 struct pt_regs {
         unsigned long r15;
         unsigned long r14;
@@ -96,14 +121,43 @@ struct pt_regs {
 /* top of stack page */
 };
 
-#ifdef __KERNEL__
+#else /* __KERNEL__ */
+
+struct pt_regs {
+        unsigned long r15;
+        unsigned long r14;
+        unsigned long r13;
+        unsigned long r12;
+        unsigned long bp;
+        unsigned long bx;
+/* arguments: non interrupts/non tracing syscalls only save upto here*/
+        unsigned long r11;
+        unsigned long r10;
+        unsigned long r9;
+        unsigned long r8;
+        unsigned long ax;
+        unsigned long cx;
+        unsigned long dx;
+        unsigned long si;
+        unsigned long di;
+        unsigned long orig_ax;
+/* end of arguments */
+/* cpu exception frame or undefined */
+        unsigned long ip;
+        unsigned long cs;
+        unsigned long flags;
+        unsigned long sp;
+        unsigned long ss;
+/* top of stack page */
+};
 
 #define user_mode(regs) (!!((regs)->cs & 3))
 #define user_mode_vm(regs) user_mode(regs)
-#define instruction_pointer(regs) ((regs)->rip)
-#define frame_pointer(regs) ((regs)->rbp)
-#define stack_pointer(regs) ((regs)->rsp)
-#define regs_return_value(regs) ((regs)->rax)
+#define v8086_mode(regs) 0      /* No V86 mode support in long mode */
+#define instruction_pointer(regs) ((regs)->ip)
+#define frame_pointer(regs) ((regs)->bp)
+#define stack_pointer(regs) ((regs)->sp)
+#define regs_return_value(regs) ((regs)->ax)
 
 extern unsigned long profile_pc(struct pt_regs *regs);
 void signal_fault(struct pt_regs *regs, void __user *frame, char *where);