gas/config/obj-ecoff.c

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