1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
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)
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
23 /* Logical line numbers can be controlled by the compiler via the
27 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
28 [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
33 #include "safe-ctype.h"
38 #ifdef HAVE_SYS_PARAM_H
39 #include <sys/param.h>
42 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
46 #include "dwarf2dbg.h"
47 #include <filenames.h>
49 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
50 /* We need to decide which character to use as a directory separator.
51 Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
52 necessarily mean that the backslash character is the one to use.
53 Some environments, eg Cygwin, can support both naming conventions.
54 So we use the heuristic that we only need to use the backslash if
55 the path is an absolute path starting with a DOS style drive
56 selector. eg C: or D: */
57 # define INSERT_DIR_SEPARATOR(string, offset) \
62 && string[1] == ':') \
63 string [offset] = '\\'; \
65 string [offset] = '/'; \
69 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
73 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
76 #ifndef DWARF2_ADDR_SIZE
77 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
80 #ifndef DWARF2_FILE_NAME
81 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
84 #ifndef DWARF2_FILE_TIME_NAME
85 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0
88 #ifndef DWARF2_FILE_SIZE_NAME
89 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
92 #ifndef DWARF2_VERSION
93 #define DWARF2_VERSION 2
96 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
97 #ifndef DWARF2_ARANGES_VERSION
98 #define DWARF2_ARANGES_VERSION 2
101 /* This implementation output version 2 .debug_line information. */
102 #ifndef DWARF2_LINE_VERSION
103 #define DWARF2_LINE_VERSION 2
110 /* Since we can't generate the prolog until the body is complete, we
111 use three different subsegments for .debug_line: one holding the
112 prolog, one for the directory and filename info, and one for the
113 body ("statement program"). */
118 /* If linker relaxation might change offsets in the code, the DWARF special
119 opcodes and variable-length operands cannot be used. If this macro is
120 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
121 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
122 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
125 /* First special line opcde - leave room for the standard opcodes.
126 Note: If you want to change this, you'll have to update the
127 "standard_opcode_lengths" table that is emitted below in
129 #define DWARF2_LINE_OPCODE_BASE 13
131 #ifndef DWARF2_LINE_BASE
132 /* Minimum line offset in a special line info. opcode. This value
133 was chosen to give a reasonable range of values. */
134 # define DWARF2_LINE_BASE -5
137 /* Range of line offsets in a special line info. opcode. */
138 #ifndef DWARF2_LINE_RANGE
139 # define DWARF2_LINE_RANGE 14
142 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
143 /* Define the architecture-dependent minimum instruction length (in
144 bytes). This value should be rather too small than too big. */
145 # define DWARF2_LINE_MIN_INSN_LENGTH 1
148 /* Flag that indicates the initial value of the is_stmt_start flag. */
149 #define DWARF2_LINE_DEFAULT_IS_STMT 1
151 /* Given a special op, return the line skip amount. */
152 #define SPECIAL_LINE(op) \
153 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
155 /* Given a special op, return the address skip amount (in units of
156 DWARF2_LINE_MIN_INSN_LENGTH. */
157 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
159 /* The maximum address skip amount that can be encoded with a special op. */
160 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
163 struct line_entry *next;
165 struct dwarf2_line_info loc;
169 struct line_subseg *next;
171 struct line_entry *head;
172 struct line_entry **ptail;
176 struct line_seg *next;
178 struct line_subseg *head;
183 /* Collects data for all line table entries during assembly. */
184 static struct line_seg *all_segs;
185 /* Hash used to quickly lookup a segment by name, avoiding the need to search
186 through the all_segs list. */
187 static struct hash_control *all_segs_hash;
188 static struct line_seg **last_seg_ptr;
191 const char *filename;
195 /* Table of files used by .debug_line. */
196 static struct file_entry *files;
197 static unsigned int files_in_use;
198 static unsigned int files_allocated;
200 /* Table of directories used by .debug_line. */
202 static unsigned int dirs_in_use;
203 static unsigned int dirs_allocated;
205 /* TRUE when we've seen a .loc directive recently. Used to avoid
206 doing work when there's nothing to do. */
207 bfd_boolean dwarf2_loc_directive_seen;
209 /* TRUE when we're supposed to set the basic block mark whenever a
211 bfd_boolean dwarf2_loc_mark_labels;
213 /* Current location as indicated by the most recent .loc directive. */
214 static struct dwarf2_line_info current = {
216 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0,
220 /* Lines that are at the same location as CURRENT, and which are waiting
222 static struct line_entry *pending_lines, **pending_lines_tail = &pending_lines;
224 /* The size of an address on the target. */
225 static unsigned int sizeof_address;
227 static unsigned int get_filenum (const char *, unsigned int);
229 #ifndef TC_DWARF2_EMIT_OFFSET
230 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
232 /* Create an offset to .dwarf2_*. */
235 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
240 exp.X_add_symbol = symbol;
241 exp.X_add_number = 0;
242 emit_expr (&exp, size);
246 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
248 static struct line_subseg *
249 get_line_subseg (segT seg, subsegT subseg)
251 static segT last_seg;
252 static subsegT last_subseg;
253 static struct line_subseg *last_line_subseg;
256 struct line_subseg **pss, *lss;
258 if (seg == last_seg && subseg == last_subseg)
259 return last_line_subseg;
261 s = (struct line_seg *) hash_find (all_segs_hash, seg->name);
264 s = (struct line_seg *) xmalloc (sizeof (*s));
269 last_seg_ptr = &s->next;
270 hash_insert (all_segs_hash, seg->name, s);
272 gas_assert (seg == s->seg);
274 for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
276 if (lss->subseg == subseg)
278 if (lss->subseg > subseg)
282 lss = (struct line_subseg *) xmalloc (sizeof (*lss));
284 lss->subseg = subseg;
286 lss->ptail = &lss->head;
291 last_subseg = subseg;
292 last_line_subseg = lss;
297 /* Push LOC onto the pending lines list. */
300 dwarf2_push_line (struct dwarf2_line_info *loc)
302 struct line_entry *e;
304 e = (struct line_entry *) xmalloc (sizeof (*e));
309 *pending_lines_tail = e;
310 pending_lines_tail = &(*pending_lines_tail)->next;
313 /* Emit all pending line information. LABEL is the label with which the
314 lines should be associated, or null if they should be associated with
315 the current position. */
318 dwarf2_flush_pending_lines (symbolS *label)
322 struct line_subseg *lss;
323 struct line_entry *e;
326 label = symbol_temp_new_now ();
328 for (e = pending_lines; e; e = e->next)
331 lss = get_line_subseg (now_seg, now_subseg);
332 *lss->ptail = pending_lines;
333 lss->ptail = pending_lines_tail;
335 pending_lines = NULL;
336 pending_lines_tail = &pending_lines;
340 /* Record an entry for LOC occurring at OFS within the current fragment. */
343 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
345 static unsigned int line = -1;
346 static unsigned int filenum = -1;
348 /* Early out for as-yet incomplete location information. */
349 if (loc->filenum == 0 || loc->line == 0)
352 /* Don't emit sequences of line symbols for the same line when the
353 symbols apply to assembler code. It is necessary to emit
354 duplicate line symbols when a compiler asks for them, because GDB
355 uses them to determine the end of the prologue. */
356 if (debug_type == DEBUG_DWARF2
357 && line == loc->line && filenum == loc->filenum)
361 filenum = loc->filenum;
363 dwarf2_push_line (loc);
368 /* Use a non-fake name for the line number location,
369 so that it can be referred to by relocations. */
370 sprintf (name, ".Loc.%u.%u", line, filenum);
371 dwarf2_flush_pending_lines (symbol_new (name, now_seg, ofs, frag_now));
374 dwarf2_flush_pending_lines (symbol_temp_new (now_seg, ofs, frag_now));
377 /* Returns the current source information. If .file directives have
378 been encountered, the info for the corresponding source file is
379 returned. Otherwise, the info for the assembly source file is
383 dwarf2_where (struct dwarf2_line_info *line)
385 if (debug_type == DEBUG_DWARF2)
388 as_where (&filename, &line->line);
389 line->filenum = get_filenum (filename, 0);
391 line->flags = DWARF2_FLAG_IS_STMT;
392 line->isa = current.isa;
393 line->discriminator = current.discriminator;
399 /* A hook to allow the target backend to inform the line number state
400 machine of isa changes when assembler debug info is enabled. */
403 dwarf2_set_isa (unsigned int isa)
408 /* Called for each machine instruction, or relatively atomic group of
409 machine instructions (ie built-in macro). The instruction or group
410 is SIZE bytes in length. If dwarf2 line number generation is called
411 for, emit a line statement appropriately. */
414 dwarf2_emit_insn (int size)
416 struct dwarf2_line_info loc;
418 if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2)
423 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
424 dwarf2_consume_line_info ();
427 /* Called after the current line information has been either used with
428 dwarf2_gen_line_info or saved with a machine instruction for later use.
429 This resets the state of the line number information to reflect that
433 dwarf2_consume_line_info (void)
435 /* If the consumer has stashed the current location away for later use,
436 assume that any earlier location information should be associated
438 dwarf2_flush_pending_lines (NULL);
440 /* Unless we generate DWARF2 debugging information for each
441 assembler line, we only emit one line symbol for one LOC. */
442 dwarf2_loc_directive_seen = FALSE;
444 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
445 | DWARF2_FLAG_PROLOGUE_END
446 | DWARF2_FLAG_EPILOGUE_BEGIN);
447 current.discriminator = 0;
450 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
451 is enabled, emit a basic block marker. */
454 dwarf2_emit_label (symbolS *label)
456 struct dwarf2_line_info loc;
458 if (!dwarf2_loc_mark_labels)
460 if (S_GET_SEGMENT (label) != now_seg)
462 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
464 if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
469 loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
471 dwarf2_push_line (&loc);
472 dwarf2_flush_pending_lines (label);
473 dwarf2_consume_line_info ();
476 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
477 allocate it on that file table slot, otherwise return the first
481 get_filenum (const char *filename, unsigned int num)
483 static unsigned int last_used, last_used_dir_len;
488 if (num == 0 && last_used)
490 if (! files[last_used].dir
491 && filename_cmp (filename, files[last_used].filename) == 0)
493 if (files[last_used].dir
494 && filename_ncmp (filename, dirs[files[last_used].dir],
495 last_used_dir_len) == 0
496 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
497 && filename_cmp (filename + last_used_dir_len + 1,
498 files[last_used].filename) == 0)
502 file = lbasename (filename);
503 /* Don't make empty string from / or A: from A:/ . */
504 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
505 if (file <= filename + 3)
508 if (file == filename + 1)
511 dir_len = file - filename;
516 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
519 for (dir = 1; dir < dirs_in_use; ++dir)
520 if (filename_ncmp (filename, dirs[dir], dir_len) == 0
521 && dirs[dir][dir_len] == '\0')
524 if (dir >= dirs_in_use)
526 if (dir >= dirs_allocated)
528 dirs_allocated = dir + 32;
530 xrealloc (dirs, (dir + 32) * sizeof (const char *));
533 dirs[dir] = (char *) xmalloc (dir_len + 1);
534 memcpy (dirs[dir], filename, dir_len);
535 dirs[dir][dir_len] = '\0';
536 dirs_in_use = dir + 1;
542 for (i = 1; i < files_in_use; ++i)
543 if (files[i].dir == dir
545 && filename_cmp (file, files[i].filename) == 0)
548 last_used_dir_len = dir_len;
555 if (i >= files_allocated)
557 unsigned int old = files_allocated;
559 files_allocated = i + 32;
560 files = (struct file_entry *)
561 xrealloc (files, (i + 32) * sizeof (struct file_entry));
563 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
566 files[i].filename = num ? file : xstrdup (file);
568 if (files_in_use < i + 1)
569 files_in_use = i + 1;
571 last_used_dir_len = dir_len;
576 /* Handle two forms of .file directive:
577 - Pass .file "source.c" to s_app_file
578 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
580 If an entry is added to the file table, return a pointer to the filename. */
583 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
589 /* Continue to accept a bare string and pass it off. */
591 if (*input_line_pointer == '"')
597 num = get_absolute_expression ();
598 filename = demand_copy_C_string (&filename_len);
599 if (filename == NULL)
601 demand_empty_rest_of_line ();
605 as_bad (_("file number less than one"));
609 /* A .file directive implies compiler generated debug information is
610 being supplied. Turn off gas generated debug info. */
611 debug_type = DEBUG_NONE;
613 if (num < (int) files_in_use && files[num].filename != 0)
615 as_bad (_("file number %ld already allocated"), (long) num);
619 get_filenum (filename, num);
625 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
627 offsetT filenum, line;
629 /* If we see two .loc directives in a row, force the first one to be
631 if (dwarf2_loc_directive_seen)
632 dwarf2_push_line (¤t);
634 filenum = get_absolute_expression ();
636 line = get_absolute_expression ();
640 as_bad (_("file number less than one"));
643 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
645 as_bad (_("unassigned file number %ld"), (long) filenum);
649 current.filenum = filenum;
651 current.discriminator = 0;
656 if (files[filenum].dir)
658 size_t dir_len = strlen (dirs[files[filenum].dir]);
659 size_t file_len = strlen (files[filenum].filename);
660 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
662 memcpy (cp, dirs[files[filenum].dir], dir_len);
663 INSERT_DIR_SEPARATOR (cp, dir_len);
664 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
665 cp[dir_len + file_len + 1] = '\0';
666 listing_source_file (cp);
669 listing_source_file (files[filenum].filename);
670 listing_source_line (line);
675 if (ISDIGIT (*input_line_pointer))
677 current.column = get_absolute_expression ();
681 while (ISALPHA (*input_line_pointer))
686 p = input_line_pointer;
687 c = get_symbol_end ();
689 if (strcmp (p, "basic_block") == 0)
691 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
692 *input_line_pointer = c;
694 else if (strcmp (p, "prologue_end") == 0)
696 current.flags |= DWARF2_FLAG_PROLOGUE_END;
697 *input_line_pointer = c;
699 else if (strcmp (p, "epilogue_begin") == 0)
701 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
702 *input_line_pointer = c;
704 else if (strcmp (p, "is_stmt") == 0)
706 *input_line_pointer = c;
707 value = get_absolute_expression ();
709 current.flags &= ~DWARF2_FLAG_IS_STMT;
711 current.flags |= DWARF2_FLAG_IS_STMT;
714 as_bad (_("is_stmt value not 0 or 1"));
718 else if (strcmp (p, "isa") == 0)
720 *input_line_pointer = c;
721 value = get_absolute_expression ();
726 as_bad (_("isa number less than zero"));
730 else if (strcmp (p, "discriminator") == 0)
732 *input_line_pointer = c;
733 value = get_absolute_expression ();
735 current.discriminator = value;
738 as_bad (_("discriminator less than zero"));
744 as_bad (_("unknown .loc sub-directive `%s'"), p);
745 *input_line_pointer = c;
752 demand_empty_rest_of_line ();
753 dwarf2_loc_directive_seen = TRUE;
754 debug_type = DEBUG_NONE;
758 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
760 offsetT value = get_absolute_expression ();
762 if (value != 0 && value != 1)
764 as_bad (_("expected 0 or 1"));
765 ignore_rest_of_line ();
769 dwarf2_loc_mark_labels = value != 0;
770 demand_empty_rest_of_line ();
775 first_frag_for_seg (segT seg)
777 return seg_info (seg)->frchainP->frch_root;
781 last_frag_for_seg (segT seg)
783 frchainS *f = seg_info (seg)->frchainP;
785 while (f->frch_next != NULL)
791 /* Emit a single byte into the current segment. */
796 FRAG_APPEND_1_CHAR (byte);
799 /* Emit a statement program opcode into the current segment. */
807 /* Emit a two-byte word into the current segment. */
812 md_number_to_chars (frag_more (2), data, 2);
815 /* Emit a four byte word into the current segment. */
820 md_number_to_chars (frag_more (4), data, 4);
823 /* Emit an unsigned "little-endian base 128" number. */
826 out_uleb128 (addressT value)
828 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
831 /* Emit a signed "little-endian base 128" number. */
834 out_leb128 (addressT value)
836 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
839 /* Emit a tuple for .debug_abbrev. */
842 out_abbrev (int name, int form)
848 /* Get the size of a fragment. */
851 get_frag_fix (fragS *frag, segT seg)
858 /* If a fragment is the last in the chain, special measures must be
859 taken to find its size before relaxation, since it may be pending
860 on some subsegment chain. */
861 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
862 if (fr->frch_last == frag)
863 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
868 /* Set an absolute address (may result in a relocation entry). */
871 out_set_addr (symbolS *sym)
875 out_opcode (DW_LNS_extended_op);
876 out_uleb128 (sizeof_address + 1);
878 out_opcode (DW_LNE_set_address);
880 exp.X_add_symbol = sym;
881 exp.X_add_number = 0;
882 emit_expr (&exp, sizeof_address);
885 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
886 static void scale_addr_delta (addressT *);
889 scale_addr_delta (addressT *addr_delta)
891 static int printed_this = 0;
892 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
895 as_bad("unaligned opcodes detected in executable segment");
898 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
901 #define scale_addr_delta(A)
904 /* Encode a pair of line and address skips as efficiently as possible.
905 Note that the line skip is signed, whereas the address skip is unsigned.
907 The following two routines *must* be kept in sync. This is
908 enforced by making emit_inc_line_addr abort if we do not emit
909 exactly the expected number of bytes. */
912 size_inc_line_addr (int line_delta, addressT addr_delta)
914 unsigned int tmp, opcode;
917 /* Scale the address delta by the minimum instruction length. */
918 scale_addr_delta (&addr_delta);
920 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
921 We cannot use special opcodes here, since we want the end_sequence
922 to emit the matrix entry. */
923 if (line_delta == INT_MAX)
925 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
928 len = 1 + sizeof_leb128 (addr_delta, 0);
932 /* Bias the line delta by the base. */
933 tmp = line_delta - DWARF2_LINE_BASE;
935 /* If the line increment is out of range of a special opcode, we
936 must encode it with DW_LNS_advance_line. */
937 if (tmp >= DWARF2_LINE_RANGE)
939 len = 1 + sizeof_leb128 (line_delta, 1);
941 tmp = 0 - DWARF2_LINE_BASE;
944 /* Bias the opcode by the special opcode base. */
945 tmp += DWARF2_LINE_OPCODE_BASE;
947 /* Avoid overflow when addr_delta is large. */
948 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
950 /* Try using a special opcode. */
951 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
955 /* Try using DW_LNS_const_add_pc followed by special op. */
956 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
961 /* Otherwise use DW_LNS_advance_pc. */
962 len += 1 + sizeof_leb128 (addr_delta, 0);
964 /* DW_LNS_copy or special opcode. */
971 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
973 unsigned int tmp, opcode;
977 /* Line number sequences cannot go backward in addresses. This means
978 we've incorrectly ordered the statements in the sequence. */
979 gas_assert ((offsetT) addr_delta >= 0);
981 /* Scale the address delta by the minimum instruction length. */
982 scale_addr_delta (&addr_delta);
984 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
985 We cannot use special opcodes here, since we want the end_sequence
986 to emit the matrix entry. */
987 if (line_delta == INT_MAX)
989 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
990 *p++ = DW_LNS_const_add_pc;
993 *p++ = DW_LNS_advance_pc;
994 p += output_leb128 (p, addr_delta, 0);
997 *p++ = DW_LNS_extended_op;
999 *p++ = DW_LNE_end_sequence;
1003 /* Bias the line delta by the base. */
1004 tmp = line_delta - DWARF2_LINE_BASE;
1006 /* If the line increment is out of range of a special opcode, we
1007 must encode it with DW_LNS_advance_line. */
1008 if (tmp >= DWARF2_LINE_RANGE)
1010 *p++ = DW_LNS_advance_line;
1011 p += output_leb128 (p, line_delta, 1);
1014 tmp = 0 - DWARF2_LINE_BASE;
1018 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1020 if (line_delta == 0 && addr_delta == 0)
1026 /* Bias the opcode by the special opcode base. */
1027 tmp += DWARF2_LINE_OPCODE_BASE;
1029 /* Avoid overflow when addr_delta is large. */
1030 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1032 /* Try using a special opcode. */
1033 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1040 /* Try using DW_LNS_const_add_pc followed by special op. */
1041 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1044 *p++ = DW_LNS_const_add_pc;
1050 /* Otherwise use DW_LNS_advance_pc. */
1051 *p++ = DW_LNS_advance_pc;
1052 p += output_leb128 (p, addr_delta, 0);
1060 gas_assert (p == end);
1063 /* Handy routine to combine calls to the above two routines. */
1066 out_inc_line_addr (int line_delta, addressT addr_delta)
1068 int len = size_inc_line_addr (line_delta, addr_delta);
1069 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
1072 /* Write out an alternative form of line and address skips using
1073 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1074 line and address information, but it is required if linker relaxation
1075 could change the code offsets. The following two routines *must* be
1077 #define ADDR_DELTA_LIMIT 50000
1080 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
1084 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1085 if (line_delta != INT_MAX)
1086 len = 1 + sizeof_leb128 (line_delta, 1);
1088 if (addr_delta > ADDR_DELTA_LIMIT)
1090 /* DW_LNS_extended_op */
1091 len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
1092 /* DW_LNE_set_address */
1093 len += 1 + sizeof_address;
1096 /* DW_LNS_fixed_advance_pc */
1099 if (line_delta == INT_MAX)
1100 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1110 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1115 char *end = p + len;
1117 /* Line number sequences cannot go backward in addresses. This means
1118 we've incorrectly ordered the statements in the sequence. */
1119 gas_assert ((offsetT) addr_delta >= 0);
1121 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1122 if (line_delta != INT_MAX)
1124 *p++ = DW_LNS_advance_line;
1125 p += output_leb128 (p, line_delta, 1);
1128 pexp = symbol_get_value_expression (frag->fr_symbol);
1129 line_seg = subseg_get (".debug_line", 0);
1131 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1132 advance the address by at most 64K. Linker relaxation (without
1133 which this function would not be used) could change the operand by
1134 an unknown amount. If the address increment is getting close to
1135 the limit, just reset the address. */
1136 if (addr_delta > ADDR_DELTA_LIMIT)
1141 gas_assert (pexp->X_op == O_subtract);
1142 to_sym = pexp->X_add_symbol;
1144 *p++ = DW_LNS_extended_op;
1145 p += output_leb128 (p, sizeof_address + 1, 0);
1146 *p++ = DW_LNE_set_address;
1147 exp.X_op = O_symbol;
1148 exp.X_add_symbol = to_sym;
1149 exp.X_add_number = 0;
1150 subseg_change (line_seg, 0);
1151 emit_expr_fix (&exp, sizeof_address, frag, p);
1152 p += sizeof_address;
1156 *p++ = DW_LNS_fixed_advance_pc;
1157 subseg_change (line_seg, 0);
1158 emit_expr_fix (pexp, 2, frag, p);
1162 if (line_delta == INT_MAX)
1164 *p++ = DW_LNS_extended_op;
1166 *p++ = DW_LNE_end_sequence;
1171 gas_assert (p == end);
1174 /* Generate a variant frag that we can use to relax address/line
1175 increments between fragments of the target segment. */
1178 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1183 exp.X_op = O_subtract;
1184 exp.X_add_symbol = to_sym;
1185 exp.X_op_symbol = from_sym;
1186 exp.X_add_number = 0;
1188 /* The maximum size of the frag is the line delta with a maximum
1189 sized address delta. */
1190 if (DWARF2_USE_FIXED_ADVANCE_PC)
1191 max_chars = size_fixed_inc_line_addr (line_delta,
1192 -DWARF2_LINE_MIN_INSN_LENGTH);
1194 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1196 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1197 make_expr_symbol (&exp), line_delta, NULL);
1200 /* The function estimates the size of a rs_dwarf2dbg variant frag
1201 based on the current values of the symbols. It is called before
1202 the relaxation loop. We set fr_subtype to the expected length. */
1205 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1210 addr_delta = resolve_symbol_value (frag->fr_symbol);
1211 if (DWARF2_USE_FIXED_ADVANCE_PC)
1212 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1214 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1216 frag->fr_subtype = size;
1221 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1222 current values of the symbols. fr_subtype is the current length
1223 of the frag. This returns the change in frag length. */
1226 dwarf2dbg_relax_frag (fragS *frag)
1228 int old_size, new_size;
1230 old_size = frag->fr_subtype;
1231 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1233 return new_size - old_size;
1236 /* This function converts a rs_dwarf2dbg variant frag into a normal
1237 fill frag. This is called after all relaxation has been done.
1238 fr_subtype will be the desired length of the frag. */
1241 dwarf2dbg_convert_frag (fragS *frag)
1245 if (DWARF2_USE_FIXED_ADVANCE_PC)
1247 /* If linker relaxation is enabled then the distance bewteen the two
1248 symbols in the frag->fr_symbol expression might change. Hence we
1249 cannot rely upon the value computed by resolve_symbol_value.
1250 Instead we leave the expression unfinalized and allow
1251 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1252 relocation) that will allow the linker to correctly compute the
1253 actual address difference. We have to use a fixed line advance for
1254 this as we cannot (easily) relocate leb128 encoded values. */
1255 int saved_finalize_syms = finalize_syms;
1258 addr_diff = resolve_symbol_value (frag->fr_symbol);
1259 finalize_syms = saved_finalize_syms;
1262 addr_diff = resolve_symbol_value (frag->fr_symbol);
1264 /* fr_var carries the max_chars that we created the fragment with.
1265 fr_subtype carries the current expected length. We must, of
1266 course, have allocated enough memory earlier. */
1267 gas_assert (frag->fr_var >= (int) frag->fr_subtype);
1269 if (DWARF2_USE_FIXED_ADVANCE_PC)
1270 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1271 frag->fr_literal + frag->fr_fix,
1274 emit_inc_line_addr (frag->fr_offset, addr_diff,
1275 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1277 frag->fr_fix += frag->fr_subtype;
1278 frag->fr_type = rs_fill;
1280 frag->fr_offset = 0;
1283 /* Generate .debug_line content for the chain of line number entries
1284 beginning at E, for segment SEG. */
1287 process_entries (segT seg, struct line_entry *e)
1289 unsigned filenum = 1;
1291 unsigned column = 0;
1293 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1294 fragS *last_frag = NULL, *frag;
1295 addressT last_frag_ofs = 0, frag_ofs;
1296 symbolS *last_lab = NULL, *lab;
1297 struct line_entry *next;
1303 if (filenum != e->loc.filenum)
1305 filenum = e->loc.filenum;
1306 out_opcode (DW_LNS_set_file);
1307 out_uleb128 (filenum);
1310 if (column != e->loc.column)
1312 column = e->loc.column;
1313 out_opcode (DW_LNS_set_column);
1314 out_uleb128 (column);
1317 if (e->loc.discriminator != 0)
1319 out_opcode (DW_LNS_extended_op);
1320 out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
1321 out_opcode (DW_LNE_set_discriminator);
1322 out_uleb128 (e->loc.discriminator);
1325 if (isa != e->loc.isa)
1328 out_opcode (DW_LNS_set_isa);
1332 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1334 flags = e->loc.flags;
1335 out_opcode (DW_LNS_negate_stmt);
1338 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1339 out_opcode (DW_LNS_set_basic_block);
1341 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1342 out_opcode (DW_LNS_set_prologue_end);
1344 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1345 out_opcode (DW_LNS_set_epilogue_begin);
1347 /* Don't try to optimize away redundant entries; gdb wants two
1348 entries for a function where the code starts on the same line as
1349 the {, and there's no way to identify that case here. Trust gcc
1350 to optimize appropriately. */
1351 line_delta = e->loc.line - line;
1353 frag = symbol_get_frag (lab);
1354 frag_ofs = S_GET_VALUE (lab);
1356 if (last_frag == NULL)
1359 out_inc_line_addr (line_delta, 0);
1361 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1362 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1364 relax_inc_line_addr (line_delta, lab, last_lab);
1369 last_frag_ofs = frag_ofs;
1377 /* Emit a DW_LNE_end_sequence for the end of the section. */
1378 frag = last_frag_for_seg (seg);
1379 frag_ofs = get_frag_fix (frag, seg);
1380 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1381 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1384 lab = symbol_temp_new (seg, frag_ofs, frag);
1385 relax_inc_line_addr (INT_MAX, lab, last_lab);
1389 /* Emit the directory and file tables for .debug_line. */
1392 out_file_list (void)
1399 /* Emit directory list. */
1400 for (i = 1; i < dirs_in_use; ++i)
1402 dir = remap_debug_filename (dirs[i]);
1403 size = strlen (dir) + 1;
1404 cp = frag_more (size);
1405 memcpy (cp, dir, size);
1410 for (i = 1; i < files_in_use; ++i)
1412 const char *fullfilename;
1414 if (files[i].filename == NULL)
1416 as_bad (_("unassigned file number %ld"), (long) i);
1417 /* Prevent a crash later, particularly for file 1. */
1418 files[i].filename = "";
1422 fullfilename = DWARF2_FILE_NAME (files[i].filename,
1423 files[i].dir ? dirs [files [i].dir] : "");
1424 size = strlen (fullfilename) + 1;
1425 cp = frag_more (size);
1426 memcpy (cp, fullfilename, size);
1428 out_uleb128 (files[i].dir); /* directory number */
1429 /* Output the last modification timestamp. */
1430 out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
1431 files[i].dir ? dirs [files [i].dir] : ""));
1432 /* Output the filesize. */
1433 out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
1434 files[i].dir ? dirs [files [i].dir] : ""));
1437 /* Terminate filename list. */
1441 /* Switch to SEC and output a header length field. Return the size of
1442 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1443 to the end of the section. */
1446 out_header (asection *sec, expressionS *exp)
1451 subseg_set (sec, 0);
1452 start_sym = symbol_temp_new_now ();;
1453 end_sym = symbol_temp_make ();
1455 /* Total length of the information. */
1456 exp->X_op = O_subtract;
1457 exp->X_add_symbol = end_sym;
1458 exp->X_op_symbol = start_sym;
1460 switch (DWARF2_FORMAT (sec))
1462 case dwarf2_format_32bit:
1463 exp->X_add_number = -4;
1467 case dwarf2_format_64bit:
1468 exp->X_add_number = -12;
1473 case dwarf2_format_64bit_irix:
1474 exp->X_add_number = -8;
1479 as_fatal (_("internal error: unknown dwarf2 format"));
1483 /* Emit the collected .debug_line data. */
1486 out_debug_line (segT line_seg)
1489 symbolS *prologue_end;
1494 sizeof_offset = out_header (line_seg, &exp);
1495 line_end = exp.X_add_symbol;
1498 out_two (DWARF2_LINE_VERSION);
1500 /* Length of the prologue following this length. */
1501 prologue_end = symbol_temp_make ();
1502 exp.X_add_symbol = prologue_end;
1503 exp.X_add_number = - (4 + 2 + 4);
1504 emit_expr (&exp, sizeof_offset);
1506 /* Parameters of the state machine. */
1507 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1508 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1509 out_byte (DWARF2_LINE_BASE);
1510 out_byte (DWARF2_LINE_RANGE);
1511 out_byte (DWARF2_LINE_OPCODE_BASE);
1513 /* Standard opcode lengths. */
1514 out_byte (0); /* DW_LNS_copy */
1515 out_byte (1); /* DW_LNS_advance_pc */
1516 out_byte (1); /* DW_LNS_advance_line */
1517 out_byte (1); /* DW_LNS_set_file */
1518 out_byte (1); /* DW_LNS_set_column */
1519 out_byte (0); /* DW_LNS_negate_stmt */
1520 out_byte (0); /* DW_LNS_set_basic_block */
1521 out_byte (0); /* DW_LNS_const_add_pc */
1522 out_byte (1); /* DW_LNS_fixed_advance_pc */
1523 out_byte (0); /* DW_LNS_set_prologue_end */
1524 out_byte (0); /* DW_LNS_set_epilogue_begin */
1525 out_byte (1); /* DW_LNS_set_isa */
1529 symbol_set_value_now (prologue_end);
1531 /* For each section, emit a statement program. */
1532 for (s = all_segs; s; s = s->next)
1533 if (SEG_NORMAL (s->seg))
1534 process_entries (s->seg, s->head->head);
1536 as_warn ("dwarf line number information for %s ignored",
1537 segment_name (s->seg));
1539 symbol_set_value_now (line_end);
1543 out_debug_ranges (segT ranges_seg)
1545 unsigned int addr_size = sizeof_address;
1550 subseg_set (ranges_seg, 0);
1552 /* Base Address Entry. */
1553 for (i = 0; i < addr_size; i++)
1555 for (i = 0; i < addr_size; i++)
1558 /* Range List Entry. */
1559 for (s = all_segs; s; s = s->next)
1564 frag = first_frag_for_seg (s->seg);
1565 beg = symbol_temp_new (s->seg, 0, frag);
1566 s->text_start = beg;
1568 frag = last_frag_for_seg (s->seg);
1569 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1572 exp.X_op = O_symbol;
1573 exp.X_add_symbol = beg;
1574 exp.X_add_number = 0;
1575 emit_expr (&exp, addr_size);
1577 exp.X_op = O_symbol;
1578 exp.X_add_symbol = end;
1579 exp.X_add_number = 0;
1580 emit_expr (&exp, addr_size);
1583 /* End of Range Entry. */
1584 for (i = 0; i < addr_size; i++)
1586 for (i = 0; i < addr_size; i++)
1590 /* Emit data for .debug_aranges. */
1593 out_debug_aranges (segT aranges_seg, segT info_seg)
1595 unsigned int addr_size = sizeof_address;
1598 symbolS *aranges_end;
1602 sizeof_offset = out_header (aranges_seg, &exp);
1603 aranges_end = exp.X_add_symbol;
1606 out_two (DWARF2_ARANGES_VERSION);
1608 /* Offset to .debug_info. */
1609 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1611 /* Size of an address (offset portion). */
1612 out_byte (addr_size);
1614 /* Size of a segment descriptor. */
1617 /* Align the header. */
1618 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1620 for (s = all_segs; s; s = s->next)
1625 frag = first_frag_for_seg (s->seg);
1626 beg = symbol_temp_new (s->seg, 0, frag);
1627 s->text_start = beg;
1629 frag = last_frag_for_seg (s->seg);
1630 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1633 exp.X_op = O_symbol;
1634 exp.X_add_symbol = beg;
1635 exp.X_add_number = 0;
1636 emit_expr (&exp, addr_size);
1638 exp.X_op = O_subtract;
1639 exp.X_add_symbol = end;
1640 exp.X_op_symbol = beg;
1641 exp.X_add_number = 0;
1642 emit_expr (&exp, addr_size);
1645 p = frag_more (2 * addr_size);
1646 md_number_to_chars (p, 0, addr_size);
1647 md_number_to_chars (p + addr_size, 0, addr_size);
1649 symbol_set_value_now (aranges_end);
1652 /* Emit data for .debug_abbrev. Note that this must be kept in
1653 sync with out_debug_info below. */
1656 out_debug_abbrev (segT abbrev_seg,
1657 segT info_seg ATTRIBUTE_UNUSED,
1658 segT line_seg ATTRIBUTE_UNUSED)
1660 subseg_set (abbrev_seg, 0);
1663 out_uleb128 (DW_TAG_compile_unit);
1664 out_byte (DW_CHILDREN_no);
1665 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
1666 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1668 out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
1669 if (all_segs->next == NULL)
1671 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1672 if (DWARF2_VERSION < 4)
1673 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1675 out_abbrev (DW_AT_high_pc, (sizeof_address == 4
1676 ? DW_FORM_data4 : DW_FORM_data8));
1680 if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
1681 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1683 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1685 out_abbrev (DW_AT_name, DW_FORM_string);
1686 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1687 out_abbrev (DW_AT_producer, DW_FORM_string);
1688 out_abbrev (DW_AT_language, DW_FORM_data2);
1691 /* Terminate the abbreviations for this compilation unit. */
1695 /* Emit a description of this compilation unit for .debug_info. */
1698 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1701 const char *comp_dir;
1702 const char *dirname;
1709 sizeof_offset = out_header (info_seg, &exp);
1710 info_end = exp.X_add_symbol;
1712 /* DWARF version. */
1713 out_two (DWARF2_VERSION);
1715 /* .debug_abbrev offset */
1716 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1718 /* Target address size. */
1719 out_byte (sizeof_address);
1721 /* DW_TAG_compile_unit DIE abbrev */
1724 /* DW_AT_stmt_list */
1725 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
1726 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
1729 /* These two attributes are emitted if all of the code is contiguous. */
1730 if (all_segs->next == NULL)
1733 exp.X_op = O_symbol;
1734 exp.X_add_symbol = all_segs->text_start;
1735 exp.X_add_number = 0;
1736 emit_expr (&exp, sizeof_address);
1739 if (DWARF2_VERSION < 4)
1740 exp.X_op = O_symbol;
1743 exp.X_op = O_subtract;
1744 exp.X_op_symbol = all_segs->text_start;
1746 exp.X_add_symbol = all_segs->text_end;
1747 exp.X_add_number = 0;
1748 emit_expr (&exp, sizeof_address);
1752 /* This attribute is emitted if the code is disjoint. */
1754 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
1757 /* DW_AT_name. We don't have the actual file name that was present
1758 on the command line, so assume files[1] is the main input file.
1759 We're not supposed to get called unless at least one line number
1760 entry was emitted, so this should always be defined. */
1761 if (files_in_use == 0)
1765 dirname = remap_debug_filename (dirs[files[1].dir]);
1766 len = strlen (dirname);
1768 /* Already has trailing slash. */
1769 p = frag_more (len);
1770 memcpy (p, dirname, len);
1772 p = frag_more (len + 1);
1773 memcpy (p, dirname, len);
1774 INSERT_DIR_SEPARATOR (p, len);
1777 len = strlen (files[1].filename) + 1;
1778 p = frag_more (len);
1779 memcpy (p, files[1].filename, len);
1781 /* DW_AT_comp_dir */
1782 comp_dir = remap_debug_filename (getpwd ());
1783 len = strlen (comp_dir) + 1;
1784 p = frag_more (len);
1785 memcpy (p, comp_dir, len);
1787 /* DW_AT_producer */
1788 sprintf (producer, "GNU AS %s", VERSION);
1789 len = strlen (producer) + 1;
1790 p = frag_more (len);
1791 memcpy (p, producer, len);
1793 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1794 dwarf2 draft has no standard code for assembler. */
1795 out_two (DW_LANG_Mips_Assembler);
1797 symbol_set_value_now (info_end);
1803 all_segs_hash = hash_new ();
1804 last_seg_ptr = &all_segs;
1808 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1809 were any .file/.loc directives, or --gdwarf2 was given, or if the
1810 file has a non-empty .debug_info section and an empty .debug_line
1811 section. If we emit .debug_line, and the .debug_info section is
1812 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
1813 ALL_SEGS will be non-null if there were any .file/.loc directives,
1814 or --gdwarf2 was given and there were any located instructions
1818 dwarf2_finish (void)
1823 int emit_other_sections = 0;
1824 int empty_debug_line = 0;
1826 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1827 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1829 line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
1830 empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
1832 /* We can't construct a new debug_line section if we already have one.
1834 if (all_segs && !empty_debug_line)
1835 as_fatal ("duplicate .debug_line sections");
1837 if ((!all_segs && emit_other_sections)
1838 || (!emit_other_sections && !empty_debug_line))
1839 /* If there is no line information and no non-empty .debug_info
1840 section, or if there is both a non-empty .debug_info and a non-empty
1841 .debug_line, then we do nothing. */
1844 /* Calculate the size of an address for the target machine. */
1845 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1847 /* Create and switch to the line number section. */
1848 line_seg = subseg_new (".debug_line", 0);
1849 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1851 /* For each subsection, chain the debug entries together. */
1852 for (s = all_segs; s; s = s->next)
1854 struct line_subseg *lss = s->head;
1855 struct line_entry **ptail = lss->ptail;
1857 while ((lss = lss->next) != NULL)
1864 out_debug_line (line_seg);
1866 /* If this is assembler generated line info, and there is no
1867 debug_info already, we need .debug_info and .debug_abbrev
1868 sections as well. */
1869 if (emit_other_sections)
1875 gas_assert (all_segs);
1877 info_seg = subseg_new (".debug_info", 0);
1878 abbrev_seg = subseg_new (".debug_abbrev", 0);
1879 aranges_seg = subseg_new (".debug_aranges", 0);
1881 bfd_set_section_flags (stdoutput, info_seg,
1882 SEC_READONLY | SEC_DEBUGGING);
1883 bfd_set_section_flags (stdoutput, abbrev_seg,
1884 SEC_READONLY | SEC_DEBUGGING);
1885 bfd_set_section_flags (stdoutput, aranges_seg,
1886 SEC_READONLY | SEC_DEBUGGING);
1888 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1890 if (all_segs->next == NULL)
1894 ranges_seg = subseg_new (".debug_ranges", 0);
1895 bfd_set_section_flags (stdoutput, ranges_seg,
1896 SEC_READONLY | SEC_DEBUGGING);
1897 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
1898 out_debug_ranges (ranges_seg);
1901 out_debug_aranges (aranges_seg, info_seg);
1902 out_debug_abbrev (abbrev_seg, info_seg, line_seg);
1903 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);