stabs.c revision 99461
1/* Generic stabs parsing for gas. 2 Copyright 1989, 1990, 1991, 1993, 1995, 1996, 1997, 1998, 2000, 2001 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 License 18along with GAS; see the file COPYING. If not, write to the Free 19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ 21 22#include "as.h" 23#include "obstack.h" 24#include "subsegs.h" 25#include "ecoff.h" 26 27/* We need this, despite the apparent object format dependency, since 28 it defines stab types, which all object formats can use now. */ 29 30#include "aout/stab_gnu.h" 31 32/* Holds whether the assembler is generating stabs line debugging 33 information or not. Potentially used by md_cleanup function. */ 34 35int outputting_stabs_line_debug = 0; 36 37static void s_stab_generic PARAMS ((int, char *, char *)); 38static void generate_asm_file PARAMS ((int, char *)); 39 40/* Allow backends to override the names used for the stab sections. */ 41#ifndef STAB_SECTION_NAME 42#define STAB_SECTION_NAME ".stab" 43#endif 44 45#ifndef STAB_STRING_SECTION_NAME 46#define STAB_STRING_SECTION_NAME ".stabstr" 47#endif 48 49/* Non-zero if we're in the middle of a .func function, in which case 50 stabs_generate_asm_lineno emits function relative line number stabs. 51 Otherwise it emits line number stabs with absolute addresses. Note that 52 both cases only apply to assembler code assembled with -gstabs. */ 53static int in_dot_func_p; 54 55/* Label at start of current function if in_dot_func_p != 0. */ 56static const char *current_function_label; 57 58/* 59 * Handle .stabX directives, which used to be open-coded. 60 * So much creeping featurism overloaded the semantics that we decided 61 * to put all .stabX thinking in one place. Here. 62 * 63 * We try to make any .stabX directive legal. Other people's AS will often 64 * do assembly-time consistency checks: eg assigning meaning to n_type bits 65 * and "protecting" you from setting them to certain values. (They also zero 66 * certain bits before emitting symbols. Tut tut.) 67 * 68 * If an expression is not absolute we either gripe or use the relocation 69 * information. Other people's assemblers silently forget information they 70 * don't need and invent information they need that you didn't supply. 71 */ 72 73/* 74 * Build a string dictionary entry for a .stabX symbol. 75 * The symbol is added to the .<secname>str section. 76 */ 77 78#ifndef SEPARATE_STAB_SECTIONS 79#define SEPARATE_STAB_SECTIONS 0 80#endif 81 82unsigned int 83get_stab_string_offset (string, stabstr_secname) 84 const char *string; 85 const char *stabstr_secname; 86{ 87 unsigned int length; 88 unsigned int retval; 89 segT save_seg; 90 subsegT save_subseg; 91 segT seg; 92 char *p; 93 94 if (! SEPARATE_STAB_SECTIONS) 95 abort (); 96 97 length = strlen (string); 98 99 save_seg = now_seg; 100 save_subseg = now_subseg; 101 102 /* Create the stab string section. */ 103 seg = subseg_new (stabstr_secname, 0); 104 105 retval = seg_info (seg)->stabu.stab_string_size; 106 if (retval <= 0) 107 { 108 /* Make sure the first string is empty. */ 109 p = frag_more (1); 110 *p = 0; 111 retval = seg_info (seg)->stabu.stab_string_size = 1; 112#ifdef BFD_ASSEMBLER 113 bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_DEBUGGING); 114 if (seg->name == stabstr_secname) 115 seg->name = xstrdup (stabstr_secname); 116#endif 117 } 118 119 if (length > 0) 120 { /* Ordinary case. */ 121 p = frag_more (length + 1); 122 strcpy (p, string); 123 124 seg_info (seg)->stabu.stab_string_size += length + 1; 125 } 126 else 127 retval = 0; 128 129 subseg_set (save_seg, save_subseg); 130 131 return retval; 132} 133 134#ifdef AOUT_STABS 135#ifndef OBJ_PROCESS_STAB 136#define OBJ_PROCESS_STAB(SEG,W,S,T,O,D) aout_process_stab(W,S,T,O,D) 137#endif 138 139/* Here instead of obj-aout.c because other formats use it too. */ 140void 141aout_process_stab (what, string, type, other, desc) 142 int what; 143 const char *string; 144 int type, other, desc; 145{ 146 /* Put the stab information in the symbol table. */ 147 symbolS *symbol; 148 149 /* Create the symbol now, but only insert it into the symbol chain 150 after any symbols mentioned in the value expression get into the 151 symbol chain. This is to avoid "continuation symbols" (where one 152 ends in "\" and the debug info is continued in the next .stabs 153 directive) from being separated by other random symbols. */ 154 symbol = symbol_create (string, undefined_section, 0, 155 (struct frag *) NULL); 156 if (what == 's' || what == 'n') 157 { 158 /* Pick up the value from the input line. */ 159 symbol_set_frag (symbol, &zero_address_frag); 160 pseudo_set (symbol); 161 } 162 else 163 { 164 /* .stabd sets the name to NULL. Why? */ 165 S_SET_NAME (symbol, NULL); 166 symbol_set_frag (symbol, frag_now); 167 S_SET_VALUE (symbol, (valueT) frag_now_fix ()); 168 } 169 170 symbol_append (symbol, symbol_lastP, &symbol_rootP, &symbol_lastP); 171 172 S_SET_TYPE (symbol, type); 173 S_SET_OTHER (symbol, other); 174 S_SET_DESC (symbol, desc); 175} 176#endif 177 178/* This can handle different kinds of stabs (s,n,d) and different 179 kinds of stab sections. */ 180 181static void 182s_stab_generic (what, stab_secname, stabstr_secname) 183 int what; 184 char *stab_secname; 185 char *stabstr_secname; 186{ 187 long longint; 188 char *string, *saved_string_obstack_end; 189 int type; 190 int other; 191 int desc; 192 193 /* The general format is: 194 .stabs "STRING",TYPE,OTHER,DESC,VALUE 195 .stabn TYPE,OTHER,DESC,VALUE 196 .stabd TYPE,OTHER,DESC 197 At this point input_line_pointer points after the pseudo-op and 198 any trailing whitespace. The argument what is one of 's', 'n' or 199 'd' indicating which type of .stab this is. */ 200 201 if (what != 's') 202 { 203 string = ""; 204 saved_string_obstack_end = 0; 205 } 206 else 207 { 208 int length; 209 210 string = demand_copy_C_string (&length); 211 /* FIXME: We should probably find some other temporary storage 212 for string, rather than leaking memory if someone else 213 happens to use the notes obstack. */ 214 saved_string_obstack_end = notes.next_free; 215 SKIP_WHITESPACE (); 216 if (*input_line_pointer == ',') 217 input_line_pointer++; 218 else 219 { 220 as_warn (_(".stab%c: missing comma"), what); 221 ignore_rest_of_line (); 222 return; 223 } 224 } 225 226 if (get_absolute_expression_and_terminator (&longint) != ',') 227 { 228 as_warn (_(".stab%c: missing comma"), what); 229 ignore_rest_of_line (); 230 return; 231 } 232 type = longint; 233 234 if (get_absolute_expression_and_terminator (&longint) != ',') 235 { 236 as_warn (_(".stab%c: missing comma"), what); 237 ignore_rest_of_line (); 238 return; 239 } 240 other = longint; 241 242 desc = get_absolute_expression (); 243 244 if ((desc > 0xffff) || (desc < -0x8000)) 245 /* This could happen for example with a source file with a huge 246 number of lines. The only cure is to use a different debug 247 format, probably DWARF. */ 248 as_warn (_(".stab%c: description field '%x' too big, try a different debug format"), 249 what, desc); 250 251 if (what == 's' || what == 'n') 252 { 253 if (*input_line_pointer != ',') 254 { 255 as_warn (_(".stab%c: missing comma"), what); 256 ignore_rest_of_line (); 257 return; 258 } 259 input_line_pointer++; 260 SKIP_WHITESPACE (); 261 } 262 263#ifdef TC_PPC 264#ifdef OBJ_ELF 265 /* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were 266 given 4 arguments, make it a .stabn */ 267 else if (what == 'd') 268 { 269 char *save_location = input_line_pointer; 270 271 SKIP_WHITESPACE (); 272 if (*input_line_pointer == ',') 273 { 274 input_line_pointer++; 275 what = 'n'; 276 } 277 else 278 input_line_pointer = save_location; 279 } 280#endif /* OBJ_ELF */ 281#endif /* TC_PPC */ 282 283#ifndef NO_LISTING 284 if (listing) 285 { 286 switch (type) 287 { 288 case N_SLINE: 289 listing_source_line ((unsigned int) desc); 290 break; 291 case N_SO: 292 case N_SOL: 293 listing_source_file (string); 294 break; 295 } 296 } 297#endif /* ! NO_LISTING */ 298 299 /* We have now gathered the type, other, and desc information. For 300 .stabs or .stabn, input_line_pointer is now pointing at the 301 value. */ 302 303 if (SEPARATE_STAB_SECTIONS) 304 /* Output the stab information in a separate section. This is used 305 at least for COFF and ELF. */ 306 { 307 segT saved_seg = now_seg; 308 subsegT saved_subseg = now_subseg; 309 fragS *saved_frag = frag_now; 310 valueT dot; 311 segT seg; 312 unsigned int stroff; 313 char *p; 314 315 static segT cached_sec; 316 static char *cached_secname; 317 318 dot = frag_now_fix (); 319 320#ifdef md_flush_pending_output 321 md_flush_pending_output (); 322#endif 323 324 if (cached_secname && !strcmp (cached_secname, stab_secname)) 325 { 326 seg = cached_sec; 327 subseg_set (seg, 0); 328 } 329 else 330 { 331 seg = subseg_new (stab_secname, 0); 332 if (cached_secname) 333 free (cached_secname); 334 cached_secname = xstrdup (stab_secname); 335 cached_sec = seg; 336 } 337 338 if (! seg_info (seg)->hadone) 339 { 340#ifdef BFD_ASSEMBLER 341 bfd_set_section_flags (stdoutput, seg, 342 SEC_READONLY | SEC_RELOC | SEC_DEBUGGING); 343#endif 344#ifdef INIT_STAB_SECTION 345 INIT_STAB_SECTION (seg); 346#endif 347 seg_info (seg)->hadone = 1; 348 } 349 350 stroff = get_stab_string_offset (string, stabstr_secname); 351 if (what == 's') 352 { 353 /* Release the string, if nobody else has used the obstack. */ 354 if (saved_string_obstack_end == notes.next_free) 355 obstack_free (¬es, string); 356 } 357 358 /* At least for now, stabs in a special stab section are always 359 output as 12 byte blocks of information. */ 360 p = frag_more (8); 361 md_number_to_chars (p, (valueT) stroff, 4); 362 md_number_to_chars (p + 4, (valueT) type, 1); 363 md_number_to_chars (p + 5, (valueT) other, 1); 364 md_number_to_chars (p + 6, (valueT) desc, 2); 365 366 if (what == 's' || what == 'n') 367 { 368 /* Pick up the value from the input line. */ 369 cons (4); 370 input_line_pointer--; 371 } 372 else 373 { 374 const char *fake; 375 symbolS *symbol; 376 expressionS exp; 377 378 /* Arrange for a value representing the current location. */ 379 fake = FAKE_LABEL_NAME; 380 symbol = symbol_new (fake, saved_seg, dot, saved_frag); 381 382 exp.X_op = O_symbol; 383 exp.X_add_symbol = symbol; 384 exp.X_add_number = 0; 385 386 emit_expr (&exp, 4); 387 } 388 389#ifdef OBJ_PROCESS_STAB 390 OBJ_PROCESS_STAB (seg, what, string, type, other, desc); 391#endif 392 393 subseg_set (saved_seg, saved_subseg); 394 } 395 else 396 { 397#ifdef OBJ_PROCESS_STAB 398 OBJ_PROCESS_STAB (0, what, string, type, other, desc); 399#else 400 abort (); 401#endif 402 } 403 404 demand_empty_rest_of_line (); 405} 406 407/* Regular stab directive. */ 408 409void 410s_stab (what) 411 int what; 412{ 413 s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME); 414} 415 416/* "Extended stabs", used in Solaris only now. */ 417 418void 419s_xstab (what) 420 int what; 421{ 422 int length; 423 char *stab_secname, *stabstr_secname; 424 static char *saved_secname, *saved_strsecname; 425 426 /* @@ MEMORY LEAK: This allocates a copy of the string, but in most 427 cases it will be the same string, so we could release the storage 428 back to the obstack it came from. */ 429 stab_secname = demand_copy_C_string (&length); 430 SKIP_WHITESPACE (); 431 if (*input_line_pointer == ',') 432 input_line_pointer++; 433 else 434 { 435 as_bad (_("comma missing in .xstabs")); 436 ignore_rest_of_line (); 437 return; 438 } 439 440 /* To get the name of the stab string section, simply add "str" to 441 the stab section name. */ 442 if (saved_secname == 0 || strcmp (saved_secname, stab_secname)) 443 { 444 stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4); 445 strcpy (stabstr_secname, stab_secname); 446 strcat (stabstr_secname, "str"); 447 if (saved_secname) 448 { 449 free (saved_secname); 450 free (saved_strsecname); 451 } 452 saved_secname = stab_secname; 453 saved_strsecname = stabstr_secname; 454 } 455 s_stab_generic (what, saved_secname, saved_strsecname); 456} 457 458#ifdef S_SET_DESC 459 460/* Frob invented at RMS' request. Set the n_desc of a symbol. */ 461 462void 463s_desc (ignore) 464 int ignore ATTRIBUTE_UNUSED; 465{ 466 char *name; 467 char c; 468 char *p; 469 symbolS *symbolP; 470 int temp; 471 472 name = input_line_pointer; 473 c = get_symbol_end (); 474 p = input_line_pointer; 475 *p = c; 476 SKIP_WHITESPACE (); 477 if (*input_line_pointer != ',') 478 { 479 *p = 0; 480 as_bad (_("expected comma after \"%s\""), name); 481 *p = c; 482 ignore_rest_of_line (); 483 } 484 else 485 { 486 input_line_pointer++; 487 temp = get_absolute_expression (); 488 *p = 0; 489 symbolP = symbol_find_or_make (name); 490 *p = c; 491 S_SET_DESC (symbolP, temp); 492 } 493 demand_empty_rest_of_line (); 494} /* s_desc() */ 495 496#endif /* defined (S_SET_DESC) */ 497 498/* Generate stabs debugging information to denote the main source file. */ 499 500void 501stabs_generate_asm_file () 502{ 503 char *file; 504 unsigned int lineno; 505 506 as_where (&file, &lineno); 507 generate_asm_file (N_SO, file); 508} 509 510/* Generate stabs debugging information to denote the source file. 511 TYPE is one of N_SO, N_SOL. */ 512 513static void 514generate_asm_file (type, file) 515 int type; 516 char *file; 517{ 518 static char *last_file; 519 static int label_count; 520 char *hold; 521 char sym[30]; 522 char *buf; 523 char *tmp = file; 524 char *endp = file + strlen (file); 525 char *bufp = buf; 526 527 if (last_file != NULL 528 && strcmp (last_file, file) == 0) 529 return; 530 531 /* Rather than try to do this in some efficient fashion, we just 532 generate a string and then parse it again. That lets us use the 533 existing stabs hook, which expect to see a string, rather than 534 inventing new ones. */ 535 hold = input_line_pointer; 536 537 sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count); 538 ++label_count; 539 540 /* Allocate enough space for the file name (possibly extended with 541 doubled up backslashes), the symbol name, and the other characters 542 that make up a stabs file directive. */ 543 bufp = buf = xmalloc (2 * strlen (file) + strlen (sym) + 12); 544 545 *bufp++ = '"'; 546 547 while (tmp < endp) 548 { 549 char *bslash = strchr (tmp, '\\'); 550 size_t len = (bslash) ? (size_t) (bslash - tmp + 1) : strlen (tmp); 551 552 /* Double all backslashes, since demand_copy_C_string (used by 553 s_stab to extract the part in quotes) will try to replace them as 554 escape sequences. backslash may appear in a filespec. */ 555 strncpy (bufp, tmp, len); 556 557 tmp += len; 558 bufp += len; 559 560 if (bslash != NULL) 561 *bufp++ = '\\'; 562 } 563 564 sprintf (bufp, "\",%d,0,0,%s\n", type, sym); 565 566 input_line_pointer = buf; 567 s_stab ('s'); 568 colon (sym); 569 570 if (last_file != NULL) 571 free (last_file); 572 last_file = xstrdup (file); 573 574 free (buf); 575 576 input_line_pointer = hold; 577} 578 579/* Generate stabs debugging information for the current line. This is 580 used to produce debugging information for an assembler file. */ 581 582void 583stabs_generate_asm_lineno () 584{ 585 static int label_count; 586 char *hold; 587 char *file; 588 unsigned int lineno; 589 char *buf; 590 char sym[30]; 591 /* Remember the last file/line and avoid duplicates. */ 592 static unsigned int prev_lineno = -1; 593 static char *prev_file = NULL; 594 595 /* Rather than try to do this in some efficient fashion, we just 596 generate a string and then parse it again. That lets us use the 597 existing stabs hook, which expect to see a string, rather than 598 inventing new ones. */ 599 600 hold = input_line_pointer; 601 602 as_where (&file, &lineno); 603 604 /* Don't emit sequences of stabs for the same line. */ 605 if (prev_file == NULL) 606 { 607 /* First time thru. */ 608 prev_file = xstrdup (file); 609 prev_lineno = lineno; 610 } 611 else if (lineno == prev_lineno 612 && strcmp (file, prev_file) == 0) 613 { 614 /* Same file/line as last time. */ 615 return; 616 } 617 else 618 { 619 /* Remember file/line for next time. */ 620 prev_lineno = lineno; 621 if (strcmp (file, prev_file) != 0) 622 { 623 free (prev_file); 624 prev_file = xstrdup (file); 625 } 626 } 627 628 /* Let the world know that we are in the middle of generating a 629 piece of stabs line debugging information. */ 630 outputting_stabs_line_debug = 1; 631 632 generate_asm_file (N_SOL, file); 633 634 sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count); 635 ++label_count; 636 637 if (in_dot_func_p) 638 { 639 buf = (char *) alloca (100 + strlen (current_function_label)); 640 sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno, 641 sym, current_function_label); 642 } 643 else 644 { 645 buf = (char *) alloca (100); 646 sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym); 647 } 648 input_line_pointer = buf; 649 s_stab ('n'); 650 colon (sym); 651 652 input_line_pointer = hold; 653 outputting_stabs_line_debug = 0; 654} 655 656/* Emit a function stab. 657 All assembler functions are assumed to have return type `void'. */ 658 659void 660stabs_generate_asm_func (funcname, startlabname) 661 const char *funcname; 662 const char *startlabname; 663{ 664 static int void_emitted_p; 665 char *hold = input_line_pointer; 666 char *buf; 667 char *file; 668 unsigned int lineno; 669 670 if (! void_emitted_p) 671 { 672 input_line_pointer = "\"void:t1=1\",128,0,0,0"; 673 s_stab ('s'); 674 void_emitted_p = 1; 675 } 676 677 as_where (&file, &lineno); 678 asprintf (&buf, "\"%s:F1\",%d,0,%d,%s", 679 funcname, N_FUN, lineno + 1, startlabname); 680 input_line_pointer = buf; 681 s_stab ('s'); 682 free (buf); 683 684 input_line_pointer = hold; 685 current_function_label = xstrdup (startlabname); 686 in_dot_func_p = 1; 687} 688 689/* Emit a stab to record the end of a function. */ 690 691void 692stabs_generate_asm_endfunc (funcname, startlabname) 693 const char *funcname ATTRIBUTE_UNUSED; 694 const char *startlabname; 695{ 696 static int label_count; 697 char *hold = input_line_pointer; 698 char *buf; 699 char sym[30]; 700 701 sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count); 702 ++label_count; 703 colon (sym); 704 705 asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname); 706 input_line_pointer = buf; 707 s_stab ('s'); 708 free (buf); 709 710 input_line_pointer = hold; 711 in_dot_func_p = 0; 712 current_function_label = NULL; 713} 714