Added dumping of NE segments and relocations.

tools/winedump/ne.c

@@ -33,6 +33,36 @@
 #include "wine/winbase16.h"
 #include "winedump.h"
 
+struct ne_segtable_entry
+{
+    WORD seg_data_offset;   /* Sector offset of segment data	*/
+    WORD seg_data_length;   /* Length of segment data		*/
+    WORD seg_flags;         /* Flags associated with this segment	*/
+    WORD min_alloc;         /* Minimum allocation size for this	*/
+};
+
+struct relocation_entry
+{
+    BYTE address_type;    /* Relocation address type */
+    BYTE relocation_type; /* Relocation type */
+    WORD offset;          /* Offset in segment to fixup */
+    WORD target1;         /* Target specification */
+    WORD target2;         /* Target specification */
+};
+
+#define NE_RADDR_LOWBYTE      0
+#define NE_RADDR_SELECTOR     2
+#define NE_RADDR_POINTER32    3
+#define NE_RADDR_OFFSET16     5
+#define NE_RADDR_POINTER48    11
+#define NE_RADDR_OFFSET32     13
+
+#define NE_RELTYPE_INTERNAL  0
+#define NE_RELTYPE_ORDINAL   1
+#define NE_RELTYPE_NAME      2
+#define NE_RELTYPE_OSFIXUP   3
+#define NE_RELFLAG_ADDITIVE  4
+
 static inline WORD get_word( const BYTE *ptr )
 {
     return ptr[0] | (ptr[1] << 8);
@@ -228,8 +258,125 @@ static void dump_ne_exports( const void *base, const IMAGE_OS2_HEADER *ne )
     }
 }
 
+static const char *get_reloc_name( BYTE addr_type, int additive )
+{
+    switch(addr_type & 0x7f)
+    {
+    case NE_RADDR_LOWBYTE:   return additive ? "byte add" : "byte";
+    case NE_RADDR_OFFSET16:  return additive ? "off16 add" : "off16";
+    case NE_RADDR_POINTER32: return additive ? "ptr32 add" : "ptr32";
+    case NE_RADDR_SELECTOR:  return additive ? "sel add" : "sel";
+    case NE_RADDR_POINTER48: return additive ? "ptr48 add" : "ptr48";
+    case NE_RADDR_OFFSET32:  return additive ? "off32 add" : "off32";
+    }
+    return "???";
+}
+
+static const char *get_seg_flags( WORD flags )
+{
+    static char buffer[256];
+
+    buffer[0] = 0;
+#define ADD_FLAG(x) if (flags & NE_SEGFLAGS_##x) strcat( buffer, " " #x );
+    ADD_FLAG(DATA);
+    ADD_FLAG(ALLOCATED);
+    ADD_FLAG(LOADED);
+    ADD_FLAG(ITERATED);
+    ADD_FLAG(MOVEABLE);
+    ADD_FLAG(SHAREABLE);
+    ADD_FLAG(PRELOAD);
+    ADD_FLAG(EXECUTEONLY);
+    ADD_FLAG(READONLY);
+    ADD_FLAG(RELOC_DATA);
+    ADD_FLAG(SELFLOAD);
+    ADD_FLAG(DISCARDABLE);
+    ADD_FLAG(32BIT);
+#undef ADD_FLAG
+    if (buffer[0])
+    {
+        buffer[0] = '(';
+        strcat( buffer, ")" );
+    }
+    return buffer;
+}
+
+static void dump_relocations( const void *base, const IMAGE_OS2_HEADER *ne, WORD count,
+                              const struct relocation_entry *rep )
+{
+    const WORD *modref = (const WORD *)((const BYTE *)ne + ne->ne_modtab);
+    const BYTE *mod_name, *func_name;
+    WORD i;
+
+    for (i = 0; i < count; i++, rep++)
+    {
+        int additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
+        switch (rep->relocation_type & 3)
+        {
+        case NE_RELTYPE_ORDINAL:
+            mod_name = (const BYTE *)ne + ne->ne_imptab + modref[rep->target1 - 1];
+            printf( "%6d: %s = %*.*s.%d\n", i + 1, get_reloc_name( rep->address_type, additive ),
+                    *mod_name, *mod_name, mod_name + 1, rep->target2 );
+            break;
+        case NE_RELTYPE_NAME:
+            mod_name = (const BYTE *)ne + ne->ne_imptab + modref[rep->target1 - 1];
+            func_name = (const BYTE *)ne + ne->ne_imptab + rep->target2;
+            printf( "%6d: %s = %*.*s.%*.*s\n", i + 1, get_reloc_name( rep->address_type, additive ),
+                    *mod_name, *mod_name, mod_name + 1,
+                    *func_name, *func_name, func_name + 1 );
+            break;
+        case NE_RELTYPE_INTERNAL:
+            if ((rep->target1 & 0xff) == 0xff)
+            {
+                /* the module itself */
+                mod_name = (const BYTE *)ne + ne->ne_restab;
+                printf( "%6d: %s = %*.*s.%d\n", i + 1, get_reloc_name( rep->address_type, additive ),
+                        *mod_name, *mod_name, mod_name + 1, rep->target2 );
+            }
+            else
+                printf( "%6d: %s = %d:%04x\n", i + 1, get_reloc_name( rep->address_type, additive ),
+                        rep->target1, rep->target2 );
+            break;
+        case NE_RELTYPE_OSFIXUP:
+            /* Relocation type 7:
+             *
+             *    These appear to be used as fixups for the Windows
+             * floating point emulator.  Let's just ignore them and
+             * try to use the hardware floating point.  Linux should
+             * successfully emulate the coprocessor if it doesn't
+             * exist.
+             */
+            printf( "%6d: %s = TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
+                    i + 1, get_reloc_name( rep->address_type, additive ),
+                    rep->relocation_type, rep->offset,
+                    rep->target1, rep->target2 );
+            break;
+        }
+    }
+}
+
+static void dump_ne_segment( const void *base, const IMAGE_OS2_HEADER *ne, int segnum )
+{
+    const struct ne_segtable_entry *table = (const struct ne_segtable_entry *)((const BYTE *)ne + ne->ne_segtab);
+    const struct ne_segtable_entry *seg = table + segnum - 1;
+
+    printf( "\nSegment %d:\n", segnum );
+    printf( "  File offset: %08x\n", seg->seg_data_offset << ne->ne_align );
+    printf( "  Length:      %08x\n", seg->seg_data_length );
+    printf( "  Flags:       %08x %s\n", seg->seg_flags, get_seg_flags(seg->seg_flags) );
+    printf( "  Alloc size:  %08x\n", seg->min_alloc );
+    if (seg->seg_flags & NE_SEGFLAGS_RELOC_DATA)
+    {
+        const BYTE *ptr = (const BYTE *)base + (seg->seg_data_offset << ne->ne_align) + seg->seg_data_length;
+        WORD count = get_word(ptr);
+        ptr += sizeof(WORD);
+        printf( "  Relocations:\n" );
+        dump_relocations( base, ne, count, (const struct relocation_entry *)ptr );
+    }
+}
+
 void ne_dump( const void *exe, size_t exe_size )
 {
+    unsigned int i;
     const IMAGE_DOS_HEADER *dos = exe;
     const IMAGE_OS2_HEADER *ne = (const IMAGE_OS2_HEADER *)((const char *)dos + dos->e_lfanew);
 
@@ -237,4 +384,5 @@ void ne_dump( const void *exe, size_t exe_size )
     dump_ne_names( exe, ne );
     dump_ne_resources( exe, ne );
     dump_ne_exports( exe, ne );
+    for (i = 1; i <= ne->ne_cseg; i++) dump_ne_segment( exe, ne, i );
 }