obj-aout.c revision 33965
1/* a.out object file format 2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 1996 3 Free Software Foundation, Inc. 4 5This file is part of GAS, the GNU Assembler. 6 7GAS is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as 9published by the Free Software Foundation; either version 2, 10or (at your option) any later version. 11 12GAS is distributed in the hope that it will be useful, but 13WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 15the GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public 18License along with GAS; see the file COPYING. If not, write 19to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21#include "as.h" 22#ifdef BFD_ASSEMBLER 23#undef NO_RELOC 24#include "aout/aout64.h" 25#endif 26#include "obstack.h" 27 28#ifndef BFD_ASSEMBLER 29/* in: segT out: N_TYPE bits */ 30const short seg_N_TYPE[] = 31{ 32 N_ABS, 33 N_TEXT, 34 N_DATA, 35 N_BSS, 36 N_UNDF, /* unknown */ 37 N_UNDF, /* error */ 38 N_UNDF, /* expression */ 39 N_UNDF, /* debug */ 40 N_UNDF, /* ntv */ 41 N_UNDF, /* ptv */ 42 N_REGISTER, /* register */ 43}; 44 45const segT N_TYPE_seg[N_TYPE + 2] = 46{ /* N_TYPE == 0x1E = 32-2 */ 47 SEG_UNKNOWN, /* N_UNDF == 0 */ 48 SEG_GOOF, 49 SEG_ABSOLUTE, /* N_ABS == 2 */ 50 SEG_GOOF, 51 SEG_TEXT, /* N_TEXT == 4 */ 52 SEG_GOOF, 53 SEG_DATA, /* N_DATA == 6 */ 54 SEG_GOOF, 55 SEG_BSS, /* N_BSS == 8 */ 56 SEG_GOOF, 57 SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, 58 SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, 59 SEG_GOOF, SEG_GOOF, SEG_GOOF, SEG_GOOF, 60 SEG_REGISTER, /* dummy N_REGISTER for regs = 30 */ 61 SEG_GOOF, 62}; 63#endif 64 65static void obj_aout_line PARAMS ((int)); 66static void obj_aout_weak PARAMS ((int)); 67static void obj_aout_type PARAMS ((int)); 68 69const pseudo_typeS obj_pseudo_table[] = 70{ 71 {"line", obj_aout_line, 0}, /* source code line number */ 72 {"ln", obj_aout_line, 0}, /* coff line number that we use anyway */ 73 74 {"weak", obj_aout_weak, 0}, /* mark symbol as weak. */ 75 76 {"type", obj_aout_type, 0}, 77 78 /* coff debug pseudos (ignored) */ 79 {"def", s_ignore, 0}, 80 {"dim", s_ignore, 0}, 81 {"endef", s_ignore, 0}, 82 {"ident", s_ignore, 0}, 83 {"line", s_ignore, 0}, 84 {"ln", s_ignore, 0}, 85 {"scl", s_ignore, 0}, 86 {"size", s_ignore, 0}, 87 {"tag", s_ignore, 0}, 88 {"val", s_ignore, 0}, 89 {"version", s_ignore, 0}, 90 91 {"optim", s_ignore, 0}, /* For sun386i cc (?) */ 92 93 /* other stuff */ 94 {"ABORT", s_abort, 0}, 95 96 {NULL} /* end sentinel */ 97}; /* obj_pseudo_table */ 98 99 100#ifdef BFD_ASSEMBLER 101 102void 103obj_aout_frob_symbol (sym, punt) 104 symbolS *sym; 105 int *punt; 106{ 107 flagword flags; 108 asection *sec; 109 int desc, type, other; 110 111 flags = sym->bsym->flags; 112 desc = S_GET_DESC (sym); 113 type = S_GET_TYPE (sym); 114 other = S_GET_OTHER (sym); 115 sec = sym->bsym->section; 116 117 /* Only frob simple symbols this way right now. */ 118 if (! (type & ~ (N_TYPE | N_EXT))) 119 { 120 if (type == (N_UNDF | N_EXT) 121 && sec == &bfd_abs_section) 122 sym->bsym->section = sec = bfd_und_section_ptr; 123 124 if ((type & N_TYPE) != N_INDR 125 && (type & N_TYPE) != N_SETA 126 && (type & N_TYPE) != N_SETT 127 && (type & N_TYPE) != N_SETD 128 && (type & N_TYPE) != N_SETB 129 && type != N_WARNING 130 && (sec == &bfd_abs_section 131 || sec == &bfd_und_section)) 132 return; 133 if (flags & BSF_EXPORT) 134 type |= N_EXT; 135 136 switch (type & N_TYPE) 137 { 138 case N_SETA: 139 case N_SETT: 140 case N_SETD: 141 case N_SETB: 142 /* Set the debugging flag for constructor symbols so that 143 BFD leaves them alone. */ 144 sym->bsym->flags |= BSF_DEBUGGING; 145 146 /* You can't put a common symbol in a set. The way a set 147 element works is that the symbol has a definition and a 148 name, and the linker adds the definition to the set of 149 that name. That does not work for a common symbol, 150 because the linker can't tell which common symbol the 151 user means. FIXME: Using as_bad here may be 152 inappropriate, since the user may want to force a 153 particular type without regard to the semantics of sets; 154 on the other hand, we certainly don't want anybody to be 155 mislead into thinking that their code will work. */ 156 if (S_IS_COMMON (sym)) 157 as_bad ("Attempt to put a common symbol into set %s", 158 S_GET_NAME (sym)); 159 /* Similarly, you can't put an undefined symbol in a set. */ 160 else if (! S_IS_DEFINED (sym)) 161 as_bad ("Attempt to put an undefined symbol into set %s", 162 S_GET_NAME (sym)); 163 164 break; 165 case N_INDR: 166 /* Put indirect symbols in the indirect section. */ 167 sym->bsym->section = bfd_ind_section_ptr; 168 sym->bsym->flags |= BSF_INDIRECT; 169 if (type & N_EXT) 170 { 171 sym->bsym->flags |= BSF_EXPORT; 172 sym->bsym->flags &=~ BSF_LOCAL; 173 } 174 break; 175 case N_WARNING: 176 /* Mark warning symbols. */ 177 sym->bsym->flags |= BSF_WARNING; 178 break; 179 } 180 } 181 else 182 { 183 sym->bsym->flags |= BSF_DEBUGGING; 184 } 185 186 S_SET_TYPE (sym, type); 187 188 /* Double check weak symbols. */ 189 if (sym->bsym->flags & BSF_WEAK) 190 { 191 if (S_IS_COMMON (sym)) 192 as_bad ("Symbol `%s' can not be both weak and common", 193 S_GET_NAME (sym)); 194 } 195} 196 197void 198obj_aout_frob_file () 199{ 200 /* Relocation processing may require knowing the VMAs of the sections. 201 Since writing to a section will cause the BFD back end to compute the 202 VMAs, fake it out here.... */ 203 bfd_byte b = 0; 204 boolean x = true; 205 if (bfd_section_size (stdoutput, text_section) != 0) 206 { 207 x = bfd_set_section_contents (stdoutput, text_section, &b, (file_ptr) 0, 208 (bfd_size_type) 1); 209 } 210 else if (bfd_section_size (stdoutput, data_section) != 0) 211 { 212 x = bfd_set_section_contents (stdoutput, data_section, &b, (file_ptr) 0, 213 (bfd_size_type) 1); 214 } 215 assert (x == true); 216} 217 218#else 219 220/* Relocation. */ 221 222/* 223 * emit_relocations() 224 * 225 * Crawl along a fixS chain. Emit the segment's relocations. 226 */ 227void 228obj_emit_relocations (where, fixP, segment_address_in_file) 229 char **where; 230 fixS *fixP; /* Fixup chain for this segment. */ 231 relax_addressT segment_address_in_file; 232{ 233 for (; fixP; fixP = fixP->fx_next) 234 if (fixP->fx_done == 0) 235 { 236 symbolS *sym; 237 238 sym = fixP->fx_addsy; 239 while (sym->sy_value.X_op == O_symbol 240 && (! S_IS_DEFINED (sym) || S_IS_COMMON (sym))) 241 sym = sym->sy_value.X_add_symbol; 242 fixP->fx_addsy = sym; 243 244 if (! sym->sy_resolved && ! S_IS_DEFINED (sym)) 245 { 246 char *file; 247 unsigned int line; 248 249 if (expr_symbol_where (sym, &file, &line)) 250 as_bad_where (file, line, "unresolved relocation"); 251 else 252 as_bad ("bad relocation: symbol `%s' not in symbol table", 253 S_GET_NAME (sym)); 254 } 255 256 tc_aout_fix_to_chars (*where, fixP, segment_address_in_file); 257 *where += md_reloc_size; 258 } 259} 260 261#ifndef obj_header_append 262/* Aout file generation & utilities */ 263void 264obj_header_append (where, headers) 265 char **where; 266 object_headers *headers; 267{ 268 tc_headers_hook (headers); 269 270#ifdef CROSS_COMPILE 271 md_number_to_chars (*where, headers->header.a_info, sizeof (headers->header.a_info)); 272 *where += sizeof (headers->header.a_info); 273 md_number_to_chars (*where, headers->header.a_text, sizeof (headers->header.a_text)); 274 *where += sizeof (headers->header.a_text); 275 md_number_to_chars (*where, headers->header.a_data, sizeof (headers->header.a_data)); 276 *where += sizeof (headers->header.a_data); 277 md_number_to_chars (*where, headers->header.a_bss, sizeof (headers->header.a_bss)); 278 *where += sizeof (headers->header.a_bss); 279 md_number_to_chars (*where, headers->header.a_syms, sizeof (headers->header.a_syms)); 280 *where += sizeof (headers->header.a_syms); 281 md_number_to_chars (*where, headers->header.a_entry, sizeof (headers->header.a_entry)); 282 *where += sizeof (headers->header.a_entry); 283 md_number_to_chars (*where, headers->header.a_trsize, sizeof (headers->header.a_trsize)); 284 *where += sizeof (headers->header.a_trsize); 285 md_number_to_chars (*where, headers->header.a_drsize, sizeof (headers->header.a_drsize)); 286 *where += sizeof (headers->header.a_drsize); 287 288#else /* CROSS_COMPILE */ 289 290 append (where, (char *) &headers->header, sizeof (headers->header)); 291#endif /* CROSS_COMPILE */ 292 293} 294#endif 295 296void 297obj_symbol_to_chars (where, symbolP) 298 char **where; 299 symbolS *symbolP; 300{ 301 md_number_to_chars ((char *) &(S_GET_OFFSET (symbolP)), S_GET_OFFSET (symbolP), sizeof (S_GET_OFFSET (symbolP))); 302 md_number_to_chars ((char *) &(S_GET_DESC (symbolP)), S_GET_DESC (symbolP), sizeof (S_GET_DESC (symbolP))); 303 md_number_to_chars ((char *) &(symbolP->sy_symbol.n_value), S_GET_VALUE (symbolP), sizeof (symbolP->sy_symbol.n_value)); 304 305 append (where, (char *) &symbolP->sy_symbol, sizeof (obj_symbol_type)); 306} 307 308void 309obj_emit_symbols (where, symbol_rootP) 310 char **where; 311 symbolS *symbol_rootP; 312{ 313 symbolS *symbolP; 314 315 /* Emit all symbols left in the symbol chain. */ 316 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP)) 317 { 318 /* Used to save the offset of the name. It is used to point 319 to the string in memory but must be a file offset. */ 320 register char *temp; 321 322 temp = S_GET_NAME (symbolP); 323 S_SET_OFFSET (symbolP, symbolP->sy_name_offset); 324 325 /* Any symbol still undefined and is not a dbg symbol is made N_EXT. */ 326 if (!S_IS_DEBUG (symbolP) && !S_IS_DEFINED (symbolP)) 327 S_SET_EXTERNAL (symbolP); 328 329 /* Adjust the type of a weak symbol. */ 330 if (S_GET_WEAK (symbolP)) 331 { 332 switch (S_GET_TYPE (symbolP)) 333 { 334 case N_UNDF: S_SET_TYPE (symbolP, N_WEAKU); break; 335 case N_ABS: S_SET_TYPE (symbolP, N_WEAKA); break; 336 case N_TEXT: S_SET_TYPE (symbolP, N_WEAKT); break; 337 case N_DATA: S_SET_TYPE (symbolP, N_WEAKD); break; 338 case N_BSS: S_SET_TYPE (symbolP, N_WEAKB); break; 339 default: as_bad ("%s: bad type for weak symbol", temp); break; 340 } 341 } 342 343 obj_symbol_to_chars (where, symbolP); 344 S_SET_NAME (symbolP, temp); 345 } 346} 347 348#endif /* ! BFD_ASSEMBLER */ 349 350static void 351obj_aout_line (ignore) 352 int ignore; 353{ 354 /* Assume delimiter is part of expression. 355 BSD4.2 as fails with delightful bug, so we 356 are not being incompatible here. */ 357 new_logical_line ((char *) NULL, (int) (get_absolute_expression ())); 358 demand_empty_rest_of_line (); 359} /* obj_aout_line() */ 360 361/* Handle .weak. This is a GNU extension. */ 362 363static void 364obj_aout_weak (ignore) 365 int ignore; 366{ 367 char *name; 368 int c; 369 symbolS *symbolP; 370 371 do 372 { 373 name = input_line_pointer; 374 c = get_symbol_end (); 375 symbolP = symbol_find_or_make (name); 376 *input_line_pointer = c; 377 SKIP_WHITESPACE (); 378 S_SET_WEAK (symbolP); 379 if (c == ',') 380 { 381 input_line_pointer++; 382 SKIP_WHITESPACE (); 383 if (*input_line_pointer == '\n') 384 c = '\n'; 385 } 386 } 387 while (c == ','); 388 demand_empty_rest_of_line (); 389} 390 391/* Handle .type. On {Net,Open}BSD, this is used to set the n_other field, 392 which is then apparently used when doing dynamic linking. Older 393 versions ogas ignored the .type pseudo-op, so we also ignore it if 394 we can't parse it. */ 395 396static void 397obj_aout_type (ignore) 398 int ignore; 399{ 400 char *name; 401 int c; 402 symbolS *sym; 403 404 name = input_line_pointer; 405 c = get_symbol_end (); 406 sym = symbol_find (name); 407 *input_line_pointer = c; 408 if (sym != NULL) 409 { 410 SKIP_WHITESPACE (); 411 if (*input_line_pointer == ',') 412 { 413 ++input_line_pointer; 414 SKIP_WHITESPACE (); 415 if (*input_line_pointer == '@') 416 { 417 ++input_line_pointer; 418 if (strncmp (input_line_pointer, "object", 6) == 0) 419 S_SET_OTHER (sym, 1); 420 else if (strncmp (input_line_pointer, "function", 8) == 0) 421 S_SET_OTHER (sym, 2); 422 } 423 } 424 } 425 426 /* Ignore everything else on the line. */ 427 s_ignore (0); 428} 429 430void 431obj_read_begin_hook () 432{ 433} 434 435#ifndef BFD_ASSEMBLER 436 437void 438obj_crawl_symbol_chain (headers) 439 object_headers *headers; 440{ 441 symbolS *symbolP; 442 symbolS **symbolPP; 443 int symbol_number = 0; 444 445 tc_crawl_symbol_chain (headers); 446 447 symbolPP = &symbol_rootP; /*->last symbol chain link. */ 448 while ((symbolP = *symbolPP) != NULL) 449 { 450 if (symbolP->sy_mri_common) 451 { 452 if (S_IS_EXTERNAL (symbolP)) 453 as_bad ("%s: global symbols not supported in common sections", 454 S_GET_NAME (symbolP)); 455 *symbolPP = symbol_next (symbolP); 456 continue; 457 } 458 459 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_DATA)) 460 { 461 S_SET_SEGMENT (symbolP, SEG_TEXT); 462 } /* if pusing data into text */ 463 464 resolve_symbol_value (symbolP); 465 466 /* Skip symbols which were equated to undefined or common 467 symbols. */ 468 if (symbolP->sy_value.X_op == O_symbol 469 && (! S_IS_DEFINED (symbolP) || S_IS_COMMON (symbolP))) 470 { 471 *symbolPP = symbol_next (symbolP); 472 continue; 473 } 474 475 /* OK, here is how we decide which symbols go out into the brave 476 new symtab. Symbols that do are: 477 478 * symbols with no name (stabd's?) 479 * symbols with debug info in their N_TYPE 480 481 Symbols that don't are: 482 * symbols that are registers 483 * symbols with \1 as their 3rd character (numeric labels) 484 * "local labels" as defined by S_LOCAL_NAME(name) if the -L 485 switch was passed to gas. 486 487 All other symbols are output. We complain if a deleted 488 symbol was marked external. */ 489 490 491 if (!S_IS_REGISTER (symbolP) 492 && (!S_GET_NAME (symbolP) 493 || S_IS_DEBUG (symbolP) 494 || !S_IS_DEFINED (symbolP) 495 || S_IS_EXTERNAL (symbolP) 496 || (S_GET_NAME (symbolP)[0] != '\001' 497 && (flag_keep_locals || !S_LOCAL_NAME (symbolP))))) 498 { 499 symbolP->sy_number = symbol_number++; 500 501 /* The + 1 after strlen account for the \0 at the 502 end of each string */ 503 if (!S_IS_STABD (symbolP)) 504 { 505 /* Ordinary case. */ 506 symbolP->sy_name_offset = string_byte_count; 507 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1; 508 } 509 else /* .Stabd case. */ 510 symbolP->sy_name_offset = 0; 511 symbolPP = &(symbol_next (symbolP)); 512 } 513 else 514 { 515 if (S_IS_EXTERNAL (symbolP) || !S_IS_DEFINED (symbolP)) 516 /* This warning should never get triggered any more. 517 Well, maybe if you're doing twisted things with 518 register names... */ 519 { 520 as_bad ("Local symbol %s never defined.", decode_local_label_name (S_GET_NAME (symbolP))); 521 } /* oops. */ 522 523 /* Unhook it from the chain */ 524 *symbolPP = symbol_next (symbolP); 525 } /* if this symbol should be in the output */ 526 } /* for each symbol */ 527 528 H_SET_SYMBOL_TABLE_SIZE (headers, symbol_number); 529} 530 531/* 532 * Find strings by crawling along symbol table chain. 533 */ 534 535void 536obj_emit_strings (where) 537 char **where; 538{ 539 symbolS *symbolP; 540 541#ifdef CROSS_COMPILE 542 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */ 543 md_number_to_chars (*where, string_byte_count, sizeof (string_byte_count)); 544 *where += sizeof (string_byte_count); 545#else /* CROSS_COMPILE */ 546 append (where, (char *) &string_byte_count, (unsigned long) sizeof (string_byte_count)); 547#endif /* CROSS_COMPILE */ 548 549 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP)) 550 { 551 if (S_GET_NAME (symbolP)) 552 append (&next_object_file_charP, S_GET_NAME (symbolP), 553 (unsigned long) (strlen (S_GET_NAME (symbolP)) + 1)); 554 } /* walk symbol chain */ 555} 556 557#ifndef AOUT_VERSION 558#define AOUT_VERSION 0 559#endif 560 561void 562obj_pre_write_hook (headers) 563 object_headers *headers; 564{ 565 H_SET_DYNAMIC (headers, 0); 566 H_SET_VERSION (headers, AOUT_VERSION); 567 H_SET_MACHTYPE (headers, AOUT_MACHTYPE); 568 tc_aout_pre_write_hook (headers); 569} 570 571void 572DEFUN_VOID (s_sect) 573{ 574 /* Strip out the section name */ 575 char *section_name; 576 char *section_name_end; 577 char c; 578 579 unsigned int len; 580 unsigned int exp; 581 char *save; 582 583 section_name = input_line_pointer; 584 c = get_symbol_end (); 585 section_name_end = input_line_pointer; 586 587 len = section_name_end - section_name; 588 input_line_pointer++; 589 save = input_line_pointer; 590 591 SKIP_WHITESPACE (); 592 if (c == ',') 593 { 594 exp = get_absolute_expression (); 595 } 596 else if (*input_line_pointer == ',') 597 { 598 input_line_pointer++; 599 exp = get_absolute_expression (); 600 } 601 else 602 { 603 input_line_pointer = save; 604 exp = 0; 605 } 606 if (exp >= 1000) 607 { 608 as_bad ("subsegment index too high"); 609 } 610 611 if (strcmp (section_name, ".text") == 0) 612 { 613 subseg_set (SEG_TEXT, (subsegT) exp); 614 } 615 616 if (strcmp (section_name, ".data") == 0) 617 { 618 if (flag_readonly_data_in_text) 619 subseg_set (SEG_TEXT, (subsegT) exp + 1000); 620 else 621 subseg_set (SEG_DATA, (subsegT) exp); 622 } 623 624 *section_name_end = c; 625} 626 627#endif /* ! BFD_ASSEMBLER */ 628 629/* end of obj-aout.c */ 630