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 static void scale_addr_delta (addressT *);
888 scale_addr_delta (addressT *addr_delta)
890 static int printed_this = 0;
891 if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
893 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this)
895 as_bad("unaligned opcodes detected in executable segment");
898 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
902 /* Encode a pair of line and address skips as efficiently as possible.
903 Note that the line skip is signed, whereas the address skip is unsigned.
905 The following two routines *must* be kept in sync. This is
906 enforced by making emit_inc_line_addr abort if we do not emit
907 exactly the expected number of bytes. */
910 size_inc_line_addr (int line_delta, addressT addr_delta)
912 unsigned int tmp, opcode;
915 /* Scale the address delta by the minimum instruction length. */
916 scale_addr_delta (&addr_delta);
918 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
919 We cannot use special opcodes here, since we want the end_sequence
920 to emit the matrix entry. */
921 if (line_delta == INT_MAX)
923 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
926 len = 1 + sizeof_leb128 (addr_delta, 0);
930 /* Bias the line delta by the base. */
931 tmp = line_delta - DWARF2_LINE_BASE;
933 /* If the line increment is out of range of a special opcode, we
934 must encode it with DW_LNS_advance_line. */
935 if (tmp >= DWARF2_LINE_RANGE)
937 len = 1 + sizeof_leb128 (line_delta, 1);
939 tmp = 0 - DWARF2_LINE_BASE;
942 /* Bias the opcode by the special opcode base. */
943 tmp += DWARF2_LINE_OPCODE_BASE;
945 /* Avoid overflow when addr_delta is large. */
946 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
948 /* Try using a special opcode. */
949 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
953 /* Try using DW_LNS_const_add_pc followed by special op. */
954 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
959 /* Otherwise use DW_LNS_advance_pc. */
960 len += 1 + sizeof_leb128 (addr_delta, 0);
962 /* DW_LNS_copy or special opcode. */
969 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
971 unsigned int tmp, opcode;
975 /* Line number sequences cannot go backward in addresses. This means
976 we've incorrectly ordered the statements in the sequence. */
977 gas_assert ((offsetT) addr_delta >= 0);
979 /* Scale the address delta by the minimum instruction length. */
980 scale_addr_delta (&addr_delta);
982 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
983 We cannot use special opcodes here, since we want the end_sequence
984 to emit the matrix entry. */
985 if (line_delta == INT_MAX)
987 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
988 *p++ = DW_LNS_const_add_pc;
991 *p++ = DW_LNS_advance_pc;
992 p += output_leb128 (p, addr_delta, 0);
995 *p++ = DW_LNS_extended_op;
997 *p++ = DW_LNE_end_sequence;
1001 /* Bias the line delta by the base. */
1002 tmp = line_delta - DWARF2_LINE_BASE;
1004 /* If the line increment is out of range of a special opcode, we
1005 must encode it with DW_LNS_advance_line. */
1006 if (tmp >= DWARF2_LINE_RANGE)
1008 *p++ = DW_LNS_advance_line;
1009 p += output_leb128 (p, line_delta, 1);
1012 tmp = 0 - DWARF2_LINE_BASE;
1016 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1018 if (line_delta == 0 && addr_delta == 0)
1024 /* Bias the opcode by the special opcode base. */
1025 tmp += DWARF2_LINE_OPCODE_BASE;
1027 /* Avoid overflow when addr_delta is large. */
1028 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1030 /* Try using a special opcode. */
1031 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1038 /* Try using DW_LNS_const_add_pc followed by special op. */
1039 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1042 *p++ = DW_LNS_const_add_pc;
1048 /* Otherwise use DW_LNS_advance_pc. */
1049 *p++ = DW_LNS_advance_pc;
1050 p += output_leb128 (p, addr_delta, 0);
1058 gas_assert (p == end);
1061 /* Handy routine to combine calls to the above two routines. */
1064 out_inc_line_addr (int line_delta, addressT addr_delta)
1066 int len = size_inc_line_addr (line_delta, addr_delta);
1067 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
1070 /* Write out an alternative form of line and address skips using
1071 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1072 line and address information, but it is required if linker relaxation
1073 could change the code offsets. The following two routines *must* be
1075 #define ADDR_DELTA_LIMIT 50000
1078 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
1082 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1083 if (line_delta != INT_MAX)
1084 len = 1 + sizeof_leb128 (line_delta, 1);
1086 if (addr_delta > ADDR_DELTA_LIMIT)
1088 /* DW_LNS_extended_op */
1089 len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
1090 /* DW_LNE_set_address */
1091 len += 1 + sizeof_address;
1094 /* DW_LNS_fixed_advance_pc */
1097 if (line_delta == INT_MAX)
1098 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1108 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1113 char *end = p + len;
1115 /* Line number sequences cannot go backward in addresses. This means
1116 we've incorrectly ordered the statements in the sequence. */
1117 gas_assert ((offsetT) addr_delta >= 0);
1119 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1120 if (line_delta != INT_MAX)
1122 *p++ = DW_LNS_advance_line;
1123 p += output_leb128 (p, line_delta, 1);
1126 pexp = symbol_get_value_expression (frag->fr_symbol);
1127 line_seg = subseg_get (".debug_line", 0);
1129 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1130 advance the address by at most 64K. Linker relaxation (without
1131 which this function would not be used) could change the operand by
1132 an unknown amount. If the address increment is getting close to
1133 the limit, just reset the address. */
1134 if (addr_delta > ADDR_DELTA_LIMIT)
1139 gas_assert (pexp->X_op == O_subtract);
1140 to_sym = pexp->X_add_symbol;
1142 *p++ = DW_LNS_extended_op;
1143 p += output_leb128 (p, sizeof_address + 1, 0);
1144 *p++ = DW_LNE_set_address;
1145 exp.X_op = O_symbol;
1146 exp.X_add_symbol = to_sym;
1147 exp.X_add_number = 0;
1148 subseg_change (line_seg, 0);
1149 emit_expr_fix (&exp, sizeof_address, frag, p);
1150 p += sizeof_address;
1154 *p++ = DW_LNS_fixed_advance_pc;
1155 subseg_change (line_seg, 0);
1156 emit_expr_fix (pexp, 2, frag, p);
1160 if (line_delta == INT_MAX)
1162 *p++ = DW_LNS_extended_op;
1164 *p++ = DW_LNE_end_sequence;
1169 gas_assert (p == end);
1172 /* Generate a variant frag that we can use to relax address/line
1173 increments between fragments of the target segment. */
1176 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1181 exp.X_op = O_subtract;
1182 exp.X_add_symbol = to_sym;
1183 exp.X_op_symbol = from_sym;
1184 exp.X_add_number = 0;
1186 /* The maximum size of the frag is the line delta with a maximum
1187 sized address delta. */
1188 if (DWARF2_USE_FIXED_ADVANCE_PC)
1189 max_chars = size_fixed_inc_line_addr (line_delta,
1190 -DWARF2_LINE_MIN_INSN_LENGTH);
1192 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1194 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1195 make_expr_symbol (&exp), line_delta, NULL);
1198 /* The function estimates the size of a rs_dwarf2dbg variant frag
1199 based on the current values of the symbols. It is called before
1200 the relaxation loop. We set fr_subtype to the expected length. */
1203 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1208 addr_delta = resolve_symbol_value (frag->fr_symbol);
1209 if (DWARF2_USE_FIXED_ADVANCE_PC)
1210 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1212 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1214 frag->fr_subtype = size;
1219 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1220 current values of the symbols. fr_subtype is the current length
1221 of the frag. This returns the change in frag length. */
1224 dwarf2dbg_relax_frag (fragS *frag)
1226 int old_size, new_size;
1228 old_size = frag->fr_subtype;
1229 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1231 return new_size - old_size;
1234 /* This function converts a rs_dwarf2dbg variant frag into a normal
1235 fill frag. This is called after all relaxation has been done.
1236 fr_subtype will be the desired length of the frag. */
1239 dwarf2dbg_convert_frag (fragS *frag)
1243 if (DWARF2_USE_FIXED_ADVANCE_PC)
1245 /* If linker relaxation is enabled then the distance bewteen the two
1246 symbols in the frag->fr_symbol expression might change. Hence we
1247 cannot rely upon the value computed by resolve_symbol_value.
1248 Instead we leave the expression unfinalized and allow
1249 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1250 relocation) that will allow the linker to correctly compute the
1251 actual address difference. We have to use a fixed line advance for
1252 this as we cannot (easily) relocate leb128 encoded values. */
1253 int saved_finalize_syms = finalize_syms;
1256 addr_diff = resolve_symbol_value (frag->fr_symbol);
1257 finalize_syms = saved_finalize_syms;
1260 addr_diff = resolve_symbol_value (frag->fr_symbol);
1262 /* fr_var carries the max_chars that we created the fragment with.
1263 fr_subtype carries the current expected length. We must, of
1264 course, have allocated enough memory earlier. */
1265 gas_assert (frag->fr_var >= (int) frag->fr_subtype);
1267 if (DWARF2_USE_FIXED_ADVANCE_PC)
1268 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1269 frag->fr_literal + frag->fr_fix,
1272 emit_inc_line_addr (frag->fr_offset, addr_diff,
1273 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1275 frag->fr_fix += frag->fr_subtype;
1276 frag->fr_type = rs_fill;
1278 frag->fr_offset = 0;
1281 /* Generate .debug_line content for the chain of line number entries
1282 beginning at E, for segment SEG. */
1285 process_entries (segT seg, struct line_entry *e)
1287 unsigned filenum = 1;
1289 unsigned column = 0;
1291 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1292 fragS *last_frag = NULL, *frag;
1293 addressT last_frag_ofs = 0, frag_ofs;
1294 symbolS *last_lab = NULL, *lab;
1295 struct line_entry *next;
1301 if (filenum != e->loc.filenum)
1303 filenum = e->loc.filenum;
1304 out_opcode (DW_LNS_set_file);
1305 out_uleb128 (filenum);
1308 if (column != e->loc.column)
1310 column = e->loc.column;
1311 out_opcode (DW_LNS_set_column);
1312 out_uleb128 (column);
1315 if (e->loc.discriminator != 0)
1317 out_opcode (DW_LNS_extended_op);
1318 out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
1319 out_opcode (DW_LNE_set_discriminator);
1320 out_uleb128 (e->loc.discriminator);
1323 if (isa != e->loc.isa)
1326 out_opcode (DW_LNS_set_isa);
1330 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1332 flags = e->loc.flags;
1333 out_opcode (DW_LNS_negate_stmt);
1336 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1337 out_opcode (DW_LNS_set_basic_block);
1339 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1340 out_opcode (DW_LNS_set_prologue_end);
1342 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1343 out_opcode (DW_LNS_set_epilogue_begin);
1345 /* Don't try to optimize away redundant entries; gdb wants two
1346 entries for a function where the code starts on the same line as
1347 the {, and there's no way to identify that case here. Trust gcc
1348 to optimize appropriately. */
1349 line_delta = e->loc.line - line;
1351 frag = symbol_get_frag (lab);
1352 frag_ofs = S_GET_VALUE (lab);
1354 if (last_frag == NULL)
1357 out_inc_line_addr (line_delta, 0);
1359 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1360 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1362 relax_inc_line_addr (line_delta, lab, last_lab);
1367 last_frag_ofs = frag_ofs;
1375 /* Emit a DW_LNE_end_sequence for the end of the section. */
1376 frag = last_frag_for_seg (seg);
1377 frag_ofs = get_frag_fix (frag, seg);
1378 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1379 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1382 lab = symbol_temp_new (seg, frag_ofs, frag);
1383 relax_inc_line_addr (INT_MAX, lab, last_lab);
1387 /* Emit the directory and file tables for .debug_line. */
1390 out_file_list (void)
1397 /* Emit directory list. */
1398 for (i = 1; i < dirs_in_use; ++i)
1400 dir = remap_debug_filename (dirs[i]);
1401 size = strlen (dir) + 1;
1402 cp = frag_more (size);
1403 memcpy (cp, dir, size);
1408 for (i = 1; i < files_in_use; ++i)
1410 const char *fullfilename;
1412 if (files[i].filename == NULL)
1414 as_bad (_("unassigned file number %ld"), (long) i);
1415 /* Prevent a crash later, particularly for file 1. */
1416 files[i].filename = "";
1420 fullfilename = DWARF2_FILE_NAME (files[i].filename,
1421 files[i].dir ? dirs [files [i].dir] : "");
1422 size = strlen (fullfilename) + 1;
1423 cp = frag_more (size);
1424 memcpy (cp, fullfilename, size);
1426 out_uleb128 (files[i].dir); /* directory number */
1427 /* Output the last modification timestamp. */
1428 out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
1429 files[i].dir ? dirs [files [i].dir] : ""));
1430 /* Output the filesize. */
1431 out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
1432 files[i].dir ? dirs [files [i].dir] : ""));
1435 /* Terminate filename list. */
1439 /* Switch to SEC and output a header length field. Return the size of
1440 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1441 to the end of the section. */
1444 out_header (asection *sec, expressionS *exp)
1449 subseg_set (sec, 0);
1450 start_sym = symbol_temp_new_now ();
1451 end_sym = symbol_temp_make ();
1453 /* Total length of the information. */
1454 exp->X_op = O_subtract;
1455 exp->X_add_symbol = end_sym;
1456 exp->X_op_symbol = start_sym;
1458 switch (DWARF2_FORMAT (sec))
1460 case dwarf2_format_32bit:
1461 exp->X_add_number = -4;
1465 case dwarf2_format_64bit:
1466 exp->X_add_number = -12;
1471 case dwarf2_format_64bit_irix:
1472 exp->X_add_number = -8;
1477 as_fatal (_("internal error: unknown dwarf2 format"));
1481 /* Emit the collected .debug_line data. */
1484 out_debug_line (segT line_seg)
1487 symbolS *prologue_end;
1492 sizeof_offset = out_header (line_seg, &exp);
1493 line_end = exp.X_add_symbol;
1496 out_two (DWARF2_LINE_VERSION);
1498 /* Length of the prologue following this length. */
1499 prologue_end = symbol_temp_make ();
1500 exp.X_add_symbol = prologue_end;
1501 exp.X_add_number = - (4 + 2 + 4);
1502 emit_expr (&exp, sizeof_offset);
1504 /* Parameters of the state machine. */
1505 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1506 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1507 out_byte (DWARF2_LINE_BASE);
1508 out_byte (DWARF2_LINE_RANGE);
1509 out_byte (DWARF2_LINE_OPCODE_BASE);
1511 /* Standard opcode lengths. */
1512 out_byte (0); /* DW_LNS_copy */
1513 out_byte (1); /* DW_LNS_advance_pc */
1514 out_byte (1); /* DW_LNS_advance_line */
1515 out_byte (1); /* DW_LNS_set_file */
1516 out_byte (1); /* DW_LNS_set_column */
1517 out_byte (0); /* DW_LNS_negate_stmt */
1518 out_byte (0); /* DW_LNS_set_basic_block */
1519 out_byte (0); /* DW_LNS_const_add_pc */
1520 out_byte (1); /* DW_LNS_fixed_advance_pc */
1521 out_byte (0); /* DW_LNS_set_prologue_end */
1522 out_byte (0); /* DW_LNS_set_epilogue_begin */
1523 out_byte (1); /* DW_LNS_set_isa */
1527 symbol_set_value_now (prologue_end);
1529 /* For each section, emit a statement program. */
1530 for (s = all_segs; s; s = s->next)
1531 if (SEG_NORMAL (s->seg))
1532 process_entries (s->seg, s->head->head);
1534 as_warn ("dwarf line number information for %s ignored",
1535 segment_name (s->seg));
1537 symbol_set_value_now (line_end);
1541 out_debug_ranges (segT ranges_seg)
1543 unsigned int addr_size = sizeof_address;
1548 subseg_set (ranges_seg, 0);
1550 /* Base Address Entry. */
1551 for (i = 0; i < addr_size; i++)
1553 for (i = 0; i < addr_size; i++)
1556 /* Range List Entry. */
1557 for (s = all_segs; s; s = s->next)
1562 frag = first_frag_for_seg (s->seg);
1563 beg = symbol_temp_new (s->seg, 0, frag);
1564 s->text_start = beg;
1566 frag = last_frag_for_seg (s->seg);
1567 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1570 exp.X_op = O_symbol;
1571 exp.X_add_symbol = beg;
1572 exp.X_add_number = 0;
1573 emit_expr (&exp, addr_size);
1575 exp.X_op = O_symbol;
1576 exp.X_add_symbol = end;
1577 exp.X_add_number = 0;
1578 emit_expr (&exp, addr_size);
1581 /* End of Range Entry. */
1582 for (i = 0; i < addr_size; i++)
1584 for (i = 0; i < addr_size; i++)
1588 /* Emit data for .debug_aranges. */
1591 out_debug_aranges (segT aranges_seg, segT info_seg)
1593 unsigned int addr_size = sizeof_address;
1596 symbolS *aranges_end;
1600 sizeof_offset = out_header (aranges_seg, &exp);
1601 aranges_end = exp.X_add_symbol;
1604 out_two (DWARF2_ARANGES_VERSION);
1606 /* Offset to .debug_info. */
1607 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1609 /* Size of an address (offset portion). */
1610 out_byte (addr_size);
1612 /* Size of a segment descriptor. */
1615 /* Align the header. */
1616 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1618 for (s = all_segs; s; s = s->next)
1623 frag = first_frag_for_seg (s->seg);
1624 beg = symbol_temp_new (s->seg, 0, frag);
1625 s->text_start = beg;
1627 frag = last_frag_for_seg (s->seg);
1628 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1631 exp.X_op = O_symbol;
1632 exp.X_add_symbol = beg;
1633 exp.X_add_number = 0;
1634 emit_expr (&exp, addr_size);
1636 exp.X_op = O_subtract;
1637 exp.X_add_symbol = end;
1638 exp.X_op_symbol = beg;
1639 exp.X_add_number = 0;
1640 emit_expr (&exp, addr_size);
1643 p = frag_more (2 * addr_size);
1644 md_number_to_chars (p, 0, addr_size);
1645 md_number_to_chars (p + addr_size, 0, addr_size);
1647 symbol_set_value_now (aranges_end);
1650 /* Emit data for .debug_abbrev. Note that this must be kept in
1651 sync with out_debug_info below. */
1654 out_debug_abbrev (segT abbrev_seg,
1655 segT info_seg ATTRIBUTE_UNUSED,
1656 segT line_seg ATTRIBUTE_UNUSED)
1658 subseg_set (abbrev_seg, 0);
1661 out_uleb128 (DW_TAG_compile_unit);
1662 out_byte (DW_CHILDREN_no);
1663 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
1664 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1666 out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
1667 if (all_segs->next == NULL)
1669 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1670 if (DWARF2_VERSION < 4)
1671 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1673 out_abbrev (DW_AT_high_pc, (sizeof_address == 4
1674 ? DW_FORM_data4 : DW_FORM_data8));
1678 if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
1679 out_abbrev (DW_AT_ranges, DW_FORM_data4);
1681 out_abbrev (DW_AT_ranges, DW_FORM_data8);
1683 out_abbrev (DW_AT_name, DW_FORM_string);
1684 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1685 out_abbrev (DW_AT_producer, DW_FORM_string);
1686 out_abbrev (DW_AT_language, DW_FORM_data2);
1689 /* Terminate the abbreviations for this compilation unit. */
1693 /* Emit a description of this compilation unit for .debug_info. */
1696 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg)
1699 const char *comp_dir;
1700 const char *dirname;
1707 sizeof_offset = out_header (info_seg, &exp);
1708 info_end = exp.X_add_symbol;
1710 /* DWARF version. */
1711 out_two (DWARF2_VERSION);
1713 /* .debug_abbrev offset */
1714 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1716 /* Target address size. */
1717 out_byte (sizeof_address);
1719 /* DW_TAG_compile_unit DIE abbrev */
1722 /* DW_AT_stmt_list */
1723 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
1724 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
1727 /* These two attributes are emitted if all of the code is contiguous. */
1728 if (all_segs->next == NULL)
1731 exp.X_op = O_symbol;
1732 exp.X_add_symbol = all_segs->text_start;
1733 exp.X_add_number = 0;
1734 emit_expr (&exp, sizeof_address);
1737 if (DWARF2_VERSION < 4)
1738 exp.X_op = O_symbol;
1741 exp.X_op = O_subtract;
1742 exp.X_op_symbol = all_segs->text_start;
1744 exp.X_add_symbol = all_segs->text_end;
1745 exp.X_add_number = 0;
1746 emit_expr (&exp, sizeof_address);
1750 /* This attribute is emitted if the code is disjoint. */
1752 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
1755 /* DW_AT_name. We don't have the actual file name that was present
1756 on the command line, so assume files[1] is the main input file.
1757 We're not supposed to get called unless at least one line number
1758 entry was emitted, so this should always be defined. */
1759 if (files_in_use == 0)
1763 dirname = remap_debug_filename (dirs[files[1].dir]);
1764 len = strlen (dirname);
1766 /* Already has trailing slash. */
1767 p = frag_more (len);
1768 memcpy (p, dirname, len);
1770 p = frag_more (len + 1);
1771 memcpy (p, dirname, len);
1772 INSERT_DIR_SEPARATOR (p, len);
1775 len = strlen (files[1].filename) + 1;
1776 p = frag_more (len);
1777 memcpy (p, files[1].filename, len);
1779 /* DW_AT_comp_dir */
1780 comp_dir = remap_debug_filename (getpwd ());
1781 len = strlen (comp_dir) + 1;
1782 p = frag_more (len);
1783 memcpy (p, comp_dir, len);
1785 /* DW_AT_producer */
1786 sprintf (producer, "GNU AS %s", VERSION);
1787 len = strlen (producer) + 1;
1788 p = frag_more (len);
1789 memcpy (p, producer, len);
1791 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1792 dwarf2 draft has no standard code for assembler. */
1793 out_two (DW_LANG_Mips_Assembler);
1795 symbol_set_value_now (info_end);
1801 all_segs_hash = hash_new ();
1802 last_seg_ptr = &all_segs;
1806 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1807 were any .file/.loc directives, or --gdwarf2 was given, or if the
1808 file has a non-empty .debug_info section and an empty .debug_line
1809 section. If we emit .debug_line, and the .debug_info section is
1810 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
1811 ALL_SEGS will be non-null if there were any .file/.loc directives,
1812 or --gdwarf2 was given and there were any located instructions
1816 dwarf2_finish (void)
1821 int emit_other_sections = 0;
1822 int empty_debug_line = 0;
1824 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1825 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1827 line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
1828 empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
1830 /* We can't construct a new debug_line section if we already have one.
1832 if (all_segs && !empty_debug_line)
1833 as_fatal ("duplicate .debug_line sections");
1835 if ((!all_segs && emit_other_sections)
1836 || (!emit_other_sections && !empty_debug_line))
1837 /* If there is no line information and no non-empty .debug_info
1838 section, or if there is both a non-empty .debug_info and a non-empty
1839 .debug_line, then we do nothing. */
1842 /* Calculate the size of an address for the target machine. */
1843 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1845 /* Create and switch to the line number section. */
1846 line_seg = subseg_new (".debug_line", 0);
1847 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1849 /* For each subsection, chain the debug entries together. */
1850 for (s = all_segs; s; s = s->next)
1852 struct line_subseg *lss = s->head;
1853 struct line_entry **ptail = lss->ptail;
1855 while ((lss = lss->next) != NULL)
1862 out_debug_line (line_seg);
1864 /* If this is assembler generated line info, and there is no
1865 debug_info already, we need .debug_info and .debug_abbrev
1866 sections as well. */
1867 if (emit_other_sections)
1873 gas_assert (all_segs);
1875 info_seg = subseg_new (".debug_info", 0);
1876 abbrev_seg = subseg_new (".debug_abbrev", 0);
1877 aranges_seg = subseg_new (".debug_aranges", 0);
1879 bfd_set_section_flags (stdoutput, info_seg,
1880 SEC_READONLY | SEC_DEBUGGING);
1881 bfd_set_section_flags (stdoutput, abbrev_seg,
1882 SEC_READONLY | SEC_DEBUGGING);
1883 bfd_set_section_flags (stdoutput, aranges_seg,
1884 SEC_READONLY | SEC_DEBUGGING);
1886 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1888 if (all_segs->next == NULL)
1892 ranges_seg = subseg_new (".debug_ranges", 0);
1893 bfd_set_section_flags (stdoutput, ranges_seg,
1894 SEC_READONLY | SEC_DEBUGGING);
1895 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
1896 out_debug_ranges (ranges_seg);
1899 out_debug_aranges (aranges_seg, info_seg);
1900 out_debug_abbrev (abbrev_seg, info_seg, line_seg);
1901 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg);