WebSVN – QNX 8.QNX8 IFS tool – Diff – //ifstool.c

 #define RECORD_SEP '\x1e' // ASCII record separator
 #define RECORD_SEP_STR "\x1e" // ASCII record separator (as string)
 // macros for accessing ELF files
 #define ELF_MAGIC_STR "\x7f" "ELF"
-#define ELF_ENDIAN_LITTLE 1 // ELF file is little endian
+#define ELF_ENDIAN_LITTLE 1 // 'endianness' member of an ELF header: ELF file is little endian
-#define ELF_ENDIAN_BIG    2 // ELF file is big endian
+#define ELF_ENDIAN_BIG    2 // 'endianness' member of an ELF header: ELF file is big endian
+#define ELF_MACHINE_X86_64  0x3e // 'instruction_set' member of an ELF header, also used in the IFS startup header: ELF file is for x86_64 processors (62 decimal)
+#define ELF_MACHINE_AARCH64 0xb7 // 'instruction_set' member of an ELF header, also used in the IFS startup header: ELF file is for ARM64 processors (183 decimal)
+#define ELF_SECTIONTYPE_STRINGTABLE 3
 #define ELF_DT_NULL    0 // marks end of dynamic section
 #define ELF_DT_SONAME 14 // canonical name of shared object
-#define ELF_STRUCT_MEMBER_NUMERIC(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? /* is it a 64-bit ELF file ? */ \
+#define ELF_GET_NUMERIC(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? /* is it a 64-bit ELF file ? */ \
    ( \
       (sizeof ((elfstruct)->u.elf64.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \
          (elfstruct)->u.elf64.member /* same endianness, or single byte required: don't swap */ \
       : /* else */ \
          (sizeof ((elfstruct)->u.elf64.member) == 8 ? __builtin_bswap64 ((elfstruct)->u.elf64.member) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? __builtin_bswap32 ((elfstruct)->u.elf64.member) : __builtin_bswap16 ((elfstruct)->u.elf64.member))) /* different endianness: swap */ \
          (elfstruct)->u.elf32.member /* same endianness, or single byte required: don't swap */ \
       : /* else */ \
          (sizeof ((elfstruct)->u.elf32.member) == 4 ? __builtin_bswap32 ((elfstruct)->u.elf32.member) : __builtin_bswap16 ((elfstruct)->u.elf32.member)) /* different endianness: swap */ \
    ) \
 ) // this macro supports 32- and 64-bit ELF files in low and big endianness transparently
+#define ELF_SET_NUMERIC(elfhdr,elfstruct,member,data) ((elfhdr)->u.elf.platform_size == 2 ? /* is it a 64-bit ELF file ? */ \
+   ((elfstruct)->u.elf64.member = ( \
+      (sizeof ((elfstruct)->u.elf64.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \
+         (sizeof ((elfstruct)->u.elf64.member) == 8 ? (uint64_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? (uint32_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 2 ? (uint16_t) ((data)) : (uint8_t) ((data))))) /* same endianness, or single byte required: don't swap */ \
+      : /* else */ \
+         (sizeof ((elfstruct)->u.elf64.member) == 8 ? __builtin_bswap64 ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 4 ? __builtin_bswap32 ((data)) : __builtin_bswap16 ((data)))) /* different endianness: swap */ \
+   )) \
+   : /* else poke at 32-bit ELF */ \
+   ((elfstruct)->u.elf32.member = ( \
+      (sizeof ((elfstruct)->u.elf32.member) == 1) || (((elfhdr)->u.elf.endianness == 1) && (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) || (((elfhdr)->u.elf.endianness == 2) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)) ? /* single-byte, or same endianness ? */ \
+         (sizeof ((elfstruct)->u.elf64.member) == 4 ? (uint32_t) ((data)) : (sizeof ((elfstruct)->u.elf64.member) == 2 ? (uint16_t) ((data)) : (uint8_t) ((data)))) /* same endianness, or single byte required: don't swap */ \
+      : /* else */ \
+         (sizeof ((elfstruct)->u.elf32.member) == 4 ? __builtin_bswap32 ((data)) : __builtin_bswap16 ((data))) /* different endianness: swap */ \
+   )) \
+) // this macro supports 32- and 64-bit ELF files in low and big endianness transparently
-#define ELF_STRUCT_MEMBER_STRING(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? (elfstruct)->u.elf64.member : (elfstruct)->u.elf32.member) // this macro supports 32- and 64-bit ELF files transparently
+#define ELF_GET_STRING(elfhdr,elfstruct,member) ((elfhdr)->u.elf.platform_size == 2 ? (elfstruct)->u.elf64.member : (elfstruct)->u.elf32.member) // this macro supports 32- and 64-bit ELF files transparently
+#define ELF_SET_STRING(elfhdr,elfstruct,member,data,len) memcpy (((elfhdr)->u.elf.platform_size == 2 ? (elfstruct)->u.elf64.member : (elfstruct)->u.elf32.member), (data), (len)) // this macro supports 32- and 64-bit ELF files transparently
 #define ELF_STRUCT_SIZE(elfhdr,elfstruct) ((elfhdr)->u.elf.platform_size == 2 ? sizeof ((elfstruct)->u.elf64) : sizeof ((elfstruct)->u.elf32)) // this macro supports 32- and 64-bit ELF files transparently
 #define WILL_BE_FILLED_LATER 0xbaadf00d
 // bitmapped flags used in the flags1 member of the startup header
 //#define STARTUP_HDR_FLAGS1_COMPRESS_NONE  0x00
 //#define STARTUP_HDR_FLAGS1_COMPRESS_ZLIB  0x04
 //#define STARTUP_HDR_FLAGS1_COMPRESS_LZO   0x08
 //#define STARTUP_HDR_FLAGS1_COMPRESS_UCL   0x0c
 #define STARTUP_HDR_FLAGS1_TRAILER_V2     (1 << 5) // if set, then a struct startup_trailer_v2 follows the startup. If the image is compressed, then the compressed imagefs is followed by a struct image_trailer_v2
-#define STARTUP_HDR_MACHINE_X86_64  0x3e
-#define STARTUP_HDR_MACHINE_AARCH64 0xb7
 // bitmapped flags used in the flags member of the image header
 #define IMAGE_FLAGS_BIGENDIAN  (1 << 0) // header, trailer, dirents in big-endian format
 #define IMAGE_FLAGS_READONLY   (1 << 1) // do not try to write to image (rom/flash)
+{
    union __attribute__((packed))
+   {
       struct __attribute__((packed))
+      {
-         uint8_t magic[4];                     // offset 0: "\x07" + "ELF"
+         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"
          uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit
          uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian
          uint8_t header_version;               // offset 6: typically 1
          uint8_t 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
          uint8_t spare[8];                     // offset 8: zeroes
          uint16_t type;                        // offset 16: 1 = relocatable, 2 = executable, 3 = shared, 4 = core dump
          uint16_t 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
          uint32_t elf_version;                 // offset 20: typically 1
       } elf;
-      struct __attribute__((packed))
+      struct __attribute__((packed)) // size == 52
+      {
-         uint8_t magic[4];                     // offset 0: "\x07" + "ELF"
+         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"
          uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit
          uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian
          uint8_t header_version;               // offset 6: typically 1
          uint8_t 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
          uint8_t spare[8];                     // offset 8: zeroes
          uint16_t program_header_item_size;    // offset 42: size of an entry in the program header table
          uint16_t program_header_table_len;    // offset 44: number of entries in the program header table
          uint16_t section_header_item_size;    // offset 46: size of an entry in the section header table
          uint16_t section_header_table_len;    // offset 48: number of entries in the section header table
          uint16_t section_header_names_idx;    // offset 50: index of the entry in the section header table that contains the section names
-      } elf32;
+      } elf32; // size == 52
-      struct __attribute__((packed))
+      struct __attribute__((packed)) // size == 64
+      {
-         uint8_t magic[4];                     // offset 0: "\x07" + "ELF"
+         uint8_t magic[4];                     // offset 0: "\x7f" + "ELF"
          uint8_t platform_size;                // offset 4: 1 = 32-bit, 2 = 64-bit
          uint8_t endianness;                   // offset 5: 1 = little endian, 2 = big endian
          uint8_t header_version;               // offset 6: typically 1
          uint8_t 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
          uint8_t spare[8];                     // offset 8: zeroes
          uint16_t program_header_item_size;    // offset 54: size of an entry in the program header table
          uint16_t program_header_table_len;    // offset 56: number of entries in the program header table
          uint16_t section_header_item_size;    // offset 58: size of an entry in the section header table
          uint16_t section_header_table_len;    // offset 60: number of entries in the section header table
          uint16_t section_header_names_idx;    // offset 62: index of the entry in the section header table that contains the section names
-      } elf64;
+      } elf64; // size == 64
    } u;
 } elf_header_t;
+// Executable and Linkable Format program header structure type definition
+typedef struct __attribute__((packed)) elf_program_header_s
+{
+   union __attribute__((packed))
+   {
+      struct __attribute__((packed))
+      {
+         uint32_t 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)
+      } elf;
+      struct __attribute__((packed)) // size == 32
+      {
+         uint32_t 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)
+         uint32_t file_offset;    // offset 4: file offset of this segment
+         uint32_t virtual_addr;   // offset 8: virtual address where this segment should be mapped in memory
+         uint32_t physical_addr;  // offset 12: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory
+         uint32_t size_in_file;   // offset 16: size of this segment in the ELF file (may be zero)
+         uint32_t size_in_memory; // offset 20: size of this segment in memory (may be zero)
+         uint32_t segment_flags;  // offset 24: bitmap of segment flags (1: executable, 2: writable, 4: readable)
+         uint32_t 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; // size == 32
+      struct __attribute__((packed)) // size == 56
+      {
+         uint32_t 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)
+         uint32_t segment_flags;  // offset 4: bitmap of segment flags (1: executable, 2: writable, 4: readable)
+         uint64_t file_offset;    // offset 8: file offset of this segment
+         uint64_t virtual_addr;   // offset 16: virtual address where this segment should be mapped in memory
+         uint64_t physical_addr;  // offset 24: on systems where this is relevant, PHYSICAL address where this segment should be mapped in memory
+         uint64_t size_in_file;   // offset 32: size of this segment in the ELF file (may be zero)
+         uint64_t size_in_memory; // offset 40: size of this segment in memory (may be zero)
+         uint64_t 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; // size == 56
+   } u;
+} elf_program_header_t;
 // Executable and Linkable Format section header structure type definition
 typedef struct __attribute__((packed)) elf_section_header_s
+{
    union __attribute__((packed))
+   {
-      struct __attribute__((packed))
+      struct __attribute__((packed)) // size == 40
+      {
          uint32_t name_offset;  // offset 0: offset in the string table of the name of this section
          uint32_t type;         // offset 4:
          uint32_t flags;        // offset 8:
          uint32_t virtual_addr; // offset 12: address in virtual memory where this section may be loaded
          uint32_t size;         // offset 20: size of this section
          uint32_t linked_index; // offset 24: optional section index of an associated section
          uint32_t info;         // offset 28: optional extra information
          uint32_t alignment;    // offset 32: required memory alignment (must be a power of 2)
          uint32_t entry_size;   // offset 36: for table-like sections, size of an element in the table
-      } elf32;
+      } elf32; // size == 40
-      struct __attribute__((packed))
+      struct __attribute__((packed)) // size == 64
+      {
          uint32_t name_offset;  // offset 0: offset in the string table of the name of this section
          uint32_t type;         // offset 4:
          uint64_t flags;        // offset 8:
          uint64_t virtual_addr; // offset 16: address in virtual memory where this section may be loaded
          uint64_t size;         // offset 32: size of this section
          uint32_t linked_index; // offset 40: optional section index of an associated section
          uint32_t info;         // offset 44: optional extra information
          uint64_t alignment;    // offset 48: required memory alignment (must be a power of 2)
          uint64_t entry_size;   // offset 56: for table-like sections, size of an element in the table
-      } elf64;
+      } elf64; // size == 64
    } u;
 } elf_section_header_t;
 // Executable and Linkable Format dynamic section entry structure type definition
 typedef struct __attribute__((packed)) elf_dynamic_section_entry_s
+{
    union __attribute__((packed))
+   {
-      struct __attribute__((packet))
+      struct __attribute__((packed)) // size == 8
+      {
          int32_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)
          union
+         {
             uint32_t as_integer; // value as integer
             uint32_t as_pointer; // value as address
          } value;
-      } elf32;
+      } elf32; // size == 8
-      struct __attribute__((packed))
+      struct __attribute__((packed)) // size == 16
+      {
          int64_t tag; // dynamic entry type (one of ELF_DT_xxx #defines)
          union
+         {
             uint64_t as_integer; // value as intege
             uint64_t as_pointer; // value as address
          } value;
-      } elf64;
+      } elf64; // size == 16
    } u;
 } elf_dynamic_section_entry_t;
 #ifdef _MSC_VER
    uint32_t mtime_for_inline_files; // same as above but only for files that don't exist on the build host (i.e. files with an explicit content blob)
    char prefix[MAXPATHLEN]; // install path (e.g. "proc/boot")
    bool should_follow_symlinks; // follow symlinks
    bool should_autosymlink_dylib; // dynamic libraries should be written under their official SONAME and a named symlink be created pointing at them
    bool is_compiled_bootscript; // entry has [+script] attribute
+   int extra_ino_flags; // bitmap of extra inode flags (IFS_INO_xxx)
    char search[10 * MAXPATHLEN]; // binary search path (the default one will be constructed at startup)
    uint8_t *data;
    size_t datalen;
 } parms_t;
 static void hex_fprintf (FILE *fp, const uint8_t *data, size_t data_size, int howmany_columns, const char *fmt, ...); // hexdump-style formatted output to a file stream (which may be stdout/stderr)
 static char *binary (const uint8_t x, char char_for_zero, char char_for_one); // returns the binary representation of byte 'x' as a string
 static char *describe_uint8 (const uint8_t x, const char *bitwise_stringdescs[8]); // returns the ORed description of byte 'x' according to the description strings for each bit
 static char *read_filecontents (const char *pathname, const char *search_path, uint8_t **databuf, size_t *datalen); // locates pathname among MKIFS_PATH, reads it, places its contents in a buffer (caller frees) and returns a pointer to the resolved pathname (static string)
 static int fwrite_filecontents (const char *pathname, FILE *fp); // dumps the contents of pathname into fp
+static int relative_offset_of_in (const char *name, const char *string_table, const size_t table_len); // returns the relative offset of a particular string in a string table
+static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name); // get a pointer to a named section header in an ELF file
 static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp); // writes the given filesystem entry into fp (without its contents)
 static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname); // stack up a new filesystem entry
 static int fsentry_compare_pathnames_cb (const void *a, const void *b); // qsort() comparison callback that sorts filesystem entries by pathnames
 static void update_MKIFS_PATH (const char *processor);
-static int dump_ifs_info (const char *ifs_pathname); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
+static int dump_ifs_info (const char *ifs_pathname, bool want_everything); // dumps detailed info about a particular IFS file on the standard output, returns 0 on success and >0 on error
 static void sha512_private_transform (SHA512_CTX *context, const uint64_t *data)
+{
    // logical functions used in SHA-384 and SHA-512
    ret = (int) fwrite (blob_buffer, 1, blob_size, fp);
    fflush (fp); // force flush to disk, because the C stream API is *buffered*
    free (blob_buffer);
    return (ret);
+}
+static int relative_offset_of_in (const char *name, const char *string_table, const size_t table_len)
+{
+   int name_len = (int) strlen (name) + 1;
+   WELLMANNERED_ASSERT (name_len < table_len, "bad call (name longer than string table)");
+   for (int idx = 0; idx <= table_len - name_len; idx++)
+      if (memcmp (&string_table[idx], name, name_len) == 0)
+         return (idx);
+   WELLMANNERED_ASSERT (false, "bad call (name '%s' not found in string table)", name);
+   return (0);
+}
+static elf_section_header_t *elf_get_section_header_by_name (const elf_header_t *elf, const char *section_name)
+{
+   elf_section_header_t *shdr_shstrtab; // section header of the section header strings table
+   elf_section_header_t *shdr;
+   size_t table_count;
+   size_t table_index;
+   char *shstrtab; // section header strings table
+   char *name;
+   shdr_shstrtab = (elf_section_header_t *) ((uint8_t *) elf + ELF_GET_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, section_header_item_size) * ELF_GET_NUMERIC (elf, elf, section_header_names_idx)); // quick access to section header for the section that contains the section names
+   shstrtab = ((uint8_t *) elf + ELF_GET_NUMERIC (elf, shdr_shstrtab, file_offset)); // locate the start of the strings table that contains the section names
+   // cycle through the sections table
+   table_count = ELF_GET_NUMERIC (elf, elf, section_header_table_len);
+   for (table_index = 0; table_index < table_count; table_index++)
+   {
+      shdr = (elf_section_header_t *) ((uint8_t *) elf + ELF_GET_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, section_header_item_size) * table_index); // quick access to section header
+      name = &shstrtab[ELF_GET_NUMERIC (elf, shdr, name_offset)]; // peek at its name
+      if (strcmp (name, section_name) == 0)
+         return (shdr); // if found, return a pointer to this section header
+   }
+   return (NULL); // section not found
+}
 static size_t fwrite_fsentry (const fsentry_t *fsentry, FILE *fp)
+{
+}
 static size_t add_fsentry (fsentry_t **fsentries, size_t *fsentry_count, parms_t *entry_parms, const char *stored_pathname, const char *buildhost_pathname)
+{
+   #define ADD_NAME_TO_STRINGTABLE(name,pstrtab,pstrtablen) do { \
+      name_len = strlen ((name)) + 1; \
+      reallocated_ptr = realloc (*(pstrtab), *(pstrtablen) + name_len); \
+      WELLMANNERED_ASSERT (reallocated_ptr, "out of memory"); \
+      *(pstrtab) = reallocated_ptr; \
+      memcpy (&(*pstrtab)[*(pstrtablen)], (name), name_len); \
+      *(pstrtablen) += name_len; \
+   } while (0)
    static thread_local char candidate_pathname[1024];
    static int inode_count = 0; // will be preincremented each time this function is called
    const char *original_stored_pathname = NULL;
    const elf_dynamic_section_entry_t *dynamic_entry; // dynamic section entry
-   const elf_section_header_t *shdr_shstr; // section headers strings (containing ELF sections names)
    const elf_section_header_t *shdr_dynstr; // dynamic strings
    const elf_section_header_t *shdr_dynamic; // dynamic section
    const elf_section_header_t *shdr;
+   elf_section_header_t *new_shdr;
+   size_t new_qnxinfo_shdr_offset;
+   size_t new_debuglink_shdr_offset;
+   size_t new_qnxusage_shdr_offset;
+   size_t new_buildid_shdr_offset;
+   size_t new_shstrtab_shdr_offset;
+   elf_program_header_t *phdr;
    const char *canonical_dylib_name;
-   const char *elf_section_name;
    const char *dynamic_strings; // strings table of the ".dynamic" section
-   const char *shtable_strings; // strings table of the section headers table
    const char *last_dirsep;
-   const elf_header_t *elf;
+   elf_header_t *elf;
+   uint8_t *new_shdr_table = NULL; // mallocated
+   size_t new_shdr_tablesize = 0;
+   uint8_t *elfsection_qnxinfo_data = NULL; // mallocated
+   size_t elfsection_qnxinfo_size = 0;
+   uint8_t *elfsection_qnxusage_data = NULL; // mallocated
+   size_t elfsection_qnxusage_size = 0;
+   uint8_t *elfsection_debuglink_data = NULL; // mallocated
+   size_t elfsection_debuglink_size = 0;
+   uint8_t *elfsection_buildid_data = NULL; // mallocated
+   size_t elfsection_buildid_size = 0;
+   uint8_t *elfsection_shstrtab_data = NULL; // mallocated
+   size_t elfsection_shstrtab_size = 0;
    char *resolved_pathname;
    void *reallocated_ptr;
    void *old_data;
    struct stat stat_buf;
+   size_t new_shdrtable_offset;
+   size_t end_padding_offset;
    size_t table_index;
    size_t table_count;
-   //uint32_t mtime = (entry_parms->m(uint32_t) time (NULL);
-   uint32_t extra_ino_flags = 0;
+   size_t name_len;
    fsentry_t *fsentry;
    if (S_ISDIR (entry_parms->st_mode)) // are we storing a directory ?
+   {
       fprintf (stderr, "directory: ino 0x%x uid %d gid %d mode 0%o path \"%s\"\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname);
+      {
          // HACK: for now just consider the kernel as a binary blob
          // FIXME: reimplement properly
          sprintf (candidate_pathname, "%s/procnto-smp-instr", entry_parms->prefix); // fix the entry name
          stored_pathname = candidate_pathname;
-         extra_ino_flags = IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
+         entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF | IFS_INO_BOOTSTRAP_EXE; // procnto needs to have these flags stamped on the inode
          entry_parms->st_mode = S_IFREG | 0700; // procnto requires 0700 permissions
-         image_kernel_ino = extra_ino_flags | (inode_count + 1);
+         image_kernel_ino = entry_parms->extra_ino_flags | (inode_count + 1);
+      }
       else if (entry_parms->is_compiled_bootscript) // else is it a startup script ?
          image_bootscript_ino = inode_count + 1; // save boot script inode number for image header
       // do we already know the data for this data blob ?
       if (entry_parms->data != NULL)
+      {
          entry_parms->mtime = entry_parms->mtime_for_inline_files;
-         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)\n", extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->datalen);
+         fprintf (stderr, "file: ino 0x%x uid %d gid %d mode 0%o path \"%s\" blob (len %zd)\n", entry_parms->extra_ino_flags | (inode_count + 1), entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->datalen);
+      }
       else if (buildhost_pathname != NULL) // else was a source file pathname supplied ?
+      {
          resolved_pathname = read_filecontents (buildhost_pathname, (entry_parms->search[0] != 0 ? entry_parms->search : MKIFS_PATH), &entry_parms->data, &entry_parms->datalen); // locate the file
          if (resolved_pathname == NULL)
+      }
       // is the file we're storing an ELF file ?
       if ((entry_parms->datalen > 52) // file is big enough to contain an ELF header
           && ((elf = (elf_header_t *) entry_parms->data) != NULL) // cast (necessary true)
-          && (memcmp (ELF_STRUCT_MEMBER_STRING (elf, elf, magic), ELF_MAGIC_STR, 4) == 0)) // file starts with the ELF magic
+          && (memcmp (ELF_GET_STRING (elf, elf, magic), ELF_MAGIC_STR, 4) == 0)) // file starts with the ELF magic
+      {
-         shdr_shstr = (elf_section_header_t *) &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_item_size) * ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_names_idx)]; // quick access to section header for the section that contains the section names
-         shtable_strings = &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (elf, shdr_shstr, file_offset)]; // locate the start of the strings table that contains the section names
-         // strip this ELF file
          // is the file we're storing a relocatable executable (i.e. a dynamic library) and should we check for its canonical name ?
-         if ((ELF_STRUCT_MEMBER_NUMERIC (elf, elf, type) == 3) && entry_parms->should_autosymlink_dylib)
+         if ((ELF_GET_NUMERIC (elf, elf, type) == 3) && entry_parms->should_autosymlink_dylib)
+         {
             // we need to find the SONAME of this library
             canonical_dylib_name = NULL;
             // locate the sections we need (the dynamic section and its strings table)
-            table_count = ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_table_len);
-            shdr_dynamic = NULL;
-            shdr_dynstr = NULL;
-            for (table_index = 0; table_index < table_count; table_index++)
-            {
-               shdr = (elf_section_header_t *) &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_table_offset) + (size_t) ELF_STRUCT_MEMBER_NUMERIC (elf, elf, section_header_item_size) * table_index]; // quick access to section header
+            shdr_dynamic = elf_get_section_header_by_name (elf, ".dynamic");
-               elf_section_name = &shtable_strings[ELF_STRUCT_MEMBER_NUMERIC (elf, shdr, name_offset)];
-               if (strcmp (elf_section_name, ".dynamic") == 0)
-                  shdr_dynamic = shdr;
-               else if (strcmp (elf_section_name, ".dynstr") == 0)
+            shdr_dynstr = elf_get_section_header_by_name (elf, ".dynstr");
-                  shdr_dynstr = shdr;
-            }
             // make sure we have both the dynamic section header and its own strings table header
             if ((shdr_dynamic != NULL) && (shdr_dynstr != NULL))
+            {
-               dynamic_strings = (char *) &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (elf, shdr_dynstr, file_offset)]; // quick access to dynamic sections strings table
+               dynamic_strings = (char *) &entry_parms->data[ELF_GET_NUMERIC (elf, shdr_dynstr, file_offset)]; // quick access to dynamic sections strings table
                // walk through the dynamic section, look for the DT_SONAME entry
-               for (dynamic_entry = (elf_dynamic_section_entry_t *) &entry_parms->data[ELF_STRUCT_MEMBER_NUMERIC (elf, shdr_dynamic, file_offset)];
+               for (dynamic_entry = (elf_dynamic_section_entry_t *) &entry_parms->data[ELF_GET_NUMERIC (elf, shdr_dynamic, file_offset)];
-                    (ELF_STRUCT_MEMBER_NUMERIC (elf, dynamic_entry, tag) != ELF_DT_NULL);
+                    (ELF_GET_NUMERIC (elf, dynamic_entry, tag) != ELF_DT_NULL);
                     dynamic_entry = (elf_dynamic_section_entry_t *) ((uint8_t *) dynamic_entry + ELF_STRUCT_SIZE (elf, dynamic_entry)))
-                  if (ELF_STRUCT_MEMBER_NUMERIC (elf, dynamic_entry, tag) == ELF_DT_SONAME)
+                  if (ELF_GET_NUMERIC (elf, dynamic_entry, tag) == ELF_DT_SONAME)
+                  {
-                     canonical_dylib_name = dynamic_strings + ELF_STRUCT_MEMBER_NUMERIC (elf, dynamic_entry, value.as_integer);
+                     canonical_dylib_name = dynamic_strings + ELF_GET_NUMERIC (elf, dynamic_entry, value.as_integer);
                      break;
+                  }
                // do we have it ?
                if ((canonical_dylib_name != NULL) && (canonical_dylib_name[0] != 0))
                      stored_pathname = candidate_pathname;
+                  }
+               }
+            }
          } // end if the file we're storing is a dylib
+         // now strip this ELF file if necessary
+         if (!(entry_parms->extra_ino_flags & IFS_INO_PROCESSED_ELF))
+         {
+            // NOTE: for each ELF file, mkifs
+            // -> alters the program header table and offsets each p_addr (physical address) member by 0x1400000 plus the current file offset (this cannot be done right now, will need to be done once they are known)
+            // -> throws away and reconstructs the sections table by keeping only the sections that are in the program header, and writes the section table at the start of the first thrown-away section
+            // FIXME: what if a section thrown away is located between two program segments ? are they collapsed, moving everything one slot down ? this looks improbable...
+            // reconstructed ELF:
+            // ==== START OF FILE ====
+            // ELF header
+            // program header table
+            //  (same sections, just p_addr offset down by first section's p_addr)
+            // section data 5 (named ".note.gnu.build-id")
+            //  "............GNU....ZY.....c.o..l"
+            // PROGRAM
+            // sections table
+            // + section 1: ALL ZEROES
+            // + section 2: fileoffs 0x21a8 size 0xfd --> "QNX_info" --> QNX binary description: "NAME=pci_debug2.so.3.0\nDESCRIPTION=PCI Server System Debug Module\nDATE=2023/11/19-10:01:13-EST\nSTATE=lookup\nHOST=docker-n1.bts.rim.net\nUSER=builder\nVERSION=QNXOS_main\nTAGID=QNXOS_800-135\nPACKAGE=com.qnx.qnx800.target.pci.debug/3.0.0.00135T202311191043L\n"
+            // + section 3: fileoffs 0x22a5 size 0x1c --> ".gnu_debuglink" --> indicates the debug file (and a possible checksum?): "pci_debug2.so.3.0.sym" "\0\0\0" "VX2p"
+            // + section 4: fileoffs 0x22c1 size 0x2ad --> "QNX_usage" --> HELP TEXT: "\n-------------------------------------------------------------------------------\n%C\n\nThis module implements debug logging for all PCI server modules. It is\nincluded by setting the environment variable PCI_DEBUG_MODULE and uses\nthe slogger2 APIs.\nNOTE:.On systems which support slogger2, you are encouraged to use this module.instead of pci_debug.so...Release History.---------------..3.0 - This module is functionally equivalent to the previous 2.x version.      however it is incompatible with all pre v3.x PCI components..2.1 - fixes a bug whereby if slogger2 is not running and the PCI_DEBUG_MODULE.      environment variable is set, the client will SIGSEGV..2.0 - initial release.."
+            // + section 5: fileoffs 0x190 size 0x32 --> ".note.gnu.build-id" --> GNU build ID
+            // + section 6: fileoffs 0x256e size 0x40 --> ".shstrtab" --> sections names strings table
+            // section data 2 (named "QNX_info")
+            //  (QNX binary description)
+            // section data 3 (named ".gnu_debuglink")
+            //  (debug file)
+            // section data 4 (named "QNX_usage")
+            //  (help text)
+            // section data 6 (named ".shstrtab")
+            //  "\0"
+            //  ".shstrtab\0"
+            //  "QNX_info\0"
+            //  ".gnu_debuglink\0"
+            //  "QNX_usage\0"
+            //  ".note.gnu.build-id\0"
+            // ==== END OF FILE ====
+            // task 1: alter the program header table, and measure the farthest offset known by this table where we'll write the reconstructed section headers table
+            //first_offset = SIZE_MAX;
+            new_shdrtable_offset = 0;
+            table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len);
+            for (table_index = 0; table_index < table_count; table_index++)
+            {
+               phdr = (elf_program_header_t *) &entry_parms->data[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
+               //if (first_offset == SIZE_MAX)
+               //   first_offset = ELF_GET_NUMERIC (elf, phdr, physical_addr);
+               if (ELF_GET_NUMERIC (elf, phdr, file_offset) + ELF_GET_NUMERIC (elf, phdr, size_in_file) > new_shdrtable_offset)
+                  new_shdrtable_offset = ELF_GET_NUMERIC (elf, phdr, file_offset) + ELF_GET_NUMERIC (elf, phdr, size_in_file);
+//               ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + (0x1400000 + ));
+            }
+            // task 2: re-create the section header table
+            elfsection_shstrtab_data = malloc (1); // initialize an empty section headers strings table
+            WELLMANNERED_ASSERT (elfsection_shstrtab_data, "out of memory");
+            elfsection_shstrtab_data[0] = 0;
+            elfsection_shstrtab_size = 1;
+            ADD_NAME_TO_STRINGTABLE (".shstrtab", &elfsection_shstrtab_data, &elfsection_shstrtab_size);
+            reallocated_ptr = realloc (new_shdr_table, new_shdr_tablesize + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
+            WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
+            new_shdr_table = reallocated_ptr; // reallocation succeeded, save the new pointer
+            memset (&new_shdr_table[new_shdr_tablesize], 0, ELF_STRUCT_SIZE (elf, shdr)); // the first section header is always zerofilled
+            new_shdr_tablesize += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
+            if ((shdr = elf_get_section_header_by_name (elf, "QNX_info")) != NULL)
+            {
+               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
+               {
+                  elfsection_qnxinfo_size = ELF_GET_NUMERIC (elf, shdr, size);
+                  elfsection_qnxinfo_data = malloc (elfsection_qnxinfo_size);
+                  WELLMANNERED_ASSERT (elfsection_qnxinfo_data, "out of memory");
+                  memcpy (elfsection_qnxinfo_data, &entry_parms->data[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_qnxinfo_size);
+               }
+               reallocated_ptr = realloc (new_shdr_table, new_shdr_tablesize + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
+               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
+               new_shdr_table = reallocated_ptr; // reallocation succeeded, save the new pointer
+               new_qnxinfo_shdr_offset = new_shdr_tablesize; // remember the new offset of this section header
+               new_shdr_tablesize += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_qnxinfo_shdr_offset]; // now populate this section header
+               ADD_NAME_TO_STRINGTABLE ("QNX_info", &elfsection_shstrtab_data, &elfsection_shstrtab_size);
+               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in ("QNX_info", elfsection_shstrtab_data, elfsection_shstrtab_size)); // update the relative offset of the section name
+               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
+               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
+               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
+               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
+               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (FIXME: may be wrong now!)
+               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
+               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
+               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
+            }
+            if ((shdr = elf_get_section_header_by_name (elf, ".gnu_debuglink")) != NULL)
+            {
+               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
+               {
+                  elfsection_debuglink_size = ELF_GET_NUMERIC (elf, shdr, size);
+                  elfsection_debuglink_data = malloc (elfsection_debuglink_size);
+                  WELLMANNERED_ASSERT (elfsection_debuglink_data, "out of memory");
+                  memcpy (elfsection_debuglink_data, &entry_parms->data[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_debuglink_size);
+               }
+               reallocated_ptr = realloc (new_shdr_table, new_shdr_tablesize + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
+               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
+               new_shdr_table = reallocated_ptr; // reallocation succeeded, save the new pointer
+               new_debuglink_shdr_offset = new_shdr_tablesize; // remember the new offset of this section header
+               new_shdr_tablesize += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_debuglink_shdr_offset]; // now populate this section header
+               ADD_NAME_TO_STRINGTABLE (".gnu_debuglink", &elfsection_shstrtab_data, &elfsection_shstrtab_size);
+               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in (".gnu_debuglink", elfsection_shstrtab_data, elfsection_shstrtab_size)); // update the relative offset of the section name
+               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
+               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
+               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
+               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
+               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (FIXME: may be wrong now!)
+               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
+               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
+               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
+            }
+            if ((shdr = elf_get_section_header_by_name (elf, "QNX_usage")) != NULL)
+            {
+               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
+               {
+                  elfsection_qnxusage_size = ELF_GET_NUMERIC (elf, shdr, size);
+                  elfsection_qnxusage_data = malloc (elfsection_qnxusage_size);
+                  WELLMANNERED_ASSERT (elfsection_qnxusage_data, "out of memory");
+                  memcpy (elfsection_qnxusage_data, &entry_parms->data[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_qnxusage_size);
+               }
+               reallocated_ptr = realloc (new_shdr_table, new_shdr_tablesize + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
+               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
+               new_shdr_table = reallocated_ptr; // reallocation succeeded, save the new pointer
+               new_qnxusage_shdr_offset = new_shdr_tablesize; // remember the new offset of this section header
+               new_shdr_tablesize += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_qnxusage_shdr_offset]; // now populate this section header
+               ADD_NAME_TO_STRINGTABLE ("QNX_usage", &elfsection_shstrtab_data, &elfsection_shstrtab_size);
+               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in ("QNX_usage", elfsection_shstrtab_data, elfsection_shstrtab_size)); // update the relative offset of the section name
+               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
+               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
+               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
+               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
+               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (FIXME: may be wrong now!)
+               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
+               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
+               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
+            }
+            if ((shdr = elf_get_section_header_by_name (elf, ".note.gnu.build-id")) != NULL)
+            {
+               if (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset) // if this section needs to be moved around, have a copy of it
+               {
+                  elfsection_buildid_size = ELF_GET_NUMERIC (elf, shdr, size);
+                  elfsection_buildid_data = malloc (elfsection_buildid_size);
+                  WELLMANNERED_ASSERT (elfsection_buildid_data, "out of memory");
+                  memcpy (elfsection_buildid_data, &entry_parms->data[ELF_GET_NUMERIC (elf, shdr, file_offset)], elfsection_buildid_size);
+               }
+               reallocated_ptr = realloc (new_shdr_table, new_shdr_tablesize + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
+               WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
+               new_shdr_table = reallocated_ptr; // reallocation succeeded, save the new pointer
+               new_buildid_shdr_offset = new_shdr_tablesize; // remember the new offset of this section header
+               new_shdr_tablesize += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_buildid_shdr_offset]; // now populate this section header
+               ADD_NAME_TO_STRINGTABLE (".note.gnu.build-id", &elfsection_shstrtab_data, &elfsection_shstrtab_size);
+               ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in (".note.gnu.build-id", elfsection_shstrtab_data, elfsection_shstrtab_size)); // update the relative offset of the section name
+               ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_GET_NUMERIC (elf, shdr, type)); // duplicate section type
+               ELF_SET_NUMERIC (elf, new_shdr, flags,        ELF_GET_NUMERIC (elf, shdr, flags)); // duplicate section flags
+               ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, ELF_GET_NUMERIC (elf, shdr, virtual_addr)); // duplicate section virtual address
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, (ELF_GET_NUMERIC (elf, shdr, file_offset) > new_shdrtable_offset ? WILL_BE_FILLED_LATER : ELF_GET_NUMERIC (elf, shdr, file_offset))); // duplicate section offset only if it doesn't move
+               ELF_SET_NUMERIC (elf, new_shdr, size,         ELF_GET_NUMERIC (elf, shdr, size)); // duplicate section size
+               ELF_SET_NUMERIC (elf, new_shdr, linked_index, ELF_GET_NUMERIC (elf, shdr, linked_index)); // duplicate section linked index (FIXME: may be wrong now!)
+               ELF_SET_NUMERIC (elf, new_shdr, info,         ELF_GET_NUMERIC (elf, shdr, info)); // duplicate section info
+               ELF_SET_NUMERIC (elf, new_shdr, alignment,    ELF_GET_NUMERIC (elf, shdr, alignment)); // duplicate section alignment
+               ELF_SET_NUMERIC (elf, new_shdr, entry_size,   ELF_GET_NUMERIC (elf, shdr, entry_size)); // duplicate section entry size
+            }
+            reallocated_ptr = realloc (new_shdr_table, new_shdr_tablesize + ELF_STRUCT_SIZE (elf, shdr)); // grow our section headers table to have one entry more
+            WELLMANNERED_ASSERT (reallocated_ptr, "out of memory");
+            new_shdr_table = reallocated_ptr; // reallocation succeeded, save the new pointer
+            new_shstrtab_shdr_offset = new_shdr_tablesize; // remember the new offset of this section header
+            new_shdr_tablesize += ELF_STRUCT_SIZE (elf, shdr); // and remember how bigger the section headers table is now
+            new_shdr = (elf_section_header_t *) &new_shdr_table[new_shstrtab_shdr_offset]; // now populate this section header
+            ELF_SET_NUMERIC (elf, new_shdr, name_offset, relative_offset_of_in (".shstrtab", elfsection_shstrtab_data, elfsection_shstrtab_size)); // update the relative offset of the section name
+            ELF_SET_NUMERIC (elf, new_shdr, type,         ELF_SECTIONTYPE_STRINGTABLE); // section type (SHT_STRTAB)
+            ELF_SET_NUMERIC (elf, new_shdr, flags,        0); // section flags (we could set SHF_STRINGS i.e. 0x20 here, but mkifs does not, so mimic that)
+            ELF_SET_NUMERIC (elf, new_shdr, virtual_addr, 0); // this section does not need to be mapped
+            ELF_SET_NUMERIC (elf, new_shdr, file_offset, WILL_BE_FILLED_LATER); // FIXME
+            ELF_SET_NUMERIC (elf, new_shdr, size,         elfsection_shstrtab_size); // section size
+            ELF_SET_NUMERIC (elf, new_shdr, linked_index, 0); // this section is not linked to any other
+            ELF_SET_NUMERIC (elf, new_shdr, info,         0); // this section has no additional info
+            ELF_SET_NUMERIC (elf, new_shdr, alignment,    1); // this section is byte-aligned
+            ELF_SET_NUMERIC (elf, new_shdr, entry_size,   0); // this section is not a table, so entry_size is zero
+            // jump over the new section headers table and write the sections that need to be relocated after the section headers table
+            entry_parms->datalen = new_shdrtable_offset + new_shdr_tablesize; // assume there are no sections beyond the section headers table until known otherwise
+            if (elfsection_qnxinfo_data != NULL)
+            {
+               memcpy (&entry_parms->data[entry_parms->datalen], elfsection_qnxinfo_data, elfsection_qnxinfo_size); // write section in place
+               free (elfsection_qnxinfo_data); // free it
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_qnxinfo_shdr_offset]; // now fix this section header
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, entry_parms->datalen); // fix section offset in the new section headers table
+               entry_parms->datalen += elfsection_qnxinfo_size; // update new ELF file length
+            }
+            if (elfsection_debuglink_data != NULL)
+            {
+               memcpy (&entry_parms->data[entry_parms->datalen], elfsection_debuglink_data, elfsection_debuglink_size); // write section in place
+               free (elfsection_debuglink_data); // free it
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_debuglink_shdr_offset]; // now fix this section header
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, entry_parms->datalen); // fix section offset in the new section headers table
+               entry_parms->datalen += elfsection_debuglink_size; // update new ELF file length
+            }
+            if (elfsection_qnxusage_data != NULL)
+            {
+               memcpy (&entry_parms->data[entry_parms->datalen], elfsection_qnxusage_data, elfsection_qnxusage_size); // write section in place
+               free (elfsection_qnxusage_data); // free it
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_qnxusage_shdr_offset]; // now fix this section header
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, entry_parms->datalen); // fix section offset in the new section headers table
+               entry_parms->datalen += elfsection_qnxusage_size; // update new ELF file length
+            }
+            if (elfsection_buildid_data != NULL)
+            {
+               memcpy (&entry_parms->data[entry_parms->datalen], elfsection_buildid_data, elfsection_buildid_size); // write section in place
+               free (elfsection_buildid_data); // free it
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_buildid_shdr_offset]; // now fix this section header
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, entry_parms->datalen); // fix section offset in the new section headers table
+               entry_parms->datalen += elfsection_buildid_size; // update new ELF file length
+            }
+            if (elfsection_shstrtab_data != NULL)
+            {
+               memcpy (&entry_parms->data[entry_parms->datalen], elfsection_shstrtab_data, elfsection_shstrtab_size); // write section header strings table section in place
+               free (elfsection_shstrtab_data);
+               new_shdr = (elf_section_header_t *) &new_shdr_table[new_shstrtab_shdr_offset]; // now fix this section header
+               ELF_SET_NUMERIC (elf, new_shdr, file_offset, entry_parms->datalen); // fix section offset in the new section headers table
+               entry_parms->datalen += elfsection_shstrtab_size; // update new ELF file length
+            }
+            // now write the section headers table
+            fprintf (stderr, "rewriting section headers table at offset 0x%zd\n", new_shdrtable_offset);
+            memcpy (&entry_parms->data[new_shdrtable_offset], new_shdr_table, new_shdr_tablesize);
+            free (new_shdr_table); // free it
+            // and finally fix the ELF header
+            ELF_SET_NUMERIC (elf, elf, section_header_table_offset, new_shdrtable_offset);
+            ELF_SET_NUMERIC (elf, elf, section_header_table_len, new_shdr_tablesize / ELF_STRUCT_SIZE (elf, shdr));
+            ELF_SET_NUMERIC (elf, elf, section_header_names_idx, new_shdr_tablesize / ELF_STRUCT_SIZE (elf, shdr) - 1); // the section headers strings table is the last section
+            // align size with page size (4096 on x86, 16k on ARM)
+            end_padding_offset = entry_parms->datalen;
+            if (ELF_GET_NUMERIC (elf, elf, instruction_set) == ELF_MACHINE_X86_64)
+               entry_parms->datalen = ROUND_TO_UPPER_MULTIPLE (end_padding_offset, 4 * 1024); // 4 kb pages on Intel processors
+            else if (ELF_GET_NUMERIC (elf, elf, instruction_set) == ELF_MACHINE_AARCH64)
+               entry_parms->datalen = ROUND_TO_UPPER_MULTIPLE (end_padding_offset, 16 * 1024); // 16 kb pages on ARM64
+            else
+            {
+               fprintf (stderr, "fatal error: this ELF file \"%s\" does not belong to an architecture supported by ifstool (neither x86_64, nor aarch64)\n", stored_pathname);
+               exit (1);
+            }
+            memset (&entry_parms->data[end_padding_offset], 0, entry_parms->datalen - end_padding_offset); // zerofill
+            entry_parms->extra_ino_flags |= IFS_INO_PROCESSED_ELF; // mark this inode as a preprocessed ELF file
+         } // end if the file is not yet a processed ELF
       } // end if the file we're storing is an ELF file
+   }
    else if (S_ISLNK (entry_parms->st_mode)) // else are we storing a symbolic link ?
       fprintf (stderr, "symlink: ino 0x%x uid %d gid %d mode 0%o path \"%s\" -> \"%s\"\n", inode_count + 1, entry_parms->uid, entry_parms->gid, entry_parms->st_mode, stored_pathname, entry_parms->data);
    else // we must be storing a FIFO
+   }
    *fsentries = reallocated_ptr; // save reallocated pointer
    fsentry = &(*fsentries)[*fsentry_count]; // quick access to fs entry slot
    //fsentry->header.size = 0; // will be filled once we know it
    fsentry->header.extattr_offset = 0;
-   fsentry->header.ino = extra_ino_flags | (++inode_count);
+   fsentry->header.ino = entry_parms->extra_ino_flags | (++inode_count);
    fsentry->header.mode = entry_parms->st_mode;
    fsentry->header.gid = entry_parms->gid;
    fsentry->header.uid = entry_parms->uid;
    fsentry->header.mtime = (entry_parms->mtime == UINT32_MAX ? (uint32_t) time (NULL) : entry_parms->mtime);
    if (S_ISDIR (entry_parms->st_mode))
+   {
       entry_parms->is_compiled_bootscript = false;
       entry_parms->should_autosymlink_dylib = false;
       entry_parms->should_follow_symlinks = false;
       entry_parms->st_mode = S_IFLNK | 0777; // NOTE: mkifs stores symlink permissions as rwxrwxrwx !
+      entry_parms->extra_ino_flags = (fsentry->header.ino & (IFS_INO_PROCESSED_ELF | IFS_INO_RUNONCE_ELF | IFS_INO_BOOTSTRAP_EXE)); // preserve target's inode flags
       last_dirsep = strrchr (stored_pathname, '/');
       old_data = entry_parms->data; // backup previous data pointer
       entry_parms->data = (uint8_t *) (last_dirsep == NULL ? stored_pathname : last_dirsep + 1); // store symlink target in dirent data
       entry_parms->datalen = strlen (entry_parms->data);
       add_fsentry (fsentries, fsentry_count, entry_parms, original_stored_pathname, NULL);
       .mtime_for_inline_files = UINT32_MAX,
       .prefix = "/proc/boot",
       .should_follow_symlinks = true, // [+|-followlink]
       .should_autosymlink_dylib = true, // [+|-autolink]
       .is_compiled_bootscript = false, // [+|-script]
+      .extra_ino_flags = 0,
       .search = "",
       .data = NULL,
       .datalen = 0
    };
    static parms_t entry_parms = { 0 }; // current parameters for a filesystem entry (will be initialized to default_parms each time a new entry is parsed in the build file)
    char path_on_buildhost[MAXPATHLEN] = "";
    char path_in_ifs[MAXPATHLEN] = "";
    char *ifs_pathname = NULL;
    void *reallocated_ptr;
+   const elf_header_t *elf;
+   elf_program_header_t *phdr;
    struct tm utc_time;
    struct stat stat_buf;
    size_t startuptrailer_offset;
    size_t startupheader_offset;
    size_t imagetrailer_offset;
    size_t allocated_size;
    size_t fsentry_index;
    size_t largest_index;
    size_t largest_size;
    size_t curr_offset;
+   size_t table_index;
+   size_t table_count;
    uint8_t *blob_data;
    int32_t checksum;
    char *specifiedpathname_start;
    char *directiveblock_start;
    char *write_ptr;
    int arg_index;
    bool is_quoted_context = false;
    bool is_escaped_char = false;
    bool has_data_already = false;
    bool want_info = false;
+   bool want_everything = false;
    bool want_help = false;
    bool is_foreign_endianness;
    int string_len;
    int read_char;
    FILE *buildfile_fp;
          default_parms.mtime = 0; // all files should have a mtime set to zero
          default_parms.mtime_for_inline_files = 0;
+      }
       else if (strcmp (argv[arg_index], "--info") == 0)
          want_info = true;
+      else if (strcmp (argv[arg_index], "--everything") == 0)
+         want_everything = true;
       else if ((strcmp (argv[arg_index], "-?") == 0) || (strcmp (argv[arg_index], "--help") == 0))
          want_help = true;
       else if (buildfile_pathname == NULL)
          buildfile_pathname = argv[arg_index];
       else if (ifs_pathname == NULL)
       fprintf ((want_help ? stdout : stderr), "          version " VERSION_FMT_YYYYMMDD "\n", VERSION_ARG_YYYYMMDD);
       if (!want_help)
          fprintf (stderr, "error: missing parameters\n");
       fprintf ((want_help ? stdout : stderr), "usage:\n");
       fprintf ((want_help ? stdout : stderr), "    ifstool [--bootfile <pathname>] [--startupfile <pathname>@<EP_from_imgbase>] [--kernelfile <pathname>@<fileoffs>] [-n[n]] <buildfile> <outfile>\n");
-      fprintf ((want_help ? stdout : stderr), "    ifstool --info <ifs file>\n");
+      fprintf ((want_help ? stdout : stderr), "    ifstool --info [--everything] <ifs file>\n");
       fprintf ((want_help ? stdout : stderr), "    ifstool --help\n");
       fprintf ((want_help ? stdout : stderr), "WARNING: the compilation feature is currently a work in progress (broken). Only the --info mode is usable at the moment.\n");
       exit (want_help ? 0 : 1);
+   }
    // do we want info about a particular IFS ? if so, dump it
    if (want_info)
-      exit (dump_ifs_info (buildfile_pathname)); // NOTE: the first argument after --info is actually the IFS file, not a build file, but the arguments are collected in this order
+      exit (dump_ifs_info (buildfile_pathname, want_everything)); // NOTE: the first argument after --info is actually the IFS file, not a build file, but the arguments are collected in this order
    // make sure we have ${QNX_TARGET} pointing somewhere
    QNX_TARGET = getenv ("QNX_TARGET");
    if (QNX_TARGET == NULL)
+   {
       memcpy (startup_header.signature, "\xeb\x7e\xff\x00", 4); // startup header signature, i.e. 0xff7eeb
       startup_header.version       = 1;
       startup_header.flags1        = STARTUP_HDR_FLAGS1_VIRTUAL | STARTUP_HDR_FLAGS1_TRAILER_V2; // flags, 0x21 (STARTUP_HDR_FLAGS1_VIRTUAL | STARTUP_HDR_FLAGS1_TRAILER_V2)
       startup_header.header_size   = sizeof (startup_header); // 256
       if (strcmp (image_processor, "x86_64") == 0)
-         startup_header.machine = STARTUP_HDR_MACHINE_X86_64; // EM_X86_64
+         startup_header.machine = ELF_MACHINE_X86_64; // EM_X86_64
       else if (strcmp (image_processor, "aarch64le") == 0)
-         startup_header.machine = STARTUP_HDR_MACHINE_AARCH64; // EM_AARCH64
+         startup_header.machine = ELF_MACHINE_AARCH64; // EM_AARCH64
       else
+      {
          fprintf (stderr, "fatal error: unsupported processor type '%s' found in build file \"%s\"\n", image_processor, buildfile_pathname);
          exit (1);
+      }
                largest_index = fsentry_index;
+            }
+         }
          if (largest_size == 0)
             break; // found none ? if so, stop searching
+         // is the file we're storing a preprocessed ELF file ?
+         if (fsentries[fsentry_index].header.ino & IFS_INO_PROCESSED_ELF)
+         {
+            elf = (elf_header_t *) fsentries[fsentry_index].u.file.UNSAVED_databuf; // quick access to ELF header
+            table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers
+            for (table_index = 0; table_index < table_count; table_index++)
+            {
+               phdr = (elf_program_header_t *) &fsentries[fsentry_index].u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
+               ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + (0x1400000 + curr_offset)); // patch the physical address member of the program header table
+            }
+         }
          fsentries[largest_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
          fwrite_or_die (fsentries[largest_index].u.file.UNSAVED_databuf, 1, fsentries[largest_index].u.file.size, fp); // write file data blob
          fsentries[largest_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+      }
+      fprintf (stderr, "Current offset: 0x%zx\n", curr_offset);
+      fprintf (stderr, "Kernel file offset: 0x%zx\n", kernelfile_offset);
       PAD_OUTFILE_TO (kernelfile_offset); // reach the kernel offset
       // now write the QNX kernel
       for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++)
          if (fsentries[fsentry_index].header.ino == image_kernel_ino)
       if (!S_ISREG (fsentries[fsentry_index].header.mode) || fsentries[fsentry_index].UNSAVED_was_data_written // filter out anything that's not a file, and anything that's been already written
           || (fsentries[fsentry_index].u.file.size < 4) || (memcmp (fsentries[fsentry_index].u.file.UNSAVED_databuf, ELF_MAGIC_STR, 4) != 0)) // filter out anything that's not an ELF file
          continue; // skip all entries that don't have a separate data block and those who were written already
       curr_offset = ftell (fp);
       fsentries[fsentry_index].u.file.offset = (uint32_t) (curr_offset - imageheader_offset); // save file data blob offset in file structure
+      // is the file we're storing a preprocessed ELF file ?
+      if (fsentries[fsentry_index].header.ino & IFS_INO_PROCESSED_ELF)
+      {
+         elf = (elf_header_t *) fsentries[fsentry_index].u.file.UNSAVED_databuf; // quick access to ELF header
+         table_count = ELF_GET_NUMERIC (elf, elf, program_header_table_len); // get the number of program headers
+         for (table_index = 0; table_index < table_count; table_index++)
+         {
+            phdr = (elf_program_header_t *) &fsentries[fsentry_index].u.file.UNSAVED_databuf[ELF_GET_NUMERIC (elf, elf, program_header_table_offset) + (size_t) ELF_GET_NUMERIC (elf, elf, program_header_item_size) * table_index]; // quick access to program header
+            ELF_SET_NUMERIC (elf, phdr, physical_addr, ELF_GET_NUMERIC (elf, phdr, physical_addr) + (0x1400000 + curr_offset)); // patch the physical address member of the program header table
+         }
+      }
       fwrite_or_die (fsentries[fsentry_index].u.file.UNSAVED_databuf, 1, fsentries[fsentry_index].u.file.size, fp); // write file data blob
       fsentries[fsentry_index].UNSAVED_was_data_written = true; // and remember this file's data was written
+   }
    for (fsentry_index = 1; fsentry_index < fsentry_count; fsentry_index++) // other files (non-ELF, e.g. scripts and data files) last
+   {
    fprintf (stdout, "Success\n");
    exit (0);
+}
-static int dump_ifs_info (const char *ifs_pathname)
+static int dump_ifs_info (const char *ifs_pathname, bool want_everything)
+{
    #define hex_printf(buf,size,...) do { \
-      if ((size) <= 16 * 1024) /* only print when it's not too big (up to 16 kb) */\
+      if (want_everything || ((size) <= 16 * 1024)) /* only print when it's not too big (up to 16 kb) */\
          hex_fprintf (stdout, (buf), (size), 16, __VA_ARGS__); /* use 16 columns in hex output to stdout */ \
       else { \
          printf (__VA_ARGS__); \
-         printf ("   size %zd > 16kb, not printed\n", (size_t) (size)); \
+         hex_fprintf (stdout, (buf), 1024, 16, "   first kilobyte:\n"); \
       } \
    } while (0)
    #define BINARY(x) binary ((x), '-', 'x')
    static const char *startupheader_flags1_strings[8] = {
          printf ("   signature     = %02x %02x %02x %02x - good\n", startup_header->signature[0], startup_header->signature[1], startup_header->signature[2], startup_header->signature[3]);
          printf ("   version       = 0x%04x (%d) - %s\n", startup_header->version, startup_header->version, (startup_header->version == 1 ? "looks good" : "???"));
          printf ("   flags1        = 0x%02x (%s)\n", startup_header->flags1, describe_uint8 (startup_header->flags1, startupheader_flags1_strings));
          printf ("   flags2        = 0x%02x (%s) - %s\n", startup_header->flags2, BINARY (startup_header->flags2), (startup_header->flags2 == 0 ? "looks good" : "???"));
          printf ("   header_size   = 0x%04x (%d) - %s\n", startup_header->header_size, startup_header->header_size, (startup_header->header_size == sizeof (startup_header_t) ? "looks good" : "BAD"));
-         printf ("   machine       = 0x%04x (%d) - %s\n", startup_header->machine, startup_header->machine, (startup_header->machine == STARTUP_HDR_MACHINE_X86_64 ? "x86_64" : (startup_header->machine == STARTUP_HDR_MACHINE_AARCH64 ? "aarch64" : "unknown")));
+         printf ("   machine       = 0x%04x (%d) - %s\n", startup_header->machine, startup_header->machine, (startup_header->machine == ELF_MACHINE_X86_64 ? "x86_64" : (startup_header->machine == ELF_MACHINE_AARCH64 ? "aarch64" : "unknown")));
          printf ("   startup_vaddr = 0x%08x (%d) - virtual address to transfer to after IPL is done\n", startup_header->startup_vaddr, startup_header->startup_vaddr);
          printf ("   paddr_bias    = 0x%08x (%d) - value to add to physical addresses to get an indirectable pointer value\n", startup_header->paddr_bias, startup_header->paddr_bias);
          printf ("   image_paddr   = 0x%08x (%d) - physical address of image\n", startup_header->image_paddr, startup_header->image_paddr);
          printf ("   ram_paddr     = 0x%08x (%d) - physical address of RAM to copy image to (startup_size bytes copied)\n", startup_header->ram_paddr, startup_header->ram_paddr);
          printf ("   ram_size      = 0x%08x (%d) - amount of RAM used by the startup program and executables in the fs\n", startup_header->ram_size, startup_header->ram_size);
                printf ("   corresponding dirent index: %zd/%zd\n", fsentry_index, fsentry_count);
                printf ("   corresponding inode 0x%08x (%d) -%s%s%s%s\n", current_fsentry->header.ino, current_fsentry->header.ino, (current_fsentry->header.ino & 0xE0000000 ? "" : " nothing special"), (current_fsentry->header.ino & IFS_INO_PROCESSED_ELF ? " PROCESSED_ELF" : ""), (current_fsentry->header.ino & IFS_INO_RUNONCE_ELF ? " RUNONCE_ELF" : ""), (current_fsentry->header.ino & IFS_INO_BOOTSTRAP_EXE ? " BOOTSTRAP_EXE" : ""));
                printf ("   corresponding path: \"%s\"\n", (char *) &current_fsentry->u.file.path); // convert from pointer to char array
                printf ("   size 0x%zx (%zd) bytes\n", (size_t) current_fsentry->u.file.size, (size_t) current_fsentry->u.file.size);
                if (current_offset + 4 < filesize)
-               {
-                  if ((current_fsentry->u.file.size < 16 * 1024) && (current_offset + current_fsentry->u.file.size < filesize))
-                     hex_printf (&filedata[current_offset], current_fsentry->u.file.size, "   data:\n");
+                  hex_printf (&filedata[current_offset], current_fsentry->u.file.size, "   data:\n");
-                  else
-                     printf ("   first 4 bytes: %02x%02x%02x%02x \"%c%c%c%c\" (%s)\n", (uint8_t) filedata[current_offset + 0], (uint8_t) filedata[current_offset + 1], (uint8_t) filedata[current_offset + 2], (uint8_t) filedata[current_offset + 3], (isprint (filedata[current_offset + 0]) ? filedata[current_offset + 0] : '.'), (isprint (filedata[current_offset + 1]) ? filedata[current_offset + 1] : '.'), (isprint (filedata[current_offset + 2]) ? filedata[current_offset + 2] : '.'), (isprint (filedata[current_offset + 3]) ? filedata[current_offset + 3] : '.'), (memcmp (&filedata[current_offset], ELF_MAGIC_STR, 4) == 0 ? "ELF binary" : (memcmp (&filedata[current_offset], "#!", 2) == 0 ? "shell script" : "data file")));
-               }
                if (current_offset + current_fsentry->u.file.size < filesize)
                   printf ("   checksum %d\n", update_checksum (&filedata[current_offset], current_fsentry->u.file.size, is_foreign_endianness));
                else
+               {
                   printf ("WARNING: this IFS file is corrupted (the size of this file data extends past the IFS size)\n");

Subversion Repositories QNX 8.QNX8 IFS tool

QNX 8.QNX8 IFS tool//ifstool.c – Rev 9 → 10