gas/stabs.c

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