gas/stabs.c

   1 /* Generic stabs parsing for gas.
   2    Copyright (C) 1989-2016 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, 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.  */
  53 static int in_dot_func_p;
  54
  55 /* Label at start of current function if in_dot_func_p != 0.  */
  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 (what, string, type, other, desc)
 138      int what;
 139      const char *string;
 140      int type, other, desc;
 141 {
 142   /* Put the stab information in the symbol table.  */
 143   symbolS *symbol;
 144
 145   /* Create the symbol now, but only insert it into the symbol chain
 146      after any symbols mentioned in the value expression get into the
 147      symbol chain.  This is to avoid "continuation symbols" (where one
 148      ends in "\" and the debug info is continued in the next .stabs
 149      directive) from being separated by other random symbols.  */
 150   symbol = symbol_create (string, undefined_section, 0,
 151                           &zero_address_frag);
 152   if (what == 's' || what == 'n')
 153     {
 154       /* Pick up the value from the input line.  */
 155       pseudo_set (symbol);
 156     }
 157   else
 158     {
 159       /* .stabd sets the name to NULL.  Why?  */
 160       S_SET_NAME (symbol, NULL);
 161       symbol_set_frag (symbol, frag_now);
 162       S_SET_VALUE (symbol, (valueT) frag_now_fix ());
 163     }
 164
 165   symbol_append (symbol, symbol_lastP, &symbol_rootP, &symbol_lastP);
 166
 167   symbol_get_bfdsym (symbol)->flags |= BSF_DEBUGGING;
 168
 169   S_SET_TYPE (symbol, type);
 170   S_SET_OTHER (symbol, other);
 171   S_SET_DESC (symbol, desc);
 172 }
 173 #endif
 174
 175 /* This can handle different kinds of stabs (s,n,d) and different
 176    kinds of stab sections.  */
 177
 178 static void
 179 s_stab_generic (int          what,
 180                 const char * stab_secname,
 181                 const char * stabstr_secname)
 182 {
 183   long longint;
 184   char *string, *saved_string_obstack_end;
 185   int type;
 186   int other;
 187   int desc;
 188
 189   /* The general format is:
 190      .stabs "STRING",TYPE,OTHER,DESC,VALUE
 191      .stabn TYPE,OTHER,DESC,VALUE
 192      .stabd TYPE,OTHER,DESC
 193      At this point input_line_pointer points after the pseudo-op and
 194      any trailing whitespace.  The argument what is one of 's', 'n' or
 195      'd' indicating which type of .stab this is.  */
 196
 197   if (what != 's')
 198     {
 199       string = "";
 200       saved_string_obstack_end = 0;
 201     }
 202   else
 203     {
 204       int length;
 205
 206       string = demand_copy_C_string (&length);
 207       /* FIXME: We should probably find some other temporary storage
 208          for string, rather than leaking memory if someone else
 209          happens to use the notes obstack.  */
 210       saved_string_obstack_end = notes.next_free;
 211       SKIP_WHITESPACE ();
 212       if (*input_line_pointer == ',')
 213         input_line_pointer++;
 214       else
 215         {
 216           as_warn (_(".stab%c: missing comma"), what);
 217           ignore_rest_of_line ();
 218           return;
 219         }
 220     }
 221
 222   if (get_absolute_expression_and_terminator (&longint) != ',')
 223     {
 224       as_warn (_(".stab%c: missing comma"), what);
 225       ignore_rest_of_line ();
 226       return;
 227     }
 228   type = longint;
 229
 230   if (get_absolute_expression_and_terminator (&longint) != ',')
 231     {
 232       as_warn (_(".stab%c: missing comma"), what);
 233       ignore_rest_of_line ();
 234       return;
 235     }
 236   other = longint;
 237
 238   desc = get_absolute_expression ();
 239
 240   if ((desc > 0xffff) || (desc < -0x8000))
 241     /* This could happen for example with a source file with a huge
 242        number of lines.  The only cure is to use a different debug
 243        format, probably DWARF.  */
 244     as_warn (_(".stab%c: description field '%x' too big, try a different debug format"),
 245              what, desc);
 246
 247   if (what == 's' || what == 'n')
 248     {
 249       if (*input_line_pointer != ',')
 250         {
 251           as_warn (_(".stab%c: missing comma"), what);
 252           ignore_rest_of_line ();
 253           return;
 254         }
 255       input_line_pointer++;
 256       SKIP_WHITESPACE ();
 257     }
 258
 259 #ifdef TC_PPC
 260 #ifdef OBJ_ELF
 261   /* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were
 262      given 4 arguments, make it a .stabn */
 263   else if (what == 'd')
 264     {
 265       char *save_location = input_line_pointer;
 266
 267       SKIP_WHITESPACE ();
 268       if (*input_line_pointer == ',')
 269         {
 270           input_line_pointer++;
 271           what = 'n';
 272         }
 273       else
 274         input_line_pointer = save_location;
 275     }
 276 #endif /* OBJ_ELF */
 277 #endif /* TC_PPC */
 278
 279 #ifndef NO_LISTING
 280   if (listing)
 281     {
 282       switch (type)
 283         {
 284         case N_SLINE:
 285           listing_source_line ((unsigned int) desc);
 286           break;
 287         case N_SO:
 288         case N_SOL:
 289           listing_source_file (string);
 290           break;
 291         }
 292     }
 293 #endif /* ! NO_LISTING */
 294
 295   /* We have now gathered the type, other, and desc information.  For
 296      .stabs or .stabn, input_line_pointer is now pointing at the
 297      value.  */
 298
 299   if (SEPARATE_STAB_SECTIONS)
 300     /* Output the stab information in a separate section.  This is used
 301        at least for COFF and ELF.  */
 302     {
 303       segT saved_seg = now_seg;
 304       subsegT saved_subseg = now_subseg;
 305       fragS *saved_frag = frag_now;
 306       valueT dot;
 307       segT seg;
 308       unsigned int stroff;
 309       char *p;
 310
 311       static segT cached_sec;
 312       static char *cached_secname;
 313
 314       dot = frag_now_fix ();
 315
 316 #ifdef md_flush_pending_output
 317       md_flush_pending_output ();
 318 #endif
 319
 320       if (cached_secname && !strcmp (cached_secname, stab_secname))
 321         {
 322           seg = cached_sec;
 323           subseg_set (seg, 0);
 324         }
 325       else
 326         {
 327           seg = subseg_new (stab_secname, 0);
 328           if (cached_secname)
 329             free (cached_secname);
 330           cached_secname = xstrdup (stab_secname);
 331           cached_sec = seg;
 332         }
 333
 334       if (! seg_info (seg)->hadone)
 335         {
 336           bfd_set_section_flags (stdoutput, seg,
 337                                  SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
 338 #ifdef INIT_STAB_SECTION
 339           INIT_STAB_SECTION (seg);
 340 #endif
 341           seg_info (seg)->hadone = 1;
 342         }
 343
 344       stroff = get_stab_string_offset (string, stabstr_secname);
 345       if (what == 's')
 346         {
 347           /* Release the string, if nobody else has used the obstack.  */
 348           if (saved_string_obstack_end == notes.next_free)
 349             obstack_free (&notes, string);
 350         }
 351
 352       /* At least for now, stabs in a special stab section are always
 353          output as 12 byte blocks of information.  */
 354       p = frag_more (8);
 355       md_number_to_chars (p, (valueT) stroff, 4);
 356       md_number_to_chars (p + 4, (valueT) type, 1);
 357       md_number_to_chars (p + 5, (valueT) other, 1);
 358       md_number_to_chars (p + 6, (valueT) desc, 2);
 359
 360       if (what == 's' || what == 'n')
 361         {
 362           /* Pick up the value from the input line.  */
 363           cons (4);
 364           input_line_pointer--;
 365         }
 366       else
 367         {
 368           symbolS *symbol;
 369           expressionS exp;
 370
 371           /* Arrange for a value representing the current location.  */
 372           symbol = symbol_temp_new (saved_seg, dot, saved_frag);
 373
 374           exp.X_op = O_symbol;
 375           exp.X_add_symbol = symbol;
 376           exp.X_add_number = 0;
 377
 378           emit_expr (&exp, 4);
 379         }
 380
 381 #ifdef OBJ_PROCESS_STAB
 382       OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
 383 #endif
 384
 385       subseg_set (saved_seg, saved_subseg);
 386     }
 387   else
 388     {
 389 #ifdef OBJ_PROCESS_STAB
 390       OBJ_PROCESS_STAB (0, what, string, type, other, desc);
 391 #else
 392       abort ();
 393 #endif
 394     }
 395
 396   demand_empty_rest_of_line ();
 397 }
 398
 399 /* Regular stab directive.  */
 400
 401 void
 402 s_stab (int what)
 403 {
 404   s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
 405 }
 406
 407 /* "Extended stabs", used in Solaris only now.  */
 408
 409 void
 410 s_xstab (int what)
 411 {
 412   int length;
 413   char *stab_secname, *stabstr_secname;
 414   static char *saved_secname, *saved_strsecname;
 415
 416   /* @@ MEMORY LEAK: This allocates a copy of the string, but in most
 417      cases it will be the same string, so we could release the storage
 418      back to the obstack it came from.  */
 419   stab_secname = demand_copy_C_string (&length);
 420   SKIP_WHITESPACE ();
 421   if (*input_line_pointer == ',')
 422     input_line_pointer++;
 423   else
 424     {
 425       as_bad (_("comma missing in .xstabs"));
 426       ignore_rest_of_line ();
 427       return;
 428     }
 429
 430   /* To get the name of the stab string section, simply add "str" to
 431      the stab section name.  */
 432   if (saved_secname == 0 || strcmp (saved_secname, stab_secname))
 433     {
 434       stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
 435       strcpy (stabstr_secname, stab_secname);
 436       strcat (stabstr_secname, "str");
 437       if (saved_secname)
 438         {
 439           free (saved_secname);
 440           free (saved_strsecname);
 441         }
 442       saved_secname = stab_secname;
 443       saved_strsecname = stabstr_secname;
 444     }
 445   s_stab_generic (what, saved_secname, saved_strsecname);
 446 }
 447
 448 #ifdef S_SET_DESC
 449
 450 /* Frob invented at RMS' request. Set the n_desc of a symbol.  */
 451
 452 void
 453 s_desc (ignore)
 454      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   char *file;
 493   unsigned int lineno;
 494
 495   as_where (&file, &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 = (char *) alloca (strlen (dir) + 2);
 503       sprintf (dir2, "%s%s", dir, "/");
 504       generate_asm_file (N_SO, 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, char *file)
 515 {
 516   static char *last_file;
 517   static int label_count;
 518   char *hold;
 519   char sym[30];
 520   char *buf;
 521   char *tmp = file;
 522   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   hold = input_line_pointer;
 534
 535   sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count);
 536   ++label_count;
 537
 538   /* Allocate enough space for the file name (possibly extended with
 539      doubled up backslashes), the symbol name, and the other characters
 540      that make up a stabs file directive.  */
 541   bufp = buf = (char *) xmalloc (2 * strlen (file) + strlen (sym) + 12);
 542
 543   *bufp++ = '"';
 544
 545   while (tmp < file_endp)
 546     {
 547       char *bslash = strchr (tmp, '\\');
 548       size_t len = (bslash) ? (size_t) (bslash - tmp + 1) : strlen (tmp);
 549
 550       /* Double all backslashes, since demand_copy_C_string (used by
 551          s_stab to extract the part in quotes) will try to replace them as
 552          escape sequences.  backslash may appear in a filespec.  */
 553       strncpy (bufp, tmp, len);
 554
 555       tmp += len;
 556       bufp += len;
 557
 558       if (bslash != NULL)
 559         *bufp++ = '\\';
 560     }
 561
 562   sprintf (bufp, "\",%d,0,0,%s\n", type, sym);
 563
 564   input_line_pointer = buf;
 565   s_stab ('s');
 566   colon (sym);
 567
 568   if (last_file != NULL)
 569     free (last_file);
 570   last_file = xstrdup (file);
 571
 572   free (buf);
 573
 574   input_line_pointer = hold;
 575 }
 576
 577 /* Generate stabs debugging information for the current line.  This is
 578    used to produce debugging information for an assembler file.  */
 579
 580 void
 581 stabs_generate_asm_lineno (void)
 582 {
 583   static int label_count;
 584   char *hold;
 585   char *file;
 586   unsigned int lineno;
 587   char *buf;
 588   char sym[30];
 589   /* Remember the last file/line and avoid duplicates.  */
 590   static unsigned int prev_lineno = -1;
 591   static char *prev_file = NULL;
 592
 593   /* Rather than try to do this in some efficient fashion, we just
 594      generate a string and then parse it again.  That lets us use the
 595      existing stabs hook, which expect to see a string, rather than
 596      inventing new ones.  */
 597
 598   hold = input_line_pointer;
 599
 600   as_where (&file, &lineno);
 601
 602   /* Don't emit sequences of stabs for the same line.  */
 603   if (prev_file == NULL)
 604     {
 605       /* First time thru.  */
 606       prev_file = xstrdup (file);
 607       prev_lineno = lineno;
 608     }
 609   else if (lineno == prev_lineno
 610            && filename_cmp (file, prev_file) == 0)
 611     {
 612       /* Same file/line as last time.  */
 613       return;
 614     }
 615   else
 616     {
 617       /* Remember file/line for next time.  */
 618       prev_lineno = lineno;
 619       if (filename_cmp (file, prev_file) != 0)
 620         {
 621           free (prev_file);
 622           prev_file = xstrdup (file);
 623         }
 624     }
 625
 626   /* Let the world know that we are in the middle of generating a
 627      piece of stabs line debugging information.  */
 628   outputting_stabs_line_debug = 1;
 629
 630   generate_asm_file (N_SOL, file);
 631
 632   sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count);
 633   ++label_count;
 634
 635   if (in_dot_func_p)
 636     {
 637       buf = (char *) alloca (100 + strlen (current_function_label));
 638       sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno,
 639                sym, current_function_label);
 640     }
 641   else
 642     {
 643       buf = (char *) alloca (100);
 644       sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
 645     }
 646   input_line_pointer = buf;
 647   s_stab ('n');
 648   colon (sym);
 649
 650   input_line_pointer = hold;
 651   outputting_stabs_line_debug = 0;
 652 }
 653
 654 /* Emit a function stab.
 655    All assembler functions are assumed to have return type `void'.  */
 656
 657 void
 658 stabs_generate_asm_func (const char *funcname, const char *startlabname)
 659 {
 660   static int void_emitted_p;
 661   char *hold = input_line_pointer;
 662   char *buf;
 663   char *file;
 664   unsigned int lineno;
 665
 666   if (! void_emitted_p)
 667     {
 668       input_line_pointer = "\"void:t1=1\",128,0,0,0";
 669       s_stab ('s');
 670       void_emitted_p = 1;
 671     }
 672
 673   as_where (&file, &lineno);
 674   if (asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
 675                 funcname, N_FUN, lineno + 1, startlabname) == -1)
 676     as_fatal ("%s", xstrerror (errno));
 677   input_line_pointer = buf;
 678   s_stab ('s');
 679   free (buf);
 680
 681   input_line_pointer = hold;
 682   current_function_label = xstrdup (startlabname);
 683   in_dot_func_p = 1;
 684 }
 685
 686 /* Emit a stab to record the end of a function.  */
 687
 688 void
 689 stabs_generate_asm_endfunc (const char *funcname ATTRIBUTE_UNUSED,
 690                             const char *startlabname)
 691 {
 692   static int label_count;
 693   char *hold = input_line_pointer;
 694   char *buf;
 695   char sym[30];
 696
 697   sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count);
 698   ++label_count;
 699   colon (sym);
 700
 701   if (asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname) == -1)
 702     as_fatal ("%s", xstrerror (errno));
 703   input_line_pointer = buf;
 704   s_stab ('s');
 705   free (buf);
 706
 707   input_line_pointer = hold;
 708   in_dot_func_p = 0;
 709   current_function_label = NULL;
 710 }