bfd/coff-stgo32.c

   1 /* BFD back-end for Intel 386 COFF files (DJGPP variant with a stub).
   2    Copyright 1997, 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3    Written by Robert Hoehne.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 /* This file handles now also stubbed coff images. The stub is a small
  22    DOS executable program before the coff image to load it in memory
  23    and execute it. This is needed, because DOS cannot run coff files.
  24
  25    All the functions below are called by the corresponding functions
  26    from coffswap.h.
  27    The only thing what they do is to adjust the information stored in
  28    the COFF file which are offset into the file.
  29    This is needed, because DJGPP uses a very special way to load and run
  30    the coff image. It loads the image in memory and assumes then, that the
  31    image had no stub by using the filepointers as pointers in the coff
  32    image and NOT in the file.
  33
  34    To be compatible with any existing executables I have fixed this
  35    here and NOT in the DJGPP startup code.  */
  36
  37 #define TARGET_SYM              go32stubbedcoff_vec
  38 #define TARGET_NAME             "coff-go32-exe"
  39 #define TARGET_UNDERSCORE       '_'
  40 #define COFF_GO32_EXE
  41 #define COFF_LONG_SECTION_NAMES
  42 #define COFF_SUPPORT_GNU_LINKONCE
  43 #define COFF_LONG_FILENAMES
  44
  45 #define COFF_SECTION_ALIGNMENT_ENTRIES \
  46 { COFF_SECTION_NAME_EXACT_MATCH (".data"), \
  47   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
  48 { COFF_SECTION_NAME_EXACT_MATCH (".text"), \
  49   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 4 }, \
  50 { COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
  51   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
  52 { COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi"), \
  53   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }
  54
  55 #include "bfd.h"
  56
  57 /* At first the prototypes.  */
  58
  59 static void
  60 adjust_filehdr_in_post PARAMS ((bfd *, PTR, PTR));
  61 static void
  62 adjust_filehdr_out_pre PARAMS ((bfd *, PTR, PTR));
  63 static void
  64 adjust_filehdr_out_post PARAMS ((bfd *, PTR, PTR));
  65 static void
  66 adjust_scnhdr_in_post PARAMS ((bfd *, PTR, PTR));
  67 static void
  68 adjust_scnhdr_out_pre PARAMS ((bfd *, PTR, PTR));
  69 static void
  70 adjust_scnhdr_out_post PARAMS ((bfd *, PTR, PTR));
  71 static void
  72 adjust_aux_in_post PARAMS ((bfd *, PTR, int, int, int, int, PTR));
  73 static void
  74 adjust_aux_out_pre PARAMS ((bfd *, PTR, int, int, int, int, PTR));
  75 static void
  76 adjust_aux_out_post PARAMS ((bfd *, PTR, int, int, int, int, PTR));
  77 static void
  78 create_go32_stub PARAMS ((bfd *));
  79
  80 /* All that ..._PRE and ...POST functions are called from the corresponding
  81    coff_swap... functions. The ...PRE functions are called at the beginning
  82    of the function and the ...POST functions at the end of the swap routines.  */
  83
  84 #define COFF_ADJUST_FILEHDR_IN_POST adjust_filehdr_in_post
  85 #define COFF_ADJUST_FILEHDR_OUT_PRE adjust_filehdr_out_pre
  86 #define COFF_ADJUST_FILEHDR_OUT_POST adjust_filehdr_out_post
  87
  88 #define COFF_ADJUST_SCNHDR_IN_POST adjust_scnhdr_in_post
  89 #define COFF_ADJUST_SCNHDR_OUT_PRE adjust_scnhdr_out_pre
  90 #define COFF_ADJUST_SCNHDR_OUT_POST adjust_scnhdr_out_post
  91
  92 #define COFF_ADJUST_AUX_IN_POST adjust_aux_in_post
  93 #define COFF_ADJUST_AUX_OUT_PRE adjust_aux_out_pre
  94 #define COFF_ADJUST_AUX_OUT_POST adjust_aux_out_post
  95
  96 static bfd_boolean
  97   go32_stubbed_coff_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
  98
  99 #define coff_bfd_copy_private_bfd_data go32_stubbed_coff_bfd_copy_private_bfd_data
 100
 101 #include "coff-i386.c"
 102
 103 /* I hold in the usrdata the stub.  */
 104 #define bfd_coff_go32stub bfd_usrdata
 105
 106 /* This macro is used, because I cannot assume the endianess of the
 107    host system.  */
 108 #define _H(index) (H_GET_16 (abfd, (header+index*2)))
 109
 110 /* These bytes are a 2048-byte DOS executable, which loads the COFF
 111    image into memory and then runs it. It is called 'stub'.  */
 112
 113 static const unsigned char stub_bytes[STUBSIZE] =
 114 {
 115 #include "go32stub.h"
 116 };
 117
 118 /*
 119    I have not commented each swap function below, because the
 120    technique is in any function the same. For the ...in function,
 121    all the pointers are adjusted by adding STUBSIZE and for the
 122    ...out function, it is subtracted first and after calling the
 123    standard swap function it is reset to the old value.  */
 124
 125 /* This macro is used for adjusting the filepointers, which
 126    is done only, if the pointer is nonzero.  */
 127
 128 #define ADJUST_VAL(val,diff) \
 129   if (val != 0) val += diff
 130
 131 static void
 132 adjust_filehdr_in_post  (abfd, src, dst)
 133      bfd *abfd;
 134      PTR src;
 135      PTR dst;
 136 {
 137   FILHDR *filehdr_src = (FILHDR *) src;
 138   struct internal_filehdr *filehdr_dst = (struct internal_filehdr *) dst;
 139
 140   ADJUST_VAL (filehdr_dst->f_symptr, STUBSIZE);
 141
 142   /* Save now the stub to be used later.  */
 143   bfd_coff_go32stub (abfd) = (PTR) bfd_alloc (abfd, (bfd_size_type) STUBSIZE);
 144
 145   /* Since this function returns no status, I do not set here
 146      any bfd_error_...
 147      That means, before the use of bfd_coff_go32stub (), this value
 148      should be checked if it is != NULL.  */
 149   if (bfd_coff_go32stub (abfd) == NULL)
 150     return;
 151   memcpy (bfd_coff_go32stub (abfd), filehdr_src->stub, STUBSIZE);
 152 }
 153
 154 static void
 155 adjust_filehdr_out_pre  (abfd, in, out)
 156      bfd *abfd;
 157      PTR in;
 158      PTR out;
 159 {
 160   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 161   FILHDR *filehdr_out = (FILHDR *) out;
 162
 163   /* Generate the stub.  */
 164   create_go32_stub (abfd);
 165
 166   /* Copy the stub to the file header.  */
 167   if (bfd_coff_go32stub (abfd) != NULL)
 168     memcpy (filehdr_out->stub, bfd_coff_go32stub (abfd), STUBSIZE);
 169   else
 170     /* Use the default.  */
 171     memcpy (filehdr_out->stub, stub_bytes, STUBSIZE);
 172
 173   ADJUST_VAL (filehdr_in->f_symptr, -STUBSIZE);
 174 }
 175
 176 static void
 177 adjust_filehdr_out_post  (abfd, in, out)
 178      bfd *abfd ATTRIBUTE_UNUSED;
 179      PTR in;
 180      PTR out ATTRIBUTE_UNUSED;
 181 {
 182   struct internal_filehdr *filehdr_in = (struct internal_filehdr *) in;
 183   /* Undo the above change.  */
 184   ADJUST_VAL (filehdr_in->f_symptr, STUBSIZE);
 185 }
 186
 187 static void
 188 adjust_scnhdr_in_post  (abfd, ext, in)
 189      bfd *abfd ATTRIBUTE_UNUSED;
 190      PTR ext ATTRIBUTE_UNUSED;
 191      PTR in;
 192 {
 193   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 194
 195   ADJUST_VAL (scnhdr_int->s_scnptr, STUBSIZE);
 196   ADJUST_VAL (scnhdr_int->s_relptr, STUBSIZE);
 197   ADJUST_VAL (scnhdr_int->s_lnnoptr, STUBSIZE);
 198 }
 199
 200 static void
 201 adjust_scnhdr_out_pre  (abfd, in, out)
 202      bfd *abfd ATTRIBUTE_UNUSED;
 203      PTR in;
 204      PTR out ATTRIBUTE_UNUSED;
 205 {
 206   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 207
 208   ADJUST_VAL (scnhdr_int->s_scnptr, -STUBSIZE);
 209   ADJUST_VAL (scnhdr_int->s_relptr, -STUBSIZE);
 210   ADJUST_VAL (scnhdr_int->s_lnnoptr, -STUBSIZE);
 211 }
 212
 213 static void
 214 adjust_scnhdr_out_post (abfd, in, out)
 215      bfd *abfd ATTRIBUTE_UNUSED;
 216      PTR in;
 217      PTR out ATTRIBUTE_UNUSED;
 218 {
 219   struct internal_scnhdr *scnhdr_int = (struct internal_scnhdr *) in;
 220
 221   ADJUST_VAL (scnhdr_int->s_scnptr, STUBSIZE);
 222   ADJUST_VAL (scnhdr_int->s_relptr, STUBSIZE);
 223   ADJUST_VAL (scnhdr_int->s_lnnoptr, STUBSIZE);
 224 }
 225
 226 static void
 227 adjust_aux_in_post  (abfd, ext1, type, class, indx, numaux, in1)
 228      bfd *abfd ATTRIBUTE_UNUSED;
 229      PTR ext1 ATTRIBUTE_UNUSED;
 230      int type;
 231      int class;
 232      int indx ATTRIBUTE_UNUSED;
 233      int numaux ATTRIBUTE_UNUSED;
 234      PTR in1;
 235 {
 236   union internal_auxent *in = (union internal_auxent *) in1;
 237
 238   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 239     {
 240       ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, STUBSIZE);
 241     }
 242 }
 243
 244 static void
 245 adjust_aux_out_pre  (abfd, inp, type, class, indx, numaux, extp)
 246      bfd *abfd ATTRIBUTE_UNUSED;
 247      PTR inp;
 248      int type;
 249      int class;
 250      int indx ATTRIBUTE_UNUSED;
 251      int numaux ATTRIBUTE_UNUSED;
 252      PTR extp ATTRIBUTE_UNUSED;
 253 {
 254   union internal_auxent *in = (union internal_auxent *) inp;
 255
 256   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 257     {
 258       ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, -STUBSIZE);
 259     }
 260 }
 261
 262 static void
 263 adjust_aux_out_post (abfd, inp, type, class, indx, numaux, extp)
 264      bfd *abfd ATTRIBUTE_UNUSED;
 265      PTR inp;
 266      int type;
 267      int class;
 268      int indx ATTRIBUTE_UNUSED;
 269      int numaux ATTRIBUTE_UNUSED;
 270      PTR extp ATTRIBUTE_UNUSED;
 271 {
 272   union internal_auxent *in = (union internal_auxent *) inp;
 273
 274   if (class == C_BLOCK || class == C_FCN || ISFCN (type) || ISTAG (class))
 275     {
 276       ADJUST_VAL (in->x_sym.x_fcnary.x_fcn.x_lnnoptr, STUBSIZE);
 277     }
 278 }
 279
 280 /* That's the function, which creates the stub. There are
 281    different cases from where the stub is taken.
 282    At first the environment variable $(GO32STUB) is checked and then
 283    $(STUB) if it was not set.
 284    If it exists and points to a valid stub the stub is taken from
 285    that file. This file can be also a whole executable file, because
 286    the stub is computed from the exe information at the start of that
 287    file.
 288
 289    If there was any error, the standard stub (compiled in this file)
 290    is taken.  */
 291
 292 static void
 293 create_go32_stub (abfd)
 294      bfd *abfd;
 295 {
 296   /* Do it only once.  */
 297   if (bfd_coff_go32stub (abfd) == NULL)
 298     {
 299       char *stub;
 300       struct stat st;
 301       int f;
 302       unsigned char header[10];
 303       char magic[8];
 304       unsigned long coff_start;
 305       long exe_start;
 306
 307       /* Check at first the environment variable $(GO32STUB).  */
 308       stub = getenv ("GO32STUB");
 309       /* Now check the environment variable $(STUB).  */
 310       if (stub == NULL)
 311         stub = getenv ("STUB");
 312       if (stub == NULL)
 313         goto stub_end;
 314       if (stat (stub, &st) != 0)
 315         goto stub_end;
 316 #ifdef O_BINARY
 317       f = open (stub, O_RDONLY | O_BINARY);
 318 #else
 319       f = open (stub, O_RDONLY);
 320 #endif
 321       if (f < 0)
 322         goto stub_end;
 323       if (read (f, &header, sizeof (header)) < 0)
 324         {
 325           close (f);
 326           goto stub_end;
 327         }
 328       if (_H (0) != 0x5a4d)     /* It is not an exe file.  */
 329         {
 330           close (f);
 331           goto stub_end;
 332         }
 333       /* Compute the size of the stub (it is every thing up
 334          to the beginning of the coff image).  */
 335       coff_start = (long) _H (2) * 512L;
 336       if (_H (1))
 337         coff_start += (long) _H (1) - 512L;
 338
 339       /* Currently there is only a fixed stub size of 2048 bytes
 340          supported.  */
 341       if (coff_start != 2048)
 342         {
 343           close (f);
 344           goto stub_end;
 345         }
 346       exe_start = _H (4) * 16;
 347       if ((long) lseek (f, exe_start, SEEK_SET) != exe_start)
 348         {
 349           close (f);
 350           goto stub_end;
 351         }
 352       if (read (f, &magic, 8) != 8)
 353         {
 354           close (f);
 355           goto stub_end;
 356         }
 357       if (memcmp (magic, "go32stub", 8) != 0)
 358         {
 359           close (f);
 360           goto stub_end;
 361         }
 362       /* Now we found a correct stub (hopefully).  */
 363       bfd_coff_go32stub (abfd)
 364         = (PTR) bfd_alloc (abfd, (bfd_size_type) coff_start);
 365       if (bfd_coff_go32stub (abfd) == NULL)
 366         {
 367           close (f);
 368           return;
 369         }
 370       lseek (f, 0L, SEEK_SET);
 371       if ((unsigned long) read (f, bfd_coff_go32stub (abfd), coff_start)
 372           != coff_start)
 373         {
 374           bfd_release (abfd, bfd_coff_go32stub (abfd));
 375           bfd_coff_go32stub (abfd) = NULL;
 376         }
 377       close (f);
 378     }
 379 stub_end:
 380   /* There was something wrong above, so use now the standard builtin
 381      stub.  */
 382   if (bfd_coff_go32stub (abfd) == NULL)
 383     {
 384       bfd_coff_go32stub (abfd)
 385         = (PTR) bfd_alloc (abfd, (bfd_size_type) STUBSIZE);
 386       if (bfd_coff_go32stub (abfd) == NULL)
 387         return;
 388       memcpy (bfd_coff_go32stub (abfd), stub_bytes, STUBSIZE);
 389     }
 390 }
 391
 392 /* If ibfd was a stubbed coff image, copy the stub from that bfd
 393    to the new obfd.  */
 394
 395 static bfd_boolean
 396 go32_stubbed_coff_bfd_copy_private_bfd_data  (ibfd, obfd)
 397      bfd *ibfd;
 398      bfd *obfd;
 399 {
 400   /* Check if both are the same targets.  */
 401   if (ibfd->xvec != obfd->xvec)
 402     return TRUE;
 403
 404   /* Check if both have a valid stub.  */
 405   if (bfd_coff_go32stub (ibfd) == NULL
 406       || bfd_coff_go32stub (obfd) == NULL)
 407     return TRUE;
 408
 409   /* Now copy the stub.  */
 410   memcpy (bfd_coff_go32stub (obfd), bfd_coff_go32stub (ibfd), STUBSIZE);
 411
 412   return TRUE;
 413 }