Subversion Repositories QNX 8.QNX8 IFS tool

// Executable and Linkable Format master header structure type definition

typedef struct elf32_header_s

{

   unsigned char magic[4];                     // offset 0: "\x07" + "ELF"

   unsigned char platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit

   unsigned char endianness;                   // offset 5: 1 = little endian, 2 = big endian

   unsigned char header_version;               // offset 6: typically 1

   unsigned char os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS

   unsigned char spare[8];                     // offset 8: zeroes

   unsigned __int16 type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump

   unsigned __int16 instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V

   unsigned __int32 elf_version;                 // offset 20: typically 1

   unsigned __int32 entrypoint_offset;           // offset 24: offset to program entrypoint

   unsigned __int32 program_header_table_offset; // offset 28: offset to program header table

   unsigned __int32 section_header_table_offset; // offset 32: offset to section header table

   unsigned __int32 flags;                       // offset 36: flags (architecture-dependent, none for x86)

   unsigned __int16 header_size;                 // offset 40: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF -- DO NOT USE sizeof() ON THE elf_header_s STRUCT BECAUSE OF THE UNION! WRITE THE CORRECT SIZE YOURSELF!

   unsigned __int16 program_header_item_size;    // offset 42: size of an entry in the program header table

   unsigned __int16 program_header_table_len;    // offset 44: number of entries in the program header table

   unsigned __int16 section_header_item_size;    // offset 46: size of an entry in the section header table

   unsigned __int16 section_header_table_len;    // offset 48: number of entries in the section header table

   unsigned __int16 section_header_names_idx;    // offset 50: index of the entry in the section header table that contains the section names

} elf32_header_t;

typedef struct elf64_header_s

      {

         unsigned char magic[4];                     // offset 0: "\x07" + "ELF"

         unsigned char platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit

         unsigned char endianness;                   // offset 5: 1 = little endian, 2 = big endian

         unsigned char header_version;               // offset 6: typically 1

         unsigned char os_abi;                       // offset 7: 0 = SysV, 1 = HP/UX, 2 = NetBSD, 3 = Linux, 4 = GNU/Hurd, 6 = Solaris, 7 = AIX, 8 = IRIX, 9 = FreeBSD, 10 = Tru64, 11 = Novell, 12 = OpenBSD, 13 = OpenVMS, 14 = NonStop kernel, 15 = AROS, 16 = FenixOS, 17 = Nuxi CloudABI, 18 = OpenVOS

         unsigned char spare[8];                     // offset 8: zeroes

         unsigned __int16 type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump

         unsigned __int16 instruction_set;             // offset 18: 2 = Sparc, 3 = i386, 8 = MIPS, 20 = PowerPC, 40 = ARM, 42 = SuperH, 50 = IA-64, 62 = x86_64, 183 = AArch64, 243 = RISC-V

         unsigned __int32 elf_version;                 // offset 20: typically 1

         unsigned __int64 entrypoint_offset;           // offset 24: program entry offset

         unsigned __int64 program_header_table_offset; // offset 32: offset to program header table

         unsigned __int64 section_header_table_offset; // offset 40: offset to section header table

         unsigned __int32 flags;                       // offset 48: flags (architecture-dependent, none for x86)

         unsigned __int16 header_size;                 // offset 52: size of ELF header, 52 for 32-bit ELF and 64 for 64-bit ELF

         unsigned __int16 program_header_item_size;    // offset 54: size of an entry in the program header table

         unsigned __int16 program_header_table_len;    // offset 56: number of entries in the program header table

         unsigned __int16 section_header_item_size;    // offset 58: size of an entry in the section header table

         unsigned __int16 section_header_table_len;    // offset 60: number of entries in the section header table

         unsigned __int16 section_header_names_idx;    // offset 62: index of the entry in the section header table that contains the section names

} elf64_header_t;

// Executable and Linkable Format program header structure type definition

typedef struct elf32_program_header_s

{

         unsigned __int32 segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)

         unsigned __int32 file_offset;    // offset 4: file offset of this segment

         unsigned __int32 virtual_addr;   // offset 8: virtual address where this segment should be mapped in memory

         unsigned __int32 physical_addr;  // offset 12: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory

         unsigned __int32 size_in_file;   // offset 16: size of this segment in the ELF file (may be zero)

         unsigned __int32 size_in_memory; // offset 20: size of this segment in memory (may be zero)

         unsigned __int32 segment_flags;  // offset 24: bitmap of segment flags (1: executable, 2: writable, 4: readable)

         unsigned __int32 alignment;      // offset 28: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)

      } elf32_program_header_t;

typedef struct elf64_program_header_s

{

         unsigned __int32 segment_type;   // offset 0: type of segment (0: unused table entry, 1: loadable, 2: dynamic linking information, 3: interpreter information, 4: auxiliary information, 5: reserved, 6: this very segment, 7: TLS template)

         unsigned __int32 segment_flags;  // offset 4: bitmap of segment flags (1: executable, 2: writable, 4: readable)

         unsigned __int64 file_offset;    // offset 8: file offset of this segment

         unsigned __int64 virtual_addr;   // offset 16: virtual address where this segment should be mapped in memory

         unsigned __int64 physical_addr;  // offset 24: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory

         unsigned __int64 size_in_file;   // offset 32: size of this segment in the ELF file (may be zero)

         unsigned __int64 size_in_memory; // offset 40: size of this segment in memory (may be zero)

         unsigned __int64 alignment;      // offset 48: memory alignment (0 or 1 mean non alignment, else must be a power of 2 where virtual_addr == file_offset % alignment)

      } elf64_program_header_t;

// Executable and Linkable Format section header structure type definition

typedef struct elf32_section_header_s

{

         unsigned __int32 name_offset;  // offset 0: offset in the string table of the name of this section

         unsigned __int32 type;         // offset 4:

         unsigned __int32 flags;        // offset 8:

         unsigned __int32 virtual_addr; // offset 12: address in virtual memory where this section may be loaded

         unsigned __int32 file_offset;  // offset 16: offset of this section in the ELF file

         unsigned __int32 size;         // offset 20: size of this section

         unsigned __int32 linked_index; // offset 24: optional section index of an associated section

         unsigned __int32 info;         // offset 28: optional extra information

         unsigned __int32 alignment;    // offset 32: required memory alignment (must be a power of 2)

         unsigned __int32 entry_size;   // offset 36: for table-like sections, size of an element in the table

      } elf32_section_header_t;

typedef struct elf64_section_header_s

      {

         unsigned __int32 name_offset;  // offset 0: offset in the string table of the name of this section

         unsigned __int32 type;         // offset 4:

         unsigned __int64 flags;        // offset 8:

         unsigned __int64 virtual_addr; // offset 16: address in virtual memory where this section may be loaded

         unsigned __int64 file_offset;  // offset 24: offset of this section in the ELF file

         unsigned __int64 size;         // offset 32: size of this section

         unsigned __int32 linked_index; // offset 40: optional section index of an associated section

         unsigned __int32 info;         // offset 44: optional extra information

         unsigned __int64 alignment;    // offset 48: required memory alignment (must be a power of 2)

         unsigned __int64 entry_size;   // offset 56: for table-like sections, size of an element in the table

      } elf64_section_header_t;

// Executable and Linkable Format dynamic section entry structure type definition

typedef struct elf32_dynamic_section_entry_s

{

         __int32 tag; // dynamic entry type (one of ELF_DT_xxx #defines)

         unsigned __int32 integer_or_pointer; // value as integer

      } elf32_dynamic_section_entry_t;

typedef struct elf32_dynamic_section_entry_s

{

         __int64 tag; // dynamic entry type (one of ELF_DT_xxx #defines)

         unsigned __int64 integer_or_pointer; // value as intege

      } elf64_dynamic_section_entry_t;