upstream/dynamips-0.2.7/ppc32.c

/*
 * Cisco router simulation platform.
 * Copyright (c) 2005,2006 Christophe Fillot (cf@utc.fr)
 *
 * PowerPC (32-bit) generic routines.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <assert.h>

#include "rbtree.h"
#include "cpu.h"
#include "dynamips.h"
#include "memory.h"
#include "device.h"
#include "ppc32_mem.h"
#include "ppc32_exec.h"
#include "ppc32_jit.h"

/* Reset a PowerPC CPU */
int ppc32_reset(cpu_ppc_t *cpu)
{
   cpu->ia = PPC32_ROM_START;
   cpu->gpr[1] = PPC32_ROM_SP;
   cpu->msr = PPC32_MSR_IP;

   /* Restart the MTS subsystem */
   ppc32_mem_restart(cpu);

   /* Flush JIT structures */
   ppc32_jit_flush(cpu,0);
   return(0);
}

/* Initialize a PowerPC processor */
int ppc32_init(cpu_ppc_t *cpu)
{
   /* Initialize JIT operations */
   jit_op_init_cpu(cpu->gen);

   /* Initialize idle timer */
   cpu->gen->idle_max = 1500;
   cpu->gen->idle_sleep_time = 30000;

   /* Timer IRQ parameters (default frequency: 250 Hz <=> 4ms period) */
   cpu->timer_irq_check_itv = 1000;
   cpu->timer_irq_freq      = 250;

   /* Enable/disable direct block jump */
   cpu->exec_blk_direct_jump = cpu->vm->exec_blk_direct_jump;

   /* Idle loop mutex and condition */
   pthread_mutex_init(&cpu->gen->idle_mutex,NULL);
   pthread_cond_init(&cpu->gen->idle_cond,NULL);

   /* Set the CPU methods */
   cpu->gen->reg_set =  (void *)ppc32_reg_set;
   cpu->gen->reg_dump = (void *)ppc32_dump_regs;
   cpu->gen->mmu_dump = (void *)ppc32_dump_mmu;
   cpu->gen->mmu_raw_dump = (void *)ppc32_dump_mmu;
   cpu->gen->add_breakpoint = (void *)ppc32_add_breakpoint;
   cpu->gen->remove_breakpoint = (void *)ppc32_remove_breakpoint;
   cpu->gen->set_idle_pc = (void *)ppc32_set_idle_pc;
   cpu->gen->get_idling_pc = (void *)ppc32_get_idling_pc;

   /* Set the startup parameters */
   ppc32_reset(cpu);
   return(0);
}

/* Delete a PowerPC processor */
void ppc32_delete(cpu_ppc_t *cpu)
{
   if (cpu) {
      ppc32_mem_shutdown(cpu);
      ppc32_jit_shutdown(cpu);
   }
}

/* Set the processor version register (PVR) */
void ppc32_set_pvr(cpu_ppc_t *cpu,m_uint32_t pvr)
{
   cpu->pvr = pvr;
   ppc32_mem_restart(cpu);
}

/* Set idle PC value */
void ppc32_set_idle_pc(cpu_gen_t *cpu,m_uint64_t addr)
{
   CPU_PPC32(cpu)->idle_pc = (m_uint32_t)addr;
}

/* Timer IRQ */
void *ppc32_timer_irq_run(cpu_ppc_t *cpu)
{
   pthread_mutex_t umutex = PTHREAD_MUTEX_INITIALIZER;
   pthread_cond_t ucond = PTHREAD_COND_INITIALIZER;
   struct timespec t_spc;
   m_tmcnt_t expire;
   u_int interval;
   u_int threshold;

#if 0
   while(!cpu->timer_irq_armed)
      sleep(1);
#endif

   interval = 1000000 / cpu->timer_irq_freq;
   threshold = cpu->timer_irq_freq * 10;
   expire = m_gettime_usec() + interval;

   while(cpu->gen->state != CPU_STATE_HALTED) {
      pthread_mutex_lock(&umutex);
      t_spc.tv_sec = expire / 1000000;
      t_spc.tv_nsec = (expire % 1000000) * 1000;
      pthread_cond_timedwait(&ucond,&umutex,&t_spc);
      pthread_mutex_unlock(&umutex);

      if (likely(!cpu->irq_disable) &&
          likely(cpu->gen->state == CPU_STATE_RUNNING) &&
          likely(cpu->msr & PPC32_MSR_EE))
      {
         cpu->timer_irq_pending++;

         if (unlikely(cpu->timer_irq_pending > threshold)) {
            cpu->timer_irq_pending = 0;
            cpu->timer_drift++;
#if 0
            printf("Timer IRQ not accurate (%u pending IRQ): "
                   "reduce the \"--timer-irq-check-itv\" parameter "
                   "(current value: %u)\n",
                   cpu->timer_irq_pending,cpu->timer_irq_check_itv);
#endif
         }
      }

      expire += interval;
   }

   return NULL;
}

#define IDLE_HASH_SIZE  8192

/* Idle PC hash item */
struct ppc32_idle_pc_hash {
   m_uint32_t ia;
   u_int count;
   struct ppc32_idle_pc_hash *next;
};

/* Determine an "idling" PC */
int ppc32_get_idling_pc(cpu_gen_t *cpu)
{
   cpu_ppc_t *pcpu = CPU_PPC32(cpu);
   struct ppc32_idle_pc_hash **pc_hash,*p;
   struct cpu_idle_pc *res;
   u_int h_index,res_count;
   m_uint32_t cur_ia;
   int i;

   cpu->idle_pc_prop_count = 0;

   if (pcpu->idle_pc != 0) {
      printf("\nYou already use an idle PC, using the calibration would give "
             "incorrect results.\n");
      return(-1);
   }

   printf("\nPlease wait while gathering statistics...\n");

   pc_hash = calloc(IDLE_HASH_SIZE,sizeof(struct ppc32_idle_pc_hash *));

   /* Disable IRQ */
   pcpu->irq_disable = TRUE;

   /* Take 1000 measures, each mesure every 10ms */
   for(i=0;i<1000;i++) {
      cur_ia = pcpu->ia;
      h_index = (cur_ia >> 2) & (IDLE_HASH_SIZE-1);

      for(p=pc_hash[h_index];p;p=p->next)
         if (p->ia == cur_ia) {
            p->count++;
            break;
         }

      if (!p) {
         if ((p = malloc(sizeof(*p)))) {
            p->ia    = cur_ia;
            p->count = 1;
            p->next  = pc_hash[h_index];
            pc_hash[h_index] = p;
         }
      }

      usleep(10000);
   }

   /* Select PCs */
   for(i=0,res_count=0;i<IDLE_HASH_SIZE;i++) {
      for(p=pc_hash[i];p;p=p->next)
         if ((p->count >= 20) && (p->count <= 80)) {
            res = &cpu->idle_pc_prop[cpu->idle_pc_prop_count++];

            res->pc    = p->ia;
            res->count = p->count;

            if (cpu->idle_pc_prop_count >= CPU_IDLE_PC_MAX_RES)
               goto done;
         }
   }

 done:
   /* Set idle PC */
   if (cpu->idle_pc_prop_count) {
      printf("Done. Suggested idling PC:\n");

      for(i=0;i<cpu->idle_pc_prop_count;i++) {
         printf("   0x%llx (count=%u)\n",
                cpu->idle_pc_prop[i].pc,
                cpu->idle_pc_prop[i].count);
      }         

      printf("Restart the emulator with \"--idle-pc=0x%llx\" (for example)\n",
             cpu->idle_pc_prop[0].pc);
   } else {
      printf("Done. No suggestion for idling PC, dumping the full table:\n");

      for(i=0;i<IDLE_HASH_SIZE;i++)
         for(p=pc_hash[i];p;p=p->next) {
            printf("  0x%8.8x (%3u)\n",p->ia,p->count);

            if (cpu->idle_pc_prop_count < CPU_IDLE_PC_MAX_RES) {
               res = &cpu->idle_pc_prop[cpu->idle_pc_prop_count++];

               res->pc    = p->ia;
               res->count = p->count;
            }
         }
       
      printf("\n");
   }

   /* Re-enable IRQ */
   pcpu->irq_disable = FALSE;
   return(0);
}

#if 0
/* Set an IRQ (VM IRQ standard routing) */
void ppc32_vm_set_irq(vm_instance_t *vm,u_int irq)
{
   cpu_ppc_t *boot_cpu;

   boot_cpu = CPU_PPC32(vm->boot_cpu);

   if (boot_cpu->irq_disable) {
      boot_cpu->irq_pending = 0;
      return;
   }

   ppc32_set_irq(boot_cpu,irq);

   if (boot_cpu->irq_idle_preempt[irq])
      cpu_idle_break_wait(vm->boot_cpu);
}

/* Clear an IRQ (VM IRQ standard routing) */
void ppc32_vm_clear_irq(vm_instance_t *vm,u_int irq)
{
   cpu_ppc_t *boot_cpu;

   boot_cpu = CPU_PPC32(vm->boot_cpu);
   ppc32_clear_irq(boot_cpu,irq);
}
#endif

/* Generate an exception */
void ppc32_trigger_exception(cpu_ppc_t *cpu,u_int exc_vector)
{
   //printf("TRIGGER_EXCEPTION: saving cpu->ia=0x%8.8x, msr=0x%8.8x\n",
   //       cpu->ia,cpu->msr);

   /* Save the return instruction address */
   cpu->srr0 = cpu->ia;
   
   if (exc_vector == PPC32_EXC_SYSCALL)
      cpu->srr0 += sizeof(ppc_insn_t);

   //printf("SRR0 = 0x%8.8x\n",cpu->srr0);

   /* Save Machine State Register (MSR) */
   cpu->srr1 = cpu->msr & PPC32_EXC_SRR1_MASK;

   //printf("SRR1 = 0x%8.8x\n",cpu->srr1);

   /* Set the new SRR value */
   cpu->msr &= ~PPC32_EXC_MSR_MASK;
   cpu->irq_check = FALSE;

   //printf("MSR = 0x%8.8x\n",cpu->msr);

   /* Use bootstrap vectors ? */
   if (cpu->msr & PPC32_MSR_IP)
      cpu->ia = 0xFFF00000 + exc_vector;
   else
      cpu->ia = exc_vector;
}

/* Trigger IRQs */
fastcall void ppc32_trigger_irq(cpu_ppc_t *cpu)
{
   if (unlikely(cpu->irq_disable)) {
      cpu->irq_pending = FALSE;
      cpu->irq_check = FALSE;
      return;
   }

   /* Clear the IRQ check flag */
   cpu->irq_check = FALSE;

   if (cpu->irq_pending && (cpu->msr & PPC32_MSR_EE)) {
      cpu->irq_count++;
      cpu->irq_pending = FALSE;
      ppc32_trigger_exception(cpu,PPC32_EXC_EXT);
   }
}

/* Trigger the decrementer exception */
void ppc32_trigger_timer_irq(cpu_ppc_t *cpu)
{
   cpu->timer_irq_count++;

   if (cpu->msr & PPC32_MSR_EE)
      ppc32_trigger_exception(cpu,PPC32_EXC_DEC);
}

/* Virtual breakpoint */
fastcall void ppc32_run_breakpoint(cpu_ppc_t *cpu)
{
   cpu_log(cpu->gen,"BREAKPOINT",
           "Virtual breakpoint reached at IA=0x%8.8x\n",cpu->ia);

   printf("[[[ Virtual Breakpoint reached at IA=0x%8.8x LR=0x%8.8x]]]\n",
          cpu->ia,cpu->lr);

   ppc32_dump_regs(cpu->gen);
}

/* Add a virtual breakpoint */
int ppc32_add_breakpoint(cpu_gen_t *cpu,m_uint64_t ia)
{
   cpu_ppc_t *pcpu = CPU_PPC32(cpu);
   int i;

   for(i=0;i<PPC32_MAX_BREAKPOINTS;i++)
      if (!pcpu->breakpoints[i])
         break;

   if (i == PPC32_MAX_BREAKPOINTS)
      return(-1);

   pcpu->breakpoints[i] = ia;
   pcpu->breakpoints_enabled = TRUE;
   return(0);
}

/* Remove a virtual breakpoint */
void ppc32_remove_breakpoint(cpu_gen_t *cpu,m_uint64_t ia)
{   
   cpu_ppc_t *pcpu = CPU_PPC32(cpu);
   int i,j;

   for(i=0;i<PPC32_MAX_BREAKPOINTS;i++)
      if (pcpu->breakpoints[i] == ia)
      {
         for(j=i;j<PPC32_MAX_BREAKPOINTS-1;j++)
            pcpu->breakpoints[j] = pcpu->breakpoints[j+1];

         pcpu->breakpoints[PPC32_MAX_BREAKPOINTS-1] = 0;
      }

   for(i=0;i<PPC32_MAX_BREAKPOINTS;i++)
      if (pcpu->breakpoints[i] != 0)
         return;

   pcpu->breakpoints_enabled = FALSE;
}

/* Set a register */
void ppc32_reg_set(cpu_gen_t *cpu,u_int reg,m_uint64_t val)
{
   if (reg < PPC32_GPR_NR)
      CPU_PPC32(cpu)->gpr[reg] = (m_uint32_t)val;
}

/* Dump registers of a PowerPC processor */
void ppc32_dump_regs(cpu_gen_t *cpu)
{ 
   cpu_ppc_t *pcpu = CPU_PPC32(cpu);
   int i;
   
   printf("PowerPC Registers:\n");

   for(i=0;i<PPC32_GPR_NR/4;i++) {
      printf("  $%2d = 0x%8.8x  $%2d = 0x%8.8x"
             "  $%2d = 0x%8.8x  $%2d = 0x%8.8x\n",
             i*4, pcpu->gpr[i*4], (i*4)+1, pcpu->gpr[(i*4)+1],
             (i*4)+2, pcpu->gpr[(i*4)+2], (i*4)+3, pcpu->gpr[(i*4)+3]);
   }

   printf("\n");
   printf("  ia = 0x%8.8x, lr = 0x%8.8x\n", pcpu->ia, pcpu->lr);
   printf("  cr = 0x%8.8x, msr = 0x%8.8x, xer = 0x%8.8x, dec = 0x%8.8x\n", 
          ppc32_get_cr(pcpu), pcpu->msr, 
          pcpu->xer | (pcpu->xer_ca << PPC32_XER_CA_BIT), 
          pcpu->dec);

   printf("  sprg[0] = 0x%8.8x, sprg[1] = 0x%8.8x\n",
          pcpu->sprg[0],pcpu->sprg[1]);

   printf("  sprg[2] = 0x%8.8x, sprg[3] = 0x%8.8x\n",
          pcpu->sprg[2],pcpu->sprg[3]);

   printf("\n  IRQ count: %llu, IRQ false positives: %llu, "
          "IRQ Pending: %u, IRQ Check: %s\n",
          pcpu->irq_count,pcpu->irq_fp_count,pcpu->irq_pending,
          pcpu->irq_check ? "yes" : "no");

   printf("  Timer IRQ count: %llu, pending: %u, timer drift: %u\n\n",
          pcpu->timer_irq_count,pcpu->timer_irq_pending,pcpu->timer_drift);

   printf("  Device access count: %llu\n",cpu->dev_access_counter);

   printf("\n");
}

/* Dump BAT registers */
static void ppc32_dump_bat(cpu_ppc_t *cpu,int index)
{
   int i;

   for(i=0;i<PPC32_BAT_NR;i++)
      printf("    BAT[%d] = 0x%8.8x 0x%8.8x\n",
             i,cpu->bat[index][i].reg[0],cpu->bat[index][i].reg[1]);
}

/* Dump MMU registers */
void ppc32_dump_mmu(cpu_gen_t *cpu)
{
   cpu_ppc_t *pcpu = CPU_PPC32(cpu);
   int i;

   printf("PowerPC MMU Registers:\n");

   printf(" - IBAT Registers:\n");
   ppc32_dump_bat(pcpu,PPC32_IBAT_IDX);

   printf(" - DBAT Registers:\n");
   ppc32_dump_bat(pcpu,PPC32_DBAT_IDX);

   printf(" - Segment Registers:\n");
   for(i=0;i<PPC32_SR_NR;i++)
      printf("    SR[%d] = 0x%8.8x\n",i,pcpu->sr[i]);

   printf(" - SDR1: 0x%8.8x\n",pcpu->sdr1);
}

/* Load a raw image into the simulated memory */
int ppc32_load_raw_image(cpu_ppc_t *cpu,char *filename,m_uint32_t vaddr)
{   
   struct stat file_info;
   size_t len,clen;
   m_uint32_t remain;
   void *haddr;
   FILE *bfd;

   if (!(bfd = fopen(filename,"r"))) {
      perror("fopen");
      return(-1);
   }

   if (fstat(fileno(bfd),&file_info) == -1) {
      perror("stat");
      return(-1);
   }

   len = file_info.st_size;

   printf("Loading RAW file '%s' at virtual address 0x%8.8x (size=%lu)\n",
          filename,vaddr,(u_long)len);

   while(len > 0)
   {
      haddr = cpu->mem_op_lookup(cpu,vaddr,PPC32_MTS_DCACHE);
   
      if (!haddr) {
         fprintf(stderr,"load_raw_image: invalid load address 0x%8.8x\n",
                 vaddr);
         return(-1);
      }

      if (len > PPC32_MIN_PAGE_SIZE)
         clen = PPC32_MIN_PAGE_SIZE;
      else
         clen = len;

      remain = MIPS_MIN_PAGE_SIZE;
      remain -= (vaddr - (vaddr & MIPS_MIN_PAGE_MASK));
      
      clen = m_min(clen,remain);

      if (fread((u_char *)haddr,clen,1,bfd) != 1)
         break;
      
      vaddr += clen;
      len -= clen;
   }
   
   fclose(bfd);
   return(0);
}

/* Load an ELF image into the simulated memory */
int ppc32_load_elf_image(cpu_ppc_t *cpu,char *filename,int skip_load,
                         m_uint32_t *entry_point)
{
   m_uint32_t vaddr,remain;
   void *haddr;
   Elf32_Ehdr *ehdr;
   Elf32_Shdr *shdr;
   Elf_Scn *scn;
   Elf *img_elf;
   size_t len,clen;
   char *name;
   int i,fd;
   FILE *bfd;

   if (!filename)
      return(-1);

#ifdef __CYGWIN__
   fd = open(filename,O_RDONLY|O_BINARY);
#else
   fd = open(filename,O_RDONLY);
#endif

   if (fd == -1) {
      perror("load_elf_image: open");
      return(-1);
   }

   if (elf_version(EV_CURRENT) == EV_NONE) {
      fprintf(stderr,"load_elf_image: library out of date\n");
      return(-1);
   }

   if (!(img_elf = elf_begin(fd,ELF_C_READ,NULL))) {
      fprintf(stderr,"load_elf_image: elf_begin: %s\n",
              elf_errmsg(elf_errno()));
      return(-1);
   }

   if (!(ehdr = elf32_getehdr(img_elf))) {
      fprintf(stderr,"load_elf_image: invalid ELF file\n");
      return(-1);
   }

   printf("Loading ELF file '%s'...\n",filename);
   bfd = fdopen(fd,"rb");

   if (!bfd) {
      perror("load_elf_image: fdopen");
      return(-1);
   }

   if (!skip_load) {
      for(i=0;i<ehdr->e_shnum;i++) {
         scn = elf_getscn(img_elf,i);

         shdr = elf32_getshdr(scn);
         name = elf_strptr(img_elf, ehdr->e_shstrndx, (size_t)shdr->sh_name);
         len  = shdr->sh_size;

         if (!(shdr->sh_flags & SHF_ALLOC) || !len)
            continue;

         fseek(bfd,shdr->sh_offset,SEEK_SET);
         vaddr = shdr->sh_addr;

         if (cpu->vm->debug_level > 0) {
            printf("   * Adding section at virtual address 0x%8.8x "
                   "(len=0x%8.8lx)\n",vaddr,(u_long)len);
         }
         
         while(len > 0)
         {
            haddr = cpu->mem_op_lookup(cpu,vaddr,PPC32_MTS_DCACHE);

            if (!haddr) {
               fprintf(stderr,"load_elf_image: invalid load address 0x%x\n",
                       vaddr);
               return(-1);
            }

            if (len > PPC32_MIN_PAGE_SIZE)
               clen = PPC32_MIN_PAGE_SIZE;
            else
               clen = len;

            remain = PPC32_MIN_PAGE_SIZE;
            remain -= (vaddr - (vaddr & PPC32_MIN_PAGE_MASK));

            clen = m_min(clen,remain);

            if (fread((u_char *)haddr,clen,1,bfd) < 1)
               break;

            vaddr += clen;
            len -= clen;
         }
      }
   } else {
      printf("ELF loading skipped, using a ghost RAM file.\n");
   }

   printf("ELF entry point: 0x%x\n",ehdr->e_entry);

   if (entry_point)
      *entry_point = ehdr->e_entry;

   elf_end(img_elf);
   fclose(bfd);
   return(0);
}
1	dpavlin	7	/*
2			* Cisco router simulation platform.
3			* Copyright (c) 2005,2006 Christophe Fillot (cf@utc.fr)
4			*
5			* PowerPC (32-bit) generic routines.
6			*/
7
8			#include <stdio.h>
9			#include <stdlib.h>
10			#include <unistd.h>
11			#include <string.h>
12			#include <sys/types.h>
13			#include <sys/stat.h>
14			#include <sys/mman.h>
15			#include <fcntl.h>
16			#include <assert.h>
17
18			#include "rbtree.h"
19			#include "cpu.h"
20			#include "dynamips.h"
21			#include "memory.h"
22			#include "device.h"
23			#include "ppc32_mem.h"
24			#include "ppc32_exec.h"
25			#include "ppc32_jit.h"
26
27			/* Reset a PowerPC CPU */
28			int ppc32_reset(cpu_ppc_t *cpu)
29			{
30			cpu->ia = PPC32_ROM_START;
31			cpu->gpr[1] = PPC32_ROM_SP;
32			cpu->msr = PPC32_MSR_IP;
33
34			/* Restart the MTS subsystem */
35			ppc32_mem_restart(cpu);
36
37			/* Flush JIT structures */
38			ppc32_jit_flush(cpu,0);
39			return(0);
40			}
41
42			/* Initialize a PowerPC processor */
43			int ppc32_init(cpu_ppc_t *cpu)
44			{
45	dpavlin	9	/* Initialize JIT operations */
46			jit_op_init_cpu(cpu->gen);
47
48	dpavlin	7	/* Initialize idle timer */
49			cpu->gen->idle_max = 1500;
50			cpu->gen->idle_sleep_time = 30000;
51
52			/* Timer IRQ parameters (default frequency: 250 Hz <=> 4ms period) */
53			cpu->timer_irq_check_itv = 1000;
54			cpu->timer_irq_freq = 250;
55
56	dpavlin	8	/* Enable/disable direct block jump */
57			cpu->exec_blk_direct_jump = cpu->vm->exec_blk_direct_jump;
58
59	dpavlin	7	/* Idle loop mutex and condition */
60			pthread_mutex_init(&cpu->gen->idle_mutex,NULL);
61			pthread_cond_init(&cpu->gen->idle_cond,NULL);
62
63			/* Set the CPU methods */
64			cpu->gen->reg_set = (void *)ppc32_reg_set;
65			cpu->gen->reg_dump = (void *)ppc32_dump_regs;
66			cpu->gen->mmu_dump = (void *)ppc32_dump_mmu;
67			cpu->gen->mmu_raw_dump = (void *)ppc32_dump_mmu;
68			cpu->gen->add_breakpoint = (void *)ppc32_add_breakpoint;
69			cpu->gen->remove_breakpoint = (void *)ppc32_remove_breakpoint;
70			cpu->gen->set_idle_pc = (void *)ppc32_set_idle_pc;
71			cpu->gen->get_idling_pc = (void *)ppc32_get_idling_pc;
72
73			/* Set the startup parameters */
74			ppc32_reset(cpu);
75			return(0);
76			}
77
78			/* Delete a PowerPC processor */
79			void ppc32_delete(cpu_ppc_t *cpu)
80			{
81			if (cpu) {
82			ppc32_mem_shutdown(cpu);
83			ppc32_jit_shutdown(cpu);
84			}
85			}
86
87			/* Set the processor version register (PVR) */
88			void ppc32_set_pvr(cpu_ppc_t *cpu,m_uint32_t pvr)
89			{
90			cpu->pvr = pvr;
91			ppc32_mem_restart(cpu);
92			}
93
94			/* Set idle PC value */
95			void ppc32_set_idle_pc(cpu_gen_t *cpu,m_uint64_t addr)
96			{
97			CPU_PPC32(cpu)->idle_pc = (m_uint32_t)addr;
98			}
99
100			/* Timer IRQ */
101			void ppc32_timer_irq_run(cpu_ppc_t cpu)
102			{
103			pthread_mutex_t umutex = PTHREAD_MUTEX_INITIALIZER;
104			pthread_cond_t ucond = PTHREAD_COND_INITIALIZER;
105			struct timespec t_spc;
106			m_tmcnt_t expire;
107			u_int interval;
108			u_int threshold;
109
110			#if 0
111			while(!cpu->timer_irq_armed)
112			sleep(1);
113			#endif
114
115			interval = 1000000 / cpu->timer_irq_freq;
116			threshold = cpu->timer_irq_freq * 10;
117			expire = m_gettime_usec() + interval;
118
119			while(cpu->gen->state != CPU_STATE_HALTED) {
120			pthread_mutex_lock(&umutex);
121			t_spc.tv_sec = expire / 1000000;
122			t_spc.tv_nsec = (expire % 1000000) * 1000;
123			pthread_cond_timedwait(&ucond,&umutex,&t_spc);
124			pthread_mutex_unlock(&umutex);
125
126			if (likely(!cpu->irq_disable) &&
127			likely(cpu->gen->state == CPU_STATE_RUNNING) &&
128			likely(cpu->msr & PPC32_MSR_EE))
129			{
130			cpu->timer_irq_pending++;
131
132			if (unlikely(cpu->timer_irq_pending > threshold)) {
133			cpu->timer_irq_pending = 0;
134			cpu->timer_drift++;
135			#if 0
136			printf("Timer IRQ not accurate (%u pending IRQ): "
137			"reduce the \"--timer-irq-check-itv\" parameter "
138			"(current value: %u)\n",
139			cpu->timer_irq_pending,cpu->timer_irq_check_itv);
140			#endif
141			}
142			}
143
144			expire += interval;
145			}
146
147			return NULL;
148			}
149
150			#define IDLE_HASH_SIZE 8192
151
152			/* Idle PC hash item */
153			struct ppc32_idle_pc_hash {
154			m_uint32_t ia;
155			u_int count;
156			struct ppc32_idle_pc_hash *next;
157			};
158
159			/* Determine an "idling" PC */
160			int ppc32_get_idling_pc(cpu_gen_t *cpu)
161			{
162			cpu_ppc_t *pcpu = CPU_PPC32(cpu);
163			struct ppc32_idle_pc_hash *pc_hash,p;
164			struct cpu_idle_pc *res;
165			u_int h_index,res_count;
166			m_uint32_t cur_ia;
167			int i;
168
169			cpu->idle_pc_prop_count = 0;
170
171			if (pcpu->idle_pc != 0) {
172			printf("\nYou already use an idle PC, using the calibration would give "
173			"incorrect results.\n");
174			return(-1);
175			}
176
177			printf("\nPlease wait while gathering statistics...\n");
178
179			pc_hash = calloc(IDLE_HASH_SIZE,sizeof(struct ppc32_idle_pc_hash *));
180
181			/* Disable IRQ */
182			pcpu->irq_disable = TRUE;
183
184			/* Take 1000 measures, each mesure every 10ms */
185			for(i=0;i<1000;i++) {
186			cur_ia = pcpu->ia;
187			h_index = (cur_ia >> 2) & (IDLE_HASH_SIZE-1);
188
189			for(p=pc_hash[h_index];p;p=p->next)
190			if (p->ia == cur_ia) {
191			p->count++;
192			break;
193			}
194
195			if (!p) {
196			if ((p = malloc(sizeof(*p)))) {
197			p->ia = cur_ia;
198			p->count = 1;
199			p->next = pc_hash[h_index];
200			pc_hash[h_index] = p;
201			}
202			}
203
204			usleep(10000);
205			}
206
207			/* Select PCs */
208			for(i=0,res_count=0;i<IDLE_HASH_SIZE;i++) {
209			for(p=pc_hash[i];p;p=p->next)
210			if ((p->count >= 20) && (p->count <= 80)) {
211			res = &cpu->idle_pc_prop[cpu->idle_pc_prop_count++];
212
213			res->pc = p->ia;
214			res->count = p->count;
215
216			if (cpu->idle_pc_prop_count >= CPU_IDLE_PC_MAX_RES)
217			goto done;
218			}
219			}
220
221			done:
222			/* Set idle PC */
223			if (cpu->idle_pc_prop_count) {
224			printf("Done. Suggested idling PC:\n");
225
226			for(i=0;i<cpu->idle_pc_prop_count;i++) {
227			printf(" 0x%llx (count=%u)\n",
228			cpu->idle_pc_prop[i].pc,
229			cpu->idle_pc_prop[i].count);
230			}
231
232			printf("Restart the emulator with \"--idle-pc=0x%llx\" (for example)\n",
233			cpu->idle_pc_prop[0].pc);
234			} else {
235	dpavlin	8	printf("Done. No suggestion for idling PC, dumping the full table:\n");
236
237			for(i=0;i<IDLE_HASH_SIZE;i++)
238			for(p=pc_hash[i];p;p=p->next) {
239			printf(" 0x%8.8x (%3u)\n",p->ia,p->count);
240
241			if (cpu->idle_pc_prop_count < CPU_IDLE_PC_MAX_RES) {
242			res = &cpu->idle_pc_prop[cpu->idle_pc_prop_count++];
243
244			res->pc = p->ia;
245			res->count = p->count;
246			}
247			}
248
249			printf("\n");
250	dpavlin	7	}
251
252			/* Re-enable IRQ */
253			pcpu->irq_disable = FALSE;
254			return(0);
255			}
256
257			#if 0
258			/* Set an IRQ (VM IRQ standard routing) */
259			void ppc32_vm_set_irq(vm_instance_t *vm,u_int irq)
260			{
261			cpu_ppc_t *boot_cpu;
262
263			boot_cpu = CPU_PPC32(vm->boot_cpu);
264
265			if (boot_cpu->irq_disable) {
266			boot_cpu->irq_pending = 0;
267			return;
268			}
269
270			ppc32_set_irq(boot_cpu,irq);
271
272			if (boot_cpu->irq_idle_preempt[irq])
273			cpu_idle_break_wait(vm->boot_cpu);
274			}
275
276			/* Clear an IRQ (VM IRQ standard routing) */
277			void ppc32_vm_clear_irq(vm_instance_t *vm,u_int irq)
278			{
279			cpu_ppc_t *boot_cpu;
280
281			boot_cpu = CPU_PPC32(vm->boot_cpu);
282			ppc32_clear_irq(boot_cpu,irq);
283			}
284			#endif
285
286			/* Generate an exception */
287			void ppc32_trigger_exception(cpu_ppc_t *cpu,u_int exc_vector)
288			{
289			//printf("TRIGGER_EXCEPTION: saving cpu->ia=0x%8.8x, msr=0x%8.8x\n",
290			// cpu->ia,cpu->msr);
291
292			/* Save the return instruction address */
293			cpu->srr0 = cpu->ia;
294
295			if (exc_vector == PPC32_EXC_SYSCALL)
296			cpu->srr0 += sizeof(ppc_insn_t);
297
298			//printf("SRR0 = 0x%8.8x\n",cpu->srr0);
299
300			/* Save Machine State Register (MSR) */
301			cpu->srr1 = cpu->msr & PPC32_EXC_SRR1_MASK;
302
303			//printf("SRR1 = 0x%8.8x\n",cpu->srr1);
304
305			/* Set the new SRR value */
306			cpu->msr &= ~PPC32_EXC_MSR_MASK;
307			cpu->irq_check = FALSE;
308
309			//printf("MSR = 0x%8.8x\n",cpu->msr);
310
311			/* Use bootstrap vectors ? */
312			if (cpu->msr & PPC32_MSR_IP)
313			cpu->ia = 0xFFF00000 + exc_vector;
314			else
315			cpu->ia = exc_vector;
316			}
317
318			/* Trigger IRQs */
319			fastcall void ppc32_trigger_irq(cpu_ppc_t *cpu)
320			{
321			if (unlikely(cpu->irq_disable)) {
322			cpu->irq_pending = FALSE;
323			cpu->irq_check = FALSE;
324			return;
325			}
326
327			/* Clear the IRQ check flag */
328			cpu->irq_check = FALSE;
329
330			if (cpu->irq_pending && (cpu->msr & PPC32_MSR_EE)) {
331			cpu->irq_count++;
332			cpu->irq_pending = FALSE;
333			ppc32_trigger_exception(cpu,PPC32_EXC_EXT);
334			}
335			}
336
337			/* Trigger the decrementer exception */
338			void ppc32_trigger_timer_irq(cpu_ppc_t *cpu)
339			{
340			cpu->timer_irq_count++;
341
342			if (cpu->msr & PPC32_MSR_EE)
343			ppc32_trigger_exception(cpu,PPC32_EXC_DEC);
344			}
345
346			/* Virtual breakpoint */
347			fastcall void ppc32_run_breakpoint(cpu_ppc_t *cpu)
348			{
349			cpu_log(cpu->gen,"BREAKPOINT",
350			"Virtual breakpoint reached at IA=0x%8.8x\n",cpu->ia);
351
352			printf("[[[ Virtual Breakpoint reached at IA=0x%8.8x LR=0x%8.8x]]]\n",
353			cpu->ia,cpu->lr);
354
355			ppc32_dump_regs(cpu->gen);
356			}
357
358			/* Add a virtual breakpoint */
359			int ppc32_add_breakpoint(cpu_gen_t *cpu,m_uint64_t ia)
360			{
361			cpu_ppc_t *pcpu = CPU_PPC32(cpu);
362			int i;
363
364			for(i=0;i<PPC32_MAX_BREAKPOINTS;i++)
365			if (!pcpu->breakpoints[i])
366			break;
367
368			if (i == PPC32_MAX_BREAKPOINTS)
369			return(-1);
370
371			pcpu->breakpoints[i] = ia;
372			pcpu->breakpoints_enabled = TRUE;
373			return(0);
374			}
375
376			/* Remove a virtual breakpoint */
377			void ppc32_remove_breakpoint(cpu_gen_t *cpu,m_uint64_t ia)
378			{
379			cpu_ppc_t *pcpu = CPU_PPC32(cpu);
380			int i,j;
381
382			for(i=0;i<PPC32_MAX_BREAKPOINTS;i++)
383			if (pcpu->breakpoints[i] == ia)
384			{
385			for(j=i;j<PPC32_MAX_BREAKPOINTS-1;j++)
386			pcpu->breakpoints[j] = pcpu->breakpoints[j+1];
387
388			pcpu->breakpoints[PPC32_MAX_BREAKPOINTS-1] = 0;
389			}
390
391			for(i=0;i<PPC32_MAX_BREAKPOINTS;i++)
392			if (pcpu->breakpoints[i] != 0)
393			return;
394
395			pcpu->breakpoints_enabled = FALSE;
396			}
397
398			/* Set a register */
399			void ppc32_reg_set(cpu_gen_t *cpu,u_int reg,m_uint64_t val)
400			{
401			if (reg < PPC32_GPR_NR)
402			CPU_PPC32(cpu)->gpr[reg] = (m_uint32_t)val;
403			}
404
405			/* Dump registers of a PowerPC processor */
406			void ppc32_dump_regs(cpu_gen_t *cpu)
407			{
408			cpu_ppc_t *pcpu = CPU_PPC32(cpu);
409			int i;
410
411			printf("PowerPC Registers:\n");
412
413			for(i=0;i<PPC32_GPR_NR/4;i++) {
414			printf(" $%2d = 0x%8.8x $%2d = 0x%8.8x"
415			" $%2d = 0x%8.8x $%2d = 0x%8.8x\n",
416			i4, pcpu->gpr[i4], (i4)+1, pcpu->gpr[(i4)+1],
417			(i4)+2, pcpu->gpr[(i4)+2], (i4)+3, pcpu->gpr[(i4)+3]);
418			}
419
420			printf("\n");
421			printf(" ia = 0x%8.8x, lr = 0x%8.8x\n", pcpu->ia, pcpu->lr);
422			printf(" cr = 0x%8.8x, msr = 0x%8.8x, xer = 0x%8.8x, dec = 0x%8.8x\n",
423	dpavlin	8	ppc32_get_cr(pcpu), pcpu->msr,
424	dpavlin	7	pcpu->xer \| (pcpu->xer_ca << PPC32_XER_CA_BIT),
425			pcpu->dec);
426
427			printf(" sprg[0] = 0x%8.8x, sprg[1] = 0x%8.8x\n",
428			pcpu->sprg[0],pcpu->sprg[1]);
429
430			printf(" sprg[2] = 0x%8.8x, sprg[3] = 0x%8.8x\n",
431			pcpu->sprg[2],pcpu->sprg[3]);
432
433			printf("\n IRQ count: %llu, IRQ false positives: %llu, "
434			"IRQ Pending: %u, IRQ Check: %s\n",
435			pcpu->irq_count,pcpu->irq_fp_count,pcpu->irq_pending,
436			pcpu->irq_check ? "yes" : "no");
437
438			printf(" Timer IRQ count: %llu, pending: %u, timer drift: %u\n\n",
439			pcpu->timer_irq_count,pcpu->timer_irq_pending,pcpu->timer_drift);
440
441	dpavlin	8	printf(" Device access count: %llu\n",cpu->dev_access_counter);
442
443	dpavlin	7	printf("\n");
444			}
445
446			/* Dump BAT registers */
447			static void ppc32_dump_bat(cpu_ppc_t *cpu,int index)
448			{
449			int i;
450
451			for(i=0;i<PPC32_BAT_NR;i++)
452			printf(" BAT[%d] = 0x%8.8x 0x%8.8x\n",
453			i,cpu->bat[index][i].reg[0],cpu->bat[index][i].reg[1]);
454			}
455
456			/* Dump MMU registers */
457			void ppc32_dump_mmu(cpu_gen_t *cpu)
458			{
459			cpu_ppc_t *pcpu = CPU_PPC32(cpu);
460			int i;
461
462			printf("PowerPC MMU Registers:\n");
463
464			printf(" - IBAT Registers:\n");
465			ppc32_dump_bat(pcpu,PPC32_IBAT_IDX);
466
467			printf(" - DBAT Registers:\n");
468			ppc32_dump_bat(pcpu,PPC32_DBAT_IDX);
469
470			printf(" - Segment Registers:\n");
471			for(i=0;i<PPC32_SR_NR;i++)
472			printf(" SR[%d] = 0x%8.8x\n",i,pcpu->sr[i]);
473
474			printf(" - SDR1: 0x%8.8x\n",pcpu->sdr1);
475			}
476
477			/* Load a raw image into the simulated memory */
478			int ppc32_load_raw_image(cpu_ppc_t cpu,char filename,m_uint32_t vaddr)
479			{
480			struct stat file_info;
481			size_t len,clen;
482			m_uint32_t remain;
483			void *haddr;
484			FILE *bfd;
485
486			if (!(bfd = fopen(filename,"r"))) {
487			perror("fopen");
488			return(-1);
489			}
490
491			if (fstat(fileno(bfd),&file_info) == -1) {
492			perror("stat");
493			return(-1);
494			}
495
496			len = file_info.st_size;
497
498			printf("Loading RAW file '%s' at virtual address 0x%8.8x (size=%lu)\n",
499			filename,vaddr,(u_long)len);
500
501			while(len > 0)
502			{
503			haddr = cpu->mem_op_lookup(cpu,vaddr,PPC32_MTS_DCACHE);
504
505			if (!haddr) {
506			fprintf(stderr,"load_raw_image: invalid load address 0x%8.8x\n",
507			vaddr);
508			return(-1);
509			}
510
511			if (len > PPC32_MIN_PAGE_SIZE)
512			clen = PPC32_MIN_PAGE_SIZE;
513			else
514			clen = len;
515
516			remain = MIPS_MIN_PAGE_SIZE;
517			remain -= (vaddr - (vaddr & MIPS_MIN_PAGE_MASK));
518
519			clen = m_min(clen,remain);
520
521			if (fread((u_char *)haddr,clen,1,bfd) != 1)
522			break;
523
524			vaddr += clen;
525			len -= clen;
526			}
527
528			fclose(bfd);
529			return(0);
530			}
531
532			/* Load an ELF image into the simulated memory */
533			int ppc32_load_elf_image(cpu_ppc_t cpu,char filename,int skip_load,
534			m_uint32_t *entry_point)
535			{
536			m_uint32_t vaddr,remain;
537			void *haddr;
538			Elf32_Ehdr *ehdr;
539			Elf32_Shdr *shdr;
540			Elf_Scn *scn;
541			Elf *img_elf;
542			size_t len,clen;
543			char *name;
544			int i,fd;
545			FILE *bfd;
546
547			if (!filename)
548			return(-1);
549
550			#ifdef __CYGWIN__
551			fd = open(filename,O_RDONLY\|O_BINARY);
552			#else
553			fd = open(filename,O_RDONLY);
554			#endif
555
556			if (fd == -1) {
557			perror("load_elf_image: open");
558			return(-1);
559			}
560
561			if (elf_version(EV_CURRENT) == EV_NONE) {
562			fprintf(stderr,"load_elf_image: library out of date\n");
563			return(-1);
564			}
565
566			if (!(img_elf = elf_begin(fd,ELF_C_READ,NULL))) {
567			fprintf(stderr,"load_elf_image: elf_begin: %s\n",
568			elf_errmsg(elf_errno()));
569			return(-1);
570			}
571
572			if (!(ehdr = elf32_getehdr(img_elf))) {
573			fprintf(stderr,"load_elf_image: invalid ELF file\n");
574			return(-1);
575			}
576
577			printf("Loading ELF file '%s'...\n",filename);
578			bfd = fdopen(fd,"rb");
579
580			if (!bfd) {
581			perror("load_elf_image: fdopen");
582			return(-1);
583			}
584
585			if (!skip_load) {
586			for(i=0;i<ehdr->e_shnum;i++) {
587			scn = elf_getscn(img_elf,i);
588
589			shdr = elf32_getshdr(scn);
590			name = elf_strptr(img_elf, ehdr->e_shstrndx, (size_t)shdr->sh_name);
591			len = shdr->sh_size;
592
593			if (!(shdr->sh_flags & SHF_ALLOC) \|\| !len)
594			continue;
595
596			fseek(bfd,shdr->sh_offset,SEEK_SET);
597			vaddr = shdr->sh_addr;
598
599			if (cpu->vm->debug_level > 0) {
600			printf(" * Adding section at virtual address 0x%8.8x "
601			"(len=0x%8.8lx)\n",vaddr,(u_long)len);
602			}
603
604			while(len > 0)
605			{
606			haddr = cpu->mem_op_lookup(cpu,vaddr,PPC32_MTS_DCACHE);
607
608			if (!haddr) {
609			fprintf(stderr,"load_elf_image: invalid load address 0x%x\n",
610			vaddr);
611			return(-1);
612			}
613
614			if (len > PPC32_MIN_PAGE_SIZE)
615			clen = PPC32_MIN_PAGE_SIZE;
616			else
617			clen = len;
618
619			remain = PPC32_MIN_PAGE_SIZE;
620			remain -= (vaddr - (vaddr & PPC32_MIN_PAGE_MASK));
621
622			clen = m_min(clen,remain);
623
624			if (fread((u_char *)haddr,clen,1,bfd) < 1)
625			break;
626
627			vaddr += clen;
628			len -= clen;
629			}
630			}
631			} else {
632			printf("ELF loading skipped, using a ghost RAM file.\n");
633			}
634
635			printf("ELF entry point: 0x%x\n",ehdr->e_entry);
636
637			if (entry_point)
638			*entry_point = ehdr->e_entry;
639
640			elf_end(img_elf);
641			fclose(bfd);
642			return(0);
643			}