stabs.c revision 77298
1/* Generic stabs parsing for gas. 2 Copyright (C) 1989, 90, 91, 93, 94, 95, 96, 97, 98, 99, 2000 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; 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 string = ""; 203 else 204 { 205 int length; 206 207 string = demand_copy_C_string (&length); 208 SKIP_WHITESPACE (); 209 if (*input_line_pointer == ',') 210 input_line_pointer++; 211 else 212 { 213 as_warn (_(".stabs: Missing comma")); 214 ignore_rest_of_line (); 215 return; 216 } 217 } 218 219 if (get_absolute_expression_and_terminator (&longint) != ',') 220 { 221 as_warn (_(".stab%c: Missing comma"), what); 222 ignore_rest_of_line (); 223 return; 224 } 225 type = longint; 226 227 if (get_absolute_expression_and_terminator (&longint) != ',') 228 { 229 as_warn (_(".stab%c: Missing comma"), what); 230 ignore_rest_of_line (); 231 return; 232 } 233 other = longint; 234 235 desc = get_absolute_expression (); 236 if (what == 's' || what == 'n') 237 { 238 if (*input_line_pointer != ',') 239 { 240 as_warn (_(".stab%c: Missing comma"), what); 241 ignore_rest_of_line (); 242 return; 243 } 244 input_line_pointer++; 245 SKIP_WHITESPACE (); 246 } 247 248#ifdef TC_PPC 249#ifdef OBJ_ELF 250 /* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were 251 given 4 arguments, make it a .stabn */ 252 else if (what == 'd') 253 { 254 char *save_location = input_line_pointer; 255 256 SKIP_WHITESPACE (); 257 if (*input_line_pointer == ',') 258 { 259 input_line_pointer++; 260 what = 'n'; 261 } 262 else 263 input_line_pointer = save_location; 264 } 265#endif /* OBJ_ELF */ 266#endif /* TC_PPC */ 267 268#ifndef NO_LISTING 269 if (listing) 270 { 271 switch (type) 272 { 273 case N_SLINE: 274 listing_source_line ((unsigned int) desc); 275 break; 276 case N_SO: 277 case N_SOL: 278 listing_source_file (string); 279 break; 280 } 281 } 282#endif /* ! NO_LISTING */ 283 284 /* We have now gathered the type, other, and desc information. For 285 .stabs or .stabn, input_line_pointer is now pointing at the 286 value. */ 287 288 if (SEPARATE_STAB_SECTIONS) 289 /* Output the stab information in a separate section. This is used 290 at least for COFF and ELF. */ 291 { 292 segT saved_seg = now_seg; 293 subsegT saved_subseg = now_subseg; 294 fragS *saved_frag = frag_now; 295 valueT dot; 296 segT seg; 297 unsigned int stroff; 298 char *p; 299 300 static segT cached_sec; 301 static char *cached_secname; 302 303 dot = frag_now_fix (); 304 305#ifdef md_flush_pending_output 306 md_flush_pending_output (); 307#endif 308 309 if (cached_secname && !strcmp (cached_secname, stab_secname)) 310 { 311 seg = cached_sec; 312 subseg_set (seg, 0); 313 } 314 else 315 { 316 seg = subseg_new (stab_secname, 0); 317 if (cached_secname) 318 free (cached_secname); 319 cached_secname = xstrdup (stab_secname); 320 cached_sec = seg; 321 } 322 323 if (! seg_info (seg)->hadone) 324 { 325#ifdef BFD_ASSEMBLER 326 bfd_set_section_flags (stdoutput, seg, 327 SEC_READONLY | SEC_RELOC | SEC_DEBUGGING); 328#endif 329#ifdef INIT_STAB_SECTION 330 INIT_STAB_SECTION (seg); 331#endif 332 seg_info (seg)->hadone = 1; 333 } 334 335 stroff = get_stab_string_offset (string, stabstr_secname); 336 if (what == 's') 337 { 338 /* release the string */ 339 obstack_free (¬es, string); 340 } 341 342 /* At least for now, stabs in a special stab section are always 343 output as 12 byte blocks of information. */ 344 p = frag_more (8); 345 md_number_to_chars (p, (valueT) stroff, 4); 346 md_number_to_chars (p + 4, (valueT) type, 1); 347 md_number_to_chars (p + 5, (valueT) other, 1); 348 md_number_to_chars (p + 6, (valueT) desc, 2); 349 350 if (what == 's' || what == 'n') 351 { 352 /* Pick up the value from the input line. */ 353 cons (4); 354 input_line_pointer--; 355 } 356 else 357 { 358 const char *fake; 359 symbolS *symbol; 360 expressionS exp; 361 362 /* Arrange for a value representing the current location. */ 363 fake = FAKE_LABEL_NAME; 364 symbol = symbol_new (fake, saved_seg, dot, saved_frag); 365 366 exp.X_op = O_symbol; 367 exp.X_add_symbol = symbol; 368 exp.X_add_number = 0; 369 370 emit_expr (&exp, 4); 371 } 372 373#ifdef OBJ_PROCESS_STAB 374 OBJ_PROCESS_STAB (seg, what, string, type, other, desc); 375#endif 376 377 subseg_set (saved_seg, saved_subseg); 378 } 379 else 380 { 381#ifdef OBJ_PROCESS_STAB 382 OBJ_PROCESS_STAB (0, what, string, type, other, desc); 383#else 384 abort (); 385#endif 386 } 387 388 demand_empty_rest_of_line (); 389} 390 391/* Regular stab directive. */ 392 393void 394s_stab (what) 395 int what; 396{ 397 s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME); 398} 399 400/* "Extended stabs", used in Solaris only now. */ 401 402void 403s_xstab (what) 404 int what; 405{ 406 int length; 407 char *stab_secname, *stabstr_secname; 408 static char *saved_secname, *saved_strsecname; 409 410 /* @@ MEMORY LEAK: This allocates a copy of the string, but in most 411 cases it will be the same string, so we could release the storage 412 back to the obstack it came from. */ 413 stab_secname = demand_copy_C_string (&length); 414 SKIP_WHITESPACE (); 415 if (*input_line_pointer == ',') 416 input_line_pointer++; 417 else 418 { 419 as_bad (_("comma missing in .xstabs")); 420 ignore_rest_of_line (); 421 return; 422 } 423 424 /* To get the name of the stab string section, simply add "str" to 425 the stab section name. */ 426 if (saved_secname == 0 || strcmp (saved_secname, stab_secname)) 427 { 428 stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4); 429 strcpy (stabstr_secname, stab_secname); 430 strcat (stabstr_secname, "str"); 431 if (saved_secname) 432 { 433 free (saved_secname); 434 free (saved_strsecname); 435 } 436 saved_secname = stab_secname; 437 saved_strsecname = stabstr_secname; 438 } 439 s_stab_generic (what, saved_secname, saved_strsecname); 440} 441 442#ifdef S_SET_DESC 443 444/* Frob invented at RMS' request. Set the n_desc of a symbol. */ 445 446void 447s_desc (ignore) 448 int ignore ATTRIBUTE_UNUSED; 449{ 450 char *name; 451 char c; 452 char *p; 453 symbolS *symbolP; 454 int temp; 455 456 name = input_line_pointer; 457 c = get_symbol_end (); 458 p = input_line_pointer; 459 *p = c; 460 SKIP_WHITESPACE (); 461 if (*input_line_pointer != ',') 462 { 463 *p = 0; 464 as_bad (_("Expected comma after name \"%s\""), name); 465 *p = c; 466 ignore_rest_of_line (); 467 } 468 else 469 { 470 input_line_pointer++; 471 temp = get_absolute_expression (); 472 *p = 0; 473 symbolP = symbol_find_or_make (name); 474 *p = c; 475 S_SET_DESC (symbolP, temp); 476 } 477 demand_empty_rest_of_line (); 478} /* s_desc() */ 479 480#endif /* defined (S_SET_DESC) */ 481 482/* Generate stabs debugging information to denote the main source file. */ 483 484void 485stabs_generate_asm_file () 486{ 487 char *file; 488 unsigned int lineno; 489 490 as_where (&file, &lineno); 491 generate_asm_file (N_SO, file); 492} 493 494/* Generate stabs debugging information to denote the source file. 495 TYPE is one of N_SO, N_SOL. */ 496 497static void 498generate_asm_file (type, file) 499 int type; 500 char *file; 501{ 502 static char *last_file; 503 static int label_count; 504 char *hold; 505 char sym[30]; 506 char *buf; 507 char *tmp = file; 508 char *endp = file + strlen (file); 509 char *bufp = buf; 510 511 if (last_file != NULL 512 && strcmp (last_file, file) == 0) 513 return; 514 515 /* Rather than try to do this in some efficient fashion, we just 516 generate a string and then parse it again. That lets us use the 517 existing stabs hook, which expect to see a string, rather than 518 inventing new ones. */ 519 hold = input_line_pointer; 520 521 sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count); 522 ++label_count; 523 524 /* Allocate enough space for the file name (possibly extended with 525 doubled up backslashes), the symbol name, and the other characters 526 that make up a stabs file directive. */ 527 bufp = buf = xmalloc (2 * strlen (file) + strlen (sym) + 12); 528 529 *bufp++ = '"'; 530 531 while (tmp < endp) 532 { 533 char *bslash = strchr (tmp, '\\'); 534 int len = (bslash ? (bslash - tmp + 1) : strlen (tmp)); 535 536 /* Double all backslashes, since demand_copy_C_string (used by 537 s_stab to extract the part in quotes) will try to replace them as 538 escape sequences. backslash may appear in a filespec. */ 539 strncpy (bufp, tmp, len); 540 541 tmp += len; 542 bufp += len; 543 544 if (bslash != NULL) 545 *bufp++ = '\\'; 546 } 547 548 sprintf (bufp, "\",%d,0,0,%s\n", type, sym); 549 550 input_line_pointer = buf; 551 s_stab ('s'); 552 colon (sym); 553 554 if (last_file != NULL) 555 free (last_file); 556 last_file = xstrdup (file); 557 558 free (buf); 559 560 input_line_pointer = hold; 561} 562 563/* Generate stabs debugging information for the current line. This is 564 used to produce debugging information for an assembler file. */ 565 566void 567stabs_generate_asm_lineno () 568{ 569 static int label_count; 570 char *hold; 571 char *file; 572 unsigned int lineno; 573 char *buf; 574 char sym[30]; 575 576 /* Let the world know that we are in the middle of generating a 577 piece of stabs line debugging information. */ 578 outputting_stabs_line_debug = 1; 579 580 /* Rather than try to do this in some efficient fashion, we just 581 generate a string and then parse it again. That lets us use the 582 existing stabs hook, which expect to see a string, rather than 583 inventing new ones. */ 584 585 hold = input_line_pointer; 586 587 as_where (&file, &lineno); 588 589 generate_asm_file (N_SOL, file); 590 591 sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count); 592 ++label_count; 593 594 if (in_dot_func_p) 595 { 596 buf = (char *) alloca (100 + strlen (current_function_label)); 597 sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno, 598 sym, current_function_label); 599 } 600 else 601 { 602 buf = (char *) alloca (100); 603 sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym); 604 } 605 input_line_pointer = buf; 606 s_stab ('n'); 607 colon (sym); 608 609 input_line_pointer = hold; 610 outputting_stabs_line_debug = 0; 611} 612 613/* Emit a function stab. 614 All assembler functions are assumed to have return type `void'. */ 615 616void 617stabs_generate_asm_func (funcname, startlabname) 618 const char *funcname; 619 const char *startlabname; 620{ 621 static int void_emitted_p; 622 char *hold = input_line_pointer; 623 char *buf; 624 char *file; 625 unsigned int lineno; 626 627 if (! void_emitted_p) 628 { 629 input_line_pointer = "\"void:t1=1\",128,0,0,0"; 630 s_stab ('s'); 631 void_emitted_p = 1; 632 } 633 634 as_where (&file, &lineno); 635 asprintf (&buf, "\"%s:F1\",%d,0,%d,%s", 636 funcname, N_FUN, lineno + 1, startlabname); 637 input_line_pointer = buf; 638 s_stab ('s'); 639 free (buf); 640 641 input_line_pointer = hold; 642 current_function_label = xstrdup (startlabname); 643 in_dot_func_p = 1; 644} 645 646/* Emit a stab to record the end of a function. */ 647 648void 649stabs_generate_asm_endfunc (funcname, startlabname) 650 const char *funcname ATTRIBUTE_UNUSED; 651 const char *startlabname; 652{ 653 static int label_count; 654 char *hold = input_line_pointer; 655 char *buf; 656 char sym[30]; 657 658 sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count); 659 ++label_count; 660 colon (sym); 661 662 asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname); 663 input_line_pointer = buf; 664 s_stab ('s'); 665 free (buf); 666 667 input_line_pointer = hold; 668 in_dot_func_p = 0; 669 current_function_label = NULL; 670} 671