[ust.git] / include / ust / processor.h

/* Copyright (C) 2009  Pierre-Marc Fournier
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
 */

#ifndef UST_PROCESSOR_H
#define UST_PROCESSOR_H

#include <stddef.h>
#include <string.h>

extern __thread long ust_reg_stack[500];
extern volatile __thread long *ust_reg_stack_ptr;

#ifndef __x86_64

struct registers {
	short ss;
	short cs;
	long esi;
	long ebp;
	long edx;
	long edi;
	long ecx;
	long ebx;
	long eax;
	long eflags;
	long esp;
};

#ifdef CONFIG_UST_GDB_INTEGRATION

/* save_registers - saves most of the processor's registers so
 * they are available to the probe. gdb uses this to give the
 * value of local variables.
 *
 * Saving all registers without losing any of their values is
 * tricky.
 *
 * We cannot pass to the asm stub the address of a registers structure
 * on the stack, because it will use a register and override its value.
 *
 * We don't want to use a stub to push the regs on the stack and then
 * another stub to copy them to a structure because changing %sp in asm
 * and then returning to C (even briefly) can have unexpected results.
 * Also, gcc might modify %sp between the stubs in reaction to the
 * register needs of the second stub that needs to know where to copy
 * the register values.
 *
 * So the chosen approach is to use another stack, declared in thread-
 * local storage, to push the registers. They are subsequently copied
 * to the stack, by C code.
 */

#define save_registers(regsptr) \
	asm volatile ( \
	     /* save original esp */ \
	     "pushl %%esp\n\t" \
	     /* push original eflags */ \
	     "pushfl\n\t" \
	      /* eax will hold the ptr to the private stack bottom */ \
	     "pushl %%eax\n\t" \
	     /* ebx is used for TLS access */ \
	     "pushl %%ebx\n\t" \
	     /* ecx will be used to temporarily hold the stack bottom addr */\
	     "pushl %%ecx\n\t"						     \
	     /* rdi is the input to __tls_get_addr, and also a temp var */   \
	     "pushl %%edi\n\t"						     \
	     /* For TLS access, we have to do function calls. However,	     \
	      * we must not lose the original value of:			     \
	      *   esp, eflags, eax, ebx, ecx, edx, esi, edi, ebp, cs, ss     \
	      *								     \
	      * Some registers' original values have already been saved:     \
	      *   esp, eflags, eax, ebx, ecx, edi			     \
	      *								     \
	      * In addition, the i386 ABI says the following registers belong\
	      * to the caller function:					     \
	      *   esp, ebp, esi, edi, ebx				     \
	      *								     \
	      * The following registers should not be changed by the callee: \
	      *   cs, ss						     \
	      *								     \
	      * Therefore, the following registers must be explicitly 	     \
	      * preserved:						     \
	      *   edx							     \
	      */ \
	     "pushl %%edx\n\t" \
	     /* Get GOT address */ \
	     "call __i686.get_pc_thunk.bx\n\t" \
	     "addl $_GLOBAL_OFFSET_TABLE_, %%ebx\n\t" \
	     /* Start TLS access of private reg stack pointer */ \
	     "leal ust_reg_stack_ptr@tlsgd(,%%ebx,1),%%eax\n\t" \
	     "call ___tls_get_addr@plt\n\t" \
	     /* --- End TLS access */ \
	     /* check if ust_reg_stack_ptr has been initialized */ \
	     "movl (%%eax),%%ecx\n\t" \
	     "testl %%ecx,%%ecx\n\t" \
	     "jne 1f\n\t" \
	     "movl %%eax,%%ecx\n\t" \
	     /* Save ecx because we are using it. */ \
	     "pushl %%ecx\n\t" \
	     /* Start TLS access of private reg stack */ \
	     "leal ust_reg_stack@tlsgd(,%%ebx,1),%%eax\n\t" \
	     "call ___tls_get_addr@plt\n\t" \
	     /* --- End TLS access */ \
	     "popl %%ecx\n\t" \
	     "addl $500,%%eax\n\t" \
	     "movl %%eax,(%%ecx)\n\t" \
	     "movl %%ecx,%%eax\n\t" \
	     /* now the pointer to the private stack is in eax. \
	        must add stack size so the ptr points to the stack bottom. */ \
	"1:\n\t" \
	     /* edx was pushed for function calls */ \
	     "popl %%edx\n\t" \
	     /* Manually push esp to private stack */ \
	     "addl $-4,(%%eax)\n\t" \
	     "movl 20(%%esp), %%edi\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%edi, (%%ebx)\n\t" \
	     /* Manually push eflags to private stack */ \
	     "addl $-4,(%%eax)\n\t" \
	     "movl 16(%%esp), %%edi\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%edi, (%%ebx)\n\t" \
	     /* Manually push eax to private stack */ \
	     "addl $-4,(%%eax)\n\t" \
	     "movl 12(%%esp), %%edi\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%edi, (%%ebx)\n\t" \
	     /* Manually push ebx to private stack */ \
	     "addl $-4,(%%eax)\n\t" \
	     "movl 8(%%esp), %%edi\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%edi, (%%ebx)\n\t" \
	     /* Manually push ecx to private stack */ \
	     "addl $-4,(%%eax)\n\t" \
	     "movl 4(%%esp), %%edi\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%edi, (%%ebx)\n\t" \
	     /* Manually push edi to private stack */ \
	     "addl $-4,(%%eax)\n\t" \
	     "movl 0(%%esp), %%edi\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%edi, (%%ebx)\n\t" \
	     /* now push regs to tls */ \
	     /* -- esp already pushed -- */ \
	     /* -- eax already pushed -- */ \
	     /* -- ebx already pushed -- */ \
	     /* -- ecx already pushed -- */ \
	     /* -- edi already pushed -- */ \
	     "addl $-4,(%%eax)\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%edx,(%%ebx)\n\t" \
	     "addl $-4,(%%eax)\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%ebp,(%%ebx)\n\t" \
	     "addl $-4,(%%eax)\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movl %%esi,(%%ebx)\n\t" \
	     /* push cs */ \
	     "addl $-2,(%%eax)\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movw %%cs, (%%ebx)\n\t" \
	     /* push ss */ \
	     "addl $-2,(%%eax)\n\t" \
	     "movl (%%eax), %%ebx\n\t" \
	     "movw %%ss, (%%ebx)\n\t" \
	     /* restore original values of regs that were used internally */ \
	     "popl %%edi\n\t" \
	     "popl %%ecx\n\t" \
	     "popl %%ebx\n\t" \
	     "popl %%eax\n\t" \
	     /* cancel push of rsp */ \
	     "addl $4,%%esp\n\t" \
	     /* cancel push of eflags */ \
	     "addl $4,%%esp\n\t" \
	     ::: "memory"); \
	memcpy(regsptr, (void *)ust_reg_stack_ptr, sizeof(struct registers)); \
	ust_reg_stack_ptr = (void *)(((long)ust_reg_stack_ptr) + sizeof(struct registers));

#else /* CONFIG_UST_GDB_INTEGRATION */

#define save_registers(a)

#endif /* CONFIG_UST_GDB_INTEGRATION */

#define RELATIVE_ADDRESS(__rel_label__) __rel_label__

#define ARCH_COPY_ADDR(src, dst) "lea " src "," dst

#define _ASM_PTR ".long "

#else /* below is code for x86-64 */

struct registers {
	int padding; /* 4 bytes */
	short ss;
	short cs;
	unsigned long r15;
	unsigned long r14;
	unsigned long r13;
	unsigned long r12;
	unsigned long r11;
	unsigned long r10;
	unsigned long r9;
	unsigned long r8;
	unsigned long rsi;
	unsigned long rbp;
	unsigned long rdx;
	unsigned long rcx;
	unsigned long rdi;
	unsigned long rbx;
	unsigned long rax;
	unsigned long rflags;
	unsigned long rsp;
};

#ifdef CONFIG_UST_GDB_INTEGRATION

#define save_registers(regsptr) \
	asm volatile ( \
	     /* save original rsp */ \
	     "pushq %%rsp\n\t" \
	     /* push original rflags */ \
	     "pushfq\n\t" \
	      /* rax will hold the ptr to the private stack bottom */ \
	     "pushq %%rax\n\t" \
	     /* rbx will be used to temporarily hold the stack bottom addr */ \
	     "pushq %%rbx\n\t" \
	     /* rdi is the input to __tls_get_addr, and also a temp var */ \
	     "pushq %%rdi\n\t" \
	     /* For TLS access, we have to do function calls. However,	     \
	      * we must not lose the original value of:			     \
	      *   rsp, rflags, rax, rbx, rcx, rdx, rsi, rdi, rbp, r8, r9     \
	      *   r10, r11, r12, r13, r14, r15, cs, ss			     \
	      *								     \
	      * Some registers' original values have already been saved:     \
	      *   rsp, rflags, rax, rbx, rdi				     \
	      *								     \
	      * In addition, the x86-64 ABI says the following registers     \
	      * belong to the caller function:				     \
	      *   rbp, rbx, r12, r13, r14, r15				     \
	      *								     \
	      * The following registers should not be changed by the callee: \
	      *   cs, ss						     \
	      *								     \
	      * Therefore, the following registers must be explicitly 	     \
	      * preserved:						     \
	      *   rcx, rdx, rsi, r8, r9, r10, r11			     \
	      */ \
	     "pushq %%rcx\n\t" \
	     "pushq %%rdx\n\t" \
	     "pushq %%rsi\n\t" \
	     "pushq %%r8\n\t" \
	     "pushq %%r9\n\t" \
	     "pushq %%r10\n\t" \
	     "pushq %%r11\n\t" \
	     /* Start TLS access of private reg stack pointer */ \
	     ".byte 0x66\n\t" \
	     "leaq ust_reg_stack_ptr@tlsgd(%%rip), %%rdi\n\t" \
	     ".word 0x6666\n\t" \
	     "rex64\n\t" \
	     "call __tls_get_addr@plt\n\t" \
	     /* --- End TLS access */ \
	     /* check if ust_reg_stack_ptr has been initialized */ \
	     "movq (%%rax),%%rbx\n\t" \
	     "testq %%rbx,%%rbx\n\t" \
	     "jne 1f\n\t" \
	     "movq %%rax,%%rbx\n\t" \
	     /* Start TLS access of private reg stack */ \
	     ".byte 0x66\n\t" \
	     "leaq ust_reg_stack@tlsgd(%%rip), %%rdi\n\t" \
	     ".word 0x6666\n\t" \
	     "rex64\n\t" \
	     "call __tls_get_addr@plt\n\t" \
	     /* --- End TLS access */ \
	     "addq $500,%%rax\n\t" \
	     "movq %%rax,(%%rbx)\n\t" \
	     "movq %%rbx,%%rax\n\t" \
	     /* now the pointer to the private stack is in rax.
	        must add stack size so the ptr points to the stack bottom. */ \
	"1:\n\t" \
	     /* Pop regs that were pushed for function calls */ \
	     "popq %%r11\n\t" \
	     "popq %%r10\n\t" \
	     "popq %%r9\n\t" \
	     "popq %%r8\n\t" \
	     "popq %%rsi\n\t" \
	     "popq %%rdx\n\t" \
	     "popq %%rcx\n\t" \
	     /* Manually push rsp to private stack */ \
	     "addq $-8,(%%rax)\n\t" \
	     "movq 32(%%rsp), %%rdi\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rdi, (%%rbx)\n\t" \
	     /* Manually push eflags to private stack */ \
	     "addq $-8,(%%rax)\n\t" \
	     "movq 24(%%rsp), %%rdi\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rdi, (%%rbx)\n\t" \
	     /* Manually push rax to private stack */ \
	     "addq $-8,(%%rax)\n\t" \
	     "movq 16(%%rsp), %%rdi\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rdi, (%%rbx)\n\t" \
	     /* Manually push rbx to private stack */ \
	     "addq $-8,(%%rax)\n\t" \
	     "movq 8(%%rsp), %%rdi\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rdi, (%%rbx)\n\t" \
	     /* Manually push rdi to private stack */ \
	     "addq $-8,(%%rax)\n\t" \
	     "movq 0(%%rsp), %%rdi\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rdi, (%%rbx)\n\t" \
	     /* now push regs to tls */ \
	     /* -- rsp already pushed -- */ \
	     /* -- rax already pushed -- */ \
	     /* -- rbx already pushed -- */ \
	     /* -- rdi already pushed -- */ \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rcx,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rdx,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rbp,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%rsi,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r8,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r9,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r10,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r11,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r12,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r13,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r14,(%%rbx)\n\t" \
	     "addq $-8,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movq %%r15,(%%rbx)\n\t" \
	     /* push cs */ \
	     "addq $-2,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movw %%cs, (%%rbx)\n\t" \
	     /* push ss */ \
	     "addq $-2,(%%rax)\n\t" \
	     "movq (%%rax), %%rbx\n\t" \
	     "movw %%ss, (%%rbx)\n\t" \
	     /* add padding for struct registers */ \
	     "addq $-4,(%%rax)\n\t" \
	     /* restore original values of regs that were used internally */ \
	     "popq %%rdi\n\t" \
	     "popq %%rbx\n\t" \
	     "popq %%rax\n\t" \
	     /* cancel push of rsp */ \
	     "addq $8,%%rsp\n\t" \
	     /* cancel push of rflags */ \
	     "addq $8,%%rsp\n\t" \
	     ::); \
	memcpy(regsptr, (void *)ust_reg_stack_ptr, sizeof(struct registers)); \
	ust_reg_stack_ptr = (void *)(((long)ust_reg_stack_ptr) + sizeof(struct registers));

#else /* CONFIG_UST_GDB_INTEGRATION */

#define save_registers(a)

#endif /* CONFIG_UST_GDB_INTEGRATION */

/* Macro to insert the address of a relative jump in an assembly stub,
 * in a relocatable way. On x86-64, this uses a special (%rip) notation. */
#define RELATIVE_ADDRESS(__rel_label__) __rel_label__(%%rip)

#define ARCH_COPY_ADDR(src, dst) "lea " src "(%%rip)," dst

#define _ASM_PTR ".quad "

#endif

#endif /* UST_PROCESSOR_H */
Commit	Line	Data
a09dac63 PMF	1	/* Copyright (C) 2009 Pierre-Marc Fournier
	2	*
	3	* This library is free software; you can redistribute it and/or
	4	* modify it under the terms of the GNU Lesser General Public
	5	* License as published by the Free Software Foundation; either
	6	* version 2.1 of the License, or (at your option) any later version.
	7	*
	8	* This library is distributed in the hope that it will be useful,
	9	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	11	* Lesser General Public License for more details.
	12	*
	13	* You should have received a copy of the GNU Lesser General Public
	14	* License along with this library; if not, write to the Free Software
	15	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	16	*/
	17
5af57e62 PMF	18	#ifndef UST_PROCESSOR_H
5af57e62 PMF	19	#define UST_PROCESSOR_H
d98a01c6 PMF	20
d98a01c6 PMF	21	#include <stddef.h>
636ca5d6 PMF	22	#include <string.h>
	23
	24	extern __thread long ust_reg_stack[500];
	25	extern volatile __thread long *ust_reg_stack_ptr;
	26
e003d6ee	27	#ifndef __x86_64
d98a01c6 PMF	28
d98a01c6 PMF	29	struct registers {
7756d65a PMF	30	short ss;
7756d65a PMF	31	short cs;
d98a01c6	32	long esi;
7756d65a PMF	33	long ebp;
7756d65a PMF	34	long edx;
d98a01c6	35	long edi;
f2496f58	36	long ecx;
7756d65a PMF	37	long ebx;
7756d65a PMF	38	long eax;
d98a01c6	39	long eflags;
7756d65a	40	long esp;
d98a01c6 PMF	41	};
d98a01c6 PMF	42
e003d6ee	43	#ifdef CONFIG_UST_GDB_INTEGRATION
defa46a7	44
55c5b393 PMF	45	/* save_registers - saves most of the processor's registers so
	46	* they are available to the probe. gdb uses this to give the
	47	* value of local variables.
	48	*
	49	* Saving all registers without losing any of their values is
	50	* tricky.
	51	*
	52	* We cannot pass to the asm stub the address of a registers structure
	53	* on the stack, because it will use a register and override its value.
	54	*
	55	* We don't want to use a stub to push the regs on the stack and then
	56	* another stub to copy them to a structure because changing %sp in asm
	57	* and then returning to C (even briefly) can have unexpected results.
	58	* Also, gcc might modify %sp between the stubs in reaction to the
	59	* register needs of the second stub that needs to know where to copy
	60	* the register values.
	61	*
	62	* So the chosen approach is to use another stack, declared in thread-
	63	* local storage, to push the registers. They are subsequently copied
	64	* to the stack, by C code.
	65	*/
7756d65a PMF	66
	67	#define save_registers(regsptr) \
	68	asm volatile ( \
	69	/* save original esp */ \
	70	"pushl %%esp\n\t" \
	71	/* push original eflags */ \
	72	"pushfl\n\t" \
	73	/* eax will hold the ptr to the private stack bottom */ \
	74	"pushl %%eax\n\t" \
f2496f58	75	/* ebx is used for TLS access */ \
7756d65a	76	"pushl %%ebx\n\t" \
55c5b393 PMF	77	/* ecx will be used to temporarily hold the stack bottom addr */\
	78	"pushl %%ecx\n\t" \
	79	/* rdi is the input to __tls_get_addr, and also a temp var */ \
	80	"pushl %%edi\n\t" \
	81	/* For TLS access, we have to do function calls. However, \
	82	* we must not lose the original value of: \
	83	* esp, eflags, eax, ebx, ecx, edx, esi, edi, ebp, cs, ss \
	84	* \
	85	* Some registers' original values have already been saved: \
	86	* esp, eflags, eax, ebx, ecx, edi \
	87	* \
	88	* In addition, the i386 ABI says the following registers belong\
	89	* to the caller function: \
	90	* esp, ebp, esi, edi, ebx \
	91	* \
	92	* The following registers should not be changed by the callee: \
	93	* cs, ss \
	94	* \
	95	* Therefore, the following registers must be explicitly \
	96	* preserved: \
	97	* edx \
	98	*/ \
	99	"pushl %%edx\n\t" \
f2496f58 PMF	100	/* Get GOT address */ \
	101	"call __i686.get_pc_thunk.bx\n\t" \
	102	"addl $_GLOBAL_OFFSET_TABLE_, %%ebx\n\t" \
7756d65a PMF	103	/* Start TLS access of private reg stack pointer */ \
	104	"leal ust_reg_stack_ptr@tlsgd(,%%ebx,1),%%eax\n\t" \
	105	"call ___tls_get_addr@plt\n\t" \
	106	/* --- End TLS access */ \
	107	/* check if ust_reg_stack_ptr has been initialized */ \
f2496f58 PMF	108	"movl (%%eax),%%ecx\n\t" \
f2496f58 PMF	109	"testl %%ecx,%%ecx\n\t" \
7756d65a	110	"jne 1f\n\t" \
f2496f58	111	"movl %%eax,%%ecx\n\t" \
55c5b393	112	/* Save ecx because we are using it. */ \
f2496f58	113	"pushl %%ecx\n\t" \
7756d65a PMF	114	/* Start TLS access of private reg stack */ \
	115	"leal ust_reg_stack@tlsgd(,%%ebx,1),%%eax\n\t" \
	116	"call ___tls_get_addr@plt\n\t" \
	117	/* --- End TLS access */ \
f2496f58	118	"popl %%ecx\n\t" \
7756d65a	119	"addl $500,%%eax\n\t" \
f2496f58 PMF	120	"movl %%eax,(%%ecx)\n\t" \
f2496f58 PMF	121	"movl %%ecx,%%eax\n\t" \
7756d65a PMF	122	/* now the pointer to the private stack is in eax. \
	123	must add stack size so the ptr points to the stack bottom. */ \
	124	"1:\n\t" \
55c5b393 PMF	125	/* edx was pushed for function calls */ \
55c5b393 PMF	126	"popl %%edx\n\t" \
7756d65a PMF	127	/* Manually push esp to private stack */ \
7756d65a PMF	128	"addl $-4,(%%eax)\n\t" \
f2496f58	129	"movl 20(%%esp), %%edi\n\t" \
7756d65a PMF	130	"movl (%%eax), %%ebx\n\t" \
	131	"movl %%edi, (%%ebx)\n\t" \
	132	/* Manually push eflags to private stack */ \
	133	"addl $-4,(%%eax)\n\t" \
f2496f58	134	"movl 16(%%esp), %%edi\n\t" \
7756d65a PMF	135	"movl (%%eax), %%ebx\n\t" \
	136	"movl %%edi, (%%ebx)\n\t" \
	137	/* Manually push eax to private stack */ \
	138	"addl $-4,(%%eax)\n\t" \
f2496f58	139	"movl 12(%%esp), %%edi\n\t" \
7756d65a PMF	140	"movl (%%eax), %%ebx\n\t" \
	141	"movl %%edi, (%%ebx)\n\t" \
	142	/* Manually push ebx to private stack */ \
	143	"addl $-4,(%%eax)\n\t" \
f2496f58 PMF	144	"movl 8(%%esp), %%edi\n\t" \
	145	"movl (%%eax), %%ebx\n\t" \
	146	"movl %%edi, (%%ebx)\n\t" \
	147	/* Manually push ecx to private stack */ \
	148	"addl $-4,(%%eax)\n\t" \
7756d65a PMF	149	"movl 4(%%esp), %%edi\n\t" \
	150	"movl (%%eax), %%ebx\n\t" \
	151	"movl %%edi, (%%ebx)\n\t" \
	152	/* Manually push edi to private stack */ \
	153	"addl $-4,(%%eax)\n\t" \
	154	"movl 0(%%esp), %%edi\n\t" \
	155	"movl (%%eax), %%ebx\n\t" \
	156	"movl %%edi, (%%ebx)\n\t" \
	157	/* now push regs to tls */ \
	158	/* -- esp already pushed -- */ \
	159	/* -- eax already pushed -- */ \
	160	/* -- ebx already pushed -- */ \
f2496f58	161	/* -- ecx already pushed -- */ \
7756d65a PMF	162	/* -- edi already pushed -- */ \
	163	"addl $-4,(%%eax)\n\t" \
	164	"movl (%%eax), %%ebx\n\t" \
7756d65a PMF	165	"movl %%edx,(%%ebx)\n\t" \
	166	"addl $-4,(%%eax)\n\t" \
	167	"movl (%%eax), %%ebx\n\t" \
	168	"movl %%ebp,(%%ebx)\n\t" \
	169	"addl $-4,(%%eax)\n\t" \
	170	"movl (%%eax), %%ebx\n\t" \
	171	"movl %%esi,(%%ebx)\n\t" \
	172	/* push cs */ \
	173	"addl $-2,(%%eax)\n\t" \
	174	"movl (%%eax), %%ebx\n\t" \
	175	"movw %%cs, (%%ebx)\n\t" \
	176	/* push ss */ \
	177	"addl $-2,(%%eax)\n\t" \
	178	"movl (%%eax), %%ebx\n\t" \
	179	"movw %%ss, (%%ebx)\n\t" \
	180	/* restore original values of regs that were used internally */ \
	181	"popl %%edi\n\t" \
f2496f58	182	"popl %%ecx\n\t" \
7756d65a PMF	183	"popl %%ebx\n\t" \
	184	"popl %%eax\n\t" \
	185	/* cancel push of rsp */ \
	186	"addl $4,%%esp\n\t" \
	187	/* cancel push of eflags */ \
	188	"addl $4,%%esp\n\t" \
	189	::: "memory"); \
	190	memcpy(regsptr, (void *)ust_reg_stack_ptr, sizeof(struct registers)); \
	191	ust_reg_stack_ptr = (void *)(((long)ust_reg_stack_ptr) + sizeof(struct registers));
defa46a7	192
e003d6ee	193	#else /* CONFIG_UST_GDB_INTEGRATION */
defa46a7	194
defa46a7 PMF	195	#define save_registers(a)
defa46a7 PMF	196
e003d6ee	197	#endif /* CONFIG_UST_GDB_INTEGRATION */
d98a01c6	198
9e8f4f52 PMF	199	#define RELATIVE_ADDRESS(__rel_label__) __rel_label__
9e8f4f52 PMF	200
9692fa18 PMF	201	#define ARCH_COPY_ADDR(src, dst) "lea " src "," dst
9692fa18 PMF	202
9e8f4f52 PMF	203	#define _ASM_PTR ".long "
9e8f4f52 PMF	204
defa46a7	205	#else /* below is code for x86-64 */
d98a01c6 PMF	206
d98a01c6 PMF	207	struct registers {
636ca5d6 PMF	208	int padding; /* 4 bytes */
	209	short ss;
	210	short cs;
636ca5d6 PMF	211	unsigned long r15;
	212	unsigned long r14;
	213	unsigned long r13;
	214	unsigned long r12;
	215	unsigned long r11;
	216	unsigned long r10;
	217	unsigned long r9;
	218	unsigned long r8;
d98a01c6	219	unsigned long rsi;
636ca5d6 PMF	220	unsigned long rbp;
	221	unsigned long rdx;
	222	unsigned long rcx;
d98a01c6	223	unsigned long rdi;
636ca5d6 PMF	224	unsigned long rbx;
636ca5d6 PMF	225	unsigned long rax;
a5850bc4	226	unsigned long rflags;
636ca5d6	227	unsigned long rsp;
d98a01c6 PMF	228	};
d98a01c6 PMF	229
e003d6ee	230	#ifdef CONFIG_UST_GDB_INTEGRATION
defa46a7	231
8524c98d	232	#define save_registers(regsptr) \
636ca5d6 PMF	233	asm volatile ( \
	234	/* save original rsp */ \
	235	"pushq %%rsp\n\t" \
a5850bc4 PMF	236	/* push original rflags */ \
a5850bc4 PMF	237	"pushfq\n\t" \
636ca5d6 PMF	238	/* rax will hold the ptr to the private stack bottom */ \
	239	"pushq %%rax\n\t" \
	240	/* rbx will be used to temporarily hold the stack bottom addr */ \
	241	"pushq %%rbx\n\t" \
	242	/* rdi is the input to __tls_get_addr, and also a temp var */ \
	243	"pushq %%rdi\n\t" \
55c5b393 PMF	244	/* For TLS access, we have to do function calls. However, \
	245	* we must not lose the original value of: \
	246	* rsp, rflags, rax, rbx, rcx, rdx, rsi, rdi, rbp, r8, r9 \
	247	* r10, r11, r12, r13, r14, r15, cs, ss \
	248	* \
	249	* Some registers' original values have already been saved: \
	250	* rsp, rflags, rax, rbx, rdi \
	251	* \
	252	* In addition, the x86-64 ABI says the following registers \
	253	* belong to the caller function: \
	254	* rbp, rbx, r12, r13, r14, r15 \
	255	* \
	256	* The following registers should not be changed by the callee: \
	257	* cs, ss \
	258	* \
	259	* Therefore, the following registers must be explicitly \
	260	* preserved: \
	261	* rcx, rdx, rsi, r8, r9, r10, r11 \
	262	*/ \
	263	"pushq %%rcx\n\t" \
	264	"pushq %%rdx\n\t" \
	265	"pushq %%rsi\n\t" \
	266	"pushq %%r8\n\t" \
	267	"pushq %%r9\n\t" \
	268	"pushq %%r10\n\t" \
	269	"pushq %%r11\n\t" \
a5850bc4	270	/* Start TLS access of private reg stack pointer */ \
636ca5d6 PMF	271	".byte 0x66\n\t" \
	272	"leaq ust_reg_stack_ptr@tlsgd(%%rip), %%rdi\n\t" \
	273	".word 0x6666\n\t" \
	274	"rex64\n\t" \
	275	"call __tls_get_addr@plt\n\t" \
	276	/* --- End TLS access */ \
a5850bc4 PMF	277	/* check if ust_reg_stack_ptr has been initialized */ \
	278	"movq (%%rax),%%rbx\n\t" \
	279	"testq %%rbx,%%rbx\n\t" \
	280	"jne 1f\n\t" \
	281	"movq %%rax,%%rbx\n\t" \
	282	/* Start TLS access of private reg stack */ \
	283	".byte 0x66\n\t" \
	284	"leaq ust_reg_stack@tlsgd(%%rip), %%rdi\n\t" \
	285	".word 0x6666\n\t" \
	286	"rex64\n\t" \
	287	"call __tls_get_addr@plt\n\t" \
	288	/* --- End TLS access */ \
	289	"addq $500,%%rax\n\t" \
	290	"movq %%rax,(%%rbx)\n\t" \
	291	"movq %%rbx,%%rax\n\t" \
	292	/* now the pointer to the private stack is in rax.
	293	must add stack size so the ptr points to the stack bottom. */ \
	294	"1:\n\t" \
55c5b393 PMF	295	/* Pop regs that were pushed for function calls */ \
	296	"popq %%r11\n\t" \
	297	"popq %%r10\n\t" \
	298	"popq %%r9\n\t" \
	299	"popq %%r8\n\t" \
	300	"popq %%rsi\n\t" \
	301	"popq %%rdx\n\t" \
	302	"popq %%rcx\n\t" \
636ca5d6 PMF	303	/* Manually push rsp to private stack */ \
636ca5d6 PMF	304	"addq $-8,(%%rax)\n\t" \
a5850bc4 PMF	305	"movq 32(%%rsp), %%rdi\n\t" \
	306	"movq (%%rax), %%rbx\n\t" \
	307	"movq %%rdi, (%%rbx)\n\t" \
	308	/* Manually push eflags to private stack */ \
	309	"addq $-8,(%%rax)\n\t" \
636ca5d6 PMF	310	"movq 24(%%rsp), %%rdi\n\t" \
	311	"movq (%%rax), %%rbx\n\t" \
	312	"movq %%rdi, (%%rbx)\n\t" \
	313	/* Manually push rax to private stack */ \
	314	"addq $-8,(%%rax)\n\t" \
	315	"movq 16(%%rsp), %%rdi\n\t" \
	316	"movq (%%rax), %%rbx\n\t" \
	317	"movq %%rdi, (%%rbx)\n\t" \
	318	/* Manually push rbx to private stack */ \
	319	"addq $-8,(%%rax)\n\t" \
	320	"movq 8(%%rsp), %%rdi\n\t" \
	321	"movq (%%rax), %%rbx\n\t" \
	322	"movq %%rdi, (%%rbx)\n\t" \
	323	/* Manually push rdi to private stack */ \
	324	"addq $-8,(%%rax)\n\t" \
	325	"movq 0(%%rsp), %%rdi\n\t" \
	326	"movq (%%rax), %%rbx\n\t" \
	327	"movq %%rdi, (%%rbx)\n\t" \
	328	/* now push regs to tls */ \
	329	/* -- rsp already pushed -- */ \
	330	/* -- rax already pushed -- */ \
	331	/* -- rbx already pushed -- */ \
	332	/* -- rdi already pushed -- */ \
	333	"addq $-8,(%%rax)\n\t" \
	334	"movq (%%rax), %%rbx\n\t" \
	335	"movq %%rcx,(%%rbx)\n\t" \
	336	"addq $-8,(%%rax)\n\t" \
	337	"movq (%%rax), %%rbx\n\t" \
	338	"movq %%rdx,(%%rbx)\n\t" \
	339	"addq $-8,(%%rax)\n\t" \
	340	"movq (%%rax), %%rbx\n\t" \
	341	"movq %%rbp,(%%rbx)\n\t" \
	342	"addq $-8,(%%rax)\n\t" \
	343	"movq (%%rax), %%rbx\n\t" \
	344	"movq %%rsi,(%%rbx)\n\t" \
	345	"addq $-8,(%%rax)\n\t" \
	346	"movq (%%rax), %%rbx\n\t" \
	347	"movq %%r8,(%%rbx)\n\t" \
	348	"addq $-8,(%%rax)\n\t" \
	349	"movq (%%rax), %%rbx\n\t" \
	350	"movq %%r9,(%%rbx)\n\t" \
	351	"addq $-8,(%%rax)\n\t" \
	352	"movq (%%rax), %%rbx\n\t" \
	353	"movq %%r10,(%%rbx)\n\t" \
	354	"addq $-8,(%%rax)\n\t" \
	355	"movq (%%rax), %%rbx\n\t" \
	356	"movq %%r11,(%%rbx)\n\t" \
	357	"addq $-8,(%%rax)\n\t" \
	358	"movq (%%rax), %%rbx\n\t" \
	359	"movq %%r12,(%%rbx)\n\t" \
	360	"addq $-8,(%%rax)\n\t" \
	361	"movq (%%rax), %%rbx\n\t" \
	362	"movq %%r13,(%%rbx)\n\t" \
	363	"addq $-8,(%%rax)\n\t" \
	364	"movq (%%rax), %%rbx\n\t" \
	365	"movq %%r14,(%%rbx)\n\t" \
	366	"addq $-8,(%%rax)\n\t" \
	367	"movq (%%rax), %%rbx\n\t" \
	368	"movq %%r15,(%%rbx)\n\t" \
636ca5d6 PMF	369	/* push cs */ \
	370	"addq $-2,(%%rax)\n\t" \
	371	"movq (%%rax), %%rbx\n\t" \
	372	"movw %%cs, (%%rbx)\n\t" \
	373	/* push ss */ \
	374	"addq $-2,(%%rax)\n\t" \
	375	"movq (%%rax), %%rbx\n\t" \
	376	"movw %%ss, (%%rbx)\n\t" \
	377	/* add padding for struct registers */ \
	378	"addq $-4,(%%rax)\n\t" \
	379	/* restore original values of regs that were used internally */ \
	380	"popq %%rdi\n\t" \
	381	"popq %%rbx\n\t" \
	382	"popq %%rax\n\t" \
	383	/* cancel push of rsp */ \
	384	"addq $8,%%rsp\n\t" \
a5850bc4 PMF	385	/* cancel push of rflags */ \
a5850bc4 PMF	386	"addq $8,%%rsp\n\t" \
636ca5d6 PMF	387	::); \
	388	memcpy(regsptr, (void *)ust_reg_stack_ptr, sizeof(struct registers)); \
	389	ust_reg_stack_ptr = (void *)(((long)ust_reg_stack_ptr) + sizeof(struct registers));
d98a01c6	390
fc1f31ab PMF	391	#else /* CONFIG_UST_GDB_INTEGRATION */
fc1f31ab PMF	392
fc1f31ab PMF	393	#define save_registers(a)
fc1f31ab PMF	394
e003d6ee	395	#endif /* CONFIG_UST_GDB_INTEGRATION */
defa46a7	396
9e8f4f52 PMF	397	/* Macro to insert the address of a relative jump in an assembly stub,
	398	* in a relocatable way. On x86-64, this uses a special (%rip) notation. */
	399	#define RELATIVE_ADDRESS(__rel_label__) __rel_label__(%%rip)
	400
9692fa18 PMF	401	#define ARCH_COPY_ADDR(src, dst) "lea " src "(%%rip)," dst
9692fa18 PMF	402
9e8f4f52 PMF	403	#define _ASM_PTR ".quad "
9e8f4f52 PMF	404
d98a01c6 PMF	405	#endif
d98a01c6 PMF	406
5af57e62	407	#endif /* UST_PROCESSOR_H */