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

Subversion Repositories or1k

[/] [or1k/] [tags/] [nog_patch_42/] [or1ksim/] [cpu/] [common/] [abstract.c] - Blame information for rev 458

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


/* abstract.c -- Abstract entities
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
 
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 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
 
/* Abstract memory and routines that go with this. I need to
add all sorts of other abstract entities. Currently we have
only memory. */
 
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
#include "config.h"
#include "sim-config.h"
 
#include "parse.h"
#include "abstract.h"
#include "labels.h"
#include "arch.h"
#include "trace.h"
#include "execute.h"
#include "sprs.h"
#include "stats.h"
#include "except.h"
#include "debug_unit.h"
#include "opcode/or32.h"
 
extern unsigned long reg[];
extern char *disassembled;
 
/* This is an abstract+physical memory array rather than only physical
   memory array */
static struct mem_entry *simmem;
 
/* Pointer to memory area descriptions that are assigned to individual
   peripheral devices. */
struct dev_memarea *dev_list;
 
/* Temporary variable to increase speed.  */
struct dev_memarea *cur_area;
 
/* It returns physical address. */
inline unsigned long translate_vrt_to_phy_add(unsigned long virtaddr, int write_access)
{
  if (config.ic.tagtype == CT_NONE)
    return virtaddr;
  else
    if (config.ic.tagtype == CT_VIRTUAL) {
      return immu_translate(virtaddr, write_access);
    }
    else if (config.dc.tagtype == CT_PHYSICAL) {
      unsigned long phyaddr = immu_translate(virtaddr, write_access);
      return phyaddr;
    }
    else {
      printf("INTERNAL ERROR: Unknown insn cache type.\n");
      cont_run = 0;
    }
 
  return -1;
}
 
/* Calls IMMU translation routines before simulating insn
cache for virtually indexed insn cache or after simulating insn cache
for physically indexed insn cache. It returns physical address. */
 
unsigned long simulate_ic_mmu_fetch(unsigned long virtaddr)
{
 
  unsigned long phyaddr;
 
  if ((phyaddr = translate_vrt_to_phy_add(virtaddr, 0)) != -1) {
    ic_simulate_fetch(phyaddr);
    return phyaddr;
  }
  else {
    printf("INTERNAL ERROR: Unknown insn cache type.\n");
    cont_run = 0;
  }
  return -1;
}
 
/* Calls DMMU translation routines (load cycles) before simulating data
   cache for virtually indexed data cache or after simulating data cache
   for physically indexed data cache. It returns physical address. */
 
unsigned long simulate_dc_mmu_load(unsigned long virtaddr)
{
  if (config.dc.tagtype == CT_NONE)
    return virtaddr;
  else
  if (config.dc.tagtype == CT_VIRTUAL) {
    dc_simulate_read(virtaddr);
    return dmmu_translate(virtaddr, 0);
  }
  else if (config.dc.tagtype == CT_PHYSICAL) {
    unsigned long phyaddr = dmmu_translate(virtaddr, 0);
    dc_simulate_read(phyaddr);
    return phyaddr;
  }
  else {
    printf("INTERNAL ERROR: Unknown data cache type.\n");
    cont_run = 0;
  }
 
  return -1;
}
 
/* Calls DMMU translation routines (store cycles) before simulating data
cache for virtually indexed data cache or after simulating data cache
for physically indexed data cache. It returns physical address. */
 
unsigned long simulate_dc_mmu_store(unsigned long virtaddr)
{
  if (config.dc.tagtype == CT_NONE)
    return virtaddr;
  else
  if (config.dc.tagtype == CT_VIRTUAL) {
    dc_simulate_write(virtaddr);
    return dmmu_translate(virtaddr, 1);
  }
  else if (config.dc.tagtype == CT_PHYSICAL) {
    unsigned long phyaddr = dmmu_translate(virtaddr, 1);
    dc_simulate_write(phyaddr);
    return phyaddr;
  }
  else {
    printf("INTERNAL ERROR: Unknown data cache type.\n");
    cont_run = 0;
  }
 
  return -1;
}
 
/* Calculates bit mask to fit the data */
unsigned long bit_mask (unsigned long data) {
  int i = 0;
  data--;
  while (data >> i)
    data |= 1 << i++;
  return data;
}
 
/* Register read and write function for a memory area.
   addr is inside the area, if addr & addr_mask == addr_compare
   (used also by peripheral devices like 16450 UART etc.) */
void register_memoryarea_mask(unsigned long addr_mask, unsigned long addr_compare,
                         unsigned long size, unsigned granularity,
                         unsigned long (readfunc)(unsigned long),
                         void (writefunc)(unsigned long, unsigned long))
{
  struct dev_memarea **pptmp;
  unsigned long size_mask = bit_mask (size);
  int found_error = 0;
  addr_compare &= addr_mask;
 
  debug(5, "addr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare | bit_mask (size), size, granularity);
  /* Go to the end of the list. */
  for(pptmp = &dev_list; *pptmp; pptmp = &(*pptmp)->next)
    if ((addr_compare >= (*pptmp)->addr_compare) && (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)
     || (addr_compare + size > (*pptmp)->addr_compare) && (addr_compare < (*pptmp)->addr_compare + (*pptmp)->size)) {
      if (!found_error) {
        fprintf (stderr, "ERROR: Overlapping memory area(s):\n");
        fprintf (stderr, "\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare | bit_mask (size), size, granularity);
      }
      found_error = 1;
      fprintf (stderr, "and\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", (*pptmp)->addr_mask, (*pptmp)->addr_compare,
        (*pptmp)->addr_compare | (*pptmp)->size_mask, (*pptmp)->size, (*pptmp)->granularity);
    }
 
  if (found_error)
    exit (-1);
 
  cur_area = *pptmp = (struct dev_memarea *)malloc(sizeof(struct dev_memarea));
  (*pptmp)->addr_mask = addr_mask;
  (*pptmp)->addr_compare = addr_compare;
  (*pptmp)->size = size;
  (*pptmp)->size_mask = size_mask;
  (*pptmp)->granularity = granularity;
  (*pptmp)->readfunc = readfunc;
  (*pptmp)->writefunc = writefunc;
  (*pptmp)->next = NULL;
}
 
/* Register read and write function for a memory area.
   Memory areas should be aligned. Memory area is rounded up to
   fit the nearest 2^n aligment.
   (used also by peripheral devices like 16450 UART etc.) */
void register_memoryarea(unsigned long addr,
                         unsigned long size, unsigned granularity,
                         unsigned long (readfunc)(unsigned long),
                         void (writefunc)(unsigned long, unsigned long))
{
  unsigned long size_mask = bit_mask (size);
  unsigned long addr_mask = ~size_mask;
  register_memoryarea_mask (addr_mask, addr & addr_mask,
                      size_mask + 1, granularity,
                      readfunc, writefunc);
}
 
 
/* Check if access is to registered area of memory. */
struct dev_memarea *verify_memoryarea(unsigned long addr)
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next)
    if ((addr & ptmp->addr_mask) == ptmp->addr_compare)
      return cur_area = ptmp;
  return cur_area = NULL;
}
 
/* Returns 32-bit values from mem array. Big endian version. */
unsigned long read_mem(unsigned long memaddr,int* breakpoint)
{
  unsigned long temp;
  struct dev_memarea *dev;
 
  slp_checkaccess(memaddr, SLP_MEMREAD);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  temp = evalsim_mem32(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 32-bit values from mem array. Big endian version. */
unsigned long eval_mem32(unsigned long memaddr,int* breakpoint)
{
 
  unsigned long temp;
  struct dev_memarea *dev;
 
  slp_checkaccess(memaddr, SLP_MEMREAD);
  memaddr = simulate_dc_mmu_load(memaddr);
  if (pending.valid)
    return 0;
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  temp = evalsim_mem32(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 32-bit values from mem array. Big endian version. */
unsigned long eval_insn(unsigned long memaddr,int* breakpoint)
{
 
  unsigned long temp;
  struct dev_memarea *dev;
 
  slp_checkaccess(memaddr, SLP_MEMREAD);
//  memaddr = simulate_ic_mmu_fetch(memaddr);
  ic_simulate_fetch(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  temp = evalsim_mem32(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
unsigned long evalsim_mem32(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr) << 24;
      temp |= cur_area->readfunc(memaddr + 1) << 16;
      temp |= cur_area->readfunc(memaddr + 2) << 8;
      temp |= cur_area->readfunc(memaddr + 3);
      break;
    case 2:
      temp = cur_area->readfunc(memaddr) << 16;
      temp |= cur_area->readfunc(memaddr + 2);
      break;
    case 4:
      temp = cur_area->readfunc(memaddr);
      break;
    }
    if (cur_area->log)
      fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  } else {
    printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, memaddr);
    temp = 0;
  }
  return temp;
}
 
/* Returns 16-bit values from mem array. Big endian version. */
 
unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)
{
  unsigned short temp;
  memaddr = simulate_dc_mmu_load(memaddr);
  if (pending.valid)
    return 0;
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
 
  temp = evalsim_mem16(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
unsigned short evalsim_mem16(unsigned long memaddr)
{
  unsigned short temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr) << 8;
      temp |= cur_area->readfunc(memaddr + 1);
      break;
    case 2:
      temp = cur_area->readfunc(memaddr);
      break;
    case 4:
      printf("EXCEPTION: read 16-bit value from 32-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);
      cont_run = 0;
      break;
    }
    if (cur_area->log)
      fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  } else {
    printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, memaddr);
    temp = 0;
  }
  return temp;
}
 
 
/* Returns 8-bit values from mem array. */
 
unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)
{
  unsigned char temp;
  memaddr = simulate_dc_mmu_load(memaddr);
  if (pending.valid)
    return 0;
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);  /* 28/05/01 CZ */
 
  temp = evalsim_mem8(memaddr);
  if (DEBUG_ENABLED)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
unsigned char evalsim_mem8(unsigned long memaddr)
{
  unsigned char temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr);
      break;
    case 2:
    case 4:
      printf("EXCEPTION: read 8-bit value from %u-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);
      cont_run = 0;
      break;
    }
    if (cur_area->log)
      fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  } else {
    printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, memaddr);
    temp = 0;
  }
  return temp;
}
 
/* Set mem, 32-bit. Big endian version. */
 
void set_mem32(unsigned long memaddr, unsigned long value,int* breakpoint)
{
  slp_checkaccess(memaddr, SLP_MEMWRITE);
  memaddr = simulate_dc_mmu_store(memaddr);
 
  /* If we produced exception don't set anything */
  if (pending.valid == 1)
    return;
 
  if (DEBUG_ENABLED) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  setsim_mem32(memaddr, value);
}
 
void setsim_mem32(unsigned long memaddr, unsigned long value)
{
  struct dev_memarea *dev;
 
  if (verify_memoryarea(memaddr)) {
    if (cur_area->log)
      fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
    switch(cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr    , (value >> 24) & 0xFF);
      cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);
      cur_area->writefunc(memaddr + 2, (value >>  8) & 0xFF);
      cur_area->writefunc(memaddr + 3, (value      ) & 0xFF);
      break;
    case 2:
      cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);
      cur_area->writefunc(memaddr + 2, value & 0xFFFF);
      break;
    case 4:
      cur_area->writefunc(memaddr, value);
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, memaddr);
  }
}
 
/* Set mem, 16-bit. Big endian version. */
 
void set_mem16(unsigned long memaddr, unsigned short value,int* breakpoint)
{
  memaddr = simulate_dc_mmu_store(memaddr);
 
  /* If we produced exception don't set anything */
  if (pending.valid == 1)
    return;
 
  if (DEBUG_ENABLED) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  setsim_mem16(memaddr, value);
}
 
void setsim_mem16(unsigned long memaddr, unsigned short value)
{
  if (verify_memoryarea(memaddr)) {
    if (cur_area->log)
      fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
    switch(cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr, (value >> 8) & 0xFF);
      cur_area->writefunc(memaddr + 1, value & 0xFF);
      break;
    case 2:
      cur_area->writefunc(memaddr, value & 0xFFFF);
      break;
    case 4:
      printf("EXCEPTION: write 16-bit value to 32-bit region (address 0x%08lX)\n", memaddr);
      cont_run = 0;
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, memaddr);
  }
}
 
/* Set mem, 8-bit. */
 
void set_mem8(unsigned long memaddr, unsigned char value,int* breakpoint)
{
  memaddr = simulate_dc_mmu_store(memaddr);
 
  /* If we produced exception don't set anything */
  if (pending.valid == 1)
    return;
 
  if (DEBUG_ENABLED) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  setsim_mem8(memaddr, value);
}
 
void setsim_mem8(unsigned long memaddr, unsigned char value)
{
  if (verify_memoryarea(memaddr)) {
    if (cur_area->log)
      fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
    if (cur_area->granularity == 1)
      cur_area->writefunc(memaddr, value);
    else {
      printf("EXCEPTION: write 8-bit value to %u-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);
      cont_run = 0;
    }
  } else {
    printf("EXCEPTION: write out of memory (8-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, memaddr);
  }
}
 
void dumpmemory(unsigned int from, unsigned int to, int disasm, int nl)
{
  unsigned int i, j;
  struct label_entry *tmp;
  int breakpoint = 0;
  int ilen = disasm ? 4 : 16;
 
  for(i = from; i < to; i += ilen) {
    printf("%.8x: ", i);
    for (j = 0; j < ilen;) {
      int data = -1;
      if (!disasm) {
        tmp = NULL;
        if (verify_memoryarea(i+j)) {
          struct label_entry *entry;
          entry = get_label(i + j);
          if (entry)
            printf("(%s)", entry->name);
          printf("%02x ", data = evalsim_mem8(i+j));
        } else printf("XX ");
        j++;
      } else {
        int breakpoint;
        unsigned int _insn = read_mem(i, &breakpoint);
        int index = insn_decode (_insn);
        int len = insn_len (index);
 
        tmp = NULL;
        if (verify_memoryarea(i+j)) {
          struct label_entry *entry;
          entry = get_label(i + j);
          if (entry)
            printf("(%s)", entry->name);
 
          printf(": %08x ", (unsigned long)_insn);
          if (index >= 0) {
            disassemble_insn (_insn);
            printf(" %s", disassembled);
          } else
            printf("<invalid>");
        } else printf("XXXXXXXX");
        j += len;
      }
    }
    if (nl)
      printf ("\n");
  }
}
 
 
unsigned long simmem_read_byte(unsigned long addr) {
  return simmem[cur_area->misc + (addr & cur_area->size_mask)].data;
}
 
void simmem_write_byte(unsigned long addr, unsigned long value) {
  simmem[cur_area->misc + (addr & cur_area->size_mask)].data = (unsigned char)value;
}
 
unsigned long simmem_read_zero(unsigned long addr) {
  if (config.sim.verbose)
    fprintf (stderr, "WARNING: memory read from non-read memory area 0x%08x.\n", addr);
  return 0;
}
 
void simmem_write_null(unsigned long addr, unsigned long value) {
  if (config.sim.verbose)
    fprintf (stderr, "WARNING: memory write to 0x%08x, non-write memory area (value 0x%08x).\n", addr, value);
}
 
/* Initialize memory table from a config struct */
 
void init_memory_table ()
{
  unsigned long memory_needed = 0;
 
  /* If nothing was defined, use default memory block */
  if (config.memory.nmemories) {
    int i;
    for (i = 0; i < config.memory.nmemories; i++) {
      unsigned long start = config.memory.table[i].baseaddr;
      unsigned long length = config.memory.table[i].size;
      char *type = config.memory.table[i].name;
      int rd = config.memory.table[i].delayr;
      int wd = config.memory.table[i].delayw;
      int ce = config.memory.table[i].ce;
      if (config.sim.verbose)
        debug (1, "%08X %08X (%i KB): %s (activated by CE%i; read delay = %icyc, write delay = %icyc)\n",
          start, length, length >> 10, type, ce, rd, wd);
      register_memoryarea(start, length, 1, &simmem_read_byte, &simmem_write_byte);
      cur_area->misc = memory_needed;
      cur_area->delayw = wd;
      cur_area->delayr = rd;
      if (config.memory.table[i].log[0] != '\0') {
        if ((cur_area->log = fopen (config.memory.table[i].log, "wt+")) == NULL)
          fprintf (stderr, "WARNING: Cannot open '%s'.\n", config.memory.table[i].log);
      } else
        cur_area->log = 0;
      memory_needed += cur_area->size;
    }
    printf ("\n");
  } else {
    if (config.sim.verbose)
      fprintf (stderr, "WARNING: Memory not defined, assuming standard configuration.\n");
    register_memoryarea(DEFAULT_MEMORY_START, DEFAULT_MEMORY_LEN, 1, &simmem_read_byte, &simmem_write_byte);
    memory_needed += cur_area->size;
  }
 
  simmem = (struct mem_entry *) malloc (sizeof (struct mem_entry) * memory_needed);
  if (!simmem) {
    fprintf (stderr, "Failed to allocate sim memory. Aborting\n");
    exit (-1);
  }
}
 
/* Changes read/write memory in read/write only */
 
void lock_memory_table ()
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
    if (ptmp->delayr < 0 && ptmp->readfunc == &simmem_read_byte)
      ptmp->readfunc = &simmem_read_zero;
    if (ptmp->delayw < 0 && ptmp->writefunc == &simmem_write_byte)
      ptmp->writefunc = &simmem_write_null;
  }
}
 
/* Closes files, etc. */
 
void done_memory_table ()
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
    if (ptmp->log)
      fclose (ptmp->log);
  }
}
 
/* Displays current memory configuration */
 
void memory_table_status ()
{
  struct dev_memarea *ptmp;
 
  /* Check list of registered devices. */
  for(ptmp = dev_list; ptmp; ptmp = ptmp->next) {
    printf ("addr & %08x == %08x to %08x, size %08x, gran %iB\n",
      ptmp->addr_mask, ptmp->addr_compare, ptmp->addr_compare | bit_mask (ptmp->size),
      ptmp->size, ptmp->granularity);
    printf ("\t");
    if (ptmp->delayr >= 0)
      printf ("read delay = %i cycles, ", ptmp->delayr);
    else
      printf ("reads not possible, ");
 
    if (ptmp->delayw >= 0)
      printf ("write delay = %i cycles", ptmp->delayw);
    else
      printf ("writes not possible");
 
    if (ptmp->log)
      printf (", (logged)\n");
    else
      printf ("\n");
  }
}
 
/* Outputs time in pretty form to dest string */
 
void generate_time_pretty (char *dest, long time_ps)
{
  int exp3 = 0;
  if (time_ps) {
    while ((time_ps % 1000) == 0) {
      time_ps /= 1000;
      exp3++;
    }
  }
  sprintf (dest, "%i%cs", time_ps, "pnum"[exp3]);
}

Line No.	Rev	Author	Line
1	2	cvs	`/* abstract.c -- Abstract entities`
2			`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
3
4			`This file is part of OpenRISC 1000 Architectural Simulator.`
5
6			`This program is free software; you can redistribute it and/or modify`
7			`it under the terms of the GNU General Public License as published by`
8			`the Free Software Foundation; either version 2 of the License, or`
9			`(at your option) any later version.`
10
11			`This program is distributed in the hope that it will be useful,`
12			`but WITHOUT ANY WARRANTY; without even the implied warranty of`
13			`MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
14			`GNU General Public License for more details.`
15
16			`You should have received a copy of the GNU General Public License`
17			`along with this program; if not, write to the Free Software`
18			`Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */`
19
20	66	lampret	`/* Abstract memory and routines that go with this. I need to`
21	2	cvs	`add all sorts of other abstract entities. Currently we have`
22			`only memory. */`
23
24	221	markom	`#include <stdlib.h>`
25	2	cvs	`#include <stdio.h>`
26			`#include <ctype.h>`
27			`#include <string.h>`
28
29	6	lampret	`#include "config.h"`
30	7	jrydberg	`#include "sim-config.h"`
31	6	lampret
32	2	cvs	`#include "parse.h"`
33			`#include "abstract.h"`
34	261	markom	`#include "labels.h"`
35	2	cvs	`#include "arch.h"`
36			`#include "trace.h"`
37			`#include "execute.h"`
38	32	lampret	`#include "sprs.h"`
39	35	lampret	`#include "stats.h"`
40	32	lampret	`#include "except.h"`
41	123	markom	`#include "debug_unit.h"`
42	134	markom	`#include "opcode/or32.h"`
43	2	cvs
44			`extern unsigned long reg[];`
45	138	markom	`extern char *disassembled;`
46	2	cvs
47	28	lampret	`/* This is an abstract+physical memory array rather than only physical`
48			`memory array */`
49	221	markom	`static struct mem_entry *simmem;`
50	2	cvs
51	30	lampret	`/* Pointer to memory area descriptions that are assigned to individual`
52			`peripheral devices. */`
53			`struct dev_memarea *dev_list;`
54
55	221	markom	`/* Temporary variable to increase speed. */`
56			`struct dev_memarea *cur_area;`
57
58	349	simons	`/* It returns physical address. */`
59	430	markom	`inline unsigned long translate_vrt_to_phy_add(unsigned long virtaddr, int write_access)`
60	77	lampret	`{`
61	429	markom	`if (config.ic.tagtype == CT_NONE)`
62	239	markom	`return virtaddr;`
63			`else`
64	429	markom	`if (config.ic.tagtype == CT_VIRTUAL) {`
65	430	markom	`return immu_translate(virtaddr, write_access);`
66	239	markom	`}`
67	429	markom	`else if (config.dc.tagtype == CT_PHYSICAL) {`
68	430	markom	`unsigned long phyaddr = immu_translate(virtaddr, write_access);`
69	239	markom	`return phyaddr;`
70			`}`
71			`else {`
72			`printf("INTERNAL ERROR: Unknown insn cache type.\n");`
73			`cont_run = 0;`
74			`}`
75	221	markom
76	239	markom	`return -1;`
77	77	lampret	`}`
78
79	349	simons	`/* Calls IMMU translation routines before simulating insn`
80			`cache for virtually indexed insn cache or after simulating insn cache`
81			`for physically indexed insn cache. It returns physical address. */`
82
83			`unsigned long simulate_ic_mmu_fetch(unsigned long virtaddr)`
84			`{`
85
86			`unsigned long phyaddr;`
87
88	430	markom	`if ((phyaddr = translate_vrt_to_phy_add(virtaddr, 0)) != -1) {`
89	349	simons	`ic_simulate_fetch(phyaddr);`
90			`return phyaddr;`
91			`}`
92			`else {`
93			`printf("INTERNAL ERROR: Unknown insn cache type.\n");`
94			`cont_run = 0;`
95			`}`
96			`return -1;`
97			`}`
98
99	77	lampret	`/* Calls DMMU translation routines (load cycles) before simulating data`
100	239	markom	`cache for virtually indexed data cache or after simulating data cache`
101			`for physically indexed data cache. It returns physical address. */`
102	6	lampret
103			`unsigned long simulate_dc_mmu_load(unsigned long virtaddr)`
104			`{`
105	429	markom	`if (config.dc.tagtype == CT_NONE)`
106	239	markom	`return virtaddr;`
107			`else`
108	429	markom	`if (config.dc.tagtype == CT_VIRTUAL) {`
109	327	lampret	`dc_simulate_read(virtaddr);`
110	430	markom	`return dmmu_translate(virtaddr, 0);`
111	239	markom	`}`
112	429	markom	`else if (config.dc.tagtype == CT_PHYSICAL) {`
113	430	markom	`unsigned long phyaddr = dmmu_translate(virtaddr, 0);`
114	327	lampret	`dc_simulate_read(phyaddr);`
115	239	markom	`return phyaddr;`
116			`}`
117			`else {`
118	327	lampret	`printf("INTERNAL ERROR: Unknown data cache type.\n");`
119	239	markom	`cont_run = 0;`
120			`}`
121	221	markom
122	239	markom	`return -1;`
123	6	lampret	`}`
124
125	77	lampret	`/* Calls DMMU translation routines (store cycles) before simulating data`
126	6	lampret	`cache for virtually indexed data cache or after simulating data cache`
127			`for physically indexed data cache. It returns physical address. */`
128
129			`unsigned long simulate_dc_mmu_store(unsigned long virtaddr)`
130			`{`
131	429	markom	`if (config.dc.tagtype == CT_NONE)`
132	239	markom	`return virtaddr;`
133			`else`
134	429	markom	`if (config.dc.tagtype == CT_VIRTUAL) {`
135	239	markom	`dc_simulate_write(virtaddr);`
136	430	markom	`return dmmu_translate(virtaddr, 1);`
137	239	markom	`}`
138	429	markom	`else if (config.dc.tagtype == CT_PHYSICAL) {`
139	430	markom	`unsigned long phyaddr = dmmu_translate(virtaddr, 1);`
140	239	markom	`dc_simulate_write(phyaddr);`
141			`return phyaddr;`
142			`}`
143			`else {`
144			`printf("INTERNAL ERROR: Unknown data cache type.\n");`
145			`cont_run = 0;`
146			`}`
147	221	markom
148	239	markom	`return -1;`
149	6	lampret	`}`
150
151	261	markom	`/* Calculates bit mask to fit the data */`
152			`unsigned long bit_mask (unsigned long data) {`
153			`int i = 0;`
154			`data--;`
155	382	markom	`while (data >> i)`
156	261	markom	`data \|= 1 << i++;`
157			`return data;`
158			`}`
159
160			`/* Register read and write function for a memory area.`
161			`addr is inside the area, if addr & addr_mask == addr_compare`
162			`(used also by peripheral devices like 16450 UART etc.) */`
163			`void register_memoryarea_mask(unsigned long addr_mask, unsigned long addr_compare,`
164			`unsigned long size, unsigned granularity,`
165	239	markom	`unsigned long (readfunc)(unsigned long),`
166	261	markom	`void (writefunc)(unsigned long, unsigned long))`
167	30	lampret	`{`
168	239	markom	`struct dev_memarea **pptmp;`
169	261	markom	`unsigned long size_mask = bit_mask (size);`
170			`int found_error = 0;`
171			`addr_compare &= addr_mask;`
172	221	markom
173	382	markom	`debug(5, "addr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare \| bit_mask (size), size, granularity);`
174	239	markom	`/* Go to the end of the list. */`
175	261	markom	`for(pptmp = &dev_list; pptmp; pptmp = &(pptmp)->next)`
176			`if ((addr_compare >= (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)`
177			`\|\| (addr_compare + size > (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)) {`
178	262	markom	`if (!found_error) {`
179	261	markom	`fprintf (stderr, "ERROR: Overlapping memory area(s):\n");`
180	262	markom	`fprintf (stderr, "\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", addr_mask, addr_compare, addr_compare \| bit_mask (size), size, granularity);`
181			`}`
182	261	markom	`found_error = 1;`
183	424	markom	`fprintf (stderr, "and\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", (pptmp)->addr_mask, (pptmp)->addr_compare,`
184	261	markom	`(pptmp)->addr_compare \| (pptmp)->size_mask, (pptmp)->size, (pptmp)->granularity);`
185			`}`
186
187			`if (found_error)`
188			`exit (-1);`
189
190	239	markom	`cur_area = pptmp = (struct dev_memarea )malloc(sizeof(struct dev_memarea));`
191	261	markom	`(*pptmp)->addr_mask = addr_mask;`
192			`(*pptmp)->addr_compare = addr_compare;`
193	239	markom	`(*pptmp)->size = size;`
194	261	markom	`(*pptmp)->size_mask = size_mask;`
195	239	markom	`(*pptmp)->granularity = granularity;`
196			`(*pptmp)->readfunc = readfunc;`
197			`(*pptmp)->writefunc = writefunc;`
198			`(*pptmp)->next = NULL;`
199	261	markom	`}`
200	221	markom
201	261	markom	`/* Register read and write function for a memory area.`
202			`Memory areas should be aligned. Memory area is rounded up to`
203			`fit the nearest 2^n aligment.`
204			`(used also by peripheral devices like 16450 UART etc.) */`
205			`void register_memoryarea(unsigned long addr,`
206			`unsigned long size, unsigned granularity,`
207			`unsigned long (readfunc)(unsigned long),`
208			`void (writefunc)(unsigned long, unsigned long))`
209			`{`
210			`unsigned long size_mask = bit_mask (size);`
211			`unsigned long addr_mask = ~size_mask;`
212			`register_memoryarea_mask (addr_mask, addr & addr_mask,`
213			`size_mask + 1, granularity,`
214			`readfunc, writefunc);`
215	30	lampret	`}`
216
217	261	markom
218	30	lampret	`/* Check if access is to registered area of memory. */`
219			`struct dev_memarea *verify_memoryarea(unsigned long addr)`
220			`{`
221	239	markom	`struct dev_memarea *ptmp;`
222	221	markom
223	239	markom	`/* Check list of registered devices. */`
224			`for(ptmp = dev_list; ptmp; ptmp = ptmp->next)`
225	261	markom	`if ((addr & ptmp->addr_mask) == ptmp->addr_compare)`
226	239	markom	`return cur_area = ptmp;`
227			`return cur_area = NULL;`
228	30	lampret	`}`
229
230	2	cvs	`/* Returns 32-bit values from mem array. Big endian version. */`
231	349	simons	`unsigned long read_mem(unsigned long memaddr,int* breakpoint)`
232			`{`
233			`unsigned long temp;`
234			`struct dev_memarea *dev;`
235
236			`slp_checkaccess(memaddr, SLP_MEMREAD);`
237			`if (DEBUG_ENABLED)`
238			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
239			`temp = evalsim_mem32(memaddr);`
240			`if (DEBUG_ENABLED)`
241			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
242			`return temp;`
243			`}`
244
245			`/* Returns 32-bit values from mem array. Big endian version. */`
246	123	markom	`unsigned long eval_mem32(unsigned long memaddr,int* breakpoint)`
247	2	cvs	`{`
248	6	lampret
249	239	markom	`unsigned long temp;`
250			`struct dev_memarea *dev;`
251	123	markom
252	239	markom	`slp_checkaccess(memaddr, SLP_MEMREAD);`
253			`memaddr = simulate_dc_mmu_load(memaddr);`
254	458	simons	`if (pending.valid)`
255			`return 0;`
256	270	markom	`if (DEBUG_ENABLED)`
257			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
258	239	markom	`temp = evalsim_mem32(memaddr);`
259	270	markom	`if (DEBUG_ENABLED)`
260			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
261	239	markom	`return temp;`
262	66	lampret	`}`
263
264	349	simons	`/* Returns 32-bit values from mem array. Big endian version. */`
265			`unsigned long eval_insn(unsigned long memaddr,int* breakpoint)`
266			`{`
267
268			`unsigned long temp;`
269			`struct dev_memarea *dev;`
270
271			`slp_checkaccess(memaddr, SLP_MEMREAD);`
272	416	simons	`// memaddr = simulate_ic_mmu_fetch(memaddr);`
273			`ic_simulate_fetch(memaddr);`
274	349	simons	`if (DEBUG_ENABLED)`
275			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
276			`temp = evalsim_mem32(memaddr);`
277			`if (DEBUG_ENABLED)`
278			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
279			`return temp;`
280			`}`
281
282	221	markom	`unsigned long evalsim_mem32(unsigned long memaddr)`
283	66	lampret	`{`
284	239	markom	`unsigned long temp;`
285	221	markom
286	239	markom	`if (verify_memoryarea(memaddr)) {`
287			`switch(cur_area->granularity) {`
288			`case 1:`
289			`temp = cur_area->readfunc(memaddr) << 24;`
290			`temp \|= cur_area->readfunc(memaddr + 1) << 16;`
291			`temp \|= cur_area->readfunc(memaddr + 2) << 8;`
292			`temp \|= cur_area->readfunc(memaddr + 3);`
293			`break;`
294			`case 2:`
295			`temp = cur_area->readfunc(memaddr) << 16;`
296			`temp \|= cur_area->readfunc(memaddr + 2);`
297			`break;`
298			`case 4:`
299			`temp = cur_area->readfunc(memaddr);`
300			`break;`
301	426	markom	`}`
302			`if (cur_area->log)`
303			`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
304	239	markom	`} else {`
305			`printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
306	458	simons	`except_handle(EXCEPT_BUSERR, memaddr);`
307	239	markom	`temp = 0;`
308			`}`
309			`return temp;`
310	2	cvs	`}`
311
312			`/* Returns 16-bit values from mem array. Big endian version. */`
313
314	123	markom	`unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)`
315	2	cvs	`{`
316	239	markom	`unsigned short temp;`
317			`memaddr = simulate_dc_mmu_load(memaddr);`
318	458	simons	`if (pending.valid)`
319			`return 0;`
320	270	markom	`if (DEBUG_ENABLED)`
321			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
322	66	lampret
323	239	markom	`temp = evalsim_mem16(memaddr);`
324	270	markom	`if (DEBUG_ENABLED)`
325			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
326	239	markom	`return temp;`
327	66	lampret	`}`
328
329	221	markom	`unsigned short evalsim_mem16(unsigned long memaddr)`
330	66	lampret	`{`
331	239	markom	`unsigned short temp;`
332	221	markom
333	239	markom	`if (verify_memoryarea(memaddr)) {`
334			`switch(cur_area->granularity) {`
335			`case 1:`
336			`temp = cur_area->readfunc(memaddr) << 8;`
337			`temp \|= cur_area->readfunc(memaddr + 1);`
338			`break;`
339			`case 2:`
340			`temp = cur_area->readfunc(memaddr);`
341			`break;`
342			`case 4:`
343			`printf("EXCEPTION: read 16-bit value from 32-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);`
344			`cont_run = 0;`
345			`break;`
346			`}`
347	426	markom	`if (cur_area->log)`
348			`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
349	239	markom	`} else {`
350			`printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
351	458	simons	`except_handle(EXCEPT_BUSERR, memaddr);`
352	239	markom	`temp = 0;`
353			`}`
354			`return temp;`
355	2	cvs	`}`
356
357
358	6	lampret	`/* Returns 8-bit values from mem array. */`
359	2	cvs
360	123	markom	`unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)`
361	221	markom	`{`
362	239	markom	`unsigned char temp;`
363			`memaddr = simulate_dc_mmu_load(memaddr);`
364	458	simons	`if (pending.valid)`
365			`return 0;`
366	270	markom	`if (DEBUG_ENABLED)`
367			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
368	6	lampret
369	239	markom	`temp = evalsim_mem8(memaddr);`
370	270	markom	`if (DEBUG_ENABLED)`
371			`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
372	239	markom	`return temp;`
373	66	lampret	`}`
374
375	221	markom	`unsigned char evalsim_mem8(unsigned long memaddr)`
376			`{`
377	239	markom	`unsigned char temp;`
378	123	markom
379	239	markom	`if (verify_memoryarea(memaddr)) {`
380			`switch(cur_area->granularity) {`
381			`case 1:`
382			`temp = cur_area->readfunc(memaddr);`
383			`break;`
384			`case 2:`
385			`case 4:`
386			`printf("EXCEPTION: read 8-bit value from %u-bit region (address 0x%08lX)\n", cur_area->granularity * 8, memaddr);`
387			`cont_run = 0;`
388			`break;`
389			`}`
390	426	markom	`if (cur_area->log)`
391			`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
392	239	markom	`} else {`
393			`printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);`
394	458	simons	`except_handle(EXCEPT_BUSERR, memaddr);`
395	239	markom	`temp = 0;`
396			`}`
397			`return temp;`
398	2	cvs	`}`
399
400			`/* Set mem, 32-bit. Big endian version. */`
401
402	123	markom	`void set_mem32(unsigned long memaddr, unsigned long value,int* breakpoint)`
403	2	cvs	`{`
404	239	markom	`slp_checkaccess(memaddr, SLP_MEMWRITE);`
405			`memaddr = simulate_dc_mmu_store(memaddr);`
406	221	markom
407	437	simons	`/* If we produced exception don't set anything */`
408			`if (pending.valid == 1)`
409			`return;`
410
411	270	markom	`if (DEBUG_ENABLED) {`
412			`breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); / 28/05/01 CZ */`
413			`*breakpoint += CheckDebugUnit(DebugStoreData,value);`
414			`}`
415	123	markom
416	239	markom	`setsim_mem32(memaddr, value);`
417	66	lampret	`}`
418
419			`void setsim_mem32(unsigned long memaddr, unsigned long value)`
420			`{`
421	239	markom	`struct dev_memarea *dev;`
422	66	lampret
423	239	markom	`if (verify_memoryarea(memaddr)) {`
424	426	markom	`if (cur_area->log)`
425			`fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);`
426	239	markom	`switch(cur_area->granularity) {`
427			`case 1:`
428	251	erez	`cur_area->writefunc(memaddr , (value >> 24) & 0xFF);`
429	239	markom	`cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);`
430	251	erez	`cur_area->writefunc(memaddr + 2, (value >> 8) & 0xFF);`
431			`cur_area->writefunc(memaddr + 3, (value ) & 0xFF);`
432	239	markom	`break;`
433			`case 2:`
434			`cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);`
435			`cur_area->writefunc(memaddr + 2, value & 0xFFFF);`
436			`break;`
437			`case 4:`
438			`cur_area->writefunc(memaddr, value);`
439			`break;`
440	242	markom	`}`
441	239	markom	`} else {`
442			`printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);`
443	458	simons	`except_handle(EXCEPT_BUSERR, memaddr);`
444	239	markom	`}`
445	2	cvs	`}`
446
447			`/* Set mem, 16-bit. Big endian version. */`
448
449	123	markom	`void set_mem16(unsigned long memaddr, unsigned short value,int* breakpoint)`
450	2	cvs	`{`
451	239	markom	`memaddr = simulate_dc_mmu_store(memaddr);`
452	221	markom
453	437	simons	`/* If we produced exception don't set anything */`
454			`if (pending.valid == 1)`
455			`return;`
456
457	270	markom	`if (DEBUG_ENABLED) {`
458			`breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); / 28/05/01 CZ */`
459			`*breakpoint += CheckDebugUnit(DebugStoreData,value);`
460			`}`
461	123	markom
462	239	markom	`setsim_mem16(memaddr, value);`
463	66	lampret	`}`
464
465			`void setsim_mem16(unsigned long memaddr, unsigned short value)`
466			`{`
467	239	markom	`if (verify_memoryarea(memaddr)) {`
468	426	markom	`if (cur_area->log)`
469			`fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);`
470	239	markom	`switch(cur_area->granularity) {`
471			`case 1:`
472			`cur_area->writefunc(memaddr, (value >> 8) & 0xFF);`
473			`cur_area->writefunc(memaddr + 1, value & 0xFF);`
474			`break;`
475			`case 2:`
476	251	erez	`cur_area->writefunc(memaddr, value & 0xFFFF);`
477	239	markom	`break;`
478			`case 4:`
479			`printf("EXCEPTION: write 16-bit value to 32-bit region (address 0x%08lX)\n", memaddr);`
480			`cont_run = 0;`
481			`break;`
482			`}`
483			`} else {`
484			`printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);`
485	458	simons	`except_handle(EXCEPT_BUSERR, memaddr);`
486	239	markom	`}`
487	2	cvs	`}`
488
489	6	lampret	`/* Set mem, 8-bit. */`
490	2	cvs
491	123	markom	`void set_mem8(unsigned long memaddr, unsigned char value,int* breakpoint)`
492	2	cvs	`{`
493	239	markom	`memaddr = simulate_dc_mmu_store(memaddr);`
494	221	markom
495	437	simons	`/* If we produced exception don't set anything */`
496			`if (pending.valid == 1)`
497			`return;`
498
499	270	markom	`if (DEBUG_ENABLED) {`
500			`breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr); / 28/05/01 CZ */`

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [tags/] [nog_patch_42/] [or1ksim/] [cpu/] [common/] [abstract.c] - Blame information for rev 458