/* GX target-independent functions for block translation.
  Copyright (C) 1998 Cygnus Solutions.  */


#include "sim-main.h"
#include "sim-assert.h"
#include "sim-gx.h"

#include "config.h"
/* #include "cconfig.h" */

/* shared object functions */
#ifdef HAVE_DLFCN_H
#include <dlfcn.h>
#else
#error "need dlfcn.h"
#endif

#ifdef HAVE_ERRNO_H
#include <errno.h>
#else
#error "need errno.h"
#endif

#include <stdlib.h>
#include <string.h>
#include <limits.h>
#ifdef HAVE_TIME_H
#include <time.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_FCNTL_H
#include <fcntl.h>
#endif
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif

#include "bfd.h"




/* Load the object file with given gx block.  Return pointer to GX
   function or NULL on failure. */

sim_gx_function
sim_gx_compiled_block_f(sim_gx_compiled_block* gx)
{
  sim_gx_function f = gx->function_dlhandle;
  SIM_DESC sd = current_state;
  int rc;

  if(f == NULL)
    {
      /* compile object */
      if(gx->object_name == NULL && gx->source_name != NULL)
	{
	  char compile_command[2000];

	  gx->object_name = strdup(gx->source_name);
	  /* turn *.c into *.o */
	  gx->object_name[strlen(gx->object_name)]='o';

	  /* compute command string to compile object */
	  sprintf(compile_command,
		  "make -f %s OBJ=%s SRC=%s gx",
#define GX_MAKEFILE "--no-makefile-yet--"
		  GX_MAKEFILE,
		  gx->object_name,
		  gx->source_name);

	  rc = system(compile_command);
	  if(rc != 0)
	    {
	      sim_io_error(sd, "Compile error rc %d for GX source %s: %s", 
			rc,
			gx->source_name,
			strerror(errno));
	    }
	}
      
      /* load object */
      if(gx->object_dlhandle == NULL && gx->object_name != NULL)
	{
	  gx->object_dlhandle = dlopen(gx->object_name, RTLD_NOW);
	  if(gx->object_dlhandle == NULL)
	    {
	      sim_io_error(sd, "Load error for GX object %s: %s", 
			gx->object_name,
			dlerror());
	    }
	}
      
      /* locate function */
      if(gx->function_dlhandle == NULL && gx->object_dlhandle != NULL && gx->symbol_name != NULL)
	{
	  f = gx->function_dlhandle = dlsym(gx->object_dlhandle, gx->symbol_name);
	  if(f == NULL)
	    {
	      sim_io_error(sd, "Resolve error for GX object %s symbol %s: %s", 
			gx->object_name,
			gx->symbol_name,
			dlerror());
	    }
	}
    } /* f == NULL */

  return f;
}



/* Forget about given GX block.  Remove its source/object; unload it
   from memory. */
void
sim_gx_compiled_block_dispose(sim_gx_compiled_block* gx)
{
  SIM_DESC sd = current_state;
  int rc;

  /* forget dl information */
  gx->function_dlhandle = NULL;

  /* unload shared library */
  if(gx->object_dlhandle != NULL)
    {
      rc = dlclose(gx->object_dlhandle);
      if(rc != 0)
	{
	  sim_io_error(sd, "dlclose() error for GX object %s: %s", 
		    gx->object_name,
		    dlerror());
	}
      gx->object_dlhandle = NULL;
    }

  /* final gasps */
  zfree(gx->source_name);
  zfree(gx->object_name);
  zfree(gx->symbol_name);
  zfree(gx);
}



/* Translate a piece of the code segment around given PC, in given mode. */
sim_gx_block*
sim_gx_block_create(sim_cia cia)
{
  sim_gx_block* block;

  /* allocate emtpy block */
  block = zalloc(sizeof(sim_gx_block));

  /* initialize block bounds, callback struct etc. */ 
  tgx_block_ctor(block, cia);

  /* create learning mode translation */ 
  sim_gx_block_translate(block, 0 /* learning mode */);

  /* add block to block list */
  sim_gx_block_add(block);

  return block;
}



/* Write the current block list to the state file */
void
sim_gx_write_block_list()
{
  int i;
  SIM_DESC sd = current_state;
  sim_gx_block_list* blocks = STATE_BLOCKS(sd);
  FILE* f;
  char state_file_name[PATH_MAX];
  char *exec_name;

  /* get base of executable name */
  exec_name = bfd_get_filename(STATE_PROG_BFD(sd));
  if(strrchr(exec_name, '/') != NULL)
    exec_name = strrchr(exec_name, '/') + 1;

  /* generate base name */
  sprintf(state_file_name, "%s/%s.gx",
	  GX_DIR,
	  exec_name);

  f = fopen(state_file_name, "w");
  if(f == NULL)
    {
      sim_io_error(sd, "Error: cannot write to state file %s, errno %d", 
		   state_file_name, errno);
    }

  fprintf(f, "# This file was automatically generated.  Do not edit.\n");

  /* write block descriptors into state file */
  for(i=0; i<blocks->gx_blocks_used; i++)
    {
      sim_gx_block* gx = blocks->gx_blocks[i];
      sim_gx_compiled_block* block;
      int j;
      int age;

      age = time(NULL) - gx->learn_last_change; /* store interval */
      fprintf(f, "BLOCK 0x%lx 0x%lx %u %u\n", gx->origin, gx->length, gx->divisor, age);
      fprintf(f, "FLAGS ");
      for(j=0; j<GX_PC_FLAGS_INDEX(gx, gx->origin + gx->length); j++)
	{
	  fprintf(f, "%2x ", gx->pc_flags[j]);
	}
      fprintf(f, "\n");

      /* write learning mode names */
      block = gx->learning_block;
      fprintf(f, "LEARNING %s %s %s %lu %u\n",
	      block->source_name, block->object_name, block->symbol_name,
	      gx->compile_time, gx->opt_compile_count);

      /* write optimized mode names */
      block = gx->optimized_block;
      if(block)
	fprintf(f, "OPTIMIZED %s %s %s\n",
		block->source_name, block->object_name, block->symbol_name);

      /* NB: other fields will be filled in with freshly guessed values */
    }

  (void) fclose(f);
}



void
print_gx_blocks(sim_gx_block_list* blocks, char* where)
{
  printf("print_gx_blocks: %s\n", where);

  if(blocks == NULL)
    printf("(null)\n");
  else
    {
      int i;
      printf("size: %d, used: %d\n",
	     blocks->gx_blocks_size, blocks->gx_blocks_used);

      /* linear search */
      for(i=0; i<blocks->gx_blocks_used; i++)
	{
	  sim_gx_block* gx = blocks->gx_blocks[i];
	  printf("block %d: %p\n", i, (void*) gx);
	  if(gx == NULL)
	    printf("** NULL!\n");
	  else
	    printf("  begin 0x%08x length 0x%08x [opt %d%s]\n",
		   (unsigned)gx->origin, (unsigned)gx->length,
		   gx->opt_compile_count,
		   (gx->optimized_block ? " loaded" : " discarded"));
	}
      
    }
}



/* Read the current block list from the cache */
void
sim_gx_read_block_list()
{
  SIM_DESC sd = current_state;
  FILE* f;
  char state_file_name[PATH_MAX];
  char *exec_name;

  /* check for block */
  if(STATE_PROG_BFD(sd) == NULL)
    return;

  /* get base of executable name */
  exec_name = bfd_get_filename(STATE_PROG_BFD(sd));
  if(strrchr(exec_name, '/') != NULL)
    exec_name = strrchr(exec_name, '/') + 1;

  /* generate base name */
  sprintf(state_file_name, "%s/%s.gx",
	  GX_DIR,
	  exec_name);

  f = fopen(state_file_name, "r");
  if(f == NULL)
    {
      /* XXX: print warning */
      return;
    }

  fscanf(f, "#%*[^\n]\n"); /* swallow # comment line */

  while(1)
    {
      unsigned_4 origin, length;
      unsigned divisor;
      sim_gx_block* gx;
      int rc;
      sim_gx_compiled_block* block;
      unsigned age;
      int j;

      rc = fscanf(f, "BLOCK 0x%0lx 0x%lx %u %u\n", & origin, & length, & divisor, & age);
      if(rc != 4) /* not all fields matched - assume EOF */
	break;

      gx = zalloc(sizeof(sim_gx_block));

      /* initialize block bounds, callback struct etc. */ 
      tgx_block_ctor2(gx, origin, length, divisor);

      /* read flags */
      fscanf(f, "FLAGS");
      for(j=0; j<GX_PC_FLAGS_INDEX(gx, gx->origin + gx->length); j++)
	{
	  unsigned value;
	  fscanf(f, "%2x ", & value);
	  gx->pc_flags[j] = (unsigned_1) value;
	}
      fscanf(f, "\n");

      /* read learning mode info */
      block = zalloc(sizeof(sim_gx_compiled_block));
      gx->learning_block = block;
      block->source_name = zalloc(PATH_MAX);
      block->object_name = zalloc(PATH_MAX);
      block->symbol_name = zalloc(PATH_MAX);
      fscanf(f, "LEARNING %s %s %s %lu %u\n",
	     block->source_name, block->object_name, block->symbol_name,
	     & gx->compile_time, & gx->opt_compile_count);

      /* read optimized mode info */
      block = zalloc(sizeof(sim_gx_compiled_block));
      gx->optimized_block = block;
      block->source_name = zalloc(PATH_MAX);
      block->object_name = zalloc(PATH_MAX);
      block->symbol_name = zalloc(PATH_MAX);
      rc = fscanf(f, "OPTIMIZED %s %s %s\n",
		  block->source_name, block->object_name, block->symbol_name);
      if(rc != 3)
	{
	  /* oops, not an optimized block */
	  zfree(block->source_name);
	  zfree(block->object_name);
	  zfree(block->symbol_name);
	  zfree(block);
	  gx->optimized_block = NULL;
	}

      /* fill in remaining fields */
      gx->learn_last_change = time(NULL) - age; /* make absolute */

      /* store it away */
      sim_gx_block_add(gx);
    }

  print_gx_blocks(STATE_BLOCKS(sd), "after restoring state");
}






/* Add a gx block to list */
void
sim_gx_block_add(sim_gx_block* block)
{
  SIM_DESC sd = current_state;
  sim_gx_block_list* blocks = STATE_BLOCKS(sd);
  int i;

  /* print_gx_blocks(blocks, "pre add"); */

  if(blocks == NULL)
    blocks = STATE_BLOCKS(sd) = zalloc(sizeof(sim_gx_block_list));

  /* need to enlarge block vector? */
  if(blocks->gx_blocks_used == blocks->gx_blocks_size)
    {
      sim_gx_block** new_blocks;
      int j;

      blocks->gx_blocks_size += 20;
      new_blocks = zalloc(blocks->gx_blocks_size * sizeof(sim_gx_block*));
      for(j=0; j<blocks->gx_blocks_used; j++)
	new_blocks[j] = blocks->gx_blocks[j];
      if(blocks->gx_blocks) zfree(blocks->gx_blocks);
      blocks->gx_blocks = new_blocks;
    }

  /* insert new block */
  for(i=0; i<blocks->gx_blocks_used; i++)
    {
      ASSERT(blocks->gx_blocks[i] != NULL);

      /* insertion point reached? */
      if(blocks->gx_blocks[i]->origin > block->origin)
	{
	  int j;
	  for(j=blocks->gx_blocks_used; j>=i; j--)
	    blocks->gx_blocks[j] = blocks->gx_blocks[j-1];
	  blocks->gx_blocks[i] = block;
	  blocks->gx_blocks_used ++;
	  break;
	}
    }

  /* end of block vector */
  if(i == blocks->gx_blocks_used)
    {
      blocks->gx_blocks[blocks->gx_blocks_used ++] = block;
    }

  /* print_gx_blocks(blocks, "post add"); */
}



/* Remove a gx block from list */
void
sim_gx_block_remove(sim_gx_block* block)
{
  SIM_DESC sd = current_state;
  sim_gx_block_list* blocks = STATE_BLOCKS(sd);
  int i;

  /* print_gx_blocks(blocks, "pre remove"); */

  /* linear search */
  for(i=0; i<blocks->gx_blocks_used; i++)
    {
      if(blocks->gx_blocks[i] == block)
	{
	  /* found it */
	  while(i < blocks->gx_blocks_used - 1)
	    {
	      blocks->gx_blocks[i] = blocks->gx_blocks[i+1];
	      i++;
	    }
	  blocks->gx_blocks_used --;
	  break;
	}
    }

  /* print_gx_blocks(blocks, "post remove"); */
}


/* Find a gx block from list */
sim_gx_block*
sim_gx_block_find(sim_cia cia)
{
  SIM_DESC sd = current_state;
  sim_gx_block_list* blocks = STATE_BLOCKS(sd);
  int i;

  if(blocks == NULL) return NULL;

  /* print_gx_blocks(blocks, "pre find"); */

  /* linear search */
  for(i=0; i<blocks->gx_blocks_used; i++)
    {
      sim_gx_block* gx = blocks->gx_blocks[i];
      ASSERT(gx != NULL);

      if(GX_PC_INCLUDES(gx,cia))
	{
	  return gx;
	}
    }

  return NULL;
}



/* generate */
void
sim_gx_block_translate(sim_gx_block* gx, int optimized)
{
  char pwd_name[PATH_MAX];
  char dir_name[PATH_MAX];
  char base_name[PATH_MAX];
  char compile_command[PATH_MAX*4];
  char* exec_name;
  SIM_DESC sd = current_state;
  int rc;
  sim_cia gx_cia;
  sim_gx_compiled_block* block = zalloc(sizeof(sim_gx_compiled_block));
  unsigned time_begin, time_end;

  time_begin = time(NULL);

  if(optimized) gx->optimized_block = block;
  else gx->learning_block = block;

  /* get base of executable name */
  exec_name = bfd_get_filename(STATE_PROG_BFD(sd));
  if(strrchr(exec_name, '/') != NULL)
    exec_name = strrchr(exec_name, '/') + 1;

  /* generate base name */
  sprintf(dir_name, "%s/%s",
	  GX_DIR,
	  exec_name);

  /* generate base name */
  getcwd(pwd_name, sizeof(pwd_name));
  
  /* create work directory */
  rc = mkdir(GX_DIR, 0777);
  if(rc != 0 &&
     errno != EEXIST)
    {
      sim_io_error(sd, "Error: cannot create directory %s, errno %d", 
		   GX_DIR, errno);
    }

  rc = mkdir(dir_name, 0777);
  if(rc != 0 &&
     errno != EEXIST)
    {
      sim_io_error(sd, "Error: cannot create directory %s, errno %d",
		   dir_name, errno);
    }

  /* compute base name */
  if(optimized)
    sprintf(base_name, "%08lx_opt%d", gx->origin, gx->opt_compile_count);
  else
    sprintf(base_name, "%08lx", gx->origin);

  /* generate source/object file names */ 
  block->source_name = zalloc(PATH_MAX);
  block->object_name = zalloc(PATH_MAX);
  sprintf(block->source_name, "%s/%s.c", dir_name, base_name);

  /* generate symbol name for gx function */
  block->symbol_name = zalloc(PATH_MAX);
  sprintf(block->symbol_name, "gx_%s", base_name);

  /* open source file */
  block->source_file = fopen(block->source_name, "w");
  if(block->source_file == NULL)
    {
      sim_io_error(sd, "Error: cannot open file %s, errno %d",
		   block->source_name, errno);
    }

  /* front matter */
  fprintf(block->source_file, "/* sim-gx version %d */\n", GX_VERSION);
  fprintf(block->source_file, "/* gx block date stamp %lu */\n\n", time(NULL));

  /* emit head end of source */
  tgx_emit_pre_function(gx, optimized); 

  /* emit function header */
  fprintf(block->source_file, "\n\n");
  fprintf(block->source_file, "extern int\n");
  fprintf(block->source_file, "%s", block->symbol_name);
  fprintf(block->source_file, "(struct tgx_cpu_regs* regs, char* pc_flags, struct tgx_callbacks* callbacks)\n");
  fprintf(block->source_file, "{\n");
  fprintf(block->source_file, "  int rc = 0;\n");
  if(! optimized)
    fprintf(block->source_file, "  unsigned int insn_count = 0;\n");

  /* pre-block gunk: register load */
  tgx_emit_load_block(gx, optimized);

  /* emit intra-block jump label */
  fprintf(block->source_file, "\n");
  fprintf(block->source_file, "shortjump:\n");
  fprintf(block->source_file, "  pc = npc;\n");

  /* translate jumptarget table */
  if(! optimized)
    {
      fprintf(block->source_file, "  pc_flags[(pc - 0x%08x) / %u] |= %d;\n",
	      (unsigned)gx->origin, gx->divisor, GX_PCF_JUMPTARGET);
    }

  /* enforce learning mode run limit */
  if(! optimized)
    {
      fprintf(block->source_file, "  insn_count++;\n");
      fprintf(block->source_file, "  if (insn_count > %d)\n", GX_LEARN_RUN_LIMIT);
      fprintf(block->source_file, "    {\n");
      fprintf(block->source_file, "      rc = %d;\n", GX_F_YIELD);
      fprintf(block->source_file, "      npc = pc;\n");
      fprintf(block->source_file, "      goto save;\n");
      fprintf(block->source_file, "    }\n");
    }

  /* emit PC switch, use compressed case numbers */
  fprintf(block->source_file, "\n");
  fprintf(block->source_file, "  switch((pc - 0x%08x) / %u)\n",
	  (unsigned)gx->origin, gx->divisor); 
  fprintf(block->source_file, "    {\n"); 

  /* handle bad-PC event */
  fprintf(block->source_file, "    /* handle unknown jump target */\n");
  fprintf(block->source_file, "    default:\n");
  fprintf(block->source_file, "      rc = %d;\n", GX_F_NONPC);
  fprintf(block->source_file, "      npc = pc;\n");
  fprintf(block->source_file, "      goto save;\n");
  
  /* start translating at the origin */
  gx_cia = gx->origin;

  /* translate instructions in block */ 
  while(GX_PC_INCLUDES(gx,gx_cia))
    { 
      sim_cia next_gx_cia;

      /* translate PC case statement */
      fprintf(block->source_file, "\n");
      fprintf(block->source_file, "    /* PC: 0x%08x, flags %02x */\n",
	      gx_cia, (int) GX_PC_FLAGS(gx, gx_cia));


      /* skip over this instruction if it is not executed */
      if(optimized && !(GX_PC_FLAGS(gx, gx_cia) & GX_PCF_INSTRUCTION))
	{
	  fprintf(block->source_file, "    /* (not reached) */\n");

	  /* prevent fall-through from previous translated insn */
	  if(gx_cia > gx->origin &&
	     GX_PC_FLAGS(gx, (gx_cia - gx->divisor)) & GX_PCF_INSTRUCTION)
	    {
	      fprintf(block->source_file, "    /* prevent fall-through */\n");
	      fprintf(block->source_file, "    npc = 0x%08x;\n", gx_cia);  
	      fprintf(block->source_file, "    rc = %d;\n", GX_F_NONPC);  
	      fprintf(block->source_file, "    goto save;\n");
	    }

	  next_gx_cia = gx_cia + gx->divisor;
	  goto skip_instruction;
	}

      /* translate PC case statement */
      if((! optimized) ||
	 (GX_PC_FLAGS(gx, gx_cia) & GX_PCF_JUMPTARGET))
	{
	  fprintf(block->source_file, "    case %ld:\n",
		  ((gx_cia - gx->origin) / gx->divisor));
	}

      /* translate breakpoint check & exit */
      if(GX_PC_FLAGS(gx, gx_cia) & GX_PCF_COND_HALT)
	{
	  fprintf(block->source_file, "      if(pc_flags[%ld] & %d)\n",
		  GX_PC_FLAGS_INDEX(gx, gx_cia),
		  GX_PCF_HALT);
	  fprintf(block->source_file, "        {\n");
	  fprintf(block->source_file, "          rc = %d;\n", GX_F_HALT);
	  fprintf(block->source_file, "          npc = pc;\n");
	  fprintf(block->source_file, "          goto save;\n");
	  fprintf(block->source_file, "        }\n");
	}

      /* [don't] emit PC-setting */
      /* fprintf(block->source_file, "      pc = 0x%08x;\n", gx_cia); */

      /* mark traversed instructions */
      if(! optimized)
	{
	  fprintf(block->source_file, "      pc_flags[%ld] |= %d;\n",
		  GX_PC_FLAGS_INDEX(gx, gx_cia),
		  GX_PCF_INSTRUCTION);
	}
      
      
      /* translate instruction semantics */
      next_gx_cia = tgx_emit_insn(gx, gx_cia, optimized);

    skip_instruction:

      /* go to next instruction */
      gx_cia = next_gx_cia;
    } 
  fprintf(block->source_file, "    }\n"); 

  /* dropped through last instruction in switch block */
  fprintf(block->source_file, "\n");
  fprintf(block->source_file, "  /* dropped through PC switch */\n");
  fprintf(block->source_file, "  npc = 0x%08x;\n", gx_cia);
  fprintf(block->source_file, "  rc = %d;\n", GX_F_RANGE);
  fprintf(block->source_file, "  goto save;\n");

  /* unknown length jump */
  fprintf(block->source_file, "\n");
  fprintf(block->source_file, "unknownjump:\n");
  fprintf(block->source_file, "  if(npc >= 0x%08lx && npc < 0x%08lx)\n",
	  gx->origin, gx->origin + gx->length);
  fprintf(block->source_file, "    goto shortjump;\n");

  /* long jump */
  fprintf(block->source_file, "\n");
  fprintf(block->source_file, "longjump:\n");
  fprintf(block->source_file, "  rc = %d;\n", GX_F_RANGE);

  /* post-block gunk: SAVE etc. */
  fprintf(block->source_file, "\n");
  fprintf(block->source_file, "save:\n");

  tgx_emit_save_block(gx, optimized); 

  /* emit tail end of function */ 
  fprintf(block->source_file, "\n");
  fprintf(block->source_file, "  return rc;\n");
  fprintf(block->source_file, "}\n"); 

  /* emit tail end of source */
  tgx_emit_post_function(gx, optimized); 

  /* close source file */ 
  fclose(block->source_file);
  block->source_file = NULL;

  /* compile source & produce shared object */

  sprintf(compile_command, 
	  "gxtool --silent --mode=compile gcc -c -g %s %s",
	  (optimized ? "-O3" : "-O"), block->source_name);

  rc = system(compile_command);
  if(rc != 0)
    {
      sim_io_error(sd, "Error during compiling: `%s' rc %d",
		   compile_command, rc);
    }

  /* link source */

  sprintf(compile_command,
	  "gxtool --silent --mode=link gcc -export-dynamic -rpath %s -g -o lib%s.la %s.lo",
	  dir_name, base_name, base_name);

  rc = system(compile_command);
  if(rc != 0)
    {
      sim_io_error(sd, "Error during linking: `%s' rc %d",
		   compile_command, rc);
    }


  /* install */

  sprintf(compile_command,
	  "gxtool --silent --mode=install cp lib%s.la %s/%s >/dev/null 2>/dev/null",
	  base_name, pwd_name, dir_name);

  rc = system(compile_command);
  if(rc != 0)
    {
      sim_io_error(sd, "Error during install: `%s' rc %d",
		   compile_command, rc);
    }


  /* finish */

  sprintf(compile_command,
	  "gxtool --silent --mode=finish %s >/dev/null 2>/dev/null",
	  dir_name);

  rc = system(compile_command);
  if(rc != 0)
    {
      sim_io_error(sd, "Error during finish: `%s' rc %d",
		   compile_command, rc);
    }

  /* clean up */

  sprintf(compile_command, "rm -f lib%s.la %s.lo", base_name, base_name);
  rc = system(compile_command);
  if(rc != 0)
    {
      sim_io_error(sd, "Error during cleanup: `%s' rc %d",
		   compile_command, rc);
    }

  /* XXX: FILL IN  block->object_name from .la file */
  sprintf(block->object_name, "%s/%s/lib%s.so.0",
	  pwd_name, dir_name, base_name);

  /* measure compile time */
  time_end = time(NULL);

  if(time_end == time_begin) time_end ++; /* clamp minimum duration to 1 */
  gx->compile_time += time_end - time_begin;
  /* fprintf(stderr, "*** compile time: %d\n", gx->compile_time); */
}