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, 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 /* 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   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       /* FIXME: We should probably find some other temporary storage
 209          for string, rather than leaking memory if someone else
 210          happens to use the notes obstack.  */
 211       saved_string_obstack_end = notes.next_free;
 212       SKIP_WHITESPACE ();
 213       if (*input_line_pointer == ',')
 214         input_line_pointer++;
 215       else
 216         {
 217           as_warn (_(".stab%c: missing comma"), what);
 218           ignore_rest_of_line ();
 219           return;
 220         }
 221     }
 222
 223   if (get_absolute_expression_and_terminator (&longint) != ',')
 224     {
 225       as_warn (_(".stab%c: missing comma"), what);
 226       ignore_rest_of_line ();
 227       return;
 228     }
 229   type = longint;
 230
 231   if (get_absolute_expression_and_terminator (&longint) != ',')
 232     {
 233       as_warn (_(".stab%c: missing comma"), what);
 234       ignore_rest_of_line ();
 235       return;
 236     }
 237   other = longint;
 238
 239   desc = get_absolute_expression ();
 240
 241   if ((desc > 0xffff) || (desc < -0x8000))
 242     /* This could happen for example with a source file with a huge
 243        number of lines.  The only cure is to use a different debug
 244        format, probably DWARF.  */
 245     as_warn (_(".stab%c: description field '%x' too big, try a different debug format"),
 246              what, desc);
 247
 248   if (what == 's' || what == 'n')
 249     {
 250       if (*input_line_pointer != ',')
 251         {
 252           as_warn (_(".stab%c: missing comma"), what);
 253           ignore_rest_of_line ();
 254           return;
 255         }
 256       input_line_pointer++;
 257       SKIP_WHITESPACE ();
 258     }
 259
 260 #ifdef TC_PPC
 261 #ifdef OBJ_ELF
 262   /* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were
 263      given 4 arguments, make it a .stabn */
 264   else if (what == 'd')
 265     {
 266       char *save_location = input_line_pointer;
 267
 268       SKIP_WHITESPACE ();
 269       if (*input_line_pointer == ',')
 270         {
 271           input_line_pointer++;
 272           what = 'n';
 273         }
 274       else
 275         input_line_pointer = save_location;
 276     }
 277 #endif /* OBJ_ELF */
 278 #endif /* TC_PPC */
 279
 280 #ifndef NO_LISTING
 281   if (listing)
 282     {
 283       switch (type)
 284         {
 285         case N_SLINE:
 286           listing_source_line ((unsigned int) desc);
 287           break;
 288         case N_SO:
 289         case N_SOL:
 290           listing_source_file (string);
 291           break;
 292         }
 293     }
 294 #endif /* ! NO_LISTING */
 295
 296   /* We have now gathered the type, other, and desc information.  For
 297      .stabs or .stabn, input_line_pointer is now pointing at the
 298      value.  */
 299
 300   if (SEPARATE_STAB_SECTIONS)
 301     /* Output the stab information in a separate section.  This is used
 302        at least for COFF and ELF.  */
 303     {
 304       segT saved_seg = now_seg;
 305       subsegT saved_subseg = now_subseg;
 306       fragS *saved_frag = frag_now;
 307       valueT dot;
 308       segT seg;
 309       unsigned int stroff;
 310       char *p;
 311
 312       static segT cached_sec;
 313       static char *cached_secname;
 314
 315       dot = frag_now_fix ();
 316
 317 #ifdef md_flush_pending_output
 318       md_flush_pending_output ();
 319 #endif
 320
 321       if (cached_secname && !strcmp (cached_secname, stab_secname))
 322         {
 323           seg = cached_sec;
 324           subseg_set (seg, 0);
 325         }
 326       else
 327         {
 328           seg = subseg_new (stab_secname, 0);
 329           if (cached_secname)
 330             free (cached_secname);
 331           cached_secname = xstrdup (stab_secname);
 332           cached_sec = seg;
 333         }
 334
 335       if (! seg_info (seg)->hadone)
 336         {
 337           bfd_set_section_flags (stdoutput, seg,
 338                                  SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
 339 #ifdef INIT_STAB_SECTION
 340           INIT_STAB_SECTION (seg);
 341 #endif
 342           seg_info (seg)->hadone = 1;
 343         }
 344
 345       stroff = get_stab_string_offset (string, stabstr_secname);
 346       if (what == 's')
 347         {
 348           /* Release the string, if nobody else has used the obstack.  */
 349           if (saved_string_obstack_end == notes.next_free)
 350             obstack_free (&notes, string);
 351         }
 352
 353       /* At least for now, stabs in a special stab section are always
 354          output as 12 byte blocks of information.  */
 355       p = frag_more (8);
 356       md_number_to_chars (p, (valueT) stroff, 4);
 357       md_number_to_chars (p + 4, (valueT) type, 1);
 358       md_number_to_chars (p + 5, (valueT) other, 1);
 359       md_number_to_chars (p + 6, (valueT) desc, 2);
 360
 361       if (what == 's' || what == 'n')
 362         {
 363           /* Pick up the value from the input line.  */
 364           cons (4);
 365           input_line_pointer--;
 366         }
 367       else
 368         {
 369           symbolS *symbol;
 370           expressionS exp;
 371
 372           /* Arrange for a value representing the current location.  */
 373           symbol = symbol_temp_new (saved_seg, dot, saved_frag);
 374
 375           exp.X_op = O_symbol;
 376           exp.X_add_symbol = symbol;
 377           exp.X_add_number = 0;
 378
 379           emit_expr (&exp, 4);
 380         }
 381
 382 #ifdef OBJ_PROCESS_STAB
 383       OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
 384 #endif
 385
 386       subseg_set (saved_seg, saved_subseg);
 387     }
 388   else
 389     {
 390 #ifdef OBJ_PROCESS_STAB
 391       OBJ_PROCESS_STAB (0, what, string, type, other, desc);
 392 #else
 393       abort ();
 394 #endif
 395     }
 396
 397   demand_empty_rest_of_line ();
 398 }
 399
 400 /* Regular stab directive.  */
 401
 402 void
 403 s_stab (int what)
 404 {
 405   s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
 406 }
 407
 408 /* "Extended stabs", used in Solaris only now.  */
 409
 410 void
 411 s_xstab (int what)
 412 {
 413   int length;
 414   char *stab_secname, *stabstr_secname;
 415   static char *saved_secname, *saved_strsecname;
 416
 417   /* @@ MEMORY LEAK: This allocates a copy of the string, but in most
 418      cases it will be the same string, so we could release the storage
 419      back to the obstack it came from.  */
 420   stab_secname = demand_copy_C_string (&length);
 421   SKIP_WHITESPACE ();
 422   if (*input_line_pointer == ',')
 423     input_line_pointer++;
 424   else
 425     {
 426       as_bad (_("comma missing in .xstabs"));
 427       ignore_rest_of_line ();
 428       return;
 429     }
 430
 431   /* To get the name of the stab string section, simply add "str" to
 432      the stab section name.  */
 433   if (saved_secname == 0 || strcmp (saved_secname, stab_secname))
 434     {
 435       stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
 436       strcpy (stabstr_secname, stab_secname);
 437       strcat (stabstr_secname, "str");
 438       if (saved_secname)
 439         {
 440           free (saved_secname);
 441           free (saved_strsecname);
 442         }
 443       saved_secname = stab_secname;
 444       saved_strsecname = stabstr_secname;
 445     }
 446   s_stab_generic (what, saved_secname, saved_strsecname);
 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 (ignore)
 455      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 = (char *) alloca (strlen (dir) + 2);
 504       sprintf (dir2, "%s%s", dir, "/");
 505       generate_asm_file (N_SO, 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 *hold;
 520   char sym[30];
 521   char *buf;
 522   const char *tmp = file;
 523   const char *file_endp = file + strlen (file);
 524   char *bufp;
 525
 526   if (last_file != NULL
 527       && filename_cmp (last_file, file) == 0)
 528     return;
 529
 530   /* Rather than try to do this in some efficient fashion, we just
 531      generate a string and then parse it again.  That lets us use the
 532      existing stabs hook, which expect to see a string, rather than
 533      inventing new ones.  */
 534   hold = input_line_pointer;
 535
 536   sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count);
 537   ++label_count;
 538
 539   /* Allocate enough space for the file name (possibly extended with
 540      doubled up backslashes), the symbol name, and the other characters
 541      that make up a stabs file directive.  */
 542   bufp = buf = (char *) xmalloc (2 * strlen (file) + strlen (sym) + 12);
 543
 544   *bufp++ = '"';
 545
 546   while (tmp < file_endp)
 547     {
 548       char *bslash = strchr (tmp, '\\');
 549       size_t len = (bslash) ? (size_t) (bslash - tmp + 1) : strlen (tmp);
 550
 551       /* Double all backslashes, since demand_copy_C_string (used by
 552          s_stab to extract the part in quotes) will try to replace them as
 553          escape sequences.  backslash may appear in a filespec.  */
 554       strncpy (bufp, tmp, len);
 555
 556       tmp += len;
 557       bufp += len;
 558
 559       if (bslash != NULL)
 560         *bufp++ = '\\';
 561     }
 562
 563   sprintf (bufp, "\",%d,0,0,%s\n", type, sym);
 564
 565   input_line_pointer = buf;
 566   s_stab ('s');
 567   colon (sym);
 568
 569   if (last_file != NULL)
 570     free (last_file);
 571   last_file = xstrdup (file);
 572
 573   free (buf);
 574
 575   input_line_pointer = hold;
 576 }
 577
 578 /* Generate stabs debugging information for the current line.  This is
 579    used to produce debugging information for an assembler file.  */
 580
 581 void
 582 stabs_generate_asm_lineno (void)
 583 {
 584   static int label_count;
 585   char *hold;
 586   const char *file;
 587   unsigned int lineno;
 588   char *buf;
 589   char sym[30];
 590   /* Remember the last file/line and avoid duplicates.  */
 591   static unsigned int prev_lineno = -1;
 592   static char *prev_file = NULL;
 593
 594   /* Rather than try to do this in some efficient fashion, we just
 595      generate a string and then parse it again.  That lets us use the
 596      existing stabs hook, which expect to see a string, rather than
 597      inventing new ones.  */
 598
 599   hold = input_line_pointer;
 600
 601   file = as_where (&lineno);
 602
 603   /* Don't emit sequences of stabs for the same line.  */
 604   if (prev_file == NULL)
 605     {
 606       /* First time thru.  */
 607       prev_file = xstrdup (file);
 608       prev_lineno = lineno;
 609     }
 610   else if (lineno == prev_lineno
 611            && filename_cmp (file, prev_file) == 0)
 612     {
 613       /* Same file/line as last time.  */
 614       return;
 615     }
 616   else
 617     {
 618       /* Remember file/line for next time.  */
 619       prev_lineno = lineno;
 620       if (filename_cmp (file, prev_file) != 0)
 621         {
 622           free (prev_file);
 623           prev_file = xstrdup (file);
 624         }
 625     }
 626
 627   /* Let the world know that we are in the middle of generating a
 628      piece of stabs line debugging information.  */
 629   outputting_stabs_line_debug = 1;
 630
 631   generate_asm_file (N_SOL, file);
 632
 633   sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count);
 634   ++label_count;
 635
 636   if (in_dot_func_p)
 637     {
 638       buf = (char *) alloca (100 + strlen (current_function_label));
 639       sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno,
 640                sym, current_function_label);
 641     }
 642   else
 643     {
 644       buf = (char *) alloca (100);
 645       sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
 646     }
 647   input_line_pointer = buf;
 648   s_stab ('n');
 649   colon (sym);
 650
 651   input_line_pointer = hold;
 652   outputting_stabs_line_debug = 0;
 653 }
 654
 655 /* Emit a function stab.
 656    All assembler functions are assumed to have return type `void'.  */
 657
 658 void
 659 stabs_generate_asm_func (const char *funcname, const char *startlabname)
 660 {
 661   static int void_emitted_p;
 662   char *hold = input_line_pointer;
 663   char *buf;
 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 (&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 }