daily update
[binutils.git] / gas / dwarf2dbg.c
blob671a9b030d4b9932181049de03dc0291d2e0e7af
1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
23 /* Logical line numbers can be controlled by the compiler via the
24 following directives:
26 .file FILENO "file.c"
27 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
28 [epilogue_begin] [is_stmt VALUE] [isa VALUE]
31 #include "as.h"
32 #include "safe-ctype.h"
34 #ifdef HAVE_LIMITS_H
35 #include <limits.h>
36 #else
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
39 #endif
40 #ifndef INT_MAX
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
42 #endif
43 #endif
45 #include "dwarf2dbg.h"
46 #include <filenames.h>
48 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
49 /* We need to decide which character to use as a directory separator.
50 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
51 necessarily mean that the backslash character is the one to use.
52 Some environments, eg Cygwin, can support both naming conventions.
53 So we use the heuristic that we only need to use the backslash if
54 the path is an absolute path starting with a DOS style drive
55 selector. eg C: or D: */
56 # define INSERT_DIR_SEPARATOR(string, offset) \
57 do \
58 { \
59 if (offset > 1 \
60 && string[0] != 0 \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
63 else \
64 string [offset] = '/'; \
65 } \
66 while (0)
67 #else
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
69 #endif
71 #ifndef DWARF2_FORMAT
72 # define DWARF2_FORMAT() dwarf2_format_32bit
73 #endif
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
77 #endif
79 #include "subsegs.h"
81 #include "elf/dwarf2.h"
83 /* Since we can't generate the prolog until the body is complete, we
84 use three different subsegments for .debug_line: one holding the
85 prolog, one for the directory and filename info, and one for the
86 body ("statement program"). */
87 #define DL_PROLOG 0
88 #define DL_FILES 1
89 #define DL_BODY 2
91 /* If linker relaxation might change offsets in the code, the DWARF special
92 opcodes and variable-length operands cannot be used. If this macro is
93 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
94 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
95 # define DWARF2_USE_FIXED_ADVANCE_PC 0
96 #endif
98 /* First special line opcde - leave room for the standard opcodes.
99 Note: If you want to change this, you'll have to update the
100 "standard_opcode_lengths" table that is emitted below in
101 out_debug_line(). */
102 #define DWARF2_LINE_OPCODE_BASE 13
104 #ifndef DWARF2_LINE_BASE
105 /* Minimum line offset in a special line info. opcode. This value
106 was chosen to give a reasonable range of values. */
107 # define DWARF2_LINE_BASE -5
108 #endif
110 /* Range of line offsets in a special line info. opcode. */
111 #ifndef DWARF2_LINE_RANGE
112 # define DWARF2_LINE_RANGE 14
113 #endif
115 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
116 /* Define the architecture-dependent minimum instruction length (in
117 bytes). This value should be rather too small than too big. */
118 # define DWARF2_LINE_MIN_INSN_LENGTH 1
119 #endif
121 /* Flag that indicates the initial value of the is_stmt_start flag. */
122 #define DWARF2_LINE_DEFAULT_IS_STMT 1
124 /* Given a special op, return the line skip amount. */
125 #define SPECIAL_LINE(op) \
126 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
128 /* Given a special op, return the address skip amount (in units of
129 DWARF2_LINE_MIN_INSN_LENGTH. */
130 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
132 /* The maximum address skip amount that can be encoded with a special op. */
133 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
135 struct line_entry {
136 struct line_entry *next;
137 symbolS *label;
138 struct dwarf2_line_info loc;
141 struct line_subseg {
142 struct line_subseg *next;
143 subsegT subseg;
144 struct line_entry *head;
145 struct line_entry **ptail;
148 struct line_seg {
149 struct line_seg *next;
150 segT seg;
151 struct line_subseg *head;
152 symbolS *text_start;
153 symbolS *text_end;
156 /* Collects data for all line table entries during assembly. */
157 static struct line_seg *all_segs;
159 struct file_entry {
160 const char *filename;
161 unsigned int dir;
164 /* Table of files used by .debug_line. */
165 static struct file_entry *files;
166 static unsigned int files_in_use;
167 static unsigned int files_allocated;
169 /* Table of directories used by .debug_line. */
170 static char **dirs;
171 static unsigned int dirs_in_use;
172 static unsigned int dirs_allocated;
174 /* TRUE when we've seen a .loc directive recently. Used to avoid
175 doing work when there's nothing to do. */
176 static bfd_boolean loc_directive_seen;
178 /* TRUE when we're supposed to set the basic block mark whenever a
179 label is seen. */
180 bfd_boolean dwarf2_loc_mark_labels;
182 /* Current location as indicated by the most recent .loc directive. */
183 static struct dwarf2_line_info current = {
184 1, 1, 0, 0,
185 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0
188 /* The size of an address on the target. */
189 static unsigned int sizeof_address;
191 static struct line_subseg *get_line_subseg (segT, subsegT);
192 static unsigned int get_filenum (const char *, unsigned int);
193 static struct frag *first_frag_for_seg (segT);
194 static struct frag *last_frag_for_seg (segT);
195 static void out_byte (int);
196 static void out_opcode (int);
197 static void out_two (int);
198 static void out_four (int);
199 static void out_abbrev (int, int);
200 static void out_uleb128 (addressT);
201 static void out_sleb128 (addressT);
202 static offsetT get_frag_fix (fragS *, segT);
203 static void out_set_addr (symbolS *);
204 static int size_inc_line_addr (int, addressT);
205 static void emit_inc_line_addr (int, addressT, char *, int);
206 static void out_inc_line_addr (int, addressT);
207 static void out_fixed_inc_line_addr (int, symbolS *, symbolS *);
208 static void relax_inc_line_addr (int, symbolS *, symbolS *);
209 static void process_entries (segT, struct line_entry *);
210 static void out_file_list (void);
211 static void out_debug_line (segT);
212 static void out_debug_aranges (segT, segT);
213 static void out_debug_abbrev (segT);
215 #ifndef TC_DWARF2_EMIT_OFFSET
216 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
218 /* Create an offset to .dwarf2_*. */
220 static void
221 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
223 expressionS expr;
225 expr.X_op = O_symbol;
226 expr.X_add_symbol = symbol;
227 expr.X_add_number = 0;
228 emit_expr (&expr, size);
230 #endif
232 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
234 static struct line_subseg *
235 get_line_subseg (segT seg, subsegT subseg)
237 static segT last_seg;
238 static subsegT last_subseg;
239 static struct line_subseg *last_line_subseg;
241 struct line_seg **ps, *s;
242 struct line_subseg **pss, *ss;
244 if (seg == last_seg && subseg == last_subseg)
245 return last_line_subseg;
247 for (ps = &all_segs; (s = *ps) != NULL; ps = &s->next)
248 if (s->seg == seg)
249 goto found_seg;
251 s = (struct line_seg *) xmalloc (sizeof (*s));
252 s->next = NULL;
253 s->seg = seg;
254 s->head = NULL;
255 *ps = s;
257 found_seg:
258 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
260 if (ss->subseg == subseg)
261 goto found_subseg;
262 if (ss->subseg > subseg)
263 break;
266 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
267 ss->next = *pss;
268 ss->subseg = subseg;
269 ss->head = NULL;
270 ss->ptail = &ss->head;
271 *pss = ss;
273 found_subseg:
274 last_seg = seg;
275 last_subseg = subseg;
276 last_line_subseg = ss;
278 return ss;
281 /* Record an entry for LOC occurring at LABEL. */
283 static void
284 dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
286 struct line_subseg *ss;
287 struct line_entry *e;
289 e = (struct line_entry *) xmalloc (sizeof (*e));
290 e->next = NULL;
291 e->label = label;
292 e->loc = *loc;
294 ss = get_line_subseg (now_seg, now_subseg);
295 *ss->ptail = e;
296 ss->ptail = &e->next;
299 /* Record an entry for LOC occurring at OFS within the current fragment. */
301 void
302 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
304 static unsigned int line = -1;
305 static unsigned int filenum = -1;
307 symbolS *sym;
309 /* Early out for as-yet incomplete location information. */
310 if (loc->filenum == 0 || loc->line == 0)
311 return;
313 /* Don't emit sequences of line symbols for the same line when the
314 symbols apply to assembler code. It is necessary to emit
315 duplicate line symbols when a compiler asks for them, because GDB
316 uses them to determine the end of the prologue. */
317 if (debug_type == DEBUG_DWARF2
318 && line == loc->line && filenum == loc->filenum)
319 return;
321 line = loc->line;
322 filenum = loc->filenum;
324 sym = symbol_temp_new (now_seg, ofs, frag_now);
325 dwarf2_gen_line_info_1 (sym, loc);
328 /* Returns the current source information. If .file directives have
329 been encountered, the info for the corresponding source file is
330 returned. Otherwise, the info for the assembly source file is
331 returned. */
333 void
334 dwarf2_where (struct dwarf2_line_info *line)
336 if (debug_type == DEBUG_DWARF2)
338 char *filename;
339 as_where (&filename, &line->line);
340 line->filenum = get_filenum (filename, 0);
341 line->column = 0;
342 line->flags = DWARF2_FLAG_IS_STMT;
343 line->isa = current.isa;
345 else
346 *line = current;
349 /* A hook to allow the target backend to inform the line number state
350 machine of isa changes when assembler debug info is enabled. */
352 void
353 dwarf2_set_isa (unsigned int isa)
355 current.isa = isa;
358 /* Called for each machine instruction, or relatively atomic group of
359 machine instructions (ie built-in macro). The instruction or group
360 is SIZE bytes in length. If dwarf2 line number generation is called
361 for, emit a line statement appropriately. */
363 void
364 dwarf2_emit_insn (int size)
366 struct dwarf2_line_info loc;
368 if (loc_directive_seen)
370 /* Use the last location established by a .loc directive, not
371 the value returned by dwarf2_where(). That calls as_where()
372 which will return either the logical input file name (foo.c)
373 or the physical input file name (foo.s) and not the file name
374 specified in the most recent .loc directive (eg foo.h). */
375 loc = current;
377 /* Unless we generate DWARF2 debugging information for each
378 assembler line, we only emit one line symbol for one LOC. */
379 if (debug_type != DEBUG_DWARF2)
380 loc_directive_seen = FALSE;
382 else if (debug_type != DEBUG_DWARF2)
383 return;
384 else
385 dwarf2_where (&loc);
387 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
389 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
390 | DWARF2_FLAG_PROLOGUE_END
391 | DWARF2_FLAG_EPILOGUE_BEGIN);
394 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
395 is enabled, emit a basic block marker. */
397 void
398 dwarf2_emit_label (symbolS *label)
400 struct dwarf2_line_info loc;
402 if (!dwarf2_loc_mark_labels)
403 return;
404 if (S_GET_SEGMENT (label) != now_seg)
405 return;
406 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
407 return;
409 if (debug_type == DEBUG_DWARF2)
410 dwarf2_where (&loc);
411 else
413 loc = current;
414 loc_directive_seen = FALSE;
417 loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
419 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
420 | DWARF2_FLAG_PROLOGUE_END
421 | DWARF2_FLAG_EPILOGUE_BEGIN);
423 dwarf2_gen_line_info_1 (label, &loc);
426 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
427 allocate it on that file table slot, otherwise return the first
428 empty one. */
430 static unsigned int
431 get_filenum (const char *filename, unsigned int num)
433 static unsigned int last_used, last_used_dir_len;
434 const char *file;
435 size_t dir_len;
436 unsigned int i, dir;
438 if (num == 0 && last_used)
440 if (! files[last_used].dir
441 && strcmp (filename, files[last_used].filename) == 0)
442 return last_used;
443 if (files[last_used].dir
444 && strncmp (filename, dirs[files[last_used].dir],
445 last_used_dir_len) == 0
446 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
447 && strcmp (filename + last_used_dir_len + 1,
448 files[last_used].filename) == 0)
449 return last_used;
452 file = lbasename (filename);
453 /* Don't make empty string from / or A: from A:/ . */
454 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
455 if (file <= filename + 3)
456 file = filename;
457 #else
458 if (file == filename + 1)
459 file = filename;
460 #endif
461 dir_len = file - filename;
463 dir = 0;
464 if (dir_len)
466 --dir_len;
467 for (dir = 1; dir < dirs_in_use; ++dir)
468 if (strncmp (filename, dirs[dir], dir_len) == 0
469 && dirs[dir][dir_len] == '\0')
470 break;
472 if (dir >= dirs_in_use)
474 if (dir >= dirs_allocated)
476 dirs_allocated = dir + 32;
477 dirs = (char **)
478 xrealloc (dirs, (dir + 32) * sizeof (const char *));
481 dirs[dir] = xmalloc (dir_len + 1);
482 memcpy (dirs[dir], filename, dir_len);
483 dirs[dir][dir_len] = '\0';
484 dirs_in_use = dir + 1;
488 if (num == 0)
490 for (i = 1; i < files_in_use; ++i)
491 if (files[i].dir == dir
492 && files[i].filename
493 && strcmp (file, files[i].filename) == 0)
495 last_used = i;
496 last_used_dir_len = dir_len;
497 return i;
500 else
501 i = num;
503 if (i >= files_allocated)
505 unsigned int old = files_allocated;
507 files_allocated = i + 32;
508 files = (struct file_entry *)
509 xrealloc (files, (i + 32) * sizeof (struct file_entry));
511 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
514 files[i].filename = num ? file : xstrdup (file);
515 files[i].dir = dir;
516 if (files_in_use < i + 1)
517 files_in_use = i + 1;
518 last_used = i;
519 last_used_dir_len = dir_len;
521 return i;
524 /* Handle two forms of .file directive:
525 - Pass .file "source.c" to s_app_file
526 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
528 If an entry is added to the file table, return a pointer to the filename. */
530 char *
531 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
533 offsetT num;
534 char *filename;
535 int filename_len;
537 /* Continue to accept a bare string and pass it off. */
538 SKIP_WHITESPACE ();
539 if (*input_line_pointer == '"')
541 s_app_file (0);
542 return NULL;
545 num = get_absolute_expression ();
546 filename = demand_copy_C_string (&filename_len);
547 if (filename == NULL)
548 return NULL;
549 demand_empty_rest_of_line ();
551 if (num < 1)
553 as_bad (_("file number less than one"));
554 return NULL;
557 if (num < (int) files_in_use && files[num].filename != 0)
559 as_bad (_("file number %ld already allocated"), (long) num);
560 return NULL;
563 get_filenum (filename, num);
565 return filename;
568 void
569 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
571 offsetT filenum, line;
573 filenum = get_absolute_expression ();
574 SKIP_WHITESPACE ();
575 line = get_absolute_expression ();
577 if (filenum < 1)
579 as_bad (_("file number less than one"));
580 return;
582 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
584 as_bad (_("unassigned file number %ld"), (long) filenum);
585 return;
588 current.filenum = filenum;
589 current.line = line;
591 #ifndef NO_LISTING
592 if (listing)
594 if (files[filenum].dir)
596 size_t dir_len = strlen (dirs[files[filenum].dir]);
597 size_t file_len = strlen (files[filenum].filename);
598 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
600 memcpy (cp, dirs[files[filenum].dir], dir_len);
601 INSERT_DIR_SEPARATOR (cp, dir_len);
602 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
603 cp[dir_len + file_len + 1] = '\0';
604 listing_source_file (cp);
606 else
607 listing_source_file (files[filenum].filename);
608 listing_source_line (line);
610 #endif
612 SKIP_WHITESPACE ();
613 if (ISDIGIT (*input_line_pointer))
615 current.column = get_absolute_expression ();
616 SKIP_WHITESPACE ();
619 while (ISALPHA (*input_line_pointer))
621 char *p, c;
622 offsetT value;
624 p = input_line_pointer;
625 c = get_symbol_end ();
627 if (strcmp (p, "basic_block") == 0)
629 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
630 *input_line_pointer = c;
632 else if (strcmp (p, "prologue_end") == 0)
634 current.flags |= DWARF2_FLAG_PROLOGUE_END;
635 *input_line_pointer = c;
637 else if (strcmp (p, "epilogue_begin") == 0)
639 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
640 *input_line_pointer = c;
642 else if (strcmp (p, "is_stmt") == 0)
644 *input_line_pointer = c;
645 value = get_absolute_expression ();
646 if (value == 0)
647 current.flags &= ~DWARF2_FLAG_IS_STMT;
648 else if (value == 1)
649 current.flags |= DWARF2_FLAG_IS_STMT;
650 else
652 as_bad (_("is_stmt value not 0 or 1"));
653 return;
656 else if (strcmp (p, "isa") == 0)
658 *input_line_pointer = c;
659 value = get_absolute_expression ();
660 if (value >= 0)
661 current.isa = value;
662 else
664 as_bad (_("isa number less than zero"));
665 return;
668 else
670 as_bad (_("unknown .loc sub-directive `%s'"), p);
671 *input_line_pointer = c;
672 return;
675 SKIP_WHITESPACE ();
678 demand_empty_rest_of_line ();
679 loc_directive_seen = TRUE;
682 void
683 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
685 offsetT value = get_absolute_expression ();
687 if (value != 0 && value != 1)
689 as_bad (_("expected 0 or 1"));
690 ignore_rest_of_line ();
692 else
694 dwarf2_loc_mark_labels = value != 0;
695 demand_empty_rest_of_line ();
699 static struct frag *
700 first_frag_for_seg (segT seg)
702 return seg_info (seg)->frchainP->frch_root;
705 static struct frag *
706 last_frag_for_seg (segT seg)
708 frchainS *f = seg_info (seg)->frchainP;
710 while (f->frch_next != NULL)
711 f = f->frch_next;
713 return f->frch_last;
716 /* Emit a single byte into the current segment. */
718 static inline void
719 out_byte (int byte)
721 FRAG_APPEND_1_CHAR (byte);
724 /* Emit a statement program opcode into the current segment. */
726 static inline void
727 out_opcode (int opc)
729 out_byte (opc);
732 /* Emit a two-byte word into the current segment. */
734 static inline void
735 out_two (int data)
737 md_number_to_chars (frag_more (2), data, 2);
740 /* Emit a four byte word into the current segment. */
742 static inline void
743 out_four (int data)
745 md_number_to_chars (frag_more (4), data, 4);
748 /* Emit an unsigned "little-endian base 128" number. */
750 static void
751 out_uleb128 (addressT value)
753 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
756 /* Emit a signed "little-endian base 128" number. */
758 static void
759 out_sleb128 (addressT value)
761 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
764 /* Emit a tuple for .debug_abbrev. */
766 static inline void
767 out_abbrev (int name, int form)
769 out_uleb128 (name);
770 out_uleb128 (form);
773 /* Get the size of a fragment. */
775 static offsetT
776 get_frag_fix (fragS *frag, segT seg)
778 frchainS *fr;
780 if (frag->fr_next)
781 return frag->fr_fix;
783 /* If a fragment is the last in the chain, special measures must be
784 taken to find its size before relaxation, since it may be pending
785 on some subsegment chain. */
786 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
787 if (fr->frch_last == frag)
788 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
790 abort ();
793 /* Set an absolute address (may result in a relocation entry). */
795 static void
796 out_set_addr (symbolS *sym)
798 expressionS expr;
800 out_opcode (DW_LNS_extended_op);
801 out_uleb128 (sizeof_address + 1);
803 out_opcode (DW_LNE_set_address);
804 expr.X_op = O_symbol;
805 expr.X_add_symbol = sym;
806 expr.X_add_number = 0;
807 emit_expr (&expr, sizeof_address);
810 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
811 static void scale_addr_delta (addressT *);
813 static void
814 scale_addr_delta (addressT *addr_delta)
816 static int printed_this = 0;
817 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
819 if (!printed_this)
820 as_bad("unaligned opcodes detected in executable segment");
821 printed_this = 1;
823 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
825 #else
826 #define scale_addr_delta(A)
827 #endif
829 /* Encode a pair of line and address skips as efficiently as possible.
830 Note that the line skip is signed, whereas the address skip is unsigned.
832 The following two routines *must* be kept in sync. This is
833 enforced by making emit_inc_line_addr abort if we do not emit
834 exactly the expected number of bytes. */
836 static int
837 size_inc_line_addr (int line_delta, addressT addr_delta)
839 unsigned int tmp, opcode;
840 int len = 0;
842 /* Scale the address delta by the minimum instruction length. */
843 scale_addr_delta (&addr_delta);
845 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
846 We cannot use special opcodes here, since we want the end_sequence
847 to emit the matrix entry. */
848 if (line_delta == INT_MAX)
850 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
851 len = 1;
852 else
853 len = 1 + sizeof_leb128 (addr_delta, 0);
854 return len + 3;
857 /* Bias the line delta by the base. */
858 tmp = line_delta - DWARF2_LINE_BASE;
860 /* If the line increment is out of range of a special opcode, we
861 must encode it with DW_LNS_advance_line. */
862 if (tmp >= DWARF2_LINE_RANGE)
864 len = 1 + sizeof_leb128 (line_delta, 1);
865 line_delta = 0;
866 tmp = 0 - DWARF2_LINE_BASE;
869 /* Bias the opcode by the special opcode base. */
870 tmp += DWARF2_LINE_OPCODE_BASE;
872 /* Avoid overflow when addr_delta is large. */
873 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
875 /* Try using a special opcode. */
876 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
877 if (opcode <= 255)
878 return len + 1;
880 /* Try using DW_LNS_const_add_pc followed by special op. */
881 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
882 if (opcode <= 255)
883 return len + 2;
886 /* Otherwise use DW_LNS_advance_pc. */
887 len += 1 + sizeof_leb128 (addr_delta, 0);
889 /* DW_LNS_copy or special opcode. */
890 len += 1;
892 return len;
895 static void
896 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
898 unsigned int tmp, opcode;
899 int need_copy = 0;
900 char *end = p + len;
902 /* Line number sequences cannot go backward in addresses. This means
903 we've incorrectly ordered the statements in the sequence. */
904 assert ((offsetT) addr_delta >= 0);
906 /* Scale the address delta by the minimum instruction length. */
907 scale_addr_delta (&addr_delta);
909 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
910 We cannot use special opcodes here, since we want the end_sequence
911 to emit the matrix entry. */
912 if (line_delta == INT_MAX)
914 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
915 *p++ = DW_LNS_const_add_pc;
916 else
918 *p++ = DW_LNS_advance_pc;
919 p += output_leb128 (p, addr_delta, 0);
922 *p++ = DW_LNS_extended_op;
923 *p++ = 1;
924 *p++ = DW_LNE_end_sequence;
925 goto done;
928 /* Bias the line delta by the base. */
929 tmp = line_delta - DWARF2_LINE_BASE;
931 /* If the line increment is out of range of a special opcode, we
932 must encode it with DW_LNS_advance_line. */
933 if (tmp >= DWARF2_LINE_RANGE)
935 *p++ = DW_LNS_advance_line;
936 p += output_leb128 (p, line_delta, 1);
938 line_delta = 0;
939 tmp = 0 - DWARF2_LINE_BASE;
940 need_copy = 1;
943 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
944 special opcode. */
945 if (line_delta == 0 && addr_delta == 0)
947 *p++ = DW_LNS_copy;
948 goto done;
951 /* Bias the opcode by the special opcode base. */
952 tmp += DWARF2_LINE_OPCODE_BASE;
954 /* Avoid overflow when addr_delta is large. */
955 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
957 /* Try using a special opcode. */
958 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
959 if (opcode <= 255)
961 *p++ = opcode;
962 goto done;
965 /* Try using DW_LNS_const_add_pc followed by special op. */
966 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
967 if (opcode <= 255)
969 *p++ = DW_LNS_const_add_pc;
970 *p++ = opcode;
971 goto done;
975 /* Otherwise use DW_LNS_advance_pc. */
976 *p++ = DW_LNS_advance_pc;
977 p += output_leb128 (p, addr_delta, 0);
979 if (need_copy)
980 *p++ = DW_LNS_copy;
981 else
982 *p++ = tmp;
984 done:
985 assert (p == end);
988 /* Handy routine to combine calls to the above two routines. */
990 static void
991 out_inc_line_addr (int line_delta, addressT addr_delta)
993 int len = size_inc_line_addr (line_delta, addr_delta);
994 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
997 /* Write out an alternative form of line and address skips using
998 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
999 line and address information, but it helps support linker relaxation that
1000 changes the code offsets. */
1002 static void
1003 out_fixed_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1005 expressionS expr;
1007 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1008 if (line_delta == INT_MAX)
1010 out_opcode (DW_LNS_fixed_advance_pc);
1011 expr.X_op = O_subtract;
1012 expr.X_add_symbol = to_sym;
1013 expr.X_op_symbol = from_sym;
1014 expr.X_add_number = 0;
1015 emit_expr (&expr, 2);
1017 out_opcode (DW_LNS_extended_op);
1018 out_byte (1);
1019 out_opcode (DW_LNE_end_sequence);
1020 return;
1023 out_opcode (DW_LNS_advance_line);
1024 out_sleb128 (line_delta);
1026 out_opcode (DW_LNS_fixed_advance_pc);
1027 expr.X_op = O_subtract;
1028 expr.X_add_symbol = to_sym;
1029 expr.X_op_symbol = from_sym;
1030 expr.X_add_number = 0;
1031 emit_expr (&expr, 2);
1033 out_opcode (DW_LNS_copy);
1036 /* Generate a variant frag that we can use to relax address/line
1037 increments between fragments of the target segment. */
1039 static void
1040 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1042 expressionS expr;
1043 int max_chars;
1045 expr.X_op = O_subtract;
1046 expr.X_add_symbol = to_sym;
1047 expr.X_op_symbol = from_sym;
1048 expr.X_add_number = 0;
1050 /* The maximum size of the frag is the line delta with a maximum
1051 sized address delta. */
1052 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1054 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1055 make_expr_symbol (&expr), line_delta, NULL);
1058 /* The function estimates the size of a rs_dwarf2dbg variant frag
1059 based on the current values of the symbols. It is called before
1060 the relaxation loop. We set fr_subtype to the expected length. */
1063 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1065 offsetT addr_delta;
1066 int size;
1068 addr_delta = resolve_symbol_value (frag->fr_symbol);
1069 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1071 frag->fr_subtype = size;
1073 return size;
1076 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1077 current values of the symbols. fr_subtype is the current length
1078 of the frag. This returns the change in frag length. */
1081 dwarf2dbg_relax_frag (fragS *frag)
1083 int old_size, new_size;
1085 old_size = frag->fr_subtype;
1086 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1088 return new_size - old_size;
1091 /* This function converts a rs_dwarf2dbg variant frag into a normal
1092 fill frag. This is called after all relaxation has been done.
1093 fr_subtype will be the desired length of the frag. */
1095 void
1096 dwarf2dbg_convert_frag (fragS *frag)
1098 offsetT addr_diff;
1100 addr_diff = resolve_symbol_value (frag->fr_symbol);
1102 /* fr_var carries the max_chars that we created the fragment with.
1103 fr_subtype carries the current expected length. We must, of
1104 course, have allocated enough memory earlier. */
1105 assert (frag->fr_var >= (int) frag->fr_subtype);
1107 emit_inc_line_addr (frag->fr_offset, addr_diff,
1108 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1110 frag->fr_fix += frag->fr_subtype;
1111 frag->fr_type = rs_fill;
1112 frag->fr_var = 0;
1113 frag->fr_offset = 0;
1116 /* Generate .debug_line content for the chain of line number entries
1117 beginning at E, for segment SEG. */
1119 static void
1120 process_entries (segT seg, struct line_entry *e)
1122 unsigned filenum = 1;
1123 unsigned line = 1;
1124 unsigned column = 0;
1125 unsigned isa = 0;
1126 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1127 fragS *last_frag = NULL, *frag;
1128 addressT last_frag_ofs = 0, frag_ofs;
1129 symbolS *last_lab = NULL, *lab;
1130 struct line_entry *next;
1134 int line_delta;
1136 if (filenum != e->loc.filenum)
1138 filenum = e->loc.filenum;
1139 out_opcode (DW_LNS_set_file);
1140 out_uleb128 (filenum);
1143 if (column != e->loc.column)
1145 column = e->loc.column;
1146 out_opcode (DW_LNS_set_column);
1147 out_uleb128 (column);
1150 if (isa != e->loc.isa)
1152 isa = e->loc.isa;
1153 out_opcode (DW_LNS_set_isa);
1154 out_uleb128 (isa);
1157 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1159 flags = e->loc.flags;
1160 out_opcode (DW_LNS_negate_stmt);
1163 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1164 out_opcode (DW_LNS_set_basic_block);
1166 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1167 out_opcode (DW_LNS_set_prologue_end);
1169 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1170 out_opcode (DW_LNS_set_epilogue_begin);
1172 /* Don't try to optimize away redundant entries; gdb wants two
1173 entries for a function where the code starts on the same line as
1174 the {, and there's no way to identify that case here. Trust gcc
1175 to optimize appropriately. */
1176 line_delta = e->loc.line - line;
1177 lab = e->label;
1178 frag = symbol_get_frag (lab);
1179 frag_ofs = S_GET_VALUE (lab);
1181 if (last_frag == NULL)
1183 out_set_addr (lab);
1184 out_inc_line_addr (line_delta, 0);
1186 else if (DWARF2_USE_FIXED_ADVANCE_PC)
1187 out_fixed_inc_line_addr (line_delta, lab, last_lab);
1188 else if (frag == last_frag)
1189 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1190 else
1191 relax_inc_line_addr (line_delta, lab, last_lab);
1193 line = e->loc.line;
1194 last_lab = lab;
1195 last_frag = frag;
1196 last_frag_ofs = frag_ofs;
1198 next = e->next;
1199 free (e);
1200 e = next;
1202 while (e);
1204 /* Emit a DW_LNE_end_sequence for the end of the section. */
1205 frag = last_frag_for_seg (seg);
1206 frag_ofs = get_frag_fix (frag, seg);
1207 if (DWARF2_USE_FIXED_ADVANCE_PC)
1209 lab = symbol_temp_new (seg, frag_ofs, frag);
1210 out_fixed_inc_line_addr (INT_MAX, lab, last_lab);
1212 else if (frag == last_frag)
1213 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1214 else
1216 lab = symbol_temp_new (seg, frag_ofs, frag);
1217 relax_inc_line_addr (INT_MAX, lab, last_lab);
1221 /* Emit the directory and file tables for .debug_line. */
1223 static void
1224 out_file_list (void)
1226 size_t size;
1227 char *cp;
1228 unsigned int i;
1230 /* Emit directory list. */
1231 for (i = 1; i < dirs_in_use; ++i)
1233 size = strlen (dirs[i]) + 1;
1234 cp = frag_more (size);
1235 memcpy (cp, dirs[i], size);
1237 /* Terminate it. */
1238 out_byte ('\0');
1240 for (i = 1; i < files_in_use; ++i)
1242 if (files[i].filename == NULL)
1244 as_bad (_("unassigned file number %ld"), (long) i);
1245 /* Prevent a crash later, particularly for file 1. */
1246 files[i].filename = "";
1247 continue;
1250 size = strlen (files[i].filename) + 1;
1251 cp = frag_more (size);
1252 memcpy (cp, files[i].filename, size);
1254 out_uleb128 (files[i].dir); /* directory number */
1255 out_uleb128 (0); /* last modification timestamp */
1256 out_uleb128 (0); /* filesize */
1259 /* Terminate filename list. */
1260 out_byte (0);
1263 /* Emit the collected .debug_line data. */
1265 static void
1266 out_debug_line (segT line_seg)
1268 expressionS expr;
1269 symbolS *line_start;
1270 symbolS *prologue_end;
1271 symbolS *line_end;
1272 struct line_seg *s;
1273 enum dwarf2_format d2f;
1274 int sizeof_offset;
1276 subseg_set (line_seg, 0);
1278 line_start = symbol_temp_new_now ();
1279 prologue_end = symbol_temp_make ();
1280 line_end = symbol_temp_make ();
1282 /* Total length of the information for this compilation unit. */
1283 expr.X_op = O_subtract;
1284 expr.X_add_symbol = line_end;
1285 expr.X_op_symbol = line_start;
1287 d2f = DWARF2_FORMAT ();
1288 if (d2f == dwarf2_format_32bit)
1290 expr.X_add_number = -4;
1291 emit_expr (&expr, 4);
1292 sizeof_offset = 4;
1294 else if (d2f == dwarf2_format_64bit)
1296 expr.X_add_number = -12;
1297 out_four (-1);
1298 emit_expr (&expr, 8);
1299 sizeof_offset = 8;
1301 else if (d2f == dwarf2_format_64bit_irix)
1303 expr.X_add_number = -8;
1304 emit_expr (&expr, 8);
1305 sizeof_offset = 8;
1307 else
1309 as_fatal (_("internal error: unknown dwarf2 format"));
1312 /* Version. */
1313 out_two (2);
1315 /* Length of the prologue following this length. */
1316 expr.X_op = O_subtract;
1317 expr.X_add_symbol = prologue_end;
1318 expr.X_op_symbol = line_start;
1319 expr.X_add_number = - (4 + 2 + 4);
1320 emit_expr (&expr, sizeof_offset);
1322 /* Parameters of the state machine. */
1323 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1324 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1325 out_byte (DWARF2_LINE_BASE);
1326 out_byte (DWARF2_LINE_RANGE);
1327 out_byte (DWARF2_LINE_OPCODE_BASE);
1329 /* Standard opcode lengths. */
1330 out_byte (0); /* DW_LNS_copy */
1331 out_byte (1); /* DW_LNS_advance_pc */
1332 out_byte (1); /* DW_LNS_advance_line */
1333 out_byte (1); /* DW_LNS_set_file */
1334 out_byte (1); /* DW_LNS_set_column */
1335 out_byte (0); /* DW_LNS_negate_stmt */
1336 out_byte (0); /* DW_LNS_set_basic_block */
1337 out_byte (0); /* DW_LNS_const_add_pc */
1338 out_byte (1); /* DW_LNS_fixed_advance_pc */
1339 out_byte (0); /* DW_LNS_set_prologue_end */
1340 out_byte (0); /* DW_LNS_set_epilogue_begin */
1341 out_byte (1); /* DW_LNS_set_isa */
1343 out_file_list ();
1345 symbol_set_value_now (prologue_end);
1347 /* For each section, emit a statement program. */
1348 for (s = all_segs; s; s = s->next)
1349 process_entries (s->seg, s->head->head);
1351 symbol_set_value_now (line_end);
1354 static void
1355 out_debug_ranges (segT ranges_seg)
1357 unsigned int addr_size = sizeof_address;
1358 struct line_seg *s;
1359 expressionS expr;
1360 unsigned int i;
1362 subseg_set (ranges_seg, 0);
1364 /* Base Address Entry. */
1365 for (i = 0; i < addr_size; i++)
1366 out_byte (0xff);
1367 for (i = 0; i < addr_size; i++)
1368 out_byte (0);
1370 /* Range List Entry. */
1371 for (s = all_segs; s; s = s->next)
1373 fragS *frag;
1374 symbolS *beg, *end;
1376 frag = first_frag_for_seg (s->seg);
1377 beg = symbol_temp_new (s->seg, 0, frag);
1378 s->text_start = beg;
1380 frag = last_frag_for_seg (s->seg);
1381 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1382 s->text_end = end;
1384 expr.X_op = O_symbol;
1385 expr.X_add_symbol = beg;
1386 expr.X_add_number = 0;
1387 emit_expr (&expr, addr_size);
1389 expr.X_op = O_symbol;
1390 expr.X_add_symbol = end;
1391 expr.X_add_number = 0;
1392 emit_expr (&expr, addr_size);
1395 /* End of Range Entry. */
1396 for (i = 0; i < addr_size; i++)
1397 out_byte (0);
1398 for (i = 0; i < addr_size; i++)
1399 out_byte (0);
1402 /* Emit data for .debug_aranges. */
1404 static void
1405 out_debug_aranges (segT aranges_seg, segT info_seg)
1407 unsigned int addr_size = sizeof_address;
1408 addressT size, skip;
1409 struct line_seg *s;
1410 expressionS expr;
1411 char *p;
1413 size = 4 + 2 + 4 + 1 + 1;
1415 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1416 if (skip == 2 * addr_size)
1417 skip = 0;
1418 size += skip;
1420 for (s = all_segs; s; s = s->next)
1421 size += 2 * addr_size;
1423 size += 2 * addr_size;
1425 subseg_set (aranges_seg, 0);
1427 /* Length of the compilation unit. */
1428 out_four (size - 4);
1430 /* Version. */
1431 out_two (2);
1433 /* Offset to .debug_info. */
1434 /* ??? sizeof_offset */
1435 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4);
1437 /* Size of an address (offset portion). */
1438 out_byte (addr_size);
1440 /* Size of a segment descriptor. */
1441 out_byte (0);
1443 /* Align the header. */
1444 if (skip)
1445 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1447 for (s = all_segs; s; s = s->next)
1449 fragS *frag;
1450 symbolS *beg, *end;
1452 frag = first_frag_for_seg (s->seg);
1453 beg = symbol_temp_new (s->seg, 0, frag);
1454 s->text_start = beg;
1456 frag = last_frag_for_seg (s->seg);
1457 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1458 s->text_end = end;
1460 expr.X_op = O_symbol;
1461 expr.X_add_symbol = beg;
1462 expr.X_add_number = 0;
1463 emit_expr (&expr, addr_size);
1465 expr.X_op = O_subtract;
1466 expr.X_add_symbol = end;
1467 expr.X_op_symbol = beg;
1468 expr.X_add_number = 0;
1469 emit_expr (&expr, addr_size);
1472 p = frag_more (2 * addr_size);
1473 md_number_to_chars (p, 0, addr_size);
1474 md_number_to_chars (p + addr_size, 0, addr_size);
1477 /* Emit data for .debug_abbrev. Note that this must be kept in
1478 sync with out_debug_info below. */
1480 static void
1481 out_debug_abbrev (segT abbrev_seg)
1483 subseg_set (abbrev_seg, 0);
1485 out_uleb128 (1);
1486 out_uleb128 (DW_TAG_compile_unit);
1487 out_byte (DW_CHILDREN_no);
1488 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1489 if (all_segs->next == NULL)
1491 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1492 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1494 else
1496 if (DWARF2_FORMAT () == dwarf2_format_32bit)
1497 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1498 else
1499 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1501 out_abbrev (DW_AT_name, DW_FORM_string);
1502 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1503 out_abbrev (DW_AT_producer, DW_FORM_string);
1504 out_abbrev (DW_AT_language, DW_FORM_data2);
1505 out_abbrev (0, 0);
1507 /* Terminate the abbreviations for this compilation unit. */
1508 out_byte (0);
1511 /* Emit a description of this compilation unit for .debug_info. */
1513 static void
1514 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1516 char producer[128];
1517 char *comp_dir;
1518 expressionS expr;
1519 symbolS *info_start;
1520 symbolS *info_end;
1521 char *p;
1522 int len;
1523 enum dwarf2_format d2f;
1524 int sizeof_offset;
1526 subseg_set (info_seg, 0);
1528 info_start = symbol_temp_new_now ();
1529 info_end = symbol_temp_make ();
1531 /* Compilation Unit length. */
1532 expr.X_op = O_subtract;
1533 expr.X_add_symbol = info_end;
1534 expr.X_op_symbol = info_start;
1536 d2f = DWARF2_FORMAT ();
1537 if (d2f == dwarf2_format_32bit)
1539 expr.X_add_number = -4;
1540 emit_expr (&expr, 4);
1541 sizeof_offset = 4;
1543 else if (d2f == dwarf2_format_64bit)
1545 expr.X_add_number = -12;
1546 out_four (-1);
1547 emit_expr (&expr, 8);
1548 sizeof_offset = 8;
1550 else if (d2f == dwarf2_format_64bit_irix)
1552 expr.X_add_number = -8;
1553 emit_expr (&expr, 8);
1554 sizeof_offset = 8;
1556 else
1558 as_fatal (_("internal error: unknown dwarf2 format"));
1561 /* DWARF version. */
1562 out_two (2);
1564 /* .debug_abbrev offset */
1565 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1567 /* Target address size. */
1568 out_byte (sizeof_address);
1570 /* DW_TAG_compile_unit DIE abbrev */
1571 out_uleb128 (1);
1573 /* DW_AT_stmt_list */
1574 /* ??? sizeof_offset */
1575 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4);
1577 /* These two attributes are emitted if all of the code is contiguous. */
1578 if (all_segs->next == NULL)
1580 /* DW_AT_low_pc */
1581 expr.X_op = O_symbol;
1582 expr.X_add_symbol = all_segs->text_start;
1583 expr.X_add_number = 0;
1584 emit_expr (&expr, sizeof_address);
1586 /* DW_AT_high_pc */
1587 expr.X_op = O_symbol;
1588 expr.X_add_symbol = all_segs->text_end;
1589 expr.X_add_number = 0;
1590 emit_expr (&expr, sizeof_address);
1592 else
1594 /* This attribute is emitted if the code is disjoint. */
1595 /* DW_AT_ranges. */
1596 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
1599 /* DW_AT_name. We don't have the actual file name that was present
1600 on the command line, so assume files[1] is the main input file.
1601 We're not supposed to get called unless at least one line number
1602 entry was emitted, so this should always be defined. */
1603 if (!files || files_in_use < 1)
1604 abort ();
1605 if (files[1].dir)
1607 len = strlen (dirs[files[1].dir]);
1608 p = frag_more (len + 1);
1609 memcpy (p, dirs[files[1].dir], len);
1610 INSERT_DIR_SEPARATOR (p, len);
1612 len = strlen (files[1].filename) + 1;
1613 p = frag_more (len);
1614 memcpy (p, files[1].filename, len);
1616 /* DW_AT_comp_dir */
1617 comp_dir = getpwd ();
1618 len = strlen (comp_dir) + 1;
1619 p = frag_more (len);
1620 memcpy (p, comp_dir, len);
1622 /* DW_AT_producer */
1623 sprintf (producer, "GNU AS %s", VERSION);
1624 len = strlen (producer) + 1;
1625 p = frag_more (len);
1626 memcpy (p, producer, len);
1628 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1629 dwarf2 draft has no standard code for assembler. */
1630 out_two (DW_LANG_Mips_Assembler);
1632 symbol_set_value_now (info_end);
1635 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1636 were any .file/.loc directives, or --gdwarf2 was given, or if the
1637 file has a non-empty .debug_info section. If we emit .debug_line,
1638 and the .debug_info section is empty, we also emit .debug_info,
1639 .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if
1640 there were any .file/.loc directives, or --gdwarf2 was given and
1641 there were any located instructions emitted. */
1643 void
1644 dwarf2_finish (void)
1646 segT line_seg;
1647 struct line_seg *s;
1648 segT info_seg;
1649 int emit_other_sections = 0;
1651 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1652 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1654 if (!all_segs && emit_other_sections)
1655 /* There is no line information and no non-empty .debug_info
1656 section. */
1657 return;
1659 /* Calculate the size of an address for the target machine. */
1660 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1662 /* Create and switch to the line number section. */
1663 line_seg = subseg_new (".debug_line", 0);
1664 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1666 /* For each subsection, chain the debug entries together. */
1667 for (s = all_segs; s; s = s->next)
1669 struct line_subseg *ss = s->head;
1670 struct line_entry **ptail = ss->ptail;
1672 while ((ss = ss->next) != NULL)
1674 *ptail = ss->head;
1675 ptail = ss->ptail;
1679 out_debug_line (line_seg);
1681 /* If this is assembler generated line info, and there is no
1682 debug_info already, we need .debug_info and .debug_abbrev
1683 sections as well. */
1684 if (emit_other_sections)
1686 segT abbrev_seg;
1687 segT aranges_seg;
1688 segT ranges_seg;
1690 assert (all_segs);
1692 info_seg = subseg_new (".debug_info", 0);
1693 abbrev_seg = subseg_new (".debug_abbrev", 0);
1694 aranges_seg = subseg_new (".debug_aranges", 0);
1696 bfd_set_section_flags (stdoutput, info_seg,
1697 SEC_READONLY | SEC_DEBUGGING);
1698 bfd_set_section_flags (stdoutput, abbrev_seg,
1699 SEC_READONLY | SEC_DEBUGGING);
1700 bfd_set_section_flags (stdoutput, aranges_seg,
1701 SEC_READONLY | SEC_DEBUGGING);
1703 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1705 if (all_segs->next == NULL)
1706 ranges_seg = NULL;
1707 else
1709 ranges_seg = subseg_new (".debug_ranges", 0);
1710 bfd_set_section_flags (stdoutput, ranges_seg,
1711 SEC_READONLY | SEC_DEBUGGING);
1712 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
1713 out_debug_ranges (ranges_seg);
1716 out_debug_aranges (aranges_seg, info_seg);
1717 out_debug_abbrev (abbrev_seg);
1718 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);