Import binutils 2.18
[nacl-binutils.git] / gas / dwarf2dbg.c
blob93b5f480b06a340497aca34d23b16bac70d1b179
1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
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 3, 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 const char *dir;
1228 char *cp;
1229 unsigned int i;
1231 /* Emit directory list. */
1232 for (i = 1; i < dirs_in_use; ++i)
1234 dir = remap_debug_filename (dirs[i]);
1235 size = strlen (dir) + 1;
1236 cp = frag_more (size);
1237 memcpy (cp, dir, size);
1239 /* Terminate it. */
1240 out_byte ('\0');
1242 for (i = 1; i < files_in_use; ++i)
1244 if (files[i].filename == NULL)
1246 as_bad (_("unassigned file number %ld"), (long) i);
1247 /* Prevent a crash later, particularly for file 1. */
1248 files[i].filename = "";
1249 continue;
1252 size = strlen (files[i].filename) + 1;
1253 cp = frag_more (size);
1254 memcpy (cp, files[i].filename, size);
1256 out_uleb128 (files[i].dir); /* directory number */
1257 out_uleb128 (0); /* last modification timestamp */
1258 out_uleb128 (0); /* filesize */
1261 /* Terminate filename list. */
1262 out_byte (0);
1265 /* Emit the collected .debug_line data. */
1267 static void
1268 out_debug_line (segT line_seg)
1270 expressionS expr;
1271 symbolS *line_start;
1272 symbolS *prologue_end;
1273 symbolS *line_end;
1274 struct line_seg *s;
1275 enum dwarf2_format d2f;
1276 int sizeof_offset;
1278 subseg_set (line_seg, 0);
1280 line_start = symbol_temp_new_now ();
1281 prologue_end = symbol_temp_make ();
1282 line_end = symbol_temp_make ();
1284 /* Total length of the information for this compilation unit. */
1285 expr.X_op = O_subtract;
1286 expr.X_add_symbol = line_end;
1287 expr.X_op_symbol = line_start;
1289 d2f = DWARF2_FORMAT ();
1290 if (d2f == dwarf2_format_32bit)
1292 expr.X_add_number = -4;
1293 emit_expr (&expr, 4);
1294 sizeof_offset = 4;
1296 else if (d2f == dwarf2_format_64bit)
1298 expr.X_add_number = -12;
1299 out_four (-1);
1300 emit_expr (&expr, 8);
1301 sizeof_offset = 8;
1303 else if (d2f == dwarf2_format_64bit_irix)
1305 expr.X_add_number = -8;
1306 emit_expr (&expr, 8);
1307 sizeof_offset = 8;
1309 else
1311 as_fatal (_("internal error: unknown dwarf2 format"));
1314 /* Version. */
1315 out_two (2);
1317 /* Length of the prologue following this length. */
1318 expr.X_op = O_subtract;
1319 expr.X_add_symbol = prologue_end;
1320 expr.X_op_symbol = line_start;
1321 expr.X_add_number = - (4 + 2 + 4);
1322 emit_expr (&expr, sizeof_offset);
1324 /* Parameters of the state machine. */
1325 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1326 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1327 out_byte (DWARF2_LINE_BASE);
1328 out_byte (DWARF2_LINE_RANGE);
1329 out_byte (DWARF2_LINE_OPCODE_BASE);
1331 /* Standard opcode lengths. */
1332 out_byte (0); /* DW_LNS_copy */
1333 out_byte (1); /* DW_LNS_advance_pc */
1334 out_byte (1); /* DW_LNS_advance_line */
1335 out_byte (1); /* DW_LNS_set_file */
1336 out_byte (1); /* DW_LNS_set_column */
1337 out_byte (0); /* DW_LNS_negate_stmt */
1338 out_byte (0); /* DW_LNS_set_basic_block */
1339 out_byte (0); /* DW_LNS_const_add_pc */
1340 out_byte (1); /* DW_LNS_fixed_advance_pc */
1341 out_byte (0); /* DW_LNS_set_prologue_end */
1342 out_byte (0); /* DW_LNS_set_epilogue_begin */
1343 out_byte (1); /* DW_LNS_set_isa */
1345 out_file_list ();
1347 symbol_set_value_now (prologue_end);
1349 /* For each section, emit a statement program. */
1350 for (s = all_segs; s; s = s->next)
1351 process_entries (s->seg, s->head->head);
1353 symbol_set_value_now (line_end);
1356 static void
1357 out_debug_ranges (segT ranges_seg)
1359 unsigned int addr_size = sizeof_address;
1360 struct line_seg *s;
1361 expressionS expr;
1362 unsigned int i;
1364 subseg_set (ranges_seg, 0);
1366 /* Base Address Entry. */
1367 for (i = 0; i < addr_size; i++)
1368 out_byte (0xff);
1369 for (i = 0; i < addr_size; i++)
1370 out_byte (0);
1372 /* Range List Entry. */
1373 for (s = all_segs; s; s = s->next)
1375 fragS *frag;
1376 symbolS *beg, *end;
1378 frag = first_frag_for_seg (s->seg);
1379 beg = symbol_temp_new (s->seg, 0, frag);
1380 s->text_start = beg;
1382 frag = last_frag_for_seg (s->seg);
1383 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1384 s->text_end = end;
1386 expr.X_op = O_symbol;
1387 expr.X_add_symbol = beg;
1388 expr.X_add_number = 0;
1389 emit_expr (&expr, addr_size);
1391 expr.X_op = O_symbol;
1392 expr.X_add_symbol = end;
1393 expr.X_add_number = 0;
1394 emit_expr (&expr, addr_size);
1397 /* End of Range Entry. */
1398 for (i = 0; i < addr_size; i++)
1399 out_byte (0);
1400 for (i = 0; i < addr_size; i++)
1401 out_byte (0);
1404 /* Emit data for .debug_aranges. */
1406 static void
1407 out_debug_aranges (segT aranges_seg, segT info_seg)
1409 unsigned int addr_size = sizeof_address;
1410 addressT size, skip;
1411 struct line_seg *s;
1412 expressionS expr;
1413 char *p;
1415 size = 4 + 2 + 4 + 1 + 1;
1417 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1418 if (skip == 2 * addr_size)
1419 skip = 0;
1420 size += skip;
1422 for (s = all_segs; s; s = s->next)
1423 size += 2 * addr_size;
1425 size += 2 * addr_size;
1427 subseg_set (aranges_seg, 0);
1429 /* Length of the compilation unit. */
1430 out_four (size - 4);
1432 /* Version. */
1433 out_two (2);
1435 /* Offset to .debug_info. */
1436 /* ??? sizeof_offset */
1437 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4);
1439 /* Size of an address (offset portion). */
1440 out_byte (addr_size);
1442 /* Size of a segment descriptor. */
1443 out_byte (0);
1445 /* Align the header. */
1446 if (skip)
1447 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1449 for (s = all_segs; s; s = s->next)
1451 fragS *frag;
1452 symbolS *beg, *end;
1454 frag = first_frag_for_seg (s->seg);
1455 beg = symbol_temp_new (s->seg, 0, frag);
1456 s->text_start = beg;
1458 frag = last_frag_for_seg (s->seg);
1459 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1460 s->text_end = end;
1462 expr.X_op = O_symbol;
1463 expr.X_add_symbol = beg;
1464 expr.X_add_number = 0;
1465 emit_expr (&expr, addr_size);
1467 expr.X_op = O_subtract;
1468 expr.X_add_symbol = end;
1469 expr.X_op_symbol = beg;
1470 expr.X_add_number = 0;
1471 emit_expr (&expr, addr_size);
1474 p = frag_more (2 * addr_size);
1475 md_number_to_chars (p, 0, addr_size);
1476 md_number_to_chars (p + addr_size, 0, addr_size);
1479 /* Emit data for .debug_abbrev. Note that this must be kept in
1480 sync with out_debug_info below. */
1482 static void
1483 out_debug_abbrev (segT abbrev_seg)
1485 subseg_set (abbrev_seg, 0);
1487 out_uleb128 (1);
1488 out_uleb128 (DW_TAG_compile_unit);
1489 out_byte (DW_CHILDREN_no);
1490 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1491 if (all_segs->next == NULL)
1493 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1494 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1496 else
1498 if (DWARF2_FORMAT () == dwarf2_format_32bit)
1499 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1500 else
1501 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1503 out_abbrev (DW_AT_name, DW_FORM_string);
1504 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1505 out_abbrev (DW_AT_producer, DW_FORM_string);
1506 out_abbrev (DW_AT_language, DW_FORM_data2);
1507 out_abbrev (0, 0);
1509 /* Terminate the abbreviations for this compilation unit. */
1510 out_byte (0);
1513 /* Emit a description of this compilation unit for .debug_info. */
1515 static void
1516 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1518 char producer[128];
1519 const char *comp_dir;
1520 const char *dirname;
1521 expressionS expr;
1522 symbolS *info_start;
1523 symbolS *info_end;
1524 char *p;
1525 int len;
1526 enum dwarf2_format d2f;
1527 int sizeof_offset;
1529 subseg_set (info_seg, 0);
1531 info_start = symbol_temp_new_now ();
1532 info_end = symbol_temp_make ();
1534 /* Compilation Unit length. */
1535 expr.X_op = O_subtract;
1536 expr.X_add_symbol = info_end;
1537 expr.X_op_symbol = info_start;
1539 d2f = DWARF2_FORMAT ();
1540 if (d2f == dwarf2_format_32bit)
1542 expr.X_add_number = -4;
1543 emit_expr (&expr, 4);
1544 sizeof_offset = 4;
1546 else if (d2f == dwarf2_format_64bit)
1548 expr.X_add_number = -12;
1549 out_four (-1);
1550 emit_expr (&expr, 8);
1551 sizeof_offset = 8;
1553 else if (d2f == dwarf2_format_64bit_irix)
1555 expr.X_add_number = -8;
1556 emit_expr (&expr, 8);
1557 sizeof_offset = 8;
1559 else
1561 as_fatal (_("internal error: unknown dwarf2 format"));
1564 /* DWARF version. */
1565 out_two (2);
1567 /* .debug_abbrev offset */
1568 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1570 /* Target address size. */
1571 out_byte (sizeof_address);
1573 /* DW_TAG_compile_unit DIE abbrev */
1574 out_uleb128 (1);
1576 /* DW_AT_stmt_list */
1577 /* ??? sizeof_offset */
1578 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4);
1580 /* These two attributes are emitted if all of the code is contiguous. */
1581 if (all_segs->next == NULL)
1583 /* DW_AT_low_pc */
1584 expr.X_op = O_symbol;
1585 expr.X_add_symbol = all_segs->text_start;
1586 expr.X_add_number = 0;
1587 emit_expr (&expr, sizeof_address);
1589 /* DW_AT_high_pc */
1590 expr.X_op = O_symbol;
1591 expr.X_add_symbol = all_segs->text_end;
1592 expr.X_add_number = 0;
1593 emit_expr (&expr, sizeof_address);
1595 else
1597 /* This attribute is emitted if the code is disjoint. */
1598 /* DW_AT_ranges. */
1599 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
1602 /* DW_AT_name. We don't have the actual file name that was present
1603 on the command line, so assume files[1] is the main input file.
1604 We're not supposed to get called unless at least one line number
1605 entry was emitted, so this should always be defined. */
1606 if (!files || files_in_use < 1)
1607 abort ();
1608 if (files[1].dir)
1610 dirname = remap_debug_filename (dirs[files[1].dir]);
1611 len = strlen (dirname);
1612 p = frag_more (len + 1);
1613 memcpy (p, dirname, len);
1614 INSERT_DIR_SEPARATOR (p, len);
1616 len = strlen (files[1].filename) + 1;
1617 p = frag_more (len);
1618 memcpy (p, files[1].filename, len);
1620 /* DW_AT_comp_dir */
1621 comp_dir = remap_debug_filename (getpwd ());
1622 len = strlen (comp_dir) + 1;
1623 p = frag_more (len);
1624 memcpy (p, comp_dir, len);
1626 /* DW_AT_producer */
1627 sprintf (producer, "GNU AS %s", VERSION);
1628 len = strlen (producer) + 1;
1629 p = frag_more (len);
1630 memcpy (p, producer, len);
1632 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1633 dwarf2 draft has no standard code for assembler. */
1634 out_two (DW_LANG_Mips_Assembler);
1636 symbol_set_value_now (info_end);
1639 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1640 were any .file/.loc directives, or --gdwarf2 was given, or if the
1641 file has a non-empty .debug_info section. If we emit .debug_line,
1642 and the .debug_info section is empty, we also emit .debug_info,
1643 .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if
1644 there were any .file/.loc directives, or --gdwarf2 was given and
1645 there were any located instructions emitted. */
1647 void
1648 dwarf2_finish (void)
1650 segT line_seg;
1651 struct line_seg *s;
1652 segT info_seg;
1653 int emit_other_sections = 0;
1655 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1656 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1658 if (!all_segs && emit_other_sections)
1659 /* There is no line information and no non-empty .debug_info
1660 section. */
1661 return;
1663 /* Calculate the size of an address for the target machine. */
1664 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1666 /* Create and switch to the line number section. */
1667 line_seg = subseg_new (".debug_line", 0);
1668 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1670 /* For each subsection, chain the debug entries together. */
1671 for (s = all_segs; s; s = s->next)
1673 struct line_subseg *ss = s->head;
1674 struct line_entry **ptail = ss->ptail;
1676 while ((ss = ss->next) != NULL)
1678 *ptail = ss->head;
1679 ptail = ss->ptail;
1683 out_debug_line (line_seg);
1685 /* If this is assembler generated line info, and there is no
1686 debug_info already, we need .debug_info and .debug_abbrev
1687 sections as well. */
1688 if (emit_other_sections)
1690 segT abbrev_seg;
1691 segT aranges_seg;
1692 segT ranges_seg;
1694 assert (all_segs);
1696 info_seg = subseg_new (".debug_info", 0);
1697 abbrev_seg = subseg_new (".debug_abbrev", 0);
1698 aranges_seg = subseg_new (".debug_aranges", 0);
1700 bfd_set_section_flags (stdoutput, info_seg,
1701 SEC_READONLY | SEC_DEBUGGING);
1702 bfd_set_section_flags (stdoutput, abbrev_seg,
1703 SEC_READONLY | SEC_DEBUGGING);
1704 bfd_set_section_flags (stdoutput, aranges_seg,
1705 SEC_READONLY | SEC_DEBUGGING);
1707 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1709 if (all_segs->next == NULL)
1710 ranges_seg = NULL;
1711 else
1713 ranges_seg = subseg_new (".debug_ranges", 0);
1714 bfd_set_section_flags (stdoutput, ranges_seg,
1715 SEC_READONLY | SEC_DEBUGGING);
1716 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
1717 out_debug_ranges (ranges_seg);
1720 out_debug_aranges (aranges_seg, info_seg);
1721 out_debug_abbrev (abbrev_seg);
1722 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);