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

Subversion Repositories or1k

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

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 "execute.h"
#include "sprs.h"
#include "stats.h"
#include "except.h"
#include "debug_unit.h"
#include "opcode/or32.h"
#include "support/profile.h"
 
extern unsigned long reg[];
extern char *disassembled;
 
/* This is an abstract+physical memory array rather than only physical
   memory array */
static unsigned long *simmem32;
 
/* 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;
 
/* These are set by mmu if cache inhibit bit is set for current acces.  */
int data_ci, insn_ci;
 
/* Virtual address of current access. */
unsigned long cur_vadd;
 
/* 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)->log = 0;
  (*pptmp)->delayr = 2;
  (*pptmp)->delayw = 2;
  (*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. */
inline struct dev_memarea *verify_memoryarea(unsigned long addr)
{
  struct dev_memarea *ptmp;
 
  /* Check cached value first */
  if (cur_area && (addr & cur_area->addr_mask) == (cur_area->addr_compare & cur_area->addr_mask))
    return cur_area;
 
  /* When mc is enabled, we must check valid also, otherwise we assume it is nonzero */
  IFF (config.mc.enabled) {
    /* Check list of registered devices. */
    for(ptmp = dev_list; ptmp; ptmp = ptmp->next)
      if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask) && ptmp->valid)
        return cur_area = ptmp;
  } else {
    /* Check list of registered devices. */
    for(ptmp = dev_list; ptmp; ptmp = ptmp->next)
      if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask))
        return cur_area = ptmp;
  }
  return cur_area = NULL;
}
 
/* Finds the memory area for the address and adjust the read and write delays for it. */
void adjust_rw_delay(unsigned long memaddr, unsigned long delayr, unsigned long delayw)
{
  if (verify_memoryarea(memaddr)) {
    cur_area->delayr = delayr;
    cur_area->delayw = delayw;
  }
}
 
inline unsigned long evalsim_mem32(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 4:
      temp = cur_area->readfunc(memaddr);
      runtime.sim.mem_cycles += cur_area->delayr;
      break;
    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);
      runtime.sim.mem_cycles += cur_area->delayr * 4;
      break;
    case 2:
      temp = cur_area->readfunc(memaddr) << 16;
      temp |= cur_area->readfunc(memaddr + 2);
      runtime.sim.mem_cycles += cur_area->delayr * 2;
      break;
    }
  }
  return temp;
}
 
unsigned short evalsim_mem16(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr) << 8;
      temp |= cur_area->readfunc(memaddr + 1);
      runtime.sim.mem_cycles += cur_area->delayr * 2;
      break;
    case 2:
      temp = cur_area->readfunc(memaddr);
      runtime.sim.mem_cycles += cur_area->delayr;
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      if (memaddr & 2)
        temp &= 0xffff;
      else
        temp >>= 16;
      break;
    }
  }
  return temp;
}
 
unsigned char evalsim_mem8(unsigned long memaddr)
{
  unsigned long temp;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      temp = cur_area->readfunc(memaddr);
      runtime.sim.mem_cycles += cur_area->delayr;
      break;
    case 2:
      temp = evalsim_mem16 (memaddr & ~1ul);
      if (memaddr & 1)
        temp &= 0xff;
      else
        temp >>= 8;
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      temp >>= 8 * (3 - (memaddr & 3));
      temp &= 0xff;
      break;
    }
  }
  return temp;
}
 
/* 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;
 
  cur_vadd = memaddr;
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  temp = evalsim_mem32(memaddr);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.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;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_READ);
 
  if (memaddr & 3) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return 0;
  }
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
 
  cur_vadd = memaddr;
 
  memaddr = dmmu_translate(memaddr, 0);
  if (pending.valid)
    return 0;
 
  temp = dc_simulate_read(memaddr, 4);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.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;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_FETCH);
//  memaddr = simulate_ic_mmu_fetch(memaddr);
  cur_vadd = pc;
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
  if (config.ic.enabled)
    temp = ic_simulate_fetch(memaddr);
  else
    temp = evalsim_mem32(memaddr);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 16-bit values from mem array. Big endian version. */
 
unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)
{
  unsigned short temp;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_16 | MPROF_READ);
 
  if (memaddr & 1) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return 0;
  }
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); /* 28/05/01 CZ */
 
  cur_vadd = memaddr;
 
  memaddr = dmmu_translate(memaddr, 0);
  if (pending.valid)
    return 0;
 
  temp = (unsigned short)dc_simulate_read(memaddr, 2);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
/* Returns 8-bit values from mem array. */
 
unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)
{
  unsigned char temp;
 
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_8 | MPROF_READ);
 
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr);  /* 28/05/01 CZ */
 
  cur_vadd = memaddr;
 
  memaddr = dmmu_translate(memaddr, 0);
  if (pending.valid)
    return 0;
 
  temp = (unsigned char)dc_simulate_read(memaddr, 1);
  if (!cur_area) {
    printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
    temp = 0;
  }
 
  if (!pending.valid && cur_area->log)
    fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);
  if (config.debug.enabled)
    *breakpoint += CheckDebugUnit(DebugLoadData,temp);  /* MM170901 */
  return temp;
}
 
void setsim_mem32(unsigned long memaddr, unsigned long value)
{
  struct dev_memarea *dev;
 
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 4:
      cur_area->writefunc(memaddr, value);
      runtime.sim.mem_cycles += cur_area->delayw;
      break;
    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);
      runtime.sim.mem_cycles += cur_area->delayw * 4;
      break;
    case 2:
      cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);
      cur_area->writefunc(memaddr + 2, value & 0xFFFF);
      runtime.sim.mem_cycles += cur_area->delayw * 2;
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
  }
}
 
void setsim_mem16(unsigned long memaddr, unsigned short value)
{
  unsigned long temp;
  if (verify_memoryarea(memaddr)) {
    switch(cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr, (value >> 8) & 0xFF);
      cur_area->writefunc(memaddr + 1, value & 0xFF);
      runtime.sim.mem_cycles += cur_area->delayw * 2;
      break;
    case 2:
      cur_area->writefunc(memaddr, value & 0xFFFF);
      runtime.sim.mem_cycles += cur_area->delayw;
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      temp &= 0xffff << ((memaddr & 2) ? 16 : 0);
      temp |= (unsigned long)(value & 0xffff) << ((memaddr & 2) ? 0 : 16);
      setsim_mem32 (memaddr & ~3ul, temp);
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
  }
}
 
void setsim_mem8(unsigned long memaddr, unsigned char value)
{
  unsigned long temp;
  if (verify_memoryarea(memaddr)) {
    switch (cur_area->granularity) {
    case 1:
      cur_area->writefunc(memaddr, value);
      runtime.sim.mem_cycles += cur_area->delayw;
      break;
    case 2:
      temp = evalsim_mem16 (memaddr & ~1ul);
      temp &= 0xff << ((memaddr & 1) ? 8 : 0);
      temp |= (unsigned short)(value & 0xff) << ((memaddr & 1) ? 0 : 8);
      setsim_mem16 (memaddr & ~1ul, temp);
      break;
    case 4:
      temp = evalsim_mem32 (memaddr & ~3ul);
      temp &= ~(0xff << (8 * (3 - (memaddr & 3))));
      temp |= (unsigned long)(value & 0xff) << (8 * (3 - (memaddr & 3)));
      setsim_mem32 (memaddr & ~3ul, temp);
      break;
    }
  } else {
    printf("EXCEPTION: write out of memory (8-bit access to %.8lx)\n", memaddr);
    except_handle(EXCEPT_BUSERR, cur_vadd);
  }
}
 
/* Set mem, 32-bit. Big endian version. */
 
void set_mem32(unsigned long memaddr, unsigned long value,int* breakpoint)
{
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_32 | MPROF_WRITE);
 
  if (memaddr & 3) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return;
  }
 
  cur_vadd = memaddr;
  memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (pending.valid)
    return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
 
  dc_simulate_write(memaddr, value, 4);
}
 
/* Set mem, 16-bit. Big endian version. */
 
void set_mem16(unsigned long memaddr, unsigned short value,int* breakpoint)
{
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_16 | MPROF_WRITE);
 
  if (memaddr & 1) {
    except_handle (EXCEPT_ALIGN, memaddr);
    return;
  }
 
  cur_vadd = memaddr;
  memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (pending.valid)
    return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
 
  dc_simulate_write(memaddr, (unsigned long)value, 2);
}
 
/* Set mem, 8-bit. */
 
void set_mem8(unsigned long memaddr, unsigned char value,int* breakpoint)
{
  if (config.sim.mprofile)
    mprofile (memaddr, MPROF_8 | MPROF_WRITE);
 
  cur_vadd = memaddr;
  memaddr = dmmu_translate(memaddr, 1);;
  /* If we produced exception don't set anything */
  if (pending.valid) return;
 
  if (config.debug.enabled) {
    *breakpoint += CheckDebugUnit(DebugStoreAddress,memaddr);  /* 28/05/01 CZ */
    *breakpoint += CheckDebugUnit(DebugStoreData,value);
  }
 
  if (cur_area->log)
    fprintf (cur_area->log, "[%08x] -> write %08x\n", memaddr, value);
 
  dc_simulate_write(memaddr, (unsigned long)value, 1);
}
 
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_word(unsigned long addr) {
  return simmem32[(cur_area->misc + (addr & cur_area->size_mask)) >> 2];
}
 
void simmem_write_word(unsigned long addr, unsigned long value) {
  simmem32[(cur_area->misc + (addr & cur_area->size_mask)) >> 2] = 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, 4, &simmem_read_word, &simmem_write_word);
      cur_area->misc = memory_needed;
      cur_area->chip_select = ce;
      cur_area->valid = 1;
      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 = NULL;
      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, 4, &simmem_read_word, &simmem_write_word);
    cur_area->misc = memory_needed;
    cur_area->chip_select = 0;
    cur_area->valid = 1;
    cur_area->delayw = 1;
    cur_area->delayr = 1;
    cur_area->log = NULL;
    memory_needed += cur_area->size;
  }
 
  simmem32 = (unsigned long *) malloc (sizeof (unsigned long) * ((memory_needed + 3) / 4));
  if (!simmem32) {
    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_word)
      ptmp->readfunc = &simmem_read_zero;
    if (ptmp->delayw < 0 && ptmp->writefunc == &simmem_write_word)
      ptmp->writefunc = &simmem_write_null;
 
    /* If this mem area is not for memory chip under MC control
       then this area is valid all the time */
    if (ptmp->readfunc != &simmem_read_word) {
      ptmp->valid = 1;
      ptmp->chip_select = -1;
    }
  }
}
 
/* 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 */
 
char *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]);
  return dest;
}

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 "execute.h"`
37	32	lampret	`#include "sprs.h"`
38	35	lampret	`#include "stats.h"`
39	32	lampret	`#include "except.h"`
40	123	markom	`#include "debug_unit.h"`
41	134	markom	`#include "opcode/or32.h"`
42	547	markom	`#include "support/profile.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	538	markom	`static unsigned long *simmem32;`
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	638	simons	`/* These are set by mmu if cache inhibit bit is set for current acces. */`
59			`int data_ci, insn_ci;`
60
61	525	simons	`/* Virtual address of current access. */`
62			`unsigned long cur_vadd;`
63
64	261	markom	`/* Calculates bit mask to fit the data */`
65			`unsigned long bit_mask (unsigned long data) {`
66			`int i = 0;`
67			`data--;`
68	382	markom	`while (data >> i)`
69	261	markom	`data \|= 1 << i++;`
70			`return data;`
71			`}`
72
73			`/* Register read and write function for a memory area.`
74			`addr is inside the area, if addr & addr_mask == addr_compare`
75			`(used also by peripheral devices like 16450 UART etc.) */`
76			`void register_memoryarea_mask(unsigned long addr_mask, unsigned long addr_compare,`
77			`unsigned long size, unsigned granularity,`
78	239	markom	`unsigned long (readfunc)(unsigned long),`
79	261	markom	`void (writefunc)(unsigned long, unsigned long))`
80	30	lampret	`{`
81	239	markom	`struct dev_memarea **pptmp;`
82	261	markom	`unsigned long size_mask = bit_mask (size);`
83			`int found_error = 0;`
84			`addr_compare &= addr_mask;`
85	221	markom
86	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);`
87	239	markom	`/* Go to the end of the list. */`
88	261	markom	`for(pptmp = &dev_list; pptmp; pptmp = &(pptmp)->next)`
89			`if ((addr_compare >= (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)`
90			`\|\| (addr_compare + size > (pptmp)->addr_compare) && (addr_compare < (pptmp)->addr_compare + (*pptmp)->size)) {`
91	262	markom	`if (!found_error) {`
92	261	markom	`fprintf (stderr, "ERROR: Overlapping memory area(s):\n");`
93	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);`
94			`}`
95	261	markom	`found_error = 1;`
96	424	markom	`fprintf (stderr, "and\taddr & %08x == %08x to %08x, size %08x, gran %iB\n", (pptmp)->addr_mask, (pptmp)->addr_compare,`
97	261	markom	`(pptmp)->addr_compare \| (pptmp)->size_mask, (pptmp)->size, (pptmp)->granularity);`
98			`}`
99
100			`if (found_error)`
101			`exit (-1);`
102	537	markom
103	239	markom	`cur_area = pptmp = (struct dev_memarea )malloc(sizeof(struct dev_memarea));`
104	261	markom	`(*pptmp)->addr_mask = addr_mask;`
105			`(*pptmp)->addr_compare = addr_compare;`
106	239	markom	`(*pptmp)->size = size;`
107	261	markom	`(*pptmp)->size_mask = size_mask;`
108	239	markom	`(*pptmp)->granularity = granularity;`
109			`(*pptmp)->readfunc = readfunc;`
110			`(*pptmp)->writefunc = writefunc;`
111	479	markom	`(*pptmp)->log = 0;`
112	882	simons	`(*pptmp)->delayr = 2;`
113			`(*pptmp)->delayw = 2;`
114	239	markom	`(*pptmp)->next = NULL;`
115	261	markom	`}`
116	221	markom
117	261	markom	`/* Register read and write function for a memory area.`
118			`Memory areas should be aligned. Memory area is rounded up to`
119			`fit the nearest 2^n aligment.`
120			`(used also by peripheral devices like 16450 UART etc.) */`
121			`void register_memoryarea(unsigned long addr,`
122			`unsigned long size, unsigned granularity,`
123			`unsigned long (readfunc)(unsigned long),`
124			`void (writefunc)(unsigned long, unsigned long))`
125			`{`
126			`unsigned long size_mask = bit_mask (size);`
127			`unsigned long addr_mask = ~size_mask;`
128			`register_memoryarea_mask (addr_mask, addr & addr_mask,`
129			`size_mask + 1, granularity,`
130			`readfunc, writefunc);`
131	30	lampret	`}`
132
133	261	markom
134	30	lampret	`/* Check if access is to registered area of memory. */`
135	560	markom	`inline struct dev_memarea *verify_memoryarea(unsigned long addr)`
136	30	lampret	`{`
137	239	markom	`struct dev_memarea *ptmp;`
138	221	markom
139	560	markom	`/* Check cached value first */`
140			`if (cur_area && (addr & cur_area->addr_mask) == (cur_area->addr_compare & cur_area->addr_mask))`
141			`return cur_area;`
142
143			`/* When mc is enabled, we must check valid also, otherwise we assume it is nonzero */`
144			`IFF (config.mc.enabled) {`
145			`/* Check list of registered devices. */`
146			`for(ptmp = dev_list; ptmp; ptmp = ptmp->next)`
147			`if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask) && ptmp->valid)`
148			`return cur_area = ptmp;`
149			`} else {`
150			`/* Check list of registered devices. */`
151			`for(ptmp = dev_list; ptmp; ptmp = ptmp->next)`
152			`if ((addr & ptmp->addr_mask) == (ptmp->addr_compare & ptmp->addr_mask))`
153			`return cur_area = ptmp;`
154			`}`
155	239	markom	`return cur_area = NULL;`
156	30	lampret	`}`
157
158	882	simons	`/* Finds the memory area for the address and adjust the read and write delays for it. */`
159			`void adjust_rw_delay(unsigned long memaddr, unsigned long delayr, unsigned long delayw)`
160			`{`
161			`if (verify_memoryarea(memaddr)) {`
162			`cur_area->delayr = delayr;`
163			`cur_area->delayw = delayw;`
164			`}`
165			`}`
166
167	560	markom	`inline unsigned long evalsim_mem32(unsigned long memaddr)`
168			`{`
169			`unsigned long temp;`
170
171			`if (verify_memoryarea(memaddr)) {`
172			`switch(cur_area->granularity) {`
173			`case 4:`
174			`temp = cur_area->readfunc(memaddr);`
175	884	markom	`runtime.sim.mem_cycles += cur_area->delayr;`
176	560	markom	`break;`
177			`case 1:`
178			`temp = cur_area->readfunc(memaddr) << 24;`
179			`temp \|= cur_area->readfunc(memaddr + 1) << 16;`
180			`temp \|= cur_area->readfunc(memaddr + 2) << 8;`
181			`temp \|= cur_area->readfunc(memaddr + 3);`
182	884	markom	`runtime.sim.mem_cycles += cur_area->delayr * 4;`
183	560	markom	`break;`
184			`case 2:`
185			`temp = cur_area->readfunc(memaddr) << 16;`
186			`temp \|= cur_area->readfunc(memaddr + 2);`
187	884	markom	`runtime.sim.mem_cycles += cur_area->delayr * 2;`
188	560	markom	`break;`
189			`}`
190			`}`
191			`return temp;`
192			`}`
193
194			`unsigned short evalsim_mem16(unsigned long memaddr)`
195			`{`
196			`unsigned long temp;`
197
198			`if (verify_memoryarea(memaddr)) {`
199			`switch(cur_area->granularity) {`
200			`case 1:`
201			`temp = cur_area->readfunc(memaddr) << 8;`
202			`temp \|= cur_area->readfunc(memaddr + 1);`
203	884	markom	`runtime.sim.mem_cycles += cur_area->delayr * 2;`
204	560	markom	`break;`
205			`case 2:`
206			`temp = cur_area->readfunc(memaddr);`
207	884	markom	`runtime.sim.mem_cycles += cur_area->delayr;`
208	560	markom	`break;`
209			`case 4:`
210			`temp = evalsim_mem32 (memaddr & ~3ul);`
211			`if (memaddr & 2)`
212			`temp &= 0xffff;`
213			`else`
214			`temp >>= 16;`
215			`break;`
216			`}`
217			`}`
218			`return temp;`
219			`}`
220
221			`unsigned char evalsim_mem8(unsigned long memaddr)`
222			`{`
223			`unsigned long temp;`
224
225			`if (verify_memoryarea(memaddr)) {`
226			`switch(cur_area->granularity) {`
227			`case 1:`
228			`temp = cur_area->readfunc(memaddr);`
229	884	markom	`runtime.sim.mem_cycles += cur_area->delayr;`
230	560	markom	`break;`
231			`case 2:`
232			`temp = evalsim_mem16 (memaddr & ~1ul);`
233			`if (memaddr & 1)`
234			`temp &= 0xff;`
235			`else`
236			`temp >>= 8;`
237			`break;`
238			`case 4:`
239			`temp = evalsim_mem32 (memaddr & ~3ul);`
240			`temp >>= 8 * (3 - (memaddr & 3));`
241			`temp &= 0xff;`
242			`break;`
243			`}`
244			`}`
245			`return temp;`
246			`}`
247
248	2	cvs	`/* Returns 32-bit values from mem array. Big endian version. */`
249	349	simons	`unsigned long read_mem(unsigned long memaddr,int* breakpoint)`
250			`{`
251			`unsigned long temp;`
252			`struct dev_memarea *dev;`
253
254	525	simons	`cur_vadd = memaddr;`
255	550	markom	`if (config.debug.enabled)`
256	349	simons	`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
257			`temp = evalsim_mem32(memaddr);`
258	611	simons	`if (!cur_area) {`
259			`printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
260			`except_handle(EXCEPT_BUSERR, cur_vadd);`
261			`temp = 0;`
262			`}`
263
264	599	simons	`if (!pending.valid && cur_area->log)`
265	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
266	550	markom	`if (config.debug.enabled)`
267	349	simons	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
268			`return temp;`
269	537	markom	`}`
270	349	simons
271			`/* Returns 32-bit values from mem array. Big endian version. */`
272	123	markom	`unsigned long eval_mem32(unsigned long memaddr,int* breakpoint)`
273	2	cvs	`{`
274	6	lampret
275	239	markom	`unsigned long temp;`
276			`struct dev_memarea *dev;`
277	123	markom
278	547	markom	`if (config.sim.mprofile)`
279			`mprofile (memaddr, MPROF_32 \| MPROF_READ);`
280
281	538	markom	`if (memaddr & 3) {`
282			`except_handle (EXCEPT_ALIGN, memaddr);`
283			`return 0;`
284			`}`
285	557	markom
286	631	simons	`if (config.debug.enabled)`
287			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
288
289	574	markom	`cur_vadd = memaddr;`
290	631	simons
291			`memaddr = dmmu_translate(memaddr, 0);`
292	574	markom	`if (pending.valid)`
293			`return 0;`
294
295	631	simons	`temp = dc_simulate_read(memaddr, 4);`
296	611	simons	`if (!cur_area) {`
297			`printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
298			`except_handle(EXCEPT_BUSERR, cur_vadd);`
299			`temp = 0;`
300			`}`
301
302	599	simons	`if (!pending.valid && cur_area->log)`
303	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
304	550	markom	`if (config.debug.enabled)`
305	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
306	239	markom	`return temp;`
307	66	lampret	`}`
308
309	349	simons	`/* Returns 32-bit values from mem array. Big endian version. */`
310			`unsigned long eval_insn(unsigned long memaddr,int* breakpoint)`
311			`{`
312			`unsigned long temp;`
313			`struct dev_memarea *dev;`
314
315	547	markom	`if (config.sim.mprofile)`
316			`mprofile (memaddr, MPROF_32 \| MPROF_FETCH);`
317	532	markom	`// memaddr = simulate_ic_mmu_fetch(memaddr);`
318	525	simons	`cur_vadd = pc;`
319	550	markom	`if (config.debug.enabled)`
320	349	simons	`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
321	631	simons	`if (config.ic.enabled)`
322			`temp = ic_simulate_fetch(memaddr);`
323			`else`
324			`temp = evalsim_mem32(memaddr);`
325	611	simons	`if (!cur_area) {`
326			`printf("EXCEPTION: read out of memory (32-bit access to %.8lx)\n", memaddr);`
327			`except_handle(EXCEPT_BUSERR, cur_vadd);`
328			`temp = 0;`
329			`}`
330
331	599	simons	`if (!pending.valid && cur_area->log)`
332	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
333	550	markom	`if (config.debug.enabled)`
334	349	simons	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
335			`return temp;`
336			`}`
337
338	2	cvs	`/* Returns 16-bit values from mem array. Big endian version. */`
339
340	123	markom	`unsigned short eval_mem16(unsigned long memaddr,int* breakpoint)`
341	2	cvs	`{`
342	239	markom	`unsigned short temp;`
343	547	markom
344			`if (config.sim.mprofile)`
345			`mprofile (memaddr, MPROF_16 \| MPROF_READ);`
346
347	538	markom	`if (memaddr & 1) {`
348			`except_handle (EXCEPT_ALIGN, memaddr);`
349			`return 0;`
350			`}`
351	574	markom
352	631	simons	`if (config.debug.enabled)`
353			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
354
355	574	markom	`cur_vadd = memaddr;`
356	631	simons
357			`memaddr = dmmu_translate(memaddr, 0);`
358	574	markom	`if (pending.valid)`
359			`return 0;`
360	66	lampret
361	631	simons	`temp = (unsigned short)dc_simulate_read(memaddr, 2);`
362	611	simons	`if (!cur_area) {`
363			`printf("EXCEPTION: read out of memory (16-bit access to %.8lx)\n", memaddr);`
364			`except_handle(EXCEPT_BUSERR, cur_vadd);`
365			`temp = 0;`
366			`}`
367
368	599	simons	`if (!pending.valid && cur_area->log)`
369	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
370	550	markom	`if (config.debug.enabled)`
371	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
372	239	markom	`return temp;`
373	66	lampret	`}`
374
375	6	lampret	`/* Returns 8-bit values from mem array. */`
376	2	cvs
377	123	markom	`unsigned char eval_mem8(unsigned long memaddr,int* breakpoint)`
378	221	markom	`{`
379	631	simons	`unsigned char temp;`
380	547	markom
381			`if (config.sim.mprofile)`
382			`mprofile (memaddr, MPROF_8 \| MPROF_READ);`
383
384	631	simons	`if (config.debug.enabled)`
385			`breakpoint += CheckDebugUnit(DebugLoadAddress,memaddr); / 28/05/01 CZ */`
386
387	525	simons	`cur_vadd = memaddr;`
388	631	simons
389			`memaddr = dmmu_translate(memaddr, 0);`
390	458	simons	`if (pending.valid)`
391			`return 0;`
392	6	lampret
393	631	simons	`temp = (unsigned char)dc_simulate_read(memaddr, 1);`
394	611	simons	`if (!cur_area) {`
395			`printf("EXCEPTION: read out of memory (8-bit access to %.8lx)\n", memaddr);`
396			`except_handle(EXCEPT_BUSERR, cur_vadd);`
397			`temp = 0;`
398			`}`
399
400	599	simons	`if (!pending.valid && cur_area->log)`
401	587	markom	`fprintf (cur_area->log, "[%08x] -> read %08x\n", memaddr, temp);`
402	550	markom	`if (config.debug.enabled)`
403	270	markom	`breakpoint += CheckDebugUnit(DebugLoadData,temp); / MM170901 */`
404	239	markom	`return temp;`
405	66	lampret	`}`
406
407			`void setsim_mem32(unsigned long memaddr, unsigned long value)`
408			`{`
409	239	markom	`struct dev_memarea *dev;`
410	66	lampret
411	239	markom	`if (verify_memoryarea(memaddr)) {`
412			`switch(cur_area->granularity) {`
413	538	markom	`case 4:`
414			`cur_area->writefunc(memaddr, value);`
415	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
416	538	markom	`break;`
417	239	markom	`case 1:`
418	251	erez	`cur_area->writefunc(memaddr , (value >> 24) & 0xFF);`
419	239	markom	`cur_area->writefunc(memaddr + 1, (value >> 16) & 0xFF);`
420	251	erez	`cur_area->writefunc(memaddr + 2, (value >> 8) & 0xFF);`
421			`cur_area->writefunc(memaddr + 3, (value ) & 0xFF);`
422	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 4;`
423	239	markom	`break;`
424			`case 2:`
425			`cur_area->writefunc(memaddr, (value >> 16) & 0xFFFF);`
426			`cur_area->writefunc(memaddr + 2, value & 0xFFFF);`
427	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 2;`
428	239	markom	`break;`
429	242	markom	`}`
430	239	markom	`} else {`
431			`printf("EXCEPTION: write out of memory (32-bit access to %.8lx)\n", memaddr);`
432	525	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
433	239	markom	`}`
434	2	cvs	`}`
435
436	66	lampret	`void setsim_mem16(unsigned long memaddr, unsigned short value)`
437			`{`
438	538	markom	`unsigned long temp;`
439	239	markom	`if (verify_memoryarea(memaddr)) {`
440			`switch(cur_area->granularity) {`
441			`case 1:`
442			`cur_area->writefunc(memaddr, (value >> 8) & 0xFF);`
443			`cur_area->writefunc(memaddr + 1, value & 0xFF);`
444	884	markom	`runtime.sim.mem_cycles += cur_area->delayw * 2;`
445	239	markom	`break;`
446			`case 2:`
447	251	erez	`cur_area->writefunc(memaddr, value & 0xFFFF);`
448	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
449	239	markom	`break;`
450			`case 4:`
451	538	markom	`temp = evalsim_mem32 (memaddr & ~3ul);`
452	546	simons	`temp &= 0xffff << ((memaddr & 2) ? 16 : 0);`
453			`temp \|= (unsigned long)(value & 0xffff) << ((memaddr & 2) ? 0 : 16);`
454	538	markom	`setsim_mem32 (memaddr & ~3ul, temp);`
455	239	markom	`break;`
456			`}`
457			`} else {`
458			`printf("EXCEPTION: write out of memory (16-bit access to %.8lx)\n", memaddr);`
459	525	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
460	239	markom	`}`
461	2	cvs	`}`
462
463	66	lampret	`void setsim_mem8(unsigned long memaddr, unsigned char value)`
464			`{`
465	538	markom	`unsigned long temp;`
466	239	markom	`if (verify_memoryarea(memaddr)) {`
467	538	markom	`switch (cur_area->granularity) {`
468			`case 1:`
469	239	markom	`cur_area->writefunc(memaddr, value);`
470	884	markom	`runtime.sim.mem_cycles += cur_area->delayw;`
471	538	markom	`break;`
472			`case 2:`
473			`temp = evalsim_mem16 (memaddr & ~1ul);`
474	546	simons	`temp &= 0xff << ((memaddr & 1) ? 8 : 0);`
475			`temp \|= (unsigned short)(value & 0xff) << ((memaddr & 1) ? 0 : 8);`
476	538	markom	`setsim_mem16 (memaddr & ~1ul, temp);`
477			`break;`
478			`case 4:`
479			`temp = evalsim_mem32 (memaddr & ~3ul);`
480			`temp &= ~(0xff << (8 * (3 - (memaddr & 3))));`
481			`temp \|= (unsigned long)(value & 0xff) << (8 * (3 - (memaddr & 3)));`
482			`setsim_mem32 (memaddr & ~3ul, temp);`
483			`break;`
484	239	markom	`}`
485			`} else {`
486			`printf("EXCEPTION: write out of memory (8-bit access to %.8lx)\n", memaddr);`
487	525	simons	`except_handle(EXCEPT_BUSERR, cur_vadd);`
488	239	markom	`}`
489	2	cvs	`}`
490	30	lampret
491	587	markom	`/* Set mem, 32-bit. Big endian version. */`
492
493			`void set_mem32(unsigned long memaddr, unsigned long value,int* breakpoint)`
494			`{`
495			`if (config.sim.mprofile)`
496			`mprofile (memaddr, MPROF_32 \| MPROF_WRITE);`
497
498			`if (memaddr & 3) {`
499			`except_handle (EXCEPT_ALIGN, memaddr);`
500			`return;`

Browse

Tools

Subversion Repositories or1k

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