gas/stabs.c

   1 /* Generic stabs parsing for gas.
   2    Copyright (C) 1989-2018 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 s_stab_generic (int, const char *, const char *);
  38 static void generate_asm_file (int, const 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 /* True 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.  */
  53 static bfd_boolean in_dot_func_p = FALSE;
  54
  55 /* Label at start of current function if in_dot_func_p != FALSE.  */
  56 static 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
  82 unsigned int
  83 get_stab_string_offset (const char *string, const char *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.  */
 101   seg = subseg_new (stabstr_secname, 0);
 102
 103   retval = seg_info (seg)->stabu.stab_string_size;
 104   if (retval <= 0)
 105     {
 106       /* Make sure the first string is empty.  */
 107       p = frag_more (1);
 108       *p = 0;
 109       retval = seg_info (seg)->stabu.stab_string_size = 1;
 110       bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_DEBUGGING);
 111       if (seg->name == stabstr_secname)
 112         seg->name = xstrdup (stabstr_secname);
 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.  */
 174
 175 static void
 176 s_stab_generic (int          what,
 177                 const char * stab_secname,
 178                 const char * stabstr_secname)
 179 {
 180   long longint;
 181   const char *string;
 182   char *saved_string_obstack_end;
 183   int type;
 184   int other;
 185   int desc;
 186
 187   /* The general format is:
 188      .stabs "STRING",TYPE,OTHER,DESC,VALUE
 189      .stabn TYPE,OTHER,DESC,VALUE
 190      .stabd TYPE,OTHER,DESC
 191      At this point input_line_pointer points after the pseudo-op and
 192      any trailing whitespace.  The argument what is one of 's', 'n' or
 193      'd' indicating which type of .stab this is.  */
 194
 195   if (what != 's')
 196     {
 197       string = "";
 198       saved_string_obstack_end = 0;
 199     }
 200   else
 201     {
 202       int length;
 203
 204       string = demand_copy_C_string (&length);
 205       if (string == NULL)
 206         {
 207           as_warn (_(".stab%c: missing string"), what);
 208           ignore_rest_of_line ();
 209           return;
 210         }
 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           bfd_set_section_flags (stdoutput, seg,
 341                                  SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
 342 #ifdef INIT_STAB_SECTION
 343           INIT_STAB_SECTION (seg);
 344 #endif
 345           seg_info (seg)->hadone = 1;
 346         }
 347
 348       stroff = get_stab_string_offset (string, stabstr_secname);
 349       if (what == 's')
 350         {
 351           /* Release the string, if nobody else has used the obstack.  */
 352           if (saved_string_obstack_end == notes.next_free)
 353             obstack_free (&notes, string);
 354         }
 355
 356       /* At least for now, stabs in a special stab section are always
 357          output as 12 byte blocks of information.  */
 358       p = frag_more (8);
 359       md_number_to_chars (p, (valueT) stroff, 4);
 360       md_number_to_chars (p + 4, (valueT) type, 1);
 361       md_number_to_chars (p + 5, (valueT) other, 1);
 362       md_number_to_chars (p + 6, (valueT) desc, 2);
 363
 364       if (what == 's' || what == 'n')
 365         {
 366           /* Pick up the value from the input line.  */
 367           cons (4);
 368           input_line_pointer--;
 369         }
 370       else
 371         {
 372           symbolS *symbol;
 373           expressionS exp;
 374
 375           /* Arrange for a value representing the current location.  */
 376           symbol = symbol_temp_new (saved_seg, dot, saved_frag);
 377
 378           exp.X_op = O_symbol;
 379           exp.X_add_symbol = symbol;
 380           exp.X_add_number = 0;
 381
 382           emit_expr (&exp, 4);
 383         }
 384
 385 #ifdef OBJ_PROCESS_STAB
 386       OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
 387 #endif
 388
 389       subseg_set (saved_seg, saved_subseg);
 390     }
 391   else
 392     {
 393 #ifdef OBJ_PROCESS_STAB
 394       OBJ_PROCESS_STAB (0, what, string, type, other, desc);
 395 #else
 396       abort ();
 397 #endif
 398     }
 399
 400   demand_empty_rest_of_line ();
 401 }
 402
 403 /* Regular stab directive.  */
 404
 405 void
 406 s_stab (int what)
 407 {
 408   s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
 409 }
 410
 411 /* "Extended stabs", used in Solaris only now.  */
 412
 413 void
 414 s_xstab (int what)
 415 {
 416   int length;
 417   char *stab_secname, *stabstr_secname;
 418   static char *saved_secname, *saved_strsecname;
 419
 420   /* @@ MEMORY LEAK: This allocates a copy of the string, but in most
 421      cases it will be the same string, so we could release the storage
 422      back to the obstack it came from.  */
 423   stab_secname = demand_copy_C_string (&length);
 424   SKIP_WHITESPACE ();
 425   if (*input_line_pointer == ',')
 426     input_line_pointer++;
 427   else
 428     {
 429       as_bad (_("comma missing in .xstabs"));
 430       ignore_rest_of_line ();
 431       return;
 432     }
 433
 434   /* To get the name of the stab string section, simply add "str" to
 435      the stab section name.  */
 436   if (saved_secname == 0 || strcmp (saved_secname, stab_secname))
 437     {
 438       stabstr_secname = concat (stab_secname, "str", (char *) NULL);
 439       if (saved_secname)
 440         {
 441           free (saved_secname);
 442           free (saved_strsecname);
 443         }
 444       saved_secname = stab_secname;
 445       saved_strsecname = stabstr_secname;
 446     }
 447   s_stab_generic (what, saved_secname, saved_strsecname);
 448 }
 449
 450 #ifdef S_SET_DESC
 451
 452 /* Frob invented at RMS' request. Set the n_desc of a symbol.  */
 453
 454 void
 455 s_desc (int ignore ATTRIBUTE_UNUSED)
 456 {
 457   char *name;
 458   char c;
 459   char *p;
 460   symbolS *symbolP;
 461   int temp;
 462
 463   c = get_symbol_name (&name);
 464   p = input_line_pointer;
 465   *p = c;
 466   SKIP_WHITESPACE_AFTER_NAME ();
 467   if (*input_line_pointer != ',')
 468     {
 469       *p = 0;
 470       as_bad (_("expected comma after \"%s\""), name);
 471       *p = c;
 472       ignore_rest_of_line ();
 473     }
 474   else
 475     {
 476       input_line_pointer++;
 477       temp = get_absolute_expression ();
 478       *p = 0;
 479       symbolP = symbol_find_or_make (name);
 480       *p = c;
 481       S_SET_DESC (symbolP, temp);
 482     }
 483   demand_empty_rest_of_line ();
 484 }                               /* s_desc() */
 485
 486 #endif /* defined (S_SET_DESC) */
 487
 488 /* Generate stabs debugging information to denote the main source file.  */
 489
 490 void
 491 stabs_generate_asm_file (void)
 492 {
 493   const char *file;
 494   unsigned int lineno;
 495
 496   file = as_where (&lineno);
 497   if (use_gnu_debug_info_extensions)
 498     {
 499       const char *dir;
 500       char *dir2;
 501
 502       dir = remap_debug_filename (getpwd ());
 503       dir2 = concat (dir, "/", NULL);
 504       generate_asm_file (N_SO, dir2);
 505       free (dir2);
 506       xfree ((char *) dir);
 507     }
 508   generate_asm_file (N_SO, file);
 509 }
 510
 511 /* Generate stabs debugging information to denote the source file.
 512    TYPE is one of N_SO, N_SOL.  */
 513
 514 static void
 515 generate_asm_file (int type, const char *file)
 516 {
 517   static char *last_file;
 518   static int label_count;
 519   char sym[30];
 520   char *buf;
 521   const char *tmp = file;
 522   const char *file_endp = file + strlen (file);
 523   char *bufp;
 524
 525   if (last_file != NULL
 526       && filename_cmp (last_file, file) == 0)
 527     return;
 528
 529   /* Rather than try to do this in some efficient fashion, we just
 530      generate a string and then parse it again.  That lets us use the
 531      existing stabs hook, which expect to see a string, rather than
 532      inventing new ones.  */
 533   sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count);
 534   ++label_count;
 535
 536   /* Allocate enough space for the file name (possibly extended with
 537      doubled up backslashes), the symbol name, and the other characters
 538      that make up a stabs file directive.  */
 539   bufp = buf = XNEWVEC (char, 2 * strlen (file) + strlen (sym) + 12);
 540
 541   *bufp++ = '"';
 542
 543   while (tmp < file_endp)
 544     {
 545       const char *bslash = strchr (tmp, '\\');
 546       size_t len = bslash != NULL ? bslash - tmp + 1 : file_endp - tmp;
 547
 548       /* Double all backslashes, since demand_copy_C_string (used by
 549          s_stab to extract the part in quotes) will try to replace them as
 550          escape sequences.  backslash may appear in a filespec.  */
 551       memcpy (bufp, tmp, len);
 552
 553       tmp += len;
 554       bufp += len;
 555
 556       if (bslash != NULL)
 557         *bufp++ = '\\';
 558     }
 559
 560   sprintf (bufp, "\",%d,0,0,%s\n", type, sym);
 561
 562   temp_ilp (buf);
 563   s_stab ('s');
 564   restore_ilp ();
 565
 566   colon (sym);
 567
 568   if (last_file != NULL)
 569     free (last_file);
 570   last_file = xstrdup (file);
 571
 572   free (buf);
 573 }
 574
 575 /* Generate stabs debugging information for the current line.  This is
 576    used to produce debugging information for an assembler file.  */
 577
 578 void
 579 stabs_generate_asm_lineno (void)
 580 {
 581   static int label_count;
 582   const char *file;
 583   unsigned int lineno;
 584   char *buf;
 585   char sym[30];
 586   /* Remember the last file/line and avoid duplicates.  */
 587   static unsigned int prev_lineno = -1;
 588   static char *prev_file = NULL;
 589
 590   /* Rather than try to do this in some efficient fashion, we just
 591      generate a string and then parse it again.  That lets us use the
 592      existing stabs hook, which expect to see a string, rather than
 593      inventing new ones.  */
 594
 595   file = as_where (&lineno);
 596
 597   /* Don't emit sequences of stabs for the same line.  */
 598   if (prev_file == NULL)
 599     {
 600       /* First time through.  */
 601       prev_file = xstrdup (file);
 602       prev_lineno = lineno;
 603     }
 604   else if (lineno == prev_lineno
 605            && filename_cmp (file, prev_file) == 0)
 606     {
 607       /* Same file/line as last time.  */
 608       return;
 609     }
 610   else
 611     {
 612       /* Remember file/line for next time.  */
 613       prev_lineno = lineno;
 614       if (filename_cmp (file, prev_file) != 0)
 615         {
 616           free (prev_file);
 617           prev_file = xstrdup (file);
 618         }
 619     }
 620
 621   /* Let the world know that we are in the middle of generating a
 622      piece of stabs line debugging information.  */
 623   outputting_stabs_line_debug = 1;
 624
 625   generate_asm_file (N_SOL, file);
 626
 627   sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count);
 628   ++label_count;
 629
 630   if (in_dot_func_p)
 631     {
 632       buf = XNEWVEC (char, 100 + strlen (current_function_label));
 633       sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno,
 634                sym, current_function_label);
 635     }
 636   else
 637     {
 638       buf = XNEWVEC (char, 100);
 639       sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
 640     }
 641
 642   temp_ilp (buf);
 643   s_stab ('n');
 644   restore_ilp ();
 645
 646   colon (sym);
 647
 648   outputting_stabs_line_debug = 0;
 649   free (buf);
 650 }
 651
 652 /* Emit a function stab.
 653    All assembler functions are assumed to have return type `void'.  */
 654
 655 void
 656 stabs_generate_asm_func (const char *funcname, const char *startlabname)
 657 {
 658   static bfd_boolean void_emitted_p = FALSE;
 659   char *buf;
 660   unsigned int lineno;
 661
 662   if (! void_emitted_p)
 663     {
 664       temp_ilp ((char *) "\"void:t1=1\",128,0,0,0");
 665       s_stab ('s');
 666       restore_ilp ();
 667       void_emitted_p = TRUE;
 668     }
 669
 670   as_where (&lineno);
 671   if (asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
 672                 funcname, N_FUN, lineno + 1, startlabname) == -1)
 673     as_fatal ("%s", xstrerror (errno));
 674
 675   temp_ilp (buf);
 676   s_stab ('s');
 677   restore_ilp ();
 678   free (buf);
 679
 680   current_function_label = xstrdup (startlabname);
 681   in_dot_func_p = TRUE;
 682 }
 683
 684 /* Emit a stab to record the end of a function.  */
 685
 686 void
 687 stabs_generate_asm_endfunc (const char *funcname ATTRIBUTE_UNUSED,
 688                             const char *startlabname)
 689 {
 690   static int label_count;
 691   char *buf;
 692   char sym[30];
 693
 694   sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count);
 695   ++label_count;
 696   colon (sym);
 697
 698   if (asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname) == -1)
 699     as_fatal ("%s", xstrerror (errno));
 700
 701   temp_ilp (buf);
 702   s_stab ('s');
 703   restore_ilp ();
 704   free (buf);
 705
 706   in_dot_func_p = FALSE;
 707   current_function_label = NULL;
 708 }