// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <tools/elfdefs.h>

#define MAXPATHNAMELENGTH 2000
#define MAXSYMBOLLENGTH 2000

#define writef(f, d, n, s) if ( 1 != fwrite(d, n, 1, f)) { croak(s); }

void croak(char * s)
{
  printf("GENSTUB ERROR: %s\n", s);
  exit(EXIT_FAILURE);
}

long codeSectionData [] = 
{
  0xe51ff004,    // LDR      pc,0x4
  0x00000000     // the pointer to the imported code
};


#define COMMENTSTRING "\tAndy's magic stub generator vsn 0.2\n"
char commentSectionData[] = // "\tAndy's magic stub generator vsn 0.2\n"
{ 
  '\t','A','n','d','y','\'','s',' ','m','a','g','i','c',' ',
  's','t','u','b',' ','g','e','n','e','r','a','t','o','r',' ',
  'v','s','n',' ','0','.','2','\n'
};

char directiveSectionData[] = // "#<SYMEDIT>\nIMPORT "
{
  '#','<','S','Y','M','E','D','I','T','>','\n',
  'I','M','P','O','R','T',' '
};

char strtabSectionData [] =
{
  0,'$','a',0,                                                          // $a
  '$','d',0,                                                            // $d
  'S','t','u','b','C','o','d','e',0,                                    // StubCode
  '.','d','i','r','e','c','t','i','v','e',0,                            // .directive
  't','h','e','I','m','p','o','r','t','e','d','S','y','m','b','o','l',0 // theImportSymbol
};

Elf32_Sym symtabSectionData[] =
{
  // undefined symbol
  {
    0, // st_name
    0, // st_value
    0, // st_size
    0, // st_info
    0, // st_other
    0  // stshndx
  },
  // $a
  {
    1, // st_name
    0, // st_value
    0, // st_size
    ELF32_ST_INFO(STB_LOCAL,STT_FUNC), // st_info
    0, // st_other
    1  // stshndx
  },
  // $d
  {
    4, // st_name
    4, // st_value
    0, // st_size
    ELF32_ST_INFO(STB_LOCAL,STT_OBJECT), // st_info
    0, // st_other
    1  // stshndx
  },
  // StubCode
  {
    7, // st_name
    0, // st_value
    sizeof(codeSectionData), // st_size
    ELF32_ST_INFO(STB_LOCAL,STT_SECTION), // st_info
    0, // st_other
    1  // stshndx
  },
  // .directive
#define DIRECTIVESYMNDX 4
  {
    16,// st_name
    0, // st_value
    0, // st_size - to be filled on
    ELF32_ST_INFO(STB_LOCAL,STT_SECTION), // st_info
    0, // st_other
    3  // stshndx
  },
  // theImportedSymbol
  {
    27, // st_name
    4, // st_value
    0, // st_size
    ELF32_ST_INFO(STB_LOCAL,STT_FUNC), // st_info
    0, // st_other
    1  // stshndx
  },

  // the exported symbol
#define EXPORTEDSYMBOLSTRNDX 45
  {
    EXPORTEDSYMBOLSTRNDX, // st_name
    0, // st_value
    0, // st_size
    ELF32_ST_INFO(STB_GLOBAL,STT_FUNC), // st_info
    0, // st_other
    1  // stshndx
  },
  // the imported symbol
#define IMPORTEDSYMBOLSYMNDX 7
  {
    0, // st_name - needs to be filled in = EXPORTEDSYMBOLSTRNDX + strlen(exportedSymbol) + 1
    0, // st_value
    0, // st_size
    ELF32_ST_INFO(STB_GLOBAL,STT_NOTYPE), // st_info
    0, // st_other
    SHN_UNDEF  // stshndx
  }
};

Elf32_Rel relocSectionData [] =
{
  {
    0x00000004, // r_offset
    ELF32_R_INFO(IMPORTEDSYMBOLSYMNDX, R_ARM_ABS32)
  }
};

char shstrtabSectionData []= 
{
  0,'S','t','u','b','C','o','d','e',0,                 // StubCode
  '.','r','e','l','S','t','u','b','C','o','d','e',0,   // .relStubCode
  '.','d','i','r','e','c','t','i','v','e',0,           // .directive
  '.','s','y','m','t','a','b',0,                       // .symtab
  '.','s','t','r','t','a','b',0,                       // .strtab
  '.','c','o','m','m','e','n','t',0,                  // .comment
  '.','s','h','s','t','r','t','a','b',0                // .shstrtab
};

Elf32_Shdr SectionHeaderTable[] = 
{
  // dummy section
  {
    0,             // sh_name - to be filled
    SHT_NULL,      // sh_type
    0,             // sh_flags
    0,             // sh_addr
    0,             // sh_offset - file offset of this section - to be filled in
    0,             // sh_size - to be filled in
    0,             // sh_link
    0,             // sh_info
    0,             // sh_addralign
    0              // sh_entsize
  },

  // StubCode section
#define CODEINDEX 1
#define CODEOFFSET (sizeof(Elf32_Ehdr) + (8 * sizeof(Elf32_Shdr)))
#define CODESIZE (sizeof(codeSectionData))
  {
    1,             // sh_name 
    SHT_PROGBITS,  // sh_type
    SHF_ALLOC + SHF_EXECINSTR, // sh_flags
    0,             // sh_addr
    CODEOFFSET,    // sh_offset 
    CODESIZE,      // sh_size
    SHN_UNDEF,     // sh_link
    0,             // sh_info
    4,             // sh_addralign
    0              // sh_entsize
  },

  // relocation data
#define RELOCINDEX 2
#define RELOCOFFSET (CODEOFFSET + CODESIZE)
#define RELOCSIZE (sizeof(relocSectionData))
  {
    10,            // sh_name - to be filled
    SHT_REL,       // sh_type
    0,             // sh_flags
    0,             // sh_addr
    RELOCOFFSET,   // sh_offset - file offset of this section - to be filled in
    RELOCSIZE,     // sh_size - there's only one of them
    3,             // sh_link - index of the symbol table we use
    1,             // sh_info - refers to section 1
    0,             // sh_addralign
    sizeof(Elf32_Rel) // sh_entsize
  },

  // .symtab
#define SYMTABINDEX 3
#define SYMTABOFFSET (RELOCOFFSET + RELOCSIZE)
#define SYMTABSIZE sizeof(symtabSectionData)
{
    34,            // sh_name 
    SHT_SYMTAB,    // sh_type
    0,             // sh_flags
    0,             // sh_addr
    SYMTABOFFSET,  // sh_offset
    SYMTABSIZE, // sh_size
    7,             // sh_link - .strtab - the string table section
    6,             // sh_info - last local symbol
    0,             // sh_addralign
    sizeof(Elf32_Sym)// sh_entsize
  },

  // .comment
#define COMMENTINDEX 4
#define COMMENTOFFSET (SYMTABOFFSET + SYMTABSIZE)
#define COMMENTSIZE (sizeof(commentSectionData))
{
    50,            // sh_name 
    SHT_PROGBITS,  // sh_type
    0,             // sh_flags
    0,             // sh_addr
    COMMENTOFFSET, // sh_offset
    COMMENTSIZE,   // sh_size - to be filled in
    SHN_UNDEF,     // sh_link
    0,             // sh_info
    0,             // sh_addralign
    0              // sh_entsize
  },


  // .shstrtab
#define SHSTRTABINDEX 5
#define SHSTRTABOFFSET (COMMENTOFFSET + COMMENTSIZE)
#define SHSTRTABSIZE sizeof(shstrtabSectionData)
  {
    59,            // sh_name 
    SHT_STRTAB,    // sh_type
    0,             // sh_flags
    0,             // sh_addr
    SHSTRTABOFFSET,// sh_offset
    SHSTRTABSIZE,  // sh_size - to be filled in
    SHN_UNDEF,     // sh_link
    0,             // sh_info
    0,             // sh_addralign
    0              // sh_entsize
      },

  // .directive section
#define DIRECTIVEINDEX 6
#define DIRECTIVEOFFSET SHSTRTABOFFSET + SHSTRTABSIZE
  {
    23,            // sh_name 
    SHT_PROGBITS,  // sh_type
    0,             // sh_flags
    0,             // sh_addr
    DIRECTIVEOFFSET,// sh_offset
    0,             // sh_size - to be filled in
    SHN_UNDEF,     // sh_link 
    0,             // sh_info 
    1,             // sh_addralign
    0              // sh_entsize
  },

  // .strtab
#define STRTABINDEX 7
  {
    42,            // sh_name
    SHT_STRTAB,    // sh_type
    0,             // sh_flags
    0,             // sh_addr
    0,             // sh_offset - to be filled in
    0,             // sh_size - to be filled in
    SHN_UNDEF,     // sh_link
    0,             // sh_info
    0,             // sh_addralign
    0              // sh_entsize
  }
};

#define ELFOBJECTFILEVERSION 1
#define EF_NONE 0x02000000

Elf32_Ehdr headerTemplate = 
{
  {0x7f, 'E', 'L', 'F', 
   ELFCLASS32, ELFDATA2LSB, ELFOBJECTFILEVERSION, 0,
   0, 0, 0, 0,
   0, 0, 0, 0},       // e_ident
  ET_REL,             // e_type
  EM_ARM,             // e_machine
  EV_CURRENT,         // e_version
  0x00000000,         // e_entry
  0,                  // e_phoff
  sizeof(Elf32_Ehdr), // e_shoff
  EF_ARM_EABI_VERSION,// e_flags
  sizeof(Elf32_Ehdr), // e_ehsize
  sizeof(Elf32_Phdr), // e_phentsize
  0,                  // e_phnum
  sizeof(Elf32_Shdr), // e_shentsize
#define SHNUM (sizeof(SectionHeaderTable)/sizeof(Elf32_Shdr))
  SHNUM,              // e_shnum 
  SHSTRTABINDEX       // e_shstrndx
};

void WriteElfHeader(FILE * file);
void WriteSectionHeaderTable(FILE * file);
void WriteCodeSection(FILE * file);
void WriteRelocationSection(FILE * file);
void WriteCommentSection(FILE * file);
void WriteSymtabSection(FILE * file);
void WriteShStrtabSection(FILE * file);
void WriteDirectiveSection(FILE * file, char * import);
void WriteStrtabSection(FILE * file, char * eexport, char * import);

void WriteStubFileX(FILE * file, char * eexport, char * import)
{
  int directiveSize = sizeof(directiveSectionData) + strlen(import) + 1; // terminated by a newline
  int strtabSize = sizeof(strtabSectionData) + strlen(eexport) + strlen(import) + 2; // strings are null terminated

  SectionHeaderTable[DIRECTIVEINDEX].sh_size = directiveSize;
  SectionHeaderTable[STRTABINDEX].sh_offset = DIRECTIVEOFFSET+ directiveSize;
  SectionHeaderTable[STRTABINDEX].sh_size = strtabSize;

  symtabSectionData[IMPORTEDSYMBOLSYMNDX].st_name  = EXPORTEDSYMBOLSTRNDX + strlen(eexport) + 1;

  WriteElfHeader(file);
  WriteSectionHeaderTable(file);
  WriteCodeSection(file);
  WriteRelocationSection(file);
  WriteSymtabSection(file);
  WriteCommentSection(file);
  WriteShStrtabSection(file);
  WriteDirectiveSection(file, import);
  WriteStrtabSection(file, eexport, import);
}

void WriteElfHeader(FILE * file)
{
  writef(file, &headerTemplate, sizeof(headerTemplate), "ELF header");
}

void WriteSectionHeaderTable(FILE * file)
{
  writef(file, &SectionHeaderTable, sizeof(SectionHeaderTable), "Section header table");
}

void CheckFileOffset(FILE * f, int i, char *s)
{
	int o = SectionHeaderTable[i].sh_offset;
	if (ftell(f)!= o) { croak(s); }
}

#define WriteSection(f, i, d, e1, e2) { CheckFileOffset(f, i, e1); writef(f, d, sizeof(d), e2); }

void WriteCodeSection(FILE * file)
{
  WriteSection(file, CODEINDEX, codeSectionData,"StubCode section offset incorrect", "StubCode section");
}

void WriteRelocationSection(FILE * file)
{
  WriteSection(file, RELOCINDEX, relocSectionData,".relStubCode section offset incorrect", ".relStubCode section");
}

void WriteCommentSection(FILE * file)
{
  WriteSection(file, COMMENTINDEX, commentSectionData,".comment section offset incorrect", ".comment section");
}

void WriteSymtabSection(FILE * file)
{
  WriteSection(file, SYMTABINDEX, symtabSectionData,".symtab section offset incorrect", ".symtab section");
}

void WriteShStrtabSection(FILE * file)
{
  WriteSection(file, SHSTRTABINDEX, shstrtabSectionData,".shstrtab section offset incorrect", ".shstrtab section");
}

void WriteDirectiveSection(FILE * file, char * import)
{
  WriteSection(file, DIRECTIVEINDEX, directiveSectionData,
	       ".directive section offset incorrect", ".directive section");
  fprintf(file, "%s\n", import);
}

void WriteStrtabSection(FILE * file, char * eexport, char * import)
{
  char n = 0;
  WriteSection(file, STRTABINDEX, strtabSectionData,".strtab section offset incorrect", ".strtab section");
  fprintf(file, eexport);
  fwrite(&n, sizeof(n), 1, file);
  fprintf(file, import);
  fwrite(&n, sizeof(n), 1, file);
}



void WriteStubFile(char * file, char * eexport, char * import)
{
  FILE * f = fopen(file, "wb");
  if (!f) croak("can't open output file");
  
  WriteStubFileX(f, eexport, import);

  fclose(f);
}


int  main (void)
{
  
  char file[MAXPATHNAMELENGTH], eexport[MAXSYMBOLLENGTH], import[MAXSYMBOLLENGTH];
  
  while (!feof(stdin) && !ferror(stdin)) {
    fscanf(stdin, "%s %s %s\n", file, eexport, import);
    WriteStubFile(file, eexport, import);
  }
  return EXIT_SUCCESS;
}