URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [or1ksim/] [cpu/] [or32/] [execute.c] - Blame information for rev 1748

Go to most recent revision | Details | Compare with Previous | View Log


/* execute.c -- OR1K architecture dependent simulation
 
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
   Copyright (C) 2005 Gy�rgy `nog' Jeney, nog@sdf.lonestar.org
   Copyright (C) 2008 Embecosm Limited
 
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of OpenRISC 1000 Architectural Simulator.
 
   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 3 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, see <http://www.gnu.org/licenses/>. */
 
/* This program is commented throughout in a fashion suitable for processing
   with Doxygen. */
 
 
/* Most of the OR1K simulation is done in here.
 
   When SIMPLE_EXECUTION is defined below a file insnset.c is included!
*/
 
/* Autoconf and/or portability configuration */
#include "config.h"
#include "port.h"
 
/* System includes */
#include <stdlib.h>
 
/* Package includes */
#include "execute.h"
#include "toplevel-support.h"
#include "except.h"
#include "labels.h"
#include "gdbcomm.h"
#include "sched.h"
#include "stats.h"
#include "opcode/or32.h"
#include "dmmu.h"
#include "immu.h"
#include "sim-cmd.h"
#include "vapi.h"
#include "debug-unit.h"
#include "branch-predict.h"
#include "support/simprintf.h"
#include "sprs.h"
 
 
/* Sets a new SPR_SR_OV value, based on next register value */
#if SET_OV_FLAG
#define SET_OV_FLAG_FN(value) \
  if((value) & 0x80000000) \
    cpu_state.sprs[SPR_SR] |= SPR_SR_OV; \
  else \
    cpu_state.sprs[SPR_SR] &= ~SPR_SR_OV
#else
#define SET_OV_FLAG_FN(value)
#endif
 
/* Macros for simple execution */
#if SIMPLE_EXECUTION
#define SET_PARAM0(val) set_operand(0, val, current->insn_index, current->insn)
 
#define PARAM0 eval_operand(0, current->insn_index, current->insn)
#define PARAM1 eval_operand(1, current->insn_index, current->insn)
#define PARAM2 eval_operand(2, current->insn_index, current->insn)
#endif
 
/*! Current cpu state. Globally available. */
struct cpu_state  cpu_state;
 
/*! Temporary program counter. Globally available */
oraddr_t  pcnext;
 
/*! Num cycles waiting for stores to complete. Globally available */
int  sbuf_wait_cyc = 0;
 
/*! Number of total store cycles. Globally available */
int  sbuf_total_cyc = 0;
 
/*! Whether we are doing statistical analysis. Globally available */
int  do_stats = 0;
 
/*! History of execution. Globally available */
struct hist_exec *hist_exec_tail = NULL;
 
/* Benchmark multi issue execution. This file only */
static int  multissue[20];
static int  issued_per_cycle = 4;
 
/* Store buffer analysis - stores are accumulated and commited when IO is
   idle. This file only */
static int  sbuf_head              = 0;
static int  sbuf_tail              = 0;
static int  sbuf_count             = 0;
static int  sbuf_buf[MAX_SBUF_LEN] = { 0 };
 
static int sbuf_prev_cycles = 0;
 
/* Local data needed for execution.  */
static int next_delay_insn;
static int breakpoint;
 
/* Forward declaration of static functions */
static void decode_execute (struct iqueue_entry *current);
 
/*---------------------------------------------------------------------------*/
/*!Get an actual value of a specific register
 
   Implementation specific. Abort if we are given a duff register. Only used
   externally to support simprintf().
 
   @param[in] regno  The register of interest
 
   @return  The value of the register                                        */
/*---------------------------------------------------------------------------*/
uorreg_t
evalsim_reg (unsigned int  regno)
{
  if (regno < MAX_GPRS)
    {
#if RAW_RANGE_STATS
      int delta = (runtime.sim.cycles - raw_stats.reg[regno]);
 
      if ((unsigned long) delta < (unsigned long) MAX_RAW_RANGE)
        {
          raw_stats.range[delta]++;
        }
#endif /* RAW_RANGE */
 
      return cpu_state.reg[regno];
    }
  else
    {
      PRINTF ("\nABORT: read out of registers\n");
      sim_done ();
      return 0;
    }
}       /* evalsim_reg() */
 
 
/*---------------------------------------------------------------------------*/
/*!Set a specific register with value
 
   Implementation specific. Abort if we are given a duff register.
 
   @param[in] regno  The register of interest
   @param[in] value  The value to be set                                     */
/*---------------------------------------------------------------------------*/
void
setsim_reg (unsigned int  regno,
            uorreg_t      value)
{
  if (regno == 0)                /* gpr0 is always zero */
    {
      value = 0;
    }
 
  if (regno < MAX_GPRS)
    {
      cpu_state.reg[regno] = value;
    }
  else
    {
      PRINTF ("\nABORT: write out of registers\n");
      sim_done ();
    }
 
#if RAW_RANGE_STATS
  raw_stats.reg[regno] = runtime.sim.cycles;
#endif /* RAW_RANGE */
 
}       /* setsim_reg() */
 
 
/*---------------------------------------------------------------------------*/
/*!Evaluates source operand operand
 
   Implementation specific. Declared global, although this is only actually
   required for DYNAMIC_EXECUTION,
 
   @param[in] insn  The instruction
   @param[in] opd   The operand
 
   @return  The value of the source operand                                  */
/*---------------------------------------------------------------------------*/
uorreg_t
eval_operand_val (uint32_t               insn,
                  struct insn_op_struct *opd)
{
  unsigned long  operand = 0;
  unsigned long  sbit;
  unsigned int   nbits = 0;
 
  while (1)
    {
      operand |=
        ((insn >> (opd->type & OPTYPE_SHR)) & ((1 << opd->data) - 1)) <<
        nbits;
      nbits += opd->data;
 
      if (opd->type & OPTYPE_OP)
        {
          break;
        }
 
      opd++;
    }
 
  if (opd->type & OPTYPE_SIG)
    {
      sbit = (opd->type & OPTYPE_SBIT) >> OPTYPE_SBIT_SHR;
 
      if (operand & (1 << sbit))
        {
          operand |= ~REG_C (0) << sbit;
        }
    }
 
  return operand;
 
}       /* eval_operand_val() */
 
 
/*---------------------------------------------------------------------------*/
/*!Does source operand depend on computation of dest operand?
 
      Cycle t                 Cycle t+1
  dst: irrelevant         src: immediate                  always 0
  dst: reg1 direct        src: reg2 direct                0 if reg1 != reg2
  dst: reg1 disp          src: reg2 direct                always 0
  dst: reg1 direct        src: reg2 disp                  0 if reg1 != reg2
  dst: reg1 disp          src: reg2 disp                  always 1 (store must
                                                          finish before load)
  dst: flag               src: flag                       always 1
 
  @param[in] prev  Previous instruction
  @param[in] next  Next instruction
 
  @return  Non-zero if yes.                                                  */
/*---------------------------------------------------------------------------*/
static int
check_depend (struct iqueue_entry *prev,
              struct iqueue_entry *next)
{
  /* Find destination type. */
  unsigned long          type = 0;
  int                    prev_dis;
  int                    next_dis;
  orreg_t                prev_reg_val = 0;
  struct insn_op_struct *opd;
 
  if (or32_opcodes[prev->insn_index].flags & OR32_W_FLAG
      && or32_opcodes[next->insn_index].flags & OR32_R_FLAG)
    {
      return  1;
    }
 
  opd      = op_start[prev->insn_index];
  prev_dis = 0;
 
  while (1)
    {
      if (opd->type & OPTYPE_DIS)
        {
          prev_dis = 1;
        }
 
      if (opd->type & OPTYPE_DST)
        {
          type = opd->type;
 
          if (prev_dis)
            {
              type |= OPTYPE_DIS;
            }
 
          /* Destination is always a register */
          prev_reg_val = eval_operand_val (prev->insn, opd);
          break;
        }
 
      if (opd->type & OPTYPE_LAST)
        {
          return 0;              /* Doesn't have a destination operand */
        }
 
      if (opd->type & OPTYPE_OP)
        {
          prev_dis = 0;
        }
 
      opd++;
    }
 
  /* We search all source operands - if we find confict => return 1 */
  opd      = op_start[next->insn_index];
  next_dis = 0;
 
  while (1)
    {
      if (opd->type & OPTYPE_DIS)
        {
          next_dis = 1;
        }
 
      /* This instruction sequence also depends on order of execution:
           l.lw r1, k(r1)
           l.sw k(r1), r4
         Here r1 is a destination in l.sw */
 
      /* FIXME: This situation is not handeld here when r1 == r2:
           l.sw k(r1), r4
           l.lw r3, k(r2) */
      if (!(opd->type & OPTYPE_DST) || (next_dis && (opd->type & OPTYPE_DST)))
        {
          if (opd->type & OPTYPE_REG)
            {
              if (eval_operand_val (next->insn, opd) == prev_reg_val)
                {
                  return 1;
                }
            }
        }
 
      if (opd->type & OPTYPE_LAST)
        {
          break;
        }
 
      opd++;
    }
 
  return  0;
 
}       /* check_depend() */
 
 
/*---------------------------------------------------------------------------*/
/*!Should instruction NOT be executed?
 
   Modified by CZ 26/05/01 for new mode execution.
 
   @return  Nonzero if instruction should NOT be executed                    */
/*---------------------------------------------------------------------------*/
static int
fetch ()
{
  static int break_just_hit = 0;
 
  if (NULL != breakpoints)
    {
      /* MM: Check for breakpoint.  This has to be done in fetch cycle,
         because of peripheria.
         MM1709: if we cannot access the memory entry, we could not set the
         breakpoint earlier, so just check the breakpoint list.  */
      if (has_breakpoint (peek_into_itlb (cpu_state.pc)) && !break_just_hit)
        {
          break_just_hit = 1;
          return 1;             /* Breakpoint set. */
        }
      break_just_hit = 0;
    }
 
  breakpoint                 = 0;
  cpu_state.iqueue.insn_addr = cpu_state.pc;
  cpu_state.iqueue.insn      = eval_insn (cpu_state.pc, &breakpoint);
 
  /* Fetch instruction. */
  if (!except_pending)
    {
      runtime.cpu.instructions++;
    }
 
  /* update_pc will be called after execution */
  return 0;
 
}       /* fetch() */
 
 
/*---------------------------------------------------------------------------*/
/*!This code actually updates the PC value                                   */
/*---------------------------------------------------------------------------*/
static void
update_pc ()
{
  cpu_state.delay_insn    = next_delay_insn;
  cpu_state.sprs[SPR_PPC] = cpu_state.pc;       /* Store value for later */
  cpu_state.pc            = pcnext;
  pcnext                  = cpu_state.delay_insn ? cpu_state.pc_delay :
                                                   pcnext + 4;
}       /* update_pc() */
 
 
/*---------------------------------------------------------------------------*/
/*!Perform analysis of the instruction being executed
 
   This could be static for SIMPLE_EXECUTION, but made global for general use.
 
   @param[in] current  The instruction being executed                        */
/*---------------------------------------------------------------------------*/
void
analysis (struct iqueue_entry *current)
{
  if (config.cpu.dependstats)
    {
      /* Dynamic, dependency stats. */
      adddstats (cpu_state.icomplet.insn_index, current->insn_index, 1,
                 check_depend (&cpu_state.icomplet, current));
 
      /* Dynamic, functional units stats. */
      addfstats (or32_opcodes[cpu_state.icomplet.insn_index].func_unit,
                 or32_opcodes[current->insn_index].func_unit, 1,
                 check_depend (&cpu_state.icomplet, current));
 
      /* Dynamic, single stats. */
      addsstats (current->insn_index, 1);
    }
 
  if (config.cpu.superscalar)
    {
      if ((or32_opcodes[current->insn_index].func_unit == it_branch) ||
          (or32_opcodes[current->insn_index].func_unit == it_jump))
        runtime.sim.storecycles += 0;
 
      if (or32_opcodes[current->insn_index].func_unit == it_store)
        runtime.sim.storecycles += 1;
 
      if (or32_opcodes[current->insn_index].func_unit == it_load)
        runtime.sim.loadcycles += 1;
 
      /* Pseudo multiple issue benchmark */
      if ((multissue[or32_opcodes[current->insn_index].func_unit] < 1) ||
          (check_depend (&cpu_state.icomplet, current))
          || (issued_per_cycle < 1))
        {
          int i;
          for (i = 0; i < 20; i++)
            multissue[i] = 2;
          issued_per_cycle = 2;
          runtime.cpu.supercycles++;
          if (check_depend (&cpu_state.icomplet, current))
            runtime.cpu.hazardwait++;
          multissue[it_unknown] = 2;
          multissue[it_shift] = 2;
          multissue[it_compare] = 1;
          multissue[it_branch] = 1;
          multissue[it_jump] = 1;
          multissue[it_extend] = 2;
          multissue[it_nop] = 2;
          multissue[it_move] = 2;
          multissue[it_movimm] = 2;
          multissue[it_arith] = 2;
          multissue[it_store] = 2;
          multissue[it_load] = 2;
        }
      multissue[or32_opcodes[current->insn_index].func_unit]--;
      issued_per_cycle--;
    }
 
  if (config.cpu.dependstats)
    /* Instruction waits in completition buffer until retired. */
    memcpy (&cpu_state.icomplet, current, sizeof (struct iqueue_entry));
 
  if (config.sim.history)
    {
      /* History of execution */
      hist_exec_tail = hist_exec_tail->next;
      hist_exec_tail->addr = cpu_state.icomplet.insn_addr;
    }
 
  if (config.sim.exe_log)
    dump_exe_log ();
 
}       /* analysis() */
 
/*---------------------------------------------------------------------------*/
/*!Store buffer analysis for store instructions
 
   Stores are accumulated and commited when IO is idle
 
   @param[in] cyc  Number of cycles being analysed                           */
/*---------------------------------------------------------------------------*/
static void
sbuf_store (int cyc)
{
  int delta = runtime.sim.cycles - sbuf_prev_cycles;
 
  sbuf_total_cyc   += cyc;
  sbuf_prev_cycles  = runtime.sim.cycles;
 
  /* Take stores from buffer, that occured meanwhile */
  while (sbuf_count && delta >= sbuf_buf[sbuf_tail])
    {
      delta     -= sbuf_buf[sbuf_tail];
      sbuf_tail  = (sbuf_tail + 1) % MAX_SBUF_LEN;
      sbuf_count--;
    }
 
  if (sbuf_count)
    {
      sbuf_buf[sbuf_tail] -= delta;
    }
 
  /* Store buffer is full, take one out */
  if (sbuf_count >= config.cpu.sbuf_len)
    {
      sbuf_wait_cyc          += sbuf_buf[sbuf_tail];
      runtime.sim.mem_cycles += sbuf_buf[sbuf_tail];
      sbuf_prev_cycles       += sbuf_buf[sbuf_tail];
      sbuf_tail               = (sbuf_tail + 1) % MAX_SBUF_LEN;
      sbuf_count--;
    }
 
  /* Put newest store in the buffer */
  sbuf_buf[sbuf_head] = cyc;
  sbuf_head           = (sbuf_head + 1) % MAX_SBUF_LEN;
  sbuf_count++;
 
}       /* sbuf_store() */
 
 
/*---------------------------------------------------------------------------*/
/*!Store buffer analysis for load instructions
 
   Previous stores should commit, before any load                            */
/*---------------------------------------------------------------------------*/
static void
sbuf_load ()
{
  int delta = runtime.sim.cycles - sbuf_prev_cycles;
  sbuf_prev_cycles = runtime.sim.cycles;
 
  /* Take stores from buffer, that occured meanwhile */
  while (sbuf_count && delta >= sbuf_buf[sbuf_tail])
    {
      delta     -= sbuf_buf[sbuf_tail];
      sbuf_tail  = (sbuf_tail + 1) % MAX_SBUF_LEN;
      sbuf_count--;
    }
 
  if (sbuf_count)
    {
      sbuf_buf[sbuf_tail] -= delta;
    }
 
  /* Wait for all stores to complete */
  while (sbuf_count > 0)
    {
      sbuf_wait_cyc          += sbuf_buf[sbuf_tail];
      runtime.sim.mem_cycles += sbuf_buf[sbuf_tail];
      sbuf_prev_cycles       += sbuf_buf[sbuf_tail];
      sbuf_tail               = (sbuf_tail + 1) % MAX_SBUF_LEN;
      sbuf_count--;
    }
}       /* sbuf_load() */
 
 
/*---------------------------------------------------------------------------*/
/*!Outputs dissasembled instruction                                          */
/*---------------------------------------------------------------------------*/
void
dump_exe_log ()
{
  oraddr_t      insn_addr = cpu_state.iqueue.insn_addr;
  unsigned int  i;
  unsigned int  j;
  uorreg_t      operand;
 
  if (insn_addr == 0xffffffff)
    {
      return;
    }
 
  if ((config.sim.exe_log_start <= runtime.cpu.instructions) &&
      ((config.sim.exe_log_end <= 0) ||
       (runtime.cpu.instructions <= config.sim.exe_log_end)))
    {
      struct label_entry *entry;
 
      if (config.sim.exe_log_marker &&
          !(runtime.cpu.instructions % config.sim.exe_log_marker))
        {
          fprintf (runtime.sim.fexe_log,
                   "--------------------- %8lli instruction "
                   "---------------------\n",
                   runtime.cpu.instructions);
        }
 
      switch (config.sim.exe_log_type)
        {
        case EXE_LOG_HARDWARE:
          fprintf (runtime.sim.fexe_log,
                   "\nEXECUTED(%11llu): %" PRIxADDR ":  ",
                   runtime.cpu.instructions, insn_addr);
          fprintf (runtime.sim.fexe_log, "%.2x%.2x",
                   eval_direct8 (insn_addr, 0, 0),
                   eval_direct8 (insn_addr + 1, 0, 0));
          fprintf (runtime.sim.fexe_log, "%.2x%.2x",
                   eval_direct8 (insn_addr + 2, 0, 0),
                   eval_direct8 (insn_addr + 3, 0, 0));
 
          for (i = 0; i < MAX_GPRS; i++)
            {
              if (i % 4 == 0)
                {
                  fprintf (runtime.sim.fexe_log, "\n");
                }
 
              fprintf (runtime.sim.fexe_log, "GPR%2u: %" PRIxREG "  ", i,
                       cpu_state.reg[i]);
            }
 
          fprintf (runtime.sim.fexe_log, "\n");
          fprintf (runtime.sim.fexe_log, "SR   : %.8" PRIx32 "  ",
                   cpu_state.sprs[SPR_SR]);
          fprintf (runtime.sim.fexe_log, "EPCR0: %" PRIxADDR "  ",
                   cpu_state.sprs[SPR_EPCR_BASE]);
          fprintf (runtime.sim.fexe_log, "EEAR0: %" PRIxADDR "  ",
                   cpu_state.sprs[SPR_EEAR_BASE]);
          fprintf (runtime.sim.fexe_log, "ESR0 : %.8" PRIx32 "\n",
                   cpu_state.sprs[SPR_ESR_BASE]);
          break;
 
        case EXE_LOG_SIMPLE:
        case EXE_LOG_SOFTWARE:
          disassemble_index (cpu_state.iqueue.insn,
                             cpu_state.iqueue.insn_index);
 
          entry = get_label (insn_addr);
          if (entry)
            {
              fprintf (runtime.sim.fexe_log, "%s:\n", entry->name);
            }
 
          if (config.sim.exe_log_type == EXE_LOG_SOFTWARE)
            {
              struct insn_op_struct *opd =
                op_start[cpu_state.iqueue.insn_index];
 
              j = 0;
              while (1)
                {
                  operand = eval_operand_val (cpu_state.iqueue.insn, opd);
                  while (!(opd->type & OPTYPE_OP))
                    {
                      opd++;
                    }
                  if (opd->type & OPTYPE_DIS)
                    {
                      fprintf (runtime.sim.fexe_log,
                               "EA =%" PRIxADDR " PA =%" PRIxADDR " ",
                               cpu_state.insn_ea,
                               peek_into_dtlb (cpu_state.insn_ea, 0, 0));
                      opd++;    /* Skip of register operand */
                      j++;
                    }
                  else if ((opd->type & OPTYPE_REG) && operand)
                    {
                      fprintf (runtime.sim.fexe_log, "r%-2i=%" PRIxREG " ",
                               (int) operand, evalsim_reg (operand));
                    }
                  else
                    {
                      fprintf (runtime.sim.fexe_log, "             ");
                    }
                  j++;
                  if (opd->type & OPTYPE_LAST)
                    {
                      break;
                    }
                  opd++;
                }
              if (or32_opcodes[cpu_state.iqueue.insn_index].flags & OR32_R_FLAG)
                {
                  fprintf (runtime.sim.fexe_log, "SR =%08x ",
                           cpu_state.sprs[SPR_SR]);
                  j++;
                }
              while (j < 3)
                {
                  fprintf (runtime.sim.fexe_log, "             ");
                  j++;
                }
            }
          fprintf (runtime.sim.fexe_log, "%" PRIxADDR " ", insn_addr);
          fprintf (runtime.sim.fexe_log, "%s\n", disassembled);
        }
    }
}       /* dump_exe_log() */
 
 
/*---------------------------------------------------------------------------*/
/*!Dump registers
 
   Supports the CLI 'r' and 't' commands                                     */
/*---------------------------------------------------------------------------*/
void
dumpreg ()
{
  int       i;
  oraddr_t  physical_pc;
 
  if ((physical_pc = peek_into_itlb (cpu_state.iqueue.insn_addr)))
    {
      disassemble_memory (physical_pc, physical_pc + 4, 0);
    }
  else
    {
      PRINTF ("INTERNAL SIMULATOR ERROR:\n");
      PRINTF ("no translation for currently executed instruction\n");
    }
 
  // generate_time_pretty (temp, runtime.sim.cycles * config.sim.clkcycle_ps);
  PRINTF (" (executed) [cycle %lld, #%lld]\n", runtime.sim.cycles,
          runtime.cpu.instructions);
  if (config.cpu.superscalar)
    {
      PRINTF ("Superscalar CYCLES: %u", runtime.cpu.supercycles);
    }
  if (config.cpu.hazards)
    {
      PRINTF ("  HAZARDWAIT: %u\n", runtime.cpu.hazardwait);
    }
  else if (config.cpu.superscalar)
    {
      PRINTF ("\n");
    }
 
  if ((physical_pc = peek_into_itlb (cpu_state.pc)))
    {
      disassemble_memory (physical_pc, physical_pc + 4, 0);
    }
  else
    {
      PRINTF ("%" PRIxADDR ": : xxxxxxxx  ITLB miss follows", cpu_state.pc);
    }
 
  PRINTF (" (next insn) %s", (cpu_state.delay_insn ? "(delay insn)" : ""));
 
  for (i = 0; i < MAX_GPRS; i++)
    {
      if (i % 4 == 0)
        {
          PRINTF ("\n");
        }
 
      PRINTF ("GPR%.2u: %" PRIxREG "  ", i, evalsim_reg (i));
    }
 
  PRINTF ("flag: %u\n", cpu_state.sprs[SPR_SR] & SPR_SR_F ? 1 : 0);
 
}       /* dumpreg() */
 
 
/*---------------------------------------------------------------------------*/
/*!Wrapper around real decode_execute function
 
   Some statistics here only
 
   @param[in] current  Instruction being executed                            */
/*---------------------------------------------------------------------------*/
static void
decode_execute_wrapper (struct iqueue_entry *current)
{
  breakpoint = 0;
 
#ifndef HAVE_EXECUTION
#error HAVE_EXECUTION has to be defined in order to execute programs.
#endif
 
  /* FIXME: Most of this file is not needed with DYNAMIC_EXECUTION */
#if !(DYNAMIC_EXECUTION)
  decode_execute (current);
#endif
 
#if SET_OV_FLAG
  /* Check for range exception */
  if ((cpu_state.sprs[SPR_SR] & SPR_SR_OVE) &&
      (cpu_state.sprs[SPR_SR] & SPR_SR_OV))
    {
      except_handle (EXCEPT_RANGE, cpu_state.sprs[SPR_EEAR_BASE]);
    }
#endif
 
  if (breakpoint)
    {
      except_handle (EXCEPT_TRAP, cpu_state.sprs[SPR_EEAR_BASE]);
    }
}       /* decode_execute_wrapper() */
 
/*---------------------------------------------------------------------------*/
/*!Reset the CPU                                                             */
/*---------------------------------------------------------------------------*/
void
cpu_reset ()
{
  int               i;
  struct hist_exec *hist_exec_head = NULL;
  struct hist_exec *hist_exec_new;
 
  runtime.sim.cycles       = 0;
  runtime.sim.loadcycles   = 0;
  runtime.sim.storecycles  = 0;
  runtime.cpu.instructions = 0;
  runtime.cpu.supercycles  = 0;
  runtime.cpu.hazardwait   = 0;
 
  for (i = 0; i < MAX_GPRS; i++)
    {
      setsim_reg (i, 0);
    }
 
  memset (&cpu_state.iqueue,   0, sizeof (cpu_state.iqueue));
  memset (&cpu_state.icomplet, 0, sizeof (cpu_state.icomplet));
 
  sbuf_head        = 0;
  sbuf_tail        = 0;
  sbuf_count       = 0;
  sbuf_prev_cycles = 0;
 
  /* Initialise execution history circular buffer */
  for (i = 0; i < HISTEXEC_LEN; i++)
    {
      hist_exec_new = malloc (sizeof (struct hist_exec));
 
      if (!hist_exec_new)
        {
          fprintf (stderr, "Out-of-memory\n");
          exit (1);
        }
 
      if (!hist_exec_head)
        {
          hist_exec_head = hist_exec_new;
        }
      else
        {
          hist_exec_tail->next = hist_exec_new;
        }
 
      hist_exec_new->prev = hist_exec_tail;
      hist_exec_tail = hist_exec_new;
    }
 
  /* Make hist_exec_tail->next point to hist_exec_head */
  hist_exec_tail->next = hist_exec_head;
  hist_exec_head->prev = hist_exec_tail;
 
  /* MM1409: All progs should start at reset vector entry! This sorted out by
     setting the cpu_state.pc field below. Not clear this is very good code! */
  pcnext = 0x0;
 
  if (config.sim.verbose)
    {
      PRINTF ("Starting at 0x%" PRIxADDR "\n", pcnext);
    }
 
  cpu_state.pc  = pcnext;
  pcnext       += 4;
 
  /* MM1409: All programs should set their stack pointer!  */
#if !(DYNAMIC_EXECUTION)
  except_handle (EXCEPT_RESET, 0);
  update_pc ();
#endif
 
  except_pending = 0;
  cpu_state.pc   = EXCEPT_RESET;
 
}       /* cpu_reset() */
 
 
/*---------------------------------------------------------------------------*/
/*!Simulates one CPU clock cycle
 
  @return  non-zero if a breakpoint is hit, zero otherwise.                  */
/*---------------------------------------------------------------------------*/
int
cpu_clock ()
{
  except_pending  = 0;
  next_delay_insn = 0;
 
  if (fetch ())
    {
      PRINTF ("Breakpoint hit.\n");
      return  1;
    }
 
  if (except_pending)
    {
      update_pc ();
      except_pending = 0;
      return  0;
    }
 
  if (breakpoint)
    {
      except_handle (EXCEPT_TRAP, cpu_state.sprs[SPR_EEAR_BASE]);
      update_pc ();
      except_pending = 0;
      return  0;
    }
 
  decode_execute_wrapper (&cpu_state.iqueue);
  update_pc ();
  return  0;
 
}       /* cpu_clock() */
 
 
/*---------------------------------------------------------------------------*/
/*!If decoding cannot be found, call this function                           */
/*---------------------------------------------------------------------------*/
#if SIMPLE_EXECUTION
void
l_invalid (struct iqueue_entry *current)
{
#else
void
l_invalid ()
{
#endif
  except_handle (EXCEPT_ILLEGAL, cpu_state.iqueue.insn_addr);
 
}       /* l_invalid() */
 
 
/*---------------------------------------------------------------------------*/
/*!The main execution loop                                                   */
/*---------------------------------------------------------------------------*/
void
exec_main ()
{
  long long time_start;
 
  while (1)
    {
      time_start = runtime.sim.cycles;
      if (config.debug.enabled)
        {
          while (runtime.cpu.stalled)
            {
              if (config.debug.gdb_enabled)
                {
                  block_jtag ();
                  handle_server_socket (FALSE);
                }
              else
                {
                  fprintf (stderr,
                           "WARNING: CPU stalled and gdb connection not enabled.\n");
                  /* Dump the user into interactive mode.  From there he can decide what
                   * to do. */
                  handle_sim_command ();
                  sim_done ();
                }
              if (runtime.sim.iprompt)
                handle_sim_command ();
            }
        }
 
      /* Each cycle has counter of mem_cycles; this value is joined with cycles
         at the end of the cycle; no sim originated memory accesses should be
         performed inbetween. */
      runtime.sim.mem_cycles = 0;
 
      if (!config.pm.enabled ||
          !(config.pm.enabled &
            (cpu_state.sprs[SPR_PMR] & (SPR_PMR_DME | SPR_PMR_SME))))
        {
          if (cpu_clock ())
            {
              /* A breakpoint has been hit, drop to interactive mode */
              handle_sim_command ();
            }
        }
 
      if (config.vapi.enabled && runtime.vapi.enabled)
        {
          vapi_check ();
        }
 
      if (config.debug.gdb_enabled)
        {
          handle_server_socket (FALSE); /* block & check_stdin = false */
        }
 
      if (config.debug.enabled)
        {
          if (cpu_state.sprs[SPR_DMR1] & SPR_DMR1_ST)
            {
              set_stall_state (1);
            }
        }
 
      runtime.sim.cycles        += runtime.sim.mem_cycles;
      scheduler.job_queue->time -= runtime.sim.cycles - time_start;
 
      if (scheduler.job_queue->time <= 0)
        {
          do_scheduler ();
        }
    }
}       /* exec_main() */
 
#if COMPLEX_EXECUTION
 
/* Include generated/built in decode_execute function */
#include "execgen.c"
 
#elif SIMPLE_EXECUTION
 
 
#define INSTRUCTION(name) void name (struct iqueue_entry *current)
 
/*---------------------------------------------------------------------------*/
/*!Evaluates source operand
 
   Implementation specific.
 
   @param[in] op_no       The operand
   @param[in] insn_index  Address of the instruction
   @param[in] insn        The instruction
 
   @return  The value of the operand                                         */
/*---------------------------------------------------------------------------*/
static uorreg_t
eval_operand (int            op_no,
              unsigned long  insn_index,
              uint32_t       insn)
{
  struct insn_op_struct *opd = op_start[insn_index];
  uorreg_t               ret;
 
  while (op_no)
    {
      if (opd->type & OPTYPE_LAST)
        {
          fprintf (stderr,
                   "Instruction requested more operands than it has\n");
          exit (1);
        }
 
      if ((opd->type & OPTYPE_OP) && !(opd->type & OPTYPE_DIS))
        {
          op_no--;
        }
 
      opd++;
    }
 
  if (opd->type & OPTYPE_DIS)
    {
      ret = eval_operand_val (insn, opd);
 
      while (!(opd->type & OPTYPE_OP))
        {
          opd++;
        }
 
      opd++;
      ret               += evalsim_reg (eval_operand_val (insn, opd));
      cpu_state.insn_ea  = ret;
 
      return  ret;
    }
 
  if (opd->type & OPTYPE_REG)
    {
      return  evalsim_reg (eval_operand_val (insn, opd));
    }
 
  return  eval_operand_val (insn, opd);
 
}       /* eval_operand() */
 
 
/*---------------------------------------------------------------------------*/
/*!Set destination operand (register direct) with value.
 
   Implementation specific.
 
   @param[in] op_no       The operand
   @param[in] value       The value to set
   @param[in] insn_index  Address of the instruction
   @param[in] insn        The instruction                                    */
/*---------------------------------------------------------------------------*/
static void
set_operand (int            op_no,
             orreg_t        value,
             unsigned long  insn_index,
             uint32_t       insn)
{
  struct insn_op_struct *opd = op_start[insn_index];
 
  while (op_no)
    {
      if (opd->type & OPTYPE_LAST)
        {
          fprintf (stderr,
                   "Instruction requested more operands than it has\n");
          exit (1);
        }
 
      if ((opd->type & OPTYPE_OP) && !(opd->type & OPTYPE_DIS))
        {
          op_no--;
        }
 
      opd++;
    }
 
  if (!(opd->type & OPTYPE_REG))
    {
      fprintf (stderr, "Trying to set a non-register operand\n");
      exit (1);
    }
 
  setsim_reg (eval_operand_val (insn, opd), value);
 
}       /* set_operand() */
 
 
/*---------------------------------------------------------------------------*/
/*!Simple and rather slow decoding function
 
   Based on built automata.
 
   @param[in] current  The current instruction to execute                    */
/*---------------------------------------------------------------------------*/
static void
decode_execute (struct iqueue_entry *current)
{
  int insn_index;
 
  current->insn_index = insn_index = insn_decode (current->insn);
 
  if (insn_index < 0)
    {
      l_invalid (current);
    }
  else
    {
      or32_opcodes[insn_index].exec (current);
    }
 
  if (do_stats)
    analysis (&cpu_state.iqueue);
}
 
#include "insnset.c"
 
#elif defined(DYNAMIC_EXECUTION)
 
#else
# error "Must define SIMPLE_EXECUTION, COMPLEX_EXECUTION or DYNAMIC_EXECUTION"
#endif

Line No.	Rev	Author	Line
1	2	cvs	`/* execute.c -- OR1K architecture dependent simulation`
2	1744	jeremybenn
3	2	cvs	`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
4	1346	nogj	Copyright (C) 2005 Gy�rgy `nog' Jeney, nog@sdf.lonestar.org
5	1744	jeremybenn	`Copyright (C) 2008 Embecosm Limited`
6
7			`Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>`
8
9			`This file is part of OpenRISC 1000 Architectural Simulator.`
10
11			`This program is free software; you can redistribute it and/or modify it`
12			`under the terms of the GNU General Public License as published by the Free`
13			`Software Foundation; either version 3 of the License, or (at your option)`
14			`any later version.`
15
16			`This program is distributed in the hope that it will be useful, but WITHOUT`
17			`ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or`
18			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for`
19			`more details.`
20
21			`You should have received a copy of the GNU General Public License along`
22			`with this program. If not, see <http://www.gnu.org/licenses/>. */`
23	2	cvs
24	1748	jeremybenn	`/* This program is commented throughout in a fashion suitable for processing`
25			`with Doxygen. */`
26	2	cvs
27	1748	jeremybenn
28	706	markom	`/* Most of the OR1K simulation is done in here.`
29	2	cvs
30	706	markom	`When SIMPLE_EXECUTION is defined below a file insnset.c is included!`
31			`*/`
32
33	1748	jeremybenn	`/* Autoconf and/or portability configuration */`
34	123	markom	`#include "config.h"`
35	1748	jeremybenn	`#include "port.h"`
36	1350	nogj
37	1748	jeremybenn	`/* System includes */`
38			`#include <stdlib.h>`
39	1350	nogj
40	1748	jeremybenn	`/* Package includes */`
41			`#include "execute.h"`
42			`#include "toplevel-support.h"`
43			`#include "except.h"`
44	261	markom	`#include "labels.h"`
45	1748	jeremybenn	`#include "gdbcomm.h"`
46			`#include "sched.h"`
47			`#include "stats.h"`
48	1308	phoenix	`#include "opcode/or32.h"`
49	1748	jeremybenn	`#include "dmmu.h"`
50	1308	phoenix	`#include "immu.h"`
51	1748	jeremybenn	`#include "sim-cmd.h"`
52	1690	nogj	`#include "vapi.h"`
53	1748	jeremybenn	`#include "debug-unit.h"`
54			`#include "branch-predict.h"`
55			`#include "support/simprintf.h"`
56			`#include "sprs.h"`
57	2	cvs
58
59	1748	jeremybenn	`/* Sets a new SPR_SR_OV value, based on next register value */`
60			`#if SET_OV_FLAG`
61			`#define SET_OV_FLAG_FN(value) \`
62			`if((value) & 0x80000000) \`
63			`cpu_state.sprs[SPR_SR] \|= SPR_SR_OV; \`
64			`else \`
65			`cpu_state.sprs[SPR_SR] &= ~SPR_SR_OV`
66			`#else`
67			`#define SET_OV_FLAG_FN(value)`
68			`#endif`
69	2	cvs
70	1748	jeremybenn	`/* Macros for simple execution */`
71			`#if SIMPLE_EXECUTION`
72			`#define SET_PARAM0(val) set_operand(0, val, current->insn_index, current->insn)`
73	2	cvs
74	1748	jeremybenn	`#define PARAM0 eval_operand(0, current->insn_index, current->insn)`
75			`#define PARAM1 eval_operand(1, current->insn_index, current->insn)`
76			`#define PARAM2 eval_operand(2, current->insn_index, current->insn)`
77			`#endif`
78	626	markom
79	1748	jeremybenn	`/! Current cpu state. Globally available. /`
80			`struct cpu_state cpu_state;`
81	626	markom
82	1748	jeremybenn	`/! Temporary program counter. Globally available /`
83			`oraddr_t pcnext;`
84	626	markom
85	1748	jeremybenn	`/! Num cycles waiting for stores to complete. Globally available /`
86			`int sbuf_wait_cyc = 0;`
87	714	markom
88	1748	jeremybenn	`/! Number of total store cycles. Globally available /`
89			`int sbuf_total_cyc = 0;`
90
91			`/! Whether we are doing statistical analysis. Globally available /`
92			`int do_stats = 0;`
93
94			`/! History of execution. Globally available /`
95			`struct hist_exec *hist_exec_tail = NULL;`
96
97			`/* Benchmark multi issue execution. This file only */`
98			`static int multissue[20];`
99			`static int issued_per_cycle = 4;`
100
101			`/* Store buffer analysis - stores are accumulated and commited when IO is`
102			`idle. This file only */`
103			`static int sbuf_head = 0;`
104			`static int sbuf_tail = 0;`
105			`static int sbuf_count = 0;`
106			`static int sbuf_buf[MAX_SBUF_LEN] = { 0 };`
107
108			`static int sbuf_prev_cycles = 0;`
109
110	138	markom	`/* Local data needed for execution. */`
111			`static int next_delay_insn;`
112			`static int breakpoint;`
113
114	1748	jeremybenn	`/* Forward declaration of static functions */`
115			`static void decode_execute (struct iqueue_entry *current);`
116	1346	nogj
117	1748	jeremybenn	`/---------------------------------------------------------------------------/`
118			`/*!Get an actual value of a specific register`
119	1352	nogj
120	1748	jeremybenn	`Implementation specific. Abort if we are given a duff register. Only used`
121			`externally to support simprintf().`
122	2	cvs
123	1748	jeremybenn	`@param[in] regno The register of interest`
124
125			`@return The value of the register */`
126			`/---------------------------------------------------------------------------/`
127			`uorreg_t`
128			`evalsim_reg (unsigned int regno)`
129	2	cvs	`{`
130	1748	jeremybenn	`if (regno < MAX_GPRS)`
131			`{`
132			`#if RAW_RANGE_STATS`
133			`int delta = (runtime.sim.cycles - raw_stats.reg[regno]);`
134	560	markom
135	1748	jeremybenn	`if ((unsigned long) delta < (unsigned long) MAX_RAW_RANGE)`
136			`{`
137			`raw_stats.range[delta]++;`
138			`}`
139			`#endif /* RAW_RANGE */`
140	560	markom
141	1748	jeremybenn	`return cpu_state.reg[regno];`
142			`}`
143			`else`
144			`{`
145			`PRINTF ("\nABORT: read out of registers\n");`
146			`sim_done ();`
147			`return 0;`
148			`}`
149			`} /* evalsim_reg() */`
150	560	markom
151	2	cvs
152	1748	jeremybenn	`/---------------------------------------------------------------------------/`
153			`/*!Set a specific register with value`
154
155			`Implementation specific. Abort if we are given a duff register.`
156
157			`@param[in] regno The register of interest`
158			`@param[in] value The value to be set */`
159			`/---------------------------------------------------------------------------/`
160			`void`
161			`setsim_reg (unsigned int regno,`
162			`uorreg_t value)`
163	2	cvs	`{`
164	1748	jeremybenn	`if (regno == 0) /* gpr0 is always zero */`
165			`{`
166			`value = 0;`
167			`}`
168	560	markom
169	1748	jeremybenn	`if (regno < MAX_GPRS)`
170			`{`
171			`cpu_state.reg[regno] = value;`
172			`}`
173			`else`
174			`{`
175			`PRINTF ("\nABORT: write out of registers\n");`
176			`sim_done ();`
177			`}`
178
179	713	markom	`#if RAW_RANGE_STATS`
180	1748	jeremybenn	`raw_stats.reg[regno] = runtime.sim.cycles;`
181	713	markom	`#endif /* RAW_RANGE */`
182	2	cvs
183	1748	jeremybenn	`} /* setsim_reg() */`
184	1346	nogj
185	1748	jeremybenn
186			`/---------------------------------------------------------------------------/`
187			`/*!Evaluates source operand operand`
188
189			`Implementation specific. Declared global, although this is only actually`
190			`required for DYNAMIC_EXECUTION,`
191
192			`@param[in] insn The instruction`
193			`@param[in] opd The operand`
194
195			`@return The value of the source operand */`
196			`/---------------------------------------------------------------------------/`
197			`uorreg_t`
198			`eval_operand_val (uint32_t insn,`
199			`struct insn_op_struct *opd)`
200	1346	nogj	`{`
201	1748	jeremybenn	`unsigned long operand = 0;`
202			`unsigned long sbit;`
203			`unsigned int nbits = 0;`
204	1346	nogj
205	1748	jeremybenn	`while (1)`
206			`{`
207			`operand \|=`
208			`((insn >> (opd->type & OPTYPE_SHR)) & ((1 << opd->data) - 1)) <<`
209			`nbits;`
210			`nbits += opd->data;`
211	1346	nogj
212	1748	jeremybenn	`if (opd->type & OPTYPE_OP)`
213			`{`
214			`break;`
215			`}`
216	1346	nogj
217	1748	jeremybenn	`opd++;`
218			`}`
219	1346	nogj
220	1748	jeremybenn	`if (opd->type & OPTYPE_SIG)`
221			`{`
222			`sbit = (opd->type & OPTYPE_SBIT) >> OPTYPE_SBIT_SHR;`
223
224			`if (operand & (1 << sbit))`
225			`{`
226			`operand \|= ~REG_C (0) << sbit;`
227			`}`
228			`}`
229
230	1346	nogj	`return operand;`
231
232	1748	jeremybenn	`} /* eval_operand_val() */`
233	2	cvs
234
235	1748	jeremybenn	`/---------------------------------------------------------------------------/`
236			`/*!Does source operand depend on computation of dest operand?`
237
238			`Cycle t Cycle t+1`
239			`dst: irrelevant src: immediate always 0`
240			`dst: reg1 direct src: reg2 direct 0 if reg1 != reg2`
241			`dst: reg1 disp src: reg2 direct always 0`
242			`dst: reg1 direct src: reg2 disp 0 if reg1 != reg2`
243			`dst: reg1 disp src: reg2 disp always 1 (store must`
244			`finish before load)`
245			`dst: flag src: flag always 1`
246
247			`@param[in] prev Previous instruction`
248			`@param[in] next Next instruction`
249
250			`@return Non-zero if yes. */`
251			`/---------------------------------------------------------------------------/`
252			`static int`
253			`check_depend (struct iqueue_entry *prev,`
254			`struct iqueue_entry *next)`
255	2	cvs	`{`
256	138	markom	`/* Find destination type. */`
257	1748	jeremybenn	`unsigned long type = 0;`
258			`int prev_dis;`
259			`int next_dis;`
260			`orreg_t prev_reg_val = 0;`
261	1346	nogj	`struct insn_op_struct *opd;`
262
263	138	markom	`if (or32_opcodes[prev->insn_index].flags & OR32_W_FLAG`
264			`&& or32_opcodes[next->insn_index].flags & OR32_R_FLAG)`
265	1748	jeremybenn	`{`
266			`return 1;`
267			`}`
268	2	cvs
269	1748	jeremybenn	`opd = op_start[prev->insn_index];`
270	1346	nogj	`prev_dis = 0;`
271	560	markom
272	1748	jeremybenn	`while (1)`
273			`{`
274			`if (opd->type & OPTYPE_DIS)`
275			`{`
276			`prev_dis = 1;`
277			`}`
278	1346	nogj
279	1748	jeremybenn	`if (opd->type & OPTYPE_DST)`
280			`{`
281			`type = opd->type;`
282
283			`if (prev_dis)`
284			`{`
285			`type \|= OPTYPE_DIS;`
286			`}`
287
288			`/* Destination is always a register */`
289			`prev_reg_val = eval_operand_val (prev->insn, opd);`
290			`break;`
291			`}`
292
293			`if (opd->type & OPTYPE_LAST)`
294			`{`
295			`return 0; /* Doesn't have a destination operand */`
296			`}`
297
298			`if (opd->type & OPTYPE_OP)`
299			`{`
300			`prev_dis = 0;`
301			`}`
302
303			`opd++;`
304	1346	nogj	`}`
305
306	138	markom	`/* We search all source operands - if we find confict => return 1 */`
307	1748	jeremybenn	`opd = op_start[next->insn_index];`
308	1346	nogj	`next_dis = 0;`
309
310	1748	jeremybenn	`while (1)`
311			`{`
312			`if (opd->type & OPTYPE_DIS)`
313			`{`
314			`next_dis = 1;`
315			`}`
316
317			`/* This instruction sequence also depends on order of execution:`
318			`l.lw r1, k(r1)`
319			`l.sw k(r1), r4`
320			`Here r1 is a destination in l.sw */`
321
322			`/* FIXME: This situation is not handeld here when r1 == r2:`
323			`l.sw k(r1), r4`
324			`l.lw r3, k(r2) */`
325			`if (!(opd->type & OPTYPE_DST) \|\| (next_dis && (opd->type & OPTYPE_DST)))`
326			`{`
327			`if (opd->type & OPTYPE_REG)`
328			`{`
329			`if (eval_operand_val (next->insn, opd) == prev_reg_val)`
330			`{`
331			`return 1;`
332			`}`
333			`}`
334			`}`
335
336			`if (opd->type & OPTYPE_LAST)`
337			`{`
338			`break;`
339			`}`
340
341			`opd++;`
342	1346	nogj	`}`
343
344	1748	jeremybenn	`return 0;`
345	2	cvs
346	1748	jeremybenn	`} /* check_depend() */`
347	2	cvs
348	605	markom
349	1748	jeremybenn	`/---------------------------------------------------------------------------/`
350			`/*!Should instruction NOT be executed?`
351
352			`Modified by CZ 26/05/01 for new mode execution.`
353
354			`@return Nonzero if instruction should NOT be executed */`
355			`/---------------------------------------------------------------------------/`
356			`static int`
357			`fetch ()`
358	557	markom	`{`
359	1386	nogj	`static int break_just_hit = 0;`
360	574	markom
361	1748	jeremybenn	`if (NULL != breakpoints)`
362			`{`
363			`/* MM: Check for breakpoint. This has to be done in fetch cycle,`
364			`because of peripheria.`
365			`MM1709: if we cannot access the memory entry, we could not set the`
366			`breakpoint earlier, so just check the breakpoint list. */`
367			`if (has_breakpoint (peek_into_itlb (cpu_state.pc)) && !break_just_hit)`
368			`{`
369			`break_just_hit = 1;`
370			`return 1; /* Breakpoint set. */`
371			`}`
372			`break_just_hit = 0;`
373	557	markom	`}`
374	1244	hpanther
375	1748	jeremybenn	`breakpoint = 0;`
376	1482	nogj	`cpu_state.iqueue.insn_addr = cpu_state.pc;`
377	1748	jeremybenn	`cpu_state.iqueue.insn = eval_insn (cpu_state.pc, &breakpoint);`
378	1482	nogj
379	378	markom	`/* Fetch instruction. */`
380	1386	nogj	`if (!except_pending)`
381	1748	jeremybenn	`{`
382			`runtime.cpu.instructions++;`
383			`}`
384	1386	nogj
385	378	markom	`/* update_pc will be called after execution */`
386			`return 0;`
387	2	cvs
388	1748	jeremybenn	`} /* fetch() */`
389
390
391			`/---------------------------------------------------------------------------/`
392			`/!This code actually updates the PC value /`
393			`/---------------------------------------------------------------------------/`
394			`static void`
395			`update_pc ()`
396	142	chris	`{`
397	1748	jeremybenn	`cpu_state.delay_insn = next_delay_insn;`
398			`cpu_state.sprs[SPR_PPC] = cpu_state.pc; /* Store value for later */`
399			`cpu_state.pc = pcnext;`
400			`pcnext = cpu_state.delay_insn ? cpu_state.pc_delay :`
401			`pcnext + 4;`
402			`} /* update_pc() */`
403	2	cvs
404	1748	jeremybenn
405			`/---------------------------------------------------------------------------/`
406			`/*!Perform analysis of the instruction being executed`
407
408			`This could be static for SIMPLE_EXECUTION, but made global for general use.`
409
410			`@param[in] current The instruction being executed */`
411			`/---------------------------------------------------------------------------/`
412			`void`
413			`analysis (struct iqueue_entry *current)`
414	2	cvs	`{`
415	1748	jeremybenn	`if (config.cpu.dependstats)`
416			`{`
417			`/* Dynamic, dependency stats. */`
418			`adddstats (cpu_state.icomplet.insn_index, current->insn_index, 1,`
419			`check_depend (&cpu_state.icomplet, current));`
420	713	markom
421	1748	jeremybenn	`/* Dynamic, functional units stats. */`
422			`addfstats (or32_opcodes[cpu_state.icomplet.insn_index].func_unit,`
423			`or32_opcodes[current->insn_index].func_unit, 1,`
424			`check_depend (&cpu_state.icomplet, current));`
425	713	markom
426	1748	jeremybenn	`/* Dynamic, single stats. */`
427			`addsstats (current->insn_index, 1);`
428			`}`
429	713	markom
430	1748	jeremybenn	`if (config.cpu.superscalar)`
431			`{`
432			`if ((or32_opcodes[current->insn_index].func_unit == it_branch) \|\|`
433			`(or32_opcodes[current->insn_index].func_unit == it_jump))`
434			`runtime.sim.storecycles += 0;`
435
436			`if (or32_opcodes[current->insn_index].func_unit == it_store)`
437			`runtime.sim.storecycles += 1;`
438
439			`if (or32_opcodes[current->insn_index].func_unit == it_load)`
440			`runtime.sim.loadcycles += 1;`
441
442			`/* Pseudo multiple issue benchmark */`
443			`if ((multissue[or32_opcodes[current->insn_index].func_unit] < 1) \|\|`
444			`(check_depend (&cpu_state.icomplet, current))`
445			`\|\| (issued_per_cycle < 1))`
446			`{`
447			`int i;`
448			`for (i = 0; i < 20; i++)`
449			`multissue[i] = 2;`
450			`issued_per_cycle = 2;`
451			`runtime.cpu.supercycles++;`
452			`if (check_depend (&cpu_state.icomplet, current))`
453			`runtime.cpu.hazardwait++;`
454			`multissue[it_unknown] = 2;`
455			`multissue[it_shift] = 2;`
456			`multissue[it_compare] = 1;`
457			`multissue[it_branch] = 1;`
458			`multissue[it_jump] = 1;`
459			`multissue[it_extend] = 2;`
460			`multissue[it_nop] = 2;`
461			`multissue[it_move] = 2;`
462			`multissue[it_movimm] = 2;`
463			`multissue[it_arith] = 2;`
464			`multissue[it_store] = 2;`
465			`multissue[it_load] = 2;`
466			`}`
467			`multissue[or32_opcodes[current->insn_index].func_unit]--;`
468			`issued_per_cycle--;`
469	713	markom	`}`
470	1748	jeremybenn
471	394	markom	`if (config.cpu.dependstats)`
472	123	markom	`/* Instruction waits in completition buffer until retired. */`
473	1432	nogj	`memcpy (&cpu_state.icomplet, current, sizeof (struct iqueue_entry));`
474	138	markom
475	1748	jeremybenn	`if (config.sim.history)`
476			`{`
477			`/* History of execution */`
478			`hist_exec_tail = hist_exec_tail->next;`
479			`hist_exec_tail->addr = cpu_state.icomplet.insn_addr;`
480			`}`
481	714	markom
482	1748	jeremybenn	`if (config.sim.exe_log)`
483			`dump_exe_log ();`
484	2	cvs
485	1748	jeremybenn	`} /* analysis() */`
486
487			`/---------------------------------------------------------------------------/`
488			`/*!Store buffer analysis for store instructions`
489
490			`Stores are accumulated and commited when IO is idle`
491
492			`@param[in] cyc Number of cycles being analysed */`
493			`/---------------------------------------------------------------------------/`
494			`static void`
495			`sbuf_store (int cyc)`
496			`{`
497	884	markom	`int delta = runtime.sim.cycles - sbuf_prev_cycles;`
498	1748	jeremybenn
499			`sbuf_total_cyc += cyc;`
500			`sbuf_prev_cycles = runtime.sim.cycles;`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [or1ksim/] [cpu/] [or32/] [execute.c] - Blame information for rev 1748