coregrind/vg_dispatch.S

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

/*
  This file is part of Valgrind, an x86 protected-mode emulator 
  designed for debugging and profiling binaries on x86-Unixes.

  Copyright (C) 2000-2002 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.
*/

#include "vg_constants.h"


/*------------------------------------------------------------*/
/*--- The normal-case dispatch machinery.                  ---*/
/*------------------------------------------------------------*/
	
/* To transfer to an (original) code address, load it into %eax and
   jump to vg_dispatch.  This fragment of code tries to find the
   address of the corresponding translation by searching the translation
   table.   If it fails, a new translation is made, added to the
   translation table, and then jumped to.  Almost all the hard
   work is done by C routines; this code simply handles the
   common case fast -- when the translation address is found in
   the translation cache.

   At entry, %eax is the only live (real-machine) register; the
   entire simulated state is tidily saved in vg_m_state.  
*/

	
/* The C world needs a way to get started simulating.  So we provide
   a function void vg_run_innerloop ( void ), which starts running
   from vg_m_eip, and exits when the counter reaches zero.  This loop
   can also exit if vg_oursignalhandler() catches a non-resumable
   signal, for example SIGSEGV.  It then longjmp()s back past here.
*/
	
.globl VG_(run_innerloop)
VG_(run_innerloop):
	/* OYNK(1000) */

	/* ----- entry point to VG_(run_innerloop) ----- */
	pushl	%ebx
	pushl	%ecx
	pushl	%edx
	pushl	%esi
	pushl	%edi
	pushl	%ebp

	/* Set up the baseBlock pointer */
	movl	$VG_(baseBlock), %ebp

	/* fetch m_eip into %eax */
	movl	VGOFF_(m_eip), %esi
	movl	(%ebp, %esi, 4), %eax
	
dispatch_main:
	/* Jump here to do a new dispatch.
	   %eax holds destination (original) address.
	   %ebp indicates further details of the control transfer
	   requested to the address in %eax.
	
	   If ebp == & VG_(baseBlock), just jump next to %eax.
	 
	   If ebp == VG_EBP_JMP_SYSCALL, do a system call before 
	   continuing at eax.
	
	   If ebp == VG_EBP_JMP_CLIENTREQ, do a client request before 
	   continuing at eax.
	
	   If %ebp has any other value, we panic.
	*/
	cmpl	$VG_(baseBlock), %ebp
	jnz	dispatch_exceptional
	/* fall into main loop */


dispatch_boring:
	/* save the jump address at VG_(baseBlock)[VGOFF_(m_eip)] */
	movl	VGOFF_(m_eip), %esi
	movl	%eax, (%ebp, %esi, 4)
	/* Are we out of timeslice?  If yes, defer to scheduler. */
	decl	VG_(dispatch_ctr)
	jz	counter_is_zero
	/* try a fast lookup in the translation cache */
	movl	%eax, %ebx
	andl	$VG_TT_FAST_MASK, %ebx	
	/* ebx = tt_fast index */
	movl	VG_(tt_fast)(,%ebx,4), %ebx	
	/* ebx points at a tt entry
	   now compare target with the tte.orig_addr field (+0) */
	cmpl	%eax, (%ebx)
	jnz	fast_lookup_failed
#if 1
	/* Found a match.  Set the tte.mru_epoch field (+8)
	   and call the tte.trans_addr field (+4) */
	movl	VG_(current_epoch), %ecx
	movl	%ecx, 8(%ebx)
#endif
	call	*4(%ebx)
	cmpl	$VG_(baseBlock), %ebp
	jnz	dispatch_exceptional

dispatch_boring_unroll2:
	/* save the jump address at VG_(baseBlock)[VGOFF_(m_eip)] */
	movl	VGOFF_(m_eip), %esi
	movl	%eax, (%ebp, %esi, 4)
#if 1
	/* Are we out of timeslice?  If yes, defer to scheduler. */
	decl	VG_(dispatch_ctr)
	jz	counter_is_zero
#endif
	/* try a fast lookup in the translation cache */
	movl	%eax, %ebx
	andl	$VG_TT_FAST_MASK, %ebx	
	/* ebx = tt_fast index */
	movl	VG_(tt_fast)(,%ebx,4), %ebx	
	/* ebx points at a tt entry
	   now compare target with the tte.orig_addr field (+0) */
	cmpl	%eax, (%ebx)
	jnz	fast_lookup_failed
#if 1
	/* Found a match.  Set the tte.mru_epoch field (+8)
	   and call the tte.trans_addr field (+4) */
	movl	VG_(current_epoch), %ecx
	movl	%ecx, 8(%ebx)
#endif
	call	*4(%ebx)
	cmpl	$VG_(baseBlock), %ebp
	jz	dispatch_boring

	jmp	dispatch_exceptional

	
fast_lookup_failed:
	/* %EIP is up to date here since dispatch_boring dominates */
	movl	$VG_TRC_INNER_FASTMISS, %eax
	jmp	run_innerloop_exit

counter_is_zero:
	/* %EIP is up to date here since dispatch_boring dominates */
	movl	$VG_TRC_INNER_COUNTERZERO, %eax
	jmp	run_innerloop_exit
	
run_innerloop_exit:
	popl	%ebp
	popl	%edi
	popl	%esi
	popl	%edx
	popl	%ecx
	popl	%ebx
	ret	



/* Other ways of getting out of the inner loop.  Placed out-of-line to
   make it look cleaner. 
*/
dispatch_exceptional:
	/* this is jumped to only, not fallen-through from above */
	cmpl	$VG_TRC_EBP_JMP_SYSCALL, %ebp
	jz	dispatch_syscall
	cmpl	$VG_TRC_EBP_JMP_CLIENTREQ, %ebp
	jz	dispatch_clientreq

	/* ebp has an invalid value ... crap out. */
	pushl	$panic_msg_ebp
	call	VG_(panic)
	/* (never returns) */

dispatch_syscall:
	/* save %eax in %EIP and defer to sched */
	movl	$VG_(baseBlock), %ebp
	movl	VGOFF_(m_eip), %esi
	movl	%eax, (%ebp, %esi, 4)
	movl	$VG_TRC_EBP_JMP_SYSCALL, %eax
	jmp	run_innerloop_exit
	
dispatch_clientreq:
	/* save %eax in %EIP and defer to sched */
	movl	$VG_(baseBlock), %ebp
	movl	VGOFF_(m_eip), %esi
	movl	%eax, (%ebp, %esi, 4)
	movl	$VG_TRC_EBP_JMP_CLIENTREQ, %eax
	jmp	run_innerloop_exit

.data
panic_msg_ebp:
.ascii	"vg_dispatch: %ebp has invalid value!"
.byte	0
.text	


/*--------------------------------------------------------------------*/
/*--- end                                            vg_dispatch.S ---*/
/*--------------------------------------------------------------------*/