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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [orpsocv2/] [bench/] [sysc/] [src/] [MemoryLoad.cpp] - Blame information for rev 500

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


/* MemoryLoad.cpp -- Program load functions
 
   Copyright (C) 1999 Damjan Lampret, lampret@opencores.org
   Copyright (C) 2008 Embecosm Limited
   Copyright (C) 2009 Julius Baxter, julius@orsoc.se
 
   Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>
 
   This file is part of Or1ksim, the 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. */
 
/* System includes */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#include "MemoryLoad.h"
#include "OrpsocMain.h"
 
//! Constructor for the ORPSoC memory loader class
 
//! Initializes various values
 
//! @param[in] orpsoc  The SystemC Verilated ORPSoC instance
//! @param[in] accessor  Accessor class for this Verilated ORPSoC model
 
MemoryLoad::MemoryLoad(OrpsocAccess * _accessor)
{
        accessor = _accessor;
}                               // MemoryAccess ()
 
/*---------------------------------------------------------------------------*/
/*!Copy a string with null termination
 
   This function is very similar to strncpy, except it null terminates the
   string. A global function also used by the CUC.
 
   @param[in] dst  The destination string
   @param[in] src  The source string
   @param[in] n    Number of chars to copy EXCLUDING the null terminator
                   (i.e. dst had better have room for n+1 chars)
 
   @return  A pointer to dst                                                 */
/*---------------------------------------------------------------------------*/
char *MemoryLoad::strstrip(char *dst, const char *src, int n)
{
        strncpy(dst, src, n);
        *(dst + n) = '\0';
 
        return dst;
 
}                               /* strstrip () */
 
#if IMM_STATS
int MemoryLoad::bits(uint32_t val)
{
        int i = 1;
        if (!val)
                return 0;
        while (val != 0 && (int32_t) val != -1) {
                i++;
                val = (int32_t) val >> 1;
        }
        return i;
}
 
void MemoryLoad::check_insn(uint32_t insn)
{
        int insn_index = insn_decode(insn);
        struct insn_op_struct *opd = op_start[insn_index];
        uint32_t data = 0;
        int dis = 0;
        const char *name;
        if (!insn || insn_index < 0)
                return;
        name = insn_name(insn_index);
        if (strcmp(name, "l.nop") == 0 || strcmp(name, "l.sys") == 0)
                return;
 
        while (1) {
                uint32_t tmp = 0 unsigned int nbits = 0;
                while (1) {
                        tmp |=
                            ((insn >> (opd->type & OPTYPE_SHR)) &
                             ((1 << opd->data) - 1)) << nbits;
                        nbits += opd->data;
                        if (opd->type & OPTYPE_OP)
                                break;
                        opd++;
                }
 
                /* Do we have to sign extend? */
                if (opd->type & OPTYPE_SIG) {
                        int sbit = (opd->type & OPTYPE_SBIT) >> OPTYPE_SBIT_SHR;
                        if (tmp & (1 << sbit))
                                tmp |= 0xFFFFFFFF << sbit;
                }
                if (opd->type & OPTYPE_DIS) {
                        /* We have to read register later.  */
                        data += tmp;
                        dis = 1;
                } else {
                        if (!(opd->type & OPTYPE_REG) || dis) {
                                if (!dis)
                                        data = tmp;
                                if (strcmp(name, "l.movhi") == 0) {
                                        movhi = data << 16;
                                } else {
                                        data |= movhi;
                                        //PRINTF ("%08x %s\n", data, name);
                                        if (!
                                            (or32_opcodes[insn_index].flags &
                                             OR32_IF_DELAY)) {
                                                bcnt[bits(data)][0]++;
                                                bsum[0]++;
                                        } else {
                                                if (strcmp(name, "l.bf") == 0
                                                    || strcmp(name,
                                                              "l.bnf") == 0) {
                                                        bcnt[bits(data)][1]++;
                                                        bsum[1]++;
                                                } else {
                                                        bcnt[bits(data)][2]++;
                                                        bsum[2]++;
                                                }
                                        }
                                }
                        }
                        data = 0;
                        dis = 0;
                }
                if (opd->type & OPTYPE_LAST) {
                        return;
                }
                opd++;
        }
}
#endif
 
/*---------------------------------------------------------------------------*/
/*!Add an instruction to the program
 
  @note insn must be in big endian format
 
  @param[in] address     The address to use
  @param[in] insn        The instruction to add                              */
/*---------------------------------------------------------------------------*/
void MemoryLoad::addprogram(oraddr_t address, uint32_t insn)
{
 
        int vaddr = (int)address;
        /* Use the whole-word write */
        accessor->set_mem32(vaddr, insn);
        /*printf("*  addprogram: addr 0x%.8x insn: 0x%.8x (conf: 0x%.8x)\n",
           vaddr, insn, accessor->get_mem32(vaddr)); */
        freemem += 4;
 
}                               /* addprogram () */
 
/*---------------------------------------------------------------------------*/
/*!Load big-endian COFF file
 
   @param[in] filename  File to load
   @param[in] sections  Number of sections in file                           */
/*---------------------------------------------------------------------------*/
void MemoryLoad::readfile_coff(char *filename, short sections)
{
        FILE *inputfs;
        char inputbuf[4];
        uint32_t insn;
        int32_t sectsize;
        COFF_AOUTHDR coffaouthdr;
        struct COFF_scnhdr coffscnhdr;
        int len;
        int firstthree = 0;
        int breakpoint = 0;
 
        if (!(inputfs = fopen(filename, "r"))) {
                perror("readfile_coff");
                exit(1);
        }
 
        if (fseek(inputfs, sizeof(COFF_FILHDR), SEEK_SET) == -1) {
                fclose(inputfs);
                perror("readfile_coff");
                exit(1);
        }
 
        if (fread(&coffaouthdr, sizeof(coffaouthdr), 1, inputfs) != 1) {
                fclose(inputfs);
                perror("readfile_coff");
                exit(1);
        }
 
        while (sections--) {
                uint32_t scnhdr_pos =
                    sizeof(COFF_FILHDR) + sizeof(coffaouthdr) +
                    sizeof(struct COFF_scnhdr) * firstthree;
                if (fseek(inputfs, scnhdr_pos, SEEK_SET) == -1) {
                        fclose(inputfs);
                        perror("readfile_coff");
                        exit(1);
                }
                if (fread(&coffscnhdr, sizeof(struct COFF_scnhdr), 1, inputfs)
                    != 1) {
                        fclose(inputfs);
                        perror("readfile_coff");
                        exit(1);
                }
                PRINTF("Section: %s,", coffscnhdr.s_name);
                PRINTF(" paddr: 0x%.8lx,", COFF_LONG_H(coffscnhdr.s_paddr));
                PRINTF(" vaddr: 0x%.8lx,", COFF_LONG_H(coffscnhdr.s_vaddr));
                PRINTF(" size: 0x%.8lx,", COFF_LONG_H(coffscnhdr.s_size));
                PRINTF(" scnptr: 0x%.8lx\n", COFF_LONG_H(coffscnhdr.s_scnptr));
 
                sectsize = COFF_LONG_H(coffscnhdr.s_size);
                ++firstthree;
 
                /* loading section */
                freemem = COFF_LONG_H(coffscnhdr.s_paddr);
                if (fseek(inputfs, COFF_LONG_H(coffscnhdr.s_scnptr), SEEK_SET)
                    == -1) {
                        fclose(inputfs);
                        perror("readfile_coff");
                        exit(1);
                }
                while (sectsize > 0
                       && (len =
                           fread(&inputbuf, sizeof(inputbuf), 1, inputfs))) {
                        insn = COFF_LONG_H(inputbuf);
                        //len = insn_len (insn_decode (insn));
                        len = 4;
                        if (len == 2) {
                                fseek(inputfs, -2, SEEK_CUR);
                        }
 
                        addprogram(freemem, insn);
                        sectsize -= len;
                }
        }
        if (firstthree < 3) {
                PRINTF("One or more missing sections. At least");
                PRINTF(" three sections expected (.text, .data, .bss).\n");
                exit(1);
        }
        if (firstthree > 3) {
                PRINTF("Warning: one or more extra sections. These");
                PRINTF(" sections were handled as .data sections.\n");
        }
 
        fclose(inputfs);
        PRINTF("Finished loading COFF.\n");
        return;
 
}                               /* readfile_coff () */
 
/*---------------------------------------------------------------------------*/
/*!Load symbols from big-endian COFF file
 
   @param[in] filename  File to load
   @param[in] symptr    Symbol pointer value
   @param[in] syms      Symbols value                                        */
/*---------------------------------------------------------------------------*/
 
void MemoryLoad::readsyms_coff(char *filename, uint32_t symptr, uint32_t syms)
{
        FILE *inputfs;
        struct COFF_syment coffsymhdr;
        int count = 0;
        uint32_t nsyms = syms;
        if (!(inputfs = fopen(filename, "r"))) {
                perror("readsyms_coff");
                exit(1);
        }
 
        if (fseek(inputfs, symptr, SEEK_SET) == -1) {
                fclose(inputfs);
                perror("readsyms_coff");
                exit(1);
        }
 
        while (syms--) {
                int i, n;
                if (fread(&coffsymhdr, COFF_SYMESZ, 1, inputfs) != 1) {
                        fclose(inputfs);
                        perror("readsyms_coff");
                        exit(1);
                }
 
                n = (unsigned char)coffsymhdr.e_numaux[0];
 
                /* check whether this symbol belongs to a section and is external
                   symbol; ignore all others */
                if (COFF_SHORT_H(coffsymhdr.e_scnum) >= 0
                    && coffsymhdr.e_sclass[0] == C_EXT) {
                        if (*((uint32_t *) coffsymhdr.e.e.e_zeroes)) {
                                if (strlen(coffsymhdr.e.e_name)
                                    && strlen(coffsymhdr.e.e_name) < 9)
                                        add_label(COFF_LONG_H
                                                  (coffsymhdr.e_value),
                                                  coffsymhdr.e.e_name);
                        } else {
                                uint32_t fpos = ftell(inputfs);
 
                                if (fseek
                                    (inputfs,
                                     symptr + nsyms * COFF_SYMESZ +
                                     COFF_LONG_H(coffsymhdr.e.e.e_offset),
                                     SEEK_SET) == 0) {
                                        char tmp[33], *s = &tmp[0];
                                        while (s != &tmp[32])
                                                if ((*(s++) =
                                                     fgetc(inputfs)) == 0)
                                                        break;
                                        tmp[32] = 0;
                                        add_label(COFF_LONG_H
                                                  (coffsymhdr.e_value),
                                                  &tmp[0]);
                                }
                                fseek(inputfs, fpos, SEEK_SET);
                        }
                }
 
                for (i = 0; i < n; i++)
                        if (fread(&coffsymhdr, COFF_SYMESZ, 1, inputfs) != 1) {
                                fclose(inputfs);
                                perror("readsyms_coff3");
                                exit(1);
                        }
                syms -= n;
                count += n;
        }
 
        fclose(inputfs);
        PRINTF("Finished loading symbols.\n");
        return;
}
 
/*---------------------------------------------------------------------------*/
/*!Read an ELF file
 
   @param[in] filename  File to load                                         */
/*---------------------------------------------------------------------------*/
void MemoryLoad::readfile_elf(char *filename)
{
 
        FILE *inputfs;
        struct elf32_hdr elfhdr;
        struct elf32_phdr *elf_phdata = NULL;
        struct elf32_shdr *elf_spnt, *elf_shdata;
        struct elf32_sym *sym_tbl = (struct elf32_sym *)0;
        uint32_t syms = 0;
        char *str_tbl = (char *)0;
        char *s_str = (char *)0;
        int breakpoint = 0;
        uint32_t inputbuf;
        uint32_t padd;
        uint32_t insn;
        int i, j, sectsize, len;
 
        if (!(inputfs = fopen(filename, "r"))) {
                perror("readfile_elf");
                exit(1);
        }
 
        if (fread(&elfhdr, sizeof(elfhdr), 1, inputfs) != 1) {
                perror("readfile_elf");
                exit(1);
        }
 
        if ((elf_shdata =
             (struct elf32_shdr *)malloc(ELF_SHORT_H(elfhdr.e_shentsize) *
                                         ELF_SHORT_H(elfhdr.e_shnum))) == NULL)
        {
                perror("readfile_elf");
                exit(1);
        }
 
        if (fseek(inputfs, ELF_LONG_H(elfhdr.e_shoff), SEEK_SET) != 0) {
                perror("readfile_elf");
                exit(1);
        }
 
        if (fread
            (elf_shdata,
             ELF_SHORT_H(elfhdr.e_shentsize) * ELF_SHORT_H(elfhdr.e_shnum), 1,
             inputfs) != 1) {
                perror("readfile_elf");
                exit(1);
        }
 
        if (ELF_LONG_H(elfhdr.e_phoff)) {
                if ((elf_phdata =
                     (struct elf32_phdr *)malloc(ELF_SHORT_H(elfhdr.e_phnum) *
                                                 ELF_SHORT_H
                                                 (elfhdr.e_phentsize))) ==
                    NULL) {
                        perror("readfile_elf");
                        exit(1);
                }
 
                if (fseek(inputfs, ELF_LONG_H(elfhdr.e_phoff), SEEK_SET) != 0) {
                        perror("readfile_elf");
                        exit(1);
                }
 
                if (fread
                    (elf_phdata,
                     ELF_SHORT_H(elfhdr.e_phnum) *
                     ELF_SHORT_H(elfhdr.e_phentsize), 1, inputfs) != 1) {
                        perror("readfile_elf");
                        exit(1);
                }
        }
 
        for (i = 0, elf_spnt = elf_shdata; i < ELF_SHORT_H(elfhdr.e_shnum);
             i++, elf_spnt++) {
 
                if (ELF_LONG_H(elf_spnt->sh_type) == SHT_STRTAB) {
                        if (NULL != str_tbl) {
                                free(str_tbl);
                        }
 
                        if ((str_tbl =
                             (char *)malloc(ELF_LONG_H(elf_spnt->sh_size))) ==
                            NULL) {
                                perror("readfile_elf");
                                exit(1);
                        }
 
                        if (fseek
                            (inputfs, ELF_LONG_H(elf_spnt->sh_offset),
                             SEEK_SET) != 0) {
                                perror("readfile_elf");
                                exit(1);
                        }
 
                        if (fread
                            (str_tbl, ELF_LONG_H(elf_spnt->sh_size), 1,
                             inputfs) != 1) {
                                perror("readfile_elf");
                                exit(1);
                        }
                } else if (ELF_LONG_H(elf_spnt->sh_type) == SHT_SYMTAB) {
 
                        if (NULL != sym_tbl) {
                                free(sym_tbl);
                        }
 
                        if ((sym_tbl = (struct elf32_sym *)
                             malloc(ELF_LONG_H(elf_spnt->sh_size)))
                            == NULL) {
                                perror("readfile_elf");
                                exit(1);
                        }
 
                        if (fseek
                            (inputfs, ELF_LONG_H(elf_spnt->sh_offset),
                             SEEK_SET) != 0) {
                                perror("readfile_elf");
                                exit(1);
                        }
 
                        if (fread
                            (sym_tbl, ELF_LONG_H(elf_spnt->sh_size), 1,
                             inputfs) != 1) {
                                perror("readfile_elf");
                                exit(1);
                        }
 
                        syms =
                            ELF_LONG_H(elf_spnt->sh_size) /
                            ELF_LONG_H(elf_spnt->sh_entsize);
                }
        }
 
        if (ELF_SHORT_H(elfhdr.e_shstrndx) != SHN_UNDEF) {
                elf_spnt = &elf_shdata[ELF_SHORT_H(elfhdr.e_shstrndx)];
 
                if ((s_str =
                     (char *)malloc(ELF_LONG_H(elf_spnt->sh_size))) == NULL) {
                        perror("readfile_elf");
                        exit(1);
                }
 
                if (fseek(inputfs, ELF_LONG_H(elf_spnt->sh_offset), SEEK_SET) !=
                    0) {
                        perror("readfile_elf");
                        exit(1);
                }
 
                if (fread(s_str, ELF_LONG_H(elf_spnt->sh_size), 1, inputfs) !=
                    1) {
                        perror("readfile_elf");
                        exit(1);
                }
        }
 
        for (i = 0, elf_spnt = elf_shdata; i < ELF_SHORT_H(elfhdr.e_shnum);
             i++, elf_spnt++) {
 
                if ((ELF_LONG_H(elf_spnt->sh_type) & SHT_PROGBITS)
                    && (ELF_LONG_H(elf_spnt->sh_flags) & SHF_ALLOC)) {
 
                        padd = ELF_LONG_H(elf_spnt->sh_addr);
                        for (j = 0; j < ELF_SHORT_H(elfhdr.e_phnum); j++) {
                                if (ELF_LONG_H(elf_phdata[j].p_offset) &&
                                    ELF_LONG_H(elf_phdata[j].p_offset) <=
                                    ELF_LONG_H(elf_spnt->sh_offset)
                                    && (ELF_LONG_H(elf_phdata[j].p_offset) +
                                        ELF_LONG_H(elf_phdata[j].p_memsz)) >
                                    ELF_LONG_H(elf_spnt->sh_offset))
                                        padd =
                                            ELF_LONG_H(elf_phdata[j].p_paddr) +
                                            ELF_LONG_H(elf_spnt->sh_offset) -
                                            ELF_LONG_H(elf_phdata[j].p_offset);
                        }
 
                        if (!gQuiet)
                        {
                                if (ELF_LONG_H(elf_spnt->sh_name) && s_str)
                                        printf("* Section: %s,",
                                               &s_str[ELF_LONG_H(elf_spnt->sh_name)]);
                                else
                                        printf("* Section: noname,");
                                printf("* vaddr: 0x%.8lx,",
                                       ELF_LONG_H(elf_spnt->sh_addr));
                                printf("* paddr: 0x%" PRIx32, padd);
                                printf("* offset: 0x%.8lx,",
                                       ELF_LONG_H(elf_spnt->sh_offset));
                                printf("* size: 0x%.8lx\n",
                                       ELF_LONG_H(elf_spnt->sh_size));
                        }
 
                        freemem = padd;
                        sectsize = ELF_LONG_H(elf_spnt->sh_size);
 
                        if (fseek
                            (inputfs, ELF_LONG_H(elf_spnt->sh_offset),
                             SEEK_SET) != 0) {
                                perror("readfile_elf");
                                free(elf_phdata);
                                exit(1);
                        }
 
                        while (sectsize > 0
                               && (len =
                                   fread(&inputbuf, sizeof(inputbuf), 1,
                                         inputfs))) {
                                insn = ELF_LONG_H(inputbuf);
                                //PRINTF("* addprogram(%.8x, %.8x, %d)\n", freemem, insn, breakpoint);
                                addprogram(freemem, insn);
                                sectsize -= 4;
                        }
                }
        }
 
        if (str_tbl) {
                i = 0;
                while (syms--) {
                        if (sym_tbl[i].st_name && sym_tbl[i].st_info
                            && ELF_SHORT_H(sym_tbl[i].st_shndx) < 0x8000) {
                                add_label(ELF_LONG_H(sym_tbl[i].st_value),
                                          &str_tbl[ELF_LONG_H
                                                   (sym_tbl[i].st_name)]);
                        }
                        i++;
                }
        }
 
        if (NULL != str_tbl) {
                free(str_tbl);
        }
 
        if (NULL != sym_tbl) {
                free(sym_tbl);
        }
 
        free(s_str);
        free(elf_phdata);
        free(elf_shdata);
 
}
 
/* Identify file type and call appropriate readfile_X routine. It only
handles orX-coff-big executables at the moment. */
 
void MemoryLoad::identifyfile(char *filename)
{
        FILE *inputfs;
        COFF_FILHDR coffhdr;
        struct elf32_hdr elfhdr;
 
        if (!(inputfs = fopen(filename, "r"))) {
                perror(filename);
                fflush(stdout);
                fflush(stderr);
                exit(1);
        }
 
        if (fread(&coffhdr, sizeof(coffhdr), 1, inputfs) == 1) {
                if (COFF_SHORT_H(coffhdr.f_magic) == 0x17a) {
                        uint32_t opthdr_size;
                        PRINTF("COFF magic: 0x%.4x\n",
                               COFF_SHORT_H(coffhdr.f_magic));
                        PRINTF("COFF flags: 0x%.4x\n",
                               COFF_SHORT_H(coffhdr.f_flags));
                        PRINTF("COFF symptr: 0x%.8lx\n",
                               COFF_LONG_H(coffhdr.f_symptr));
                        if ((COFF_SHORT_H(coffhdr.f_flags) & COFF_F_EXEC) !=
                            COFF_F_EXEC) {
                                PRINTF("This COFF is not an executable.\n");
                                exit(1);
                        }
                        opthdr_size = COFF_SHORT_H(coffhdr.f_opthdr);
                        if (opthdr_size != sizeof(COFF_AOUTHDR)) {
                                PRINTF
                                    ("COFF optional header is missing or not recognized.\n");
                                PRINTF("COFF f_opthdr: 0x%" PRIx32 "\n",
                                       opthdr_size);
                                exit(1);
                        }
                        fclose(inputfs);
                        readfile_coff(filename, COFF_SHORT_H(coffhdr.f_nscns));
                        readsyms_coff(filename, COFF_LONG_H(coffhdr.f_symptr),
                                      COFF_LONG_H(coffhdr.f_nsyms));
                        return;
                } else {
                        PRINTF("Not COFF file format\n");
                        fseek(inputfs, 0, SEEK_SET);
                }
        }
        if (fread(&elfhdr, sizeof(elfhdr), 1, inputfs) == 1) {
                if (elfhdr.e_ident[0] == 0x7f && elfhdr.e_ident[1] == 0x45
                    && elfhdr.e_ident[2] == 0x4c && elfhdr.e_ident[3] == 0x46) {
                        PRINTF("ELF type: 0x%.4x\n",
                               ELF_SHORT_H(elfhdr.e_type));
                        PRINTF("ELF machine: 0x%.4x\n",
                               ELF_SHORT_H(elfhdr.e_machine));
                        PRINTF("ELF version: 0x%.8lx\n",
                               ELF_LONG_H(elfhdr.e_version));
                        PRINTF("ELF sec = %d\n", ELF_SHORT_H(elfhdr.e_shnum));
                        if (ELF_SHORT_H(elfhdr.e_type) != ET_EXEC) {
                                PRINTF("This ELF is not an executable.\n");
                                exit(1);
                        }
                        fclose(inputfs);
                        readfile_elf(filename);
                        return;
                } else {
                        PRINTF("Not ELF file format.\n");
                        fseek(inputfs, 0, SEEK_SET);
                }
        }
 
        perror("identifyfile2");
        fclose(inputfs);
 
        return;
}
 
/*---------------------------------------------------------------------------*/
/*!Load file to memory
 
   Loads file to memory starting at address startaddr and returns freemem.
 
   @param[in] filename        File to load
   @param[in] startaddr       Start address at which to load
   @param[in] virtphy_transl  Virtual to physical transation table if
                              required. Only used for microkernel simulation,
                              and not used in Ork1sim at present (set to NULL)
 
   @return  zero on success, negative on failure.                            */
/*---------------------------------------------------------------------------*/
uint32_t
    MemoryLoad::loadcode(char *filename, oraddr_t startaddr,
                         oraddr_t virtphy_transl)
{
 
        init_labels();          // jb
 
        transl_table = virtphy_transl;
        freemem = startaddr;
        /*printf ("*  MemoryLoad::loadcode: filename %s  startaddr=%" PRIxADDR "  virtphy_transl=%" PRIxADDR "\n", filename, startaddr, virtphy_transl); */
 
        identifyfile(filename);
 
        return (uint32_t) freemem;
 
}
 
/* From arch sim labels.c */
void
 MemoryLoad::init_labels()
{
        int i;
        for (i = 0; i < LABELS_HASH_SIZE; i++)
                label_hash[i] = NULL;
}
 
void MemoryLoad::add_label(oraddr_t addr, char *name)
{
        struct label_entry **tmp;
        tmp = &(label_hash[addr % LABELS_HASH_SIZE]);
        for (; *tmp; tmp = &((*tmp)->next)) ;
        *tmp = (label_entry *) malloc(sizeof(**tmp));
        (*tmp)->name = (char *)malloc(strlen(name) + 1);
        (*tmp)->addr = addr;
        strcpy((*tmp)->name, name);
        (*tmp)->next = NULL;
}
 
struct label_entry *MemoryLoad::get_label(oraddr_t addr)
{
        struct label_entry *tmp = label_hash[addr % LABELS_HASH_SIZE];
        while (tmp) {
                if (tmp->addr == addr)
                        return tmp;
                tmp = tmp->next;
        }
        return NULL;
}
 
struct label_entry *MemoryLoad::find_label(char *name)
{
        int i;
        for (i = 0; i < LABELS_HASH_SIZE; i++) {
                struct label_entry *tmp = label_hash[i % LABELS_HASH_SIZE];
                while (tmp) {
                        if (strcmp(tmp->name, name) == 0)
                                return tmp;
                        tmp = tmp->next;
                }
        }
        return NULL;
}
 
/* Searches mem array for a particular label and returns label's address.
   If label does not exist, returns 0. */
oraddr_t MemoryLoad::eval_label(char *name)
{
        struct label_entry *le;
        char *plus;
        char *minus;
        int positive_offset = 0;
        int negative_offset = 0;
 
        if ((plus = strchr(name, '+'))) {
                *plus = '\0';
                positive_offset = atoi(++plus);
        }
 
        if ((minus = strchr(name, '-'))) {
                *minus = '\0';
                negative_offset = atoi(++minus);
        }
        le = find_label(name);
        if (!le)
                return 0;
 
        return le->addr + positive_offset - negative_offset;
}

Line No.	Rev	Author	Line
1	51	julius	`/* MemoryLoad.cpp -- Program load functions`
2
3			`Copyright (C) 1999 Damjan Lampret, lampret@opencores.org`
4			`Copyright (C) 2008 Embecosm Limited`
5			`Copyright (C) 2009 Julius Baxter, julius@orsoc.se`
6
7			`Contributor Jeremy Bennett <jeremy.bennett@embecosm.com>`
8
9			`This file is part of Or1ksim, the 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
24			`/* This program is commented throughout in a fashion suitable for processing`
25			`with Doxygen. */`
26
27			`/* System includes */`
28			`#include <stdio.h>`
29			`#include <stdlib.h>`
30			`#include <string.h>`
31
32			`#include "MemoryLoad.h"`
33			`#include "OrpsocMain.h"`
34
35			`//! Constructor for the ORPSoC memory loader class`
36
37			`//! Initializes various values`
38
39			`//! @param[in] orpsoc The SystemC Verilated ORPSoC instance`
40			`//! @param[in] accessor Accessor class for this Verilated ORPSoC model`
41
42	462	julius	`MemoryLoad::MemoryLoad(OrpsocAccess * _accessor)`
43	51	julius	`{`
44	462	julius	`accessor = _accessor;`
45			`} // MemoryAccess ()`
46	51	julius
47			`/---------------------------------------------------------------------------/`
48			`/*!Copy a string with null termination`
49
50			`This function is very similar to strncpy, except it null terminates the`
51			`string. A global function also used by the CUC.`
52
53			`@param[in] dst The destination string`
54			`@param[in] src The source string`
55			`@param[in] n Number of chars to copy EXCLUDING the null terminator`
56			`(i.e. dst had better have room for n+1 chars)`
57
58			`@return A pointer to dst */`
59			`/---------------------------------------------------------------------------/`
60	462	julius	`char MemoryLoad::strstrip(char dst, const char *src, int n)`
61	51	julius	`{`
62	462	julius	`strncpy(dst, src, n);`
63			`*(dst + n) = '\0';`
64	51	julius
65	462	julius	`return dst;`
66	51	julius
67	462	julius	`} /* strstrip () */`
68	51	julius
69	462	julius	`#if IMM_STATS`
70			`int MemoryLoad::bits(uint32_t val)`
71	51	julius	`{`
72	462	julius	`int i = 1;`
73			`if (!val)`
74			`return 0;`
75			`while (val != 0 && (int32_t) val != -1) {`
76			`i++;`
77			`val = (int32_t) val >> 1;`
78	51	julius	`}`
79	462	julius	`return i;`
80	51	julius	`}`
81
82	462	julius	`void MemoryLoad::check_insn(uint32_t insn)`
83	51	julius	`{`
84	462	julius	`int insn_index = insn_decode(insn);`
85			`struct insn_op_struct *opd = op_start[insn_index];`
86			`uint32_t data = 0;`
87			`int dis = 0;`
88			`const char *name;`
89			`if (!insn \|\| insn_index < 0)`
90			`return;`
91			`name = insn_name(insn_index);`
92			`if (strcmp(name, "l.nop") == 0 \|\| strcmp(name, "l.sys") == 0)`
93			`return;`
94	51	julius
95	462	julius	`while (1) {`
96			`uint32_t tmp = 0 unsigned int nbits = 0;`
97			`while (1) {`
98			`tmp \|=`
99			`((insn >> (opd->type & OPTYPE_SHR)) &`
100			`((1 << opd->data) - 1)) << nbits;`
101			`nbits += opd->data;`
102			`if (opd->type & OPTYPE_OP)`
103			`break;`
104			`opd++;`
105			`}`
106	51	julius
107	462	julius	`/* Do we have to sign extend? */`
108			`if (opd->type & OPTYPE_SIG) {`
109			`int sbit = (opd->type & OPTYPE_SBIT) >> OPTYPE_SBIT_SHR;`
110			`if (tmp & (1 << sbit))`
111			`tmp \|= 0xFFFFFFFF << sbit;`
112	51	julius	`}`
113	462	julius	`if (opd->type & OPTYPE_DIS) {`
114			`/* We have to read register later. */`
115			`data += tmp;`
116			`dis = 1;`
117			`} else {`
118			`if (!(opd->type & OPTYPE_REG) \|\| dis) {`
119			`if (!dis)`
120			`data = tmp;`
121			`if (strcmp(name, "l.movhi") == 0) {`
122			`movhi = data << 16;`
123			`} else {`
124			`data \|= movhi;`
125			`//PRINTF ("%08x %s\n", data, name);`
126			`if (!`
127			`(or32_opcodes[insn_index].flags &`
128			`OR32_IF_DELAY)) {`
129			`bcnt[bits(data)][0]++;`
130			`bsum[0]++;`
131			`} else {`
132			`if (strcmp(name, "l.bf") == 0`
133			`\|\| strcmp(name,`
134			`"l.bnf") == 0) {`
135			`bcnt[bits(data)][1]++;`
136			`bsum[1]++;`
137			`} else {`
138			`bcnt[bits(data)][2]++;`
139			`bsum[2]++;`
140			`}`
141			`}`
142			`}`
143	51	julius	`}`
144	462	julius	`data = 0;`
145			`dis = 0;`
146	51	julius	`}`
147	462	julius	`if (opd->type & OPTYPE_LAST) {`
148			`return;`
149			`}`
150			`opd++;`
151	51	julius	`}`
152			`}`
153			`#endif`
154
155			`/---------------------------------------------------------------------------/`
156			`/*!Add an instruction to the program`
157
158			`@note insn must be in big endian format`
159
160			`@param[in] address The address to use`
161	462	julius	`@param[in] insn The instruction to add */`
162	51	julius	`/---------------------------------------------------------------------------/`
163	462	julius	`void MemoryLoad::addprogram(oraddr_t address, uint32_t insn)`
164	51	julius	`{`
165
166	462	julius	`int vaddr = (int)address;`
167			`/* Use the whole-word write */`
168			`accessor->set_mem32(vaddr, insn);`
169			`/printf(" addprogram: addr 0x%.8x insn: 0x%.8x (conf: 0x%.8x)\n",`
170			`vaddr, insn, accessor->get_mem32(vaddr)); */`
171			`freemem += 4;`
172	51	julius
173	462	julius	`} /* addprogram () */`
174
175	51	julius	`/---------------------------------------------------------------------------/`
176			`/*!Load big-endian COFF file`
177
178			`@param[in] filename File to load`
179			`@param[in] sections Number of sections in file */`
180			`/---------------------------------------------------------------------------/`
181	462	julius	`void MemoryLoad::readfile_coff(char *filename, short sections)`
182	51	julius	`{`
183	462	julius	`FILE *inputfs;`
184			`char inputbuf[4];`
185			`uint32_t insn;`
186			`int32_t sectsize;`
187			`COFF_AOUTHDR coffaouthdr;`
188			`struct COFF_scnhdr coffscnhdr;`
189			`int len;`
190			`int firstthree = 0;`
191			`int breakpoint = 0;`
192	51	julius
193	462	julius	`if (!(inputfs = fopen(filename, "r"))) {`
194			`perror("readfile_coff");`
195			`exit(1);`
196			`}`
197	51	julius
198	462	julius	`if (fseek(inputfs, sizeof(COFF_FILHDR), SEEK_SET) == -1) {`
199			`fclose(inputfs);`
200			`perror("readfile_coff");`
201			`exit(1);`
202			`}`
203	51	julius
204	462	julius	`if (fread(&coffaouthdr, sizeof(coffaouthdr), 1, inputfs) != 1) {`
205			`fclose(inputfs);`
206			`perror("readfile_coff");`
207			`exit(1);`
208	51	julius	`}`
209
210	462	julius	`while (sections--) {`
211			`uint32_t scnhdr_pos =`
212			`sizeof(COFF_FILHDR) + sizeof(coffaouthdr) +`
213			`sizeof(struct COFF_scnhdr) * firstthree;`
214			`if (fseek(inputfs, scnhdr_pos, SEEK_SET) == -1) {`
215			`fclose(inputfs);`
216			`perror("readfile_coff");`
217			`exit(1);`
218			`}`
219			`if (fread(&coffscnhdr, sizeof(struct COFF_scnhdr), 1, inputfs)`
220			`!= 1) {`
221			`fclose(inputfs);`
222			`perror("readfile_coff");`
223			`exit(1);`
224			`}`
225			`PRINTF("Section: %s,", coffscnhdr.s_name);`
226			`PRINTF(" paddr: 0x%.8lx,", COFF_LONG_H(coffscnhdr.s_paddr));`
227			`PRINTF(" vaddr: 0x%.8lx,", COFF_LONG_H(coffscnhdr.s_vaddr));`
228			`PRINTF(" size: 0x%.8lx,", COFF_LONG_H(coffscnhdr.s_size));`
229			`PRINTF(" scnptr: 0x%.8lx\n", COFF_LONG_H(coffscnhdr.s_scnptr));`
230	51	julius
231	462	julius	`sectsize = COFF_LONG_H(coffscnhdr.s_size);`
232			`++firstthree;`
233	51	julius
234	462	julius	`/* loading section */`
235			`freemem = COFF_LONG_H(coffscnhdr.s_paddr);`
236			`if (fseek(inputfs, COFF_LONG_H(coffscnhdr.s_scnptr), SEEK_SET)`
237			`== -1) {`
238			`fclose(inputfs);`
239			`perror("readfile_coff");`
240			`exit(1);`
241			`}`
242			`while (sectsize > 0`
243			`&& (len =`
244			`fread(&inputbuf, sizeof(inputbuf), 1, inputfs))) {`
245			`insn = COFF_LONG_H(inputbuf);`
246			`//len = insn_len (insn_decode (insn));`
247			`len = 4;`
248			`if (len == 2) {`
249			`fseek(inputfs, -2, SEEK_CUR);`
250			`}`
251
252			`addprogram(freemem, insn);`
253			`sectsize -= len;`
254			`}`
255	51	julius	`}`
256	462	julius	`if (firstthree < 3) {`
257			`PRINTF("One or more missing sections. At least");`
258			`PRINTF(" three sections expected (.text, .data, .bss).\n");`
259			`exit(1);`
260			`}`
261			`if (firstthree > 3) {`
262			`PRINTF("Warning: one or more extra sections. These");`
263			`PRINTF(" sections were handled as .data sections.\n");`
264			`}`
265	51	julius
266	462	julius	`fclose(inputfs);`
267			`PRINTF("Finished loading COFF.\n");`
268			`return;`
269	51	julius
270	462	julius	`} /* readfile_coff () */`
271	51	julius
272			`/---------------------------------------------------------------------------/`
273			`/*!Load symbols from big-endian COFF file`
274
275			`@param[in] filename File to load`
276			`@param[in] symptr Symbol pointer value`
277			`@param[in] syms Symbols value */`
278			`/---------------------------------------------------------------------------/`
279
280	462	julius	`void MemoryLoad::readsyms_coff(char *filename, uint32_t symptr, uint32_t syms)`
281	51	julius	`{`
282	462	julius	`FILE *inputfs;`
283			`struct COFF_syment coffsymhdr;`
284			`int count = 0;`
285			`uint32_t nsyms = syms;`
286			`if (!(inputfs = fopen(filename, "r"))) {`
287			`perror("readsyms_coff");`
288			`exit(1);`
289			`}`
290	51	julius
291	462	julius	`if (fseek(inputfs, symptr, SEEK_SET) == -1) {`
292			`fclose(inputfs);`
293			`perror("readsyms_coff");`
294			`exit(1);`
295	51	julius	`}`
296
297	462	julius	`while (syms--) {`
298			`int i, n;`
299			`if (fread(&coffsymhdr, COFF_SYMESZ, 1, inputfs) != 1) {`
300			`fclose(inputfs);`
301			`perror("readsyms_coff");`
302			`exit(1);`
303			`}`
304	51	julius
305	462	julius	`n = (unsigned char)coffsymhdr.e_numaux[0];`
306	51	julius
307	462	julius	`/* check whether this symbol belongs to a section and is external`
308			`symbol; ignore all others */`
309			`if (COFF_SHORT_H(coffsymhdr.e_scnum) >= 0`
310			`&& coffsymhdr.e_sclass[0] == C_EXT) {`
311			`if (((uint32_t ) coffsymhdr.e.e.e_zeroes)) {`
312			`if (strlen(coffsymhdr.e.e_name)`
313			`&& strlen(coffsymhdr.e.e_name) < 9)`
314			`add_label(COFF_LONG_H`
315			`(coffsymhdr.e_value),`
316			`coffsymhdr.e.e_name);`
317			`} else {`
318			`uint32_t fpos = ftell(inputfs);`
319
320			`if (fseek`
321			`(inputfs,`
322			`symptr + nsyms * COFF_SYMESZ +`
323			`COFF_LONG_H(coffsymhdr.e.e.e_offset),`
324			`SEEK_SET) == 0) {`
325			`char tmp[33], *s = &tmp[0];`
326			`while (s != &tmp[32])`
327			`if ((*(s++) =`
328			`fgetc(inputfs)) == 0)`
329			`break;`
330			`tmp[32] = 0;`
331			`add_label(COFF_LONG_H`
332			`(coffsymhdr.e_value),`
333			`&tmp[0]);`
334			`}`
335			`fseek(inputfs, fpos, SEEK_SET);`
336			`}`
337	51	julius	`}`
338	462	julius
339			`for (i = 0; i < n; i++)`
340			`if (fread(&coffsymhdr, COFF_SYMESZ, 1, inputfs) != 1) {`
341			`fclose(inputfs);`
342			`perror("readsyms_coff3");`
343			`exit(1);`
344			`}`
345			`syms -= n;`
346			`count += n;`
347	51	julius	`}`
348
349	462	julius	`fclose(inputfs);`
350			`PRINTF("Finished loading symbols.\n");`
351			`return;`
352	51	julius	`}`
353
354			`/---------------------------------------------------------------------------/`
355			`/*!Read an ELF file`
356
357			`@param[in] filename File to load */`
358			`/---------------------------------------------------------------------------/`
359	462	julius	`void MemoryLoad::readfile_elf(char *filename)`
360	51	julius	`{`
361
362	462	julius	`FILE *inputfs;`
363			`struct elf32_hdr elfhdr;`
364			`struct elf32_phdr *elf_phdata = NULL;`
365			`struct elf32_shdr elf_spnt, elf_shdata;`
366			`struct elf32_sym sym_tbl = (struct elf32_sym )0;`
367			`uint32_t syms = 0;`
368			`char str_tbl = (char )0;`
369			`char s_str = (char )0;`
370			`int breakpoint = 0;`
371			`uint32_t inputbuf;`
372			`uint32_t padd;`
373			`uint32_t insn;`
374			`int i, j, sectsize, len;`
375	51	julius
376	462	julius	`if (!(inputfs = fopen(filename, "r"))) {`
377			`perror("readfile_elf");`
378			`exit(1);`
379			`}`
380	51	julius
381	462	julius	`if (fread(&elfhdr, sizeof(elfhdr), 1, inputfs) != 1) {`
382			`perror("readfile_elf");`
383			`exit(1);`
384			`}`
385	51	julius
386	462	julius	`if ((elf_shdata =`
387			`(struct elf32_shdr )malloc(ELF_SHORT_H(elfhdr.e_shentsize) `
388			`ELF_SHORT_H(elfhdr.e_shnum))) == NULL)`
389	51	julius	`{`
390	462	julius	`perror("readfile_elf");`
391			`exit(1);`
392	51	julius	`}`
393
394	462	julius	`if (fseek(inputfs, ELF_LONG_H(elfhdr.e_shoff), SEEK_SET) != 0) {`
395			`perror("readfile_elf");`
396			`exit(1);`
397	51	julius	`}`
398
399	462	julius	`if (fread`
400			`(elf_shdata,`
401			`ELF_SHORT_H(elfhdr.e_shentsize) * ELF_SHORT_H(elfhdr.e_shnum), 1,`
402			`inputfs) != 1) {`
403			`perror("readfile_elf");`
404			`exit(1);`
405	51	julius	`}`
406
407	462	julius	`if (ELF_LONG_H(elfhdr.e_phoff)) {`
408			`if ((elf_phdata =`
409			`(struct elf32_phdr )malloc(ELF_SHORT_H(elfhdr.e_phnum) `
410			`ELF_SHORT_H`
411			`(elfhdr.e_phentsize))) ==`
412			`NULL) {`
413			`perror("readfile_elf");`
414			`exit(1);`
415			`}`
416	51	julius
417	462	julius	`if (fseek(inputfs, ELF_LONG_H(elfhdr.e_phoff), SEEK_SET) != 0) {`
418			`perror("readfile_elf");`
419			`exit(1);`
420			`}`
421	51	julius
422	462	julius	`if (fread`
423			`(elf_phdata,`
424			`ELF_SHORT_H(elfhdr.e_phnum) *`
425			`ELF_SHORT_H(elfhdr.e_phentsize), 1, inputfs) != 1) {`
426			`perror("readfile_elf");`
427			`exit(1);`
428			`}`
429			`}`
430	51	julius
431	462	julius	`for (i = 0, elf_spnt = elf_shdata; i < ELF_SHORT_H(elfhdr.e_shnum);`
432			`i++, elf_spnt++) {`
433	51	julius
434	462	julius	`if (ELF_LONG_H(elf_spnt->sh_type) == SHT_STRTAB) {`
435			`if (NULL != str_tbl) {`
436			`free(str_tbl);`
437			`}`
438	51	julius
439	462	julius	`if ((str_tbl =`
440			`(char *)malloc(ELF_LONG_H(elf_spnt->sh_size))) ==`
441			`NULL) {`
442			`perror("readfile_elf");`
443			`exit(1);`
444			`}`
445	51	julius
446	462	julius	`if (fseek`
447			`(inputfs, ELF_LONG_H(elf_spnt->sh_offset),`
448			`SEEK_SET) != 0) {`
449			`perror("readfile_elf");`
450			`exit(1);`
451			`}`
452	51	julius
453	462	julius	`if (fread`
454			`(str_tbl, ELF_LONG_H(elf_spnt->sh_size), 1,`
455			`inputfs) != 1) {`
456			`perror("readfile_elf");`
457			`exit(1);`
458			`}`
459			`} else if (ELF_LONG_H(elf_spnt->sh_type) == SHT_SYMTAB) {`
460	51	julius
461	462	julius	`if (NULL != sym_tbl) {`
462			`free(sym_tbl);`
463			`}`
464	51	julius
465	462	julius	`if ((sym_tbl = (struct elf32_sym *)`
466			`malloc(ELF_LONG_H(elf_spnt->sh_size)))`
467			`== NULL) {`
468			`perror("readfile_elf");`
469			`exit(1);`
470			`}`
471	51	julius
472	462	julius	`if (fseek`
473			`(inputfs, ELF_LONG_H(elf_spnt->sh_offset),`
474			`SEEK_SET) != 0) {`
475			`perror("readfile_elf");`
476			`exit(1);`
477			`}`
478	51	julius
479	462	julius	`if (fread`
480			`(sym_tbl, ELF_LONG_H(elf_spnt->sh_size), 1,`
481			`inputfs) != 1) {`
482			`perror("readfile_elf");`
483			`exit(1);`
484			`}`
485	51	julius
486	462	julius	`syms =`
487			`ELF_LONG_H(elf_spnt->sh_size) /`
488			`ELF_LONG_H(elf_spnt->sh_entsize);`
489			`}`
490	51	julius	`}`
491
492	462	julius	`if (ELF_SHORT_H(elfhdr.e_shstrndx) != SHN_UNDEF) {`
493			`elf_spnt = &elf_shdata[ELF_SHORT_H(elfhdr.e_shstrndx)];`
494	51	julius
495	462	julius	`if ((s_str =`
496			`(char *)malloc(ELF_LONG_H(elf_spnt->sh_size))) == NULL) {`
497			`perror("readfile_elf");`
498			`exit(1);`
499			`}`
500	51	julius

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [orpsocv2/] [bench/] [sysc/] [src/] [MemoryLoad.cpp] - Blame information for rev 500