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