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 <string.h>
#include <stdlib.h>
#include <assert.h>
 
#include "or32.h"
 
#include "periph_timer.h"
 
#ifdef WIN32
#include "getopt_win32.h"
#else
#include <unistd.h>
#endif
 
#ifdef INCLUDE_ELF_SUPPORT
#include <libelf.h>
#include <fcntl.h>
#include <gelf.h>
#endif
 
//-----------------------------------------------------------------
// Defines
//-----------------------------------------------------------------
#define DEFAULT_MEM_BASE            0x10000000
#define DEFAULT_MEM_SIZE            (10 << 20)
#define DEFAULT_LOAD_ADDR           0x10000000
#define DEFAULT_FILENAME            NULL
 
//-----------------------------------------------------------------
// Locals
//-----------------------------------------------------------------
 
//-----------------------------------------------------------------
// elf_load
//-----------------------------------------------------------------
#ifdef INCLUDE_ELF_SUPPORT
static int elf_load(OR32 *sim, 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;
            }
 
            // Create some memory for this section
            if (!sim->CreateMemory(shdr->sh_addr, shdr->sh_size))
                return 0;
 
            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)
            {
                if (!sim->Load(shdr->sh_addr, (unsigned char*)data->d_buf, data->d_size))
                    return 0;
            }
        }
 
        section_idx++;
    }    
 
    elf_end ( e );
    close ( fd );
 
    return 1;
}
#endif
//-----------------------------------------------------------------
// main
//-----------------------------------------------------------------
int main(int argc, char *argv[])
{
    int c;
    unsigned int loadAddr = DEFAULT_LOAD_ADDR;
    unsigned int memBase = DEFAULT_MEM_BASE;
    unsigned int memSize = DEFAULT_MEM_SIZE;
    unsigned int startAddr = DEFAULT_MEM_BASE + VECTOR_RESET;
    int max_cycles = -1;
    char *filename = DEFAULT_FILENAME;
    char *elf_file = NULL;
    int help = 0;
    int trace = 0;
    unsigned int trace_mask = 1;
    int exitcode = -1;
    int mem_trace = 0;
    unsigned int trace_enable_pc = 0xFFFFFFFF;
    unsigned int stop_pc = 0xFFFFFFFF;    
    OR32 *sim = NULL;
 
    while ((c = getopt (argc, argv, "tv:l:b:s:f:c:x:nme:d:z:k:r:")) != -1)
    {
        switch(c)
        {
            case 't':
                 trace = 1;
                 break;
            case 'v':
                 trace_mask = strtoul(optarg, NULL, 0);
                 break;
            case 'l':
                 loadAddr = strtoul(optarg, NULL, 0);
                 break;
            case 'b':
                 memBase = strtoul(optarg, NULL, 0);
                 break;
            case 's':
                 memSize = strtoul(optarg, NULL, 0);
                 break;
            case 'x':
                 startAddr = strtoul(optarg, NULL, 0);
                 break;
            case 'k':
                 trace_enable_pc = strtoul(optarg, NULL, 0);
                 break;
            case 'r':
                 stop_pc = strtoul(optarg, NULL, 0);
                 break;
            case 'f':
                 filename = optarg;
                 break;
#ifdef INCLUDE_ELF_SUPPORT                  
            case 'e':
                 elf_file = optarg;
                 break;
#endif                 
            case 'c':
                 max_cycles = (int)strtoul(optarg, NULL, 0);
                 break;
            case 'm':
                 mem_trace = 1;
                 break;               
            case '?':
            default:
                help = 1;   
                break;
        }
    }
 
    if (help || (filename == NULL && elf_file == NULL))
    {
        fprintf (stderr,"Usage:\n");
        fprintf (stderr,"-f filename.bin = Executable to load (binary)\n");
#ifdef INCLUDE_ELF_SUPPORT        
        fprintf (stderr,"-e filename.elf = Executable to load (ELF)\n");
#endif
        fprintf (stderr,"-t              = Enable program trace\n");
        fprintf (stderr,"-v 0xX          = Trace Mask\n");
        fprintf (stderr,"-b 0xnnnn       = Memory base address\n");
        fprintf (stderr,"-s 0xnnnn       = Memory size\n");
        fprintf (stderr,"-l 0xnnnn       = Executable load address\n");     
        fprintf (stderr,"-x 0xnnnn       = Executable boot address\n");     
        fprintf (stderr,"-c nnnn         = Max instructions to execute\n");
        fprintf (stderr,"-k 0xnnnn       = Trace enable PC\n");
 
        exit(-1);
    }
 
 
    if (elf_file)
    {
#ifdef INCLUDE_ELF_SUPPORT                
        sim = new OR32(false);
        sim->AttachPeripheral(new TimerPeripheral());   
 
        if (elf_load(sim, elf_file, &memBase))
        {
            int cycles = 0;
 
            sim->Reset(memBase + VECTOR_RESET);
 
            if (trace & trace_enable_pc == 0xFFFFFFFF)
                sim->EnableTrace(trace_mask);
 
            if (mem_trace)
            {
                printf("Memory trace enabled\n");
                sim->EnableMemoryTrace();
            }            
 
            printf("Execute from 0x%x\n", memBase + VECTOR_RESET);
            while (!sim->GetBreak() && !sim->GetFault() && sim->GetPC() != stop_pc)
            {
                sim->Step();
                cycles++;
 
                if (max_cycles != -1 && max_cycles == cycles)
                    break;
 
                if (trace)
                {
                    if (sim->GetPC() == trace_enable_pc)
                        sim->EnableTrace(trace_mask);
                }
            }        
 
            // Show execution stats
            sim->DumpStats();
 
            // Fault occurred?
            if (sim->GetFault())
                exitcode = 1;
            else
                exitcode = 0;
        }
        else
            fprintf (stderr,"Error: Could not open ELF file %s\n", elf_file);
 
        delete sim;
 
        return exitcode;
#else
        fprintf (stderr,"Error: ELF files not supported\n");
        return -1;        
#endif
    }
    else
    {
        sim = new OR32(memBase, memSize, false);
        sim->AttachPeripheral(new TimerPeripheral());
 
        sim->Reset(startAddr);
 
        if (trace)
            sim->EnableTrace(trace_mask);
 
        if (mem_trace)
        {
            printf("Memory trace enabled\n");
            sim->EnableMemoryTrace();
        }
 
        FILE *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)
            {
                int wait_for_input = 0;
 
                // Read file data in
                int len = fread(buf, 1, size, f);
                buf[len] = 0;
 
                if (sim->Load(loadAddr, (unsigned char *)buf, len))
                {
                    int cycles = 0;
 
                    while (!sim->GetBreak() && !sim->GetFault() && sim->GetPC() != stop_pc)
                    {
                        sim->Step();
                        cycles++;
 
                        if (max_cycles != -1 && max_cycles == cycles)
                            break;
 
                        if (trace)
                        {
                            if (sim->GetPC() == trace_enable_pc)
                                sim->EnableTrace(trace_mask);
                        }
                    }   
                }
                else
                    fprintf (stderr,"Error: Could not load image to memory\n");
 
                free(buf);
                fclose(f);
            }
            // Show execution stats
            sim->DumpStats();
 
            // Fault occurred?
            if (sim->GetFault())
                exitcode = 1;
            else
                exitcode = 0;
        }
        else
            fprintf (stderr,"Error: Could not open %s\n", filename);
 
        delete sim;
    }    
 
    return exitcode;
}