1 /* Generic stabs parsing for gas.
2 Copyright 1989, 1990, 1991, 1993, 1995, 1996, 1997, 1998, 2000, 2001
3 2002, 2003, 2004, 2005, 2007, 2009 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 3,
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, 51 Franklin Street - Fifth Floor, Boston, MA
23 #include "filenames.h"
28 /* We need this, despite the apparent object format dependency, since
29 it defines stab types, which all object formats can use now. */
31 #include "aout/stab_gnu.h"
33 /* Holds whether the assembler is generating stabs line debugging
34 information or not. Potentially used by md_cleanup function. */
36 int outputting_stabs_line_debug
= 0;
38 static void s_stab_generic (int, char *, char *);
39 static void generate_asm_file (int, char *);
41 /* Allow backends to override the names used for the stab sections. */
42 #ifndef STAB_SECTION_NAME
43 #define STAB_SECTION_NAME ".stab"
46 #ifndef STAB_STRING_SECTION_NAME
47 #define STAB_STRING_SECTION_NAME ".stabstr"
50 /* Non-zero if we're in the middle of a .func function, in which case
51 stabs_generate_asm_lineno emits function relative line number stabs.
52 Otherwise it emits line number stabs with absolute addresses. Note that
53 both cases only apply to assembler code assembled with -gstabs. */
54 static int in_dot_func_p
;
56 /* Label at start of current function if in_dot_func_p != 0. */
57 static const char *current_function_label
;
60 * Handle .stabX directives, which used to be open-coded.
61 * So much creeping featurism overloaded the semantics that we decided
62 * to put all .stabX thinking in one place. Here.
64 * We try to make any .stabX directive legal. Other people's AS will often
65 * do assembly-time consistency checks: eg assigning meaning to n_type bits
66 * and "protecting" you from setting them to certain values. (They also zero
67 * certain bits before emitting symbols. Tut tut.)
69 * If an expression is not absolute we either gripe or use the relocation
70 * information. Other people's assemblers silently forget information they
71 * don't need and invent information they need that you didn't supply.
75 * Build a string dictionary entry for a .stabX symbol.
76 * The symbol is added to the .<secname>str section.
79 #ifndef SEPARATE_STAB_SECTIONS
80 #define SEPARATE_STAB_SECTIONS 0
84 get_stab_string_offset (const char *string
, const char *stabstr_secname
)
93 if (! SEPARATE_STAB_SECTIONS
)
96 length
= strlen (string
);
99 save_subseg
= now_subseg
;
101 /* Create the stab string section. */
102 seg
= subseg_new (stabstr_secname
, 0);
104 retval
= seg_info (seg
)->stabu
.stab_string_size
;
107 /* Make sure the first string is empty. */
110 retval
= seg_info (seg
)->stabu
.stab_string_size
= 1;
111 bfd_set_section_flags (stdoutput
, seg
, SEC_READONLY
| SEC_DEBUGGING
);
112 if (seg
->name
== stabstr_secname
)
113 seg
->name
= xstrdup (stabstr_secname
);
117 { /* Ordinary case. */
118 p
= frag_more (length
+ 1);
121 seg_info (seg
)->stabu
.stab_string_size
+= length
+ 1;
126 subseg_set (save_seg
, save_subseg
);
132 #ifndef OBJ_PROCESS_STAB
133 #define OBJ_PROCESS_STAB(SEG,W,S,T,O,D) aout_process_stab(W,S,T,O,D)
136 /* Here instead of obj-aout.c because other formats use it too. */
138 aout_process_stab (what
, string
, type
, other
, desc
)
141 int type
, other
, desc
;
143 /* Put the stab information in the symbol table. */
146 /* Create the symbol now, but only insert it into the symbol chain
147 after any symbols mentioned in the value expression get into the
148 symbol chain. This is to avoid "continuation symbols" (where one
149 ends in "\" and the debug info is continued in the next .stabs
150 directive) from being separated by other random symbols. */
151 symbol
= symbol_create (string
, undefined_section
, 0,
153 if (what
== 's' || what
== 'n')
155 /* Pick up the value from the input line. */
160 /* .stabd sets the name to NULL. Why? */
161 S_SET_NAME (symbol
, NULL
);
162 symbol_set_frag (symbol
, frag_now
);
163 S_SET_VALUE (symbol
, (valueT
) frag_now_fix ());
166 symbol_append (symbol
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
168 symbol_get_bfdsym (symbol
)->flags
|= BSF_DEBUGGING
;
170 S_SET_TYPE (symbol
, type
);
171 S_SET_OTHER (symbol
, other
);
172 S_SET_DESC (symbol
, desc
);
176 /* This can handle different kinds of stabs (s,n,d) and different
177 kinds of stab sections. */
180 s_stab_generic (int what
, char *stab_secname
, char *stabstr_secname
)
183 char *string
, *saved_string_obstack_end
;
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. */
199 saved_string_obstack_end
= 0;
205 string
= demand_copy_C_string (&length
);
206 /* FIXME: We should probably find some other temporary storage
207 for string, rather than leaking memory if someone else
208 happens to use the notes obstack. */
209 saved_string_obstack_end
= notes
.next_free
;
211 if (*input_line_pointer
== ',')
212 input_line_pointer
++;
215 as_warn (_(".stab%c: missing comma"), what
);
216 ignore_rest_of_line ();
221 if (get_absolute_expression_and_terminator (&longint
) != ',')
223 as_warn (_(".stab%c: missing comma"), what
);
224 ignore_rest_of_line ();
229 if (get_absolute_expression_and_terminator (&longint
) != ',')
231 as_warn (_(".stab%c: missing comma"), what
);
232 ignore_rest_of_line ();
237 desc
= get_absolute_expression ();
239 if ((desc
> 0xffff) || (desc
< -0x8000))
240 /* This could happen for example with a source file with a huge
241 number of lines. The only cure is to use a different debug
242 format, probably DWARF. */
243 as_warn (_(".stab%c: description field '%x' too big, try a different debug format"),
246 if (what
== 's' || what
== 'n')
248 if (*input_line_pointer
!= ',')
250 as_warn (_(".stab%c: missing comma"), what
);
251 ignore_rest_of_line ();
254 input_line_pointer
++;
260 /* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were
261 given 4 arguments, make it a .stabn */
262 else if (what
== 'd')
264 char *save_location
= input_line_pointer
;
267 if (*input_line_pointer
== ',')
269 input_line_pointer
++;
273 input_line_pointer
= save_location
;
284 listing_source_line ((unsigned int) desc
);
288 listing_source_file (string
);
292 #endif /* ! NO_LISTING */
294 /* We have now gathered the type, other, and desc information. For
295 .stabs or .stabn, input_line_pointer is now pointing at the
298 if (SEPARATE_STAB_SECTIONS
)
299 /* Output the stab information in a separate section. This is used
300 at least for COFF and ELF. */
302 segT saved_seg
= now_seg
;
303 subsegT saved_subseg
= now_subseg
;
304 fragS
*saved_frag
= frag_now
;
310 static segT cached_sec
;
311 static char *cached_secname
;
313 dot
= frag_now_fix ();
315 #ifdef md_flush_pending_output
316 md_flush_pending_output ();
319 if (cached_secname
&& !strcmp (cached_secname
, stab_secname
))
326 seg
= subseg_new (stab_secname
, 0);
328 free (cached_secname
);
329 cached_secname
= xstrdup (stab_secname
);
333 if (! seg_info (seg
)->hadone
)
335 bfd_set_section_flags (stdoutput
, seg
,
336 SEC_READONLY
| SEC_RELOC
| SEC_DEBUGGING
);
337 #ifdef INIT_STAB_SECTION
338 INIT_STAB_SECTION (seg
);
340 seg_info (seg
)->hadone
= 1;
343 stroff
= get_stab_string_offset (string
, stabstr_secname
);
346 /* Release the string, if nobody else has used the obstack. */
347 if (saved_string_obstack_end
== notes
.next_free
)
348 obstack_free (¬es
, string
);
351 /* At least for now, stabs in a special stab section are always
352 output as 12 byte blocks of information. */
354 md_number_to_chars (p
, (valueT
) stroff
, 4);
355 md_number_to_chars (p
+ 4, (valueT
) type
, 1);
356 md_number_to_chars (p
+ 5, (valueT
) other
, 1);
357 md_number_to_chars (p
+ 6, (valueT
) desc
, 2);
359 if (what
== 's' || what
== 'n')
361 /* Pick up the value from the input line. */
363 input_line_pointer
--;
370 /* Arrange for a value representing the current location. */
371 symbol
= symbol_temp_new (saved_seg
, dot
, saved_frag
);
374 exp
.X_add_symbol
= symbol
;
375 exp
.X_add_number
= 0;
380 #ifdef OBJ_PROCESS_STAB
381 OBJ_PROCESS_STAB (seg
, what
, string
, type
, other
, desc
);
384 subseg_set (saved_seg
, saved_subseg
);
388 #ifdef OBJ_PROCESS_STAB
389 OBJ_PROCESS_STAB (0, what
, string
, type
, other
, desc
);
395 demand_empty_rest_of_line ();
398 /* Regular stab directive. */
403 s_stab_generic (what
, STAB_SECTION_NAME
, STAB_STRING_SECTION_NAME
);
406 /* "Extended stabs", used in Solaris only now. */
412 char *stab_secname
, *stabstr_secname
;
413 static char *saved_secname
, *saved_strsecname
;
415 /* @@ MEMORY LEAK: This allocates a copy of the string, but in most
416 cases it will be the same string, so we could release the storage
417 back to the obstack it came from. */
418 stab_secname
= demand_copy_C_string (&length
);
420 if (*input_line_pointer
== ',')
421 input_line_pointer
++;
424 as_bad (_("comma missing in .xstabs"));
425 ignore_rest_of_line ();
429 /* To get the name of the stab string section, simply add "str" to
430 the stab section name. */
431 if (saved_secname
== 0 || strcmp (saved_secname
, stab_secname
))
433 stabstr_secname
= (char *) xmalloc (strlen (stab_secname
) + 4);
434 strcpy (stabstr_secname
, stab_secname
);
435 strcat (stabstr_secname
, "str");
438 free (saved_secname
);
439 free (saved_strsecname
);
441 saved_secname
= stab_secname
;
442 saved_strsecname
= stabstr_secname
;
444 s_stab_generic (what
, saved_secname
, saved_strsecname
);
449 /* Frob invented at RMS' request. Set the n_desc of a symbol. */
453 int ignore ATTRIBUTE_UNUSED
;
461 name
= input_line_pointer
;
462 c
= get_symbol_end ();
463 p
= input_line_pointer
;
466 if (*input_line_pointer
!= ',')
469 as_bad (_("expected comma after \"%s\""), name
);
471 ignore_rest_of_line ();
475 input_line_pointer
++;
476 temp
= get_absolute_expression ();
478 symbolP
= symbol_find_or_make (name
);
480 S_SET_DESC (symbolP
, temp
);
482 demand_empty_rest_of_line ();
485 #endif /* defined (S_SET_DESC) */
487 /* Generate stabs debugging information to denote the main source file. */
490 stabs_generate_asm_file (void)
495 as_where (&file
, &lineno
);
496 if (use_gnu_debug_info_extensions
)
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
);
506 generate_asm_file (N_SO
, file
);
509 /* Generate stabs debugging information to denote the source file.
510 TYPE is one of N_SO, N_SOL. */
513 generate_asm_file (int type
, char *file
)
515 static char *last_file
;
516 static int label_count
;
521 char *file_endp
= file
+ strlen (file
);
524 if (last_file
!= NULL
525 && filename_cmp (last_file
, file
) == 0)
528 /* Rather than try to do this in some efficient fashion, we just
529 generate a string and then parse it again. That lets us use the
530 existing stabs hook, which expect to see a string, rather than
531 inventing new ones. */
532 hold
= input_line_pointer
;
534 sprintf (sym
, "%sF%d", FAKE_LABEL_NAME
, label_count
);
537 /* Allocate enough space for the file name (possibly extended with
538 doubled up backslashes), the symbol name, and the other characters
539 that make up a stabs file directive. */
540 bufp
= buf
= (char *) xmalloc (2 * strlen (file
) + strlen (sym
) + 12);
544 while (tmp
< file_endp
)
546 char *bslash
= strchr (tmp
, '\\');
547 size_t len
= (bslash
) ? (size_t) (bslash
- tmp
+ 1) : strlen (tmp
);
549 /* Double all backslashes, since demand_copy_C_string (used by
550 s_stab to extract the part in quotes) will try to replace them as
551 escape sequences. backslash may appear in a filespec. */
552 strncpy (bufp
, tmp
, len
);
561 sprintf (bufp
, "\",%d,0,0,%s\n", type
, sym
);
563 input_line_pointer
= buf
;
567 if (last_file
!= NULL
)
569 last_file
= xstrdup (file
);
573 input_line_pointer
= hold
;
576 /* Generate stabs debugging information for the current line. This is
577 used to produce debugging information for an assembler file. */
580 stabs_generate_asm_lineno (void)
582 static int label_count
;
588 /* Remember the last file/line and avoid duplicates. */
589 static unsigned int prev_lineno
= -1;
590 static char *prev_file
= NULL
;
592 /* Rather than try to do this in some efficient fashion, we just
593 generate a string and then parse it again. That lets us use the
594 existing stabs hook, which expect to see a string, rather than
595 inventing new ones. */
597 hold
= input_line_pointer
;
599 as_where (&file
, &lineno
);
601 /* Don't emit sequences of stabs for the same line. */
602 if (prev_file
== NULL
)
604 /* First time thru. */
605 prev_file
= xstrdup (file
);
606 prev_lineno
= lineno
;
608 else if (lineno
== prev_lineno
609 && filename_cmp (file
, prev_file
) == 0)
611 /* Same file/line as last time. */
616 /* Remember file/line for next time. */
617 prev_lineno
= lineno
;
618 if (filename_cmp (file
, prev_file
) != 0)
621 prev_file
= xstrdup (file
);
625 /* Let the world know that we are in the middle of generating a
626 piece of stabs line debugging information. */
627 outputting_stabs_line_debug
= 1;
629 generate_asm_file (N_SOL
, file
);
631 sprintf (sym
, "%sL%d", FAKE_LABEL_NAME
, label_count
);
636 buf
= (char *) alloca (100 + strlen (current_function_label
));
637 sprintf (buf
, "%d,0,%d,%s-%s\n", N_SLINE
, lineno
,
638 sym
, current_function_label
);
642 buf
= (char *) alloca (100);
643 sprintf (buf
, "%d,0,%d,%s\n", N_SLINE
, lineno
, sym
);
645 input_line_pointer
= buf
;
649 input_line_pointer
= hold
;
650 outputting_stabs_line_debug
= 0;
653 /* Emit a function stab.
654 All assembler functions are assumed to have return type `void'. */
657 stabs_generate_asm_func (const char *funcname
, const char *startlabname
)
659 static int void_emitted_p
;
660 char *hold
= input_line_pointer
;
665 if (! void_emitted_p
)
667 input_line_pointer
= "\"void:t1=1\",128,0,0,0";
672 as_where (&file
, &lineno
);
673 if (asprintf (&buf
, "\"%s:F1\",%d,0,%d,%s",
674 funcname
, N_FUN
, lineno
+ 1, startlabname
) == -1)
675 as_fatal ("%s", xstrerror (errno
));
676 input_line_pointer
= buf
;
680 input_line_pointer
= hold
;
681 current_function_label
= xstrdup (startlabname
);
685 /* Emit a stab to record the end of a function. */
688 stabs_generate_asm_endfunc (const char *funcname ATTRIBUTE_UNUSED
,
689 const char *startlabname
)
691 static int label_count
;
692 char *hold
= input_line_pointer
;
696 sprintf (sym
, "%sendfunc%d", FAKE_LABEL_NAME
, label_count
);
700 if (asprintf (&buf
, "\"\",%d,0,0,%s-%s", N_FUN
, sym
, startlabname
) == -1)
701 as_fatal ("%s", xstrerror (errno
));
702 input_line_pointer
= buf
;
706 input_line_pointer
= hold
;
708 current_function_label
= NULL
;