coregrind/m_dispatch/dispatch-amd64-darwin.S - platform/external/valgrind - Git at Google


 /*--------------------------------------------------------------------*/
 /*--- The core dispatch loop, for jumping to a code address.       ---*/
 /*---                                      dispatch-amd64-darwin.S ---*/
 /*--------------------------------------------------------------------*/

 /*
   This file is part of Valgrind, a dynamic binary instrumentation
   framework.

   Copyright (C) 2000-2007 Julian Seward
      jseward@acm.org

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of the
   License, or (at your option) any later version.

   This program 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
   General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307, USA.

   The GNU General Public License is contained in the file COPYING.
 */

 #if defined(VGP_amd64_darwin)

 #include "pub_core_basics_asm.h"
 #include "pub_core_dispatch_asm.h"
 #include "pub_core_transtab_asm.h"
 #include "libvex_guest_offsets.h"	/* for OFFSET_amd64_RIP */


 /*------------------------------------------------------------*/
 /*---                                                      ---*/
 /*--- The dispatch loop.  VG_(run_innerloop) is used to    ---*/
 /*--- run all translations except no-redir ones.           ---*/
 /*---                                                      ---*/
 /*------------------------------------------------------------*/

 /*----------------------------------------------------*/
 /*--- Preamble (set everything up)                 ---*/
 /*----------------------------------------------------*/

 /* signature:
 UWord VG_(run_innerloop) ( void* guest_state, UWord do_profiling );
 */

 .text
 .globl VG_(run_innerloop)
 VG_(run_innerloop):
 	/* %rdi holds guest_state */
 	/* %rsi holds do_profiling */

 	/* ----- entry point to VG_(run_innerloop) ----- */
 	pushq	%rbx
 	pushq	%rcx
 	pushq	%rdx
 	pushq	%rsi
 	pushq	%rbp
 	pushq	%r8
 	pushq	%r9
 	pushq	%r10
 	pushq	%r11
 	pushq	%r12
 	pushq	%r13
 	pushq	%r14
 	pushq	%r15
 	pushq	%rdi  /* guest_state */

 	movq	VG_(dispatch_ctr)@GOTPCREL(%rip), %r15
 	movl	(%r15), %r15d
 	pushq	%r15

 	/* 8(%rsp) holds cached copy of guest_state ptr */
 	/* 0(%rsp) holds cached copy of VG_(dispatch_ctr) */

 	/* Set up the guest state pointer */
 	movq	%rdi, %rbp

 	/* fetch %RIP into %rax */
 	movq	OFFSET_amd64_RIP(%rbp), %rax

 	/* set host FPU control word to the default mode expected
            by VEX-generated code.  See comments in libvex.h for
            more info. */
 	finit
 	pushq	$0x027F
 	fldcw	(%rsp)
 	addq	$8, %rsp

 	/* set host SSE control word to the default mode expected
 	   by VEX-generated code. */
 	pushq	$0x1F80
 	ldmxcsr	(%rsp)
 	addq	$8, %rsp

 	/* set dir flag to known value */
 	cld

 	/* fall into main loop  (the right one) */
 	cmpq	$0, %rsi
 	je	VG_(run_innerloop__dispatch_unassisted_unprofiled)
 	jmp	VG_(run_innerloop__dispatch_unassisted_profiled)
 	/*NOTREACHED*/

 /*----------------------------------------------------*/
 /*--- NO-PROFILING (standard) dispatcher           ---*/
 /*----------------------------------------------------*/

 .align	4
 .globl	VG_(run_innerloop__dispatch_unassisted_unprofiled)
 VG_(run_innerloop__dispatch_unassisted_unprofiled):
 	/* AT ENTRY: %rax is next guest addr, %rbp is the
            unmodified guest state ptr */

 	/* save the jump address in the guest state */
 	movq	%rax, OFFSET_amd64_RIP(%rbp)

 	/* Are we out of timeslice?  If yes, defer to scheduler. */
 	subl	$1, 0(%rsp)
 	jz	counter_is_zero

 	/* try a fast lookup in the translation cache */
 	movabsq	$VG_(tt_fast), %rcx
 	movq	%rax, %rbx
 	andq	$VG_TT_FAST_MASK, %rbx	/* entry# */
 	shlq	$4, %rbx		/* entry# * sizeof(FastCacheEntry) */
 	movq	0(%rcx,%rbx,1), %r10	/* .guest */
 	movq	8(%rcx,%rbx,1), %r11	/* .host */
 	cmpq	%rax, %r10
 	jnz	fast_lookup_failed

         /* Found a match.  Jump to .host. */
 	jmp 	*%r11
 	ud2	/* persuade insn decoders not to speculate past here */
 	/* generated code should run, then jump back to
 	   VG_(run_innerloop__dispatch_{un,}assisted_unprofiled). */
 	/*NOTREACHED*/

 .align	4
 .globl	VG_(run_innerloop__dispatch_assisted_unprofiled)
 VG_(run_innerloop__dispatch_assisted_unprofiled):
 	/* AT ENTRY: %rax is next guest addr, %rbp is the
            modified guest state ptr.  Since the GSP has changed,
            jump directly to gsp_changed. */
         jmp     gsp_changed
         ud2
         /*NOTREACHED*/

 /*----------------------------------------------------*/
 /*--- PROFILING dispatcher (can be much slower)    ---*/
 /*----------------------------------------------------*/

 .align	4
 .globl	VG_(run_innerloop__dispatch_unassisted_profiled)
 VG_(run_innerloop__dispatch_unassisted_profiled):
 	/* AT ENTRY: %rax is next guest addr, %rbp is the
            unmodified guest state ptr */

 	/* save the jump address in the guest state */
 	movq	%rax, OFFSET_amd64_RIP(%rbp)

 	/* Are we out of timeslice?  If yes, defer to scheduler. */
 	subl	$1, 0(%rsp)
 	jz	counter_is_zero

 	/* try a fast lookup in the translation cache */
         movabsq $VG_(tt_fast), %rcx
 	movq	%rax, %rbx
 	andq	$VG_TT_FAST_MASK, %rbx	/* entry# */
 	shlq	$4, %rbx		/* entry# * sizeof(FastCacheEntry) */
 	movq	0(%rcx,%rbx,1), %r10	/* .guest */
 	movq	8(%rcx,%rbx,1), %r11	/* .host */
 	cmpq	%rax, %r10
 	jnz	fast_lookup_failed

 	/* increment bb profile counter */
 	movabsq	$VG_(tt_fastN), %rdx
 	shrq	$1, %rbx		/* entry# * sizeof(UInt*) */
 	movq	(%rdx,%rbx,1), %rdx
 	addl	$1, (%rdx)

         /* Found a match.  Jump to .host. */
 	jmp 	*%r11
 	ud2	/* persuade insn decoders not to speculate past here */
 	/* generated code should run, then jump back to
 	   VG_(run_innerloop__dispatch_{un,}assisted_profiled). */
 	/*NOTREACHED*/

 .align	4
 .globl	VG_(run_innerloop__dispatch_assisted_profiled)
 VG_(run_innerloop__dispatch_assisted_profiled):
 	/* AT ENTRY: %rax is next guest addr, %rbp is the
            modified guest state ptr.  Since the GSP has changed,
            jump directly to gsp_changed. */
         jmp     gsp_changed
         ud2
         /*NOTREACHED*/

 /*----------------------------------------------------*/
 /*--- exit points                                  ---*/
 /*----------------------------------------------------*/

 gsp_changed:
 	/* Someone messed with the gsp.  Have to
            defer to scheduler to resolve this.  dispatch ctr
 	   is not yet decremented, so no need to increment. */
 	/* %RIP is NOT up to date here.  First, need to write
 	   %rax back to %RIP, but without trashing %rbp since
 	   that holds the value we want to return to the scheduler.
 	   Hence use %r15 transiently for the guest state pointer. */
 	movq	8(%rsp), %r15
 	movq	%rax, OFFSET_amd64_RIP(%r15)
 	movq	%rbp, %rax
 	jmp	run_innerloop_exit
 	/*NOTREACHED*/

 counter_is_zero:
 	/* %RIP is up to date here */
 	/* back out decrement of the dispatch counter */
 	addl	$1, 0(%rsp)
 	movq	$VG_TRC_INNER_COUNTERZERO, %rax
 	jmp	run_innerloop_exit

 fast_lookup_failed:
 	/* %RIP is up to date here */
 	/* back out decrement of the dispatch counter */
 	addl	$1, 0(%rsp)
 	movq	$VG_TRC_INNER_FASTMISS, %rax
 	jmp	run_innerloop_exit


 /* All exits from the dispatcher go through here.  %rax holds
    the return value.
 */
 run_innerloop_exit:
 	/* We're leaving.  Check that nobody messed with
            %mxcsr or %fpucw.  We can't mess with %rax here as it
 	   holds the tentative return value, but any other is OK. */
 #if !defined(ENABLE_INNER)
         /* This check fails for self-hosting, so skip in that case */
 	pushq	$0
 	fstcw	(%rsp)
 	cmpl	$0x027F, (%rsp)
 	popq	%r15 /* get rid of the word without trashing %eflags */
 	jnz	invariant_violation
 #endif
 	pushq	$0
 	stmxcsr	(%rsp)
 	andl	$0xFFFFFFC0, (%rsp)  /* mask out status flags */
 	cmpl	$0x1F80, (%rsp)
 	popq	%r15
 	jnz	invariant_violation
 	/* otherwise we're OK */
 	jmp	run_innerloop_exit_REALLY

 invariant_violation:
 	movq	$VG_TRC_INVARIANT_FAILED, %rax
 	jmp	run_innerloop_exit_REALLY

 run_innerloop_exit_REALLY:

 	/* restore VG_(dispatch_ctr) */
 	popq	%r14
 	movq	VG_(dispatch_ctr)@GOTPCREL(%rip), %r15
 	movl	%r14d, (%r15)

 	popq	%rdi
 	popq	%r15
 	popq	%r14
 	popq	%r13
 	popq	%r12
 	popq	%r11
 	popq	%r10
 	popq	%r9
 	popq	%r8
 	popq	%rbp
 	popq	%rsi
 	popq	%rdx
 	popq	%rcx
 	popq	%rbx
 	ret


 /*------------------------------------------------------------*/
 /*---                                                      ---*/
 /*--- A special dispatcher, for running no-redir           ---*/
 /*--- translations.  Just runs the given translation once. ---*/
 /*---                                                      ---*/
 /*------------------------------------------------------------*/

 /* signature:
 void VG_(run_a_noredir_translation) ( UWord* argblock );
 */

 /* Run a no-redir translation.  argblock points to 4 UWords, 2 to carry args
    and 2 to carry results:
       0: input:  ptr to translation
       1: input:  ptr to guest state
       2: output: next guest PC
       3: output: guest state pointer afterwards (== thread return code)
 */
 .align 4
 .globl VG_(run_a_noredir_translation)
 VG_(run_a_noredir_translation):
 	/* Save callee-saves regs */
 	pushq %rbx
 	pushq %rbp
 	pushq %r12
 	pushq %r13
 	pushq %r14
 	pushq %r15

 	pushq %rdi  /* we will need it after running the translation */
 	movq 8(%rdi), %rbp
 	jmp *0(%rdi)
 	/*NOTREACHED*/
 	ud2
 	/* If the translation has been correctly constructed, we
 	should resume at the the following label. */
 .globl VG_(run_a_noredir_translation__return_point)
 VG_(run_a_noredir_translation__return_point):
 	popq %rdi
 	movq %rax, 16(%rdi)
 	movq %rbp, 24(%rdi)

 	popq  %r15
 	popq  %r14
 	popq  %r13
 	popq  %r12
 	popq  %rbp
 	popq  %rbx
 	ret

 #endif // defined(VGP_amd64_darwin)

 /*--------------------------------------------------------------------*/
 /*--- end                                                          ---*/
 /*--------------------------------------------------------------------*/

	/--------------------------------------------------------------------/
	/--- The core dispatch loop, for jumping to a code address. ---/
	/--- dispatch-amd64-darwin.S ---/
	/--------------------------------------------------------------------/

	/*
	This file is part of Valgrind, a dynamic binary instrumentation
	framework.

	Copyright (C) 2000-2007 Julian Seward
	jseward@acm.org

	This program is free software; you can redistribute it and/or
	modify it under the terms of the GNU General Public License as
	published by the Free Software Foundation; either version 2 of the
	License, or (at your option) any later version.

	This program 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
	General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	02111-1307, USA.

	The GNU General Public License is contained in the file COPYING.
	*/

	#if defined(VGP_amd64_darwin)

	#include "pub_core_basics_asm.h"
	#include "pub_core_dispatch_asm.h"
	#include "pub_core_transtab_asm.h"
	#include "libvex_guest_offsets.h" /* for OFFSET_amd64_RIP */


	/------------------------------------------------------------/
	/--- ---/
	/--- The dispatch loop. VG_(run_innerloop) is used to ---/
	/--- run all translations except no-redir ones. ---/
	/--- ---/
	/------------------------------------------------------------/

	/----------------------------------------------------/
	/--- Preamble (set everything up) ---/
	/----------------------------------------------------/

	/* signature:
	UWord VG_(run_innerloop) ( void* guest_state, UWord do_profiling );
	*/

	.text
	.globl VG_(run_innerloop)
	VG_(run_innerloop):
	/* %rdi holds guest_state */
	/* %rsi holds do_profiling */

	/* ----- entry point to VG_(run_innerloop) ----- */
	pushq %rbx
	pushq %rcx
	pushq %rdx
	pushq %rsi
	pushq %rbp
	pushq %r8
	pushq %r9
	pushq %r10
	pushq %r11
	pushq %r12
	pushq %r13
	pushq %r14
	pushq %r15
	pushq %rdi /* guest_state */

	movq VG_(dispatch_ctr)@GOTPCREL(%rip), %r15
	movl (%r15), %r15d
	pushq %r15

	/* 8(%rsp) holds cached copy of guest_state ptr */
	/* 0(%rsp) holds cached copy of VG_(dispatch_ctr) */

	/* Set up the guest state pointer */
	movq %rdi, %rbp

	/* fetch %RIP into %rax */
	movq OFFSET_amd64_RIP(%rbp), %rax

	/* set host FPU control word to the default mode expected
	by VEX-generated code. See comments in libvex.h for
	more info. */
	finit
	pushq $0x027F
	fldcw (%rsp)
	addq $8, %rsp

	/* set host SSE control word to the default mode expected
	by VEX-generated code. */
	pushq $0x1F80
	ldmxcsr (%rsp)
	addq $8, %rsp

	/* set dir flag to known value */
	cld

	/* fall into main loop (the right one) */
	cmpq $0, %rsi
	je VG_(run_innerloop__dispatch_unassisted_unprofiled)
	jmp VG_(run_innerloop__dispatch_unassisted_profiled)
	/NOTREACHED/

	/----------------------------------------------------/
	/--- NO-PROFILING (standard) dispatcher ---/
	/----------------------------------------------------/

	.align 4
	.globl VG_(run_innerloop__dispatch_unassisted_unprofiled)
	VG_(run_innerloop__dispatch_unassisted_unprofiled):
	/* AT ENTRY: %rax is next guest addr, %rbp is the
	unmodified guest state ptr */

	/* save the jump address in the guest state */
	movq %rax, OFFSET_amd64_RIP(%rbp)

	/* Are we out of timeslice? If yes, defer to scheduler. */
	subl $1, 0(%rsp)
	jz counter_is_zero

	/* try a fast lookup in the translation cache */
	movabsq $VG_(tt_fast), %rcx
	movq %rax, %rbx
	andq $VG_TT_FAST_MASK, %rbx /* entry# */
	shlq $4, %rbx /* entry# * sizeof(FastCacheEntry) */
	movq 0(%rcx,%rbx,1), %r10 /* .guest */
	movq 8(%rcx,%rbx,1), %r11 /* .host */
	cmpq %rax, %r10
	jnz fast_lookup_failed

	/* Found a match. Jump to .host. */
	jmp *%r11
	ud2 /* persuade insn decoders not to speculate past here */
	/* generated code should run, then jump back to
	VG_(run_innerloop__dispatch_{un,}assisted_unprofiled). */
	/NOTREACHED/

	.align 4
	.globl VG_(run_innerloop__dispatch_assisted_unprofiled)
	VG_(run_innerloop__dispatch_assisted_unprofiled):
	/* AT ENTRY: %rax is next guest addr, %rbp is the
	modified guest state ptr. Since the GSP has changed,
	jump directly to gsp_changed. */
	jmp gsp_changed
	ud2
	/NOTREACHED/

	/----------------------------------------------------/
	/--- PROFILING dispatcher (can be much slower) ---/
	/----------------------------------------------------/

	.align 4
	.globl VG_(run_innerloop__dispatch_unassisted_profiled)
	VG_(run_innerloop__dispatch_unassisted_profiled):
	/* AT ENTRY: %rax is next guest addr, %rbp is the
	unmodified guest state ptr */

	/* save the jump address in the guest state */
	movq %rax, OFFSET_amd64_RIP(%rbp)

	/* Are we out of timeslice? If yes, defer to scheduler. */
	subl $1, 0(%rsp)
	jz counter_is_zero

	/* try a fast lookup in the translation cache */
	movabsq $VG_(tt_fast), %rcx
	movq %rax, %rbx
	andq $VG_TT_FAST_MASK, %rbx /* entry# */
	shlq $4, %rbx /* entry# * sizeof(FastCacheEntry) */
	movq 0(%rcx,%rbx,1), %r10 /* .guest */
	movq 8(%rcx,%rbx,1), %r11 /* .host */
	cmpq %rax, %r10
	jnz fast_lookup_failed

	/* increment bb profile counter */
	movabsq $VG_(tt_fastN), %rdx
	shrq $1, %rbx /* entry# * sizeof(UInt) /
	movq (%rdx,%rbx,1), %rdx
	addl $1, (%rdx)

	/* Found a match. Jump to .host. */
	jmp *%r11
	ud2 /* persuade insn decoders not to speculate past here */
	/* generated code should run, then jump back to
	VG_(run_innerloop__dispatch_{un,}assisted_profiled). */
	/NOTREACHED/

	.align 4
	.globl VG_(run_innerloop__dispatch_assisted_profiled)
	VG_(run_innerloop__dispatch_assisted_profiled):
	/* AT ENTRY: %rax is next guest addr, %rbp is the
	modified guest state ptr. Since the GSP has changed,
	jump directly to gsp_changed. */
	jmp gsp_changed
	ud2
	/NOTREACHED/

	/----------------------------------------------------/
	/--- exit points ---/
	/----------------------------------------------------/

	gsp_changed:
	/* Someone messed with the gsp. Have to
	defer to scheduler to resolve this. dispatch ctr
	is not yet decremented, so no need to increment. */
	/* %RIP is NOT up to date here. First, need to write
	%rax back to %RIP, but without trashing %rbp since
	that holds the value we want to return to the scheduler.
	Hence use %r15 transiently for the guest state pointer. */
	movq 8(%rsp), %r15
	movq %rax, OFFSET_amd64_RIP(%r15)
	movq %rbp, %rax
	jmp run_innerloop_exit
	/NOTREACHED/

	counter_is_zero:
	/* %RIP is up to date here */
	/* back out decrement of the dispatch counter */
	addl $1, 0(%rsp)
	movq $VG_TRC_INNER_COUNTERZERO, %rax
	jmp run_innerloop_exit

	fast_lookup_failed:
	/* %RIP is up to date here */
	/* back out decrement of the dispatch counter */
	addl $1, 0(%rsp)
	movq $VG_TRC_INNER_FASTMISS, %rax
	jmp run_innerloop_exit



	/* All exits from the dispatcher go through here. %rax holds
	the return value.
	*/
	run_innerloop_exit:
	/* We're leaving. Check that nobody messed with
	%mxcsr or %fpucw. We can't mess with %rax here as it
	holds the tentative return value, but any other is OK. */
	#if !defined(ENABLE_INNER)
	/* This check fails for self-hosting, so skip in that case */
	pushq $0
	fstcw (%rsp)
	cmpl $0x027F, (%rsp)
	popq %r15 /* get rid of the word without trashing %eflags */
	jnz invariant_violation
	#endif
	pushq $0
	stmxcsr (%rsp)
	andl $0xFFFFFFC0, (%rsp) /* mask out status flags */
	cmpl $0x1F80, (%rsp)
	popq %r15
	jnz invariant_violation
	/* otherwise we're OK */
	jmp run_innerloop_exit_REALLY

	invariant_violation:
	movq $VG_TRC_INVARIANT_FAILED, %rax
	jmp run_innerloop_exit_REALLY

	run_innerloop_exit_REALLY:

	/* restore VG_(dispatch_ctr) */
	popq %r14
	movq VG_(dispatch_ctr)@GOTPCREL(%rip), %r15
	movl %r14d, (%r15)

	popq %rdi
	popq %r15
	popq %r14
	popq %r13
	popq %r12
	popq %r11
	popq %r10
	popq %r9
	popq %r8
	popq %rbp
	popq %rsi
	popq %rdx
	popq %rcx
	popq %rbx
	ret


	/------------------------------------------------------------/
	/--- ---/
	/--- A special dispatcher, for running no-redir ---/
	/--- translations. Just runs the given translation once. ---/
	/--- ---/
	/------------------------------------------------------------/

	/* signature:
	void VG_(run_a_noredir_translation) ( UWord* argblock );
	*/

	/* Run a no-redir translation. argblock points to 4 UWords, 2 to carry args
	and 2 to carry results:
	0: input: ptr to translation
	1: input: ptr to guest state
	2: output: next guest PC
	3: output: guest state pointer afterwards (== thread return code)
	*/
	.align 4
	.globl VG_(run_a_noredir_translation)
	VG_(run_a_noredir_translation):
	/* Save callee-saves regs */
	pushq %rbx
	pushq %rbp
	pushq %r12
	pushq %r13
	pushq %r14
	pushq %r15

	pushq %rdi /* we will need it after running the translation */
	movq 8(%rdi), %rbp
	jmp *0(%rdi)
	/NOTREACHED/
	ud2
	/* If the translation has been correctly constructed, we
	should resume at the the following label. */
	.globl VG_(run_a_noredir_translation__return_point)
	VG_(run_a_noredir_translation__return_point):
	popq %rdi
	movq %rax, 16(%rdi)
	movq %rbp, 24(%rdi)

	popq %r15
	popq %r14
	popq %r13
	popq %r12
	popq %rbp
	popq %rbx
	ret

	#endif // defined(VGP_amd64_darwin)

	/--------------------------------------------------------------------/
	/--- end ---/
	/--------------------------------------------------------------------/