1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright (C) 1999-2019 Free Software Foundation, Inc.
3 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 /* Logical line numbers can be controlled by the compiler via the
26 .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
32 #include "safe-ctype.h"
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
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) \
61 && string[1] == ':') \
62 string [offset] = '\\'; \
64 string [offset] = '/'; \
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
79 #ifndef DWARF2_FILE_NAME
80 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
83 #ifndef DWARF2_FILE_TIME_NAME
84 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION 2
95 /* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */
96 #ifndef DWARF2_ARANGES_VERSION
97 #define DWARF2_ARANGES_VERSION 2
100 /* This implementation outputs version 3 .debug_line information. */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION 3
109 /* Since we can't generate the prolog until the body is complete, we
110 use three different subsegments for .debug_line: one holding the
111 prolog, one for the directory and filename info, and one for the
112 body ("statement program"). */
117 /* If linker relaxation might change offsets in the code, the DWARF special
118 opcodes and variable-length operands cannot be used. If this macro is
119 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */
120 #ifndef DWARF2_USE_FIXED_ADVANCE_PC
121 # define DWARF2_USE_FIXED_ADVANCE_PC linkrelax
124 /* First special line opcode - leave room for the standard opcodes.
125 Note: If you want to change this, you'll have to update the
126 "standard_opcode_lengths" table that is emitted below in
128 #define DWARF2_LINE_OPCODE_BASE 13
130 #ifndef DWARF2_LINE_BASE
131 /* Minimum line offset in a special line info. opcode. This value
132 was chosen to give a reasonable range of values. */
133 # define DWARF2_LINE_BASE -5
136 /* Range of line offsets in a special line info. opcode. */
137 #ifndef DWARF2_LINE_RANGE
138 # define DWARF2_LINE_RANGE 14
141 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
142 /* Define the architecture-dependent minimum instruction length (in
143 bytes). This value should be rather too small than too big. */
144 # define DWARF2_LINE_MIN_INSN_LENGTH 1
147 /* Flag that indicates the initial value of the is_stmt_start flag. */
148 #define DWARF2_LINE_DEFAULT_IS_STMT 1
150 /* Given a special op, return the line skip amount. */
151 #define SPECIAL_LINE(op) \
152 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
154 /* Given a special op, return the address skip amount (in units of
155 DWARF2_LINE_MIN_INSN_LENGTH. */
156 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
158 /* The maximum address skip amount that can be encoded with a special op. */
159 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
161 #ifndef TC_PARSE_CONS_RETURN_NONE
162 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
167 struct line_entry *next;
169 struct dwarf2_line_info loc;
172 /* Don't change the offset of next in line_entry. set_or_check_view
173 calls in dwarf2_gen_line_info_1 depend on it. */
174 static char unused[offsetof(struct line_entry, next) ? -1 : 1]
179 struct line_subseg *next;
181 struct line_entry *head;
182 struct line_entry **ptail;
183 struct line_entry **pmove_tail;
188 struct line_seg *next;
190 struct line_subseg *head;
195 /* Collects data for all line table entries during assembly. */
196 static struct line_seg *all_segs;
197 static struct line_seg **last_seg_ptr;
201 const char *filename;
205 /* Table of files used by .debug_line. */
206 static struct file_entry *files;
207 static unsigned int files_in_use;
208 static unsigned int files_allocated;
210 /* Table of directories used by .debug_line. */
212 static unsigned int dirs_in_use;
213 static unsigned int dirs_allocated;
215 /* TRUE when we've seen a .loc directive recently. Used to avoid
216 doing work when there's nothing to do. */
217 bfd_boolean dwarf2_loc_directive_seen;
219 /* TRUE when we're supposed to set the basic block mark whenever a
221 bfd_boolean dwarf2_loc_mark_labels;
223 /* Current location as indicated by the most recent .loc directive. */
224 static struct dwarf2_line_info current =
227 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0,
231 /* This symbol is used to recognize view number forced resets in loc
233 static symbolS *force_reset_view;
235 /* This symbol evaluates to an expression that, if nonzero, indicates
236 some view assert check failed. */
237 static symbolS *view_assert_failed;
239 /* The size of an address on the target. */
240 static unsigned int sizeof_address;
242 static unsigned int get_filenum (const char *, unsigned int);
244 #ifndef TC_DWARF2_EMIT_OFFSET
245 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
247 /* Create an offset to .dwarf2_*. */
250 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
254 memset (&exp, 0, sizeof exp);
256 exp.X_add_symbol = symbol;
257 exp.X_add_number = 0;
258 emit_expr (&exp, size);
262 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */
264 static struct line_subseg *
265 get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p)
267 struct line_seg *s = seg_info (seg)->dwarf2_line_seg;
268 struct line_subseg **pss, *lss;
275 s = XNEW (struct line_seg);
280 last_seg_ptr = &s->next;
281 seg_info (seg)->dwarf2_line_seg = s;
283 gas_assert (seg == s->seg);
285 for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
287 if (lss->subseg == subseg)
289 if (lss->subseg > subseg)
293 lss = XNEW (struct line_subseg);
295 lss->subseg = subseg;
297 lss->ptail = &lss->head;
298 lss->pmove_tail = &lss->head;
305 /* (Un)reverse the line_entry list starting from H. */
307 static struct line_entry *
308 reverse_line_entry_list (struct line_entry *h)
310 struct line_entry *p = NULL, *e, *n;
312 for (e = h; e; e = n)
321 /* Compute the view for E based on the previous entry P. If we
322 introduce an (undefined) view symbol for P, and H is given (P must
323 be the tail in this case), introduce view symbols for earlier list
324 entries as well, until one of them is constant. */
327 set_or_check_view (struct line_entry *e, struct line_entry *p,
328 struct line_entry *h)
332 memset (&viewx, 0, sizeof (viewx));
333 viewx.X_unsigned = 1;
335 /* First, compute !(E->label > P->label), to tell whether or not
336 we're to reset the view number. If we can't resolve it to a
337 constant, keep it symbolic. */
338 if (!p || (e->loc.view == force_reset_view && force_reset_view))
340 viewx.X_op = O_constant;
341 viewx.X_add_number = 0;
342 viewx.X_add_symbol = NULL;
343 viewx.X_op_symbol = NULL;
348 viewx.X_add_number = 0;
349 viewx.X_add_symbol = e->label;
350 viewx.X_op_symbol = p->label;
351 resolve_expression (&viewx);
352 if (viewx.X_op == O_constant)
353 viewx.X_add_number = !viewx.X_add_number;
356 viewx.X_add_symbol = make_expr_symbol (&viewx);
357 viewx.X_add_number = 0;
358 viewx.X_op_symbol = NULL;
359 viewx.X_op = O_logical_not;
363 if (S_IS_DEFINED (e->loc.view) && symbol_constant_p (e->loc.view))
365 expressionS *value = symbol_get_value_expression (e->loc.view);
366 /* We can't compare the view numbers at this point, because in
367 VIEWX we've only determined whether we're to reset it so
369 if (viewx.X_op == O_constant)
371 if (!value->X_add_number != !viewx.X_add_number)
372 as_bad (_("view number mismatch"));
374 /* Record the expression to check it later. It is the result of
375 a logical not, thus 0 or 1. We just add up all such deferred
376 expressions, and resolve it at the end. */
377 else if (!value->X_add_number)
379 symbolS *deferred = make_expr_symbol (&viewx);
380 if (view_assert_failed)
384 memset (&chk, 0, sizeof (chk));
387 chk.X_add_number = 0;
388 chk.X_add_symbol = view_assert_failed;
389 chk.X_op_symbol = deferred;
390 deferred = make_expr_symbol (&chk);
392 view_assert_failed = deferred;
396 if (viewx.X_op != O_constant || viewx.X_add_number)
402 p->loc.view = symbol_temp_make ();
403 gas_assert (!S_IS_DEFINED (p->loc.view));
406 memset (&incv, 0, sizeof (incv));
408 incv.X_op = O_symbol;
409 incv.X_add_symbol = p->loc.view;
410 incv.X_add_number = 1;
412 if (viewx.X_op == O_constant)
414 gas_assert (viewx.X_add_number == 1);
419 viewx.X_add_symbol = make_expr_symbol (&viewx);
420 viewx.X_add_number = 0;
421 viewx.X_op_symbol = make_expr_symbol (&incv);
422 viewx.X_op = O_multiply;
426 if (!S_IS_DEFINED (e->loc.view))
428 symbol_set_value_expression (e->loc.view, &viewx);
429 S_SET_SEGMENT (e->loc.view, expr_section);
430 symbol_set_frag (e->loc.view, &zero_address_frag);
433 /* Define and attempt to simplify any earlier views needed to
435 if (h && p && p->loc.view && !S_IS_DEFINED (p->loc.view))
437 struct line_entry *h2;
438 /* Reverse the list to avoid quadratic behavior going backwards
439 in a single-linked list. */
440 struct line_entry *r = reverse_line_entry_list (h);
443 /* Set or check views until we find a defined or absent view. */
446 /* Do not define the head of a (sub?)segment view while
447 handling others. It would be defined too early, without
448 regard to the last view of other subsegments.
449 set_or_check_view will be called for every head segment
453 set_or_check_view (r, r->next, NULL);
455 while (r->next && r->next->loc.view && !S_IS_DEFINED (r->next->loc.view)
458 /* Unreverse the list, so that we can go forward again. */
459 h2 = reverse_line_entry_list (p);
460 gas_assert (h2 == h);
462 /* Starting from the last view we just defined, attempt to
463 simplify the view expressions, until we do so to P. */
466 /* The head view of a subsegment may remain undefined while
467 handling other elements, before it is linked to the last
468 view of the previous subsegment. */
471 gas_assert (S_IS_DEFINED (r->loc.view));
472 resolve_expression (symbol_get_value_expression (r->loc.view));
474 while (r != p && (r = r->next));
476 /* Now that we've defined and computed all earlier views that might
477 be needed to compute E's, attempt to simplify it. */
478 resolve_expression (symbol_get_value_expression (e->loc.view));
482 /* Record an entry for LOC occurring at LABEL. */
485 dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
487 struct line_subseg *lss;
488 struct line_entry *e;
490 e = XNEW (struct line_entry);
495 lss = get_line_subseg (now_seg, now_subseg, TRUE);
497 /* Subseg heads are chained to previous subsegs in
499 if (loc->view && lss->head)
500 set_or_check_view (e,
501 (struct line_entry *)lss->ptail,
505 lss->ptail = &e->next;
508 /* Record an entry for LOC occurring at OFS within the current fragment. */
511 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
513 static unsigned int line = -1;
514 static unsigned int filenum = -1;
518 /* Early out for as-yet incomplete location information. */
519 if (loc->filenum == 0 || loc->line == 0)
522 /* Don't emit sequences of line symbols for the same line when the
523 symbols apply to assembler code. It is necessary to emit
524 duplicate line symbols when a compiler asks for them, because GDB
525 uses them to determine the end of the prologue. */
526 if (debug_type == DEBUG_DWARF2
527 && line == loc->line && filenum == loc->filenum)
531 filenum = loc->filenum;
537 /* Use a non-fake name for the line number location,
538 so that it can be referred to by relocations. */
539 sprintf (name, ".Loc.%u.%u", line, filenum);
540 sym = symbol_new (name, now_seg, ofs, frag_now);
543 sym = symbol_temp_new (now_seg, ofs, frag_now);
544 dwarf2_gen_line_info_1 (sym, loc);
547 /* Returns the current source information. If .file directives have
548 been encountered, the info for the corresponding source file is
549 returned. Otherwise, the info for the assembly source file is
553 dwarf2_where (struct dwarf2_line_info *line)
555 if (debug_type == DEBUG_DWARF2)
557 const char *filename;
559 memset (line, 0, sizeof (*line));
560 filename = as_where (&line->line);
561 line->filenum = get_filenum (filename, 0);
563 line->flags = DWARF2_FLAG_IS_STMT;
564 line->isa = current.isa;
565 line->discriminator = current.discriminator;
572 /* A hook to allow the target backend to inform the line number state
573 machine of isa changes when assembler debug info is enabled. */
576 dwarf2_set_isa (unsigned int isa)
581 /* Called for each machine instruction, or relatively atomic group of
582 machine instructions (ie built-in macro). The instruction or group
583 is SIZE bytes in length. If dwarf2 line number generation is called
584 for, emit a line statement appropriately. */
587 dwarf2_emit_insn (int size)
589 struct dwarf2_line_info loc;
591 if (debug_type != DEBUG_DWARF2
592 ? !dwarf2_loc_directive_seen
593 : !seen_at_least_1_file ())
598 dwarf2_gen_line_info ((frag_now_fix_octets () - size) / OCTETS_PER_BYTE, &loc);
599 dwarf2_consume_line_info ();
602 /* Move all previously-emitted line entries for the current position by
603 DELTA bytes. This function cannot be used to move the same entries
607 dwarf2_move_insn (int delta)
609 struct line_subseg *lss;
610 struct line_entry *e;
616 lss = get_line_subseg (now_seg, now_subseg, FALSE);
620 now = frag_now_fix ();
621 while ((e = *lss->pmove_tail))
623 if (S_GET_VALUE (e->label) == now)
624 S_SET_VALUE (e->label, now + delta);
625 lss->pmove_tail = &e->next;
629 /* Called after the current line information has been either used with
630 dwarf2_gen_line_info or saved with a machine instruction for later use.
631 This resets the state of the line number information to reflect that
635 dwarf2_consume_line_info (void)
637 /* Unless we generate DWARF2 debugging information for each
638 assembler line, we only emit one line symbol for one LOC. */
639 dwarf2_loc_directive_seen = FALSE;
641 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
642 | DWARF2_FLAG_PROLOGUE_END
643 | DWARF2_FLAG_EPILOGUE_BEGIN);
644 current.discriminator = 0;
648 /* Called for each (preferably code) label. If dwarf2_loc_mark_labels
649 is enabled, emit a basic block marker. */
652 dwarf2_emit_label (symbolS *label)
654 struct dwarf2_line_info loc;
656 if (!dwarf2_loc_mark_labels)
658 if (S_GET_SEGMENT (label) != now_seg)
660 if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE))
662 if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
667 loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
669 dwarf2_gen_line_info_1 (label, &loc);
670 dwarf2_consume_line_info ();
673 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
674 allocate it on that file table slot, otherwise return the first
678 get_filenum (const char *filename, unsigned int num)
680 static unsigned int last_used, last_used_dir_len;
685 if (num == 0 && last_used)
687 if (! files[last_used].dir
688 && filename_cmp (filename, files[last_used].filename) == 0)
690 if (files[last_used].dir
691 && filename_ncmp (filename, dirs[files[last_used].dir],
692 last_used_dir_len) == 0
693 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
694 && filename_cmp (filename + last_used_dir_len + 1,
695 files[last_used].filename) == 0)
699 file = lbasename (filename);
700 /* Don't make empty string from / or A: from A:/ . */
701 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
702 if (file <= filename + 3)
705 if (file == filename + 1)
708 dir_len = file - filename;
713 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
716 for (dir = 1; dir < dirs_in_use; ++dir)
717 if (filename_ncmp (filename, dirs[dir], dir_len) == 0
718 && dirs[dir][dir_len] == '\0')
721 if (dir >= dirs_in_use)
723 if (dir >= dirs_allocated)
725 dirs_allocated = dir + 32;
726 dirs = XRESIZEVEC (char *, dirs, dirs_allocated);
729 dirs[dir] = xmemdup0 (filename, dir_len);
730 dirs_in_use = dir + 1;
736 for (i = 1; i < files_in_use; ++i)
737 if (files[i].dir == dir
739 && filename_cmp (file, files[i].filename) == 0)
742 last_used_dir_len = dir_len;
749 if (i >= files_allocated)
751 unsigned int old = files_allocated;
753 files_allocated = i + 32;
754 /* Catch wraparound. */
755 if (files_allocated <= old)
757 as_bad (_("file number %u is too big"), i);
761 files = XRESIZEVEC (struct file_entry, files, files_allocated);
762 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
765 files[i].filename = num ? file : xstrdup (file);
767 if (files_in_use < i + 1)
768 files_in_use = i + 1;
770 last_used_dir_len = dir_len;
775 /* Handle two forms of .file directive:
776 - Pass .file "source.c" to s_app_file
777 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
779 If an entry is added to the file table, return a pointer to the filename. */
782 dwarf2_directive_filename (void)
788 /* Continue to accept a bare string and pass it off. */
790 if (*input_line_pointer == '"')
796 num = get_absolute_expression ();
797 filename = demand_copy_C_string (&filename_len);
798 if (filename == NULL)
800 demand_empty_rest_of_line ();
804 as_bad (_("file number less than one"));
808 /* A .file directive implies compiler generated debug information is
809 being supplied. Turn off gas generated debug info. */
810 debug_type = DEBUG_NONE;
812 if (num < (offsetT) files_in_use && files[num].filename != 0)
814 as_bad (_("file number %ld already allocated"), (long) num);
819 as_bad (_("file number %ld is too small!"), (long) num);
823 get_filenum (filename, (unsigned int) num);
828 /* Calls dwarf2_directive_filename, but discards its result.
829 Used in pseudo-op tables where the function result is ignored. */
832 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
834 (void) dwarf2_directive_filename ();
838 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
840 offsetT filenum, line;
842 /* If we see two .loc directives in a row, force the first one to be
844 if (dwarf2_loc_directive_seen)
845 dwarf2_emit_insn (0);
847 filenum = get_absolute_expression ();
849 line = get_absolute_expression ();
853 as_bad (_("file number less than one"));
856 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
858 as_bad (_("unassigned file number %ld"), (long) filenum);
862 current.filenum = filenum;
864 current.discriminator = 0;
869 if (files[filenum].dir)
871 size_t dir_len = strlen (dirs[files[filenum].dir]);
872 size_t file_len = strlen (files[filenum].filename);
873 char *cp = XNEWVEC (char, dir_len + 1 + file_len + 1);
875 memcpy (cp, dirs[files[filenum].dir], dir_len);
876 INSERT_DIR_SEPARATOR (cp, dir_len);
877 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
878 cp[dir_len + file_len + 1] = '\0';
879 listing_source_file (cp);
883 listing_source_file (files[filenum].filename);
884 listing_source_line (line);
889 if (ISDIGIT (*input_line_pointer))
891 current.column = get_absolute_expression ();
895 while (ISALPHA (*input_line_pointer))
900 c = get_symbol_name (& p);
902 if (strcmp (p, "basic_block") == 0)
904 current.flags |= DWARF2_FLAG_BASIC_BLOCK;
905 *input_line_pointer = c;
907 else if (strcmp (p, "prologue_end") == 0)
909 current.flags |= DWARF2_FLAG_PROLOGUE_END;
910 *input_line_pointer = c;
912 else if (strcmp (p, "epilogue_begin") == 0)
914 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
915 *input_line_pointer = c;
917 else if (strcmp (p, "is_stmt") == 0)
919 (void) restore_line_pointer (c);
920 value = get_absolute_expression ();
922 current.flags &= ~DWARF2_FLAG_IS_STMT;
924 current.flags |= DWARF2_FLAG_IS_STMT;
927 as_bad (_("is_stmt value not 0 or 1"));
931 else if (strcmp (p, "isa") == 0)
933 (void) restore_line_pointer (c);
934 value = get_absolute_expression ();
939 as_bad (_("isa number less than zero"));
943 else if (strcmp (p, "discriminator") == 0)
945 (void) restore_line_pointer (c);
946 value = get_absolute_expression ();
948 current.discriminator = value;
951 as_bad (_("discriminator less than zero"));
955 else if (strcmp (p, "view") == 0)
959 (void) restore_line_pointer (c);
962 if (ISDIGIT (*input_line_pointer)
963 || *input_line_pointer == '-')
965 bfd_boolean force_reset = *input_line_pointer == '-';
967 value = get_absolute_expression ();
970 as_bad (_("numeric view can only be asserted to zero"));
973 if (force_reset && force_reset_view)
974 sym = force_reset_view;
977 sym = symbol_temp_new (absolute_section, value,
980 force_reset_view = sym;
985 char *name = read_symbol_name ();
989 sym = symbol_find_or_make (name);
990 if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
992 if (S_IS_VOLATILE (sym))
993 sym = symbol_clone (sym, 1);
994 else if (!S_CAN_BE_REDEFINED (sym))
996 as_bad (_("symbol `%s' is already defined"), name);
1000 S_SET_SEGMENT (sym, undefined_section);
1001 S_SET_VALUE (sym, 0);
1002 symbol_set_frag (sym, &zero_address_frag);
1008 as_bad (_("unknown .loc sub-directive `%s'"), p);
1009 (void) restore_line_pointer (c);
1013 SKIP_WHITESPACE_AFTER_NAME ();
1016 demand_empty_rest_of_line ();
1017 dwarf2_loc_directive_seen = TRUE;
1018 debug_type = DEBUG_NONE;
1020 /* If we were given a view id, emit the row right away. */
1022 dwarf2_emit_insn (0);
1026 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
1028 offsetT value = get_absolute_expression ();
1030 if (value != 0 && value != 1)
1032 as_bad (_("expected 0 or 1"));
1033 ignore_rest_of_line ();
1037 dwarf2_loc_mark_labels = value != 0;
1038 demand_empty_rest_of_line ();
1042 static struct frag *
1043 first_frag_for_seg (segT seg)
1045 return seg_info (seg)->frchainP->frch_root;
1048 static struct frag *
1049 last_frag_for_seg (segT seg)
1051 frchainS *f = seg_info (seg)->frchainP;
1053 while (f->frch_next != NULL)
1056 return f->frch_last;
1059 /* Emit a single byte into the current segment. */
1064 FRAG_APPEND_1_CHAR (byte);
1067 /* Emit a statement program opcode into the current segment. */
1070 out_opcode (int opc)
1075 /* Emit a two-byte word into the current segment. */
1080 md_number_to_chars (frag_more (2), data, 2);
1083 /* Emit a four byte word into the current segment. */
1088 md_number_to_chars (frag_more (4), data, 4);
1091 /* Emit an unsigned "little-endian base 128" number. */
1094 out_uleb128 (addressT value)
1096 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1099 /* Emit a signed "little-endian base 128" number. */
1102 out_leb128 (addressT value)
1104 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1107 /* Emit a tuple for .debug_abbrev. */
1110 out_abbrev (int name, int form)
1116 /* Get the size of a fragment. */
1119 get_frag_fix (fragS *frag, segT seg)
1124 return frag->fr_fix;
1126 /* If a fragment is the last in the chain, special measures must be
1127 taken to find its size before relaxation, since it may be pending
1128 on some subsegment chain. */
1129 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
1130 if (fr->frch_last == frag)
1131 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
1136 /* Set an absolute address (may result in a relocation entry). */
1139 out_inc_line_addr (int line_delta, addressT addr_delta);
1142 out_set_addr (symbolS *sym)
1145 addressT expr_addr, expr_addr_aligned;
1147 memset (&exp, 0, sizeof exp);
1149 /* The expression at the bottom must be aligned to OCTETS_PER_BYTE. The
1150 statements after the for loop will contribute 3 more octets. */
1151 expr_addr = frag_now_fix_octets () + 3;
1152 expr_addr_aligned = (expr_addr + OCTETS_PER_BYTE - 1) & -OCTETS_PER_BYTE;
1153 for ( ; expr_addr != expr_addr_aligned; expr_addr++)
1154 out_inc_line_addr (0, 0); /* NOP */
1156 out_opcode (DW_LNS_extended_op); /* 1 octet */
1157 out_uleb128 (sizeof_address + 1); /* 1 octet */
1159 out_opcode (DW_LNE_set_address); /* 1 octet */
1160 exp.X_op = O_symbol;
1161 exp.X_add_symbol = sym;
1162 exp.X_add_number = 0;
1163 emit_expr (&exp, sizeof_address);
1166 static void scale_addr_delta (addressT *);
1169 scale_addr_delta (addressT *addr_delta)
1171 static int printed_this = 0;
1172 if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
1174 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this)
1176 as_bad("unaligned opcodes detected in executable segment");
1179 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
1183 /* Encode a pair of line and address skips as efficiently as possible.
1184 Note that the line skip is signed, whereas the address skip is unsigned.
1186 The following two routines *must* be kept in sync. This is
1187 enforced by making emit_inc_line_addr abort if we do not emit
1188 exactly the expected number of bytes. */
1191 size_inc_line_addr (int line_delta, addressT addr_delta)
1193 unsigned int tmp, opcode;
1196 /* Scale the address delta by the minimum instruction length. */
1197 scale_addr_delta (&addr_delta);
1199 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1200 We cannot use special opcodes here, since we want the end_sequence
1201 to emit the matrix entry. */
1202 if (line_delta == INT_MAX)
1204 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
1206 else if (addr_delta)
1207 len = 1 + sizeof_leb128 (addr_delta, 0);
1211 /* Bias the line delta by the base. */
1212 tmp = line_delta - DWARF2_LINE_BASE;
1214 /* If the line increment is out of range of a special opcode, we
1215 must encode it with DW_LNS_advance_line. */
1216 if (tmp >= DWARF2_LINE_RANGE)
1218 len = 1 + sizeof_leb128 (line_delta, 1);
1220 tmp = 0 - DWARF2_LINE_BASE;
1223 /* Bias the opcode by the special opcode base. */
1224 tmp += DWARF2_LINE_OPCODE_BASE;
1226 /* Avoid overflow when addr_delta is large. */
1227 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1229 /* Try using a special opcode. */
1230 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1234 /* Try using DW_LNS_const_add_pc followed by special op. */
1235 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1240 /* Otherwise use DW_LNS_advance_pc. */
1241 len += 1 + sizeof_leb128 (addr_delta, 0);
1243 /* DW_LNS_copy or special opcode. */
1250 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
1252 unsigned int tmp, opcode;
1254 char *end = p + len;
1256 /* Line number sequences cannot go backward in addresses. This means
1257 we've incorrectly ordered the statements in the sequence. */
1258 gas_assert ((offsetT) addr_delta >= 0);
1260 /* Scale the address delta by the minimum instruction length. */
1261 scale_addr_delta (&addr_delta);
1263 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1264 We cannot use special opcodes here, since we want the end_sequence
1265 to emit the matrix entry. */
1266 if (line_delta == INT_MAX)
1268 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
1269 *p++ = DW_LNS_const_add_pc;
1270 else if (addr_delta)
1272 *p++ = DW_LNS_advance_pc;
1273 p += output_leb128 (p, addr_delta, 0);
1276 *p++ = DW_LNS_extended_op;
1278 *p++ = DW_LNE_end_sequence;
1282 /* Bias the line delta by the base. */
1283 tmp = line_delta - DWARF2_LINE_BASE;
1285 /* If the line increment is out of range of a special opcode, we
1286 must encode it with DW_LNS_advance_line. */
1287 if (tmp >= DWARF2_LINE_RANGE)
1289 *p++ = DW_LNS_advance_line;
1290 p += output_leb128 (p, line_delta, 1);
1293 tmp = 0 - DWARF2_LINE_BASE;
1297 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1299 if (line_delta == 0 && addr_delta == 0)
1305 /* Bias the opcode by the special opcode base. */
1306 tmp += DWARF2_LINE_OPCODE_BASE;
1308 /* Avoid overflow when addr_delta is large. */
1309 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1311 /* Try using a special opcode. */
1312 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1319 /* Try using DW_LNS_const_add_pc followed by special op. */
1320 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1323 *p++ = DW_LNS_const_add_pc;
1329 /* Otherwise use DW_LNS_advance_pc. */
1330 *p++ = DW_LNS_advance_pc;
1331 p += output_leb128 (p, addr_delta, 0);
1339 gas_assert (p == end);
1342 /* Handy routine to combine calls to the above two routines. */
1345 out_inc_line_addr (int line_delta, addressT addr_delta)
1347 int len = size_inc_line_addr (line_delta, addr_delta);
1348 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
1351 /* Write out an alternative form of line and address skips using
1352 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default
1353 line and address information, but it is required if linker relaxation
1354 could change the code offsets. The following two routines *must* be
1356 #define ADDR_DELTA_LIMIT 50000
1359 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
1363 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1364 if (line_delta != INT_MAX)
1365 len = 1 + sizeof_leb128 (line_delta, 1);
1367 if (addr_delta > ADDR_DELTA_LIMIT)
1369 /* DW_LNS_extended_op */
1370 len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
1371 /* DW_LNE_set_address */
1372 len += 1 + sizeof_address;
1375 /* DW_LNS_fixed_advance_pc */
1378 if (line_delta == INT_MAX)
1379 /* DW_LNS_extended_op + DW_LNE_end_sequence */
1389 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1393 char *end = p + len;
1395 /* Line number sequences cannot go backward in addresses. This means
1396 we've incorrectly ordered the statements in the sequence. */
1397 gas_assert ((offsetT) addr_delta >= 0);
1399 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */
1400 gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta));
1402 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */
1403 if (line_delta != INT_MAX)
1405 *p++ = DW_LNS_advance_line;
1406 p += output_leb128 (p, line_delta, 1);
1409 pexp = symbol_get_value_expression (frag->fr_symbol);
1411 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1412 advance the address by at most 64K. Linker relaxation (without
1413 which this function would not be used) could change the operand by
1414 an unknown amount. If the address increment is getting close to
1415 the limit, just reset the address. */
1416 if (addr_delta > ADDR_DELTA_LIMIT)
1421 memset (&exp, 0, sizeof exp);
1422 gas_assert (pexp->X_op == O_subtract);
1423 to_sym = pexp->X_add_symbol;
1425 *p++ = DW_LNS_extended_op;
1426 p += output_leb128 (p, sizeof_address + 1, 0);
1427 *p++ = DW_LNE_set_address;
1428 exp.X_op = O_symbol;
1429 exp.X_add_symbol = to_sym;
1430 exp.X_add_number = 0;
1431 emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE);
1432 p += sizeof_address;
1436 *p++ = DW_LNS_fixed_advance_pc;
1437 emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE);
1441 if (line_delta == INT_MAX)
1443 *p++ = DW_LNS_extended_op;
1445 *p++ = DW_LNE_end_sequence;
1450 gas_assert (p == end);
1453 /* Generate a variant frag that we can use to relax address/line
1454 increments between fragments of the target segment. */
1457 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1462 memset (&exp, 0, sizeof exp);
1463 exp.X_op = O_subtract;
1464 exp.X_add_symbol = to_sym;
1465 exp.X_op_symbol = from_sym;
1466 exp.X_add_number = 0;
1468 /* The maximum size of the frag is the line delta with a maximum
1469 sized address delta. */
1470 if (DWARF2_USE_FIXED_ADVANCE_PC)
1471 max_chars = size_fixed_inc_line_addr (line_delta,
1472 -DWARF2_LINE_MIN_INSN_LENGTH);
1474 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1476 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1477 make_expr_symbol (&exp), line_delta, NULL);
1480 /* The function estimates the size of a rs_dwarf2dbg variant frag
1481 based on the current values of the symbols. It is called before
1482 the relaxation loop. We set fr_subtype to the expected length. */
1485 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1490 addr_delta = resolve_symbol_value (frag->fr_symbol);
1491 if (DWARF2_USE_FIXED_ADVANCE_PC)
1492 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1494 size = size_inc_line_addr (frag->fr_offset, addr_delta);
1496 frag->fr_subtype = size;
1501 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1502 current values of the symbols. fr_subtype is the current length
1503 of the frag. This returns the change in frag length. */
1506 dwarf2dbg_relax_frag (fragS *frag)
1508 int old_size, new_size;
1510 old_size = frag->fr_subtype;
1511 new_size = dwarf2dbg_estimate_size_before_relax (frag);
1513 return new_size - old_size;
1516 /* This function converts a rs_dwarf2dbg variant frag into a normal
1517 fill frag. This is called after all relaxation has been done.
1518 fr_subtype will be the desired length of the frag. */
1521 dwarf2dbg_convert_frag (fragS *frag)
1525 if (DWARF2_USE_FIXED_ADVANCE_PC)
1527 /* If linker relaxation is enabled then the distance between the two
1528 symbols in the frag->fr_symbol expression might change. Hence we
1529 cannot rely upon the value computed by resolve_symbol_value.
1530 Instead we leave the expression unfinalized and allow
1531 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1532 relocation) that will allow the linker to correctly compute the
1533 actual address difference. We have to use a fixed line advance for
1534 this as we cannot (easily) relocate leb128 encoded values. */
1535 int saved_finalize_syms = finalize_syms;
1538 addr_diff = resolve_symbol_value (frag->fr_symbol);
1539 finalize_syms = saved_finalize_syms;
1542 addr_diff = resolve_symbol_value (frag->fr_symbol);
1544 /* fr_var carries the max_chars that we created the fragment with.
1545 fr_subtype carries the current expected length. We must, of
1546 course, have allocated enough memory earlier. */
1547 gas_assert (frag->fr_var >= (int) frag->fr_subtype);
1549 if (DWARF2_USE_FIXED_ADVANCE_PC)
1550 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1551 frag->fr_literal + frag->fr_fix,
1554 emit_inc_line_addr (frag->fr_offset, addr_diff,
1555 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1557 frag->fr_fix += frag->fr_subtype;
1558 frag->fr_type = rs_fill;
1560 frag->fr_offset = 0;
1563 /* Generate .debug_line content for the chain of line number entries
1564 beginning at E, for segment SEG. */
1567 process_entries (segT seg, struct line_entry *e)
1569 unsigned filenum = 1;
1571 unsigned column = 0;
1573 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1574 fragS *last_frag = NULL, *frag;
1575 addressT last_frag_ofs = 0, frag_ofs;
1576 symbolS *last_lab = NULL, *lab;
1577 struct line_entry *next;
1579 if (flag_dwarf_sections)
1582 const char * sec_name;
1584 /* Switch to the relevant sub-section before we start to emit
1585 the line number table.
1587 FIXME: These sub-sections do not have a normal Line Number
1588 Program Header, thus strictly speaking they are not valid
1589 DWARF sections. Unfortunately the DWARF standard assumes
1590 a one-to-one relationship between compilation units and
1591 line number tables. Thus we have to have a .debug_line
1592 section, as well as our sub-sections, and we have to ensure
1593 that all of the sub-sections are merged into a proper
1594 .debug_line section before a debugger sees them. */
1596 sec_name = bfd_get_section_name (stdoutput, seg);
1597 if (strcmp (sec_name, ".text") != 0)
1599 name = concat (".debug_line", sec_name, (char *) NULL);
1600 subseg_set (subseg_get (name, FALSE), 0);
1603 /* Don't create a .debug_line.text section -
1604 that is redundant. Instead just switch back to the
1605 normal .debug_line section. */
1606 subseg_set (subseg_get (".debug_line", FALSE), 0);
1613 if (filenum != e->loc.filenum)
1615 filenum = e->loc.filenum;
1616 out_opcode (DW_LNS_set_file);
1617 out_uleb128 (filenum);
1620 if (column != e->loc.column)
1622 column = e->loc.column;
1623 out_opcode (DW_LNS_set_column);
1624 out_uleb128 (column);
1627 if (e->loc.discriminator != 0)
1629 out_opcode (DW_LNS_extended_op);
1630 out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
1631 out_opcode (DW_LNE_set_discriminator);
1632 out_uleb128 (e->loc.discriminator);
1635 if (isa != e->loc.isa)
1638 out_opcode (DW_LNS_set_isa);
1642 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1644 flags = e->loc.flags;
1645 out_opcode (DW_LNS_negate_stmt);
1648 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1649 out_opcode (DW_LNS_set_basic_block);
1651 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1652 out_opcode (DW_LNS_set_prologue_end);
1654 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1655 out_opcode (DW_LNS_set_epilogue_begin);
1657 /* Don't try to optimize away redundant entries; gdb wants two
1658 entries for a function where the code starts on the same line as
1659 the {, and there's no way to identify that case here. Trust gcc
1660 to optimize appropriately. */
1661 line_delta = e->loc.line - line;
1663 frag = symbol_get_frag (lab);
1664 frag_ofs = S_GET_VALUE (lab);
1666 if (last_frag == NULL
1667 || (e->loc.view == force_reset_view && force_reset_view
1668 /* If we're going to reset the view, but we know we're
1669 advancing the PC, we don't have to force with
1670 set_address. We know we do when we're at the same
1671 address of the same frag, and we know we might when
1672 we're in the beginning of a frag, and we were at the
1673 end of the previous frag. */
1674 && (frag == last_frag
1675 ? (last_frag_ofs == frag_ofs)
1677 && ((offsetT)last_frag_ofs
1678 >= get_frag_fix (last_frag, seg))))))
1681 out_inc_line_addr (line_delta, 0);
1683 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1684 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1686 relax_inc_line_addr (line_delta, lab, last_lab);
1691 last_frag_ofs = frag_ofs;
1699 /* Emit a DW_LNE_end_sequence for the end of the section. */
1700 frag = last_frag_for_seg (seg);
1701 frag_ofs = get_frag_fix (frag, seg);
1702 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1703 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1706 lab = symbol_temp_new (seg, frag_ofs, frag);
1707 relax_inc_line_addr (INT_MAX, lab, last_lab);
1711 /* Emit the directory and file tables for .debug_line. */
1714 out_file_list (void)
1721 /* Emit directory list. */
1722 for (i = 1; i < dirs_in_use; ++i)
1724 dir = remap_debug_filename (dirs[i]);
1725 size = strlen (dir) + 1;
1726 cp = frag_more (size);
1727 memcpy (cp, dir, size);
1732 for (i = 1; i < files_in_use; ++i)
1734 const char *fullfilename;
1736 if (files[i].filename == NULL)
1738 as_bad (_("unassigned file number %ld"), (long) i);
1739 /* Prevent a crash later, particularly for file 1. */
1740 files[i].filename = "";
1744 fullfilename = DWARF2_FILE_NAME (files[i].filename,
1745 files[i].dir ? dirs [files [i].dir] : "");
1746 size = strlen (fullfilename) + 1;
1747 cp = frag_more (size);
1748 memcpy (cp, fullfilename, size);
1750 out_uleb128 (files[i].dir); /* directory number */
1751 /* Output the last modification timestamp. */
1752 out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
1753 files[i].dir ? dirs [files [i].dir] : ""));
1754 /* Output the filesize. */
1755 out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
1756 files[i].dir ? dirs [files [i].dir] : ""));
1759 /* Terminate filename list. */
1763 /* Switch to SEC and output a header length field. Return the size of
1764 offsets used in SEC. The caller must set EXPR->X_add_symbol value
1765 to the end of the section. EXPR->X_add_number will be set to the
1766 negative size of the header. */
1769 out_header (asection *sec, expressionS *exp)
1774 subseg_set (sec, 0);
1776 if (flag_dwarf_sections)
1778 /* If we are going to put the start and end symbols in different
1779 sections, then we need real symbols, not just fake, local ones. */
1781 start_sym = symbol_make (".Ldebug_line_start");
1782 end_sym = symbol_make (".Ldebug_line_end");
1783 symbol_set_value_now (start_sym);
1787 start_sym = symbol_temp_new_now_octets ();
1788 end_sym = symbol_temp_make ();
1791 /* Total length of the information. */
1792 exp->X_op = O_subtract;
1793 exp->X_add_symbol = end_sym;
1794 exp->X_op_symbol = start_sym;
1796 switch (DWARF2_FORMAT (sec))
1798 case dwarf2_format_32bit:
1799 exp->X_add_number = -4;
1803 case dwarf2_format_64bit:
1804 exp->X_add_number = -12;
1809 case dwarf2_format_64bit_irix:
1810 exp->X_add_number = -8;
1815 as_fatal (_("internal error: unknown dwarf2 format"));
1819 /* Emit the collected .debug_line data. */
1822 out_debug_line (segT line_seg)
1825 symbolS *prologue_start, *prologue_end;
1829 addressT section_end, section_end_aligned;
1831 memset (&exp, 0, sizeof exp);
1832 sizeof_offset = out_header (line_seg, &exp);
1833 line_end = exp.X_add_symbol;
1836 out_two (DWARF2_LINE_VERSION);
1838 /* Length of the prologue following this length. */
1839 prologue_start = symbol_temp_make ();
1840 prologue_end = symbol_temp_make ();
1841 exp.X_op = O_subtract;
1842 exp.X_add_symbol = prologue_end;
1843 exp.X_op_symbol = prologue_start;
1844 exp.X_add_number = 0;
1845 emit_expr (&exp, sizeof_offset);
1846 symbol_set_value_now_octets (prologue_start);
1848 /* Parameters of the state machine. */
1849 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1850 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1851 out_byte (DWARF2_LINE_BASE);
1852 out_byte (DWARF2_LINE_RANGE);
1853 out_byte (DWARF2_LINE_OPCODE_BASE);
1855 /* Standard opcode lengths. */
1856 out_byte (0); /* DW_LNS_copy */
1857 out_byte (1); /* DW_LNS_advance_pc */
1858 out_byte (1); /* DW_LNS_advance_line */
1859 out_byte (1); /* DW_LNS_set_file */
1860 out_byte (1); /* DW_LNS_set_column */
1861 out_byte (0); /* DW_LNS_negate_stmt */
1862 out_byte (0); /* DW_LNS_set_basic_block */
1863 out_byte (0); /* DW_LNS_const_add_pc */
1864 out_byte (1); /* DW_LNS_fixed_advance_pc */
1865 out_byte (0); /* DW_LNS_set_prologue_end */
1866 out_byte (0); /* DW_LNS_set_epilogue_begin */
1867 out_byte (1); /* DW_LNS_set_isa */
1871 symbol_set_value_now_octets (prologue_end);
1873 /* For each section, emit a statement program. */
1874 for (s = all_segs; s; s = s->next)
1875 if (SEG_NORMAL (s->seg))
1876 process_entries (s->seg, s->head->head);
1878 as_warn ("dwarf line number information for %s ignored",
1879 segment_name (s->seg));
1881 if (flag_dwarf_sections)
1882 /* We have to switch to the special .debug_line_end section
1883 before emitting the end-of-debug_line symbol. The linker
1884 script arranges for this section to be placed after all the
1885 (potentially garbage collected) .debug_line.<foo> sections.
1886 This section contains the line_end symbol which is used to
1887 compute the size of the linked .debug_line section, as seen
1888 in the DWARF Line Number header. */
1889 subseg_set (subseg_get (".debug_line_end", FALSE), 0);
1891 /* Pad size of .debug_line section to a multiple of OCTETS_PER_BYTE.
1892 Simply sizing the section in md_section_align() is not sufficient,
1893 also the size field in the .debug_line header must be a multiple
1894 of OCTETS_PER_BYTE. Not doing so will introduce gaps within the
1895 .debug_line sections after linking. */
1896 section_end = frag_now_fix_octets ();
1897 section_end_aligned = (section_end + OCTETS_PER_BYTE - 1) & -OCTETS_PER_BYTE;
1898 for ( ; section_end != section_end_aligned; section_end++)
1899 out_inc_line_addr (0, 0); /* NOP */
1901 symbol_set_value_now_octets (line_end);
1905 out_debug_ranges (segT ranges_seg)
1907 unsigned int addr_size = sizeof_address;
1912 memset (&exp, 0, sizeof exp);
1913 subseg_set (ranges_seg, 0);
1915 /* Base Address Entry. */
1916 for (i = 0; i < addr_size; i++)
1918 for (i = 0; i < addr_size; i++)
1921 /* Range List Entry. */
1922 for (s = all_segs; s; s = s->next)
1927 frag = first_frag_for_seg (s->seg);
1928 beg = symbol_temp_new (s->seg, 0, frag);
1929 s->text_start = beg;
1931 frag = last_frag_for_seg (s->seg);
1932 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1935 exp.X_op = O_symbol;
1936 exp.X_add_symbol = beg;
1937 exp.X_add_number = 0;
1938 emit_expr (&exp, addr_size);
1940 exp.X_op = O_symbol;
1941 exp.X_add_symbol = end;
1942 exp.X_add_number = 0;
1943 emit_expr (&exp, addr_size);
1946 /* End of Range Entry. */
1947 for (i = 0; i < addr_size; i++)
1949 for (i = 0; i < addr_size; i++)
1953 /* Emit data for .debug_aranges. */
1956 out_debug_aranges (segT aranges_seg, segT info_seg)
1958 unsigned int addr_size = sizeof_address;
1962 symbolS *aranges_end;
1966 memset (&exp, 0, sizeof exp);
1967 sizeof_offset = out_header (aranges_seg, &exp);
1968 aranges_end = exp.X_add_symbol;
1969 size = -exp.X_add_number;
1972 out_two (DWARF2_ARANGES_VERSION);
1975 /* Offset to .debug_info. */
1976 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1977 size += sizeof_offset;
1979 /* Size of an address (offset portion). */
1980 out_byte (addr_size);
1983 /* Size of a segment descriptor. */
1987 /* Align the header. */
1988 while ((size++ % (2 * addr_size)) > 0)
1991 for (s = all_segs; s; s = s->next)
1996 frag = first_frag_for_seg (s->seg);
1997 beg = symbol_temp_new (s->seg, 0, frag);
1998 s->text_start = beg;
2000 frag = last_frag_for_seg (s->seg);
2001 end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
2004 exp.X_op = O_symbol;
2005 exp.X_add_symbol = beg;
2006 exp.X_add_number = 0;
2007 emit_expr (&exp, addr_size);
2009 exp.X_op = O_subtract;
2010 exp.X_add_symbol = end;
2011 exp.X_op_symbol = beg;
2012 exp.X_add_number = 0;
2013 emit_expr (&exp, addr_size);
2016 p = frag_more (2 * addr_size);
2017 md_number_to_chars (p, 0, addr_size);
2018 md_number_to_chars (p + addr_size, 0, addr_size);
2020 symbol_set_value_now_octets (aranges_end);
2023 /* Emit data for .debug_abbrev. Note that this must be kept in
2024 sync with out_debug_info below. */
2027 out_debug_abbrev (segT abbrev_seg,
2028 segT info_seg ATTRIBUTE_UNUSED,
2029 segT line_seg ATTRIBUTE_UNUSED)
2031 subseg_set (abbrev_seg, 0);
2034 out_uleb128 (DW_TAG_compile_unit);
2035 out_byte (DW_CHILDREN_no);
2036 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
2037 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
2039 out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
2040 if (all_segs->next == NULL)
2042 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
2043 if (DWARF2_VERSION < 4)
2044 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
2046 out_abbrev (DW_AT_high_pc, (sizeof_address == 4
2047 ? DW_FORM_data4 : DW_FORM_data8));
2051 if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
2052 out_abbrev (DW_AT_ranges, DW_FORM_data4);
2054 out_abbrev (DW_AT_ranges, DW_FORM_data8);
2056 out_abbrev (DW_AT_name, DW_FORM_strp);
2057 out_abbrev (DW_AT_comp_dir, DW_FORM_strp);
2058 out_abbrev (DW_AT_producer, DW_FORM_strp);
2059 out_abbrev (DW_AT_language, DW_FORM_data2);
2062 /* Terminate the abbreviations for this compilation unit. */
2066 /* Emit a description of this compilation unit for .debug_info. */
2069 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg,
2070 symbolS *name_sym, symbolS *comp_dir_sym, symbolS *producer_sym)
2076 memset (&exp, 0, sizeof exp);
2077 sizeof_offset = out_header (info_seg, &exp);
2078 info_end = exp.X_add_symbol;
2080 /* DWARF version. */
2081 out_two (DWARF2_VERSION);
2083 /* .debug_abbrev offset */
2084 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
2086 /* Target address size. */
2087 out_byte (sizeof_address);
2089 /* DW_TAG_compile_unit DIE abbrev */
2092 /* DW_AT_stmt_list */
2093 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
2094 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
2097 /* These two attributes are emitted if all of the code is contiguous. */
2098 if (all_segs->next == NULL)
2101 exp.X_op = O_symbol;
2102 exp.X_add_symbol = all_segs->text_start;
2103 exp.X_add_number = 0;
2104 emit_expr (&exp, sizeof_address);
2107 if (DWARF2_VERSION < 4)
2108 exp.X_op = O_symbol;
2111 exp.X_op = O_subtract;
2112 exp.X_op_symbol = all_segs->text_start;
2114 exp.X_add_symbol = all_segs->text_end;
2115 exp.X_add_number = 0;
2116 emit_expr (&exp, sizeof_address);
2120 /* This attribute is emitted if the code is disjoint. */
2122 TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
2125 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str
2126 setup in out_debug_str below. */
2127 TC_DWARF2_EMIT_OFFSET (name_sym, sizeof_offset);
2128 TC_DWARF2_EMIT_OFFSET (comp_dir_sym, sizeof_offset);
2129 TC_DWARF2_EMIT_OFFSET (producer_sym, sizeof_offset);
2131 /* DW_AT_language. Yes, this is probably not really MIPS, but the
2132 dwarf2 draft has no standard code for assembler. */
2133 out_two (DW_LANG_Mips_Assembler);
2135 symbol_set_value_now_octets (info_end);
2138 /* Emit the three debug strings needed in .debug_str and setup symbols
2139 to them for use in out_debug_info. */
2141 out_debug_str (segT str_seg, symbolS **name_sym, symbolS **comp_dir_sym,
2142 symbolS **producer_sym)
2145 const char *comp_dir;
2146 const char *dirname;
2150 subseg_set (str_seg, 0);
2152 /* DW_AT_name. We don't have the actual file name that was present
2153 on the command line, so assume files[1] is the main input file.
2154 We're not supposed to get called unless at least one line number
2155 entry was emitted, so this should always be defined. */
2156 *name_sym = symbol_temp_new_now_octets ();
2157 if (files_in_use == 0)
2161 dirname = remap_debug_filename (dirs[files[1].dir]);
2162 len = strlen (dirname);
2164 /* Already has trailing slash. */
2165 p = frag_more (len);
2166 memcpy (p, dirname, len);
2168 p = frag_more (len + 1);
2169 memcpy (p, dirname, len);
2170 INSERT_DIR_SEPARATOR (p, len);
2173 len = strlen (files[1].filename) + 1;
2174 p = frag_more (len);
2175 memcpy (p, files[1].filename, len);
2177 /* DW_AT_comp_dir */
2178 *comp_dir_sym = symbol_temp_new_now_octets ();
2179 comp_dir = remap_debug_filename (getpwd ());
2180 len = strlen (comp_dir) + 1;
2181 p = frag_more (len);
2182 memcpy (p, comp_dir, len);
2184 /* DW_AT_producer */
2185 *producer_sym = symbol_temp_new_now_octets ();
2186 sprintf (producer, "GNU AS %s", VERSION);
2187 len = strlen (producer) + 1;
2188 p = frag_more (len);
2189 memcpy (p, producer, len);
2195 last_seg_ptr = &all_segs;
2199 /* Finish the dwarf2 debug sections. We emit .debug.line if there
2200 were any .file/.loc directives, or --gdwarf2 was given, or if the
2201 file has a non-empty .debug_info section and an empty .debug_line
2202 section. If we emit .debug_line, and the .debug_info section is
2203 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2204 ALL_SEGS will be non-null if there were any .file/.loc directives,
2205 or --gdwarf2 was given and there were any located instructions
2209 dwarf2_finish (void)
2214 int emit_other_sections = 0;
2215 int empty_debug_line = 0;
2217 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
2218 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
2220 line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
2221 empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
2223 /* We can't construct a new debug_line section if we already have one.
2225 if (all_segs && !empty_debug_line)
2226 as_fatal ("duplicate .debug_line sections");
2228 if ((!all_segs && emit_other_sections)
2229 || (!emit_other_sections && !empty_debug_line))
2230 /* If there is no line information and no non-empty .debug_info
2231 section, or if there is both a non-empty .debug_info and a non-empty
2232 .debug_line, then we do nothing. */
2235 /* Calculate the size of an address for the target machine. */
2236 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
2238 /* Create and switch to the line number section. */
2239 line_seg = subseg_new (".debug_line", 0);
2240 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
2242 /* For each subsection, chain the debug entries together. */
2243 for (s = all_segs; s; s = s->next)
2245 struct line_subseg *lss = s->head;
2246 struct line_entry **ptail = lss->ptail;
2248 /* Reset the initial view of the first subsection of the
2250 if (lss->head && lss->head->loc.view)
2251 set_or_check_view (lss->head, NULL, NULL);
2253 while ((lss = lss->next) != NULL)
2255 /* Link the first view of subsequent subsections to the
2257 if (lss->head && lss->head->loc.view)
2258 set_or_check_view (lss->head,
2259 !s->head ? NULL : (struct line_entry *)ptail,
2260 s->head ? s->head->head : NULL);
2266 out_debug_line (line_seg);
2268 /* If this is assembler generated line info, and there is no
2269 debug_info already, we need .debug_info, .debug_abbrev and
2270 .debug_str sections as well. */
2271 if (emit_other_sections)
2277 symbolS *name_sym, *comp_dir_sym, *producer_sym;
2279 gas_assert (all_segs);
2281 info_seg = subseg_new (".debug_info", 0);
2282 abbrev_seg = subseg_new (".debug_abbrev", 0);
2283 aranges_seg = subseg_new (".debug_aranges", 0);
2284 str_seg = subseg_new (".debug_str", 0);
2286 bfd_set_section_flags (stdoutput, info_seg,
2287 SEC_READONLY | SEC_DEBUGGING);
2288 bfd_set_section_flags (stdoutput, abbrev_seg,
2289 SEC_READONLY | SEC_DEBUGGING);
2290 bfd_set_section_flags (stdoutput, aranges_seg,
2291 SEC_READONLY | SEC_DEBUGGING);
2292 bfd_set_section_flags (stdoutput, str_seg,
2293 (SEC_READONLY | SEC_DEBUGGING
2294 | SEC_MERGE | SEC_STRINGS));
2295 str_seg->entsize = 1;
2297 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
2299 if (all_segs->next == NULL)
2303 ranges_seg = subseg_new (".debug_ranges", 0);
2304 bfd_set_section_flags (stdoutput, ranges_seg,
2305 SEC_READONLY | SEC_DEBUGGING);
2306 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
2307 out_debug_ranges (ranges_seg);
2310 out_debug_aranges (aranges_seg, info_seg);
2311 out_debug_abbrev (abbrev_seg, info_seg, line_seg);
2312 out_debug_str (str_seg, &name_sym, &comp_dir_sym, &producer_sym);
2313 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg,
2314 name_sym, comp_dir_sym, producer_sym);
2318 /* Perform any deferred checks pertaining to debug information. */
2321 dwarf2dbg_final_check (void)
2323 /* Perform reset-view checks. Don't evaluate view_assert_failed
2324 recursively: it could be very deep. It's a chain of adds, with
2325 each chain element pointing to the next in X_add_symbol, and
2326 holding the check value in X_op_symbol. */
2327 while (view_assert_failed)
2333 gas_assert (!symbol_resolved_p (view_assert_failed));
2335 exp = symbol_get_value_expression (view_assert_failed);
2336 sym = view_assert_failed;
2338 /* If view_assert_failed looks like a compound check in the
2339 chain, break it up. */
2340 if (exp->X_op == O_add && exp->X_add_number == 0 && exp->X_unsigned)
2342 view_assert_failed = exp->X_add_symbol;
2343 sym = exp->X_op_symbol;
2346 view_assert_failed = NULL;
2348 failed = resolve_symbol_value (sym);
2349 if (!symbol_resolved_p (sym) || failed)
2351 as_bad (_("view number mismatch"));