1 /* dwarf2dbg.c - DWARF2 debug support
2    Copyright (C) 1999-2020 Free Software Foundation, Inc.
3    Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
4 
5    This file is part of GAS, the GNU Assembler.
6 
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)
10    any later version.
11 
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.
16 
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
20    02110-1301, USA.  */
21 
22 /* Logical line numbers can be controlled by the compiler via the
23    following directives:
24 
25 	.file FILENO "file.c"
26 	.loc  FILENO LINENO [COLUMN] [basic_block] [prologue_end] \
27 	      [epilogue_begin] [is_stmt VALUE] [isa VALUE] \
28 	      [discriminator VALUE]
29 */
30 
31 #include "as.h"
32 #include "safe-ctype.h"
33 
34 #ifdef HAVE_LIMITS_H
35 #include <limits.h>
36 #else
37 #ifdef HAVE_SYS_PARAM_H
38 #include <sys/param.h>
39 #endif
40 #ifndef INT_MAX
41 #define INT_MAX (int) (((unsigned) (-1)) >> 1)
42 #endif
43 #endif
44 
45 #include "dwarf2dbg.h"
46 #include <filenames.h>
47 
48 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
49 /* We need to decide which character to use as a directory separator.
50    Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not
51    necessarily mean that the backslash character is the one to use.
52    Some environments, eg Cygwin, can support both naming conventions.
53    So we use the heuristic that we only need to use the backslash if
54    the path is an absolute path starting with a DOS style drive
55    selector.  eg C: or D:  */
56 # define INSERT_DIR_SEPARATOR(string, offset) \
57   do \
58     { \
59       if (offset > 1 \
60 	  && string[0] != 0 \
61 	  && string[1] == ':') \
62        string [offset] = '\\'; \
63       else \
64        string [offset] = '/'; \
65     } \
66   while (0)
67 #else
68 # define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/'
69 #endif
70 
71 #ifndef DWARF2_FORMAT
72 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
73 #endif
74 
75 #ifndef DWARF2_ADDR_SIZE
76 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
77 #endif
78 
79 #ifndef DWARF2_FILE_NAME
80 #define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME
81 #endif
82 
83 #ifndef DWARF2_FILE_TIME_NAME
84 #define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0
85 #endif
86 
87 #ifndef DWARF2_FILE_SIZE_NAME
88 #define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0
89 #endif
90 
91 #ifndef DWARF2_VERSION
92 #define DWARF2_VERSION 2
93 #endif
94 
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
98 #endif
99 
100 /* This implementation outputs version 3 .debug_line information.  */
101 #ifndef DWARF2_LINE_VERSION
102 #define DWARF2_LINE_VERSION 3
103 #endif
104 
105 #include "subsegs.h"
106 
107 #include "dwarf2.h"
108 
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").  */
113 #define DL_PROLOG	0
114 #define DL_FILES	1
115 #define DL_BODY		2
116 
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
122 #endif
123 
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
127    out_debug_line().  */
128 #define DWARF2_LINE_OPCODE_BASE		13
129 
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
134 #endif
135 
136 /* Range of line offsets in a special line info. opcode.  */
137 #ifndef DWARF2_LINE_RANGE
138 # define DWARF2_LINE_RANGE		14
139 #endif
140 
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
145 #endif
146 
147 /* Flag that indicates the initial value of the is_stmt_start flag.  */
148 #define	DWARF2_LINE_DEFAULT_IS_STMT	1
149 
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)
153 
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)
157 
158 /* The maximum address skip amount that can be encoded with a special op.  */
159 #define MAX_SPECIAL_ADDR_DELTA		SPECIAL_ADDR(255)
160 
161 #ifndef TC_PARSE_CONS_RETURN_NONE
162 #define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE
163 #endif
164 
165 struct line_entry
166 {
167   struct line_entry *next;
168   symbolS *label;
169   struct dwarf2_line_info loc;
170 };
171 
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]
175 ATTRIBUTE_UNUSED;
176 
177 struct line_subseg
178 {
179   struct line_subseg *next;
180   subsegT subseg;
181   struct line_entry *head;
182   struct line_entry **ptail;
183   struct line_entry **pmove_tail;
184 };
185 
186 struct line_seg
187 {
188   struct line_seg *next;
189   segT seg;
190   struct line_subseg *head;
191   symbolS *text_start;
192   symbolS *text_end;
193 };
194 
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;
198 
199 struct file_entry
200 {
201   const char *filename;
202   unsigned int dir;
203 };
204 
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;
209 
210 /* Table of directories used by .debug_line.  */
211 static char **dirs;
212 static unsigned int dirs_in_use;
213 static unsigned int dirs_allocated;
214 
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;
218 
219 /* TRUE when we're supposed to set the basic block mark whenever a
220    label is seen.  */
221 bfd_boolean dwarf2_loc_mark_labels;
222 
223 /* Current location as indicated by the most recent .loc directive.  */
224 static struct dwarf2_line_info current =
225 {
226   1, 1, 0, 0,
227   DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0,
228   0, NULL
229 };
230 
231 /* This symbol is used to recognize view number forced resets in loc
232    lists.  */
233 static symbolS *force_reset_view;
234 
235 /* This symbol evaluates to an expression that, if nonzero, indicates
236    some view assert check failed.  */
237 static symbolS *view_assert_failed;
238 
239 /* The size of an address on the target.  */
240 static unsigned int sizeof_address;
241 
242 static unsigned int get_filenum (const char *, unsigned int);
243 
244 #ifndef TC_DWARF2_EMIT_OFFSET
245 #define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset
246 
247 /* Create an offset to .dwarf2_*.  */
248 
249 static void
generic_dwarf2_emit_offset(symbolS * symbol,unsigned int size)250 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
251 {
252   expressionS exp;
253 
254   memset (&exp, 0, sizeof exp);
255   exp.X_op = O_symbol;
256   exp.X_add_symbol = symbol;
257   exp.X_add_number = 0;
258   emit_expr (&exp, size);
259 }
260 #endif
261 
262 /* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS.  */
263 
264 static struct line_subseg *
get_line_subseg(segT seg,subsegT subseg,bfd_boolean create_p)265 get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p)
266 {
267   struct line_seg *s = seg_info (seg)->dwarf2_line_seg;
268   struct line_subseg **pss, *lss;
269 
270   if (s == NULL)
271     {
272       if (!create_p)
273 	return NULL;
274 
275       s = XNEW (struct line_seg);
276       s->next = NULL;
277       s->seg = seg;
278       s->head = NULL;
279       *last_seg_ptr = s;
280       last_seg_ptr = &s->next;
281       seg_info (seg)->dwarf2_line_seg = s;
282     }
283   gas_assert (seg == s->seg);
284 
285   for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next)
286     {
287       if (lss->subseg == subseg)
288 	goto found_subseg;
289       if (lss->subseg > subseg)
290 	break;
291     }
292 
293   lss = XNEW (struct line_subseg);
294   lss->next = *pss;
295   lss->subseg = subseg;
296   lss->head = NULL;
297   lss->ptail = &lss->head;
298   lss->pmove_tail = &lss->head;
299   *pss = lss;
300 
301  found_subseg:
302   return lss;
303 }
304 
305 /* (Un)reverse the line_entry list starting from H.  */
306 
307 static struct line_entry *
reverse_line_entry_list(struct line_entry * h)308 reverse_line_entry_list (struct line_entry *h)
309 {
310   struct line_entry *p = NULL, *e, *n;
311 
312   for (e = h; e; e = n)
313     {
314       n = e->next;
315       e->next = p;
316       p = e;
317     }
318   return p;
319 }
320 
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.  */
325 
326 static void
set_or_check_view(struct line_entry * e,struct line_entry * p,struct line_entry * h)327 set_or_check_view (struct line_entry *e, struct line_entry *p,
328 		   struct line_entry *h)
329 {
330   expressionS viewx;
331 
332   memset (&viewx, 0, sizeof (viewx));
333   viewx.X_unsigned = 1;
334 
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))
339     {
340       viewx.X_op = O_constant;
341       viewx.X_add_number = 0;
342       viewx.X_add_symbol = NULL;
343       viewx.X_op_symbol = NULL;
344     }
345   else
346     {
347       viewx.X_op = O_gt;
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;
354       else
355 	{
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;
360 	}
361     }
362 
363   if (S_IS_DEFINED (e->loc.view) && symbol_constant_p (e->loc.view))
364     {
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
368 	 far.  */
369       if (viewx.X_op == O_constant)
370 	{
371 	  if (!value->X_add_number != !viewx.X_add_number)
372 	    as_bad (_("view number mismatch"));
373 	}
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)
378 	{
379 	  symbolS *deferred = make_expr_symbol (&viewx);
380 	  if (view_assert_failed)
381 	    {
382 	      expressionS chk;
383 
384 	      memset (&chk, 0, sizeof (chk));
385 	      chk.X_unsigned = 1;
386 	      chk.X_op = O_add;
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);
391 	    }
392 	  view_assert_failed = deferred;
393 	}
394     }
395 
396   if (viewx.X_op != O_constant || viewx.X_add_number)
397     {
398       expressionS incv;
399 
400       if (!p->loc.view)
401 	{
402 	  p->loc.view = symbol_temp_make ();
403 	  gas_assert (!S_IS_DEFINED (p->loc.view));
404 	}
405 
406       memset (&incv, 0, sizeof (incv));
407       incv.X_unsigned = 1;
408       incv.X_op = O_symbol;
409       incv.X_add_symbol = p->loc.view;
410       incv.X_add_number = 1;
411 
412       if (viewx.X_op == O_constant)
413 	{
414 	  gas_assert (viewx.X_add_number == 1);
415 	  viewx = incv;
416 	}
417       else
418 	{
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;
423 	}
424     }
425 
426   if (!S_IS_DEFINED (e->loc.view))
427     {
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);
431     }
432 
433   /* Define and attempt to simplify any earlier views needed to
434      compute E's.  */
435   if (h && p && p->loc.view && !S_IS_DEFINED (p->loc.view))
436     {
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);
441 
442       gas_assert (r == p);
443       /* Set or check views until we find a defined or absent view.  */
444       do
445 	{
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
450 	     that needs it.  */
451 	  if (r == h)
452 	    break;
453 	  set_or_check_view (r, r->next, NULL);
454 	}
455       while (r->next && r->next->loc.view && !S_IS_DEFINED (r->next->loc.view)
456 	     && (r = r->next));
457 
458       /* Unreverse the list, so that we can go forward again.  */
459       h2 = reverse_line_entry_list (p);
460       gas_assert (h2 == h);
461 
462       /* Starting from the last view we just defined, attempt to
463 	 simplify the view expressions, until we do so to P.  */
464       do
465 	{
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.  */
469 	  if (r == h)
470 	    continue;
471 	  gas_assert (S_IS_DEFINED (r->loc.view));
472 	  resolve_expression (symbol_get_value_expression (r->loc.view));
473 	}
474       while (r != p && (r = r->next));
475 
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));
479     }
480 }
481 
482 /* Record an entry for LOC occurring at LABEL.  */
483 
484 static void
dwarf2_gen_line_info_1(symbolS * label,struct dwarf2_line_info * loc)485 dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc)
486 {
487   struct line_subseg *lss;
488   struct line_entry *e;
489 
490   e = XNEW (struct line_entry);
491   e->next = NULL;
492   e->label = label;
493   e->loc = *loc;
494 
495   lss = get_line_subseg (now_seg, now_subseg, TRUE);
496 
497   /* Subseg heads are chained to previous subsegs in
498      dwarf2_finish.  */
499   if (loc->view && lss->head)
500     set_or_check_view (e,
501 		       (struct line_entry *)lss->ptail,
502 		       lss->head);
503 
504   *lss->ptail = e;
505   lss->ptail = &e->next;
506 }
507 
508 /* Record an entry for LOC occurring at OFS within the current fragment.  */
509 
510 void
dwarf2_gen_line_info(addressT ofs,struct dwarf2_line_info * loc)511 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
512 {
513   static unsigned int line = -1;
514   static unsigned int filenum = -1;
515 
516   symbolS *sym;
517 
518   /* Early out for as-yet incomplete location information.  */
519   if (loc->filenum == 0 || loc->line == 0)
520     return;
521 
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)
528     return;
529 
530   line = loc->line;
531   filenum = loc->filenum;
532 
533   if (linkrelax)
534     {
535       char name[120];
536 
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);
541     }
542   else
543     sym = symbol_temp_new (now_seg, ofs, frag_now);
544   dwarf2_gen_line_info_1 (sym, loc);
545 }
546 
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
550    returned.  */
551 
552 void
dwarf2_where(struct dwarf2_line_info * line)553 dwarf2_where (struct dwarf2_line_info *line)
554 {
555   if (debug_type == DEBUG_DWARF2)
556     {
557       const char *filename;
558 
559       memset (line, 0, sizeof (*line));
560       filename = as_where (&line->line);
561       line->filenum = get_filenum (filename, 0);
562       line->column = 0;
563       line->flags = DWARF2_FLAG_IS_STMT;
564       line->isa = current.isa;
565       line->discriminator = current.discriminator;
566       line->view = NULL;
567     }
568   else
569     *line = current;
570 }
571 
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.  */
574 
575 void
dwarf2_set_isa(unsigned int isa)576 dwarf2_set_isa (unsigned int isa)
577 {
578   current.isa = isa;
579 }
580 
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.  */
585 
586 void
dwarf2_emit_insn(int size)587 dwarf2_emit_insn (int size)
588 {
589   struct dwarf2_line_info loc;
590 
591   if (debug_type != DEBUG_DWARF2
592       ? !dwarf2_loc_directive_seen
593       : !seen_at_least_1_file ())
594     return;
595 
596   dwarf2_where (&loc);
597 
598   dwarf2_gen_line_info ((frag_now_fix_octets () - size) / OCTETS_PER_BYTE, &loc);
599   dwarf2_consume_line_info ();
600 }
601 
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
604    twice.  */
605 
606 void
dwarf2_move_insn(int delta)607 dwarf2_move_insn (int delta)
608 {
609   struct line_subseg *lss;
610   struct line_entry *e;
611   valueT now;
612 
613   if (delta == 0)
614     return;
615 
616   lss = get_line_subseg (now_seg, now_subseg, FALSE);
617   if (!lss)
618     return;
619 
620   now = frag_now_fix ();
621   while ((e = *lss->pmove_tail))
622     {
623       if (S_GET_VALUE (e->label) == now)
624 	S_SET_VALUE (e->label, now + delta);
625       lss->pmove_tail = &e->next;
626     }
627 }
628 
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
632    it has been used.  */
633 
634 void
dwarf2_consume_line_info(void)635 dwarf2_consume_line_info (void)
636 {
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;
640 
641   current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK
642 		     | DWARF2_FLAG_PROLOGUE_END
643 		     | DWARF2_FLAG_EPILOGUE_BEGIN);
644   current.discriminator = 0;
645   current.view = NULL;
646 }
647 
648 /* Called for each (preferably code) label.  If dwarf2_loc_mark_labels
649    is enabled, emit a basic block marker.  */
650 
651 void
dwarf2_emit_label(symbolS * label)652 dwarf2_emit_label (symbolS *label)
653 {
654   struct dwarf2_line_info loc;
655 
656   if (!dwarf2_loc_mark_labels)
657     return;
658   if (S_GET_SEGMENT (label) != now_seg)
659     return;
660   if (!(bfd_section_flags (now_seg) & SEC_CODE))
661     return;
662   if (files_in_use == 0 && debug_type != DEBUG_DWARF2)
663     return;
664 
665   dwarf2_where (&loc);
666 
667   loc.flags |= DWARF2_FLAG_BASIC_BLOCK;
668 
669   dwarf2_gen_line_info_1 (label, &loc);
670   dwarf2_consume_line_info ();
671 }
672 
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
675    empty one.  */
676 
677 static unsigned int
get_filenum(const char * filename,unsigned int num)678 get_filenum (const char *filename, unsigned int num)
679 {
680   static unsigned int last_used, last_used_dir_len;
681   const char *file;
682   size_t dir_len;
683   unsigned int i, dir;
684 
685   if (num == 0 && last_used)
686     {
687       if (! files[last_used].dir
688 	  && filename_cmp (filename, files[last_used].filename) == 0)
689 	return last_used;
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)
696 	return last_used;
697     }
698 
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)
703     file = filename;
704 #else
705   if (file == filename + 1)
706     file = filename;
707 #endif
708   dir_len = file - filename;
709 
710   dir = 0;
711   if (dir_len)
712     {
713 #ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
714       --dir_len;
715 #endif
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')
719 	  break;
720 
721       if (dir >= dirs_in_use)
722 	{
723 	  if (dir >= dirs_allocated)
724 	    {
725 	      dirs_allocated = dir + 32;
726 	      dirs = XRESIZEVEC (char *, dirs, dirs_allocated);
727 	    }
728 
729 	  dirs[dir] = xmemdup0 (filename, dir_len);
730 	  dirs_in_use = dir + 1;
731 	}
732     }
733 
734   if (num == 0)
735     {
736       for (i = 1; i < files_in_use; ++i)
737 	if (files[i].dir == dir
738 	    && files[i].filename
739 	    && filename_cmp (file, files[i].filename) == 0)
740 	  {
741 	    last_used = i;
742 	    last_used_dir_len = dir_len;
743 	    return i;
744 	  }
745     }
746   else
747     i = num;
748 
749   if (i >= files_allocated)
750     {
751       unsigned int old = files_allocated;
752 
753       files_allocated = i + 32;
754       /* Catch wraparound.  */
755       if (files_allocated <= old)
756 	{
757 	  as_bad (_("file number %lu is too big"), (unsigned long) i);
758 	  return 0;
759 	}
760 
761       files = XRESIZEVEC (struct file_entry, files, files_allocated);
762       memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
763     }
764 
765   files[i].filename = file;
766   files[i].dir = dir;
767   if (files_in_use < i + 1)
768     files_in_use = i + 1;
769   last_used = i;
770   last_used_dir_len = dir_len;
771 
772   return i;
773 }
774 
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
778 
779    If an entry is added to the file table, return a pointer to the filename.  */
780 
781 char *
dwarf2_directive_filename(void)782 dwarf2_directive_filename (void)
783 {
784   valueT num;
785   char *filename;
786   int filename_len;
787 
788   /* Continue to accept a bare string and pass it off.  */
789   SKIP_WHITESPACE ();
790   if (*input_line_pointer == '"')
791     {
792       s_app_file (0);
793       return NULL;
794     }
795 
796   num = get_absolute_expression ();
797   filename = demand_copy_C_string (&filename_len);
798   if (filename == NULL)
799     return NULL;
800   demand_empty_rest_of_line ();
801 
802   if ((offsetT) num < 1)
803     {
804       as_bad (_("file number less than one"));
805       return NULL;
806     }
807 
808   /* A .file directive implies compiler generated debug information is
809      being supplied.  Turn off gas generated debug info.  */
810   debug_type = DEBUG_NONE;
811 
812   if (num != (unsigned int) num
813       || num >= (size_t) -1 / sizeof (struct file_entry) - 32)
814     {
815       as_bad (_("file number %lu is too big"), (unsigned long) num);
816       return NULL;
817     }
818   if (num < files_in_use && files[num].filename != 0)
819     {
820       as_bad (_("file number %u already allocated"), (unsigned int) num);
821       return NULL;
822     }
823 
824   get_filenum (filename, (unsigned int) num);
825 
826   return filename;
827 }
828 
829 /* Calls dwarf2_directive_filename, but discards its result.
830    Used in pseudo-op tables where the function result is ignored.  */
831 
832 void
dwarf2_directive_file(int dummy ATTRIBUTE_UNUSED)833 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
834 {
835   (void) dwarf2_directive_filename ();
836 }
837 
838 void
dwarf2_directive_loc(int dummy ATTRIBUTE_UNUSED)839 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
840 {
841   offsetT filenum, line;
842 
843   /* If we see two .loc directives in a row, force the first one to be
844      output now.  */
845   if (dwarf2_loc_directive_seen)
846     dwarf2_emit_insn (0);
847 
848   filenum = get_absolute_expression ();
849   SKIP_WHITESPACE ();
850   line = get_absolute_expression ();
851 
852   if (filenum < 1)
853     {
854       as_bad (_("file number less than one"));
855       return;
856     }
857   if (filenum >= (int) files_in_use || files[filenum].filename == 0)
858     {
859       as_bad (_("unassigned file number %ld"), (long) filenum);
860       return;
861     }
862 
863   current.filenum = filenum;
864   current.line = line;
865   current.discriminator = 0;
866 
867 #ifndef NO_LISTING
868   if (listing)
869     {
870       if (files[filenum].dir)
871 	{
872 	  size_t dir_len = strlen (dirs[files[filenum].dir]);
873 	  size_t file_len = strlen (files[filenum].filename);
874 	  char *cp = XNEWVEC (char, dir_len + 1 + file_len + 1);
875 
876 	  memcpy (cp, dirs[files[filenum].dir], dir_len);
877 	  INSERT_DIR_SEPARATOR (cp, dir_len);
878 	  memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
879 	  cp[dir_len + file_len + 1] = '\0';
880 	  listing_source_file (cp);
881 	  free (cp);
882 	}
883       else
884 	listing_source_file (files[filenum].filename);
885       listing_source_line (line);
886     }
887 #endif
888 
889   SKIP_WHITESPACE ();
890   if (ISDIGIT (*input_line_pointer))
891     {
892       current.column = get_absolute_expression ();
893       SKIP_WHITESPACE ();
894     }
895 
896   while (ISALPHA (*input_line_pointer))
897     {
898       char *p, c;
899       offsetT value;
900 
901       c = get_symbol_name (& p);
902 
903       if (strcmp (p, "basic_block") == 0)
904 	{
905 	  current.flags |= DWARF2_FLAG_BASIC_BLOCK;
906 	  *input_line_pointer = c;
907 	}
908       else if (strcmp (p, "prologue_end") == 0)
909 	{
910 	  current.flags |= DWARF2_FLAG_PROLOGUE_END;
911 	  *input_line_pointer = c;
912 	}
913       else if (strcmp (p, "epilogue_begin") == 0)
914 	{
915 	  current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
916 	  *input_line_pointer = c;
917 	}
918       else if (strcmp (p, "is_stmt") == 0)
919 	{
920 	  (void) restore_line_pointer (c);
921 	  value = get_absolute_expression ();
922 	  if (value == 0)
923 	    current.flags &= ~DWARF2_FLAG_IS_STMT;
924 	  else if (value == 1)
925 	    current.flags |= DWARF2_FLAG_IS_STMT;
926 	  else
927 	    {
928 	      as_bad (_("is_stmt value not 0 or 1"));
929 	      return;
930 	    }
931 	}
932       else if (strcmp (p, "isa") == 0)
933 	{
934 	  (void) restore_line_pointer (c);
935 	  value = get_absolute_expression ();
936 	  if (value >= 0)
937 	    current.isa = value;
938 	  else
939 	    {
940 	      as_bad (_("isa number less than zero"));
941 	      return;
942 	    }
943 	}
944       else if (strcmp (p, "discriminator") == 0)
945 	{
946 	  (void) restore_line_pointer (c);
947 	  value = get_absolute_expression ();
948 	  if (value >= 0)
949 	    current.discriminator = value;
950 	  else
951 	    {
952 	      as_bad (_("discriminator less than zero"));
953 	      return;
954 	    }
955 	}
956       else if (strcmp (p, "view") == 0)
957 	{
958 	  symbolS *sym;
959 
960 	  (void) restore_line_pointer (c);
961 	  SKIP_WHITESPACE ();
962 
963 	  if (ISDIGIT (*input_line_pointer)
964 	      || *input_line_pointer == '-')
965 	    {
966 	      bfd_boolean force_reset = *input_line_pointer == '-';
967 
968 	      value = get_absolute_expression ();
969 	      if (value != 0)
970 		{
971 		  as_bad (_("numeric view can only be asserted to zero"));
972 		  return;
973 		}
974 	      if (force_reset && force_reset_view)
975 		sym = force_reset_view;
976 	      else
977 		{
978 		  sym = symbol_temp_new (absolute_section, value,
979 					 &zero_address_frag);
980 		  if (force_reset)
981 		    force_reset_view = sym;
982 		}
983 	    }
984 	  else
985 	    {
986 	      char *name = read_symbol_name ();
987 
988 	      if (!name)
989 		return;
990 	      sym = symbol_find_or_make (name);
991 	      if (S_IS_DEFINED (sym) || symbol_equated_p (sym))
992 		{
993 		  if (S_IS_VOLATILE (sym))
994 		    sym = symbol_clone (sym, 1);
995 		  else if (!S_CAN_BE_REDEFINED (sym))
996 		    {
997 		      as_bad (_("symbol `%s' is already defined"), name);
998 		      return;
999 		    }
1000 		}
1001 	      S_SET_SEGMENT (sym, undefined_section);
1002 	      S_SET_VALUE (sym, 0);
1003 	      symbol_set_frag (sym, &zero_address_frag);
1004 	    }
1005 	  current.view = sym;
1006 	}
1007       else
1008 	{
1009 	  as_bad (_("unknown .loc sub-directive `%s'"), p);
1010 	  (void) restore_line_pointer (c);
1011 	  return;
1012 	}
1013 
1014       SKIP_WHITESPACE_AFTER_NAME ();
1015     }
1016 
1017   demand_empty_rest_of_line ();
1018   dwarf2_loc_directive_seen = TRUE;
1019   debug_type = DEBUG_NONE;
1020 
1021   /* If we were given a view id, emit the row right away.  */
1022   if (current.view)
1023     dwarf2_emit_insn (0);
1024 }
1025 
1026 void
dwarf2_directive_loc_mark_labels(int dummy ATTRIBUTE_UNUSED)1027 dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED)
1028 {
1029   offsetT value = get_absolute_expression ();
1030 
1031   if (value != 0 && value != 1)
1032     {
1033       as_bad (_("expected 0 or 1"));
1034       ignore_rest_of_line ();
1035     }
1036   else
1037     {
1038       dwarf2_loc_mark_labels = value != 0;
1039       demand_empty_rest_of_line ();
1040     }
1041 }
1042 
1043 static struct frag *
first_frag_for_seg(segT seg)1044 first_frag_for_seg (segT seg)
1045 {
1046   return seg_info (seg)->frchainP->frch_root;
1047 }
1048 
1049 static struct frag *
last_frag_for_seg(segT seg)1050 last_frag_for_seg (segT seg)
1051 {
1052   frchainS *f = seg_info (seg)->frchainP;
1053 
1054   while (f->frch_next != NULL)
1055     f = f->frch_next;
1056 
1057   return f->frch_last;
1058 }
1059 
1060 /* Emit a single byte into the current segment.  */
1061 
1062 static inline void
out_byte(int byte)1063 out_byte (int byte)
1064 {
1065   FRAG_APPEND_1_CHAR (byte);
1066 }
1067 
1068 /* Emit a statement program opcode into the current segment.  */
1069 
1070 static inline void
out_opcode(int opc)1071 out_opcode (int opc)
1072 {
1073   out_byte (opc);
1074 }
1075 
1076 /* Emit a two-byte word into the current segment.  */
1077 
1078 static inline void
out_two(int data)1079 out_two (int data)
1080 {
1081   md_number_to_chars (frag_more (2), data, 2);
1082 }
1083 
1084 /* Emit a four byte word into the current segment.  */
1085 
1086 static inline void
out_four(int data)1087 out_four (int data)
1088 {
1089   md_number_to_chars (frag_more (4), data, 4);
1090 }
1091 
1092 /* Emit an unsigned "little-endian base 128" number.  */
1093 
1094 static void
out_uleb128(addressT value)1095 out_uleb128 (addressT value)
1096 {
1097   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1098 }
1099 
1100 /* Emit a signed "little-endian base 128" number.  */
1101 
1102 static void
out_leb128(addressT value)1103 out_leb128 (addressT value)
1104 {
1105   output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1106 }
1107 
1108 /* Emit a tuple for .debug_abbrev.  */
1109 
1110 static inline void
out_abbrev(int name,int form)1111 out_abbrev (int name, int form)
1112 {
1113   out_uleb128 (name);
1114   out_uleb128 (form);
1115 }
1116 
1117 /* Get the size of a fragment.  */
1118 
1119 static offsetT
get_frag_fix(fragS * frag,segT seg)1120 get_frag_fix (fragS *frag, segT seg)
1121 {
1122   frchainS *fr;
1123 
1124   if (frag->fr_next)
1125     return frag->fr_fix;
1126 
1127   /* If a fragment is the last in the chain, special measures must be
1128      taken to find its size before relaxation, since it may be pending
1129      on some subsegment chain.  */
1130   for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next)
1131     if (fr->frch_last == frag)
1132       return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
1133 
1134   abort ();
1135 }
1136 
1137 /* Set an absolute address (may result in a relocation entry).  */
1138 
1139 static void
out_set_addr(symbolS * sym)1140 out_set_addr (symbolS *sym)
1141 {
1142   expressionS exp;
1143 
1144   memset (&exp, 0, sizeof exp);
1145   out_opcode (DW_LNS_extended_op);
1146   out_uleb128 (sizeof_address + 1);
1147 
1148   out_opcode (DW_LNE_set_address);
1149   exp.X_op = O_symbol;
1150   exp.X_add_symbol = sym;
1151   exp.X_add_number = 0;
1152   emit_expr (&exp, sizeof_address);
1153 }
1154 
1155 static void scale_addr_delta (addressT *);
1156 
1157 static void
scale_addr_delta(addressT * addr_delta)1158 scale_addr_delta (addressT *addr_delta)
1159 {
1160   static int printed_this = 0;
1161   if (DWARF2_LINE_MIN_INSN_LENGTH > 1)
1162     {
1163       if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0  && !printed_this)
1164 	{
1165 	  as_bad("unaligned opcodes detected in executable segment");
1166 	  printed_this = 1;
1167 	}
1168       *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
1169     }
1170 }
1171 
1172 /* Encode a pair of line and address skips as efficiently as possible.
1173    Note that the line skip is signed, whereas the address skip is unsigned.
1174 
1175    The following two routines *must* be kept in sync.  This is
1176    enforced by making emit_inc_line_addr abort if we do not emit
1177    exactly the expected number of bytes.  */
1178 
1179 static int
size_inc_line_addr(int line_delta,addressT addr_delta)1180 size_inc_line_addr (int line_delta, addressT addr_delta)
1181 {
1182   unsigned int tmp, opcode;
1183   int len = 0;
1184 
1185   /* Scale the address delta by the minimum instruction length.  */
1186   scale_addr_delta (&addr_delta);
1187 
1188   /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1189      We cannot use special opcodes here, since we want the end_sequence
1190      to emit the matrix entry.  */
1191   if (line_delta == INT_MAX)
1192     {
1193       if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
1194 	len = 1;
1195       else if (addr_delta)
1196 	len = 1 + sizeof_leb128 (addr_delta, 0);
1197       return len + 3;
1198     }
1199 
1200   /* Bias the line delta by the base.  */
1201   tmp = line_delta - DWARF2_LINE_BASE;
1202 
1203   /* If the line increment is out of range of a special opcode, we
1204      must encode it with DW_LNS_advance_line.  */
1205   if (tmp >= DWARF2_LINE_RANGE)
1206     {
1207       len = 1 + sizeof_leb128 (line_delta, 1);
1208       line_delta = 0;
1209       tmp = 0 - DWARF2_LINE_BASE;
1210     }
1211 
1212   /* Bias the opcode by the special opcode base.  */
1213   tmp += DWARF2_LINE_OPCODE_BASE;
1214 
1215   /* Avoid overflow when addr_delta is large.  */
1216   if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1217     {
1218       /* Try using a special opcode.  */
1219       opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1220       if (opcode <= 255)
1221 	return len + 1;
1222 
1223       /* Try using DW_LNS_const_add_pc followed by special op.  */
1224       opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1225       if (opcode <= 255)
1226 	return len + 2;
1227     }
1228 
1229   /* Otherwise use DW_LNS_advance_pc.  */
1230   len += 1 + sizeof_leb128 (addr_delta, 0);
1231 
1232   /* DW_LNS_copy or special opcode.  */
1233   len += 1;
1234 
1235   return len;
1236 }
1237 
1238 static void
emit_inc_line_addr(int line_delta,addressT addr_delta,char * p,int len)1239 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
1240 {
1241   unsigned int tmp, opcode;
1242   int need_copy = 0;
1243   char *end = p + len;
1244 
1245   /* Line number sequences cannot go backward in addresses.  This means
1246      we've incorrectly ordered the statements in the sequence.  */
1247   gas_assert ((offsetT) addr_delta >= 0);
1248 
1249   /* Scale the address delta by the minimum instruction length.  */
1250   scale_addr_delta (&addr_delta);
1251 
1252   /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
1253      We cannot use special opcodes here, since we want the end_sequence
1254      to emit the matrix entry.  */
1255   if (line_delta == INT_MAX)
1256     {
1257       if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
1258 	*p++ = DW_LNS_const_add_pc;
1259       else if (addr_delta)
1260 	{
1261 	  *p++ = DW_LNS_advance_pc;
1262 	  p += output_leb128 (p, addr_delta, 0);
1263 	}
1264 
1265       *p++ = DW_LNS_extended_op;
1266       *p++ = 1;
1267       *p++ = DW_LNE_end_sequence;
1268       goto done;
1269     }
1270 
1271   /* Bias the line delta by the base.  */
1272   tmp = line_delta - DWARF2_LINE_BASE;
1273 
1274   /* If the line increment is out of range of a special opcode, we
1275      must encode it with DW_LNS_advance_line.  */
1276   if (tmp >= DWARF2_LINE_RANGE)
1277     {
1278       *p++ = DW_LNS_advance_line;
1279       p += output_leb128 (p, line_delta, 1);
1280 
1281       line_delta = 0;
1282       tmp = 0 - DWARF2_LINE_BASE;
1283       need_copy = 1;
1284     }
1285 
1286   /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0"
1287      special opcode.  */
1288   if (line_delta == 0 && addr_delta == 0)
1289     {
1290       *p++ = DW_LNS_copy;
1291       goto done;
1292     }
1293 
1294   /* Bias the opcode by the special opcode base.  */
1295   tmp += DWARF2_LINE_OPCODE_BASE;
1296 
1297   /* Avoid overflow when addr_delta is large.  */
1298   if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
1299     {
1300       /* Try using a special opcode.  */
1301       opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
1302       if (opcode <= 255)
1303 	{
1304 	  *p++ = opcode;
1305 	  goto done;
1306 	}
1307 
1308       /* Try using DW_LNS_const_add_pc followed by special op.  */
1309       opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
1310       if (opcode <= 255)
1311 	{
1312 	  *p++ = DW_LNS_const_add_pc;
1313 	  *p++ = opcode;
1314 	  goto done;
1315 	}
1316     }
1317 
1318   /* Otherwise use DW_LNS_advance_pc.  */
1319   *p++ = DW_LNS_advance_pc;
1320   p += output_leb128 (p, addr_delta, 0);
1321 
1322   if (need_copy)
1323     *p++ = DW_LNS_copy;
1324   else
1325     *p++ = tmp;
1326 
1327  done:
1328   gas_assert (p == end);
1329 }
1330 
1331 /* Handy routine to combine calls to the above two routines.  */
1332 
1333 static void
out_inc_line_addr(int line_delta,addressT addr_delta)1334 out_inc_line_addr (int line_delta, addressT addr_delta)
1335 {
1336   int len = size_inc_line_addr (line_delta, addr_delta);
1337   emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
1338 }
1339 
1340 /* Write out an alternative form of line and address skips using
1341    DW_LNS_fixed_advance_pc opcodes.  This uses more space than the default
1342    line and address information, but it is required if linker relaxation
1343    could change the code offsets.  The following two routines *must* be
1344    kept in sync.  */
1345 #define ADDR_DELTA_LIMIT 50000
1346 
1347 static int
size_fixed_inc_line_addr(int line_delta,addressT addr_delta)1348 size_fixed_inc_line_addr (int line_delta, addressT addr_delta)
1349 {
1350   int len = 0;
1351 
1352   /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.  */
1353   if (line_delta != INT_MAX)
1354     len = 1 + sizeof_leb128 (line_delta, 1);
1355 
1356   if (addr_delta > ADDR_DELTA_LIMIT)
1357     {
1358       /* DW_LNS_extended_op */
1359       len += 1 + sizeof_leb128 (sizeof_address + 1, 0);
1360       /* DW_LNE_set_address */
1361       len += 1 + sizeof_address;
1362     }
1363   else
1364     /* DW_LNS_fixed_advance_pc */
1365     len += 3;
1366 
1367   if (line_delta == INT_MAX)
1368     /* DW_LNS_extended_op + DW_LNE_end_sequence */
1369     len += 3;
1370   else
1371     /* DW_LNS_copy */
1372     len += 1;
1373 
1374   return len;
1375 }
1376 
1377 static void
emit_fixed_inc_line_addr(int line_delta,addressT addr_delta,fragS * frag,char * p,int len)1378 emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag,
1379 			  char *p, int len)
1380 {
1381   expressionS *pexp;
1382   char *end = p + len;
1383 
1384   /* Line number sequences cannot go backward in addresses.  This means
1385      we've incorrectly ordered the statements in the sequence.  */
1386   gas_assert ((offsetT) addr_delta >= 0);
1387 
1388   /* Verify that we have kept in sync with size_fixed_inc_line_addr.  */
1389   gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta));
1390 
1391   /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.  */
1392   if (line_delta != INT_MAX)
1393     {
1394       *p++ = DW_LNS_advance_line;
1395       p += output_leb128 (p, line_delta, 1);
1396     }
1397 
1398   pexp = symbol_get_value_expression (frag->fr_symbol);
1399 
1400   /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can
1401      advance the address by at most 64K.  Linker relaxation (without
1402      which this function would not be used) could change the operand by
1403      an unknown amount.  If the address increment is getting close to
1404      the limit, just reset the address.  */
1405   if (addr_delta > ADDR_DELTA_LIMIT)
1406     {
1407       symbolS *to_sym;
1408       expressionS exp;
1409 
1410       memset (&exp, 0, sizeof exp);
1411       gas_assert (pexp->X_op == O_subtract);
1412       to_sym = pexp->X_add_symbol;
1413 
1414       *p++ = DW_LNS_extended_op;
1415       p += output_leb128 (p, sizeof_address + 1, 0);
1416       *p++ = DW_LNE_set_address;
1417       exp.X_op = O_symbol;
1418       exp.X_add_symbol = to_sym;
1419       exp.X_add_number = 0;
1420       emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE);
1421       p += sizeof_address;
1422     }
1423   else
1424     {
1425       *p++ = DW_LNS_fixed_advance_pc;
1426       emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE);
1427       p += 2;
1428     }
1429 
1430   if (line_delta == INT_MAX)
1431     {
1432       *p++ = DW_LNS_extended_op;
1433       *p++ = 1;
1434       *p++ = DW_LNE_end_sequence;
1435     }
1436   else
1437     *p++ = DW_LNS_copy;
1438 
1439   gas_assert (p == end);
1440 }
1441 
1442 /* Generate a variant frag that we can use to relax address/line
1443    increments between fragments of the target segment.  */
1444 
1445 static void
relax_inc_line_addr(int line_delta,symbolS * to_sym,symbolS * from_sym)1446 relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym)
1447 {
1448   expressionS exp;
1449   int max_chars;
1450 
1451   memset (&exp, 0, sizeof exp);
1452   exp.X_op = O_subtract;
1453   exp.X_add_symbol = to_sym;
1454   exp.X_op_symbol = from_sym;
1455   exp.X_add_number = 0;
1456 
1457   /* The maximum size of the frag is the line delta with a maximum
1458      sized address delta.  */
1459   if (DWARF2_USE_FIXED_ADVANCE_PC)
1460     max_chars = size_fixed_inc_line_addr (line_delta,
1461 					  -DWARF2_LINE_MIN_INSN_LENGTH);
1462   else
1463     max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
1464 
1465   frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
1466 	    make_expr_symbol (&exp), line_delta, NULL);
1467 }
1468 
1469 /* The function estimates the size of a rs_dwarf2dbg variant frag
1470    based on the current values of the symbols.  It is called before
1471    the relaxation loop.  We set fr_subtype to the expected length.  */
1472 
1473 int
dwarf2dbg_estimate_size_before_relax(fragS * frag)1474 dwarf2dbg_estimate_size_before_relax (fragS *frag)
1475 {
1476   offsetT addr_delta;
1477   int size;
1478 
1479   addr_delta = resolve_symbol_value (frag->fr_symbol);
1480   if (DWARF2_USE_FIXED_ADVANCE_PC)
1481     size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta);
1482   else
1483     size = size_inc_line_addr (frag->fr_offset, addr_delta);
1484 
1485   frag->fr_subtype = size;
1486 
1487   return size;
1488 }
1489 
1490 /* This function relaxes a rs_dwarf2dbg variant frag based on the
1491    current values of the symbols.  fr_subtype is the current length
1492    of the frag.  This returns the change in frag length.  */
1493 
1494 int
dwarf2dbg_relax_frag(fragS * frag)1495 dwarf2dbg_relax_frag (fragS *frag)
1496 {
1497   int old_size, new_size;
1498 
1499   old_size = frag->fr_subtype;
1500   new_size = dwarf2dbg_estimate_size_before_relax (frag);
1501 
1502   return new_size - old_size;
1503 }
1504 
1505 /* This function converts a rs_dwarf2dbg variant frag into a normal
1506    fill frag.  This is called after all relaxation has been done.
1507    fr_subtype will be the desired length of the frag.  */
1508 
1509 void
dwarf2dbg_convert_frag(fragS * frag)1510 dwarf2dbg_convert_frag (fragS *frag)
1511 {
1512   offsetT addr_diff;
1513 
1514   if (DWARF2_USE_FIXED_ADVANCE_PC)
1515     {
1516       /* If linker relaxation is enabled then the distance between the two
1517 	 symbols in the frag->fr_symbol expression might change.  Hence we
1518 	 cannot rely upon the value computed by resolve_symbol_value.
1519 	 Instead we leave the expression unfinalized and allow
1520 	 emit_fixed_inc_line_addr to create a fixup (which later becomes a
1521 	 relocation) that will allow the linker to correctly compute the
1522 	 actual address difference.  We have to use a fixed line advance for
1523 	 this as we cannot (easily) relocate leb128 encoded values.  */
1524       int saved_finalize_syms = finalize_syms;
1525 
1526       finalize_syms = 0;
1527       addr_diff = resolve_symbol_value (frag->fr_symbol);
1528       finalize_syms = saved_finalize_syms;
1529     }
1530   else
1531     addr_diff = resolve_symbol_value (frag->fr_symbol);
1532 
1533   /* fr_var carries the max_chars that we created the fragment with.
1534      fr_subtype carries the current expected length.  We must, of
1535      course, have allocated enough memory earlier.  */
1536   gas_assert (frag->fr_var >= (int) frag->fr_subtype);
1537 
1538   if (DWARF2_USE_FIXED_ADVANCE_PC)
1539     emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag,
1540 			      frag->fr_literal + frag->fr_fix,
1541 			      frag->fr_subtype);
1542   else
1543     emit_inc_line_addr (frag->fr_offset, addr_diff,
1544 			frag->fr_literal + frag->fr_fix, frag->fr_subtype);
1545 
1546   frag->fr_fix += frag->fr_subtype;
1547   frag->fr_type = rs_fill;
1548   frag->fr_var = 0;
1549   frag->fr_offset = 0;
1550 }
1551 
1552 /* Generate .debug_line content for the chain of line number entries
1553    beginning at E, for segment SEG.  */
1554 
1555 static void
process_entries(segT seg,struct line_entry * e)1556 process_entries (segT seg, struct line_entry *e)
1557 {
1558   unsigned filenum = 1;
1559   unsigned line = 1;
1560   unsigned column = 0;
1561   unsigned isa = 0;
1562   unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
1563   fragS *last_frag = NULL, *frag;
1564   addressT last_frag_ofs = 0, frag_ofs;
1565   symbolS *last_lab = NULL, *lab;
1566   struct line_entry *next;
1567 
1568   if (flag_dwarf_sections)
1569     {
1570       char * name;
1571       const char * sec_name;
1572 
1573       /* Switch to the relevant sub-section before we start to emit
1574 	 the line number table.
1575 
1576 	 FIXME: These sub-sections do not have a normal Line Number
1577 	 Program Header, thus strictly speaking they are not valid
1578 	 DWARF sections.  Unfortunately the DWARF standard assumes
1579 	 a one-to-one relationship between compilation units and
1580 	 line number tables.  Thus we have to have a .debug_line
1581 	 section, as well as our sub-sections, and we have to ensure
1582 	 that all of the sub-sections are merged into a proper
1583 	 .debug_line section before a debugger sees them.  */
1584 
1585       sec_name = bfd_section_name (seg);
1586       if (strcmp (sec_name, ".text") != 0)
1587 	{
1588 	  name = concat (".debug_line", sec_name, (char *) NULL);
1589 	  subseg_set (subseg_get (name, FALSE), 0);
1590 	}
1591       else
1592 	/* Don't create a .debug_line.text section -
1593 	   that is redundant.  Instead just switch back to the
1594 	   normal .debug_line section.  */
1595 	subseg_set (subseg_get (".debug_line", FALSE), 0);
1596     }
1597 
1598   do
1599     {
1600       int line_delta;
1601 
1602       if (filenum != e->loc.filenum)
1603 	{
1604 	  filenum = e->loc.filenum;
1605 	  out_opcode (DW_LNS_set_file);
1606 	  out_uleb128 (filenum);
1607 	}
1608 
1609       if (column != e->loc.column)
1610 	{
1611 	  column = e->loc.column;
1612 	  out_opcode (DW_LNS_set_column);
1613 	  out_uleb128 (column);
1614 	}
1615 
1616       if (e->loc.discriminator != 0)
1617 	{
1618 	  out_opcode (DW_LNS_extended_op);
1619 	  out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
1620 	  out_opcode (DW_LNE_set_discriminator);
1621 	  out_uleb128 (e->loc.discriminator);
1622 	}
1623 
1624       if (isa != e->loc.isa)
1625 	{
1626 	  isa = e->loc.isa;
1627 	  out_opcode (DW_LNS_set_isa);
1628 	  out_uleb128 (isa);
1629 	}
1630 
1631       if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
1632 	{
1633 	  flags = e->loc.flags;
1634 	  out_opcode (DW_LNS_negate_stmt);
1635 	}
1636 
1637       if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
1638 	out_opcode (DW_LNS_set_basic_block);
1639 
1640       if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
1641 	out_opcode (DW_LNS_set_prologue_end);
1642 
1643       if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
1644 	out_opcode (DW_LNS_set_epilogue_begin);
1645 
1646       /* Don't try to optimize away redundant entries; gdb wants two
1647 	 entries for a function where the code starts on the same line as
1648 	 the {, and there's no way to identify that case here.  Trust gcc
1649 	 to optimize appropriately.  */
1650       line_delta = e->loc.line - line;
1651       lab = e->label;
1652       frag = symbol_get_frag (lab);
1653       frag_ofs = S_GET_VALUE (lab);
1654 
1655       if (last_frag == NULL
1656 	  || (e->loc.view == force_reset_view && force_reset_view
1657 	      /* If we're going to reset the view, but we know we're
1658 		 advancing the PC, we don't have to force with
1659 		 set_address.  We know we do when we're at the same
1660 		 address of the same frag, and we know we might when
1661 		 we're in the beginning of a frag, and we were at the
1662 		 end of the previous frag.  */
1663 	      && (frag == last_frag
1664 		  ? (last_frag_ofs == frag_ofs)
1665 		  : (frag_ofs == 0
1666 		     && ((offsetT)last_frag_ofs
1667 			 >= get_frag_fix (last_frag, seg))))))
1668 	{
1669 	  out_set_addr (lab);
1670 	  out_inc_line_addr (line_delta, 0);
1671 	}
1672       else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1673 	out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
1674       else
1675 	relax_inc_line_addr (line_delta, lab, last_lab);
1676 
1677       line = e->loc.line;
1678       last_lab = lab;
1679       last_frag = frag;
1680       last_frag_ofs = frag_ofs;
1681 
1682       next = e->next;
1683       free (e);
1684       e = next;
1685     }
1686   while (e);
1687 
1688   /* Emit a DW_LNE_end_sequence for the end of the section.  */
1689   frag = last_frag_for_seg (seg);
1690   frag_ofs = get_frag_fix (frag, seg);
1691   if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
1692     out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
1693   else
1694     {
1695       lab = symbol_temp_new (seg, frag_ofs, frag);
1696       relax_inc_line_addr (INT_MAX, lab, last_lab);
1697     }
1698 }
1699 
1700 /* Emit the directory and file tables for .debug_line.  */
1701 
1702 static void
out_file_list(void)1703 out_file_list (void)
1704 {
1705   size_t size;
1706   const char *dir;
1707   char *cp;
1708   unsigned int i;
1709 
1710   /* Emit directory list.  */
1711   for (i = 1; i < dirs_in_use; ++i)
1712     {
1713       dir = remap_debug_filename (dirs[i]);
1714       size = strlen (dir) + 1;
1715       cp = frag_more (size);
1716       memcpy (cp, dir, size);
1717     }
1718   /* Terminate it.  */
1719   out_byte ('\0');
1720 
1721   for (i = 1; i < files_in_use; ++i)
1722     {
1723       const char *fullfilename;
1724 
1725       if (files[i].filename == NULL)
1726 	{
1727 	  as_bad (_("unassigned file number %ld"), (long) i);
1728 	  /* Prevent a crash later, particularly for file 1.  */
1729 	  files[i].filename = "";
1730 	  continue;
1731 	}
1732 
1733       fullfilename = DWARF2_FILE_NAME (files[i].filename,
1734 				       files[i].dir ? dirs [files [i].dir] : "");
1735       size = strlen (fullfilename) + 1;
1736       cp = frag_more (size);
1737       memcpy (cp, fullfilename, size);
1738 
1739       out_uleb128 (files[i].dir);	/* directory number */
1740       /* Output the last modification timestamp.  */
1741       out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename,
1742 					  files[i].dir ? dirs [files [i].dir] : ""));
1743       /* Output the filesize.  */
1744       out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename,
1745 					  files[i].dir ? dirs [files [i].dir] : ""));
1746     }
1747 
1748   /* Terminate filename list.  */
1749   out_byte (0);
1750 }
1751 
1752 /* Switch to SEC and output a header length field.  Return the size of
1753    offsets used in SEC.  The caller must set EXPR->X_add_symbol value
1754    to the end of the section.  EXPR->X_add_number will be set to the
1755    negative size of the header.  */
1756 
1757 static int
out_header(asection * sec,expressionS * exp)1758 out_header (asection *sec, expressionS *exp)
1759 {
1760   symbolS *start_sym;
1761   symbolS *end_sym;
1762 
1763   subseg_set (sec, 0);
1764 
1765   if (flag_dwarf_sections)
1766     {
1767       /* If we are going to put the start and end symbols in different
1768 	 sections, then we need real symbols, not just fake, local ones.  */
1769       frag_now_fix ();
1770       start_sym = symbol_make (".Ldebug_line_start");
1771       end_sym = symbol_make (".Ldebug_line_end");
1772       symbol_set_value_now (start_sym);
1773     }
1774   else
1775     {
1776       start_sym = symbol_temp_new_now_octets ();
1777       end_sym = symbol_temp_make ();
1778     }
1779 
1780   /* Total length of the information.  */
1781   exp->X_op = O_subtract;
1782   exp->X_add_symbol = end_sym;
1783   exp->X_op_symbol = start_sym;
1784 
1785   switch (DWARF2_FORMAT (sec))
1786     {
1787     case dwarf2_format_32bit:
1788       exp->X_add_number = -4;
1789       emit_expr (exp, 4);
1790       return 4;
1791 
1792     case dwarf2_format_64bit:
1793       exp->X_add_number = -12;
1794       out_four (-1);
1795       emit_expr (exp, 8);
1796       return 8;
1797 
1798     case dwarf2_format_64bit_irix:
1799       exp->X_add_number = -8;
1800       emit_expr (exp, 8);
1801       return 8;
1802     }
1803 
1804   as_fatal (_("internal error: unknown dwarf2 format"));
1805   return 0;
1806 }
1807 
1808 /* Emit the collected .debug_line data.  */
1809 
1810 static void
out_debug_line(segT line_seg)1811 out_debug_line (segT line_seg)
1812 {
1813   expressionS exp;
1814   symbolS *prologue_start, *prologue_end;
1815   symbolS *line_end;
1816   struct line_seg *s;
1817   int sizeof_offset;
1818 
1819   memset (&exp, 0, sizeof exp);
1820   sizeof_offset = out_header (line_seg, &exp);
1821   line_end = exp.X_add_symbol;
1822 
1823   /* Version.  */
1824   out_two (DWARF2_LINE_VERSION);
1825 
1826   /* Length of the prologue following this length.  */
1827   prologue_start = symbol_temp_make ();
1828   prologue_end = symbol_temp_make ();
1829   exp.X_op = O_subtract;
1830   exp.X_add_symbol = prologue_end;
1831   exp.X_op_symbol = prologue_start;
1832   exp.X_add_number = 0;
1833   emit_expr (&exp, sizeof_offset);
1834   symbol_set_value_now (prologue_start);
1835 
1836   /* Parameters of the state machine.  */
1837   out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1838   out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1839   out_byte (DWARF2_LINE_BASE);
1840   out_byte (DWARF2_LINE_RANGE);
1841   out_byte (DWARF2_LINE_OPCODE_BASE);
1842 
1843   /* Standard opcode lengths.  */
1844   out_byte (0);			/* DW_LNS_copy */
1845   out_byte (1);			/* DW_LNS_advance_pc */
1846   out_byte (1);			/* DW_LNS_advance_line */
1847   out_byte (1);			/* DW_LNS_set_file */
1848   out_byte (1);			/* DW_LNS_set_column */
1849   out_byte (0);			/* DW_LNS_negate_stmt */
1850   out_byte (0);			/* DW_LNS_set_basic_block */
1851   out_byte (0);			/* DW_LNS_const_add_pc */
1852   out_byte (1);			/* DW_LNS_fixed_advance_pc */
1853   out_byte (0);			/* DW_LNS_set_prologue_end */
1854   out_byte (0);			/* DW_LNS_set_epilogue_begin */
1855   out_byte (1);			/* DW_LNS_set_isa */
1856 
1857   out_file_list ();
1858 
1859   symbol_set_value_now (prologue_end);
1860 
1861   /* For each section, emit a statement program.  */
1862   for (s = all_segs; s; s = s->next)
1863     if (SEG_NORMAL (s->seg))
1864       process_entries (s->seg, s->head->head);
1865     else
1866       as_warn ("dwarf line number information for %s ignored",
1867 	       segment_name (s->seg));
1868 
1869   if (flag_dwarf_sections)
1870     /* We have to switch to the special .debug_line_end section
1871        before emitting the end-of-debug_line symbol.  The linker
1872        script arranges for this section to be placed after all the
1873        (potentially garbage collected) .debug_line.<foo> sections.
1874        This section contains the line_end symbol which is used to
1875        compute the size of the linked .debug_line section, as seen
1876        in the DWARF Line Number header.  */
1877     subseg_set (subseg_get (".debug_line_end", FALSE), 0);
1878 
1879   symbol_set_value_now (line_end);
1880 }
1881 
1882 static void
out_debug_ranges(segT ranges_seg)1883 out_debug_ranges (segT ranges_seg)
1884 {
1885   unsigned int addr_size = sizeof_address;
1886   struct line_seg *s;
1887   expressionS exp;
1888   unsigned int i;
1889 
1890   memset (&exp, 0, sizeof exp);
1891   subseg_set (ranges_seg, 0);
1892 
1893   /* Base Address Entry.  */
1894   for (i = 0; i < addr_size; i++)
1895     out_byte (0xff);
1896   for (i = 0; i < addr_size; i++)
1897     out_byte (0);
1898 
1899   /* Range List Entry.  */
1900   for (s = all_segs; s; s = s->next)
1901     {
1902       fragS *frag;
1903       symbolS *beg, *end;
1904 
1905       frag = first_frag_for_seg (s->seg);
1906       beg = symbol_temp_new (s->seg, 0, frag);
1907       s->text_start = beg;
1908 
1909       frag = last_frag_for_seg (s->seg);
1910       end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1911       s->text_end = end;
1912 
1913       exp.X_op = O_symbol;
1914       exp.X_add_symbol = beg;
1915       exp.X_add_number = 0;
1916       emit_expr (&exp, addr_size);
1917 
1918       exp.X_op = O_symbol;
1919       exp.X_add_symbol = end;
1920       exp.X_add_number = 0;
1921       emit_expr (&exp, addr_size);
1922     }
1923 
1924   /* End of Range Entry.   */
1925   for (i = 0; i < addr_size; i++)
1926     out_byte (0);
1927   for (i = 0; i < addr_size; i++)
1928     out_byte (0);
1929 }
1930 
1931 /* Emit data for .debug_aranges.  */
1932 
1933 static void
out_debug_aranges(segT aranges_seg,segT info_seg)1934 out_debug_aranges (segT aranges_seg, segT info_seg)
1935 {
1936   unsigned int addr_size = sizeof_address;
1937   offsetT size;
1938   struct line_seg *s;
1939   expressionS exp;
1940   symbolS *aranges_end;
1941   char *p;
1942   int sizeof_offset;
1943 
1944   memset (&exp, 0, sizeof exp);
1945   sizeof_offset = out_header (aranges_seg, &exp);
1946   aranges_end = exp.X_add_symbol;
1947   size = -exp.X_add_number;
1948 
1949   /* Version.  */
1950   out_two (DWARF2_ARANGES_VERSION);
1951   size += 2;
1952 
1953   /* Offset to .debug_info.  */
1954   TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset);
1955   size += sizeof_offset;
1956 
1957   /* Size of an address (offset portion).  */
1958   out_byte (addr_size);
1959   size++;
1960 
1961   /* Size of a segment descriptor.  */
1962   out_byte (0);
1963   size++;
1964 
1965   /* Align the header.  */
1966   while ((size++ % (2 * addr_size)) > 0)
1967     out_byte (0);
1968 
1969   for (s = all_segs; s; s = s->next)
1970     {
1971       fragS *frag;
1972       symbolS *beg, *end;
1973 
1974       frag = first_frag_for_seg (s->seg);
1975       beg = symbol_temp_new (s->seg, 0, frag);
1976       s->text_start = beg;
1977 
1978       frag = last_frag_for_seg (s->seg);
1979       end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag);
1980       s->text_end = end;
1981 
1982       exp.X_op = O_symbol;
1983       exp.X_add_symbol = beg;
1984       exp.X_add_number = 0;
1985       emit_expr (&exp, addr_size);
1986 
1987       exp.X_op = O_subtract;
1988       exp.X_add_symbol = end;
1989       exp.X_op_symbol = beg;
1990       exp.X_add_number = 0;
1991       emit_expr (&exp, addr_size);
1992     }
1993 
1994   p = frag_more (2 * addr_size);
1995   md_number_to_chars (p, 0, addr_size);
1996   md_number_to_chars (p + addr_size, 0, addr_size);
1997 
1998   symbol_set_value_now (aranges_end);
1999 }
2000 
2001 /* Emit data for .debug_abbrev.  Note that this must be kept in
2002    sync with out_debug_info below.  */
2003 
2004 static void
out_debug_abbrev(segT abbrev_seg,segT info_seg ATTRIBUTE_UNUSED,segT line_seg ATTRIBUTE_UNUSED)2005 out_debug_abbrev (segT abbrev_seg,
2006 		  segT info_seg ATTRIBUTE_UNUSED,
2007 		  segT line_seg ATTRIBUTE_UNUSED)
2008 {
2009   subseg_set (abbrev_seg, 0);
2010 
2011   out_uleb128 (1);
2012   out_uleb128 (DW_TAG_compile_unit);
2013   out_byte (DW_CHILDREN_no);
2014   if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit)
2015     out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
2016   else
2017     out_abbrev (DW_AT_stmt_list, DW_FORM_data8);
2018   if (all_segs->next == NULL)
2019     {
2020       out_abbrev (DW_AT_low_pc, DW_FORM_addr);
2021       if (DWARF2_VERSION < 4)
2022 	out_abbrev (DW_AT_high_pc, DW_FORM_addr);
2023       else
2024 	out_abbrev (DW_AT_high_pc, (sizeof_address == 4
2025 				    ? DW_FORM_data4 : DW_FORM_data8));
2026     }
2027   else
2028     {
2029       if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit)
2030 	out_abbrev (DW_AT_ranges, DW_FORM_data4);
2031       else
2032 	out_abbrev (DW_AT_ranges, DW_FORM_data8);
2033     }
2034   out_abbrev (DW_AT_name, DW_FORM_strp);
2035   out_abbrev (DW_AT_comp_dir, DW_FORM_strp);
2036   out_abbrev (DW_AT_producer, DW_FORM_strp);
2037   out_abbrev (DW_AT_language, DW_FORM_data2);
2038   out_abbrev (0, 0);
2039 
2040   /* Terminate the abbreviations for this compilation unit.  */
2041   out_byte (0);
2042 }
2043 
2044 /* Emit a description of this compilation unit for .debug_info.  */
2045 
2046 static void
out_debug_info(segT info_seg,segT abbrev_seg,segT line_seg,segT ranges_seg,symbolS * name_sym,symbolS * comp_dir_sym,symbolS * producer_sym)2047 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg,
2048 		symbolS *name_sym, symbolS *comp_dir_sym, symbolS *producer_sym)
2049 {
2050   expressionS exp;
2051   symbolS *info_end;
2052   int sizeof_offset;
2053 
2054   memset (&exp, 0, sizeof exp);
2055   sizeof_offset = out_header (info_seg, &exp);
2056   info_end = exp.X_add_symbol;
2057 
2058   /* DWARF version.  */
2059   out_two (DWARF2_VERSION);
2060 
2061   /* .debug_abbrev offset */
2062   TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
2063 
2064   /* Target address size.  */
2065   out_byte (sizeof_address);
2066 
2067   /* DW_TAG_compile_unit DIE abbrev */
2068   out_uleb128 (1);
2069 
2070   /* DW_AT_stmt_list */
2071   TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg),
2072 			 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit
2073 			  ? 4 : 8));
2074 
2075   /* These two attributes are emitted if all of the code is contiguous.  */
2076   if (all_segs->next == NULL)
2077     {
2078       /* DW_AT_low_pc */
2079       exp.X_op = O_symbol;
2080       exp.X_add_symbol = all_segs->text_start;
2081       exp.X_add_number = 0;
2082       emit_expr (&exp, sizeof_address);
2083 
2084       /* DW_AT_high_pc */
2085       if (DWARF2_VERSION < 4)
2086 	exp.X_op = O_symbol;
2087       else
2088 	{
2089 	  exp.X_op = O_subtract;
2090 	  exp.X_op_symbol = all_segs->text_start;
2091 	}
2092       exp.X_add_symbol = all_segs->text_end;
2093       exp.X_add_number = 0;
2094       emit_expr (&exp, sizeof_address);
2095     }
2096   else
2097     {
2098       /* This attribute is emitted if the code is disjoint.  */
2099       /* DW_AT_ranges.  */
2100       TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset);
2101     }
2102 
2103   /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer.  Symbols in .debug_str
2104      setup in out_debug_str below.  */
2105   TC_DWARF2_EMIT_OFFSET (name_sym, sizeof_offset);
2106   TC_DWARF2_EMIT_OFFSET (comp_dir_sym, sizeof_offset);
2107   TC_DWARF2_EMIT_OFFSET (producer_sym, sizeof_offset);
2108 
2109   /* DW_AT_language.  Yes, this is probably not really MIPS, but the
2110      dwarf2 draft has no standard code for assembler.  */
2111   out_two (DW_LANG_Mips_Assembler);
2112 
2113   symbol_set_value_now (info_end);
2114 }
2115 
2116 /* Emit the three debug strings needed in .debug_str and setup symbols
2117    to them for use in out_debug_info.  */
2118 static void
out_debug_str(segT str_seg,symbolS ** name_sym,symbolS ** comp_dir_sym,symbolS ** producer_sym)2119 out_debug_str (segT str_seg, symbolS **name_sym, symbolS **comp_dir_sym,
2120 	       symbolS **producer_sym)
2121 {
2122   char producer[128];
2123   const char *comp_dir;
2124   const char *dirname;
2125   char *p;
2126   int len;
2127 
2128   subseg_set (str_seg, 0);
2129 
2130   /* DW_AT_name.  We don't have the actual file name that was present
2131      on the command line, so assume files[1] is the main input file.
2132      We're not supposed to get called unless at least one line number
2133      entry was emitted, so this should always be defined.  */
2134   *name_sym = symbol_temp_new_now_octets ();
2135   if (files_in_use == 0)
2136     abort ();
2137   if (files[1].dir)
2138     {
2139       dirname = remap_debug_filename (dirs[files[1].dir]);
2140       len = strlen (dirname);
2141 #ifdef TE_VMS
2142       /* Already has trailing slash.  */
2143       p = frag_more (len);
2144       memcpy (p, dirname, len);
2145 #else
2146       p = frag_more (len + 1);
2147       memcpy (p, dirname, len);
2148       INSERT_DIR_SEPARATOR (p, len);
2149 #endif
2150     }
2151   len = strlen (files[1].filename) + 1;
2152   p = frag_more (len);
2153   memcpy (p, files[1].filename, len);
2154 
2155   /* DW_AT_comp_dir */
2156   *comp_dir_sym = symbol_temp_new_now_octets ();
2157   comp_dir = remap_debug_filename (getpwd ());
2158   len = strlen (comp_dir) + 1;
2159   p = frag_more (len);
2160   memcpy (p, comp_dir, len);
2161 
2162   /* DW_AT_producer */
2163   *producer_sym = symbol_temp_new_now_octets ();
2164   sprintf (producer, "GNU AS %s", VERSION);
2165   len = strlen (producer) + 1;
2166   p = frag_more (len);
2167   memcpy (p, producer, len);
2168 }
2169 
2170 void
dwarf2_init(void)2171 dwarf2_init (void)
2172 {
2173   last_seg_ptr = &all_segs;
2174 
2175   /* Select the default CIE version to produce here.  The global
2176      starts with a value of -1 and will be modified to a valid value
2177      either by the user providing a command line option, or some
2178      targets will select their own default in md_after_parse_args.  If
2179      we get here and the global still contains -1 then it is up to us
2180      to pick a sane default.  The default we choose is 1, this is the
2181      CIE version gas has produced for a long time, and there seems no
2182      reason to change it yet.  */
2183   if (flag_dwarf_cie_version == -1)
2184     flag_dwarf_cie_version = 1;
2185 }
2186 
2187 
2188 /* Finish the dwarf2 debug sections.  We emit .debug.line if there
2189    were any .file/.loc directives, or --gdwarf2 was given, or if the
2190    file has a non-empty .debug_info section and an empty .debug_line
2191    section.  If we emit .debug_line, and the .debug_info section is
2192    empty, we also emit .debug_info, .debug_aranges and .debug_abbrev.
2193    ALL_SEGS will be non-null if there were any .file/.loc directives,
2194    or --gdwarf2 was given and there were any located instructions
2195    emitted.  */
2196 
2197 void
dwarf2_finish(void)2198 dwarf2_finish (void)
2199 {
2200   segT line_seg;
2201   struct line_seg *s;
2202   segT info_seg;
2203   int emit_other_sections = 0;
2204   int empty_debug_line = 0;
2205 
2206   info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
2207   emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
2208 
2209   line_seg = bfd_get_section_by_name (stdoutput, ".debug_line");
2210   empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg);
2211 
2212   /* We can't construct a new debug_line section if we already have one.
2213      Give an error.  */
2214   if (all_segs && !empty_debug_line)
2215     as_fatal ("duplicate .debug_line sections");
2216 
2217   if ((!all_segs && emit_other_sections)
2218       || (!emit_other_sections && !empty_debug_line))
2219     /* If there is no line information and no non-empty .debug_info
2220        section, or if there is both a non-empty .debug_info and a non-empty
2221        .debug_line, then we do nothing.  */
2222     return;
2223 
2224   /* Calculate the size of an address for the target machine.  */
2225   sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
2226 
2227   /* Create and switch to the line number section.  */
2228   line_seg = subseg_new (".debug_line", 0);
2229   bfd_set_section_flags (line_seg, SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
2230 
2231   /* For each subsection, chain the debug entries together.  */
2232   for (s = all_segs; s; s = s->next)
2233     {
2234       struct line_subseg *lss = s->head;
2235       struct line_entry **ptail = lss->ptail;
2236 
2237       /* Reset the initial view of the first subsection of the
2238 	 section.  */
2239       if (lss->head && lss->head->loc.view)
2240 	set_or_check_view (lss->head, NULL, NULL);
2241 
2242       while ((lss = lss->next) != NULL)
2243 	{
2244 	  /* Link the first view of subsequent subsections to the
2245 	     previous view.  */
2246 	  if (lss->head && lss->head->loc.view)
2247 	    set_or_check_view (lss->head,
2248 			       !s->head ? NULL : (struct line_entry *)ptail,
2249 			       s->head ? s->head->head : NULL);
2250 	  *ptail = lss->head;
2251 	  ptail = lss->ptail;
2252 	}
2253     }
2254 
2255   out_debug_line (line_seg);
2256 
2257   /* If this is assembler generated line info, and there is no
2258      debug_info already, we need .debug_info, .debug_abbrev and
2259      .debug_str sections as well.  */
2260   if (emit_other_sections)
2261     {
2262       segT abbrev_seg;
2263       segT aranges_seg;
2264       segT ranges_seg;
2265       segT str_seg;
2266       symbolS *name_sym, *comp_dir_sym, *producer_sym;
2267 
2268       gas_assert (all_segs);
2269 
2270       info_seg = subseg_new (".debug_info", 0);
2271       abbrev_seg = subseg_new (".debug_abbrev", 0);
2272       aranges_seg = subseg_new (".debug_aranges", 0);
2273       str_seg = subseg_new (".debug_str", 0);
2274 
2275       bfd_set_section_flags (info_seg,
2276 			      SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
2277       bfd_set_section_flags (abbrev_seg,
2278 			      SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
2279       bfd_set_section_flags (aranges_seg,
2280 			      SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
2281       bfd_set_section_flags (str_seg,
2282 			      SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS
2283 				       | SEC_MERGE | SEC_STRINGS);
2284       str_seg->entsize = 1;
2285 
2286       record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
2287 
2288       if (all_segs->next == NULL)
2289 	ranges_seg = NULL;
2290       else
2291 	{
2292 	  ranges_seg = subseg_new (".debug_ranges", 0);
2293 	  bfd_set_section_flags (ranges_seg,
2294 				 SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS);
2295 	  record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1);
2296 	  out_debug_ranges (ranges_seg);
2297 	}
2298 
2299       out_debug_aranges (aranges_seg, info_seg);
2300       out_debug_abbrev (abbrev_seg, info_seg, line_seg);
2301       out_debug_str (str_seg, &name_sym, &comp_dir_sym, &producer_sym);
2302       out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg,
2303 		      name_sym, comp_dir_sym, producer_sym);
2304     }
2305 }
2306 
2307 /* Perform any deferred checks pertaining to debug information.  */
2308 
2309 void
dwarf2dbg_final_check(void)2310 dwarf2dbg_final_check (void)
2311 {
2312   /* Perform reset-view checks.  Don't evaluate view_assert_failed
2313      recursively: it could be very deep.  It's a chain of adds, with
2314      each chain element pointing to the next in X_add_symbol, and
2315      holding the check value in X_op_symbol.  */
2316   while (view_assert_failed)
2317     {
2318       expressionS *exp;
2319       symbolS *sym;
2320       offsetT failed;
2321 
2322       gas_assert (!symbol_resolved_p (view_assert_failed));
2323 
2324       exp = symbol_get_value_expression (view_assert_failed);
2325       sym = view_assert_failed;
2326 
2327       /* If view_assert_failed looks like a compound check in the
2328 	 chain, break it up.  */
2329       if (exp->X_op == O_add && exp->X_add_number == 0 && exp->X_unsigned)
2330 	{
2331 	  view_assert_failed = exp->X_add_symbol;
2332 	  sym = exp->X_op_symbol;
2333 	}
2334       else
2335 	view_assert_failed = NULL;
2336 
2337       failed = resolve_symbol_value (sym);
2338       if (!symbol_resolved_p (sym) || failed)
2339 	{
2340 	  as_bad (_("view number mismatch"));
2341 	  break;
2342 	}
2343     }
2344 }
2345