gas/config/obj-bout.c

   1 /* b.out object file format
   2    Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   3
   4    This file is part of GAS, the GNU Assembler.
   5
   6    GAS is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as
   8    published by the Free Software Foundation; either version 2,
   9    or (at your option) any later version.
  10
  11    GAS is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  14    the GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public
  17    License along with GAS; see the file COPYING.  If not, write
  18    to the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  19
  20 #include "as.h"
  21 #include "obstack.h"
  22 #include "aout/stab_gnu.h"
  23 const short /* in: segT   out: N_TYPE bits */
  24     seg_N_TYPE[] = {
  25             N_ABS,
  26             N_TEXT,
  27             N_DATA,
  28             N_BSS,
  29             N_UNDF, /* unknown */
  30             N_UNDF, /* absent */
  31             N_UNDF, /* pass1 */
  32             N_UNDF, /* error */
  33             N_UNDF, /* bignum/flonum */
  34             N_UNDF, /* difference */
  35             N_REGISTER, /* register */
  36     };
  37
  38 const segT N_TYPE_seg [N_TYPE+2] = {    /* N_TYPE == 0x1E = 32-2 */
  39         SEG_UNKNOWN,                    /* N_UNDF == 0 */
  40         SEG_GOOF,
  41         SEG_ABSOLUTE,                   /* N_ABS == 2 */
  42         SEG_GOOF,
  43         SEG_TEXT,                       /* N_TEXT == 4 */
  44         SEG_GOOF,
  45         SEG_DATA,                       /* N_DATA == 6 */
  46         SEG_GOOF,
  47         SEG_BSS,                        /* N_BSS == 8 */
  48         SEG_GOOF,
  49         SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  50         SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  51         SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF,
  52         SEG_REGISTER,                   /* dummy N_REGISTER for regs = 30 */
  53         SEG_GOOF,
  54 };
  55
  56 #if __STDC__ == 1
  57 static void obj_bout_stab(int what);
  58 static void obj_bout_line(void);
  59 static void obj_bout_desc(void);
  60 #else /* not __STDC__ */
  61 static void obj_bout_desc();
  62 static void obj_bout_stab();
  63 static void obj_bout_line();
  64 #endif /* not __STDC__ */
  65
  66 const pseudo_typeS obj_pseudo_table[] = {
  67         /* stabs (aka a.out aka b.out directives for debug symbols) */
  68         { "desc",       obj_bout_desc,          0       }, /* def */
  69         { "line",       obj_bout_line,          0       }, /* source code line number */
  70         { "stabd",      obj_bout_stab,          'd'     }, /* stabs */
  71         { "stabn",      obj_bout_stab,          'n'     }, /* stabs */
  72         { "stabs",      obj_bout_stab,          's'     }, /* stabs */
  73
  74         /* coff debugging directives.  Currently ignored silently */
  75         { "def",        s_ignore,               0 },
  76         { "dim",        s_ignore,               0 },
  77         { "endef",      s_ignore,               0 },
  78         { "ln",         s_ignore,               0 },
  79         { "scl",        s_ignore,               0 },
  80         { "size",       s_ignore,               0 },
  81         { "tag",        s_ignore,               0 },
  82         { "type",       s_ignore,               0 },
  83         { "val",        s_ignore,               0 },
  84
  85         /* other stuff we don't handle */
  86         { "ABORT",      s_ignore,               0 },
  87         { "ident",      s_ignore,               0 },
  88
  89         { NULL} /* end sentinel */
  90 }; /* obj_pseudo_table */
  91
  92 /* Relocation. */
  93
  94 /*
  95  *              emit_relocations()
  96  *
  97  * Crawl along a fixS chain. Emit the segment's relocations.
  98  */
  99 void obj_emit_relocations(where, fixP, segment_address_in_file)
 100 char **where;
 101 fixS *fixP;     /* Fixup chain for this segment. */
 102 relax_addressT segment_address_in_file;
 103 {
 104         for (; fixP; fixP = fixP->fx_next) {
 105                 if (fixP->fx_addsy != NULL
 106                     || fixP->fx_r_type != NO_RELOC) {
 107                         tc_bout_fix_to_chars(*where, fixP, segment_address_in_file);
 108                         *where += sizeof(struct relocation_info);
 109                 } /* if there's a symbol */
 110         } /* for each fixup */
 111
 112 } /* emit_relocations() */
 113
 114 /* Aout file generation & utilities */
 115
 116 /* Convert a lvalue to machine dependent data */
 117 void obj_header_append(where, headers)
 118 char **where;
 119 object_headers *headers;
 120 {
 121         /* Always leave in host byte order */
 122
 123         headers->header.a_talign = section_alignment[SEG_TEXT];
 124
 125         if (headers->header.a_talign < 2){
 126                 headers->header.a_talign = 2;
 127         } /* force to at least 2 */
 128
 129         headers->header.a_dalign = section_alignment[SEG_DATA];
 130         headers->header.a_balign = section_alignment[SEG_BSS];
 131
 132         headers->header.a_tload = 0;
 133         headers->header.a_dload = md_section_align(SEG_DATA, H_GET_TEXT_SIZE(headers));
 134
 135         headers->header.a_relaxable = linkrelax;
 136
 137         append(where, (char *) &headers->header, sizeof(headers->header));
 138 } /* a_header_append() */
 139
 140 void obj_symbol_to_chars(where, symbolP)
 141 char **where;
 142 symbolS *symbolP;
 143 {
 144         /* leave in host byte order */
 145         append(where, (char *)&symbolP->sy_symbol, sizeof(obj_symbol_type));
 146 } /* obj_symbol_to_chars() */
 147
 148 void obj_emit_symbols(where, symbol_rootP)
 149 char **where;
 150 symbolS *symbol_rootP;
 151 {
 152         symbolS *       symbolP;
 153
 154         /*
 155          * Emit all symbols left in the symbol chain.
 156          */
 157         for(symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
 158                 /* Used to save the offset of the name. It is used to point
 159                    to the string in memory but must be a file offset. */
 160                 char *temp;
 161
 162                 temp = S_GET_NAME(symbolP);
 163                 S_SET_OFFSET(symbolP, symbolP->sy_name_offset);
 164
 165                 /* Any symbol still undefined and is not a dbg symbol is made N_EXT. */
 166                 if (!S_IS_DEBUG(symbolP) && !S_IS_DEFINED(symbolP)) S_SET_EXTERNAL(symbolP);
 167
 168                 obj_symbol_to_chars(where, symbolP);
 169                 S_SET_NAME(symbolP,temp);
 170         }
 171 } /* emit_symbols() */
 172
 173 void obj_symbol_new_hook(symbolP)
 174 symbolS *symbolP;
 175 {
 176         S_SET_OTHER(symbolP, 0);
 177         S_SET_DESC(symbolP, 0);
 178         return;
 179 } /* obj_symbol_new_hook() */
 180
 181 static void obj_bout_line() {
 182         /* Assume delimiter is part of expression. */
 183         /* BSD4.2 as fails with delightful bug, so we */
 184         /* are not being incompatible here. */
 185         new_logical_line ((char *)NULL, (int)(get_absolute_expression ()));
 186         demand_empty_rest_of_line();
 187 } /* obj_bout_line() */
 188
 189 /*
 190  *                      stab()
 191  *
 192  * Handle .stabX directives, which used to be open-coded.
 193  * So much creeping featurism overloaded the semantics that we decided
 194  * to put all .stabX thinking in one place. Here.
 195  *
 196  * We try to make any .stabX directive legal. Other people's AS will often
 197  * do assembly-time consistency checks: eg assigning meaning to n_type bits
 198  * and "protecting" you from setting them to certain values. (They also zero
 199  * certain bits before emitting symbols. Tut tut.)
 200  *
 201  * If an expression is not absolute we either gripe or use the relocation
 202  * information. Other people's assemblers silently forget information they
 203  * don't need and invent information they need that you didn't supply.
 204  *
 205  * .stabX directives always make a symbol table entry. It may be junk if
 206  * the rest of your .stabX directive is malformed.
 207  */
 208 static void obj_bout_stab(what)
 209 int what;
 210 {
 211         register symbolS *      symbolP = 0;
 212         register char * string;
 213         int saved_type = 0;
 214         int length;
 215         int goof;       /* TRUE if we have aborted. */
 216         long longint;
 217
 218         /*
 219          * Enter with input_line_pointer pointing past .stabX and any following
 220          * whitespace.
 221          */
 222         goof = 0; /* JF who forgot this?? */
 223         if (what == 's') {
 224                 string = demand_copy_C_string(& length);
 225                 SKIP_WHITESPACE();
 226                 if (*input_line_pointer == ',')
 227                     input_line_pointer ++;
 228                 else {
 229                         as_bad("I need a comma after symbol's name");
 230                         goof = 1;
 231                 }
 232         } else
 233             string = "";
 234
 235         /*
 236          * Input_line_pointer->after ','.  String->symbol name.
 237          */
 238         if (!goof) {
 239                 symbolP = symbol_new(string,
 240                                      SEG_UNKNOWN,
 241                                      0,
 242                                      (struct frag *)0);
 243                 switch (what) {
 244                 case 'd':
 245                         S_SET_NAME(symbolP,NULL); /* .stabd feature. */
 246                         S_SET_VALUE(symbolP,obstack_next_free(&frags) -
 247                                     frag_now->fr_literal);
 248                         symbolP->sy_frag = frag_now;
 249                         break;
 250
 251                 case 'n':
 252                         symbolP->sy_frag = &zero_address_frag;
 253                         break;
 254
 255                 case 's':
 256                         symbolP->sy_frag = & zero_address_frag;
 257                         break;
 258
 259                 default:
 260                         BAD_CASE(what);
 261                         break;
 262                 }
 263                 if (get_absolute_expression_and_terminator(& longint) == ',')
 264                     symbolP->sy_symbol.n_type = saved_type = longint;
 265                 else {
 266                         as_bad("I want a comma after the n_type expression");
 267                         goof = 1;
 268                         input_line_pointer--; /* Backup over a non-',' char. */
 269                 }
 270         }
 271         if (! goof) {
 272                 if (get_absolute_expression_and_terminator (& longint) == ',')
 273                     S_SET_OTHER(symbolP,longint);
 274                 else {
 275                         as_bad("I want a comma after the n_other expression");
 276                         goof = 1;
 277                         input_line_pointer--; /* Backup over a non-',' char. */
 278                 }
 279         }
 280         if (! goof) {
 281                 S_SET_DESC(symbolP, get_absolute_expression ());
 282                 if (what == 's' || what == 'n') {
 283                         if (* input_line_pointer != ',') {
 284                                 as_bad("I want a comma after the n_desc expression");
 285                                 goof = 1;
 286                         } else {
 287                                 input_line_pointer ++;
 288                         }
 289                 }
 290         }
 291         if ((! goof) && (what=='s' || what=='n')) {
 292                 pseudo_set(symbolP);
 293                 symbolP->sy_symbol.n_type = saved_type;
 294         }
 295 #ifndef NO_LISTING
 296         {
 297                 extern int listing;
 298
 299                 if (listing && !goof)
 300                     {
 301                             if (symbolP->sy_symbol.n_type == N_SLINE)
 302                                 {
 303
 304                                         listing_source_line(symbolP->sy_symbol.n_desc);
 305                                 }
 306                             else if (symbolP->sy_symbol.n_type == N_SO
 307                                      || symbolP->sy_symbol.n_type == N_SOL)
 308                                 {
 309                                         listing_source_file(string);
 310                                 }
 311                     }
 312         }
 313
 314 #endif
 315
 316         if (goof)
 317             ignore_rest_of_line ();
 318         else
 319             demand_empty_rest_of_line ();
 320 } /* obj_bout_stab() */
 321
 322 static void obj_bout_desc() {
 323         register char *name;
 324         register char c;
 325         register char *p;
 326         register symbolS *      symbolP;
 327         register int temp;
 328
 329         /*
 330          * Frob invented at RMS' request. Set the n_desc of a symbol.
 331          */
 332         name = input_line_pointer;
 333         c = get_symbol_end();
 334         p = input_line_pointer;
 335         * p = c;
 336         SKIP_WHITESPACE();
 337         if (*input_line_pointer != ',') {
 338                 *p = 0;
 339                 as_bad("Expected comma after name \"%s\"", name);
 340                 *p = c;
 341                 ignore_rest_of_line();
 342         } else {
 343                 input_line_pointer ++;
 344                 temp = get_absolute_expression ();
 345                 *p = 0;
 346                 symbolP = symbol_find_or_make(name);
 347                 *p = c;
 348                 S_SET_DESC(symbolP,temp);
 349         }
 350         demand_empty_rest_of_line();
 351 } /* obj_bout_desc() */
 352
 353 void obj_read_begin_hook() {
 354         return;
 355 } /* obj_read_begin_hook() */
 356
 357 void obj_crawl_symbol_chain(headers)
 358 object_headers *headers;
 359 {
 360         symbolS **symbolPP;
 361         symbolS *symbolP;
 362         int symbol_number = 0;
 363
 364         /* JF deal with forward references first... */
 365         for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
 366                 if (symbolP->sy_forward) {
 367                         S_SET_VALUE(symbolP, S_GET_VALUE(symbolP)
 368                                     + S_GET_VALUE(symbolP->sy_forward)
 369                                     + symbolP->sy_forward->sy_frag->fr_address);
 370
 371                         symbolP->sy_forward=0;
 372                 } /* if it has a forward reference */
 373         } /* walk the symbol chain */
 374
 375         tc_crawl_symbol_chain(headers);
 376
 377         symbolPP = & symbol_rootP;      /*->last symbol chain link. */
 378         while ((symbolP  = *symbolPP) != NULL) {
 379                 if (flagseen['R'] && (S_GET_SEGMENT(symbolP) == SEG_DATA)) {
 380                         S_SET_SEGMENT(symbolP, SEG_TEXT);
 381                 } /* if pusing data into text */
 382
 383                 S_SET_VALUE(symbolP, S_GET_VALUE(symbolP) + symbolP->sy_frag->fr_address);
 384
 385                 /* OK, here is how we decide which symbols go out into the
 386                    brave new symtab.  Symbols that do are:
 387
 388                    * symbols with no name (stabd's?)
 389                    * symbols with debug info in their N_TYPE
 390
 391                    Symbols that don't are:
 392                    * symbols that are registers
 393                    * symbols with \1 as their 3rd character (numeric labels)
 394                    * "local labels" as defined by S_LOCAL_NAME(name)
 395                    if the -L switch was passed to gas.
 396
 397                    All other symbols are output.  We complain if a deleted
 398                    symbol was marked external. */
 399
 400
 401                 if (1
 402                     && !S_IS_REGISTER(symbolP)
 403                     && (!S_GET_NAME(symbolP)
 404                         || S_IS_DEBUG(symbolP)
 405 #ifdef TC_I960
 406                         /* FIXME-SOON this ifdef seems highly dubious to me.  xoxorich. */
 407                         || !S_IS_DEFINED(symbolP)
 408                         || S_IS_EXTERNAL(symbolP)
 409 #endif /* TC_I960 */
 410                         || (S_GET_NAME(symbolP)[0] != '\001' && (flagseen ['L'] || ! S_LOCAL_NAME(symbolP))))) {
 411                         symbolP->sy_number = symbol_number++;
 412
 413                         /* The + 1 after strlen account for the \0 at the
 414                            end of each string */
 415                         if (!S_IS_STABD(symbolP)) {
 416                                 /* Ordinary case. */
 417                                 symbolP->sy_name_offset = string_byte_count;
 418                                 string_byte_count += strlen(S_GET_NAME(symbolP)) + 1;
 419                         }
 420                         else    /* .Stabd case. */
 421                             symbolP->sy_name_offset = 0;
 422                         symbolPP = &(symbol_next(symbolP));
 423                 } else {
 424                         if (S_IS_EXTERNAL(symbolP) || !S_IS_DEFINED(symbolP)) {
 425                                 as_bad("Local symbol %s never defined", S_GET_NAME(symbolP));
 426                         } /* oops. */
 427
 428                         /* Unhook it from the chain */
 429                         *symbolPP = symbol_next(symbolP);
 430                 } /* if this symbol should be in the output */
 431         } /* for each symbol */
 432
 433         H_SET_SYMBOL_TABLE_SIZE(headers, symbol_number);
 434
 435         return;
 436 } /* obj_crawl_symbol_chain() */
 437
 438 /*
 439  * Find strings by crawling along symbol table chain.
 440  */
 441
 442 void obj_emit_strings(where)
 443 char **where;
 444 {
 445         symbolS *symbolP;
 446
 447 #ifdef CROSS_COMPILE
 448         /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
 449         md_number_to_chars(*where, string_byte_count, sizeof(string_byte_count));
 450         *where += sizeof(string_byte_count);
 451 #else /* CROSS_COMPILE */
 452         append(where, (char *) &string_byte_count, (unsigned long) sizeof(string_byte_count));
 453 #endif /* CROSS_COMPILE */
 454
 455         for(symbolP = symbol_rootP; symbolP; symbolP = symbol_next(symbolP)) {
 456                 if(S_GET_NAME(symbolP))
 457                     append(where, S_GET_NAME(symbolP), (unsigned long)(strlen (S_GET_NAME(symbolP)) + 1));
 458         } /* walk symbol chain */
 459
 460         return;
 461 } /* obj_emit_strings() */
 462
 463 /*
 464  * Local Variables:
 465  * comment-column: 0
 466  * fill-column: 131
 467  * End:
 468  */
 469
 470 /* end of obj-bout.c */