Subversion Repositories altor32

//-----------------------------------------------------------------

//                           AltOR32 

//                Alternative Lightweight OpenRisc 

//                            V2.0

//                     Ultra-Embedded.com

//                   Copyright 2011 - 2013

//

//               Email: admin@ultra-embedded.com

//

//                       License: LGPL

//-----------------------------------------------------------------

//

// Copyright (C) 2011 - 2013 Ultra-Embedded.com

//

// This source file may be used and distributed without         

// restriction provided that this copyright statement is not    

// removed from the file and that any derivative work contains  

// the original copyright notice and the associated disclaimer. 

//

// This source file is free software; you can redistribute it   

// and/or modify it under the terms of the GNU Lesser General   

// Public License as published by the Free Software Foundation; 

// either version 2.1 of the License, or (at your option) any   

// later version.

//

// This source 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 Lesser General Public License for more 

// details.

//

// You should have received a copy of the GNU Lesser General    

// Public License along with this source; if not, write to the 

// Free Software Foundation, Inc., 59 Temple Place, Suite 330, 

// Boston, MA  02111-1307  USA

//-----------------------------------------------------------------

#include <stdio.h>

#include <unistd.h>

#include "top_if.h"

#include "verilated.h"

#ifdef INCLUDE_ELF_SUPPORT

#include <libelf.h>

#include <fcntl.h>

#include <gelf.h>

#endif

//-----------------------------------------------------------------

// Defines

//-----------------------------------------------------------------

#define MEM_BASE             0x10000000

#define MEM_EXEC_OFFSET      0x100

//-----------------------------------------------------------------

// Locals

//-----------------------------------------------------------------

//-----------------------------------------------------------------

// elf_load

//-----------------------------------------------------------------

#ifdef INCLUDE_ELF_SUPPORT

static int elf_load(const char *filename, unsigned int *startAddr)

{

    int fd;

    Elf * e;

    Elf_Kind ek;

    Elf_Scn *scn;

    Elf_Data *data;

    Elf32_Shdr *shdr;

    size_t shstrndx;

    if (elf_version ( EV_CURRENT ) == EV_NONE)

        return 0;

    if ((fd = open ( filename , O_RDONLY , 0)) < 0)

        return 0;

    if ((e = elf_begin ( fd , ELF_C_READ, NULL )) == NULL)

        return 0;

    ek = elf_kind ( e );

    if (ek != ELF_K_ELF)

        return 0;

    // Get section name header index

    if (elf_getshdrstrndx(e, &shstrndx)!=0)

        return 0;

    int section_idx = 0;

    while ((scn = elf_getscn(e, section_idx)) != NULL)

    {

        shdr = elf32_getshdr(scn);

        // Section which need loading (.text, .bss, .data, etc)

        if ((shdr->sh_type == SHT_PROGBITS || shdr->sh_type == SHT_NOBITS) &&

            (shdr->sh_flags & SHF_EXECINSTR || shdr->sh_flags & SHF_ALLOC)

           )

        {

            data = elf_getdata(scn, NULL);

            // .text section?

            if (elf_strptr(e, shstrndx, shdr->sh_name) && startAddr &&

                strcmp(elf_strptr(e, shstrndx, shdr->sh_name), ".text") == 0)

            {

                *startAddr = shdr->sh_addr + MEM_EXEC_OFFSET;

            }

            printf("Memory: 0x%x - 0x%x (Size=%dKB) [%s]\n", shdr->sh_addr, shdr->sh_addr + shdr->sh_size - 1, shdr->sh_size / 1024, elf_strptr(e, shstrndx, shdr->sh_name));

            if (shdr->sh_type == SHT_PROGBITS)

            {

                int i;

                for (i=0;i<shdr->sh_size;i++)

                    top_load(shdr->sh_addr + i, ((unsigned char*)data->d_buf)[i]);

            }

        }

        section_idx++;

    }

    elf_end ( e );

    close ( fd );

    return 1;

}

#endif

//-----------------------------------------------------------------

// main

//-----------------------------------------------------------------

int main(int argc, char **argv, char **env)

{

    int c;

    int err;

    unsigned int loadAddr = MEM_BASE;

    unsigned int execAddr = MEM_BASE + MEM_EXEC_OFFSET;

    unsigned int breakAddr = 0xFFFFFFFF;

    char *filename = NULL;

    int help = 0;

    int exitcode = 0;

    int cycles = -1;

    int intr_after = -1;

    Verilated::commandArgs(argc, argv);

    while ((c = getopt (argc, argv, "f:l:c:i:b:e:")) != -1)

    {

        switch(c)

        {

            case 'l':

                 loadAddr = strtoul(optarg, NULL, 0);

                 break;

            case 'f':

                 filename = optarg;

                 break;

            case 'c':

                 cycles = strtoul(optarg, NULL, 0);

                 break;

            case 'i':

                 intr_after = strtoul(optarg, NULL, 0);

                 break;

            case 'b':

                 breakAddr = strtoul(optarg, NULL, 0);

                 break;

            case '?':

            default:

                help = 1;

                break;

        }

    }

    if (loadAddr < MEM_BASE)

    {

        fprintf (stderr,"Load address incorrect (0x%x)\n", loadAddr);

        exit(-1);

    }

    if (help || filename == NULL)

    {

        fprintf (stderr,"Usage:\n");

        fprintf (stderr,"-t          = Enable program trace\n");

        fprintf (stderr,"-l 0xnnnn   = Executable load address\n");

        fprintf (stderr,"-f filename = Executable to load\n");

        fprintf (stderr,"-c num      = Max number of cycles\n");

        fprintf (stderr,"-i num      = Generate interrupt after num cycles\n");

        fprintf (stderr,"-b addr     = Break at address\n");

        exit(0);

    }

    top_init();

    if (strstr(filename, ".elf"))

    {

#ifdef INCLUDE_ELF_SUPPORT        

        if (!elf_load(filename, &execAddr))

        {

            fprintf (stderr,"Error: Could not open ELF file %s\n", filename);

            exit(-1);

        }

#else

        fprintf (stderr,"Error: ELF files not supported\n");

        exit(-1);

#endif

    }

    else

    {

        FILE *f;

        printf("Opening %s\n", filename);

        f = fopen(filename, "rb");

        if (f)

        {

            long size;

            char *buf;

            // Get size

            fseek(f, 0, SEEK_END);

            size = ftell(f);

            rewind(f);

            buf = (char*)malloc(size+1);

            if (buf)

            {

                unsigned int addr;

                // Read file data in

                int len = fread(buf, 1, size, f);

                buf[len] = 0;

                printf("Loading to 0x%x\n", loadAddr);

                for (addr=0;addr<len;addr++)

                    top_load(loadAddr + addr, buf[addr]);

                free(buf);

                fclose(f);

            }

        }

        else

        {

            printf("Could not read file!\n");

            exit(-1);

        }

    }

    // Setup breakpoint to stop at (or 0xFFFFFFFF if none)

    top_setbreakpoint(0, breakAddr);

    // Run

    err = top_run(execAddr, cycles, intr_after);

    // Cleanup

    top_done();

    printf("Exit\n");

    exit((err == TOP_RES_FAULT) ? 1 : 0);

}