Changeset 534

Timestamp:

Aug 5, 2003, 8:54:32 PM (22 years ago)

Author:

bird

Message:

#483,#428: sorting, new weak handling, legacy mode.

File:

• trunk/src/emx/src/emxexp/emxexp.c (modified) (15 diffs, 1 prop)

trunk/src/emx/src/emxexp/emxexp.c ¶

@@ -38 +38 @@
 };
 
+/* if != 0 we're supposed to add ordinals to the symbols. */ 
 static int ordinal = 0;
+/* if set the ordinals is to be sequentially assigned with no 
+   conveniency gaps or anything. */
+static int ordinal_seq = FALSE;
 static int noname_flag = FALSE;
 static int bss_flag = FALSE;
 static int weak_flag = FALSE;
+/* When clear we'll do sorting and handle make sure there no duplicate weak 
+   names and such. If set we'll just dump the publics and comdefs as we 
+   used to do. */
+static int legacy_mode = FALSE;
 
 static FILE *out_file;
@@ -50 +58 @@
 static struct bss_list *bss_list = NULL;
 
+/* OMF globals */
+static struct segdef
+{
+    /* pointer to local name */
+    const char *name;
+}              *segdefs;
+static unsigned num_segdefs;
+static char **  lnames;
+static unsigned num_lnames;
+
+/* Aout globals */
+static char *aout_segnames[] = 
+{   
+    NULL,     NULL,     /*  0 N_UNDF */    
+    NULL,     NULL,     /*  2 N_ABS */ 
+    "TEXT32", "TEXT32", /*  4 N_TEXT */    
+    "DATA32", "DATA32", /*  6 N_DATA */    
+    "BSS32",  "BSS32",  /*  8 N_BSS */     
+    NULL,     NULL,     /*  a */
+    NULL,     NULL,     /*  c,  d N_WEAKU */
+    NULL,     "TEXT32", /*  d N_WEAKA,  f N_WEAKT */
+    "DATA32", "BSS32",  /* 10 N_WEAKD, 11 N_WEAKB */
+    NULL, NULL,  NULL, NULL, NULL
+};
+
+/* Per segment name sorting 
+   Symbols are orginized in two constructs. One is a global symbol name
+   string pool kind thing. The other is per segment. 
+   
+   Weak symbols and communial data may be overridden. In those cases we'll
+   unlink the symbol and reinstert it to ensure that we don't get it in the
+   wrong segment.
+   */
+
+/* module in which a symbol is defined. */
+struct new_module
+{
+    char *              name;           /* module name. */
+    struct new_module * next;           /* next module in the chain. */
+};
+
+/* LIFO of modules. (only so we can free it) 
+   The head module is the current one. */
+struct new_module      *new_modules;    
+
+
+/* one symbol */
+struct new_symbol
+{
+    char *              name;           /* Symbol name from heap. */
+    struct new_symbol  *nexthash;       /* Next hash table entry. */
+    struct new_symbol  *next, *prev;    /* Per segment chain. */
+    struct new_module  *mod;            /* Module in which the symbol is defined. */
+    unsigned            fweak:1;        /* Weak symbol. */
+    unsigned            fcomm:1;        /* Communial data. */
+    unsigned            fdummy:1;       /* Dummy node, the one which is first & last 
+                                           in the lists to save use from any 
+                                           unpleasant list head/tail thinking. */
+}; 
+
+/* List of segments. */
+static struct new_symgrp
+{
+    char *              name;           /* segment name */
+    struct new_symbol  *head;           /* head of list. Always starts with a dummy node. */
+    struct new_symbol  *tail;           /* tail of list. Always starts with a dummy node. */
+    struct new_symgrp  *next;           /* next segement. */
+}                 * new_symgrps;
+
+/* symbol string hash table */
+struct new_symbol *  new_hashtable[211];
+
+
+
 static void error (const char *fmt, ...) NORETURN2;
 static void usage (void) NORETURN2;
@@ -75 +157 @@
 
   p = malloc (n);
-  if (p == NULL)
+  if (p == NULL && n)
     error ("Out of memory");
   return p;
@@ -90 +172 @@
 
   p = realloc (ptr, n);
-  if (p == NULL)
+  if (p == NULL && n)
     error ("Out of memory");
   return p;
 }
+
+
+/* Create a duplicate of the string S on the heap.  Quit on failure.
+   This function is used like strdup(), but we don't have to check the
+   return value. */
+
+char *xstrdup (const char *s)
+{
+  char *p;
+
+  p = xmalloc (strlen (s) + 1);
+  strcpy (p, s);
+  return p;
+}
+
 
 
@@ -106 +203 @@
          "  -o          Output ordinal numbers, starting at 1\n"
          "  -o<ordinal> Output ordinal numbers, starting at <ordinal>\n"
-         "  -u          Also export uninitialized variables\n"
-         "  -w          Allow export of weak symbols\n",
+         "  -u          Also export uninitialized variables - only legacy mode\n"
+         "  -w          Allow export of weak symbols - only legacy mode\n"
+         "  -l          Legacy mode - disables sorting and weak handling\n",
          stderr);
   exit (1);
+}
+
+
+/* New export function. This will filter out duplicated BSS32 and weak 
+   symbols and insert the symbols into arrays according to segment 
+   value. new_print() will be called when all the input files are
+   processed and do the actual printing and ordinal assignments. */
+    
+static void new_export (const char *name, const char *segname, int fweak, int fcomm)
+{
+  struct new_symbol  *psym;
+  unsigned            uhash;
+  const char *        psz;
+
+  /* compute hash */
+  for (uhash = 0, psz = name; *psz; *psz++)
+    uhash = uhash * 65599 + *psz;
+  uhash %= sizeof(new_hashtable) / sizeof(new_hashtable[0]);
+
+  /* look for it */
+  for (psym = new_hashtable[uhash]; psym; psym = psym->nexthash)
+    if (!strcmp(psym->name, name))
+        break;
+
+  /* new */
+  if (!psym)
+    {
+      /* create new symbol node */
+      psym = xmalloc(sizeof(*psym));
+      psym->name = xstrdup(name);
+
+      /* insert into hash */
+      psym->nexthash = new_hashtable[uhash];
+      new_hashtable[uhash] = psym;
+    }
+  else 
+    {/* existing. look for overrided symbols (weak/comm) and ignore duplicates. */
+      if (fweak || fcomm)
+        psym = NULL;                  /* just skip it - did I forget something...? */
+      else
+        {
+          if (psym->fcomm || psym->fweak)
+            { /* unlink the symbol. */
+              psym->prev->next = psym->next;
+              psym->next->prev = psym->prev;
+            }
+          else
+            psym = NULL;
+        }
+    }
+
+  /* insert the correct list */
+  if (psym)
+    {
+      struct new_symgrp *psymgrp;
+
+      /* Set symbol data */
+      psym->fcomm = fcomm;
+      psym->fweak = fweak;
+      psym->fdummy = 0;
+      psym->mod = new_modules;               
+
+
+      /* find the segment */
+      for (psymgrp = new_symgrps; psymgrp; psymgrp = psymgrp->next)
+        if (   psymgrp->name == segname 
+            || (segname && psymgrp->name && !strcmp(psymgrp->name, segname))
+              )
+           break;
+
+       /* new or old ? */
+       if (!psymgrp)
+         {
+           psymgrp = xmalloc(sizeof(*psymgrp));
+           psymgrp->name = segname ? xstrdup(segname) : NULL;
+           psymgrp->head = xmalloc(sizeof(*psymgrp->head));
+           psymgrp->tail = xmalloc(sizeof(*psymgrp->tail));
+           memset(psymgrp->head, 0, sizeof(*psymgrp->head));
+           memset(psymgrp->tail, 0, sizeof(*psymgrp->tail));
+           psymgrp->head->fdummy = 1;
+           psymgrp->tail->fdummy = 1;
+           /* link dummies */
+           psymgrp->head->next = psymgrp->tail;
+           psymgrp->tail->prev = psymgrp->head;
+           psymgrp->head->name = psymgrp->tail->name = "#;$$$$$$dummy$$$$$$$$$$$;#";
+           /* link it in */
+           psymgrp->next = new_symgrps;
+           new_symgrps = psymgrp;
+         }
+
+       /* insert at tail. */
+       psym->prev = psymgrp->tail->prev;
+       psym->next = psymgrp->tail;
+       psymgrp->tail->prev->next = psym;
+       psymgrp->tail->prev = psym;
+    }
+}
+
+
+/* Print the publics. (new method) 
+
+   When -o is not specified with number, to leave a round number of unused 
+   ordinals between the segments out of convenience mostly. */
+
+static void new_print(FILE *phfile, struct new_symgrp *psymgrp)
+{
+  /* enumerate symbol groups (segments) */
+  for (; psymgrp; psymgrp = psymgrp->next)
+    {
+      struct new_symbol  *psym;
+      
+      /* print a decent header */
+      if (psymgrp->name)
+        fprintf (phfile, "  ; segment %s\n", psymgrp->name); 
+      else
+        fprintf (phfile, "  ; segment noname\n"); 
+
+      /* enumerate symbols */
+      for (psym = psymgrp->head->next; psym != psymgrp->tail; psym = psym->next)
+        {
+          int   cch;
+
+          cch = fprintf (phfile, "  \"%s\"", psym->name);
+          /* fancy align */
+          if (cch < 69)
+              cch = 70 - cch;
+          else if (cch < 89)
+              cch = 90 - cch;
+          else if (cch < 119)
+              cch = 120 - cch;
+          else
+              cch = 40 - (cch % 39);
+          fprintf (phfile, "%*s", cch, "");
+
+          /* flags */
+          if (ordinal != 0)
+            cch += fprintf (phfile, " @%-5d", ordinal++);
+          if (noname_flag)
+            cch += fprintf (phfile, " NONAME");
+
+          /* comments - the first one might be used by emximp later... */
+          fprintf (phfile, "  ; magicseg='%s' len=%d", 
+                   psymgrp->name ? psymgrp->name : "", strlen(psym->name));
+          if (psym->fweak)
+              fprintf (phfile, "  weak");
+          if (psym->fcomm)
+              fprintf (phfile, "  comm");
+          if (psym->mod)
+              fprintf (phfile, "  mod='%s'", psym->mod->name);
+
+          fputc ('\n', phfile);
+        } 
+      
+      /* skip a line and some ordinals if we're allowed */
+      fputc ('\n', phfile);
+      if (!ordinal_seq)
+        ordinal = ((ordinal + 199) / 100) * 100;
+    }
 }
 
@@ -200 +456 @@
     if (sym_ptr[i].n_type == (N_TEXT|N_EXT) ||
         sym_ptr[i].n_type == (N_DATA|N_EXT) ||
-        (weak_flag &&
+        ((!legacy_mode || weak_flag) &&
          (sym_ptr[i].n_type == N_WEAKT ||
           sym_ptr[i].n_type == N_WEAKD)))
       {
         name = str_ptr + sym_ptr[i].n_un.n_strx;
-        export (name);
+        if (legacy_mode)
+          export (name);
+        else
+          new_export (name, aout_segnames[sym_ptr[i].n_type], 
+                      sym_ptr[i].n_type >= N_WEAKU && sym_ptr[i].n_type >= N_WEAKB, 
+                      FALSE);
       }
     else if ((sym_ptr[i].n_type == N_EXT && sym_ptr[i].n_value != 0) ||
              sym_ptr[i].n_type == (N_BSS|N_EXT) ||
-             (weak_flag && sym_ptr[i].n_type == N_WEAKB))
+             ((!legacy_mode || weak_flag) && sym_ptr[i].n_type == N_WEAKB))
       {
         name = str_ptr + sym_ptr[i].n_un.n_strx;
-        export_bss (name);
+        if (legacy_mode)
+          export_bss (name);
+        else
+          new_export (name, aout_segnames[sym_ptr[i].n_type], 
+                      sym_ptr[i].n_type >= N_WEAKU && sym_ptr[i].n_type >= N_WEAKB, 
+                      TRUE);
       }
 
@@ -334 +600 @@
   word frame;
   dword offset;
-  byte name[256];
+  byte name[260];
 
   group = get_index ();
@@ -343 +609 @@
   while (rec_idx < rec_len)
     {
+      char *weak;
       get_string (name);
       offset = get_word_or_dword ();
       type = get_index ();
-      export (name);
+      weak = strstr(name, "$w$");
+      if (legacy_mode)
+        {
+          if (!weak || weak_flag)
+            export (name);
+        }
+      else
+        {
+          if (weak)
+            {
+              memmove(weak + 1, weak, strlen(weak) + 1);
+              *weak++ = '\0';
+            }
+          new_export (name, segdefs[seg].name, weak != NULL, FALSE);
+        }
     }
 }
@@ -354 +635 @@
 {
   int type_index, data_type;
-  byte name[256];
+  byte name[260];
 
   while (rec_idx < rec_len)
     {
+      char *weak;
       get_string (name);
       type_index = get_index ();
@@ -373 +655 @@
           bad_omf ();
         }
-      export_bss (name);
-    }
-}
+
+      weak = strstr(name, "$w$");
+      if (legacy_mode)
+        {
+          if (!weak || weak_flag)
+            export_bss (name);
+        }
+      else
+        {
+          if (weak)
+            {
+              memmove(weak + 1, weak, strlen(weak) + 1);
+              *weak++ = '\0';
+            }
+          new_export (name, "BSS32", weak != NULL, TRUE);
+        }
+    }
+}
+
+
+static void omf_lnames (void)
+{
+  while (rec_idx < rec_len)
+    {
+      unsigned len = get_byte ();
+      if (!(num_lnames % 64))
+        lnames = xrealloc(lnames, sizeof(lnames[0]) * (num_lnames + 64));
+      lnames[num_lnames] = xmalloc(len + 1);
+      get_mem(lnames[num_lnames], len);
+      lnames[num_lnames][len] = '\0';
+      num_lnames++;
+    }
+}
+
+
+static void omf_segdef (void)
+{ 
+  byte      flags;
+  unsigned  nameidx;
+  unsigned  classidx;
+  unsigned  ovlidx;
+  
+  /* all we want the the segment name */
+  flags = get_byte ();                  /* segment attributes */
+  if ((flags & 0xE0) == 0)
+    {
+      get_word ();                      /* frame number */
+      get_byte ();                      /* offset */
+    }
+  if (rec_type & REC32)                 /* segment length */
+    get_dword ();                       
+  else
+    get_word ();
+
+  nameidx = get_index ();
+  classidx = get_index ();
+  ovlidx = get_index ();
+  if (nameidx == 0)
+      nameidx = classidx;               /* paranoia */
+
+  /* add it */
+  if (!(num_segdefs % 64))
+    segdefs = xrealloc (segdefs, sizeof(segdefs[0]) * (num_segdefs + 64));
+  if (nameidx != 0 && nameidx < num_lnames)
+    segdefs[num_segdefs].name = lnames[nameidx];
+  else
+    segdefs[num_segdefs].name = NULL;
+  num_segdefs++;
+}
+
 
 
 static void process_omf (FILE *inp_file)
 {
-  struct omf_rec rec;
-
+  int               i;
+  struct omf_rec    rec;
+
+  /* init */
   new_mod = TRUE;
+  lnames = xmalloc(sizeof(lnames[0])* 64);
+  lnames[0] = NULL;
+  num_lnames = 1;                       /* dummy entry */
+  segdefs = xmalloc(sizeof(segdefs[0])* 64);
+  memset(&segdefs[0], 0, sizeof(segdefs[0]));
+  num_segdefs = 1;
+
+  /* read */
   do
     {
@@ -402 +761 @@
           break;
         case COMDEF:
-          if (bss_flag)
+          if (!legacy_mode || bss_flag)
             omf_comdef ();
           break;
+        case LNAMES:
+          omf_lnames ();
+          break;
+        case SEGDEF:
+        case SEGDEF|REC32:
+          omf_segdef ();
+          break;
         }
     } while (rec.rec_type != MODEND && rec_type != (MODEND|REC32));
+   
+   /* cleanup (entry 0 isn't used) */
+   for (i = 1; i < num_lnames; i++)
+       free(lnames[i]);
+   free(lnames);
+   free(segdefs);
 }
 
@@ -593 +965 @@
         case 'o':
           if (optarg == NULL)
-            ordinal = 1;
+              ordinal = 1;
           else
             {
@@ -601 +973 @@
                   || ordinal < 1 || ordinal > 65535)
                 usage ();
+              ordinal_seq = 1;
             }
           break;
@@ -609 +982 @@
           weak_flag = TRUE;
           break;
+        case 'l':
+          legacy_mode = TRUE;
+          break;
         default:
           error ("Invalid option");
@@ -625 +1001 @@
     }
 
+  if (!legacy_mode)
+    new_print(out_file, new_symgrps);
+
   if (fflush (out_file) != 0 || (out_file != stdout && fclose (out_file) != 0))
     error ("Write error");