emit.c

二进制翻译的一个软件

/*
 * Copyright (c) 2005, Johns Hopkins University and The EROS Group, LLC.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above
 *    copyright notice, this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided
 *    with the distribution.
 *
 *  * Neither the name of the Johns Hopkins University, nor the name
 *    of The EROS Group, LLC, nor the names of their contributors may
 *    be used to endorse or promote products derived from this
 *    software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdbool.h>
#include <assert.h>
#include <stdio.h>
#include "switches.h"
#include "debug.h"
#include "util.h"
#include "machine.h"
#include "decode.h"
#include "emit.h"
#include "emit-support.h"
#include "xlcore.h"
#include "perf.h"
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/user.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>
#include <sched.h>
#include <asm/unistd.h>

#ifdef INLINE_EMITTERS
#define INLINE static inline
#include "emit-inline.c"
#else
#define INLINE
#endif

#include "xlate-helper.c"

/*********************************************************************
Emit Normal - All other instructions
*********************************************************************/

bool
emit_normal(machine_t *M, decode_t *d)
{
  unsigned i;
  unsigned count = M->next_eip - d->decode_eip;

  DEBUG(emits)
    fprintf(DBG, "%lu: Normal %lx %s\n", M->nTrInstr, d->decode_eip, ((OpCode *) d->pEntry)->disasm);

#ifdef PROFILE
  M->ptState->s_normal_cnt++;
  bb_emit_inc(M, MFLD(M, ptState->normal_cnt));
#endif

  /*   for (i = 0; i < count; i++) { */
  /* #ifdef STATIC_PASS */
  /*     bb_emit_byte(M, ((unsigned char *)d->mem_decode_eip)[i]);  */
  /* #else */
  /*     bb_emit_byte(M, ((unsigned char *)d->decode_eip)[i]);  */
  /* #endif */
  /*   } */

#ifdef STATIC_PASS
  memcpy(M->bbOut, (unsigned char *)d->mem_decode_eip, count);
#else
  memcpy(M->bbOut, (unsigned char *)d->decode_eip, count);
#endif
  M->bbOut += count;

  return false; 
}

/*********************************************************************
Emit INT - To capture exit only
*********************************************************************/

#define Aux1(x) (x), PERC((x), M->ptState->total_cnt)
#define Aux2(x) (x), PERC((x), M->ptState->s_total_cnt)

#if (defined(USE_STATIC_DUMP) || defined(STATIC_PASS))
#define ENABLE_DUMP_FUNCTION
#endif

#ifdef ENABLE_DUMP_FUNCTION
/* 1) Warning: Will modify str */
void
dump_to_file(machine_t *M, char *str)
{
  char arg[300]; 
  unsigned long i;
  struct stat buf;
  unsigned long len = strlen(str);

  /* This has to be mmaped eventually ...
     Better abort than buffer overflow */
  if(len > 300) {
    fprintf(DBG, "len > 300; Temporarily aborting; Did not dump.");
    return;
  }

  for(i=0; i<len; i++)
    if(str[i] == '/')
      str[i] = '_';
      
#ifdef CHECK_DUMP_DIR
  if(stat("/tmp/vdebug-dump", &buf) == -1 && errno == ENOENT)
    system("mkdir /tmp/vdebug-dump");
#endif
  int fd;

  extrabytes = (sizeof(machine_t) + sizeof(pt_state)) % PAGE_SIZE;
  
  sprintf(arg, "/tmp/vdebug-dump/%s-dump", str);
  fd = open(arg, O_CREAT | O_RDWR | O_TRUNC, S_IRWXU);
  i = write(fd, M, sizeof(machine_t)); 
  i = write(fd, M->ptState, sizeof(pt_state)); 
  i = write(fd, M, extrabytes);  // waste
  close(fd);
  

  sprintf(arg, "/tmp/vdebug-dump/%s-addr", str);
  fd = open(arg, O_CREAT | O_RDWR | O_TRUNC, S_IRWXU);
  i = write(fd, &M, sizeof(machine_t *)); 
  close(fd);
  
}
#endif

void 
exit_stub(machine_t *M)
{
  unsigned long i;
  /* This might cause some problems at least collisions due to
     the fixed size of buffers. However, I believe I 
     removed all cases of buffer overflow */

  char str[300];
  char arg[300];
  sprintf(arg, "/proc/%d/exe", getpid());
  i = readlink(arg,str,sizeof(str));
  str[i] = '\0';
  FILE *f;

#ifdef PROFILE_TRANSLATION
  f = fopen("timer", "a");
  unsigned long long start_time = M->ptState->tot_time;
  unsigned long long end_time = read_timer(); 
  M->ptState->tot_time = end_time - start_time;

  fprintf(f, "Process: %s\n", str);
  fprintf(f, "Start Time        = %llu\n", start_time);
  fprintf(f, "End Time          = %llu\n", end_time);  
  fprintf(f, "Translation Time  = %llu\n", M->ptState->trans_time);
  fprintf(f, "Total Time        = %llu\n", M->ptState->tot_time);
  fprintf(f, "Translation Time% = %0.3f\n", 
	  PERC(M->ptState->trans_time, M->ptState->tot_time));
  fprintf(f, "Total bytes       = %lu\n", (M->bbOut - M->bbCache));  
  fprintf(f, "Cycles per byte   = %0.3f\n\n\n", 
	  (float)M->ptState->trans_time / (M->bbOut - M->bbCache));  
  fclose(f);
  return;
#endif

#ifdef PROFILE_BB_CNT
  f = stdout;   
  fprintf(f, "Process         : %s\n", str);
  fprintf(f, "Total count     = %lu\n", M->ptState->bb_cnt);

  return;
#endif  

  
#if defined(PROFILE) || defined(PROFILE_RET_MISS)
  FILE *F = fopen("stats", "a");
#endif

#ifdef PROFILE 
  M->ptState->total_cnt = 
    (unsigned long long) M->ptState->normal_cnt + 
    (unsigned long long) M->ptState->jmp_cond_cnt + 
    (unsigned long long) M->ptState->jmp_dir_cnt +
    (unsigned long long) M->ptState->jmp_indr_cnt +
    (unsigned long long) M->ptState->call_dir_cnt +
    (unsigned long long) M->ptState->call_indr_cnt +
    (unsigned long long) M->ptState->ret_cnt +
    (unsigned long long) M->ptState->ret_Iw_cnt ;
 
  M->ptState->s_total_cnt = 
    (unsigned long long) M->ptState->s_normal_cnt + 
    (unsigned long long) M->ptState->s_jmp_cond_cnt + 
    (unsigned long long) M->ptState->s_jmp_dir_cnt +
    (unsigned long long) M->ptState->s_jmp_indr_cnt +
    (unsigned long long) M->ptState->s_call_dir_cnt +
    (unsigned long long) M->ptState->s_call_indr_cnt +
    (unsigned long long) M->ptState->s_ret_cnt +
    (unsigned long long) M->ptState->s_ret_Iw_cnt ;
 
  fprintf(F, "Process 			: %s\n", str);    
  fprintf(F, "         Static Statistics\n");
  fprintf(F, "Total No. of Instructions 	= %llu  100%\n", 
	  M->ptState->s_total_cnt);
  fprintf(F, "Normal Instructions 		= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_normal_cnt));
  fprintf(F, "Conditional Jump 		= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_jmp_cond_cnt)); 
  fprintf(F, "Direct Jump 			= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_jmp_dir_cnt)); 
  fprintf(F, "Indirect Jump 			= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_jmp_indr_cnt)); 
  fprintf(F, "Direct Call			= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_call_dir_cnt)); 
  fprintf(F, "Indirect Call 			= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_call_indr_cnt)); 
  fprintf(F, "Return 				= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_ret_cnt)); 
  fprintf(F, "Return IW 			= %lu  %0.3f%\n", 
	  Aux2(M->ptState->s_ret_Iw_cnt)); 

  fprintf(F, "         Dynamic Statistics\n");
  fprintf(F, "Total No. of Instructions 	= %lu  100%\n", 
	  M->ptState->total_cnt);
  fprintf(F, "Normal Instructions 		= %lu  %0.3f%\n", 
	  Aux1(M->ptState->normal_cnt));
  fprintf(F, "Conditional Jump 		= %lu  %0.3f%\n", 
	  Aux1(M->ptState->jmp_cond_cnt)); 
  fprintf(F, "Direct Jump 			= %lu  %0.3f%\n", 
	  Aux1(M->ptState->jmp_dir_cnt)); 
  fprintf(F, "Indirect Jump 			= %lu  %0.3f%\n", 
	  Aux1(M->ptState->jmp_indr_cnt)); 
  fprintf(F, "Direct Call 			= %lu  %0.3f%\n", 
	  Aux1(M->ptState->call_dir_cnt)); 
  fprintf(F, "Indirect Call 			= %lu  %0.3f%\n", 
	  Aux1(M->ptState->call_indr_cnt)); 
  fprintf(F, "Return 				= %lu  %0.3f%\n", 
	  Aux1(M->ptState->ret_cnt)); 
  fprintf(F, "Return IW 			= %lu  %0.3f%\n", 
	  Aux1(M->ptState->ret_Iw_cnt)); 

#endif

#ifdef PROFILE
  fprintf(F, "         Basic-Block Statistics\n");
#endif

#ifdef PROFILE_RET_MISS  
  unsigned long p=0, q=0;
  for(p=0; p<CALL_TABLE_SIZE; p++)
    if(M->call_hash_table[p] != (unsigned long)M->ret_calls_fast_dispatch_bb)
      q++;

#ifdef PROFILE
  fprintf(F, "Returns going to wrong call site = %lu [%.3f%%]\n", 
	  M->ptState->ret_miss_cnt, 
	  PERC(M->ptState->ret_miss_cnt, 
	       M->ptState->ret_cnt + M->ptState->ret_Iw_cnt));
  fprintf(F, "Returns going to fast-dispatch   = %lu [%.3f%%]\n", 
	  M->ptState->ret_ret_miss_cnt, 
	  PERC(M->ptState->ret_ret_miss_cnt, 
	       M->ptState->ret_cnt + M->ptState->ret_Iw_cnt));
  M->ptState->ret_miss_cnt += M->ptState->ret_ret_miss_cnt;
  fprintf(F, "Returns missed Optimization = %lu [%.3f%%]\n", 
	  M->ptState->ret_miss_cnt, 
	  PERC(M->ptState->ret_miss_cnt, 
	       M->ptState->ret_cnt + M->ptState->ret_Iw_cnt));  
#else
  fprintf(F, "Returns going to wrong call site = %lu\n", M->ret_miss_cnt);
  fprintf(F, "Returns going to fast-dispatch   = %lu\n", M->ret_ret_miss_cnt);
  M->ret_miss_cnt += M->ret_ret_miss_cnt;
  fprintf(F, "Returns missed Optimization = %lu\n", M->ret_miss_cnt);  
#endif
  fprintf(F, "%lu / %lu = %0.3f%% buckets changed\n", q, p, ((float)q*100)/((float)p));

  fprintf(F, "BBs with COLD pe = %lu / %lu [%0.3f%%]\n", 
	  M->ptState->cold_cnt, 
	  M->no_of_bbs, 
	  PERC(M->ptState->cold_cnt, M->no_of_bbs));  
  
  fflush(F);
#endif  

#ifdef PROFILE
  fprintf(F, "Total No. of BBs 		= %lu\n", M->no_of_bbs);
  fprintf(F, "No. of BBs with cmp-jmp headers = %lu %0.3f%\n", 
	  M->ptState->hash_nodes_cnt, 
	  PERC(M->ptState->hash_nodes_cnt, M->no_of_bbs));
  fprintf(F, "BBCache: Total size 		= %lu\n", BBCACHE_SIZE);
  fprintf(F, "BBCache: No. of Bytes used 	= %lu %0.3f%\n", (M->bbOut-M->bbCache), 
	  PERC((M->bbOut-M->bbCache), BBCACHE_SIZE));

  /*   bucket_entry *b = (bucket_entry *)M->hash_table;  */
  /*   unsigned long ch_used_cnt = 0; */
  /*   unsigned long max_len = 0; */
  /*   unsigned long len = 0; */
  /*   bb_header *h; */
  /*   for(i=0; i<NBUCKETS; i++, b++) */
  /*     if((unsigned long)(b->rel + &(b->filler[0])) != (unsigned long)(M->slow_dispatch_bb)) */
  /*       { */
  /* 	ch_used_cnt++; */
  /* 	len = 0; */
  /* 	h = (bb_header *)(b->rel + &(b->filler[0])); */
  /* 	while((unsigned long)h != (unsigned long)(M->slow_dispatch_bb)) */
  /* 	  { */
  /* 	    len++; */
  /* 	    h = (bb_header *) ((unsigned long)(h->next_bb) + (unsigned long) (&(h->pop_ebx))); */
  /* 	  } */
  /* 	if(len > max_len) */
  /* 	  max_len = len; */
  /*       } */
		
  /*   fprintf(F, "Total (Code) Hash_Table buckets	= %lu\n", NBUCKETS);  */
  /*   fprintf(F, "Hash Buckets used		= %lu %0.3f%\n", ch_used_cnt, PERC(ch_used_cnt, NBUCKETS));  */
  /*   fprintf(F, "Maximim length of any chain	= %lu\n", max_len); */
  /*   fprintf(F, "\n\n\n");  */
#endif  

#if defined(PROFILE) || defined(PROFILE_RET_MISS)
  fclose(F);
#endif


#ifdef USE_STATIC_DUMP 
  if(M->dump == true) {
    dump_to_file(M, str);
  }
#endif

#ifdef OUTPUT_BB_STAT
  {
    FILE *F = fopen("bbstat", "w");
    for(i=0; i<M->no_of_bbs; i++) {
      fprintf(F, "%lx\n", M->bb_entry_nodes[i].src_bb_eip);
    }
  }
#endif

#ifdef PROFILE_BB_STATS
  {
    unsigned long nrelocbbs=0, ntrelocbbs=0, nactualbbs=0;
    unsigned long nrelocbytes=0, ntrelocbytes=0, nactualbytes = M->bbOut - M->bbCache;
    unsigned long ginstrs=0, tinstrs=0, gbytes = 0, tbytes=0;

    /* Finish off the last BB */
    M->curr_bb_entry->trans_bb_end_eip = (unsigned long) M->bbOut;
    M->curr_bb_entry->flags |= IS_END_OF_TRACE;
    
    /* No of actual BBs */
    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i];
      if(curr->trans_bb_eip != NOT_YET_TRANSLATED)
	nactualbbs++;
    }

    /* BB Analysis */
    unsigned long ilongest_bb = 0;
    unsigned long ilongest_bb_len = 0;
    double iavg_bb_len = 0;
    double ibb_sd = 0;

    unsigned long blongest_bb = 0;
    unsigned long blongest_bb_len = 0;
    unsigned long bavg_bb_len = 0;
    double bbb_sd = 0;

    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i];
      if(curr->nInstr > ilongest_bb_len) {
	ilongest_bb_len = curr->nInstr;
	ilongest_bb = i;
      }
      iavg_bb_len += curr->nInstr;
    }
    iavg_bb_len /= nactualbbs;

    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i];
      ibb_sd += ((double)curr->nInstr - iavg_bb_len) * ((double)curr->nInstr - iavg_bb_len);
    }
    ibb_sd /= nactualbbs;
    ibb_sd = sqrt(ibb_sd);
    
    /* Trace Analysis */
    unsigned long longest_trace_len = 0;
    unsigned long longest_trace_ilen = 0;
    unsigned long longest_trace_start_bb = 0;
    unsigned long longest_trace_bytes = 0;
    double avg_trace = 0;
    double avg_itrace = 0;    
    double avg_trbytes = 0;
    double sd_trace = 0;
    double sd_itrace = 0;
    double sd_trbytes = 0;
    unsigned long ntraces = 0;

    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i];
      curr->flags &= ~MARKED; 
    }
    
    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i]; 
      unsigned long trace_len=0;
      unsigned long trace_instrs=0;
      unsigned long trace_bytes = 0;

      if(curr->flags & MARKED)
	continue;

      ntraces++;
      while((curr != NULL) && (curr->trans_bb_eip != NOT_YET_TRANSLATED)) {
	if(curr->flags & MARKED) {
	  //fprintf(DBG, "@@MARKED in Trace\n");
	}
	else
	  curr->flags |= MARKED;

	trace_len++;
	trace_instrs += curr->nInstr;
	trace_bytes += curr->trans_bb_end_eip - curr->trans_bb_eip;
	curr = curr->trace_next;
      }

      if(trace_len > longest_trace_len) {
	longest_trace_len = trace_len;
	longest_trace_ilen = trace_instrs;
	longest_trace_start_bb = i;
	longest_trace_bytes = trace_bytes;
      }
      avg_trace += trace_len;
      avg_itrace += trace_instrs;
      avg_trbytes += trace_bytes;
    }
    avg_trace /= ntraces;
    avg_itrace /= ntraces;
    avg_trbytes /= ntraces;
    
    /* Now calculate SD */
    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i];
      curr->flags &= ~MARKED; 
    }

    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i]; 
      unsigned long trace_len=0;
      unsigned long trace_bytes = 0;

      if(curr->flags & MARKED)
	continue;

      while((curr != NULL) && (curr->trans_bb_eip != NOT_YET_TRANSLATED)) {
	if(curr->flags & MARKED) {
	  //fprintf(DBG, "##MARKED in Trace\n");
	}
	else
	  curr->flags |= MARKED;

	trace_len++;
	trace_bytes += curr->trans_bb_end_eip - curr->trans_bb_eip;
	curr = curr->trace_next;
      }
      sd_trace += (trace_len - avg_trace) * (trace_len - avg_trace);
      sd_trbytes += (trace_bytes - avg_trbytes) * (trace_bytes - avg_trbytes);
    }

    sd_trace /= ntraces; sd_trace = sqrt(sd_trace);
    sd_trbytes /= ntraces; sd_trbytes = sqrt(sd_trbytes);
    
    /* No. of BBs needing Relocation */
    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i];
      if((curr->trans_bb_eip != NOT_YET_TRANSLATED) && (curr->flags & NEEDS_RELOC)) {
	nrelocbbs++;
	nrelocbytes += curr->trans_bb_end_eip - curr->trans_bb_eip;
      }
    }

    /* Propagate the RELOC Flag Forward and backward */
    for(i=0; i<M->no_of_bbs; i++) {
      bb_entry *curr = &M->bb_entry_nodes[i];
      bool reloc = false;
      while((curr != NULL) && (curr->trans_bb_eip != NOT_YET_TRANSLATED)) {
	if(curr->flags & NEEDS_RELOC) {
	  reloc = true;
	  break;
	}
	curr = curr->trace_next;
      }
      if(reloc) {
	curr = &M->bb_entry_nodes[i];
	while((curr != NULL) && (curr->trans_bb_eip != NOT_YET_TRANSLATED)) {
	  curr->flags |= NEEDS_RELOC;
	  curr = curr->trace_next;	  
	}
      }