contrib/binutils/gas/config/obj-ecoff.c

   1 /* ECOFF object file format.
   2    Copyright (C) 1993, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3    Contributed by Cygnus Support.
   4    This file was put together by Ian Lance Taylor <ian@cygnus.com>.
   5
   6    This file is part of GAS.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 #define OBJ_HEADER "obj-ecoff.h"
  24 #include "as.h"
  25 #include "coff/internal.h"
  26 #include "bfd/libcoff.h"
  27 #include "bfd/libecoff.h"
  28
  29 /* Almost all of the ECOFF support is actually in ecoff.c in the main
  30    gas directory.  This file mostly just arranges to call that one at
  31    the right times.  */
  32
  33 static int ecoff_sec_sym_ok_for_reloc PARAMS ((asection *));
  34 static void obj_ecoff_frob_symbol PARAMS ((symbolS *, int *));
  35 static void ecoff_pop_insert PARAMS ((void));
  36
  37 /* These are the pseudo-ops we support in this file.  Only those
  38    relating to debugging information are supported here.
  39
  40    The following pseudo-ops from the Kane and Heinrich MIPS book
  41    should be defined here, but are currently unsupported: .aent,
  42    .bgnb, .endb, .verstamp, .vreg.
  43
  44    The following pseudo-ops from the Kane and Heinrich MIPS book are
  45    MIPS CPU specific, and should be defined by tc-mips.c: .alias,
  46    .extern, .galive, .gjaldef, .gjrlive, .livereg, .noalias, .option,
  47    .rdata, .sdata, .set.
  48
  49    The following pseudo-ops from the Kane and Heinrich MIPS book are
  50    not MIPS CPU specific, but are also not ECOFF specific.  I have
  51    only listed the ones which are not already in read.c.  It's not
  52    completely clear where these should be defined, but tc-mips.c is
  53    probably the most reasonable place: .asciiz, .asm0, .endr, .err,
  54    .half, .lab, .repeat, .struct, .weakext.  */
  55
  56 const pseudo_typeS obj_pseudo_table[] =
  57 {
  58   /* COFF style debugging information. .ln is not used; .loc is used
  59      instead.  */
  60   { "def",      ecoff_directive_def,    0 },
  61   { "dim",      ecoff_directive_dim,    0 },
  62   { "endef",    ecoff_directive_endef,  0 },
  63   { "file",     ecoff_directive_file,   0 },
  64   { "scl",      ecoff_directive_scl,    0 },
  65   { "size",     ecoff_directive_size,   0 },
  66   { "esize",    ecoff_directive_size,   0 },
  67   { "tag",      ecoff_directive_tag,    0 },
  68   { "type",     ecoff_directive_type,   0 },
  69   { "etype",    ecoff_directive_type,   0 },
  70   { "val",      ecoff_directive_val,    0 },
  71
  72   /* ECOFF specific debugging information.  */
  73   { "begin",    ecoff_directive_begin,  0 },
  74   { "bend",     ecoff_directive_bend,   0 },
  75   { "end",      ecoff_directive_end,    0 },
  76   { "ent",      ecoff_directive_ent,    0 },
  77   { "fmask",    ecoff_directive_fmask,  0 },
  78   { "frame",    ecoff_directive_frame,  0 },
  79   { "loc",      ecoff_directive_loc,    0 },
  80   { "mask",     ecoff_directive_mask,   0 },
  81
  82   /* Other ECOFF directives.  */
  83   { "extern",   ecoff_directive_extern, 0 },
  84   { "weakext",  ecoff_directive_weakext, 0 },
  85
  86   /* These are used on Irix.  I don't know how to implement them.  */
  87   { "bgnb",     s_ignore,               0 },
  88   { "endb",     s_ignore,               0 },
  89   { "verstamp", s_ignore,               0 },
  90
  91   /* Sentinel.  */
  92   { NULL }
  93 };
  94
  95 /* Swap out the symbols and debugging information for BFD.  */
  96
  97 void
  98 ecoff_frob_file ()
  99 {
 100   const struct ecoff_debug_swap * const debug_swap
 101     = &ecoff_backend (stdoutput)->debug_swap;
 102   bfd_vma addr;
 103   asection *sec;
 104   HDRR *hdr;
 105   char *buf;
 106   char *set;
 107
 108   /* Set the section VMA values.  We force the .sdata and .sbss
 109      sections to the end to ensure that their VMA addresses are close
 110      together so that the GP register can address both of them.  We
 111      put the .bss section after the .sbss section.
 112
 113      Also, for the Alpha, we must sort the sections, to make sure they
 114      appear in the output file in the correct order.  (Actually, maybe
 115      this is a job for BFD.  But the VMAs computed would be out of
 116      whack if we computed them given our initial, random ordering.
 117      It's possible that that wouldn't break things; I could do some
 118      experimenting sometime and find out.
 119
 120      This output ordering of sections is magic, on the Alpha, at
 121      least.  The .lita section must come before .lit8 and .lit4,
 122      otherwise the OSF/1 linker may silently trash the .lit{4,8}
 123      section contents.  Also, .text must preceed .rdata.  These differ
 124      from the order described in some parts of the DEC OSF/1 Assembly
 125      Language Programmer's Guide, but that order doesn't seem to work
 126      with their linker.
 127
 128      I don't know if section ordering on the MIPS is important.  */
 129
 130   static const char *const names[] = {
 131     /* text segment */
 132     ".text", ".rdata", ".init", ".fini",
 133     /* data segment */
 134     ".data", ".lita", ".lit8", ".lit4", ".sdata", ".got",
 135     /* bss segment */
 136     ".sbss", ".bss",
 137   };
 138 #define n_names (sizeof (names) / sizeof (names[0]))
 139
 140   addr = 0;
 141   {
 142     /* Sections that match names, order to be straightened out later.  */
 143     asection *secs[n_names];
 144     /* Linked list of sections with non-matching names.  Random ordering.  */
 145     asection *other_sections = 0;
 146     /* Pointer to next section, since we're destroying the original
 147        ordering.  */
 148     asection *next;
 149
 150     int i;
 151
 152     for (i = 0; i < n_names; i++)
 153       secs[i] = 0;
 154     for (sec = stdoutput->sections; sec != (asection *) NULL; sec = next)
 155       {
 156         next = sec->next;
 157         for (i = 0; i < n_names; i++)
 158           if (!strcmp (sec->name, names[i]))
 159             {
 160               secs[i] = sec;
 161               break;
 162             }
 163         if (i == n_names)
 164           {
 165             bfd_set_section_vma (stdoutput, sec, addr);
 166             addr += bfd_section_size (stdoutput, sec);
 167             sec->next = other_sections;
 168             other_sections = sec;
 169           }
 170       }
 171     for (i = 0; i < n_names; i++)
 172       if (secs[i])
 173         {
 174           sec = secs[i];
 175           bfd_set_section_vma (stdoutput, sec, addr);
 176           addr += bfd_section_size (stdoutput, sec);
 177         }
 178     for (i = n_names - 1; i >= 0; i--)
 179       if (secs[i])
 180         {
 181           sec = secs[i];
 182           sec->next = other_sections;
 183           other_sections = sec;
 184         }
 185     stdoutput->sections = other_sections;
 186   }
 187
 188   /* Build the ECOFF debugging information.  */
 189   assert (ecoff_data (stdoutput) != 0);
 190   hdr = &ecoff_data (stdoutput)->debug_info.symbolic_header;
 191   ecoff_build_debug (hdr, &buf, debug_swap);
 192
 193   /* Finish up the ecoff_tdata structure.  */
 194   set = buf;
 195 #define SET(ptr, count, type, size) \
 196   if (hdr->count == 0) \
 197     ecoff_data (stdoutput)->debug_info.ptr = (type) NULL; \
 198   else \
 199     { \
 200       ecoff_data (stdoutput)->debug_info.ptr = (type) set; \
 201       set += hdr->count * size; \
 202     }
 203
 204   SET (line, cbLine, unsigned char *, sizeof (unsigned char));
 205   SET (external_dnr, idnMax, PTR, debug_swap->external_dnr_size);
 206   SET (external_pdr, ipdMax, PTR, debug_swap->external_pdr_size);
 207   SET (external_sym, isymMax, PTR, debug_swap->external_sym_size);
 208   SET (external_opt, ioptMax, PTR, debug_swap->external_opt_size);
 209   SET (external_aux, iauxMax, union aux_ext *, sizeof (union aux_ext));
 210   SET (ss, issMax, char *, sizeof (char));
 211   SET (ssext, issExtMax, char *, sizeof (char));
 212   SET (external_rfd, crfd, PTR, debug_swap->external_rfd_size);
 213   SET (external_fdr, ifdMax, PTR, debug_swap->external_fdr_size);
 214   SET (external_ext, iextMax, PTR, debug_swap->external_ext_size);
 215
 216 #undef SET
 217
 218   /* Fill in the register masks.  */
 219   {
 220     unsigned long gprmask = 0;
 221     unsigned long fprmask = 0;
 222     unsigned long *cprmask = NULL;
 223
 224 #ifdef TC_MIPS
 225     /* Fill in the MIPS register masks.  It's probably not worth
 226        setting up a generic interface for this.  */
 227     gprmask = mips_gprmask;
 228     cprmask = mips_cprmask;
 229 #endif
 230
 231 #ifdef TC_ALPHA
 232     alpha_frob_ecoff_data ();
 233
 234     if (! bfd_ecoff_set_gp_value (stdoutput, alpha_gp_value))
 235       as_fatal ("Can't set GP value");
 236
 237     gprmask = alpha_gprmask;
 238     fprmask = alpha_fprmask;
 239 #endif
 240
 241     if (! bfd_ecoff_set_regmasks (stdoutput, gprmask, fprmask, cprmask))
 242       as_fatal ("Can't set register masks");
 243   }
 244 }
 245
 246 /* This is called by the ECOFF code to set the external information
 247    for a symbol.  We just pass it on to BFD, which expects the swapped
 248    information to be stored in the native field of the symbol.  */
 249
 250 void
 251 obj_ecoff_set_ext (sym, ext)
 252      symbolS *sym;
 253      EXTR *ext;
 254 {
 255   const struct ecoff_debug_swap * const debug_swap
 256     = &ecoff_backend (stdoutput)->debug_swap;
 257   ecoff_symbol_type *esym;
 258
 259   know (bfd_asymbol_flavour (sym->bsym) == bfd_target_ecoff_flavour);
 260   esym = ecoffsymbol (sym->bsym);
 261   esym->local = false;
 262   esym->native = xmalloc (debug_swap->external_ext_size);
 263   (*debug_swap->swap_ext_out) (stdoutput, ext, esym->native);
 264 }
 265
 266 static int
 267 ecoff_sec_sym_ok_for_reloc (sec)
 268      asection *sec;
 269 {
 270   return 1;
 271 }
 272
 273 static void
 274 obj_ecoff_frob_symbol (sym, puntp)
 275      symbolS *sym;
 276      int *puntp;
 277 {
 278   ecoff_frob_symbol (sym);
 279 }
 280
 281 static void
 282 ecoff_pop_insert ()
 283 {
 284   pop_insert (obj_pseudo_table);
 285 }
 286
 287 const struct format_ops ecoff_format_ops =
 288 {
 289   bfd_target_ecoff_flavour,
 290   0,
 291   1,
 292   obj_ecoff_frob_symbol,
 293   ecoff_frob_file,
 294   0,
 295   0, 0,
 296   0, 0,
 297   0,
 298   ecoff_generate_asm_lineno,
 299   ecoff_stab,
 300   ecoff_sec_sym_ok_for_reloc,
 301   ecoff_pop_insert,
 302   ecoff_set_ext,
 303   ecoff_read_begin_hook,
 304   ecoff_symbol_new_hook,
 305 };