gas/stabs.c

   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
   5 This file is part of GAS, the GNU Assembler.
   6
   7 GAS is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as
   9 published by the Free Software Foundation; either version 2,
  10 or (at your option) any later version.
  11
  12 GAS is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15 the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GAS; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-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
  35 boolean outputting_stabs_line_debug = 0;
  36
  37 static void s_stab_generic PARAMS ((int, char *, char *));
  38 static 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.  */
  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 (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.  */
 140 void
 141 aout_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
 181 static void
 182 s_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 (&notes, 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
 393 void
 394 s_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
 402 void
 403 s_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
 446 void
 447 s_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
 484 void
 485 stabs_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
 497 static void
 498 generate_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
 566 void
 567 stabs_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
 616 void
 617 stabs_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
 648 void
 649 stabs_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 }