/* This file is part of SIS (SPARC/RISCV instruction simulator)

   Copyright (C) 2019 Free Software Foundation, Inc.
   Contributed by Jiri Gaisler, Sweden.

   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/>.  */

/* Very simple ELF program loader, only tested with RTEMS */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#ifdef WIN32
#include <winsock.h>
#else
#include <netinet/in.h>
#endif
#include <elf.h>
#include <ctype.h>
#include "sis.h"

struct elf_file
{
  FILE *fp;
  Elf32_Ehdr ehdr;
  char *strtab;
  int arch;
  int cpu;
  int bswap;
};

static struct elf_file efile;

static int
read_elf_header (FILE * fp)
{
  Elf32_Ehdr ehdr;

  fseek (fp, 0, SEEK_SET);
  if (fread (&ehdr, sizeof (ehdr), 1, fp) != 1)
    {
      return (-1);
    }
  efile.fp = fp;

  if ((ehdr.e_ident[EI_MAG0] != 0x7f) ||
      strncmp ((char *) &ehdr.e_ident[EI_MAG1], "ELF", 3) != 0)
    {
      return (-1);
    }
#ifdef HOST_LITTLE_ENDIAN
  if (ehdr.e_ident[EI_DATA] == ELFDATA2MSB)
#else
  if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB)
#endif
    {
      efile.bswap = 1;
    }
  if (efile.bswap)
    {
      ehdr.e_entry = SWAP_UINT32 (ehdr.e_entry);
      ehdr.e_shoff = SWAP_UINT32 (ehdr.e_shoff);
      ehdr.e_phoff = SWAP_UINT32 (ehdr.e_phoff);
      ehdr.e_phnum = SWAP_UINT16 (ehdr.e_phnum);
      ehdr.e_shnum = SWAP_UINT16 (ehdr.e_shnum);
      ehdr.e_phentsize = SWAP_UINT16 (ehdr.e_phentsize);
      ehdr.e_shentsize = SWAP_UINT16 (ehdr.e_shentsize);
      ehdr.e_shstrndx = SWAP_UINT16 (ehdr.e_shstrndx);
      ehdr.e_machine = SWAP_UINT16 (ehdr.e_machine);
    }

  switch (ehdr.e_machine)
    {
    case EM_SPARC:
      if (sis_verbose)
	printf ("SPARC executable\n");
      efile.arch = CPU_SPARC;
      if (ehdr.e_entry == 0)
	efile.cpu = CPU_LEON4;
      else if (ehdr.e_entry == 0x40000000)
	efile.cpu = CPU_LEON3;
      else if (ehdr.e_entry == 0x2000000)
	efile.cpu = CPU_ERC32;
      break;
    case EM_RISCV:
      if (sis_verbose)
	printf ("RISCV executable\n");
      efile.arch = CPU_RISCV;
      if (ehdr.e_entry == 0x40000000)
	efile.cpu = CPU_LEON3;
      else if (ehdr.e_entry == 0x80000000)
	efile.cpu = CPU_RISCV;
      break;
    default:
      printf ("Unknown architecture (%d)\n", ehdr.e_machine);
      return (-1);
    }

  if (ehdr.e_ident[EI_CLASS] != 1)
    {
      printf ("Only 32-bit ELF supported!\n");
      return (-1);
    }
  efile.ehdr = ehdr;
  ebase.cpu = efile.cpu;
  ebase.arch = efile.arch;
  return (ehdr.e_entry);
}

static int
read_elf_body ()
{
  Elf32_Ehdr ehdr = efile.ehdr;
  Elf32_Shdr sh, ssh;
  Elf32_Phdr ph[16];
  char *strtab;
  char *mem;
  uint32 *memw, i, j, k, vaddr;
  int bswap = efile.bswap;
  FILE *fp = efile.fp;

  fseek (fp, ehdr.e_shoff + ((ehdr.e_shstrndx) * ehdr.e_shentsize), SEEK_SET);
  if ((!fp) || (fread (&ssh, sizeof (ssh), 1, fp) != 1))
    {
      return (-1);
    }

  /* endian swap if big-endian target */
  if (bswap)
    {
      ssh.sh_name = SWAP_UINT32 (ssh.sh_name);
      ssh.sh_type = SWAP_UINT32 (ssh.sh_type);
      ssh.sh_offset = SWAP_UINT32 (ssh.sh_offset);
      ssh.sh_size = SWAP_UINT32 (ssh.sh_size);
    }
  strtab = (char *) malloc (ssh.sh_size);
  fseek (fp, ssh.sh_offset, SEEK_SET);
  if (fread (strtab, ssh.sh_size, 1, fp) != 1)
    {
      return (-1);
    }

  for (i = 0; i < ehdr.e_phnum; i++)
    {
      fseek (fp, ehdr.e_phoff + (i * ehdr.e_phentsize), SEEK_SET);
      if (fread (&ph[i], ehdr.e_phentsize, 1, fp) != 1)
	{
	  return (-1);
	}
      if (bswap)
	{
	  ph[i].p_type = SWAP_UINT32 (ph[i].p_type);
	  ph[i].p_offset = SWAP_UINT32 (ph[i].p_offset);
	  ph[i].p_vaddr = SWAP_UINT32 (ph[i].p_vaddr);
	  ph[i].p_paddr = SWAP_UINT32 (ph[i].p_paddr);
	  ph[i].p_filesz = SWAP_UINT32 (ph[i].p_filesz);
	  ph[i].p_memsz = SWAP_UINT32 (ph[i].p_memsz);
	}
    }

  for (i = 1; i < ehdr.e_shnum; i++)
    {
      fseek (fp, ehdr.e_shoff + (i * ehdr.e_shentsize), SEEK_SET);
      if (fread (&sh, sizeof (sh), 1, fp) != 1)
	{
	  return (-1);
	}
      if (bswap)
	{
	  sh.sh_name = SWAP_UINT32 (sh.sh_name);
	  sh.sh_addr = SWAP_UINT32 (sh.sh_addr);
	  sh.sh_size = SWAP_UINT32 (sh.sh_size);
	  sh.sh_type = SWAP_UINT32 (sh.sh_type);
	  sh.sh_offset = SWAP_UINT32 (sh.sh_offset);
	  sh.sh_flags = SWAP_UINT32 (sh.sh_flags);
	}

      if ((sh.sh_type != SHT_NOBITS) && (sh.sh_size)
	  && (sh.sh_flags & SHF_ALLOC))
	{
	  for (k = 0; k < ehdr.e_phnum; k++)
	    {
	      if ((sh.sh_addr >= ph[k].p_vaddr) &&
		  ((sh.sh_addr + sh.sh_size) <=
		   (ph[k].p_vaddr + ph[k].p_filesz)))
		{
		  vaddr = sh.sh_addr;
		  sh.sh_addr = sh.sh_addr - ph[k].p_vaddr + ph[k].p_paddr;
		  break;
		}
	    }
	  if (sis_verbose)
	    printf ("section: %s at 0x%x, size %d bytes\n",
		    &strtab[sh.sh_name], sh.sh_addr, sh.sh_size);
	  mem = calloc (sh.sh_size / 4 + 1, 4);
	  if (mem != NULL)
	    {
	      if ((sh.sh_type == SHT_PROGBITS)
		  || (sh.sh_type == SHT_INIT_ARRAY)
		  || (sh.sh_type == SHT_FINI_ARRAY))
		{
		  fseek (fp, sh.sh_offset, SEEK_SET);
		  if (fread (mem, sh.sh_size, 1, fp) != 1)
		    {
		      return (-1);
		    }
		  memw = (unsigned int *) mem;
		  if (bswap)
		    for (j = 0; j < (sh.sh_size) / 4 + 1; j++)
		      memw[j] = SWAP_UINT32 (memw[j]);
		  ms->sis_memory_write (sh.sh_addr, mem,
					(sh.sh_size / 4 + 1) * 4);
		}
	    }
	  else
	    {
	      return (-1);
	    }
	  free (mem);
	}
    }

  free (strtab);
  return (ehdr.e_entry);
}

int
elf_load (char *fname, int load)
{
  FILE *fp;
  int res;

  if ((fp = fopen (fname, "rb")) == NULL)
    {
      printf ("file not found\n");
      return (-1);
    }


  res = read_elf_header (fp);
  if (res == -1)
    printf ("File read error\n");

  else if (load)
    {
      res = read_elf_body ();
      if (res == -1)
	printf ("File read error\n");
      else
	printf (" Loaded %s, entry 0x%08x\n", fname, res);
      fclose (efile.fp);
    }
  return res;

}