sdcc/sdas/linksrc/lkar.c

   1 /* lkar.c - ar library format handling
   2
   3    Copyright (C) 1989-1995 Alan R. Baldwin
   4    721 Berkeley St., Kent, Ohio 44240
   5    Copyright (C) 2008-2009 Borut Razem, borut dot razem at gmail dot com
   6
   7 This program is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by the
   9 Free Software Foundation; either version 3, or (at your option) any
  10 later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  19
  20 /*
  21  * With contributions for the
  22  * object libraries from
  23  * Ken Hornstein
  24  * kenh@cmf.nrl.navy.mil
  25  *
  26  */
  27
  28 /*
  29  * Extensions: P. Felber
  30  */
  31
  32 #include <assert.h>
  33
  34 #include "aslink.h"
  35 #include "lklibr.h"
  36 #include "lkrel.h"
  37 #include "lkar.h"
  38
  39
  40 #ifndef max
  41 # define max(a,b) ((a) > (b) ? (a) : (b))
  42 #endif
  43
  44 #ifndef min
  45 # define min(a,b) ((a) < (b) ? (a) : (b))
  46 #endif
  47
  48
  49 #ifndef HAVE_STRNDUP
  50 char *
  51 strndup (const char *str, size_t len)
  52 {
  53   char *s = (char *) malloc (len + 1);
  54   memcpy (s, str, len);
  55   s[len] = '\0';
  56   return s;
  57 }
  58 #endif
  59
  60 static int
  61 is_ar (FILE * libfp)
  62 {
  63   char buf[SARMAG];
  64   int ret;
  65
  66   if (!(ret = fread (buf, 1, sizeof (buf), libfp) == sizeof (buf) && memcmp (buf, ARMAG, SARMAG) == 0))
  67     rewind (libfp);
  68
  69   return ret;
  70 }
  71
  72 static char *str_tab;     /* string table */
  73 static int str_tab_size;  /* string table size */
  74
  75 static char *
  76 get_long_name (const char *name)
  77 {
  78   assert ('/' == name[0]);
  79
  80   if (NULL != str_tab)
  81     {
  82       char *p;
  83
  84       int name_offset = strtol (++name, &p, 0);
  85       if (p != name && name_offset < str_tab_size)
  86         {
  87           int len = p - name + 1;
  88           while (len < AR_NAME_LEN && name[len++] == ' ')
  89             ;
  90           if (len == AR_NAME_LEN)
  91             {
  92               const char *n;
  93
  94               /* long name: get it from the symbol table */
  95               name = &str_tab[name_offset];
  96               for (n = name; *n != '/' && *n != '\n'; ++n)
  97                 assert (n < &str_tab[str_tab_size]);
  98
  99               if (n[0] != '/' || n[1] != '\n')
 100                 while (*++n != '\n')
 101                   assert (n < &str_tab[str_tab_size]);
 102
 103               return strndup (name, n - name);
 104             }
 105         }
 106     }
 107   return NULL;
 108 }
 109
 110 static char *
 111 get_member_name (char *name, size_t *p_size, int allocate, FILE * libfp)
 112 {
 113   if (p_size != NULL)
 114     *p_size = 0;
 115
 116   if (0 == memcmp (name, "#1/", 3))
 117     {
 118       char *p;
 119       size_t len = strtoul (&name [3], &p, 10);
 120       if (p > &name [3])
 121         {
 122           /* BSD appends real file name to the file header */
 123           if (p_size != NULL)
 124             *p_size = len;
 125
 126           if (allocate)
 127             {
 128               char *n = (char *) malloc (len);
 129               if (fread (n, 1, len, libfp) != len)
 130                 {
 131                   /* not an ar archive or broken ar archive */
 132                   free (n);
 133                   return NULL;
 134                 }
 135               else
 136                 return n;
 137             }
 138           else
 139             {
 140               /* just advance the file pointer */
 141               fseek (libfp, len, SEEK_CUR);
 142               return NULL;
 143             }
 144         }
 145       else
 146         {
 147           /* not an ar archive or broken ar archive */
 148           return NULL;
 149         }
 150     }
 151   else if (allocate)
 152     {
 153       if (name[0] == '/')
 154         {
 155           char *n = get_long_name (name);
 156           if (NULL != n)
 157             return n;
 158         }
 159       else
 160         {
 161           const char *p = strrchr (name + 1, '/');
 162
 163           if (NULL != p)
 164             {
 165               int len = p - name;
 166               while (name[++len] == ' ')
 167                 ;
 168               if (len == AR_NAME_LEN)
 169                 return strndup (name, p - name);
 170             }
 171           else
 172             {
 173               /* BSD formed member name:
 174                  trim trailing spaces */
 175               p = name + AR_NAME_LEN;
 176               while (*--p == ' ' && p >= name)
 177                 ;
 178               return strndup (name, p - name + 1);
 179             }
 180         }
 181
 182       /* bad formed member name or long name not found:
 183        just return it */
 184
 185       return strdup (name);
 186     }
 187   else
 188     return NULL;
 189 }
 190
 191 static size_t
 192 ar_get_header (struct ar_hdr *hdr, FILE * libfp, char **p_obj_name)
 193 {
 194   char header[ARHDR_LEN];
 195   char buf[AR_DATE_LEN + 1];
 196   char *obj_name;
 197   size_t size;
 198
 199   if (fread (header, 1, sizeof (header), libfp) != sizeof (header)
 200       || memcmp (header + AR_FMAG_OFFSET, ARFMAG, AR_FMAG_LEN) != 0)
 201     {
 202       /* not an ar archive */
 203       return 0;
 204     }
 205
 206   memcpy (hdr->ar_name, &header[AR_NAME_OFFSET], AR_NAME_LEN);
 207   hdr->ar_name[AR_NAME_LEN] = '\0';
 208
 209   memcpy (buf, &header[AR_DATE_OFFSET], AR_DATE_LEN);
 210   buf[AR_DATE_LEN] = '\0';
 211   hdr->ar_date = strtol (buf, NULL, 0);
 212
 213   memcpy (buf, &header[AR_UID_OFFSET], AR_GID_LEN);
 214   buf[AR_GID_LEN] = '\0';
 215   hdr->ar_uid = (uid_t) strtol (buf, NULL, 0);
 216
 217   memcpy (buf, &header[AR_GID_OFFSET], AR_DATE_LEN);
 218   buf[AR_DATE_LEN] = '\0';
 219   hdr->ar_gid = (gid_t) strtol (buf, NULL, 0);
 220
 221   memcpy (buf, &header[AR_MODE_OFFSET], AR_MODE_LEN);
 222   buf[AR_MODE_LEN] = '\0';
 223   hdr->ar_mode = (mode_t) strtoul (buf, NULL, 0);
 224
 225   memcpy (buf, &header[AR_SIZE_OFFSET], AR_SIZE_LEN);
 226   buf[AR_SIZE_LEN] = '\0';
 227   hdr->ar_size = strtol (buf, NULL, 0);
 228
 229   obj_name = get_member_name (hdr->ar_name, &size, p_obj_name != NULL, libfp);
 230
 231   if (p_obj_name != NULL)
 232     *p_obj_name = obj_name;
 233
 234   /* treat BSD appended real file name as a part of the header */
 235   hdr->ar_size -= size;
 236
 237   return size + ARHDR_LEN;
 238 }
 239
 240 #ifdef INDEXLIB
 241 static char *
 242 get_member_name_by_offset (FILE * fp, long offset)
 243 {
 244   struct ar_hdr hdr;
 245   char *name;
 246
 247   fseek (fp, offset, SEEK_SET);
 248   return (ar_get_header (&hdr, fp, &name) != 0) ? name : NULL;
 249 }
 250
 251 static pmlibraryfile
 252 find_member_by_offset (const char *libspc, long offset)
 253 {
 254   pmlibraryfile p;
 255
 256   /* walk trough all archive members */
 257   for (p = libr; p; p = p->next)
 258     {
 259       if (0 == strcmp (libspc, p->libspc) && p->offset == offset)
 260         return p;
 261     }
 262
 263   return NULL;
 264 }
 265
 266 static pmlibraryfile
 267 buildlibraryindex_ar (struct lbname *lbnh, FILE * libfp, pmlibraryfile This, int type)
 268 {
 269   struct ar_hdr hdr;
 270   char *obj_name;
 271   size_t hdr_size;
 272   int sym_found = 0;
 273
 274   /* walk trough all archive members */
 275   while ((hdr_size = ar_get_header (&hdr, libfp, &obj_name)) != 0)
 276     {
 277       long pos = ftell (libfp);
 278
 279       if (AR_IS_SYMBOL_TABLE (obj_name))
 280         {
 281           char *buf, *po, *ps;
 282           int i;
 283           long nsym;
 284
 285           /* duplicated symbol table */
 286           assert (!sym_found);
 287
 288           free (obj_name);
 289
 290           buf = (char *) new (hdr.ar_size);
 291
 292           if (fread (buf, 1, hdr.ar_size, libfp) != hdr.ar_size)
 293             {
 294               free (buf);
 295               return This;
 296             }
 297
 298           nsym = sgetl (buf);
 299
 300           po = buf + 4;
 301           ps = po + nsym * 4;
 302
 303           for (i = 0; i < nsym; ++i)
 304             {
 305               pmlibrarysymbol ThisSym;
 306               char *sym;
 307               long offset;
 308               pmlibraryfile entry;
 309
 310               offset = sgetl (po);
 311               po += 4;
 312
 313               sym = strdup (ps);
 314               ps += strlen (ps) + 1;
 315
 316               if ((entry = find_member_by_offset (lbnh->libspc, offset)) != NULL)
 317                 {
 318                   for (ThisSym = entry->symbols; ThisSym->next != NULL; ThisSym = ThisSym->next)
 319                     ;
 320                 }
 321               else
 322                 {
 323                   /* Opened OK - create a new libraryfile object for it */
 324                   if (This == NULL)
 325                     {
 326                       assert (libr == NULL);
 327                       libr = This = (pmlibraryfile) new (sizeof (mlibraryfile));
 328                     }
 329                   else
 330                     {
 331                       This->next = (pmlibraryfile) new (sizeof (mlibraryfile));
 332                       This = This->next;
 333                     }
 334                   This->next = NULL;
 335                   This->loaded = 0;
 336                   This->libspc = lbnh->libspc;
 337                   This->offset = offset;
 338                   This->relfil = get_member_name_by_offset (libfp, offset);     /* member name */
 339                   This->filspc = strdup (This->relfil); /* member file name */
 340                   This->type = type;
 341
 342                   /* start a new linked list of symbols for this module. */
 343                   This->symbols = ThisSym = NULL;
 344                 }
 345
 346               if (ThisSym == NULL)
 347                 ThisSym = This->symbols = (pmlibrarysymbol) new (sizeof (mlibrarysymbol));
 348               else
 349                 {
 350                   ThisSym->next = (pmlibrarysymbol) new (sizeof (mlibrarysymbol));
 351                   ThisSym = ThisSym->next;
 352                 }
 353               ThisSym->next = NULL;
 354               ThisSym->name = sym;
 355             }
 356           free (buf);
 357
 358           sym_found = 1;
 359
 360           /* string table already found: finish */
 361           if (str_tab)
 362             break;
 363         }
 364       else if (AR_IS_BSD_SYMBOL_TABLE (obj_name))
 365         {
 366           char *buf, *po, *ps;
 367           int i;
 368           long nsym, tablesize;
 369
 370           /* duplicated symbol table */
 371           assert (!sym_found);
 372
 373           free (obj_name);
 374
 375           buf = (char *) new (hdr.ar_size);
 376
 377           if (fread (buf, 1, hdr.ar_size, libfp) != hdr.ar_size)
 378             {
 379               free (buf);
 380               return This;
 381             }
 382
 383           tablesize = sgetl (buf);
 384           nsym = tablesize / 8;
 385
 386           po = buf + 4;
 387
 388           ps = po + tablesize + 4;
 389
 390           for (i = 0; i < nsym; ++i)
 391             {
 392               pmlibrarysymbol ThisSym;
 393               char *sym;
 394               long offset;
 395               pmlibraryfile entry;
 396
 397               sym = ps + sgetl (po);
 398               po += 4;
 399               offset = sgetl (po);
 400               po += 4;
 401
 402               sym = strdup (ps);
 403
 404               if ((entry = find_member_by_offset (lbnh->libspc, offset)) != NULL)
 405                 {
 406                   for (ThisSym = entry->symbols; ThisSym->next != NULL; ThisSym = ThisSym->next)
 407                     ;
 408                 }
 409               else
 410                 {
 411                   /* Opened OK - create a new libraryfile object for it */
 412                   if (This == NULL)
 413                     {
 414                       assert (libr == NULL);
 415                       libr = This = (pmlibraryfile) new (sizeof (mlibraryfile));
 416                     }
 417                   else
 418                     {
 419                       This->next = (pmlibraryfile) new (sizeof (mlibraryfile));
 420                       This = This->next;
 421                     }
 422                   This->next = NULL;
 423                   This->loaded = 0;
 424                   This->libspc = lbnh->libspc;
 425                   This->offset = offset;
 426                   This->relfil = get_member_name_by_offset (libfp, offset);     /* member name */
 427                   This->filspc = strdup (This->relfil); /* member file name */
 428                   This->type = type;
 429
 430                   /* start a new linked list of symbols for this module. */
 431                   This->symbols = ThisSym = NULL;
 432                 }
 433
 434               if (ThisSym == NULL)
 435                 ThisSym = This->symbols = (pmlibrarysymbol) new (sizeof (mlibrarysymbol));
 436               else
 437                 {
 438                   ThisSym->next = (pmlibrarysymbol) new (sizeof (mlibrarysymbol));
 439                   ThisSym = ThisSym->next;
 440                 }
 441               ThisSym->next = NULL;
 442               ThisSym->name = sym;
 443             }
 444           free (buf);
 445
 446           sym_found = 1;
 447
 448           /* string table already found: finish */
 449           if (str_tab)
 450             break;
 451         }
 452       else if (AR_IS_STRING_TABLE (obj_name))
 453         {
 454           free (obj_name);
 455
 456           /* duplicated string table */
 457           assert (NULL == str_tab);
 458
 459           str_tab = (char *) new (hdr.ar_size);
 460
 461           if (fread (str_tab, 1, hdr.ar_size, libfp) != hdr.ar_size)
 462             {
 463               free (str_tab);
 464               str_tab_size = 0;
 465               return This;
 466             }
 467           str_tab_size = hdr.ar_size;
 468
 469           /* sybol table already found: finish */
 470           if (sym_found)
 471             break;
 472         }
 473       else
 474         {
 475           if (NULL == libr)
 476             {
 477               /* Opened OK - create a new libraryfile object for it */
 478               if (This == NULL)
 479                 {
 480                   assert (libr == NULL);
 481                   libr = This = (pmlibraryfile) new (sizeof (mlibraryfile));
 482                 }
 483               else
 484                 {
 485                   This->next = (pmlibraryfile) new (sizeof (mlibraryfile));
 486                   This = This->next;
 487                 }
 488               This->next = NULL;
 489               This->loaded = -1;
 490               This->libspc = lbnh->libspc;
 491               This->offset = pos - hdr_size;
 492
 493               This->relfil = obj_name;              /* member name */
 494               This->filspc = strdup (This->relfil); /* member file name */
 495
 496               D ("  Indexing module: %s\n", This->relfil);
 497
 498               This->type = type;
 499
 500               /* start a new linked list of symbols for this module. */
 501               This->symbols = NULL;
 502
 503               add_rel_index (libfp, hdr.ar_size, This);
 504             }
 505         }
 506       fseek (libfp, pos + hdr.ar_size + (hdr.ar_size & 1), SEEK_SET);
 507     }
 508
 509   if (NULL != str_tab)
 510     {
 511       /* has a symbol table: walk through modules and replace offsets with names */
 512       pmlibraryfile lfp;
 513
 514       for (lfp = libr; lfp; lfp = lfp->next)
 515         {
 516           char *name = lfp->relfil;
 517           if (name[0] == '/')
 518             {
 519               char *p = get_long_name (name);
 520               if (NULL != p)
 521                 {
 522                   free (lfp->relfil);
 523                   lfp->relfil = p;
 524                   free (lfp->filspc);
 525                   lfp->filspc = strdup (p);
 526                 }
 527             }
 528         }
 529
 530
 531       free (str_tab);
 532       str_tab = NULL;
 533       str_tab_size = 0;
 534     }
 535
 536   return This;
 537 }
 538
 539 #else
 540
 541 #if 0
 542 static int
 543 load_adb (FILE * libfp, struct lbfile *lbfh)
 544 {
 545   struct ar_hdr hdr;
 546   char *adb_name;
 547   char *obj_name;
 548   size_t hdr_size;
 549
 550   /* check if it is a .rel file */
 551   if (0 != stricmp (&lbfh->relfil[strlen (lbfh->relfil) - 4], ".rel"))
 552     return 0;
 553
 554
 555   adb_name = (char *) new (strlen (lbfh->relfil) + 1);
 556   memcpy (adb_name, lbfh->relfil, strlen (lbfh->relfil) - 4);
 557   memcpy (&adb_name[strlen (lbfh->relfil) - 4], ".adb", 5);
 558
 559   if (!is_ar (libfp))
 560     {
 561       fprintf (stderr, "?ASlink-Error-%s is not an archive\n", lbfh->libspc);
 562       fclose (libfp);
 563       lkexit (1);
 564     }
 565
 566   /* walk trough all archive members */
 567   while ((hdr_size = ar_get_header (&hdr, libfp, &obj_name)) != 0)
 568     {
 569       if (AR_IS_STRING_TABLE (obj_name))
 570         {
 571           free (obj_name);
 572
 573           if (str_tab)
 574             free (str_tab);
 575
 576           str_tab = (char *) new (hdr.ar_size);
 577
 578           if ((off_t) fread (str_tab, 1, hdr.ar_size, libfp) != hdr.ar_size)
 579             {
 580               free (str_tab);
 581               str_tab_size = 0;
 582               return 0;
 583             }
 584           str_tab_size = hdr.ar_size;
 585         }
 586       if (AR_IS_SYMBOL_TABLE (obj_name) || 0 != stricmp (obj_name, adb_name))
 587         {
 588           free (obj_name);
 589
 590           /* skip the mamber */
 591           fseek (libfp, hdr.ar_size + (hdr.ar_size & 1), SEEK_CUR);
 592         }
 593       else
 594         {
 595           long left = hdr.ar_size;
 596           char buf[4096];
 597
 598           free (obj_name);
 599
 600           while (left)
 601             {
 602               size_t n = min (left, sizeof buf);
 603
 604               if (fread (buf, 1, n, libfp) != n)
 605                 {
 606                   assert (0);
 607                 }
 608
 609               fwrite (buf, 1, n, yfp);
 610
 611               left -= n;
 612             }
 613
 614           if (hdr.ar_size & 1)
 615             getc (libfp);
 616
 617           free (adb_name);
 618           return 1;
 619         }
 620     }
 621
 622   free (adb_name);
 623   return 0;
 624 }
 625 #endif
 626
 627 static void
 628 load_str_tab (FILE * libfp)
 629 {
 630   struct ar_hdr hdr;
 631   char *obj_name;
 632   size_t hdr_size;
 633
 634   /* walk trough all archive members */
 635   while ((hdr_size = ar_get_header (&hdr, libfp, &obj_name)) != 0)
 636     {
 637       long pos = ftell (libfp);
 638
 639       if (AR_IS_STRING_TABLE (obj_name))
 640         {
 641           free (obj_name);
 642
 643           /* duplicated string table */
 644           assert (NULL == str_tab);
 645
 646           str_tab = (char *) new (hdr.ar_size);
 647
 648           if (fread (str_tab, 1, hdr.ar_size, libfp) != hdr.ar_size)
 649             {
 650               free (str_tab);
 651               str_tab_size = 0;
 652               return;
 653             }
 654           str_tab_size = hdr.ar_size;
 655           return;
 656
 657         }
 658       fseek (libfp, pos + hdr.ar_size + (hdr.ar_size & 1), SEEK_SET);
 659     }
 660 }
 661
 662 static int
 663 fndsym_ar (const char *name, struct lbname *lbnh, FILE * libfp, int type)
 664 {
 665   struct ar_hdr hdr;
 666   int ret = 0;
 667   size_t hdr_size;
 668   char *obj_name;
 669   long pos;
 670
 671   pos = ftell (libfp);
 672   load_str_tab (libfp);
 673   fseek (libfp, pos, SEEK_SET);
 674
 675   /* walk trough all archive members */
 676   while ((hdr_size = ar_get_header (&hdr, libfp, &obj_name)) != 0)
 677     {
 678       char filspc[PATH_MAX] = { 0 };
 679
 680       if (lbnh->path != NULL)
 681         {
 682           strcpy (filspc, lbnh->path);
 683           if (*filspc != '\0' && (filspc[strlen (filspc) - 1] != '/') && (filspc[strlen (filspc) - 1] != LKDIRSEP))
 684             {
 685               strcat (filspc, LKDIRSEPSTR);
 686             }
 687         }
 688
 689       if (AR_IS_SYMBOL_TABLE (obj_name))
 690         {
 691           char *buf, *po, *ps;
 692           int i;
 693           long nsym;
 694
 695           free (obj_name);
 696
 697           buf = (char *) new (hdr.ar_size);
 698
 699           if (fread (buf, 1, hdr.ar_size, libfp) != hdr.ar_size)
 700             {
 701               free (buf);
 702               return 0;
 703             }
 704
 705           nsym = sgetl (buf);
 706
 707           po = buf + 4;
 708           ps = po + nsym * 4;
 709
 710           for (i = 0; i < nsym; ++i)
 711             {
 712               char *sym;
 713               long offset;
 714
 715               offset = sgetl (po);
 716               po += 4;
 717
 718               sym = ps;
 719               while (*ps++ != '\0')
 720                 ;
 721
 722               if (0 == strcmp (name, sym))
 723                 {
 724                   fseek (libfp, offset, SEEK_SET);
 725                   if (ar_get_header (&hdr, libfp, &obj_name))
 726                     {
 727                       sprintf (&filspc[strlen (filspc)], "%s", hdr.ar_name);
 728
 729                       /* If this module has been loaded already don't load it again. */
 730                       if (!is_module_loaded (filspc))
 731                         {
 732                           struct lbfile *lbfh, *lbf;
 733
 734                           lbfh = (struct lbfile *) new (sizeof (struct lbfile));
 735                           lbfh->libspc = strdup (lbnh->libspc);
 736                           lbfh->relfil = obj_name;
 737                           lbfh->filspc = strdup (filspc);
 738                           lbfh->offset = offset;
 739                           lbfh->type = type;
 740
 741                           if (lbfhead == NULL)
 742                             {
 743                               lbfhead = lbfh;
 744                             }
 745                           else
 746                             {
 747                               for (lbf = lbfhead; lbf->next != NULL; lbf = lbf->next)
 748                                 ;
 749
 750                               lbf->next = lbfh;
 751                             }
 752
 753                           D ("Loading module %s from file %s.\n", hdr.ar_name, lbfh->libspc);
 754                           load_rel (libfp, hdr.ar_size);
 755                           ///* if cdb information required & .adb file present */
 756                           //if (yflag && yfp)
 757                           //  {
 758                           //    if (load_adb(FILE *libfp, struct lbfile *lbfh))
 759                           //      SaveLinkedFilePath (filspc);
 760                           //  }
 761                           ret = 1;
 762                           break;
 763                         }
 764                     }
 765                   else
 766                     {
 767                       fprintf (stderr, "?ASlink-Error-Bad offset in library file %s(%s)\n", lbnh->libspc, name);
 768                       fclose (libfp);
 769                       lkexit (1);
 770                     }
 771                 }
 772             }
 773           free (buf);
 774
 775           break;
 776         }
 777       else if (AR_IS_BSD_SYMBOL_TABLE (obj_name))
 778         {
 779           char *buf, *po, *ps;
 780           int i;
 781           long nsym, tablesize;
 782
 783           free (obj_name);
 784
 785           buf = (char *) new (hdr.ar_size);
 786
 787           if (fread (buf, 1, hdr.ar_size, libfp) != hdr.ar_size)
 788             {
 789               free (buf);
 790               return 0;
 791             }
 792
 793           tablesize = sgetl (buf);
 794           nsym = tablesize / 8;
 795
 796           po = buf + 4;
 797
 798           ps = po + tablesize + 4;
 799
 800           for (i = 0; i < nsym; ++i)
 801             {
 802               char *sym;
 803               long offset;
 804
 805               sym = ps + sgetl (po);
 806               po += 4;
 807               offset = sgetl (po);
 808               po += 4;
 809
 810               if (0 == strcmp (name, sym))
 811                 {
 812                   fseek (libfp, offset, SEEK_SET);
 813                   if (ar_get_header (&hdr, libfp, &obj_name))
 814                     {
 815                       sprintf (&filspc[strlen (filspc)], "%s", hdr.ar_name);
 816
 817                       /* If this module has been loaded already don't load it again. */
 818                       if (!is_module_loaded (filspc))
 819                         {
 820                           struct lbfile *lbfh, *lbf;
 821
 822                           lbfh = (struct lbfile *) new (sizeof (struct lbfile));
 823                           lbfh->libspc = strdup (lbnh->libspc);
 824                           lbfh->relfil = obj_name;
 825                           lbfh->filspc = strdup (filspc);
 826                           lbfh->offset = offset;
 827                           lbfh->type = type;
 828
 829                           if (lbfhead == NULL)
 830                             {
 831                               lbfhead = lbfh;
 832                             }
 833                           else
 834                             {
 835                               for (lbf = lbfhead; lbf->next != NULL; lbf = lbf->next)
 836                                 ;
 837
 838                               lbf->next = lbfh;
 839                             }
 840
 841                           D ("Loading module %s from file %s.\n", hdr.ar_name, lbfh->libspc);
 842                           load_rel (libfp, hdr.ar_size);
 843                           ///* if cdb information required & .adb file present */
 844                           //if (yflag && yfp)
 845                           //  {
 846                           //    if (load_adb(FILE *libfp, struct lbfile *lbfh))
 847                           //      SaveLinkedFilePath (filspc);
 848                           //  }
 849                           ret = 1;
 850                           break;
 851                         }
 852                     }
 853                   else
 854                     {
 855                       fprintf (stderr, "?ASlink-Error-Bad offset in library file %s(%s)\n", lbnh->libspc, name);
 856                       fclose (libfp);
 857                       lkexit (1);
 858                     }
 859                 }
 860             }
 861           free (buf);
 862
 863           break;
 864         }
 865       else if (AR_IS_STRING_TABLE (obj_name))
 866         {
 867           free (obj_name);
 868
 869           if (str_tab)
 870             free (str_tab);
 871
 872           str_tab = (char *) new (hdr.ar_size);
 873
 874           if (fread (str_tab, 1, hdr.ar_size, libfp) != hdr.ar_size)
 875             {
 876               free (str_tab);
 877               str_tab = NULL;
 878               str_tab_size = 0;
 879               return 0;
 880             }
 881           str_tab_size = hdr.ar_size;
 882         }
 883       else
 884         {
 885           long pos = ftell (libfp);
 886
 887           free (obj_name);
 888
 889           D ("  Module: %s\n", hdr.ar_name);
 890
 891           sprintf (&filspc[strlen (filspc)], "%s", hdr.ar_name);
 892
 893           /* Opened OK - create a new libraryfile object for it */
 894           ret = add_rel_file (name, lbnh, hdr.ar_name, filspc, pos - hdr_size, libfp, hdr.ar_size, type);
 895           ///* if cdb information required & .adb file present */
 896           //if (yflag && yfp)
 897           //  {
 898           //    if (load_adb(FILE *libfp, struct lbfile *lbfh))
 899           //      SaveLinkedFilePath (filspc);
 900           //  }
 901           if (ret)
 902             break;
 903
 904           fseek (libfp, pos + hdr.ar_size + (hdr.ar_size & 1), SEEK_SET);
 905         }
 906     }
 907
 908   if (NULL != str_tab)
 909     {
 910       free (str_tab);
 911       str_tab = NULL;
 912       str_tab_size = 0;
 913     }
 914
 915   return ret;
 916 }
 917 #endif
 918
 919 static void
 920 loadfile_ar (struct lbfile *lbfh)
 921 {
 922   FILE *fp;
 923   fp = fopen (lbfh->libspc, "rb");
 924   if (fp != NULL)
 925     {
 926       struct ar_hdr hdr;
 927
 928       fseek (fp, lbfh->offset, SEEK_SET);
 929       if (ar_get_header (&hdr, fp, NULL) != 0)
 930         {
 931           D ("Loading module %s from file %s.\n", hdr.ar_name, lbfh->libspc);
 932           load_rel (fp, hdr.ar_size);
 933           fclose (fp);
 934         }
 935       else
 936         {
 937           fprintf (stderr, "?ASlink-Error-Bad offset in library file %s(%s)\n", lbfh->libspc, lbfh->relfil);
 938           fclose (fp);
 939           lkexit (1);
 940         }
 941     }
 942   else
 943     {
 944       fprintf (stderr, "?ASlink-Error-Opening library '%s'\n", lbfh->libspc);
 945       lkexit (1);
 946     }
 947 }
 948
 949 struct aslib_target aslib_target_ar = {
 950   &is_ar,
 951 #ifdef INDEXLIB
 952   &buildlibraryindex_ar,
 953 #else
 954   &fndsym_ar,
 955 #endif
 956   &loadfile_ar,
 957 };