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