bfd/i386lynx.c

   1 /* BFD back-end for i386 a.out binaries under LynxOS.
   2    Copyright (C) 1990-2023 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #define TEXT_START_ADDR 0
  22 #define TARGET_PAGE_SIZE 4096
  23 #define SEGMENT_SIZE TARGET_PAGE_SIZE
  24 #define DEFAULT_ARCH bfd_arch_i386
  25
  26 /* Do not "beautify" the CONCAT* macro args.  Traditional C will not
  27    remove whitespace added here, and thus will fail to concatenate
  28    the tokens.  */
  29 #define MY(OP) CONCAT2 (i386_aout_lynx_,OP)
  30 #define TARGETNAME "a.out-i386-lynx"
  31
  32 #include "sysdep.h"
  33 #include "bfd.h"
  34 #include "libbfd.h"
  35
  36 #ifndef WRITE_HEADERS
  37 #define WRITE_HEADERS(abfd, execp)                                      \
  38   {                                                                     \
  39     if (adata(abfd).magic == undecided_magic)                           \
  40       NAME (aout, adjust_sizes_and_vmas) (abfd);                        \
  41                                                                         \
  42     execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;      \
  43     execp->a_entry = bfd_get_start_address (abfd);                      \
  44                                                                         \
  45     execp->a_trsize = ((obj_textsec (abfd)->reloc_count)                \
  46                        * obj_reloc_entry_size (abfd));                  \
  47     execp->a_drsize = ((obj_datasec (abfd)->reloc_count)                \
  48                        * obj_reloc_entry_size (abfd));                  \
  49     NAME (aout, swap_exec_header_out) (abfd, execp, &exec_bytes);       \
  50                                                                         \
  51     if (bfd_seek (abfd, 0, SEEK_SET) != 0                               \
  52         || bfd_write (&exec_bytes, EXEC_BYTES_SIZE,                     \
  53                       abfd) != EXEC_BYTES_SIZE)                         \
  54       return false;                                                     \
  55     /* Now write out reloc info, followed by syms and strings.  */      \
  56                                                                         \
  57     if (bfd_get_outsymbols (abfd) != NULL                               \
  58         && bfd_get_symcount (abfd) != 0)                                \
  59       {                                                                 \
  60         if (bfd_seek (abfd, N_SYMOFF (execp), SEEK_SET) != 0)           \
  61           return false;                                                 \
  62                                                                         \
  63         if (! NAME (aout, write_syms) (abfd))                           \
  64           return false;                                                 \
  65       }                                                                 \
  66                                                                         \
  67     if (bfd_seek (abfd, N_TRELOFF (execp), SEEK_SET) != 0)              \
  68       return false;                                                     \
  69     if (!NAME (lynx, squirt_out_relocs) (abfd, obj_textsec (abfd)))     \
  70       return false;                                                     \
  71                                                                         \
  72     if (bfd_seek (abfd, N_DRELOFF (execp), SEEK_SET) != 0)              \
  73       return false;                                                     \
  74     if (!NAME (lynx, squirt_out_relocs) (abfd, obj_datasec (abfd)))     \
  75       return false;                                                     \
  76   }
  77 #endif
  78
  79 #include "libaout.h"
  80 #include "aout/aout64.h"
  81
  82
  83 #ifdef LYNX_CORE
  84
  85 char *lynx_core_file_failing_command ();
  86 int lynx_core_file_failing_signal ();
  87 bool lynx_core_file_matches_executable_p ();
  88 bfd_cleanup lynx_core_file_p ();
  89
  90 #define MY_core_file_failing_command lynx_core_file_failing_command
  91 #define MY_core_file_failing_signal lynx_core_file_failing_signal
  92 #define MY_core_file_matches_executable_p lynx_core_file_matches_executable_p
  93 #define MY_core_file_p lynx_core_file_p
  94
  95 #endif /* LYNX_CORE */
  96 \f
  97
  98 #define KEEPIT udata.i
  99
 100 extern reloc_howto_type aout_32_ext_howto_table[];
 101 extern reloc_howto_type aout_32_std_howto_table[];
 102
 103 /* Standard reloc stuff */
 104 /* Output standard relocation information to a file in target byte order. */
 105
 106 static void
 107 NAME(lynx,swap_std_reloc_out) (bfd *abfd,
 108                                arelent *g,
 109                                struct reloc_std_external *natptr)
 110 {
 111   int r_index;
 112   asymbol *sym = *(g->sym_ptr_ptr);
 113   int r_extern;
 114   unsigned int r_length;
 115   int r_pcrel;
 116   int r_baserel, r_jmptable, r_relative;
 117   asection *output_section = sym->section->output_section;
 118
 119   PUT_WORD (abfd, g->address, natptr->r_address);
 120
 121   r_length = bfd_log2 (bfd_get_reloc_size (g->howto));
 122   r_pcrel = (int) g->howto->pc_relative;        /* Relative to PC? */
 123   /* r_baserel, r_jmptable, r_relative???  FIXME-soon */
 124   r_baserel = 0;
 125   r_jmptable = 0;
 126   r_relative = 0;
 127
 128   /* name was clobbered by aout_write_syms to be symbol index */
 129
 130   /* If this relocation is relative to a symbol then set the
 131      r_index to the symbols index, and the r_extern bit.
 132
 133      Absolute symbols can come in in two ways, either as an offset
 134      from the abs section, or as a symbol which has an abs value.
 135      check for that here
 136   */
 137
 138   if (bfd_is_com_section (output_section)
 139       || bfd_is_abs_section (output_section)
 140       || bfd_is_und_section (output_section))
 141     {
 142       if (bfd_abs_section_ptr->symbol == sym)
 143         {
 144           /* Whoops, looked like an abs symbol, but is really an offset
 145              from the abs section */
 146           r_index = 0;
 147           r_extern = 0;
 148         }
 149       else
 150         {
 151           /* Fill in symbol */
 152           r_extern = 1;
 153           r_index = (*g->sym_ptr_ptr)->KEEPIT;
 154         }
 155     }
 156   else
 157     {
 158       /* Just an ordinary section */
 159       r_extern = 0;
 160       r_index = output_section->target_index;
 161     }
 162
 163   /* now the fun stuff */
 164   if (bfd_header_big_endian (abfd))
 165     {
 166       natptr->r_index[0] = r_index >> 16;
 167       natptr->r_index[1] = r_index >> 8;
 168       natptr->r_index[2] = r_index;
 169       natptr->r_type[0] =
 170         (r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
 171         | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
 172         | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
 173         | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
 174         | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
 175         | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
 176     }
 177   else
 178     {
 179       natptr->r_index[2] = r_index >> 16;
 180       natptr->r_index[1] = r_index >> 8;
 181       natptr->r_index[0] = r_index;
 182       natptr->r_type[0] =
 183         (r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
 184         | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
 185         | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
 186         | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
 187         | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
 188         | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
 189     }
 190 }
 191
 192
 193 /* Extended stuff */
 194 /* Output extended relocation information to a file in target byte order. */
 195
 196 static void
 197 NAME(lynx,swap_ext_reloc_out) (bfd *abfd,
 198                                arelent *g,
 199                                struct reloc_ext_external *natptr)
 200 {
 201   int r_index;
 202   int r_extern;
 203   unsigned int r_type;
 204   unsigned int r_addend;
 205   asymbol *sym = *(g->sym_ptr_ptr);
 206   asection *output_section = sym->section->output_section;
 207
 208   PUT_WORD (abfd, g->address, natptr->r_address);
 209
 210   r_type = (unsigned int) g->howto->type;
 211
 212   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
 213
 214
 215   /* If this relocation is relative to a symbol then set the
 216      r_index to the symbols index, and the r_extern bit.
 217
 218      Absolute symbols can come in in two ways, either as an offset
 219      from the abs section, or as a symbol which has an abs value.
 220      check for that here
 221      */
 222
 223   if (bfd_is_com_section (output_section)
 224       || bfd_is_abs_section (output_section)
 225       || bfd_is_und_section (output_section))
 226     {
 227       if (bfd_abs_section_ptr->symbol == sym)
 228         {
 229           /* Whoops, looked like an abs symbol, but is really an offset
 230          from the abs section */
 231           r_index = 0;
 232           r_extern = 0;
 233         }
 234       else
 235         {
 236           r_extern = 1;
 237           r_index = (*g->sym_ptr_ptr)->KEEPIT;
 238         }
 239     }
 240   else
 241     {
 242       /* Just an ordinary section */
 243       r_extern = 0;
 244       r_index = output_section->target_index;
 245     }
 246
 247
 248   /* now the fun stuff */
 249   if (bfd_header_big_endian (abfd))
 250     {
 251       natptr->r_index[0] = r_index >> 16;
 252       natptr->r_index[1] = r_index >> 8;
 253       natptr->r_index[2] = r_index;
 254       natptr->r_type[0] =
 255         (r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
 256         | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
 257     }
 258   else
 259     {
 260       natptr->r_index[2] = r_index >> 16;
 261       natptr->r_index[1] = r_index >> 8;
 262       natptr->r_index[0] = r_index;
 263       natptr->r_type[0] =
 264         (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
 265         | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
 266     }
 267
 268   PUT_WORD (abfd, r_addend, natptr->r_addend);
 269 }
 270
 271 /* BFD deals internally with all things based from the section they're
 272    in. so, something in 10 bytes into a text section  with a base of
 273    50 would have a symbol (.text+10) and know .text vma was 50.
 274
 275    Aout keeps all it's symbols based from zero, so the symbol would
 276    contain 60. This macro subs the base of each section from the value
 277    to give the true offset from the section */
 278
 279
 280 #define MOVE_ADDRESS(ad)                                                \
 281   if (r_extern)                                                         \
 282     {                                                                   \
 283       /* undefined symbol */                                            \
 284       if (symbols != NULL && r_index < bfd_get_symcount (abfd))         \
 285         cache_ptr->sym_ptr_ptr = symbols + r_index;                     \
 286       else                                                              \
 287         cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;   \
 288       cache_ptr->addend = ad;                                           \
 289     }                                                                   \
 290   else                                                                  \
 291     {                                                                   \
 292       /* defined, section relative. replace symbol with pointer to      \
 293          symbol which points to section  */                             \
 294       switch (r_index)                                                  \
 295         {                                                               \
 296         case N_TEXT:                                                    \
 297         case N_TEXT | N_EXT:                                            \
 298           cache_ptr->sym_ptr_ptr  = obj_textsec(abfd)->symbol_ptr_ptr;  \
 299           cache_ptr->addend = ad  - su->textsec->vma;                   \
 300           break;                                                        \
 301         case N_DATA:                                                    \
 302         case N_DATA | N_EXT:                                            \
 303           cache_ptr->sym_ptr_ptr  = obj_datasec(abfd)->symbol_ptr_ptr;  \
 304           cache_ptr->addend = ad - su->datasec->vma;                    \
 305           break;                                                        \
 306         case N_BSS:                                                     \
 307         case N_BSS | N_EXT:                                             \
 308           cache_ptr->sym_ptr_ptr  = obj_bsssec(abfd)->symbol_ptr_ptr;   \
 309           cache_ptr->addend = ad - su->bsssec->vma;                     \
 310           break;                                                        \
 311         default:                                                        \
 312         case N_ABS:                                                     \
 313         case N_ABS | N_EXT:                                             \
 314           cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
 315           cache_ptr->addend = ad;                                       \
 316           break;                                                        \
 317         }                                                               \
 318     }                                                                   \
 319
 320 static void
 321 NAME(lynx,swap_ext_reloc_in) (bfd *abfd,
 322                               struct reloc_ext_external *bytes,
 323                               arelent *cache_ptr,
 324                               asymbol **symbols,
 325                               bfd_size_type symcount ATTRIBUTE_UNUSED)
 326 {
 327   unsigned int r_index;
 328   int r_extern;
 329   unsigned int r_type;
 330   struct aoutdata *su = &(abfd->tdata.aout_data->a);
 331
 332   cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
 333
 334   r_index = bytes->r_index[1];
 335   r_extern = (0 != (bytes->r_index[0] & RELOC_EXT_BITS_EXTERN_BIG));
 336   r_type = (bytes->r_index[0] & RELOC_EXT_BITS_TYPE_BIG)
 337     >> RELOC_EXT_BITS_TYPE_SH_BIG;
 338
 339   cache_ptr->howto = aout_32_ext_howto_table + r_type;
 340   MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
 341 }
 342
 343 static void
 344 NAME(lynx,swap_std_reloc_in) (bfd *abfd,
 345                               struct reloc_std_external *bytes,
 346                               arelent *cache_ptr,
 347                               asymbol **symbols,
 348                               bfd_size_type symcount ATTRIBUTE_UNUSED)
 349 {
 350   unsigned int r_index;
 351   int r_extern;
 352   unsigned int r_length;
 353   int r_pcrel;
 354   struct aoutdata *su = &(abfd->tdata.aout_data->a);
 355
 356   cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
 357
 358   r_index = bytes->r_index[1];
 359   r_extern = (0 != (bytes->r_index[0] & RELOC_STD_BITS_EXTERN_BIG));
 360   r_pcrel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_PCREL_BIG));
 361   r_length = (bytes->r_index[0] & RELOC_STD_BITS_LENGTH_BIG)
 362     >> RELOC_STD_BITS_LENGTH_SH_BIG;
 363
 364   cache_ptr->howto = aout_32_std_howto_table + r_length + 4 * r_pcrel;
 365   /* FIXME-soon:  Roll baserel, jmptable, relative bits into howto setting */
 366
 367   MOVE_ADDRESS (0);
 368 }
 369
 370 /* Reloc hackery */
 371
 372 static bool
 373 NAME(lynx,slurp_reloc_table) (bfd *abfd,
 374                               sec_ptr asect,
 375                               asymbol **symbols)
 376 {
 377   bfd_size_type count;
 378   bfd_size_type reloc_size;
 379   void * relocs;
 380   arelent *reloc_cache;
 381   size_t each_size;
 382
 383   if (asect->relocation)
 384     return true;
 385
 386   if (asect->flags & SEC_CONSTRUCTOR)
 387     return true;
 388
 389   if (asect == obj_datasec (abfd))
 390     {
 391       reloc_size = exec_hdr (abfd)->a_drsize;
 392       goto doit;
 393     }
 394
 395   if (asect == obj_textsec (abfd))
 396     {
 397       reloc_size = exec_hdr (abfd)->a_trsize;
 398       goto doit;
 399     }
 400
 401   bfd_set_error (bfd_error_invalid_operation);
 402   return false;
 403
 404  doit:
 405   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
 406     return false;
 407   each_size = obj_reloc_entry_size (abfd);
 408
 409   count = reloc_size / each_size;
 410
 411
 412   reloc_cache = (arelent *) bfd_zmalloc (count * sizeof (arelent));
 413   if (!reloc_cache && count != 0)
 414     return false;
 415
 416   relocs = _bfd_alloc_and_read (abfd, reloc_size, reloc_size);
 417   if (!relocs && reloc_size != 0)
 418     {
 419       free (reloc_cache);
 420       return false;
 421     }
 422
 423   if (each_size == RELOC_EXT_SIZE)
 424     {
 425       struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
 426       unsigned int counter = 0;
 427       arelent *cache_ptr = reloc_cache;
 428
 429       for (; counter < count; counter++, rptr++, cache_ptr++)
 430         {
 431           NAME(lynx,swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols,
 432                                         (bfd_size_type) bfd_get_symcount (abfd));
 433         }
 434     }
 435   else
 436     {
 437       struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
 438       unsigned int counter = 0;
 439       arelent *cache_ptr = reloc_cache;
 440
 441       for (; counter < count; counter++, rptr++, cache_ptr++)
 442         {
 443           NAME(lynx,swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols,
 444                                         (bfd_size_type) bfd_get_symcount (abfd));
 445         }
 446
 447     }
 448
 449   bfd_release (abfd, relocs);
 450   asect->relocation = reloc_cache;
 451   asect->reloc_count = count;
 452   return true;
 453 }
 454
 455
 456
 457 /* Write out a relocation section into an object file.  */
 458
 459 static bool
 460 NAME(lynx,squirt_out_relocs) (bfd *abfd, asection *section)
 461 {
 462   arelent **generic;
 463   unsigned char *native, *natptr;
 464   size_t each_size;
 465   unsigned int count = section->reloc_count;
 466   bfd_size_type natsize;
 467
 468   if (count == 0)
 469     return true;
 470
 471   each_size = obj_reloc_entry_size (abfd);
 472   natsize = count;
 473   natsize *= each_size;
 474   native = (unsigned char *) bfd_zalloc (abfd, natsize);
 475   if (!native)
 476     return false;
 477
 478   generic = section->orelocation;
 479
 480   if (each_size == RELOC_EXT_SIZE)
 481     {
 482       for (natptr = native;
 483            count != 0;
 484            --count, natptr += each_size, ++generic)
 485         NAME(lynx,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *) natptr);
 486     }
 487   else
 488     {
 489       for (natptr = native;
 490            count != 0;
 491            --count, natptr += each_size, ++generic)
 492         NAME(lynx,swap_std_reloc_out) (abfd, *generic, (struct reloc_std_external *) natptr);
 493     }
 494
 495   if (bfd_write (native, natsize, abfd) != natsize)
 496     {
 497       bfd_release (abfd, native);
 498       return false;
 499     }
 500   bfd_release (abfd, native);
 501
 502   return true;
 503 }
 504
 505 /* This is stupid.  This function should be a boolean predicate */
 506 static long
 507 NAME(lynx,canonicalize_reloc) (bfd *abfd,
 508                                sec_ptr section,
 509                                arelent **relptr,
 510                                asymbol **symbols)
 511 {
 512   arelent *tblptr = section->relocation;
 513   unsigned int count;
 514
 515   if (!(tblptr || NAME(lynx,slurp_reloc_table) (abfd, section, symbols)))
 516     return -1;
 517
 518   if (section->flags & SEC_CONSTRUCTOR)
 519     {
 520       arelent_chain *chain = section->constructor_chain;
 521       for (count = 0; count < section->reloc_count; count++)
 522         {
 523           *relptr++ = &chain->relent;
 524           chain = chain->next;
 525         }
 526     }
 527   else
 528     {
 529       tblptr = section->relocation;
 530
 531       for (count = 0; count++ < section->reloc_count;)
 532         {
 533           *relptr++ = tblptr++;
 534         }
 535     }
 536   *relptr = 0;
 537
 538   return section->reloc_count;
 539 }
 540
 541 #define MY_canonicalize_reloc NAME(lynx,canonicalize_reloc)
 542
 543 #include "aout-target.h"