* emultempl/beos.em: Remove ARGSUSED.
[deliverable/binutils-gdb.git] / gas / stabs.c
CommitLineData
252b5132 1/* Generic stabs parsing for gas.
f7e42eb4 2 Copyright 1989, 1990, 1991, 1993, 1995, 1996, 1997, 1998, 2000, 2001
252b5132
RH
3 Free Software Foundation, Inc.
4
5This file is part of GAS, the GNU Assembler.
6
7GAS is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as
9published by the Free Software Foundation; either version 2,
10or (at your option) any later version.
11
12GAS is distributed in the hope that it will be useful, but
13WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15the GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with GAS; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
f0e652b4 2002111-1307, USA. */
252b5132
RH
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
f0e652b4 28 it defines stab types, which all object formats can use now. */
252b5132
RH
29
30#include "aout/stab_gnu.h"
31
bccba5f0
NC
32/* Holds whether the assembler is generating stabs line debugging
33 information or not. Potentially used by md_cleanup function. */
34
92eb7b32 35int outputting_stabs_line_debug = 0;
bccba5f0 36
252b5132
RH
37static void s_stab_generic PARAMS ((int, char *, char *));
38static 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. */
53static int in_dot_func_p;
54
55/* Label at start of current function if in_dot_func_p != 0. */
56static 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
82unsigned int
83get_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)
f0e652b4 120 { /* Ordinary case. */
252b5132
RH
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
0aa5d426
HPN
139/* Here instead of obj-aout.c because other formats use it too. */
140void
252b5132
RH
141aout_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. */
49309057 159 symbol_set_frag (symbol, &zero_address_frag);
252b5132
RH
160 pseudo_set (symbol);
161 }
162 else
163 {
164 /* .stabd sets the name to NULL. Why? */
165 S_SET_NAME (symbol, NULL);
49309057 166 symbol_set_frag (symbol, frag_now);
252b5132
RH
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
f0e652b4 179 kinds of stab sections. */
252b5132 180
f0e652b4 181static void
252b5132
RH
182s_stab_generic (what, stab_secname, stabstr_secname)
183 int what;
184 char *stab_secname;
185 char *stabstr_secname;
186{
187 long longint;
d68d4570 188 char *string, *saved_string_obstack_end;
252b5132
RH
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')
d68d4570
DD
202 {
203 string = "";
204 saved_string_obstack_end = 0;
205 }
252b5132
RH
206 else
207 {
208 int length;
209
210 string = demand_copy_C_string (&length);
d68d4570
DD
211 /* FIXME: We should probably find some other temporary storage
212 for string, rather than leaking memory if someone else
213 happens to use the notes obstack. */
214 saved_string_obstack_end = notes.next_free;
252b5132
RH
215 SKIP_WHITESPACE ();
216 if (*input_line_pointer == ',')
217 input_line_pointer++;
218 else
219 {
0e389e77 220 as_warn (_(".stab%c: missing comma"), what);
252b5132
RH
221 ignore_rest_of_line ();
222 return;
223 }
224 }
225
226 if (get_absolute_expression_and_terminator (&longint) != ',')
227 {
0e389e77 228 as_warn (_(".stab%c: missing comma"), what);
252b5132
RH
229 ignore_rest_of_line ();
230 return;
231 }
232 type = longint;
233
234 if (get_absolute_expression_and_terminator (&longint) != ',')
235 {
0e389e77 236 as_warn (_(".stab%c: missing comma"), what);
252b5132
RH
237 ignore_rest_of_line ();
238 return;
239 }
240 other = longint;
241
242 desc = get_absolute_expression ();
6360824b
NC
243
244 if ((desc > 0xffff) || (desc < -0x8000))
245 /* This could happen for example with a source file with a huge
246 number of lines. The only cure is to use a different debug
247 format, probably DWARF. */
7193a0e7 248 as_warn (_(".stab%c: description field '%x' too big, try a different debug format"),
6360824b 249 what, desc);
411863a4 250
252b5132
RH
251 if (what == 's' || what == 'n')
252 {
253 if (*input_line_pointer != ',')
254 {
0e389e77 255 as_warn (_(".stab%c: missing comma"), what);
252b5132
RH
256 ignore_rest_of_line ();
257 return;
258 }
259 input_line_pointer++;
260 SKIP_WHITESPACE ();
261 }
262
263#ifdef TC_PPC
264#ifdef OBJ_ELF
265 /* Solaris on PowerPC has decided that .stabd can take 4 arguments, so if we were
266 given 4 arguments, make it a .stabn */
267 else if (what == 'd')
268 {
269 char *save_location = input_line_pointer;
270
271 SKIP_WHITESPACE ();
272 if (*input_line_pointer == ',')
273 {
274 input_line_pointer++;
275 what = 'n';
276 }
277 else
278 input_line_pointer = save_location;
279 }
280#endif /* OBJ_ELF */
281#endif /* TC_PPC */
282
283#ifndef NO_LISTING
284 if (listing)
285 {
286 switch (type)
287 {
288 case N_SLINE:
289 listing_source_line ((unsigned int) desc);
290 break;
291 case N_SO:
292 case N_SOL:
293 listing_source_file (string);
294 break;
295 }
296 }
297#endif /* ! NO_LISTING */
298
299 /* We have now gathered the type, other, and desc information. For
300 .stabs or .stabn, input_line_pointer is now pointing at the
301 value. */
302
303 if (SEPARATE_STAB_SECTIONS)
304 /* Output the stab information in a separate section. This is used
305 at least for COFF and ELF. */
306 {
307 segT saved_seg = now_seg;
308 subsegT saved_subseg = now_subseg;
309 fragS *saved_frag = frag_now;
310 valueT dot;
311 segT seg;
312 unsigned int stroff;
313 char *p;
314
315 static segT cached_sec;
316 static char *cached_secname;
317
318 dot = frag_now_fix ();
319
320#ifdef md_flush_pending_output
321 md_flush_pending_output ();
322#endif
323
324 if (cached_secname && !strcmp (cached_secname, stab_secname))
325 {
326 seg = cached_sec;
327 subseg_set (seg, 0);
328 }
329 else
330 {
331 seg = subseg_new (stab_secname, 0);
332 if (cached_secname)
333 free (cached_secname);
334 cached_secname = xstrdup (stab_secname);
335 cached_sec = seg;
336 }
337
338 if (! seg_info (seg)->hadone)
339 {
340#ifdef BFD_ASSEMBLER
341 bfd_set_section_flags (stdoutput, seg,
342 SEC_READONLY | SEC_RELOC | SEC_DEBUGGING);
343#endif
344#ifdef INIT_STAB_SECTION
345 INIT_STAB_SECTION (seg);
346#endif
347 seg_info (seg)->hadone = 1;
348 }
349
350 stroff = get_stab_string_offset (string, stabstr_secname);
351 if (what == 's')
352 {
d68d4570 353 /* Release the string, if nobody else has used the obstack. */
d1a6c242 354 if (saved_string_obstack_end == notes.next_free)
d68d4570 355 obstack_free (&notes, string);
252b5132
RH
356 }
357
358 /* At least for now, stabs in a special stab section are always
359 output as 12 byte blocks of information. */
360 p = frag_more (8);
361 md_number_to_chars (p, (valueT) stroff, 4);
362 md_number_to_chars (p + 4, (valueT) type, 1);
363 md_number_to_chars (p + 5, (valueT) other, 1);
364 md_number_to_chars (p + 6, (valueT) desc, 2);
365
366 if (what == 's' || what == 'n')
367 {
368 /* Pick up the value from the input line. */
369 cons (4);
370 input_line_pointer--;
371 }
372 else
373 {
252b5132
RH
374 symbolS *symbol;
375 expressionS exp;
376
377 /* Arrange for a value representing the current location. */
756d1d01 378 symbol = symbol_temp_new (saved_seg, dot, saved_frag);
252b5132
RH
379
380 exp.X_op = O_symbol;
381 exp.X_add_symbol = symbol;
382 exp.X_add_number = 0;
383
384 emit_expr (&exp, 4);
385 }
386
387#ifdef OBJ_PROCESS_STAB
388 OBJ_PROCESS_STAB (seg, what, string, type, other, desc);
389#endif
390
391 subseg_set (saved_seg, saved_subseg);
392 }
393 else
394 {
395#ifdef OBJ_PROCESS_STAB
396 OBJ_PROCESS_STAB (0, what, string, type, other, desc);
397#else
398 abort ();
399#endif
400 }
401
402 demand_empty_rest_of_line ();
403}
404
f0e652b4 405/* Regular stab directive. */
252b5132
RH
406
407void
408s_stab (what)
409 int what;
410{
411 s_stab_generic (what, STAB_SECTION_NAME, STAB_STRING_SECTION_NAME);
412}
413
f0e652b4 414/* "Extended stabs", used in Solaris only now. */
252b5132
RH
415
416void
417s_xstab (what)
418 int what;
419{
420 int length;
421 char *stab_secname, *stabstr_secname;
422 static char *saved_secname, *saved_strsecname;
423
424 /* @@ MEMORY LEAK: This allocates a copy of the string, but in most
425 cases it will be the same string, so we could release the storage
426 back to the obstack it came from. */
427 stab_secname = demand_copy_C_string (&length);
428 SKIP_WHITESPACE ();
429 if (*input_line_pointer == ',')
430 input_line_pointer++;
431 else
432 {
433 as_bad (_("comma missing in .xstabs"));
434 ignore_rest_of_line ();
435 return;
436 }
437
438 /* To get the name of the stab string section, simply add "str" to
439 the stab section name. */
440 if (saved_secname == 0 || strcmp (saved_secname, stab_secname))
441 {
442 stabstr_secname = (char *) xmalloc (strlen (stab_secname) + 4);
443 strcpy (stabstr_secname, stab_secname);
444 strcat (stabstr_secname, "str");
445 if (saved_secname)
446 {
447 free (saved_secname);
448 free (saved_strsecname);
449 }
450 saved_secname = stab_secname;
451 saved_strsecname = stabstr_secname;
452 }
453 s_stab_generic (what, saved_secname, saved_strsecname);
454}
455
456#ifdef S_SET_DESC
457
458/* Frob invented at RMS' request. Set the n_desc of a symbol. */
459
f0e652b4 460void
252b5132 461s_desc (ignore)
0aa5d426 462 int ignore ATTRIBUTE_UNUSED;
252b5132
RH
463{
464 char *name;
465 char c;
466 char *p;
467 symbolS *symbolP;
468 int temp;
469
470 name = input_line_pointer;
471 c = get_symbol_end ();
472 p = input_line_pointer;
473 *p = c;
474 SKIP_WHITESPACE ();
475 if (*input_line_pointer != ',')
476 {
477 *p = 0;
0e389e77 478 as_bad (_("expected comma after \"%s\""), name);
252b5132
RH
479 *p = c;
480 ignore_rest_of_line ();
481 }
482 else
483 {
484 input_line_pointer++;
485 temp = get_absolute_expression ();
486 *p = 0;
487 symbolP = symbol_find_or_make (name);
488 *p = c;
489 S_SET_DESC (symbolP, temp);
490 }
491 demand_empty_rest_of_line ();
492} /* s_desc() */
493
494#endif /* defined (S_SET_DESC) */
495
496/* Generate stabs debugging information to denote the main source file. */
497
498void
499stabs_generate_asm_file ()
500{
501 char *file;
502 unsigned int lineno;
503
504 as_where (&file, &lineno);
05da4302
NC
505 if (use_gnu_debug_info_extensions)
506 {
507 char *dir, *dir2;
508
509 dir = getpwd ();
510 dir2 = alloca (strlen (dir) + 2);
511 sprintf (dir2, "%s%s", dir, "/");
512 generate_asm_file (N_SO, dir2);
513 }
252b5132
RH
514 generate_asm_file (N_SO, file);
515}
516
517/* Generate stabs debugging information to denote the source file.
518 TYPE is one of N_SO, N_SOL. */
519
520static void
521generate_asm_file (type, file)
522 int type;
523 char *file;
524{
525 static char *last_file;
526 static int label_count;
527 char *hold;
252b5132 528 char sym[30];
604d524f
NC
529 char *buf;
530 char *tmp = file;
531 char *endp = file + strlen (file);
532 char *bufp = buf;
43ad3147 533
604d524f
NC
534 if (last_file != NULL
535 && strcmp (last_file, file) == 0)
536 return;
43ad3147 537
252b5132
RH
538 /* Rather than try to do this in some efficient fashion, we just
539 generate a string and then parse it again. That lets us use the
540 existing stabs hook, which expect to see a string, rather than
541 inventing new ones. */
252b5132
RH
542 hold = input_line_pointer;
543
604d524f
NC
544 sprintf (sym, "%sF%d", FAKE_LABEL_NAME, label_count);
545 ++label_count;
546
547 /* Allocate enough space for the file name (possibly extended with
548 doubled up backslashes), the symbol name, and the other characters
549 that make up a stabs file directive. */
550 bufp = buf = xmalloc (2 * strlen (file) + strlen (sym) + 12);
43ad3147 551
604d524f
NC
552 *bufp++ = '"';
553
554 while (tmp < endp)
252b5132 555 {
604d524f 556 char *bslash = strchr (tmp, '\\');
37ffda10 557 size_t len = (bslash) ? (size_t) (bslash - tmp + 1) : strlen (tmp);
43ad3147 558
604d524f
NC
559 /* Double all backslashes, since demand_copy_C_string (used by
560 s_stab to extract the part in quotes) will try to replace them as
561 escape sequences. backslash may appear in a filespec. */
562 strncpy (bufp, tmp, len);
43ad3147 563
604d524f
NC
564 tmp += len;
565 bufp += len;
566
567 if (bslash != NULL)
568 *bufp++ = '\\';
252b5132
RH
569 }
570
604d524f
NC
571 sprintf (bufp, "\",%d,0,0,%s\n", type, sym);
572
573 input_line_pointer = buf;
574 s_stab ('s');
575 colon (sym);
576
577 if (last_file != NULL)
578 free (last_file);
579 last_file = xstrdup (file);
43ad3147 580
210dcc61 581 free (buf);
604d524f
NC
582
583 input_line_pointer = hold;
252b5132
RH
584}
585
586/* Generate stabs debugging information for the current line. This is
587 used to produce debugging information for an assembler file. */
588
589void
590stabs_generate_asm_lineno ()
591{
592 static int label_count;
593 char *hold;
594 char *file;
595 unsigned int lineno;
596 char *buf;
597 char sym[30];
d1a6c242 598 /* Remember the last file/line and avoid duplicates. */
1ea5c325
MS
599 static unsigned int prev_lineno = -1;
600 static char *prev_file = NULL;
bccba5f0 601
252b5132
RH
602 /* Rather than try to do this in some efficient fashion, we just
603 generate a string and then parse it again. That lets us use the
604 existing stabs hook, which expect to see a string, rather than
605 inventing new ones. */
606
607 hold = input_line_pointer;
608
609 as_where (&file, &lineno);
610
d1a6c242 611 /* Don't emit sequences of stabs for the same line. */
1ea5c325
MS
612 if (prev_file == NULL)
613 {
d1a6c242 614 /* First time thru. */
1ea5c325
MS
615 prev_file = xstrdup (file);
616 prev_lineno = lineno;
617 }
618 else if (lineno == prev_lineno
619 && strcmp (file, prev_file) == 0)
620 {
d1a6c242 621 /* Same file/line as last time. */
1ea5c325
MS
622 return;
623 }
624 else
625 {
d1a6c242 626 /* Remember file/line for next time. */
1ea5c325
MS
627 prev_lineno = lineno;
628 if (strcmp (file, prev_file) != 0)
629 {
630 free (prev_file);
631 prev_file = xstrdup (file);
632 }
633 }
634
635 /* Let the world know that we are in the middle of generating a
636 piece of stabs line debugging information. */
637 outputting_stabs_line_debug = 1;
638
252b5132
RH
639 generate_asm_file (N_SOL, file);
640
641 sprintf (sym, "%sL%d", FAKE_LABEL_NAME, label_count);
642 ++label_count;
643
644 if (in_dot_func_p)
645 {
646 buf = (char *) alloca (100 + strlen (current_function_label));
647 sprintf (buf, "%d,0,%d,%s-%s\n", N_SLINE, lineno,
648 sym, current_function_label);
649 }
650 else
651 {
652 buf = (char *) alloca (100);
653 sprintf (buf, "%d,0,%d,%s\n", N_SLINE, lineno, sym);
654 }
655 input_line_pointer = buf;
656 s_stab ('n');
657 colon (sym);
658
659 input_line_pointer = hold;
bccba5f0 660 outputting_stabs_line_debug = 0;
252b5132
RH
661}
662
663/* Emit a function stab.
664 All assembler functions are assumed to have return type `void'. */
665
666void
667stabs_generate_asm_func (funcname, startlabname)
668 const char *funcname;
669 const char *startlabname;
670{
671 static int void_emitted_p;
672 char *hold = input_line_pointer;
673 char *buf;
674 char *file;
675 unsigned int lineno;
676
677 if (! void_emitted_p)
678 {
679 input_line_pointer = "\"void:t1=1\",128,0,0,0";
680 s_stab ('s');
681 void_emitted_p = 1;
682 }
683
684 as_where (&file, &lineno);
685 asprintf (&buf, "\"%s:F1\",%d,0,%d,%s",
686 funcname, N_FUN, lineno + 1, startlabname);
687 input_line_pointer = buf;
688 s_stab ('s');
689 free (buf);
690
691 input_line_pointer = hold;
692 current_function_label = xstrdup (startlabname);
693 in_dot_func_p = 1;
694}
695
696/* Emit a stab to record the end of a function. */
697
698void
699stabs_generate_asm_endfunc (funcname, startlabname)
ab9da554 700 const char *funcname ATTRIBUTE_UNUSED;
252b5132
RH
701 const char *startlabname;
702{
703 static int label_count;
704 char *hold = input_line_pointer;
705 char *buf;
706 char sym[30];
707
708 sprintf (sym, "%sendfunc%d", FAKE_LABEL_NAME, label_count);
709 ++label_count;
710 colon (sym);
711
712 asprintf (&buf, "\"\",%d,0,0,%s-%s", N_FUN, sym, startlabname);
713 input_line_pointer = buf;
714 s_stab ('s');
715 free (buf);
716
717 input_line_pointer = hold;
718 in_dot_func_p = 0;
719 current_function_label = NULL;
720}
This page took 0.226379 seconds and 4 git commands to generate.