// Copyright 2019 The Cobalt Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef STARBOARD_ELF_LOADER_ELF_H_
#define STARBOARD_ELF_LOADER_ELF_H_

// Subset of the ELF specification for loading Dynamic Shared Libraries.
// System V Application Binary Interface - DRAFT - 10 June 2013
// http://www.sco.com/developers/gabi/latest/contents.html

#ifndef __cplusplus
#error "Only C++ files can include this header."
#endif

#include "starboard/types.h"

namespace starboard {
namespace elf_loader {

// 32 bit data types

// Unsigned program address - 4 bytes.
typedef uint32_t Elf32_Addr;

// Unsigned medium integer - 2 bytes.
typedef uint16_t Elf32_Half;

// Unsigned file offset - 4 bytes.
typedef uint32_t Elf32_Off;

// Signed large integer - 4 bytes.
typedef int32_t Elf32_Sword;

// Unsigned large integer - 4 bytes.
typedef uint32_t Elf32_Word;

// 64 bit data types

// Unsigned program address - 8 bytes.
typedef uint64_t Elf64_Addr;

// Unsigned file offset - 8 bytes.
typedef uint64_t Elf64_Off;

// Unsigned medium intege 2 - bytes.
typedef uint16_t Elf64_Half;

// Unsigned integer - 4 bytes.
typedef uint32_t Elf64_Word;

// Signed integer - 4 bytes.
typedef int32_t Elf64_Sword;

// Unsigned long integer - 8 bytes.
typedef uint64_t Elf64_Xword;

// Signed long integer - 8 bytes.
typedef int64_t Elf64_Sxword;

#define EI_NIDENT (16)

// Pack all the structs at 1 byte alignment.
#pragma pack(push)
#pragma pack(1)

// 32 bit ELF file header.
typedef struct {
  // The initial bytes mark the file as an object file and provide
  // machine-independent data.
  unsigned char e_ident[EI_NIDENT];

  // The object file type. We support only ET_DYN.
  Elf32_Half e_type;

  // Architecture of the file.
  Elf32_Half e_machine;

  // Object file version. The value should be 1.
  Elf32_Word e_version;

  // Virtual address to which the system first transfers
  // control, thus starting the process.
  Elf32_Addr e_entry;

  // Program header table's file offset in bytes.
  Elf32_Off e_phoff;

  // Section header table's file offset in bytes.
  Elf32_Off e_shoff;

  // Processor-specific flags associated with the file.
  Elf32_Word e_flags;

  // ELF header's size in bytes.
  Elf32_Half e_ehsize;

  // Size in bytes of one entry in the file's program  header table
  Elf32_Half e_phentsize;

  // The number of entries in the program header table.
  Elf32_Half e_phnum;

  // Section header's size in bytes.
  Elf32_Half e_shentsize;

  // The number of entries in the section header table.
  Elf32_Half e_shnum;

  // The section header table index of the entry associated
  // with the section name string table.
  Elf32_Half e_shstrndx;
} Elf32_Ehdr;

// 64 bit ELF file header.
typedef struct {
  // The initial bytes mark the file as an object file and provide
  // machine-independent data.
  unsigned char e_ident[EI_NIDENT];

  // The object file type. We support only ET_DYN.
  Elf64_Half e_type;

  // Architecture of the file.
  Elf64_Half e_machine;

  // Object file version. The value should be 1.
  Elf64_Word e_version;

  // Virtual address to which the system first transfers
  // control, thus starting the process.
  Elf64_Addr e_entry;

  // Program header table's file offset in bytes.
  Elf64_Off e_phoff;

  // Section header table's file offset in bytes.
  Elf64_Off e_shoff;

  // Processor-specific flags associated with the file.
  Elf64_Word e_flags;

  // This member holds the ELF header's size in bytes.
  Elf64_Half e_ehsize;

  // Size in bytes of one entry in the file's program  header table
  Elf64_Half e_phentsize;

  // The number of entries in the section header table.
  Elf64_Half e_phnum;

  // Section header's size in bytes.
  Elf64_Half e_shentsize;

  // The number of entries in the section header table.
  Elf64_Half e_shnum;

  // The section header table index of the entry associated
  // with the section name string table.
  Elf64_Half e_shstrndx;
} Elf64_Ehdr;

// 32 bit Program header.
typedef struct {
  // The kind of segment this array element describes.
  Elf32_Word p_type;

  // The offset from the beginning of the file at which the
  // first byte of the segment resides.
  Elf32_Off p_offset;

  // The virtual address at which the first byte of the
  // segment resides in memory.
  Elf32_Addr p_vaddr;

  // Segment's physical address. Unused for shared libraries.
  Elf32_Addr p_paddr;

  // The number of bytes in the file image of the segment.  May be zero.
  Elf32_Word p_filesz;

  // The number of bytes in the memory image of the segment.  May be zero.
  Elf32_Word p_memsz;

  // Segment flags
  Elf32_Word p_flags;

  // Segment alignment constraint.
  Elf32_Word p_align;
} Elf32_Phdr;

// 64 bit Program header.
typedef struct {
  // The kind of segment this array element describes.
  Elf64_Word p_type;

  // Segment flags
  Elf64_Word p_flags;

  // The offset from the beginning of the file at which the
  // first byte of the segment resides.
  Elf64_Off p_offset;

  // The virtual address at which the first byte of the
  // segment resides in memory.
  Elf64_Addr p_vaddr;

  // Segment's physical address. Unused for shared libraries.
  Elf64_Addr p_paddr;

  // The number of bytes in the file image of the segment. May be zero.
  Elf64_Xword p_filesz;

  // The number of bytes in the memory image of the segment.  May be zero.
  Elf64_Xword p_memsz;

  // Segment alignment constraint
  Elf64_Xword p_align;
} Elf64_Phdr;

// 32 bit Dynamic Section Entry
typedef struct {
  // Controls the interpretation of d_un.
  Elf32_Sword d_tag;
  union {
    // These objects represent integer values with various interpretations.
    Elf32_Word d_val;
    // These objects represent program virtual addresses.
    Elf32_Addr d_ptr;
  } d_un;
} Elf32_Dyn;

// 64 bit Dynamic Section Entry
typedef struct {
  // Controls the interpretation of d_un.
  Elf64_Sxword d_tag;
  union {
    // These objects represent integer values with various interpretations.
    Elf64_Xword d_val;
    // These objects represent program virtual addresses.
    Elf64_Addr d_ptr;
  } d_un;
} Elf64_Dyn;

// 32 bit Symbol Table Entry
typedef struct {
  // An index into the object file's symbol string table,
  // which holds the character representations of the symbol names. If the value
  // is non-zero, it represents a string table index that gives the symbol name.
  // Otherwise, the symbol table entry has no name.
  Elf32_Word st_name;

  // The value of the associated symbol. Depending on the
  // context, this may be an absolute value, an address, and so on;
  Elf32_Addr st_value;

  // Many symbols have associated sizes. For example, a data object's size is
  // the number of bytes contained in the object.
  Elf32_Word st_size;

  // The symbol's type and binding attributes.
  unsigned char st_info;

  // Symbol's visibility.
  unsigned char st_other;

  // Every symbol table entry is defined in relation to some section. This
  // member holds the relevant section header table index.
  Elf32_Half st_shndx;
} Elf32_Sym;

// 64 bit Symbol Table Entry
typedef struct {
  // An index into the object file's symbol string table,
  // which holds the character representations of the symbol names. If the value
  // is non-zero, it represents a string table index that gives the symbol name.
  // Otherwise, the symbol table entry has no name.
  Elf64_Word st_name;

  // The symbol's type and binding attributes.
  unsigned char st_info;

  // Symbol's visibility.
  unsigned char st_other;

  // Every symbol table entry is defined in relation to some section. This
  // member holds the relevant section header table index.
  Elf64_Half st_shndx;

  // The value of the associated symbol. Depending on the
  // context, this may be an absolute value, an address, and so on;
  Elf64_Addr st_value;

  // Many symbols have associated sizes. For example, a data object's size is
  // the number of bytes contained in the object.
  Elf64_Xword st_size;
} Elf64_Sym;

// 32 bit Relocation Entry
typedef struct {
  // The location at which to apply the relocation action. For  a relocatable
  // file, the value is the byte offset from the beginning of the  section to
  // the storage unit affected by the relocation. For an executable file or a
  // shared object, the value is the virtual address of the storage unit
  // affected by the relocation.
  Elf32_Addr r_offset;
  // The symbol table index with respect to which the
  // relocation must be made, and the type of relocation to apply.
  Elf32_Word r_info;
} Elf32_Rel;

// 64 bit Relocation Entry
typedef struct {
  // The location at which to apply the relocation action. For
  // a relocatable file, the value is the byte offset from the beginning of the
  // section to the storage unit affected by the relocation. For an executable
  // file or a shared object, the value is the virtual address of the storage
  // unit affected by the relocation.
  Elf64_Addr r_offset;

  // The symbol table index with respect to which the
  // relocation must be made, and the type of relocation to apply.
  Elf64_Xword r_info;
} Elf64_Rel;

// 32 bit Relocation Entry with Addend.
typedef struct {
  // The location at which to apply the relocation action. For
  // a relocatable file, the value is the byte offset from the beginning of the
  // section to the storage unit affected by the relocation. For an executable
  // file or a shared object, the value is the virtual address of the storage
  // unit affected by the relocation.
  Elf32_Addr r_offset;

  // The symbol table index with respect to which the
  // relocation must be made, and the type of relocation to apply.
  Elf32_Word r_info;

  // A constant addend used to compute the value to be stored into the
  // relocatable field.
  Elf32_Sword r_addend;
} Elf32_Rela;

// 64 bit Relocation Entry with Addend.
typedef struct {
  // The location at which to apply the relocation action. For  a relocatable
  // file, the value is the byte offset from the beginning of the section to the
  // storage unit affected by the relocation. For an executable file or a shared
  // object, the value is the virtual address of the storage unit affected by
  // the relocation.
  Elf64_Addr r_offset;

  // The symbol table index with respect to which the
  // relocation must be made, and the type of relocation to apply.
  Elf64_Xword r_info;

  // A constant addend used to compute the value to be stored into the
  // relocatable field.
  Elf64_Sxword r_addend;
} Elf64_Rela;

#pragma pack(pop)

#define EI_CLASS 4
#define ELFCLASS32 1
#define ELFCLASS64 2
#define EI_DATA 5
#define ELFDATA2LSB 1
#define ET_DYN 3
#define EV_CURRENT 1

#if SB_HAS(32_BIT_POINTERS)
typedef Elf32_Ehdr Ehdr;
typedef Elf32_Phdr Phdr;
typedef Elf32_Addr Addr;
typedef Elf32_Dyn Dyn;
typedef Elf32_Word Word;
typedef Elf32_Sym Sym;
typedef Elf32_Rel Rel;
typedef Elf32_Rela Rela;
typedef Elf32_Word Relr;
typedef Elf32_Sword Sword;
#define ELF_BITS 32
#define ELF_R_TYPE ELF32_R_TYPE
#define ELF_R_SYM ELF32_R_SYM
#define ELF_CLASS_VALUE ELFCLASS32
#elif SB_HAS(64_BIT_POINTERS)
typedef Elf64_Ehdr Ehdr;
typedef Elf64_Phdr Phdr;
typedef Elf64_Addr Addr;
typedef Elf64_Dyn Dyn;
typedef Elf64_Word Word;
typedef Elf64_Sym Sym;
typedef Elf64_Rel Rel;
typedef Elf64_Rela Rela;
typedef Elf64_Word Relr;
typedef Elf64_Sword Sword;
#define ELF_BITS 64
#define ELF_R_TYPE ELF64_R_TYPE
#define ELF_R_SYM ELF64_R_SYM
#define ELF_CLASS_VALUE ELFCLASS64
#else
#error "Unsupported pointer size"
#endif

#define ELF32_R_SYM(val) ((val) >> 8)
#define ELF32_R_TYPE(val) ((val)&0xff)
#define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type)&0xff))

#define ELF64_R_SYM(i) ((i) >> 32)
#define ELF64_R_TYPE(i) ((i)&0xffffffff)
#define ELF64_R_INFO(sym, type) ((((Elf64_Xword)(sym)) << 32) + (type))

#define ELFMAG "\177ELF"
#define SELFMAG 4

// TODO: Refactor the code to detect it at runtime
// using DT_PLTREL.
#if (SB_IS(ARCH_ARM) || SB_IS(ARCH_X86)) && SB_IS(64_BIT)
#define USE_RELA
#endif

#if defined(USE_RELA)
typedef Rela rel_t;
#else
typedef Rel rel_t;
#endif

#if SB_IS(ARCH_ARM) && SB_IS(32_BIT)
#define ELF_MACHINE 40
#elif SB_IS(ARCH_X86) && SB_IS(32_BIT)
#define ELF_MACHINE 3
#elif SB_IS(ARCH_X86) && SB_IS(64_BIT)
#define ELF_MACHINE 62
#elif SB_IS(ARCH_ARM) && SB_IS(64_BIT)
#define ELF_MACHINE 183
#else
#error "Unsupported target CPU architecture"
#endif

// Segment types.
typedef enum SegmentTypes {
  // Unused segment.
  PT_NULL = 0,

  // Loadable segment.
  PT_LOAD = 1,

  // Dynamic linking information.
  PT_DYNAMIC = 2,

  // Interpreter pathname.
  PT_INTERP = 3,

  // Auxiliary information.
  PT_NOTE = 4,

  // Reserved.
  PT_SHLIB = 5,

  // The program header table itself.
  PT_PHDR = 6,

  // The thread-local storage template.
  PT_TLS = 7
} SegmentTypes;

// Symbol bindings.
typedef enum SymbolBindings {
  // Local symbol, not visible outside obj file containing def
  STB_LOCAL = 0,

  // Global symbol, visible to all object files being combined
  STB_GLOBAL = 1,

  // Weak symbol, like global but lower-precedence
  STB_WEAK = 2,

  STB_GNU_UNIQUE = 10,

  // Lowest operating system-specific binding type
  STB_LOOS = 10,

  // Highest operating system-specific binding type
  STB_HIOS = 12,

  // Lowest processor-specific binding type
  STB_LOPROC = 13,

  // Highest processor-specific binding type
  STB_HIPROC = 15
} SymbolBindings;

#define ELF_ST_BIND(x) ((x) >> 4)
#define ELF32_ST_BIND(x) ELF_ST_BIND(x)
#define ELF64_ST_BIND(x) ELF_ST_BIND(x)

#define PF_X (1 << 0)
#define PF_W (1 << 1)
#define PF_R (1 << 2)
#define PF_MASKOS 0x0ff00000
#define PF_MASKPROC 0xf0000000

// Dynamic table tags.
typedef enum DynamicTags {
  DT_NULL = 0,
  DT_NEEDED = 1,
  DT_PLTRELSZ = 2,
  DT_PLTGOT = 3,
  DT_HASH = 4,
  DT_STRTAB = 5,
  DT_SYMTAB = 6,
  DT_RELA = 7,
  DT_RELASZ = 8,
  DT_RELAENT = 9,
  DT_STRSZ = 10,
  DT_SYMENT = 11,
  DT_INIT = 12,
  DT_FINI = 13,
  DT_SONAME = 14,
  DT_RPATH = 15,
  DT_SYMBOLIC = 16,
  DT_REL = 17,
  DT_RELSZ = 18,
  DT_RELENT = 19,
  DT_PLTREL = 20,
  DT_DEBUG = 21,
  DT_TEXTREL = 22,
  DT_JMPREL = 23,
  DT_BIND_NOW = 24,
  DT_INIT_ARRAY = 25,
  DT_FINI_ARRAY = 26,
  DT_INIT_ARRAYSZ = 27,
  DT_FINI_ARRAYSZ = 28,
  DT_RUNPATH = 29,
  DT_FLAGS = 30,
  DT_ENCODING = 32,
  DT_PREINIT_ARRAY = 32,
  DT_PREINIT_ARRAYSZ = 33,
  DT_SYMTAB_SHNDX = 34,
  DT_RELRSZ = 35,
  DT_RELR = 36,
  DT_RELRENT = 37,
  DT_LOOS = 0x6000000D,
  DT_ANDROID_REL = 0x6000000F,
  DT_ANDROID_RELSZ = 0x60000010,
  DT_ANDROID_RELA = 0x60000011,
  DT_ANDROID_RELASZ = 0x60000012,
  DT_HIOS = 0x6ffff000,
  DT_ANDROID_RELR = 0x6fffe000,
  DT_ANDROID_RELRSZ = 0x6fffe001,
  DT_ANDROID_RELRENT = 0x6fffe003,
  DT_GNU_HASH = 0x6ffffef5,
  DT_LOPROC = 0x70000000,
  DT_HIPROC = 0x7fffffff,
} DynamicTags;

typedef enum DynamicFlags {
  // This flag signifies that the object being loaded may make reference to the
  DF_ORIGIN = 0x00000001,

  // If this flag is set in a shared object library, the dynamic linker's symbol
  // resolution algorithm for references within the library is changed. Instead
  // of starting a symbol search with the executable file, the dynamic linker
  // starts from the shared object itself. If the shared object fails to supply
  // the referenced symbol, the dynamic linker then searches the executable file
  // and other shared objects as usual.
  DF_SYMBOLIC = 0x00000002,

  //  This flag is not set, no relocation entry should cause a modification to a
  //  non-writable segment, as specified by the segment permissions in the
  //  program header table.
  DF_TEXTREL = 0x00000004,

  // If set in a shared object or executable, this flag instructs the dynamic
  // linker to process all relocations for the object containing this entry
  // before transferring control to the program.
  DF_BIND_NOW = 0x00000008,

  // If set in a shared object or executable, this flag instructs the dynamic
  // linker to reject attempts to load this file dynamically. It indicates that
  // the shared object or executable contains code using a static thread-local
  // storage scheme. Implementations need not support any form of thread-local
  // storage.
  DF_STATIC_TLS = 0x00000010,
} DynamicFalgs;

// Relocation types per CPU architecture
#if SB_IS(ARCH_ARM) && SB_IS(32_BIT)
typedef enum RelocationTypes {
  R_ARM_ABS32 = 2,
  R_ARM_REL32 = 3,
  R_ARM_GLOB_DAT = 21,
  R_ARM_JUMP_SLOT = 22,
  R_ARM_COPY = 20,
  R_ARM_RELATIVE = 23,
} RelocationTypes;
#elif SB_IS(ARCH_ARM) && SB_IS(64_BIT)
typedef enum RelocationTypes {
  R_AARCH64_ABS64 = 257,
  R_AARCH64_COPY = 1024,
  R_AARCH64_GLOB_DAT = 1025,
  R_AARCH64_JUMP_SLOT = 1026,
  R_AARCH64_RELATIVE = 1027,
} RelocationTypes;
#elif SB_IS(ARCH_X86) && SB_IS(32_BIT)
typedef enum RelocationTypes {
  R_386_32 = 1,
  R_386_PC32 = 2,
  R_386_GLOB_DAT = 6,
  R_386_JMP_SLOT = 7,
  R_386_RELATIVE = 8,
} RelocationTypes;
#elif SB_IS(ARCH_X86) && SB_IS(64_BIT)
typedef enum RelocationTypes {
  R_X86_64_64 = 1,
  R_X86_64_PC32 = 2,
  R_X86_64_GLOB_DAT = 6,
  R_X86_64_JMP_SLOT = 7,
  R_X86_64_RELATIVE = 8,
} RelocationTypes;
#else
#error "Unsupported architecture for relocations."
#endif

// Helper macros for memory page computations.
#ifndef PAGE_SIZE
#define PAGE_SHIFT 12
#define PAGE_SIZE (1UL << PAGE_SHIFT)
#define PAGE_MASK (~(PAGE_SIZE - 1))
#endif

#define PAGE_START(x) ((x)&PAGE_MASK)
#define PAGE_OFFSET(x) ((x) & ~PAGE_MASK)
#define PAGE_END(x) PAGE_START((x) + (PAGE_SIZE - 1))

#define SHN_UNDEF 0

}  // namespace elf_loader
}  // namespace starboard
#endif  // STARBOARD_ELF_LOADER_ELF_H_