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.
5 This file is part of GAS, the GNU Assembler.
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.
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.
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
27 /* We need this, despite the apparent object format dependency, since
28 it defines stab types, which all object formats can use now. */
30 #include "aout/stab_gnu.h"
32 static void s_stab_generic PARAMS ((int, char *, char *));
33 static void generate_asm_file PARAMS ((int, char *));
35 /* Allow backends to override the names used for the stab sections. */
36 #ifndef STAB_SECTION_NAME
37 #define STAB_SECTION_NAME ".stab"
40 #ifndef STAB_STRING_SECTION_NAME
41 #define STAB_STRING_SECTION_NAME ".stabstr"
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;
50 /* Label at start of current function if in_dot_func_p != 0. */
51 static const char *current_function_label;
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.
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.)
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.
69 * Build a string dictionary entry for a .stabX symbol.
70 * The symbol is added to the .<secname>str section.
73 #ifndef SEPARATE_STAB_SECTIONS
74 #define SEPARATE_STAB_SECTIONS 0
78 get_stab_string_offset (string, stabstr_secname)
80 const char *stabstr_secname;
89 if (! SEPARATE_STAB_SECTIONS)
92 length = strlen (string);
95 save_subseg = now_subseg;
97 /* Create the stab string section. */
98 seg = subseg_new (stabstr_secname, 0);
100 retval = seg_info (seg)->stabu.stab_string_size;
103 /* Make sure the first string is empty. */
106 retval = seg_info (seg)->stabu.stab_string_size = 1;
108 bfd_set_section_flags (stdoutput, seg, SEC_READONLY | SEC_DEBUGGING);
109 if (seg->name == stabstr_secname)
110 seg->name = xstrdup (stabstr_secname);
115 { /* Ordinary case. */
116 p = frag_more (length + 1);
119 seg_info (seg)->stabu.stab_string_size += length + 1;
124 subseg_set (save_seg, save_subseg);
130 #ifndef OBJ_PROCESS_STAB
131 #define OBJ_PROCESS_STAB(SEG,W,S,T,O,D) aout_process_stab(W,S,T,O,D)
134 /* Here instead of obj-aout.c because other formats use it too. */
136 aout_process_stab (what, string, type, other, desc)
139 int type, other, desc;
141 /* Put the stab information in the symbol table. */
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')
153 /* Pick up the value from the input line. */
154 symbol_set_frag (symbol, &zero_address_frag);
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 ());
165 symbol_append (symbol, symbol_lastP, &symbol_rootP, &symbol_lastP);
167 S_SET_TYPE (symbol, type);
168 S_SET_OTHER (symbol, other);
169 S_SET_DESC (symbol, desc);
173 /* This can handle different kinds of stabs (s,n,d) and different
174 kinds of stab sections. */
177 s_stab_generic (what, stab_secname, stabstr_secname)
180 char *stabstr_secname;
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. */
202 string = demand_copy_C_string (&length);
204 if (*input_line_pointer == ',')
205 input_line_pointer++;
208 as_warn (_(".stabs: Missing comma"));
209 ignore_rest_of_line ();
214 if (get_absolute_expression_and_terminator (&longint) != ',')
216 as_warn (_(".stab%c: Missing comma"), what);
217 ignore_rest_of_line ();
222 if (get_absolute_expression_and_terminator (&longint) != ',')
224 as_warn (_(".stab%c: Missing comma"), what);
225 ignore_rest_of_line ();
230 desc = get_absolute_expression ();
231 if (what == 's' || what == 'n')
233 if (*input_line_pointer != ',')
235 as_warn (_(".stab%c: Missing comma"), what);
236 ignore_rest_of_line ();
239 input_line_pointer++;
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')
249 char *save_location = input_line_pointer;
252 if (*input_line_pointer == ',')
254 input_line_pointer++;
258 input_line_pointer = save_location;
269 listing_source_line ((unsigned int) desc);
273 listing_source_file (string);
277 #endif /* ! NO_LISTING */
279 /* We have now gathered the type, other, and desc information. For
280 .stabs or .stabn, input_line_pointer is now pointing at the
283 if (SEPARATE_STAB_SECTIONS)
284 /* Output the stab information in a separate section. This is used
285 at least for COFF and ELF. */
287 segT saved_seg = now_seg;
288 subsegT saved_subseg = now_subseg;
289 fragS *saved_frag = frag_now;
295 static segT cached_sec;
296 static char *cached_secname;
298 dot = frag_now_fix ();
300 #ifdef md_flush_pending_output
301 md_flush_pending_output ();
304 if (cached_secname && !strcmp (cached_secname, stab_secname))
311 seg = subseg_new (stab_secname, 0);
313 free (cached_secname);
314 cached_secname = xstrdup (stab_secname);
318 if (! seg_info (seg)->hadone)
321 bfd_set_section_flags (stdoutput, seg,
322 SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
324 #ifdef INIT_STAB_SECTION
325 INIT_STAB_SECTION (seg);
327 seg_info (seg)->hadone = 1;
330 stroff = get_stab_string_offset (string, stabstr_secname);
333 /* release the string */
334 obstack_free (¬es, string);
337 /* At least for now, stabs in a special stab section are always
338 output as 12 byte blocks of information. */
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);
345 if (what == 's' || what == 'n')
347 /* Pick up the value from the input line. */
349 input_line_pointer--;
357 /* Arrange for a value representing the current location. */
358 fake = FAKE_LABEL_NAME;
359 symbol = symbol_new (fake, saved_seg, dot, saved_frag);
362 exp.X_add_symbol = symbol;
363 exp.X_add_number = 0;
368 #ifdef OBJ_PROCESS_STAB
369 OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
372 subseg_set (saved_seg, saved_subseg);
376 #ifdef OBJ_PROCESS_STAB
377 OBJ_PROCESS_STAB (0, what, string, type, other, desc);
383 demand_empty_rest_of_line ();
386 /* Regular stab directive. */
392 s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
395 /* "Extended stabs", used in Solaris only now. */
402 char *stab_secname, *stabstr_secname;
403 static char *saved_secname, *saved_strsecname;
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);
410 if (*input_line_pointer == ',')
411 input_line_pointer++;
414 as_bad (_("comma missing in .xstabs"));
415 ignore_rest_of_line ();
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))
423 stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
424 strcpy (stabstr_secname, stab_secname);
425 strcat (stabstr_secname, "str");
428 free (saved_secname);
429 free (saved_strsecname);
431 saved_secname = stab_secname;
432 saved_strsecname = stabstr_secname;
434 s_stab_generic (what, saved_secname, saved_strsecname);
439 /* Frob invented at RMS' request. Set the n_desc of a symbol. */
443 int ignore ATTRIBUTE_UNUSED;
451 name = input_line_pointer;
452 c = get_symbol_end ();
453 p = input_line_pointer;
456 if (*input_line_pointer != ',')
459 as_bad (_("Expected comma after name \"%s\""), name);
461 ignore_rest_of_line ();
465 input_line_pointer++;
466 temp = get_absolute_expression ();
468 symbolP = symbol_find_or_make (name);
470 S_SET_DESC (symbolP, temp);
472 demand_empty_rest_of_line ();
475 #endif /* defined (S_SET_DESC) */
477 /* Generate stabs debugging information to denote the main source file. */
480 stabs_generate_asm_file ()
485 as_where (&file, &lineno);
486 generate_asm_file (N_SO, file);
489 /* Generate stabs debugging information to denote the source file.
490 TYPE is one of N_SO, N_SOL. */
493 generate_asm_file (type, file)
497 static char *last_file;
498 static int label_count;
503 char *endp = file + strlen (file);
506 if (last_file != NULL
507 && strcmp (last_file, file) == 0)
510 /* Rather than try to do this in some efficient fashion, we just
511 generate a string and then parse it again. That lets us use the
512 existing stabs hook, which expect to see a string, rather than
513 inventing new ones. */
514 hold = input_line_pointer;
516 sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count);
519 /* Allocate enough space for the file name (possibly extended with
520 doubled up backslashes), the symbol name, and the other characters
521 that make up a stabs file directive. */
522 bufp = buf = xmalloc (2 * strlen (file) + strlen (sym) + 12);
528 char *bslash = strchr (tmp, '\\');
529 int len = (bslash ? (bslash - tmp + 1) : strlen (tmp));
531 /* Double all backslashes, since demand_copy_C_string (used by
532 s_stab to extract the part in quotes) will try to replace them as
533 escape sequences. backslash may appear in a filespec. */
534 strncpy (bufp, tmp, len);
543 sprintf (bufp, "\",%d,0,0,%s\n", type, sym);
545 input_line_pointer = buf;
549 if (last_file != NULL)
551 last_file = xstrdup (file);
555 input_line_pointer = hold;
558 /* Generate stabs debugging information for the current line. This is
559 used to produce debugging information for an assembler file. */
562 stabs_generate_asm_lineno ()
564 static int label_count;
571 /* Rather than try to do this in some efficient fashion, we just
572 generate a string and then parse it again. That lets us use the
573 existing stabs hook, which expect to see a string, rather than
574 inventing new ones. */
576 hold = input_line_pointer;
578 as_where (&file, &lineno);
580 generate_asm_file (N_SOL, file);
582 sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count);
587 buf = (char *) alloca (100 + strlen (current_function_label));
588 sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno,
589 sym, current_function_label);
593 buf = (char *) alloca (100);
594 sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
596 input_line_pointer = buf;
600 input_line_pointer = hold;
603 /* Emit a function stab.
604 All assembler functions are assumed to have return type `void'. */
607 stabs_generate_asm_func (funcname, startlabname)
608 const char *funcname;
609 const char *startlabname;
611 static int void_emitted_p;
612 char *hold = input_line_pointer;
617 if (! void_emitted_p)
619 input_line_pointer = "\"void:t1=1\",128,0,0,0";
624 as_where (&file, &lineno);
625 asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
626 funcname, N_FUN, lineno + 1, startlabname);
627 input_line_pointer = buf;
631 input_line_pointer = hold;
632 current_function_label = xstrdup (startlabname);
636 /* Emit a stab to record the end of a function. */
639 stabs_generate_asm_endfunc (funcname, startlabname)
640 const char *funcname ATTRIBUTE_UNUSED;
641 const char *startlabname;
643 static int label_count;
644 char *hold = input_line_pointer;
648 sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count);
652 asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname);
653 input_line_pointer = buf;
657 input_line_pointer = hold;
659 current_function_label = NULL;