bfd/versados.c

   1 /* BFD back-end for VERSAdos-E objects.
   2    Copyright (C) 1995-2014 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain of Cygnus Support <sac@cygnus.com>.
   4
   5    Versados is a Motorola trademark.
   6
   7    This file is part of BFD, the Binary File Descriptor library.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22    MA 02110-1301, USA.  */
  23
  24 /*
  25    SUBSECTION
  26    VERSAdos-E relocatable object file format
  27
  28    DESCRIPTION
  29
  30    This module supports reading of VERSAdos relocatable
  31    object files.
  32
  33    A VERSAdos file looks like contains
  34
  35    o Identification Record
  36    o External Symbol Definition Record
  37    o Object Text Record
  38    o End Record.  */
  39
  40 #include "sysdep.h"
  41 #include "bfd.h"
  42 #include "libbfd.h"
  43 #include "libiberty.h"
  44
  45
  46 #define VHEADER '1'
  47 #define VESTDEF '2'
  48 #define VOTR '3'
  49 #define VEND '4'
  50
  51 #define ES_BASE 17              /* First symbol has esdid 17.  */
  52
  53 /* Per file target dependent information.  */
  54
  55 /* One for each section.  */
  56 struct esdid
  57 {
  58   asection *section;            /* Ptr to bfd version.  */
  59   unsigned char *contents;      /* Used to build image.  */
  60   int pc;
  61   int relocs;                   /* Reloc count, valid end of pass 1.  */
  62   int donerel;                  /* Have relocs been translated.  */
  63 };
  64
  65 typedef struct versados_data_struct
  66 {
  67   int es_done;                  /* Count of symbol index, starts at ES_BASE.  */
  68   asymbol *symbols;             /* Pointer to local symbols.  */
  69   char *strings;                /* Strings of all the above.  */
  70   int stringlen;                /* Len of string table (valid end of pass1).  */
  71   int nsecsyms;                 /* Number of sections.  */
  72
  73   int ndefs;                    /* Number of exported symbols (they dont get esdids).  */
  74   int nrefs;                    /* Number of imported symbols  (valid end of pass1).  */
  75
  76   int ref_idx;                  /* Current processed value of the above.  */
  77   int def_idx;
  78
  79   int pass_2_done;
  80
  81   struct esdid e[16];           /* Per section info.  */
  82   int alert;                    /* To see if we're trampling.  */
  83   asymbol *rest[256 - 16];      /* Per symbol info.  */
  84 }
  85 tdata_type;
  86
  87 #define VDATA(abfd)       (abfd->tdata.versados_data)
  88 #define EDATA(abfd, n)    (abfd->tdata.versados_data->e[n])
  89 #define RDATA(abfd, n)    (abfd->tdata.versados_data->rest[n])
  90
  91 struct ext_otr
  92 {
  93   unsigned char size;
  94   char type;
  95   unsigned char map[4];
  96   unsigned char esdid;
  97   unsigned char data[200];
  98 };
  99
 100 struct ext_vheader
 101 {
 102   unsigned char size;
 103   char type;                    /* Record type.  */
 104   char name[10];                /* Module name.  */
 105   char rev;                     /* Module rev number.  */
 106   char lang;
 107   char vol[4];
 108   char user[2];
 109   char cat[8];
 110   char fname[8];
 111   char ext[2];
 112   char time[3];
 113   char date[3];
 114   char rest[211];
 115 };
 116
 117 struct ext_esd
 118 {
 119   unsigned char size;
 120   char type;
 121   unsigned char esd_entries[1];
 122 };
 123
 124 #define ESD_ABS           0
 125 #define ESD_COMMON        1
 126 #define ESD_STD_REL_SEC   2
 127 #define ESD_SHRT_REL_SEC  3
 128 #define ESD_XDEF_IN_SEC   4
 129 #define ESD_XDEF_IN_ABS   5
 130 #define ESD_XREF_SEC      6
 131 #define ESD_XREF_SYM      7
 132
 133 union ext_any
 134 {
 135   unsigned char size;
 136   struct ext_vheader header;
 137   struct ext_esd esd;
 138   struct ext_otr otr;
 139 };
 140
 141 /* Initialize by filling in the hex conversion array.  */
 142
 143 /* Set up the tdata information.  */
 144
 145 static bfd_boolean
 146 versados_mkobject (bfd *abfd)
 147 {
 148   if (abfd->tdata.versados_data == NULL)
 149     {
 150       bfd_size_type amt = sizeof (tdata_type);
 151       tdata_type *tdata = bfd_alloc (abfd, amt);
 152
 153       if (tdata == NULL)
 154         return FALSE;
 155       abfd->tdata.versados_data = tdata;
 156       tdata->symbols = NULL;
 157       VDATA (abfd)->alert = 0x12345678;
 158     }
 159
 160   bfd_default_set_arch_mach (abfd, bfd_arch_m68k, 0);
 161   return TRUE;
 162 }
 163
 164 /* Report a problem in an S record file.  FIXME: This probably should
 165    not call fprintf, but we really do need some mechanism for printing
 166    error messages.  */
 167
 168 static asymbol *
 169 versados_new_symbol (bfd *abfd,
 170                      int snum,
 171                      const char *name,
 172                      bfd_vma val,
 173                      asection *sec)
 174 {
 175   asymbol *n = VDATA (abfd)->symbols + snum;
 176   n->name = name;
 177   n->value = val;
 178   n->section = sec;
 179   n->the_bfd = abfd;
 180   n->flags = 0;
 181   return n;
 182 }
 183
 184 static int
 185 get_record (bfd *abfd, union ext_any *ptr)
 186 {
 187   if (bfd_bread (&ptr->size, (bfd_size_type) 1, abfd) != 1
 188       || (bfd_bread ((char *) ptr + 1, (bfd_size_type) ptr->size, abfd)
 189           != ptr->size))
 190     return 0;
 191   return 1;
 192 }
 193
 194 static int
 195 get_4 (unsigned char **pp)
 196 {
 197   unsigned char *p = *pp;
 198
 199   *pp += 4;
 200   return (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | (p[3] << 0);
 201 }
 202
 203 static void
 204 get_10 (unsigned char **pp, char *name)
 205 {
 206   char *p = (char *) *pp;
 207   int len = 10;
 208
 209   *pp += len;
 210   while (*p != ' ' && len)
 211     {
 212       *name++ = *p++;
 213       len--;
 214     }
 215   *name = 0;
 216 }
 217
 218 static char *
 219 new_symbol_string (bfd *abfd, const char *name)
 220 {
 221   char *n = VDATA (abfd)->strings;
 222
 223   strcpy (VDATA (abfd)->strings, name);
 224   VDATA (abfd)->strings += strlen (VDATA (abfd)->strings) + 1;
 225   return n;
 226 }
 227
 228 static void
 229 process_esd (bfd *abfd, struct ext_esd *esd, int pass)
 230 {
 231   /* Read through the ext def for the est entries.  */
 232   int togo = esd->size - 2;
 233   bfd_vma size;
 234   bfd_vma start;
 235   asection *sec;
 236   char name[11];
 237   unsigned char *ptr = esd->esd_entries;
 238   unsigned char *end = ptr + togo;
 239
 240   while (ptr < end)
 241     {
 242       int scn = *ptr & 0xf;
 243       int typ = (*ptr >> 4) & 0xf;
 244
 245       /* Declare this section.  */
 246       sprintf (name, "%d", scn);
 247       sec = bfd_make_section_old_way (abfd, strdup (name));
 248       sec->target_index = scn;
 249       EDATA (abfd, scn).section = sec;
 250       ptr++;
 251
 252       switch (typ)
 253         {
 254         default:
 255           abort ();
 256         case ESD_XREF_SEC:
 257         case ESD_XREF_SYM:
 258           {
 259             int snum = VDATA (abfd)->ref_idx++;
 260             get_10 (&ptr, name);
 261             if (pass == 1)
 262               VDATA (abfd)->stringlen += strlen (name) + 1;
 263             else
 264               {
 265                 int esidx;
 266                 asymbol *s;
 267                 char *n = new_symbol_string (abfd, name);
 268
 269                 s = versados_new_symbol (abfd, snum, n, (bfd_vma) 0,
 270                                          bfd_und_section_ptr);
 271                 esidx = VDATA (abfd)->es_done++;
 272                 RDATA (abfd, esidx - ES_BASE) = s;
 273               }
 274           }
 275           break;
 276
 277         case ESD_ABS:
 278           size = get_4 (&ptr);
 279           (void) size;
 280           start = get_4 (&ptr);
 281           (void) start;
 282           break;
 283         case ESD_STD_REL_SEC:
 284         case ESD_SHRT_REL_SEC:
 285           sec->size = get_4 (&ptr);
 286           sec->flags |= SEC_ALLOC;
 287           break;
 288         case ESD_XDEF_IN_ABS:
 289           sec = bfd_abs_section_ptr;
 290         case ESD_XDEF_IN_SEC:
 291           {
 292             int snum = VDATA (abfd)->def_idx++;
 293             bfd_vma val;
 294
 295             get_10 (&ptr, name);
 296             val = get_4 (&ptr);
 297             if (pass == 1)
 298               /* Just remember the symbol.  */
 299               VDATA (abfd)->stringlen += strlen (name) + 1;
 300             else
 301               {
 302                 asymbol *s;
 303                 char *n = new_symbol_string (abfd, name);
 304
 305                 s = versados_new_symbol (abfd, snum + VDATA (abfd)->nrefs, n,
 306                                          val, sec);
 307                 s->flags |= BSF_GLOBAL;
 308               }
 309           }
 310           break;
 311         }
 312     }
 313 }
 314
 315 #define R_RELWORD     1
 316 #define R_RELLONG     2
 317 #define R_RELWORD_NEG 3
 318 #define R_RELLONG_NEG 4
 319
 320 reloc_howto_type versados_howto_table[] =
 321 {
 322   HOWTO (R_RELWORD, 0, 1, 16, FALSE,
 323          0, complain_overflow_dont, 0,
 324          "+v16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
 325   HOWTO (R_RELLONG, 0, 2, 32, FALSE,
 326          0, complain_overflow_dont, 0,
 327          "+v32", TRUE, 0xffffffff, 0xffffffff, FALSE),
 328
 329   HOWTO (R_RELWORD_NEG, 0, -1, 16, FALSE,
 330          0, complain_overflow_dont, 0,
 331          "-v16", TRUE, 0x0000ffff, 0x0000ffff, FALSE),
 332   HOWTO (R_RELLONG_NEG, 0, -2, 32, FALSE,
 333          0, complain_overflow_dont, 0,
 334          "-v32", TRUE, 0xffffffff, 0xffffffff, FALSE),
 335 };
 336
 337 static int
 338 get_offset (int len, unsigned char *ptr)
 339 {
 340   int val = 0;
 341
 342   if (len)
 343     {
 344       int i;
 345
 346       val = *ptr++;
 347       if (val & 0x80)
 348         val |= ~0xff;
 349       for (i = 1; i < len; i++)
 350         val = (val << 8) | *ptr++;
 351     }
 352
 353   return val;
 354 }
 355
 356 static void
 357 process_otr (bfd *abfd, struct ext_otr *otr, int pass)
 358 {
 359   unsigned long shift;
 360   unsigned char *srcp = otr->data;
 361   unsigned char *endp = (unsigned char *) otr + otr->size;
 362   unsigned int bits = (otr->map[0] << 24)
 363   | (otr->map[1] << 16)
 364   | (otr->map[2] << 8)
 365   | (otr->map[3] << 0);
 366
 367   struct esdid *esdid = &EDATA (abfd, otr->esdid - 1);
 368   unsigned char *contents = esdid->contents;
 369   int need_contents = 0;
 370   unsigned int dst_idx = esdid->pc;
 371
 372   for (shift = ((unsigned long) 1 << 31); shift && srcp < endp; shift >>= 1)
 373     {
 374       if (bits & shift)
 375         {
 376           int flag = *srcp++;
 377           int esdids = (flag >> 5) & 0x7;
 378           int sizeinwords = ((flag >> 3) & 1) ? 2 : 1;
 379           int offsetlen = flag & 0x7;
 380           int j;
 381
 382           if (esdids == 0)
 383             {
 384               /* A zero esdid means the new pc is the offset given.  */
 385               dst_idx += get_offset (offsetlen, srcp);
 386               srcp += offsetlen;
 387             }
 388           else
 389             {
 390               int val = get_offset (offsetlen, srcp + esdids);
 391
 392               if (pass == 1)
 393                 need_contents = 1;
 394               else
 395                 for (j = 0; j < sizeinwords * 2; j++)
 396                   {
 397                     contents[dst_idx + (sizeinwords * 2) - j - 1] = val;
 398                     val >>= 8;
 399                   }
 400
 401               for (j = 0; j < esdids; j++)
 402                 {
 403                   int id = *srcp++;
 404
 405                   if (id)
 406                     {
 407                       int rn = EDATA (abfd, otr->esdid - 1).relocs++;
 408
 409                       if (pass == 1)
 410                         {
 411                           /* This is the first pass over the data,
 412                              just remember that we need a reloc.  */
 413                         }
 414                       else
 415                         {
 416                           arelent *n =
 417                           EDATA (abfd, otr->esdid - 1).section->relocation + rn;
 418                           n->address = dst_idx;
 419
 420                           n->sym_ptr_ptr = (asymbol **) (size_t) id;
 421                           n->addend = 0;
 422                           n->howto = versados_howto_table + ((j & 1) * 2) + (sizeinwords - 1);
 423                         }
 424                     }
 425                 }
 426               srcp += offsetlen;
 427               dst_idx += sizeinwords * 2;
 428             }
 429         }
 430       else
 431         {
 432           need_contents = 1;
 433           if (dst_idx < esdid->section->size)
 434             if (pass == 2)
 435               {
 436                 /* Absolute code, comes in 16 bit lumps.  */
 437                 contents[dst_idx] = srcp[0];
 438                 contents[dst_idx + 1] = srcp[1];
 439               }
 440           dst_idx += 2;
 441           srcp += 2;
 442         }
 443     }
 444   EDATA (abfd, otr->esdid - 1).pc = dst_idx;
 445
 446   if (!contents && need_contents)
 447     {
 448       bfd_size_type size = esdid->section->size;
 449       esdid->contents = bfd_alloc (abfd, size);
 450     }
 451 }
 452
 453 static bfd_boolean
 454 versados_scan (bfd *abfd)
 455 {
 456   int loop = 1;
 457   int i;
 458   int j;
 459   int nsecs = 0;
 460   bfd_size_type amt;
 461
 462   VDATA (abfd)->stringlen = 0;
 463   VDATA (abfd)->nrefs = 0;
 464   VDATA (abfd)->ndefs = 0;
 465   VDATA (abfd)->ref_idx = 0;
 466   VDATA (abfd)->def_idx = 0;
 467   VDATA (abfd)->pass_2_done = 0;
 468
 469   while (loop)
 470     {
 471       union ext_any any;
 472
 473       if (!get_record (abfd, &any))
 474         return TRUE;
 475       switch (any.header.type)
 476         {
 477         case VHEADER:
 478           break;
 479         case VEND:
 480           loop = 0;
 481           break;
 482         case VESTDEF:
 483           process_esd (abfd, &any.esd, 1);
 484           break;
 485         case VOTR:
 486           process_otr (abfd, &any.otr, 1);
 487           break;
 488         }
 489     }
 490
 491   /* Now allocate space for the relocs and sections.  */
 492   VDATA (abfd)->nrefs = VDATA (abfd)->ref_idx;
 493   VDATA (abfd)->ndefs = VDATA (abfd)->def_idx;
 494   VDATA (abfd)->ref_idx = 0;
 495   VDATA (abfd)->def_idx = 0;
 496
 497   abfd->symcount = VDATA (abfd)->nrefs + VDATA (abfd)->ndefs;
 498
 499   for (i = 0; i < 16; i++)
 500     {
 501       struct esdid *esdid = &EDATA (abfd, i);
 502
 503       if (esdid->section)
 504         {
 505           amt = (bfd_size_type) esdid->relocs * sizeof (arelent);
 506           esdid->section->relocation = bfd_alloc (abfd, amt);
 507
 508           esdid->pc = 0;
 509
 510           if (esdid->contents)
 511             esdid->section->flags |= SEC_HAS_CONTENTS | SEC_LOAD;
 512
 513           esdid->section->reloc_count = esdid->relocs;
 514           if (esdid->relocs)
 515             esdid->section->flags |= SEC_RELOC;
 516
 517           esdid->relocs = 0;
 518
 519           /* Add an entry into the symbol table for it.  */
 520           nsecs++;
 521           VDATA (abfd)->stringlen += strlen (esdid->section->name) + 1;
 522         }
 523     }
 524
 525   abfd->symcount += nsecs;
 526
 527   amt = abfd->symcount;
 528   amt *= sizeof (asymbol);
 529   VDATA (abfd)->symbols = bfd_alloc (abfd, amt);
 530
 531   amt = VDATA (abfd)->stringlen;
 532   VDATA (abfd)->strings = bfd_alloc (abfd, amt);
 533
 534   if ((VDATA (abfd)->symbols == NULL && abfd->symcount > 0)
 535       || (VDATA (abfd)->strings == NULL && VDATA (abfd)->stringlen > 0))
 536     return FALSE;
 537
 538   /* Actually fill in the section symbols,
 539      we stick them at the end of the table.  */
 540   for (j = VDATA (abfd)->nrefs + VDATA (abfd)->ndefs, i = 0; i < 16; i++)
 541     {
 542       struct esdid *esdid = &EDATA (abfd, i);
 543       asection *sec = esdid->section;
 544
 545       if (sec)
 546         {
 547           asymbol *s = VDATA (abfd)->symbols + j;
 548           s->name = new_symbol_string (abfd, sec->name);
 549           s->section = sec;
 550           s->flags = BSF_LOCAL;
 551           s->value = 0;
 552           s->the_bfd = abfd;
 553           j++;
 554         }
 555     }
 556
 557   if (abfd->symcount)
 558     abfd->flags |= HAS_SYMS;
 559
 560   /* Set this to nsecs - since we've already planted the section
 561      symbols.  */
 562   VDATA (abfd)->nsecsyms = nsecs;
 563
 564   VDATA (abfd)->ref_idx = 0;
 565
 566   return 1;
 567 }
 568
 569 /* Check whether an existing file is a versados  file.  */
 570
 571 static const bfd_target *
 572 versados_object_p (bfd *abfd)
 573 {
 574   struct ext_vheader ext;
 575   unsigned char len;
 576   tdata_type *tdata_save;
 577
 578   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 579     return NULL;
 580
 581   if (bfd_bread (&len, (bfd_size_type) 1, abfd) != 1)
 582     {
 583       if (bfd_get_error () != bfd_error_system_call)
 584         bfd_set_error (bfd_error_wrong_format);
 585       return NULL;
 586     }
 587
 588   if (bfd_bread (&ext.type, (bfd_size_type) len, abfd) != len)
 589     {
 590       if (bfd_get_error () != bfd_error_system_call)
 591         bfd_set_error (bfd_error_wrong_format);
 592       return NULL;
 593     }
 594
 595   /* We guess that the language field will never be larger than 10.
 596      In sample files, it is always either 0 or 1.  Checking for this
 597      prevents confusion with Intel Hex files.  */
 598   if (ext.type != VHEADER
 599       || ext.lang > 10)
 600     {
 601       bfd_set_error (bfd_error_wrong_format);
 602       return NULL;
 603     }
 604
 605   /* OK, looks like a record, build the tdata and read in.  */
 606   tdata_save = abfd->tdata.versados_data;
 607   if (!versados_mkobject (abfd) || !versados_scan (abfd))
 608     {
 609       abfd->tdata.versados_data = tdata_save;
 610       return NULL;
 611     }
 612
 613   return abfd->xvec;
 614 }
 615
 616 static bfd_boolean
 617 versados_pass_2 (bfd *abfd)
 618 {
 619   union ext_any any;
 620
 621   if (VDATA (abfd)->pass_2_done)
 622     return 1;
 623
 624   if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
 625     return 0;
 626
 627   VDATA (abfd)->es_done = ES_BASE;
 628
 629   /* Read records till we get to where we want to be.  */
 630   while (1)
 631     {
 632       get_record (abfd, &any);
 633       switch (any.header.type)
 634         {
 635         case VEND:
 636           VDATA (abfd)->pass_2_done = 1;
 637           return 1;
 638         case VESTDEF:
 639           process_esd (abfd, &any.esd, 2);
 640           break;
 641         case VOTR:
 642           process_otr (abfd, &any.otr, 2);
 643           break;
 644         }
 645     }
 646 }
 647
 648 static bfd_boolean
 649 versados_get_section_contents (bfd *abfd,
 650                                asection *section,
 651                                void * location,
 652                                file_ptr offset,
 653                                bfd_size_type count)
 654 {
 655   if (!versados_pass_2 (abfd))
 656     return FALSE;
 657
 658   memcpy (location,
 659           EDATA (abfd, section->target_index).contents + offset,
 660           (size_t) count);
 661
 662   return TRUE;
 663 }
 664
 665 #define versados_get_section_contents_in_window \
 666   _bfd_generic_get_section_contents_in_window
 667
 668 static bfd_boolean
 669 versados_set_section_contents (bfd *abfd ATTRIBUTE_UNUSED,
 670                                sec_ptr section ATTRIBUTE_UNUSED,
 671                                const void * location ATTRIBUTE_UNUSED,
 672                                file_ptr offset ATTRIBUTE_UNUSED,
 673                                bfd_size_type bytes_to_do ATTRIBUTE_UNUSED)
 674 {
 675   return FALSE;
 676 }
 677
 678 static int
 679 versados_sizeof_headers (bfd *abfd ATTRIBUTE_UNUSED,
 680                          struct bfd_link_info *info ATTRIBUTE_UNUSED)
 681 {
 682   return 0;
 683 }
 684
 685 /* Return the amount of memory needed to read the symbol table.  */
 686
 687 static long
 688 versados_get_symtab_upper_bound (bfd *abfd)
 689 {
 690   return (bfd_get_symcount (abfd) + 1) * sizeof (asymbol *);
 691 }
 692
 693 /* Return the symbol table.  */
 694
 695 static long
 696 versados_canonicalize_symtab (bfd *abfd, asymbol **alocation)
 697 {
 698   unsigned int symcount = bfd_get_symcount (abfd);
 699   unsigned int i;
 700   asymbol *s;
 701
 702   versados_pass_2 (abfd);
 703
 704   for (i = 0, s = VDATA (abfd)->symbols;
 705        i < symcount;
 706        s++, i++)
 707     *alocation++ = s;
 708
 709   *alocation = NULL;
 710
 711   return symcount;
 712 }
 713
 714 static void
 715 versados_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
 716                           asymbol *symbol,
 717                           symbol_info *ret)
 718 {
 719   bfd_symbol_info (symbol, ret);
 720 }
 721
 722 static void
 723 versados_print_symbol (bfd *abfd,
 724                        void * afile,
 725                        asymbol *symbol,
 726                        bfd_print_symbol_type how)
 727 {
 728   FILE *file = (FILE *) afile;
 729
 730   switch (how)
 731     {
 732     case bfd_print_symbol_name:
 733       fprintf (file, "%s", symbol->name);
 734       break;
 735     default:
 736       bfd_print_symbol_vandf (abfd, (void *) file, symbol);
 737       fprintf (file, " %-5s %s",
 738                symbol->section->name,
 739                symbol->name);
 740     }
 741 }
 742
 743 static long
 744 versados_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
 745                                 sec_ptr asect)
 746 {
 747   return (asect->reloc_count + 1) * sizeof (arelent *);
 748 }
 749
 750 static long
 751 versados_canonicalize_reloc (bfd *abfd,
 752                              sec_ptr section,
 753                              arelent **relptr,
 754                              asymbol **symbols)
 755 {
 756   unsigned int count;
 757   arelent *src;
 758
 759   versados_pass_2 (abfd);
 760   src = section->relocation;
 761   if (!EDATA (abfd, section->target_index).donerel)
 762     {
 763       EDATA (abfd, section->target_index).donerel = 1;
 764       /* Translate from indexes to symptr ptrs.  */
 765       for (count = 0; count < section->reloc_count; count++)
 766         {
 767           int esdid = (int) (size_t) src[count].sym_ptr_ptr;
 768
 769           if (esdid == 0)
 770             src[count].sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 771           else if (esdid < ES_BASE)
 772             {
 773               /* Section relative thing.  */
 774               struct esdid *e = &EDATA (abfd, esdid - 1);
 775
 776               src[count].sym_ptr_ptr = e->section->symbol_ptr_ptr;
 777             }
 778           else
 779             src[count].sym_ptr_ptr = symbols + esdid - ES_BASE;
 780         }
 781     }
 782
 783   for (count = 0; count < section->reloc_count; count++)
 784     *relptr++ = src++;
 785
 786   *relptr = 0;
 787   return section->reloc_count;
 788 }
 789
 790 #define versados_close_and_cleanup                    _bfd_generic_close_and_cleanup
 791 #define versados_bfd_free_cached_info                 _bfd_generic_bfd_free_cached_info
 792 #define versados_new_section_hook                     _bfd_generic_new_section_hook
 793 #define versados_bfd_is_target_special_symbol   ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
 794 #define versados_bfd_is_local_label_name              bfd_generic_is_local_label_name
 795 #define versados_get_lineno                           _bfd_nosymbols_get_lineno
 796 #define versados_find_nearest_line                    _bfd_nosymbols_find_nearest_line
 797 #define versados_find_inliner_info                    _bfd_nosymbols_find_inliner_info
 798 #define versados_make_empty_symbol                    _bfd_generic_make_empty_symbol
 799 #define versados_bfd_make_debug_symbol                _bfd_nosymbols_bfd_make_debug_symbol
 800 #define versados_read_minisymbols                     _bfd_generic_read_minisymbols
 801 #define versados_minisymbol_to_symbol                 _bfd_generic_minisymbol_to_symbol
 802 #define versados_bfd_reloc_type_lookup                _bfd_norelocs_bfd_reloc_type_lookup
 803 #define versados_bfd_reloc_name_lookup          _bfd_norelocs_bfd_reloc_name_lookup
 804 #define versados_set_arch_mach                        bfd_default_set_arch_mach
 805 #define versados_bfd_get_relocated_section_contents   bfd_generic_get_relocated_section_contents
 806 #define versados_bfd_relax_section                    bfd_generic_relax_section
 807 #define versados_bfd_gc_sections                      bfd_generic_gc_sections
 808 #define versados_bfd_lookup_section_flags             bfd_generic_lookup_section_flags
 809 #define versados_bfd_merge_sections                   bfd_generic_merge_sections
 810 #define versados_bfd_is_group_section                 bfd_generic_is_group_section
 811 #define versados_bfd_discard_group                    bfd_generic_discard_group
 812 #define versados_section_already_linked               _bfd_generic_section_already_linked
 813 #define versados_bfd_define_common_symbol             bfd_generic_define_common_symbol
 814 #define versados_bfd_link_hash_table_create           _bfd_generic_link_hash_table_create
 815 #define versados_bfd_link_hash_table_free             _bfd_generic_link_hash_table_free
 816 #define versados_bfd_link_add_symbols                 _bfd_generic_link_add_symbols
 817 #define versados_bfd_link_just_syms                   _bfd_generic_link_just_syms
 818 #define versados_bfd_copy_link_hash_symbol_type \
 819   _bfd_generic_copy_link_hash_symbol_type
 820 #define versados_bfd_final_link                       _bfd_generic_final_link
 821 #define versados_bfd_link_split_section               _bfd_generic_link_split_section
 822
 823 const bfd_target m68k_versados_vec =
 824 {
 825   "versados",                   /* Name.  */
 826   bfd_target_versados_flavour,
 827   BFD_ENDIAN_BIG,               /* Target byte order.  */
 828   BFD_ENDIAN_BIG,               /* Target headers byte order.  */
 829   (HAS_RELOC | EXEC_P |         /* Object flags.  */
 830    HAS_LINENO | HAS_DEBUG |
 831    HAS_SYMS | HAS_LOCALS | WP_TEXT | D_PAGED),
 832   (SEC_CODE | SEC_DATA | SEC_ROM | SEC_HAS_CONTENTS
 833    | SEC_ALLOC | SEC_LOAD | SEC_RELOC),         /* Section flags.  */
 834   0,                            /* Leading underscore.  */
 835   ' ',                          /* AR_pad_char.  */
 836   16,                           /* AR_max_namelen.  */
 837   0,                            /* match priority.  */
 838   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 839   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 840   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Data.  */
 841   bfd_getb64, bfd_getb_signed_64, bfd_putb64,
 842   bfd_getb32, bfd_getb_signed_32, bfd_putb32,
 843   bfd_getb16, bfd_getb_signed_16, bfd_putb16,   /* Headers.  */
 844
 845   {
 846     _bfd_dummy_target,
 847     versados_object_p,          /* bfd_check_format.  */
 848     _bfd_dummy_target,
 849     _bfd_dummy_target,
 850   },
 851   {
 852     bfd_false,
 853     versados_mkobject,
 854     _bfd_generic_mkarchive,
 855     bfd_false,
 856   },
 857   {                             /* bfd_write_contents.  */
 858     bfd_false,
 859     bfd_false,
 860     _bfd_write_archive_contents,
 861     bfd_false,
 862   },
 863
 864   BFD_JUMP_TABLE_GENERIC (versados),
 865   BFD_JUMP_TABLE_COPY (_bfd_generic),
 866   BFD_JUMP_TABLE_CORE (_bfd_nocore),
 867   BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
 868   BFD_JUMP_TABLE_SYMBOLS (versados),
 869   BFD_JUMP_TABLE_RELOCS (versados),
 870   BFD_JUMP_TABLE_WRITE (versados),
 871   BFD_JUMP_TABLE_LINK (versados),
 872   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 873
 874   NULL,
 875
 876   NULL
 877 };