Changeset 60

Timestamp:

Apr 29, 2003, 6:13:11 PM (22 years ago)

Author:

bird

Message:

Changes relative to original emxomfld:

• Resource compiler is run with "-n" so that it won't show its logo. Note that old versions of RC do not understand "-n" - if you receive messages

like "RC: error - invalid switch -n" you will need a newer RC.

• With -Zexe emxomfld copies ldstub.bin into a file with same name as executable but without ".exe" extenstion. This way you can use Unix

shell scripts and makefiles without modifications.

• Implemented kludgy weak sypport for emxomf converter. Alas, LINK386 does not support real weak symbols for OMF object files :-( This is

implemented by keeping a list of all weak symbols in a separate text

file, along with the object file name where it has been encountered

for the first time. Then, when this symbol is encountered, if the

output file is the mentioned object file, it is transformed into a

strong external symbol, otherwise it is transformed into a non-exported

local symbol (thus duplicate symbol errors won't occur).

• Added the `-w' switch to emxomf to suppress reading/writing of the weaksyms.omf file.
  • Disabled several warnings encountered during translation of the newer a.out files generated by latest gcc's. It looks like stabs format has

been improved a little since last update to EMX tools.

• Added support for variables in the BSS segment. Newer gcc can generate variables directly in .bss, and emxomf used to `forget' such labels,

although did not print any warnings.

• emxomf won't remove the leading underscore for stdcall names. This is for better compatibility with VACPP.
  • patch to emxomld to not pass the /bat{ch} switch if the EMXOMF_LINKER variable is set to ILINK. Also for ILINK the /NOFREE{FORMAT} switch is

passed, which ensures command-line format compatibility with LINK386.

• emxomf fixed so that the segdef records are defined as paragraph aligned. This allows to merge data segments from different object files without

breaking alignments less or equal than 16 bytes.

Location:

trunk/src/emx/src/emxomf

Files:

• emxomf.c (modified) (25 diffs, 1 prop)
• emxomfld.c (modified) (7 diffs, 1 prop)
• stabshll.c (modified) (15 diffs, 1 prop)

trunk/src/emx/src/emxomf/emxomf.c

@@ -25 +25 @@
 #include <stdarg.h>
 #include <string.h>
+#include <alloca.h>
+#include <ctype.h>
 #include <getopt.h>
 #include <sys/param.h>
@@ -125 +127 @@
 };
 
+/* This structure keeps track which weak symbol and where it is defined,
+   to simulate weak symbols in OMF (which aren't supported in OMF) */
+
+struct weaksym
+{
+  struct weaksym *next;         /* Next weak symbol in chain */
+  char *name;                   /* Symbol name */
+  char *module;                 /* Object file where it should be defined */
+  int used;                     /* 1 if the symbol has been encountered */
+};
+
 
 /* The number of symbols in the a.out file. */
@@ -237 +250 @@
 static int opt_x = FALSE;
 
+/* Suppress reading and/or writing of the weaksyms.omf file */
+static int opt_w = FALSE;
+
+/* Remove underscores from all symbol names */
+static int opt_rmunder = FALSE;
+
 /* This is the page size for OMF libraries.  It is set by the -p
    option. */
@@ -258 +277 @@
 /* The index of the "WEAK$ZERO" symbol or 0. */
 static int weak_zero_index;
+
+/* The list of currently known OMF symbols */
+static struct weaksym *weak_symbol_list;
+static struct weaksym **weak_symbol_top = &weak_symbol_list;
+
+/* 1 whenever the weak symbol list has been altered */
+static int weak_list_altered;
+
+/* The file name of the weak symbol list file */
+static char *weak_list_filename;
 
 /* OMF name indices: segments, classes, groups, etc. */
@@ -348 +377 @@
 /* The name of the identifier manipulation DLL.  If this variable is
    NULL, no IDMDLL record is written. */
-static char *idmdll_name = "GPPDEMID";
+static char *idmdll_name = "GPP3DEM";
 
 /* If this variable is TRUE (-b option), we always use the 32-bit
@@ -499 +528 @@
 
 
+/* Check if we should remove the leading underscore from a symbol name */
+static inline int strip_underscore (const char *name)
+{
+  if (!opt_rmunder)
+    return 0;
+
+  return (*name == '_');
+}
+
+
 /* Find an a.out symbol.  The underscore character `_' is prepended to
    NAME.  On success, a pointer to the symbol table entry (in the
@@ -506 +545 @@
 const struct nlist *find_symbol (const char *name)
 {
-  int i, j, n, len, ok, t;
+  int i, j, n, len, t;
   const byte *s;
   
@@ -515 +554 @@
   while (i < str_size)
     {
-      ok = TRUE; s = name;
-      if (str_ptr[i] == '_')
+      int sym_ofs = i;
+      s = name;
+      if (strip_underscore (str_ptr + i))
         ++i;
-      else
-        ok = FALSE;
-      if (ok && memcmp (name, str_ptr+i, len+1) == 0)
+      if (memcmp (name, str_ptr+i, len+1) == 0)
         {
 
@@ -527 +565 @@
 
           n = sym_count;
-          --i;                  /* Move back to the underscore */
           for (j = 0; j < n; ++j)
-            if (sym_ptr[j].string == i)
+            if (sym_ptr[j].string == sym_ofs)
               {
                 t = sym_ptr[j].type & ~N_EXT;
@@ -540 +577 @@
     }
   return NULL;                  /* Symbol not found */
+}
+
+
+/* Add a symbol to weak symbol list */
+
+static struct weaksym *add_weak (const char *symname, const char *modname)
+{
+  struct weaksym *newsym = malloc (sizeof (struct weaksym));
+  newsym->name = xstrdup (symname);
+  newsym->module = xstrdup (modname);
+  newsym->used = 0;
+  newsym->next = NULL;
+  *weak_symbol_top = newsym;
+  weak_symbol_top = &newsym->next;
+  weak_list_altered = 1;
+  return newsym;
+}
+
+
+/* Load the weak symbols table from the weaksyms.omf file.
+ * We emulate the weak symbol functionality in the following way:
+ * first time we encounter a weak symbol, we mark it as "strong"
+ * and remember the first object file where it was encountered.
+ * Then when another instance of this weak symbol is encountered
+ * the output file name is checked; if it is a different object file,
+ * the symbol is marked as local. Otherwise it is marked as strong.
+ * Finally, when we find any external references to this symbol, they
+ * are marked as "OMF weak reference", e.g. the N_WEAKU type
+ * (which is quite different from a.out weaks, thats why we have
+ * to dig all that mess!). Alas, this mechanism can require multi-pass
+ * builds for complex cases...
+ */
+
+static void weak_load (void)
+{
+  FILE *wf;
+
+  if (opt_w)
+    return;
+
+  /* Find and open the weak symbol list file */
+  weak_list_filename = getenv ("GCC_WEAKSYMS");
+  if (!weak_list_filename)
+    weak_list_filename = "weaksyms.omf";
+  wf = fopen (weak_list_filename, "r");
+  if (!wf)
+    return;
+
+  /* Every line of the file contains something like:
+       __symbol:object_file
+     or just
+       __symbol
+  */
+
+  char line [1024];
+  while (fgets (line, sizeof (line), wf))
+    {
+      char *eol = strchr (line, 0);
+      while ((eol > line) && (isspace (eol [-1])))
+        eol--;
+      *eol = 0;
+      char *sep = strchr (line, ':');
+      if (!sep)
+        {
+          fprintf (stderr, "WARNING: bad line `%s' in weak symbol list file `%s'\n",
+            line, weak_list_filename);
+          continue;
+        }
+
+      *sep = 0;
+      add_weak (line, sep + 1);
+    }
+
+  fclose (wf);
+
+  /* Mark the list as unmodified */
+  weak_list_altered = 0;
+}
+
+
+/* Save the weak symbol list */
+
+static void weak_save (void)
+{
+  FILE *wf;
+  struct weaksym *wsym;
+
+  if (opt_w)
+    return;
+
+  /* Find and open the weak symbol list file */
+  wf = fopen (weak_list_filename, "w");
+  if (!wf)
+    return;
+
+  for (wsym = weak_symbol_list; wsym; wsym = wsym->next)
+    fprintf (wf, "%s:%s\n", wsym->name, wsym->module);
+
+  fclose (wf);
+}
+
+
+/* Free the weak symbol list */
+
+static void weak_free (void)
+{
+  struct weaksym *cur = weak_symbol_list;
+  while (cur)
+    {
+      struct weaksym *next = cur->next;
+      free (cur->name);
+      free (cur->module);
+      free (cur);
+      cur = next;
+    }
+  weak_symbol_list = NULL;
+}
+
+
+/* Find if a symbol is weak */
+
+static struct weaksym *is_weak (const char *symname)
+{
+  struct weaksym *wsym;
+  for (wsym = weak_symbol_list; wsym; wsym = wsym->next)
+    if (!strcmp (symname, wsym->name))
+      return wsym;
+  return NULL;
 }
 
@@ -742 +907 @@
 static void put_sym (const char *src)
 {
-  if (*src == '_')
+  if (strip_underscore (src))
     ++src;
   put_str (src);
@@ -965 +1130 @@
 
 
+/* Check all external symbol references for weakness; if a symbol is weak,
+   mark it as N_WEAKU so that it is later writen within a WKEXT record.
+   Also we convert a.out-style weak symbols here as normal public symbols,
+   as the sense of weak is reverse in OMF */
+
+static void weak_process (void)
+{
+  int i;
+
+#define SETTYPE(t) ((struct nlist *)sym_ptr)[i].type = t
+
+  for (i = 0; i < sym_count; ++i)
+    if ((sym_ptr[i].type >= N_WEAKA) && (sym_ptr[i].type <= N_WEAKB))
+      {
+        const char *name = str_ptr + sym_ptr[i].string;
+
+        int public = N_EXT;
+
+        /* Add the symbol to weak list if not already */
+        struct weaksym *wsym = is_weak (name);
+        if (!wsym)
+          wsym = add_weak (name, out_fname);
+        else if (strcmp (out_fname, wsym->module) || wsym->used)
+          public = 0;
+        /* If the symbol is exported more than once (e.g. from an archive),
+           export just the first instance... */
+        wsym->used = 1;
+
+        /* Now convert it to a normal public symbol */
+        switch (sym_ptr[i].type)
+          {
+            case N_WEAKA: SETTYPE (N_ABS  | public); break;
+            case N_WEAKT: SETTYPE (N_TEXT | public); break;
+            case N_WEAKD: SETTYPE (N_DATA | public); break;
+            case N_WEAKB: SETTYPE (N_BSS  | public); break;
+          }
+      }
+    else if ((sym_ptr[i].type & N_EXT) && is_weak (str_ptr + sym_ptr[i].string))
+      {
+         /* Convert a external reference to N_WEAKU */
+         /* P.S. As experiments show, WKEXT works somewhat strangely
+            with LINK386 (sometimes such external references are left
+            unresolved, even that they could be resolved), thus the
+            following line is commented out */
+         /*SETTYPE (N_WEAKU);*/
+      }
+
+#undef SETTYPE
+}
+
+
 /* Write ALIAS records into the output file for all indirect
    references. */
@@ -984 +1200 @@
           {
             pub_name = str_ptr + sym_ptr[i].string;
-            if (*pub_name == '_')
+            if (strip_underscore (pub_name))
               ++pub_name;
             if (omflib_add_pub (out_lib, pub_name, mod_page, lib_errmsg) != 0)
@@ -1034 +1250 @@
                   {
                     pub_name = name;
-                    if (*pub_name == '_')
+                    if (strip_underscore (pub_name))
                       ++pub_name;
                     if (omflib_add_pub (out_lib, pub_name, mod_page,
@@ -1076 +1292 @@
   write_pubdef1 (N_DATA, udat_index, FALSE, text_size);
   write_pubdef1 (N_DATA, udat_index, TRUE, text_size);
+  write_pubdef1 (N_BSS, bss_index, FALSE, text_size + data_size);
+  write_pubdef1 (N_BSS, bss_index, TRUE, text_size + data_size);
 }
 
@@ -1171 +1389 @@
     The segment attributes byte contains the following fields:
 
-    A (bits 5-7)        Alignment (101=relocatable, 32-bit alignment)
+    A (bits 5-7)        Alignment (011=relocatable, paragraph (16b) alignment)
+                        (before gcc 3.2.2: 101=relocatable, 32-bit alignment)
     C (bits 2-4)        Combination (010=PUBLIC, 101=STACK)
     B (bit 1)           Big (segment length is 64KB)
@@ -1180 +1399 @@
   byte seg_attr;
 
-  seg_attr = (stack ? 0xb5 : 0xa9);
+  seg_attr = (stack ? 0x75 : 0x69);
   if (size > 0x10000 || force_big)
     {
@@ -2135 +2354 @@
   /* Skip a leading underscore character if present. */
 
-  if (*pub_name == '_')
+  if (strip_underscore (pub_name))
     ++pub_name;
 
@@ -2629 +2848 @@
                     case N_INDR|N_EXT:
                     case N_WEAKU:
+                    case N_WEAKA:
+                    case N_WEAKT:
+                    case N_WEAKD:
+                    case N_WEAKB:
       case N_SETA:  case N_SETA|N_EXT:
       case N_SETT:  case N_SETT|N_EXT:
@@ -2847 +3070 @@
   if (do_set_groups)
     write_set_groups ();
+
+  /* Process weak symbols */
+  weak_process ();
 
   /* Define external, communal and public symbols (EXTDEF, WKEXT,
@@ -2946 +3172 @@
   puts ("  -I <idmdll>        Name the identifier manipulation DLL");
   puts ("  -O <directory>     Extract files to <directory>");
+  puts ("  -w                 Suppress reading/writing of the weaksyms.omf file");
+  puts ("  -z                 Remove underscores from all symbol names");
   exit (1);
 }
@@ -3331 +3559 @@
   /* Parse the command line options. */
 
-  while ((c = getopt (argc, argv, "bdD:gi:I:m:l::o:p:qO:r:R:sux")) != EOF)
+  while ((c = getopt (argc, argv, "bdD:gi:I:m:l::o:p:qO:r:R:suxwz")) != EOF)
     switch (c)
       {
@@ -3408 +3636 @@
         opt_x = TRUE;
         break;
+      case 'w':
+        opt_w = TRUE;
+        break;
+      case 'z':
+        opt_rmunder = TRUE;
+        break;
       default:
         usage ();
@@ -3417 +3651 @@
     usage ();
 
+  /* Initialize weak symbol list */
+
+  weak_symbol_list = NULL;
+  weak_load ();
+
   if (opt_o != NULL)
     {
-
       /* If the -o option is used, there must be exactly one input
          file name. */
@@ -3449 +3687 @@
     }
 
+  /* If the weak symbol list has been altered, save it */
+
+  if (weak_list_altered)
+    weak_save ();
+
+  /* Free the weak symbol list */
+
+  weak_free ();
+
   /* If a LIB response file has been created, finish and close it. */
 

trunk/src/emx/src/emxomf/emxomfld.c

@@ -28 +28 @@
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <getopt.h>
+#include <emx/getopt.h>
 #include <errno.h>
+#include <sys/utime.h>
 #include <sys/moddef.h>
+#include <alloca.h>
 #include "defs.h"
 
@@ -142 +144 @@
 int main (int argc, char *argv[]);
 
+/* To avoid including os2.h... */
+unsigned DosCopy (char *, char *, unsigned);
+
 
 /* Tell the user how to run this program. */
@@ -461 +466 @@
   const char *ext;
   char tmp[512], *t;
+  static char emxshell [200];
+
+  /* Drop EMXSHELL since it can point to a Unix shell which is bad for us */
+  sprintf (emxshell, "EMXSHELL=%s", getenv ("OS2_SHELL"));
+  putenv (emxshell);
 
   /* Close and delete the response file on exit. */
@@ -675 +685 @@
                         statement is used for a segment of class
                         'CODE').  Not grouping neighboring code
-                        segments would break sets */
+                        segments would break sets
+
+     For ILINK the following option is passed:
+
+     /NOFR[EEFORMAT]    Use /NOFREEFORMAT to allow a LINK386-compatible
+                        command line syntax, in which different types of file
+                        are grouped and separated by commas.
+  */
 
   put_arg (linker_name, TRUE);
+
+  /* If the linker is ILINK, don't use the /BAT{CH} option */
+  t = _getname (linker_name);
+  if (strnicmp (t, "ILINK", 5))
   put_arg ("/bat", FALSE);
+  else
+    put_arg ("/nofree", FALSE);
   put_arg ("/nol", FALSE);
   put_arg ("/noe", FALSE);
@@ -772 +795 @@
 
   rc = system (command_line);
+  /* ILINK returns 4 on warnings: consider this as success */
+  if (rc == 4) rc = 0;
+
   if (rc < 0)
     {
@@ -784 +810 @@
     {
       arg_init (TRUE);
-      put_arg ("rc", TRUE);
+      put_arg ("rc -n", TRUE);
       put_arg (res_fname, TRUE);
       put_arg (output_fname, TRUE);
@@ -802 +828 @@
   if (rc == 0 && exe_flag)
     {
-      int h;
-
-      h = open (output_fname,
-                O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
-      if (h < 0)
+      char execname[512];
+
+      t = xstrdup (output_fname);
+      _remext (t);
+
+      _execname((char *)&execname, sizeof(execname));
+      strcpy(_getname((char *)&execname), "ldstub.bin");
+      /* Copy stub into file */
+      DosCopy((char *)&execname, t, 4);
+      /* Now touch it */
+      if (utime(t, NULL))
         {
           perror ("emxomfld");
           exit (2);
         }
-      close (h);
+      free (t);
     }
 

trunk/src/emx/src/emxomf/stabshll.c

@@ -25 +25 @@
 #include <string.h>
 #include <time.h>
+#include <alloca.h>
 #include "defs.h"
 #include "emxomf.h"
@@ -341 +342 @@
 static int unnamed_struct_number;
 
+/* Suppress several kinds of warnings since newer gccs generates lots of
+   warnings... */
+
+static void no_warning (char *format, ...)
+{
+  (void)format;
+}
+
 
 /* Start a type table record of type TYPE, with type qualifier QUAL.
@@ -912 +921 @@
       /* This should not happen. */
 
-      warning ("stabs type %d not defined", tp->d.stabs_ref);
+      no_warning ("stabs type %d not defined", tp->d.stabs_ref);
       return 4;
 
@@ -934 +943 @@
       if (tp->d.struc.flags & STRUC_FORWARD)
         {
-          warning ("size of incomplete structure %s is unknown",
+          no_warning ("size of incomplete structure %s is unknown",
                    tp->d.struc.name);
           return 0;
@@ -1175 +1184 @@
   if (*parse_ptr != c)
     {
-      warning ("Invalid symbol data: `%c' expected", c);
+      no_warning ("Invalid symbol data: `%c' expected", c);
       return FALSE;
     }
@@ -1224 +1233 @@
     default:
       ++parse_ptr;
-      warning ("Invalid visibility: %c", *parse_ptr);
+      no_warning ("Invalid visibility: %c", *parse_ptr);
       if (*parse_ptr != 0)
         ++parse_ptr;
@@ -1361 +1370 @@
       else
         {
-          warning ("Unknown range type: %lld..%lld", range_lo, range_hi);
+          no_warning ("Unknown range type: %lld..%lld", range_lo, range_hi);
           goto syntax;
         }
@@ -1618 +1627 @@
                   if (*parse_ptr != ':')
                     {
-                      warning ("Arguments for member function missing");
+                      no_warning ("Arguments for member function missing");
                       goto syntax;
                     }
@@ -1643 +1652 @@
                       break;
                     default:
-                      warning ("Unknown member function qualifier: %c",
+                      no_warning ("Unknown member function qualifier: %c",
                                *parse_ptr);
                       if (*parse_ptr != 0)
@@ -1673 +1682 @@
                       break;
                     default:
-                      warning ("Unknown member function qualifier: %c",
+                      no_warning ("Unknown member function qualifier: %c",
                                *parse_ptr);
                       if (*parse_ptr != 0)
@@ -1979 +1988 @@
 
     default:
-      warning ("Unknown type: %c", *parse_ptr);
+      no_warning ("Unknown type: %c", *parse_ptr);
       goto syntax;
     }
@@ -2008 +2017 @@
   tp = parse_type (type_name);
   if (*parse_ptr != 0)
-    warning ("unexpected character at end of stabs type: %c", *parse_ptr);
+    no_warning ("unexpected character at end of stabs type: %c", *parse_ptr);
   return tp;
 }
@@ -2032 +2041 @@
   if (tp->index == -2)
     {
-      warning ("Cycle detected by make_type");
+      no_warning ("Cycle detected by make_type");
       RETURN (0);
     }
@@ -2044 +2053 @@
       if (t1 == NULL)
         {
-          warning ("Undefined stabs type %d referenced", tp->d.stabs_ref);
+          no_warning ("Undefined stabs type %d referenced", tp->d.stabs_ref);
           RETURN (0x82);        /* 32 bit signed */
         }
@@ -2724 +2733 @@
           if (sym2 == NULL)
             {
-              warning ("Cannot find address of global variable %s", name);
+              no_warning ("Cannot find address of global variable %s", name);
               return;
             }