Changeset 1544

Timestamp:

Oct 7, 2004, 8:36:35 AM (21 years ago)

Author:

bird

Message:

Implemented lazyimp for a.out.

File:

• trunk/src/emx/src/emximp/emximp.c (modified) (13 diffs, 1 prop)

trunk/src/emx/src/emximp/emximp.c

@@ -88 +88 @@
 static int opt_q;
 static int opt_s;
+static int opt_lazy;
 static enum modes mode = M_NONE;
 static long mod_lbl;
@@ -129 +130 @@
   puts ("  -q   Be quiet");
   puts ("  -m   Call _mcount for profiling");
+  puts ("  -l   Lazy loading and resolving");
   exit (1);
 }
@@ -181 +183 @@
 
 
-#if 0 /* not used */
 static void *xrealloc (void *p, size_t n)
 {
@@ -191 +192 @@
   return q;
 }
-#endif
 
 
@@ -615 +615 @@
 static struct nlist aout_sym_tab[6];
 
-static byte aout_text[64];
+static byte aout_text[300];
 static int aout_text_size;
 
-static struct relocation_info aout_treloc_tab[2];
+static byte aout_data[300];
+static int aout_data_size;
+
+static struct relocation_info aout_treloc_tab[7];
 static int aout_treloc_count;
+
+static struct relocation_info aout_dreloc_tab[7];
+static int aout_dreloc_count;
 
 static int aout_size;
@@ -629 +635 @@
   aout_sym_count = 0;
   aout_text_size = 0;
+  aout_data_size = 0;
   aout_treloc_count = 0;
+  aout_dreloc_count = 0;
 }
 
@@ -684 +692 @@
 }
 
+static void aout_data_byte (byte b)
+{
+  if (aout_data_size >= sizeof (aout_data))
+    error ("a.out data segment overflow");
+  aout_data[aout_data_size++] = b;
+}
+
+static void aout_data_dword (dword d)
+{
+  aout_data_byte ((d >> 0) & 0xff);
+  aout_data_byte ((d >> 8) & 0xff);
+  aout_data_byte ((d >> 16) & 0xff);
+  aout_data_byte ((d >> 24) & 0xff);
+}
+
+static void aout_dreloc (dword address, int symbolnum, int pcrel, int length,
+                         int ext)
+{
+  if (aout_dreloc_count >= sizeof (aout_dreloc_tab) / sizeof (struct relocation_info))
+    error ("a.out data relocation buffer overflow");
+  aout_dreloc_tab[aout_dreloc_count].r_address = address;
+  aout_dreloc_tab[aout_dreloc_count].r_symbolnum = symbolnum;
+  aout_dreloc_tab[aout_dreloc_count].r_pcrel = pcrel;
+  aout_dreloc_tab[aout_dreloc_count].r_length = length;
+  aout_dreloc_tab[aout_dreloc_count].r_extern = ext;
+  aout_dreloc_tab[aout_dreloc_count].r_pad = 0;
+  ++aout_dreloc_count;
+}
 
 static void aout_finish (void)
@@ -689 +725 @@
   while (aout_text_size & 3)
     aout_text_byte (0x90);
-  aout_size = (sizeof (struct exec) + aout_text_size
+  while (aout_data_size & 3)
+    aout_data_byte (0);
+  aout_size = (sizeof (struct exec) + aout_text_size + aout_data_size
                + aout_treloc_count * sizeof (struct relocation_info)
+               + aout_dreloc_count * sizeof (struct relocation_info)
                + aout_sym_count * sizeof (aout_sym_tab[0])
                + aout_str_size);
@@ -704 +743 @@
   N_SET_FLAGS (ao, 0);
   ao.a_text = aout_text_size;
-  ao.a_data = 0;
+  ao.a_data = aout_data_size;
   ao.a_bss = 0;
   ao.a_syms = aout_sym_count * sizeof (aout_sym_tab[0]);
   ao.a_entry = 0;
   ao.a_trsize = aout_treloc_count * sizeof (struct relocation_info);
-  ao.a_drsize = 0;
+  ao.a_drsize = aout_dreloc_count * sizeof (struct relocation_info);;
   fwrite (&ao, 1, sizeof (ao), out_file);
-  fwrite (aout_text, 1, aout_text_size, out_file);
+  fwrite (aout_text, aout_text_size, 1, out_file);
+  fwrite (aout_data, aout_data_size, 1, out_file);
   fwrite (aout_treloc_tab, aout_treloc_count, sizeof (struct relocation_info), out_file);
+  fwrite (aout_dreloc_tab, aout_dreloc_count, sizeof (struct relocation_info), out_file);
   fwrite (aout_sym_tab, aout_sym_count, sizeof (aout_sym_tab[0]), out_file);
   *(dword *)aout_str_tab = aout_str_size;
@@ -719 +760 @@
 
 
+static void write_a_lazyldr (const char *resolver_sym, const char *mod_name)
+{
+    char  tmp[257];
+    dword *ptr_hmod_fixup, *ptr_name_fixup;
+    const char *p;
+    static char *done = NULL;
+    if (done)
+      {
+        if (strstr (done, resolver_sym))
+          return;
+        done = xrealloc (done, strlen (resolver_sym) + 1);
+        strcat (done, resolver_sym);
+      }
+    else
+      done = xstrdup (resolver_sym);
+
+    /* Write module resolver object
+        .text
+        .globl ___lazyimp_doscalls_resolver
+    ___lazyimp_doscalls_resolver:
+        push    name
+        push    hmod
+        jmp     ___lazyimp_resolver
+    name:
+        .asciiz "DOSCALLS"
+        .byte 0
+
+        .data
+    hmod:
+        .long   0
+    */
+    aout_init ();
+    aout_sym (resolver_sym, N_TEXT|N_EXT, 0, 0, aout_text_size); /* .globl DosRead */
+    aout_text_byte (0x68);              /* push name */
+    aout_treloc (aout_text_size, N_TEXT, 0, 2, 0);
+    ptr_name_fixup = (dword *)&aout_text[aout_text_size];
+    aout_text_dword (0);
+
+    aout_text_byte (0x68);              /* push pfn */
+    aout_treloc (aout_text_size, N_DATA, 0, 2, 0);
+    ptr_hmod_fixup = (dword *)&aout_text[aout_text_size];
+    aout_text_dword (0);
+
+    aout_text_byte (0xe9);            /* jmp ___lazyimp_resolver */
+    aout_treloc (aout_text_size, aout_sym ("___lazyimp_resolver", N_EXT, 0, 0, 0), 1, 2, 1);
+    aout_text_dword (0 - (aout_text_size + 4));
+
+    *ptr_name_fixup = aout_text_size;   /* name: .ascii */
+    strcpy (tmp, mod_name);
+    strupr (tmp);
+    for (p = tmp; *p; p++)
+      aout_text_byte(*p);
+    aout_text_byte(0);
+
+    while (aout_text_size & 3)
+        aout_text_byte (0xcc);
+
+    *ptr_hmod_fixup = aout_text_size;   /* hmod: .long 0 */
+    aout_data_dword (0);
+
+
+    aout_finish ();
+    sprintf (tmp, "LAZYMOD#%ld", seq_no);
+    write_ar (tmp, aout_size);
+    aout_write ();
+    finish_ar ();
+    seq_no++;
+    if (ferror (out_file))
+      write_error (out_fname);
+}
+
+
 static void write_a_import (const char *func_name, const char *mod_name,
                             int ordinal, const char *proc_name)
@@ -726 +839 @@
   dword fixup_mcount, fixup_import;
 
-  aout_init ();
   /* #425: Underscore is gone. (was "_%s") */
   sprintf (tmp2, "%s", func_name);
-  if (profile_flag && strncmp (func_name, "_16_", 4) != 0)
-    {
-      sym_entry = aout_sym (tmp2, N_TEXT|N_EXT, 0, 0, aout_text_size);
-      sym_mcount = aout_sym ("__mcount", N_EXT, 0, 0, 0);
-
-      /* Use, say, "_$U_DosRead" for "DosRead" to import the
-         non-profiled function. */
-      sprintf (tmp2, "__$U_%s", func_name);
-      sym_import = aout_sym (tmp2, N_EXT, 0, 0, 0);
-
-      aout_text_byte (0x55);    /* push ebp */
-      aout_text_byte (0x89);    /* mov ebp, esp */
-      aout_text_byte (0xe5);
-      aout_text_byte (0xe8);    /* call _mcount*/
-      fixup_mcount = aout_text_size;
+  /*
+   * Lazily resolved dynamic import.
+   */
+  if (opt_lazy && strncmp (func_name, "_16_", 4) != 0)
+    {
+      int   off_name, off_resolver;
+      dword *fixup_ptr1, *fixup_ptr2;
+      char *p;
+
+      /* create module resolver object first. */
+      sprintf (tmp1, "___lazyldr_%s_resolver", mod_name);
+      write_a_lazyldr (tmp1, mod_name);
+
+      /* Write import object
+          .data
+      pfn:
+          .long   resolve
+          .text
+          .globl DosRead
+      DosRead:
+          jmp     *(pfn)
+      name:
+          .asciiz "DosRead"
+          .byte 0
+      resolve:
+          push    name
+          push    pfn
+          jmp     ___lazyimp_doscalls_resolver
+      */
+      aout_init ();
+      aout_sym (tmp2, N_TEXT|N_EXT, 0, 0, aout_text_size); /* .globl DosRead */
+      strlwr (tmp1);
+      aout_text_byte (0xff);            /* jmp *(pfn) */
+      aout_text_byte (0x25);
+      aout_treloc (aout_text_size, N_DATA, 0, 2, 0);
+      fixup_ptr1 = (dword *)&aout_text[aout_text_size];
+      aout_text_dword (aout_data_size);
+
+      if (proc_name)
+        {
+          off_name = aout_text_size;        /* name: .ascii */
+          for (p = tmp2; *p; p++)
+            aout_text_byte(*p);
+          aout_text_byte(0);
+          aout_text_byte (0xcc);
+        }
+
+      off_resolver = aout_text_size;    /* resolve: push name / ordinal */
+      aout_text_byte (0x68);
+      if (proc_name)
+        {
+          aout_treloc (aout_text_size, N_TEXT, 0, 2, 0);
+          aout_text_dword (off_name);
+        }
+      else
+        aout_text_dword (ordinal);
+
+      aout_text_byte (0x68);            /* resolve: push pfn */
+      aout_treloc (aout_text_size, N_DATA, 0, 2, 0);
+      fixup_ptr2 = (dword *)&aout_text[aout_text_size];
+      aout_text_dword (0);
+
+      aout_text_byte (0xe9);            /* jmp ___lazyimp_????_resolver */
+      aout_treloc (aout_text_size, aout_sym (tmp1, N_EXT, 0, 0, 0), 1, 2, 1);
       aout_text_dword (0 - (aout_text_size + 4));
-      aout_text_byte (0x5d);    /* pop ebp */
-      aout_text_byte (0xe9);    /* jmp _$U_DosRead*/
-      fixup_import = aout_text_size;
-      aout_text_dword (0 - (aout_text_size + 4));
-
-      aout_treloc (fixup_mcount, sym_mcount, 1, 2, 1);
-      aout_treloc (fixup_import, sym_import, 1, 2, 1);
-    }
-  sprintf (tmp1, "IMPORT#%ld", seq_no);
-  if (proc_name == NULL)
-    sprintf (tmp3, "%s=%s.%d", tmp2, mod_name, ordinal);
+      while (aout_text_size & 3)
+          aout_text_byte (0xcc);
+
+      *fixup_ptr1 = aout_text_size;
+      *fixup_ptr2 = aout_text_size;
+      aout_dreloc (aout_data_size, N_TEXT, 0, 2, 0); /* pfn: .long resolve */
+      aout_data_dword (off_resolver);
+      sprintf (tmp1, "LAZYIMP#%ld", seq_no);
+    }
+  /*
+   * Static load time import.
+   */
   else
-    sprintf (tmp3, "%s=%s.%s", tmp2, mod_name, proc_name);
-  aout_sym (tmp2, N_IMP1|N_EXT, 0, 0, 0);
-  aout_sym (tmp3, N_IMP2|N_EXT, 0, 0, 0);
+    {
+      aout_init ();
+      if (profile_flag && strncmp (func_name, "_16_", 4) != 0)
+        {
+          sym_entry = aout_sym (tmp2, N_TEXT|N_EXT, 0, 0, aout_text_size);
+          sym_mcount = aout_sym ("__mcount", N_EXT, 0, 0, 0);
+
+          /* Use, say, "_$U_DosRead" for "DosRead" to import the
+             non-profiled function. */
+          sprintf (tmp2, "__$U_%s", func_name);
+          sym_import = aout_sym (tmp2, N_EXT, 0, 0, 0);
+
+          aout_text_byte (0x55);    /* push ebp */
+          aout_text_byte (0x89);    /* mov ebp, esp */
+          aout_text_byte (0xe5);
+          aout_text_byte (0xe8);    /* call _mcount*/
+          fixup_mcount = aout_text_size;
+          aout_text_dword (0 - (aout_text_size + 4));
+          aout_text_byte (0x5d);    /* pop ebp */
+          aout_text_byte (0xe9);    /* jmp _$U_DosRead*/
+          fixup_import = aout_text_size;
+          aout_text_dword (0 - (aout_text_size + 4));
+
+          aout_treloc (fixup_mcount, sym_mcount, 1, 2, 1);
+          aout_treloc (fixup_import, sym_import, 1, 2, 1);
+        }
+      if (proc_name == NULL)
+        sprintf (tmp3, "%s=%s.%d", tmp2, mod_name, ordinal);
+      else
+        sprintf (tmp3, "%s=%s.%s", tmp2, mod_name, proc_name);
+      aout_sym (tmp2, N_IMP1|N_EXT, 0, 0, 0);
+      aout_sym (tmp3, N_IMP2|N_EXT, 0, 0, 0);
+      sprintf (tmp1, "IMPORT#%ld", seq_no);
+    }
+
   aout_finish ();
   write_ar (tmp1, aout_size);
@@ -1276 +1470 @@
   opterr = 0;
   optind = 1;
-  while ((c = getopt (argc, argv, "a::b:mo:p:qsP:")) != EOF)
+  while ((c = getopt (argc, argv, "a::b:lmo:p:qsP:")) != EOF)
     {
       switch (c)
@@ -1294 +1488 @@
               base_len = 0;
             }
+          break;
+        case 'l':
+          opt_lazy = TRUE;
           break;
         case 'm':