archc.cpp

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/*  ArchC Library for tools generated by the ArchC Pre-processor
    Copyright (C) 2002-2004  The ArchC Team

    This library 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 library 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.
*/
/********************************************************/
/* ArchC support functions                              */
/* Author:  Sandro Rigo                                 */
/*                                                      */
/*                                                      */
/* The ArchC Team                                       */
/* Computer Systems Laboratory (LSC)                    */
/* IC-UNICAMP                                           */
/* http://www.lsc.ic.unicamp.br                         */
/********************************************************/
 

#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h>
#include <sys/msg.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <stdlib.h>
#include <elf.h>
#include <sys/stat.h>
#include <fcntl.h>

#include "ac_decoder.h"
#include "ac_resources.H"

#ifdef USE_GDB
#include "ac_gdb.H"
extern AC_GDB *gdbstub;
#endif /* USE_GDB */

#ifdef AC_VERIFY

//Declaring co-verification message queue
key_t key;
int msqid;


#endif

int ac_stop_flag = 0;

//Declaring trace variables
ofstream trace_file;
bool ac_do_trace;

ac_dec_field *fields;
ac_dec_format *formats;
ac_dec_list *dec_list;
ac_dec_instr *instructions;
unsigned char buffer[AC_MAX_BUFFER];
unsigned int quant, decode_pc;
unsigned int ac_heap_ptr;
unsigned dec_cache_size;
ac_storage *IMem;

//Command line arguments used inside ArchC Simulator
int ac_argc;                       
char **ac_argv;
//Name of the file containing the application to be loaded.
char *appfilename;

int  ac_load_elf(char* filename, char* data_mem, unsigned int size);  //Loading an ELF binary application file.
void ac_load_obj(char* filename);  //Loading a binary application file.
void ac_load_dlx(char* filename);  //Loading a hex file generated by gcc-dlx

extern "C" {
  int ExpandInstrBuffer( int index){

    int bytes_needed = index - quant +1;
    int read, wordsize,i;
    
    wordsize = (AC_WORDSIZE/8);       //computes the wordsize in bytes
    read = bytes_needed/ wordsize;
    
    if( bytes_needed% wordsize) 
      read++;
    
    for( i=0; i<read; i++)
      *((ac_word*)(buffer + quant + wordsize*i)) =  IMem->read( decode_pc +  quant + wordsize*i );

    quant += read;

    return quant;

  }
}

//Read model options before application
void ac_init_opt( int ac, char* av[]){

  extern const char *project_name;
  extern const char *project_file;
  extern const char *archc_version;
  extern const char *archc_options;

  if(ac > 1){
                
    if (!strncmp( av[1], "--help", 6)) {
      cerr << "This is a " << project_name << " architecture simulator generated by ArchC.\n";
      cerr << "For more information visit http://www.archc.org\n\n";
      cerr << "Usage: " << av[0] << " [options]\n\n";
      cerr << "Options:\n";
      cerr << "  --help                  Display this help message\n";
      cerr << "  --version               Display ArchC version and options used when built\n";
      cerr << "  --load=<hex_prog>       Load application in hex format\n";
      cerr << "  --load_obj=<elf_prog>   Load application in ELF format\n";
#ifdef USE_GDB
      cerr << "  --gdb[=<port>]          Disable GDB support\n";
#endif /* USE_GDB */
      exit(1);
    }
    
    if (!strncmp( av[1], "--version", 9)) {
      cout << project_name << " simulator generated by ArchC " << archc_version
           << " from " << project_file << " with options (" << archc_options << ")" << endl;
      exit(0);
    }
  }
}

//Initialize application
void ac_init_app( int ac, char* av[]){

  int size;
  char *appname=0;
  extern int ac_argc;
  extern char** ac_argv;

  ac_argc = ac-1;   //Skiping program's name
  ac_argv = av;
  
  while(ac > 1){
    size = strlen(av[1]);

    //Checking if an application needs to be loaded
    if( (size>11) && (!strncmp( av[1], "--load_obj=", 11))){   //Loading a binary app
      appname = (char*)malloc(size - 10);
      strcpy(appname, av[1]+11);
      ac_argv[1] = appname;
      appfilename = (char*) malloc(sizeof(char)*(size - 6));
      strcpy(appfilename, appname);
      //ac_load_obj( appname );
    }
    else if( (size>7) && (!strncmp( av[1], "--load=", 7))){  //Loading hex file in the ArchC Format
      appname = (char*)malloc(size - 6);
      strcpy(appname, av[1]+7);
      ac_argv[1] = appname;
      appfilename = (char*) malloc(sizeof(char)*(size - 6));
      strcpy(appfilename, appname);
    }
    else if( (size>11) && (!strncmp( av[1], "--load_dlx=", 11))){ //Loading hex file produced by gcc-dlx
      appname = (char*)malloc(size - 10);
      strcpy(appname, av[1]+11);
      ac_argv[1] = appname;
      ac_load_dlx(appname);
    }
#ifdef USE_GDB    
    if( (size>=5) && (!strncmp( av[1], "--gdb", 5))){ //Enable GDB support
      int port = 0;
      if ( size > 6 )
        { 
          port = atoi( av[1] + 6 );
          if ( ( port > 1024 ) && gdbstub )
            gdbstub->set_port( port );
        }
      if ( gdbstub ) 
        gdbstub->enable();
    }
#endif /* USE_GDB */
    
    ac --;
    av ++;
  }

  if (!appname) {
    AC_ERROR("No application provided.");
    AC_ERROR("Use --load=<hex_prog> or --load_obj=<elf_prog> options to run applications.");
    AC_ERROR("Try --help for more options.");
    exit(1);
  }
  ac_argv++;

}

unsigned int convert_endian(unsigned int size, unsigned int num)
{
  unsigned char *in = (unsigned char*) &num;
  unsigned int out = 0;

  if (! AC_MATCH_ENDIAN) {
    for(; size>0; size--) {
      out <<= 8;
      out |= in[0];
      in++;
    }
  }
  else {
    out = num;
  }

  return out;
}

//Loading binary application
int ac_load_elf(char* filename, char* data_mem, unsigned int data_mem_size)
{
  Elf32_Ehdr    ehdr;
  Elf32_Phdr    phdr;
  int           fd;
  unsigned int  i;

  //Open application
  if (!filename || ((fd = open(filename, 0)) == -1)) {
    AC_ERROR("Openning application file '" << filename << "': " << strerror(errno) << endl);
    exit(EXIT_FAILURE);
  }

  //Test if it's an ELF file
  if ((read(fd, &ehdr, sizeof(ehdr)) != sizeof(ehdr)) ||  // read header
      (strncmp((char *)ehdr.e_ident, ELFMAG, 4) != 0) ||          // test elf magic number
      0) {
    close(fd);
    return EXIT_FAILURE;
  }

  //It is an ELF file
  AC_SAY("Reading ELF application file: " << filename << endl);

  //Get program headers and load segments
  lseek(fd, convert_endian(4,ehdr.e_phoff), SEEK_SET);
  for (i=0; i<convert_endian(2,ehdr.e_phnum); i++) {

    if (read(fd, &phdr, sizeof(phdr)) != sizeof(phdr)) {
      AC_ERROR("reading ELF program header\n");
      close(fd);
      exit(EXIT_FAILURE);
    }

    if (convert_endian(4,phdr.p_type) == PT_LOAD) {
      Elf32_Word j;
      Elf32_Addr p_vaddr = convert_endian(4,phdr.p_vaddr);
      Elf32_Word p_memsz = convert_endian(4,phdr.p_memsz);
      Elf32_Word p_filesz = convert_endian(4,phdr.p_filesz);
      Elf32_Off  p_offset = convert_endian(4,phdr.p_offset);

      //Error if segment greater then memory
      if (data_mem_size < p_vaddr + p_memsz) {
        AC_ERROR("not enough memory in ArchC model to load application.\n");
        close(fd);
        exit(EXIT_FAILURE);
      }

      //Set heap to the end of the segment
      if (ac_heap_ptr < p_vaddr + p_memsz) ac_heap_ptr = p_vaddr + p_memsz;

      //Load and correct endian
      lseek(fd, p_offset, SEEK_SET);
      for (j=0; j < p_filesz; j+=sizeof(ac_fetch)) {
        int tmp;
        read(fd, &tmp, sizeof(ac_fetch));
        *(ac_fetch *) (data_mem + p_vaddr + j) = convert_endian(sizeof(ac_fetch), tmp);
      }
      memset(data_mem + p_vaddr + p_filesz, 0, p_memsz - p_filesz);
    }

    //next header/segment
    lseek(fd, convert_endian(4,ehdr.e_phoff) + convert_endian(2,ehdr.e_phentsize) * i, SEEK_SET);
  }

  //Close file
  close(fd);

  return EXIT_SUCCESS;
}

//Loading binary application
void ac_load_obj( char* filename ){

  int child, status;
  char *ARCHC_PATH;
  char script[] = "/scripts/ac_load_obj.pl";
  char *argv[3]; 
  extern char* appfilename;
  extern unsigned int ac_heap_ptr;
  FILE* tempfile;

  ARCHC_PATH = getenv("ARCHC_PATH");

  if(!ARCHC_PATH){
    AC_ERROR("You should set the ARCHC_PATH environment variable.\n");
    exit(1);
  }

  argv[0] = (char*) malloc(strlen(ARCHC_PATH) + strlen(script) +1);
  sprintf(argv[0],"%s%s", ARCHC_PATH, script);
  argv[1] = filename;
  argv[2] = 0;
        
  if( !(child = fork()) )
    execve(argv[0], argv, NULL);
  else{
    waitpid(child,&status,0);
    if(!WIFEXITED(status))
      AC_ERROR("Could not process binary file.");
  }
        
  //Loading from the file generated by scripts
  appfilename = "loader.ac";

  //Setting heap pointer
  tempfile = fopen("loader.tmp","r");
  if( tempfile ){
    fscanf(tempfile, "%x", &ac_heap_ptr );
    fclose(tempfile);
#ifndef AC_VERIFY
    remove("loader.tmp");
#endif
  }
  else{ //The script could not open the input file
    AC_ERROR("Could not open temporary file generated by script: loader.tmp");
    AC_ERROR("Simulation aborted.");
    exit(1);
  }

  free(argv[0]);
}

//Loading hex file generated by gcc-dlx
void ac_load_dlx( char* filename ){

  int child;
  char * argv[] = {"../scripts/ac_load_dlx.pl", filename, 0};
  extern char* appfilename;

  if( !(child = fork()) )
    execve(argv[0], argv, NULL);
  else
    waitpid(child,0,0);

  //Loading from the file generated by scripts
  appfilename = "loader.ac";
}


//Functions used to calculate the instr/s of the simulation

#include <sys/times.h>

struct tms ac_run_times;
clock_t ac_run_start_time;

void InitStat()
{
  ac_run_start_time = times(&ac_run_times);
}

void PrintStat()
{
  clock_t ac_run_real;

  //Print statistics
  fprintf(stderr, "ArchC: Simulation statistics\n");

  ac_run_real = times(&ac_run_times) - ac_run_start_time;
  fprintf(stderr, "    Times: %ld.%02ld user, %ld.%02ld system, %ld.%02ld real\n",
          ac_run_times.tms_utime / 100, ac_run_times.tms_utime % 100,
          ac_run_times.tms_stime / 100, ac_run_times.tms_stime % 100,
          ac_run_real / 100, ac_run_real % 100
          );

  fprintf(stderr, "    Number of instructions executed: %llu\n", ac_instr_counter);

  if (ac_run_times.tms_utime > 5) {
    double ac_mips = (ac_instr_counter * 100) / ac_run_times.tms_utime;
    fprintf(stderr, "    Simulation speed: %.2f K instr/s\n", ac_mips/1000);
  }
  else {
    fprintf(stderr, "    Simulation speed: (too fast to be precise)\n");
  }
}


//Signal handlers for interrupt and segmentation fault (set in ac_start() )
#include <signal.h>
typedef void (*sighandler_t)(int);
void sigint_handler(int signal)
{
  fprintf(stderr, "ArchC: INTERUPTED BY THE SIGNAL %d\n", signal);
  PrintStat();
  exit(EXIT_FAILURE);
}
void sigsegv_handler(int signal)
{
  fprintf(stderr, "ArchC Error: Internal bug (segmentation fault). Sorry.\n");
  PrintStat();
  exit(EXIT_FAILURE);
}
void sigusr1_handler(int signal)
{
  fprintf(stderr, "ArchC: Received signal %d. Printing statistics\n", signal);
  PrintStat();
  fprintf(stderr, "ArchC: -------------------- Continuing Simulation ------------------\n");
}

#ifdef USE_GDB
void sigusr2_handler(int signal)
{
  fprintf(stderr, "ArchC: Received signal %d. Starting GDB support\n", signal);
  gdbstub->enable();
  gdbstub->connect();
}
#endif /* USE_GDB */

//Start simulation
void ac_start(int argc, char *argv[])
{
  cerr << "ArchC: -------------------- Starting Simulation --------------------" << endl;
#ifdef USE_GDB
  if (gdbstub && !gdbstub->is_disabled()) 
    gdbstub->connect();
#endif /* USE_GDB */
  InitStat();
  signal(SIGINT, sigint_handler);
  signal(SIGTERM, sigint_handler);
  signal(SIGSEGV, sigsegv_handler);
  signal(SIGUSR1, sigusr1_handler);
  signal(SIGUSR2, sigusr2_handler);
  sc_start(-1);
}


//Stop simulation (may receive exit status)
void ac_stop(int status)
{
  cerr << "ArchC: -------------------- Simulation Finished --------------------" << endl;
  ac_stop_flag = 1;
  dup2(2, 1); //any output to stdout is redirected for stderr (ex. SystemC stop message)
  sc_stop();
}

---