1 /* dwarf2dbg.c - DWARF2 debug support
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
5
6 This file is part of GAS, the GNU Assembler.
7
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 02110-1301, USA. */
22
23 /* Logical line numbers can be controlled by the compiler via the
24 following two directives:
25
26 .file FILENO "file.c"
27 .loc FILENO LINENO [COLUMN]
28
29 FILENO is the filenumber. */
30
31 #include "ansidecl.h"
32 #include "as.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 #ifndef DWARF2_FORMAT
49 # define DWARF2_FORMAT() dwarf2_format_32bit
50 #endif
51
52 #ifndef DWARF2_ADDR_SIZE
53 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
54 #endif
55
56 #ifdef BFD_ASSEMBLER
57
58 #include "subsegs.h"
59
60 #include "elf/dwarf2.h"
61
62 /* Since we can't generate the prolog until the body is complete, we
63 use three different subsegments for .debug_line: one holding the
64 prolog, one for the directory and filename info, and one for the
65 body ("statement program"). */
66 #define DL_PROLOG 0
67 #define DL_FILES 1
68 #define DL_BODY 2
69
70 /* First special line opcde - leave room for the standard opcodes.
71 Note: If you want to change this, you'll have to update the
72 "standard_opcode_lengths" table that is emitted below in
73 dwarf2_finish(). */
74 #define DWARF2_LINE_OPCODE_BASE 10
75
76 #ifndef DWARF2_LINE_BASE
77 /* Minimum line offset in a special line info. opcode. This value
78 was chosen to give a reasonable range of values. */
79 # define DWARF2_LINE_BASE -5
80 #endif
81
82 /* Range of line offsets in a special line info. opcode. */
83 #ifndef DWARF2_LINE_RANGE
84 # define DWARF2_LINE_RANGE 14
85 #endif
86
87 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
88 /* Define the architecture-dependent minimum instruction length (in
89 bytes). This value should be rather too small than too big. */
90 # define DWARF2_LINE_MIN_INSN_LENGTH 1
91 #endif
92
93 /* Flag that indicates the initial value of the is_stmt_start flag.
94 In the present implementation, we do not mark any lines as
95 the beginning of a source statement, because that information
96 is not made available by the GCC front-end. */
97 #define DWARF2_LINE_DEFAULT_IS_STMT 1
98
99 /* Given a special op, return the line skip amount. */
100 #define SPECIAL_LINE(op) \
101 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
102
103 /* Given a special op, return the address skip amount (in units of
104 DWARF2_LINE_MIN_INSN_LENGTH. */
105 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
106
107 /* The maximum address skip amount that can be encoded with a special op. */
108 #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255)
109
110 struct line_entry {
111 struct line_entry *next;
112 fragS *frag;
113 addressT frag_ofs;
114 struct dwarf2_line_info loc;
115 };
116
117 struct line_subseg {
118 struct line_subseg *next;
119 subsegT subseg;
120 struct line_entry *head;
121 struct line_entry **ptail;
122 };
123
124 struct line_seg {
125 struct line_seg *next;
126 segT seg;
127 struct line_subseg *head;
128 symbolS *text_start;
129 symbolS *text_end;
130 };
131
132 /* Collects data for all line table entries during assembly. */
133 static struct line_seg *all_segs;
134
135 struct file_entry {
136 const char *filename;
137 unsigned int dir;
138 };
139
140 /* Table of files used by .debug_line. */
141 static struct file_entry *files;
142 static unsigned int files_in_use;
143 static unsigned int files_allocated;
144
145 /* Table of directories used by .debug_line. */
146 static char **dirs;
147 static unsigned int dirs_in_use;
148 static unsigned int dirs_allocated;
149
150 /* TRUE when we've seen a .loc directive recently. Used to avoid
151 doing work when there's nothing to do. */
152 static bfd_boolean loc_directive_seen;
153
154 /* Current location as indicated by the most recent .loc directive. */
155 static struct dwarf2_line_info current;
156
157 /* The size of an address on the target. */
158 static unsigned int sizeof_address;
159
160 static struct line_subseg *get_line_subseg (segT, subsegT);
161 static unsigned int get_filenum (const char *, unsigned int);
162 static struct frag *first_frag_for_seg (segT);
163 static struct frag *last_frag_for_seg (segT);
164 static void out_byte (int);
165 static void out_opcode (int);
166 static void out_two (int);
167 static void out_four (int);
168 static void out_abbrev (int, int);
169 static void out_uleb128 (addressT);
170 static offsetT get_frag_fix (fragS *);
171 static void out_set_addr (segT, fragS *, addressT);
172 static int size_inc_line_addr (int, addressT);
173 static void emit_inc_line_addr (int, addressT, char *, int);
174 static void out_inc_line_addr (int, addressT);
175 static void relax_inc_line_addr (int, segT, fragS *, addressT,
176 fragS *, addressT);
177 static void process_entries (segT, struct line_entry *);
178 static void out_file_list (void);
179 static void out_debug_line (segT);
180 static void out_debug_aranges (segT, segT);
181 static void out_debug_abbrev (segT);
182 static void out_debug_info (segT, segT, segT);
183
184 #ifndef TC_DWARF2_EMIT_OFFSET
185 # define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
186 static void generic_dwarf2_emit_offset (symbolS *, unsigned int);
187
188 /* Create an offset to .dwarf2_*. */
189
190 static void
generic_dwarf2_emit_offset(symbolS * symbol,unsigned int size)191 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
192 {
193 expressionS expr;
194
195 expr.X_op = O_symbol;
196 expr.X_add_symbol = symbol;
197 expr.X_add_number = 0;
198 emit_expr (&expr, size);
199 }
200 #endif
201
202 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS. */
203
204 static struct line_subseg *
get_line_subseg(segT seg,subsegT subseg)205 get_line_subseg (segT seg, subsegT subseg)
206 {
207 static segT last_seg;
208 static subsegT last_subseg;
209 static struct line_subseg *last_line_subseg;
210
211 struct line_seg *s;
212 struct line_subseg **pss, *ss;
213
214 if (seg == last_seg && subseg == last_subseg)
215 return last_line_subseg;
216
217 for (s = all_segs; s; s = s->next)
218 if (s->seg == seg)
219 goto found_seg;
220
221 s = (struct line_seg *) xmalloc (sizeof (*s));
222 s->next = all_segs;
223 s->seg = seg;
224 s->head = NULL;
225 all_segs = s;
226
227 found_seg:
228 for (pss = &s->head; (ss = *pss) != NULL ; pss = &ss->next)
229 {
230 if (ss->subseg == subseg)
231 goto found_subseg;
232 if (ss->subseg > subseg)
233 break;
234 }
235
236 ss = (struct line_subseg *) xmalloc (sizeof (*ss));
237 ss->next = *pss;
238 ss->subseg = subseg;
239 ss->head = NULL;
240 ss->ptail = &ss->head;
241 *pss = ss;
242
243 found_subseg:
244 last_seg = seg;
245 last_subseg = subseg;
246 last_line_subseg = ss;
247
248 return ss;
249 }
250
251 /* Record an entry for LOC occurring at OFS within the current fragment. */
252
253 void
dwarf2_gen_line_info(addressT ofs,struct dwarf2_line_info * loc)254 dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc)
255 {
256 struct line_subseg *ss;
257 struct line_entry *e;
258 static unsigned int line = -1;
259 static unsigned int filenum = -1;
260
261 /* Early out for as-yet incomplete location information. */
262 if (loc->filenum == 0 || loc->line == 0)
263 return;
264
265 /* Don't emit sequences of line symbols for the same line when the
266 symbols apply to assembler code. It is necessary to emit
267 duplicate line symbols when a compiler asks for them, because GDB
268 uses them to determine the end of the prologue. */
269 if (debug_type == DEBUG_DWARF2
270 && line == loc->line && filenum == loc->filenum)
271 return;
272
273 line = loc->line;
274 filenum = loc->filenum;
275
276 e = (struct line_entry *) xmalloc (sizeof (*e));
277 e->next = NULL;
278 e->frag = frag_now;
279 e->frag_ofs = ofs;
280 e->loc = *loc;
281
282 ss = get_line_subseg (now_seg, now_subseg);
283 *ss->ptail = e;
284 ss->ptail = &e->next;
285 }
286
287 void
dwarf2_where(struct dwarf2_line_info * line)288 dwarf2_where (struct dwarf2_line_info *line)
289 {
290 if (debug_type == DEBUG_DWARF2)
291 {
292 char *filename;
293 as_where (&filename, &line->line);
294 line->filenum = get_filenum (filename, 0);
295 line->column = 0;
296 line->flags = DWARF2_FLAG_BEGIN_STMT;
297 }
298 else
299 *line = current;
300 }
301
302 /* Called for each machine instruction, or relatively atomic group of
303 machine instructions (ie built-in macro). The instruction or group
304 is SIZE bytes in length. If dwarf2 line number generation is called
305 for, emit a line statement appropriately. */
306
307 void
dwarf2_emit_insn(int size)308 dwarf2_emit_insn (int size)
309 {
310 struct dwarf2_line_info loc;
311
312 if (loc_directive_seen)
313 {
314 /* Use the last location established by a .loc directive, not
315 the value returned by dwarf2_where(). That calls as_where()
316 which will return either the logical input file name (foo.c)
317 or the physical input file name (foo.s) and not the file name
318 specified in the most recent .loc directive (eg foo.h). */
319 loc = current;
320
321 /* Unless we generate DWARF2 debugging information for each
322 assembler line, we only emit one line symbol for one LOC. */
323 if (debug_type != DEBUG_DWARF2)
324 loc_directive_seen = FALSE;
325 }
326 else if (debug_type != DEBUG_DWARF2)
327 return;
328 else
329 dwarf2_where (& loc);
330
331 dwarf2_gen_line_info (frag_now_fix () - size, &loc);
332 }
333
334 /* Get a .debug_line file number for FILENAME. If NUM is nonzero,
335 allocate it on that file table slot, otherwise return the first
336 empty one. */
337
338 static unsigned int
get_filenum(const char * filename,unsigned int num)339 get_filenum (const char *filename, unsigned int num)
340 {
341 static unsigned int last_used, last_used_dir_len;
342 const char *file;
343 size_t dir_len;
344 unsigned int i, dir;
345
346 if (num == 0 && last_used)
347 {
348 if (! files[last_used].dir
349 && strcmp (filename, files[last_used].filename) == 0)
350 return last_used;
351 if (files[last_used].dir
352 && strncmp (filename, dirs[files[last_used].dir],
353 last_used_dir_len) == 0
354 && IS_DIR_SEPARATOR (filename [last_used_dir_len])
355 && strcmp (filename + last_used_dir_len + 1,
356 files[last_used].filename) == 0)
357 return last_used;
358 }
359
360 file = lbasename (filename);
361 /* Don't make empty string from / or A: from A:/ . */
362 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
363 if (file <= filename + 3)
364 file = filename;
365 #else
366 if (file == filename + 1)
367 file = filename;
368 #endif
369 dir_len = file - filename;
370
371 dir = 0;
372 if (dir_len)
373 {
374 --dir_len;
375 for (dir = 1; dir < dirs_in_use; ++dir)
376 if (strncmp (filename, dirs[dir], dir_len) == 0
377 && dirs[dir][dir_len] == '\0')
378 break;
379
380 if (dir >= dirs_in_use)
381 {
382 if (dir >= dirs_allocated)
383 {
384 dirs_allocated = dir + 32;
385 dirs = (char **)
386 xrealloc (dirs, (dir + 32) * sizeof (const char *));
387 }
388
389 dirs[dir] = xmalloc (dir_len + 1);
390 memcpy (dirs[dir], filename, dir_len);
391 dirs[dir][dir_len] = '\0';
392 dirs_in_use = dir + 1;
393 }
394 }
395
396 if (num == 0)
397 {
398 for (i = 1; i < files_in_use; ++i)
399 if (files[i].dir == dir
400 && files[i].filename
401 && strcmp (file, files[i].filename) == 0)
402 {
403 last_used = i;
404 last_used_dir_len = dir_len;
405 return i;
406 }
407 }
408 else
409 i = num;
410
411 if (i >= files_allocated)
412 {
413 unsigned int old = files_allocated;
414
415 files_allocated = i + 32;
416 files = (struct file_entry *)
417 xrealloc (files, (i + 32) * sizeof (struct file_entry));
418
419 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry));
420 }
421
422 files[i].filename = num ? file : xstrdup (file);
423 files[i].dir = dir;
424 files_in_use = i + 1;
425 last_used = i;
426 last_used_dir_len = dir_len;
427
428 return i;
429 }
430
431 /* Handle two forms of .file directive:
432 - Pass .file "source.c" to s_app_file
433 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table
434
435 If an entry is added to the file table, return a pointer to the filename. */
436
437 char *
dwarf2_directive_file(int dummy ATTRIBUTE_UNUSED)438 dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED)
439 {
440 offsetT num;
441 char *filename;
442 int filename_len;
443
444 /* Continue to accept a bare string and pass it off. */
445 SKIP_WHITESPACE ();
446 if (*input_line_pointer == '"')
447 {
448 s_app_file (0);
449 return NULL;
450 }
451
452 num = get_absolute_expression ();
453 filename = demand_copy_C_string (&filename_len);
454 demand_empty_rest_of_line ();
455
456 if (num < 1)
457 {
458 as_bad (_("file number less than one"));
459 return NULL;
460 }
461
462 if (num < (int) files_in_use && files[num].filename != 0)
463 {
464 as_bad (_("file number %ld already allocated"), (long) num);
465 return NULL;
466 }
467
468 get_filenum (filename, num);
469
470 return filename;
471 }
472
473 void
dwarf2_directive_loc(int dummy ATTRIBUTE_UNUSED)474 dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED)
475 {
476 offsetT filenum, line, column;
477
478 filenum = get_absolute_expression ();
479 SKIP_WHITESPACE ();
480 line = get_absolute_expression ();
481 SKIP_WHITESPACE ();
482 column = get_absolute_expression ();
483 demand_empty_rest_of_line ();
484
485 if (filenum < 1)
486 {
487 as_bad (_("file number less than one"));
488 return;
489 }
490 if (filenum >= (int) files_in_use || files[filenum].filename == 0)
491 {
492 as_bad (_("unassigned file number %ld"), (long) filenum);
493 return;
494 }
495
496 current.filenum = filenum;
497 current.line = line;
498 current.column = column;
499 current.flags = DWARF2_FLAG_BEGIN_STMT;
500
501 loc_directive_seen = TRUE;
502
503 #ifndef NO_LISTING
504 if (listing)
505 {
506 if (files[filenum].dir)
507 {
508 size_t dir_len = strlen (dirs[files[filenum].dir]);
509 size_t file_len = strlen (files[filenum].filename);
510 char *cp = (char *) alloca (dir_len + 1 + file_len + 1);
511
512 memcpy (cp, dirs[files[filenum].dir], dir_len);
513 cp[dir_len] = '/';
514 memcpy (cp + dir_len + 1, files[filenum].filename, file_len);
515 cp[dir_len + file_len + 1] = '\0';
516 listing_source_file (cp);
517 }
518 else
519 listing_source_file (files[filenum].filename);
520 listing_source_line (line);
521 }
522 #endif
523 }
524
525 static struct frag *
first_frag_for_seg(segT seg)526 first_frag_for_seg (segT seg)
527 {
528 frchainS *f, *first = NULL;
529
530 for (f = frchain_root; f; f = f->frch_next)
531 if (f->frch_seg == seg
532 && (! first || first->frch_subseg > f->frch_subseg))
533 first = f;
534
535 return first ? first->frch_root : NULL;
536 }
537
538 static struct frag *
last_frag_for_seg(segT seg)539 last_frag_for_seg (segT seg)
540 {
541 frchainS *f, *last = NULL;
542
543 for (f = frchain_root; f; f = f->frch_next)
544 if (f->frch_seg == seg
545 && (! last || last->frch_subseg < f->frch_subseg))
546 last= f;
547
548 return last ? last->frch_last : NULL;
549 }
550
551 /* Emit a single byte into the current segment. */
552
553 static inline void
out_byte(int byte)554 out_byte (int byte)
555 {
556 FRAG_APPEND_1_CHAR (byte);
557 }
558
559 /* Emit a statement program opcode into the current segment. */
560
561 static inline void
out_opcode(int opc)562 out_opcode (int opc)
563 {
564 out_byte (opc);
565 }
566
567 /* Emit a two-byte word into the current segment. */
568
569 static inline void
out_two(int data)570 out_two (int data)
571 {
572 md_number_to_chars (frag_more (2), data, 2);
573 }
574
575 /* Emit a four byte word into the current segment. */
576
577 static inline void
out_four(int data)578 out_four (int data)
579 {
580 md_number_to_chars (frag_more (4), data, 4);
581 }
582
583 /* Emit an unsigned "little-endian base 128" number. */
584
585 static void
out_uleb128(addressT value)586 out_uleb128 (addressT value)
587 {
588 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
589 }
590
591 /* Emit a tuple for .debug_abbrev. */
592
593 static inline void
out_abbrev(int name,int form)594 out_abbrev (int name, int form)
595 {
596 out_uleb128 (name);
597 out_uleb128 (form);
598 }
599
600 /* Get the size of a fragment. */
601
602 static offsetT
get_frag_fix(fragS * frag)603 get_frag_fix (fragS *frag)
604 {
605 frchainS *fr;
606
607 if (frag->fr_next)
608 return frag->fr_fix;
609
610 /* If a fragment is the last in the chain, special measures must be
611 taken to find its size before relaxation, since it may be pending
612 on some subsegment chain. */
613 for (fr = frchain_root; fr; fr = fr->frch_next)
614 if (fr->frch_last == frag)
615 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal;
616
617 abort ();
618 }
619
620 /* Set an absolute address (may result in a relocation entry). */
621
622 static void
out_set_addr(segT seg,fragS * frag,addressT ofs)623 out_set_addr (segT seg, fragS *frag, addressT ofs)
624 {
625 expressionS expr;
626 symbolS *sym;
627
628 sym = symbol_temp_new (seg, ofs, frag);
629
630 out_opcode (DW_LNS_extended_op);
631 out_uleb128 (sizeof_address + 1);
632
633 out_opcode (DW_LNE_set_address);
634 expr.X_op = O_symbol;
635 expr.X_add_symbol = sym;
636 expr.X_add_number = 0;
637 emit_expr (&expr, sizeof_address);
638 }
639
640 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
641 static void scale_addr_delta (addressT *);
642
643 static void
scale_addr_delta(addressT * addr_delta)644 scale_addr_delta (addressT *addr_delta)
645 {
646 static int printed_this = 0;
647 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0)
648 {
649 if (!printed_this)
650 as_bad("unaligned opcodes detected in executable segment");
651 printed_this = 1;
652 }
653 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
654 }
655 #else
656 #define scale_addr_delta(A)
657 #endif
658
659 /* Encode a pair of line and address skips as efficiently as possible.
660 Note that the line skip is signed, whereas the address skip is unsigned.
661
662 The following two routines *must* be kept in sync. This is
663 enforced by making emit_inc_line_addr abort if we do not emit
664 exactly the expected number of bytes. */
665
666 static int
size_inc_line_addr(int line_delta,addressT addr_delta)667 size_inc_line_addr (int line_delta, addressT addr_delta)
668 {
669 unsigned int tmp, opcode;
670 int len = 0;
671
672 /* Scale the address delta by the minimum instruction length. */
673 scale_addr_delta (&addr_delta);
674
675 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
676 We cannot use special opcodes here, since we want the end_sequence
677 to emit the matrix entry. */
678 if (line_delta == INT_MAX)
679 {
680 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
681 len = 1;
682 else
683 len = 1 + sizeof_leb128 (addr_delta, 0);
684 return len + 3;
685 }
686
687 /* Bias the line delta by the base. */
688 tmp = line_delta - DWARF2_LINE_BASE;
689
690 /* If the line increment is out of range of a special opcode, we
691 must encode it with DW_LNS_advance_line. */
692 if (tmp >= DWARF2_LINE_RANGE)
693 {
694 len = 1 + sizeof_leb128 (line_delta, 1);
695 line_delta = 0;
696 tmp = 0 - DWARF2_LINE_BASE;
697 }
698
699 /* Bias the opcode by the special opcode base. */
700 tmp += DWARF2_LINE_OPCODE_BASE;
701
702 /* Avoid overflow when addr_delta is large. */
703 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
704 {
705 /* Try using a special opcode. */
706 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
707 if (opcode <= 255)
708 return len + 1;
709
710 /* Try using DW_LNS_const_add_pc followed by special op. */
711 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
712 if (opcode <= 255)
713 return len + 2;
714 }
715
716 /* Otherwise use DW_LNS_advance_pc. */
717 len += 1 + sizeof_leb128 (addr_delta, 0);
718
719 /* DW_LNS_copy or special opcode. */
720 len += 1;
721
722 return len;
723 }
724
725 static void
emit_inc_line_addr(int line_delta,addressT addr_delta,char * p,int len)726 emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len)
727 {
728 unsigned int tmp, opcode;
729 int need_copy = 0;
730 char *end = p + len;
731
732 /* Scale the address delta by the minimum instruction length. */
733 scale_addr_delta (&addr_delta);
734
735 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
736 We cannot use special opcodes here, since we want the end_sequence
737 to emit the matrix entry. */
738 if (line_delta == INT_MAX)
739 {
740 if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
741 *p++ = DW_LNS_const_add_pc;
742 else
743 {
744 *p++ = DW_LNS_advance_pc;
745 p += output_leb128 (p, addr_delta, 0);
746 }
747
748 *p++ = DW_LNS_extended_op;
749 *p++ = 1;
750 *p++ = DW_LNE_end_sequence;
751 goto done;
752 }
753
754 /* Bias the line delta by the base. */
755 tmp = line_delta - DWARF2_LINE_BASE;
756
757 /* If the line increment is out of range of a special opcode, we
758 must encode it with DW_LNS_advance_line. */
759 if (tmp >= DWARF2_LINE_RANGE)
760 {
761 *p++ = DW_LNS_advance_line;
762 p += output_leb128 (p, line_delta, 1);
763
764 /* Prettier, I think, to use DW_LNS_copy instead of a
765 "line +0, addr +0" special opcode. */
766 if (addr_delta == 0)
767 {
768 *p++ = DW_LNS_copy;
769 goto done;
770 }
771
772 line_delta = 0;
773 tmp = 0 - DWARF2_LINE_BASE;
774 need_copy = 1;
775 }
776
777 /* Bias the opcode by the special opcode base. */
778 tmp += DWARF2_LINE_OPCODE_BASE;
779
780 /* Avoid overflow when addr_delta is large. */
781 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
782 {
783 /* Try using a special opcode. */
784 opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
785 if (opcode <= 255)
786 {
787 *p++ = opcode;
788 goto done;
789 }
790
791 /* Try using DW_LNS_const_add_pc followed by special op. */
792 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
793 if (opcode <= 255)
794 {
795 *p++ = DW_LNS_const_add_pc;
796 *p++ = opcode;
797 goto done;
798 }
799 }
800
801 /* Otherwise use DW_LNS_advance_pc. */
802 *p++ = DW_LNS_advance_pc;
803 p += output_leb128 (p, addr_delta, 0);
804
805 if (need_copy)
806 *p++ = DW_LNS_copy;
807 else
808 *p++ = tmp;
809
810 done:
811 assert (p == end);
812 }
813
814 /* Handy routine to combine calls to the above two routines. */
815
816 static void
out_inc_line_addr(int line_delta,addressT addr_delta)817 out_inc_line_addr (int line_delta, addressT addr_delta)
818 {
819 int len = size_inc_line_addr (line_delta, addr_delta);
820 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
821 }
822
823 /* Generate a variant frag that we can use to relax address/line
824 increments between fragments of the target segment. */
825
826 static void
relax_inc_line_addr(int line_delta,segT seg,fragS * to_frag,addressT to_ofs,fragS * from_frag,addressT from_ofs)827 relax_inc_line_addr (int line_delta, segT seg,
828 fragS *to_frag, addressT to_ofs,
829 fragS *from_frag, addressT from_ofs)
830 {
831 symbolS *to_sym, *from_sym;
832 expressionS expr;
833 int max_chars;
834
835 to_sym = symbol_temp_new (seg, to_ofs, to_frag);
836 from_sym = symbol_temp_new (seg, from_ofs, from_frag);
837
838 expr.X_op = O_subtract;
839 expr.X_add_symbol = to_sym;
840 expr.X_op_symbol = from_sym;
841 expr.X_add_number = 0;
842
843 /* The maximum size of the frag is the line delta with a maximum
844 sized address delta. */
845 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
846
847 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
848 make_expr_symbol (&expr), line_delta, NULL);
849 }
850
851 /* The function estimates the size of a rs_dwarf2dbg variant frag
852 based on the current values of the symbols. It is called before
853 the relaxation loop. We set fr_subtype to the expected length. */
854
855 int
dwarf2dbg_estimate_size_before_relax(fragS * frag)856 dwarf2dbg_estimate_size_before_relax (fragS *frag)
857 {
858 offsetT addr_delta;
859 int size;
860
861 addr_delta = resolve_symbol_value (frag->fr_symbol);
862 size = size_inc_line_addr (frag->fr_offset, addr_delta);
863
864 frag->fr_subtype = size;
865
866 return size;
867 }
868
869 /* This function relaxes a rs_dwarf2dbg variant frag based on the
870 current values of the symbols. fr_subtype is the current length
871 of the frag. This returns the change in frag length. */
872
873 int
dwarf2dbg_relax_frag(fragS * frag)874 dwarf2dbg_relax_frag (fragS *frag)
875 {
876 int old_size, new_size;
877
878 old_size = frag->fr_subtype;
879 new_size = dwarf2dbg_estimate_size_before_relax (frag);
880
881 return new_size - old_size;
882 }
883
884 /* This function converts a rs_dwarf2dbg variant frag into a normal
885 fill frag. This is called after all relaxation has been done.
886 fr_subtype will be the desired length of the frag. */
887
888 void
dwarf2dbg_convert_frag(fragS * frag)889 dwarf2dbg_convert_frag (fragS *frag)
890 {
891 offsetT addr_diff;
892
893 addr_diff = resolve_symbol_value (frag->fr_symbol);
894
895 /* fr_var carries the max_chars that we created the fragment with.
896 fr_subtype carries the current expected length. We must, of
897 course, have allocated enough memory earlier. */
898 assert (frag->fr_var >= (int) frag->fr_subtype);
899
900 emit_inc_line_addr (frag->fr_offset, addr_diff,
901 frag->fr_literal + frag->fr_fix, frag->fr_subtype);
902
903 frag->fr_fix += frag->fr_subtype;
904 frag->fr_type = rs_fill;
905 frag->fr_var = 0;
906 frag->fr_offset = 0;
907 }
908
909 /* Generate .debug_line content for the chain of line number entries
910 beginning at E, for segment SEG. */
911
912 static void
process_entries(segT seg,struct line_entry * e)913 process_entries (segT seg, struct line_entry *e)
914 {
915 unsigned filenum = 1;
916 unsigned line = 1;
917 unsigned column = 0;
918 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
919 fragS *frag = NULL;
920 fragS *last_frag;
921 addressT frag_ofs = 0;
922 addressT last_frag_ofs;
923 struct line_entry *next;
924
925 while (e)
926 {
927 int changed = 0;
928
929 if (filenum != e->loc.filenum)
930 {
931 filenum = e->loc.filenum;
932 out_opcode (DW_LNS_set_file);
933 out_uleb128 (filenum);
934 changed = 1;
935 }
936
937 if (column != e->loc.column)
938 {
939 column = e->loc.column;
940 out_opcode (DW_LNS_set_column);
941 out_uleb128 (column);
942 changed = 1;
943 }
944
945 if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
946 {
947 flags = e->loc.flags;
948 out_opcode (DW_LNS_negate_stmt);
949 changed = 1;
950 }
951
952 if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
953 {
954 out_opcode (DW_LNS_set_basic_block);
955 changed = 1;
956 }
957
958 /* Don't try to optimize away redundant entries; gdb wants two
959 entries for a function where the code starts on the same line as
960 the {, and there's no way to identify that case here. Trust gcc
961 to optimize appropriately. */
962 if (1 /* line != e->loc.line || changed */)
963 {
964 int line_delta = e->loc.line - line;
965 if (frag == NULL)
966 {
967 out_set_addr (seg, e->frag, e->frag_ofs);
968 out_inc_line_addr (line_delta, 0);
969 }
970 else if (frag == e->frag)
971 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
972 else
973 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
974 frag, frag_ofs);
975
976 frag = e->frag;
977 frag_ofs = e->frag_ofs;
978 line = e->loc.line;
979 }
980 else if (frag == NULL)
981 {
982 out_set_addr (seg, e->frag, e->frag_ofs);
983 frag = e->frag;
984 frag_ofs = e->frag_ofs;
985 }
986
987 next = e->next;
988 free (e);
989 e = next;
990 }
991
992 /* Emit a DW_LNE_end_sequence for the end of the section. */
993 last_frag = last_frag_for_seg (seg);
994 last_frag_ofs = get_frag_fix (last_frag);
995 if (frag == last_frag)
996 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
997 else
998 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
999 frag, frag_ofs);
1000 }
1001
1002 /* Emit the directory and file tables for .debug_line. */
1003
1004 static void
out_file_list(void)1005 out_file_list (void)
1006 {
1007 size_t size;
1008 char *cp;
1009 unsigned int i;
1010
1011 /* Emit directory list. */
1012 for (i = 1; i < dirs_in_use; ++i)
1013 {
1014 size = strlen (dirs[i]) + 1;
1015 cp = frag_more (size);
1016 memcpy (cp, dirs[i], size);
1017 }
1018 /* Terminate it. */
1019 out_byte ('\0');
1020
1021 for (i = 1; i < files_in_use; ++i)
1022 {
1023 if (files[i].filename == NULL)
1024 {
1025 as_bad (_("unassigned file number %ld"), (long) i);
1026 /* Prevent a crash later, particularly for file 1. */
1027 files[i].filename = "";
1028 continue;
1029 }
1030
1031 size = strlen (files[i].filename) + 1;
1032 cp = frag_more (size);
1033 memcpy (cp, files[i].filename, size);
1034
1035 out_uleb128 (files[i].dir); /* directory number */
1036 out_uleb128 (0); /* last modification timestamp */
1037 out_uleb128 (0); /* filesize */
1038 }
1039
1040 /* Terminate filename list. */
1041 out_byte (0);
1042 }
1043
1044 /* Emit the collected .debug_line data. */
1045
1046 static void
out_debug_line(segT line_seg)1047 out_debug_line (segT line_seg)
1048 {
1049 expressionS expr;
1050 symbolS *line_start;
1051 symbolS *prologue_end;
1052 symbolS *line_end;
1053 struct line_seg *s;
1054 enum dwarf2_format d2f;
1055 int sizeof_offset;
1056
1057 subseg_set (line_seg, 0);
1058
1059 line_start = symbol_temp_new_now ();
1060 prologue_end = symbol_temp_make ();
1061 line_end = symbol_temp_make ();
1062
1063 /* Total length of the information for this compilation unit. */
1064 expr.X_op = O_subtract;
1065 expr.X_add_symbol = line_end;
1066 expr.X_op_symbol = line_start;
1067
1068 d2f = DWARF2_FORMAT ();
1069 if (d2f == dwarf2_format_32bit)
1070 {
1071 expr.X_add_number = -4;
1072 emit_expr (&expr, 4);
1073 sizeof_offset = 4;
1074 }
1075 else if (d2f == dwarf2_format_64bit)
1076 {
1077 expr.X_add_number = -12;
1078 out_four (-1);
1079 emit_expr (&expr, 8);
1080 sizeof_offset = 8;
1081 }
1082 else if (d2f == dwarf2_format_64bit_irix)
1083 {
1084 expr.X_add_number = -8;
1085 emit_expr (&expr, 8);
1086 sizeof_offset = 8;
1087 }
1088 else
1089 {
1090 as_fatal (_("internal error: unknown dwarf2 format"));
1091 }
1092
1093 /* Version. */
1094 out_two (2);
1095
1096 /* Length of the prologue following this length. */
1097 expr.X_op = O_subtract;
1098 expr.X_add_symbol = prologue_end;
1099 expr.X_op_symbol = line_start;
1100 expr.X_add_number = - (4 + 2 + 4);
1101 emit_expr (&expr, sizeof_offset);
1102
1103 /* Parameters of the state machine. */
1104 out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1105 out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1106 out_byte (DWARF2_LINE_BASE);
1107 out_byte (DWARF2_LINE_RANGE);
1108 out_byte (DWARF2_LINE_OPCODE_BASE);
1109
1110 /* Standard opcode lengths. */
1111 out_byte (0); /* DW_LNS_copy */
1112 out_byte (1); /* DW_LNS_advance_pc */
1113 out_byte (1); /* DW_LNS_advance_line */
1114 out_byte (1); /* DW_LNS_set_file */
1115 out_byte (1); /* DW_LNS_set_column */
1116 out_byte (0); /* DW_LNS_negate_stmt */
1117 out_byte (0); /* DW_LNS_set_basic_block */
1118 out_byte (0); /* DW_LNS_const_add_pc */
1119 out_byte (1); /* DW_LNS_fixed_advance_pc */
1120
1121 out_file_list ();
1122
1123 symbol_set_value_now (prologue_end);
1124
1125 /* For each section, emit a statement program. */
1126 for (s = all_segs; s; s = s->next)
1127 process_entries (s->seg, s->head->head);
1128
1129 symbol_set_value_now (line_end);
1130 }
1131
1132 /* Emit data for .debug_aranges. */
1133
1134 static void
out_debug_aranges(segT aranges_seg,segT info_seg)1135 out_debug_aranges (segT aranges_seg, segT info_seg)
1136 {
1137 unsigned int addr_size = sizeof_address;
1138 addressT size, skip;
1139 struct line_seg *s;
1140 expressionS expr;
1141 char *p;
1142
1143 size = 4 + 2 + 4 + 1 + 1;
1144
1145 skip = 2 * addr_size - (size & (2 * addr_size - 1));
1146 if (skip == 2 * addr_size)
1147 skip = 0;
1148 size += skip;
1149
1150 for (s = all_segs; s; s = s->next)
1151 size += 2 * addr_size;
1152
1153 size += 2 * addr_size;
1154
1155 subseg_set (aranges_seg, 0);
1156
1157 /* Length of the compilation unit. */
1158 out_four (size - 4);
1159
1160 /* Version. */
1161 out_two (2);
1162
1163 /* Offset to .debug_info. */
1164 /* ??? sizeof_offset */
1165 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), 4);
1166
1167 /* Size of an address (offset portion). */
1168 out_byte (addr_size);
1169
1170 /* Size of a segment descriptor. */
1171 out_byte (0);
1172
1173 /* Align the header. */
1174 if (skip)
1175 frag_align (ffs (2 * addr_size) - 1, 0, 0);
1176
1177 for (s = all_segs; s; s = s->next)
1178 {
1179 fragS *frag;
1180 symbolS *beg, *end;
1181
1182 frag = first_frag_for_seg (s->seg);
1183 beg = symbol_temp_new (s->seg, 0, frag);
1184 s->text_start = beg;
1185
1186 frag = last_frag_for_seg (s->seg);
1187 end = symbol_temp_new (s->seg, get_frag_fix (frag), frag);
1188 s->text_end = end;
1189
1190 expr.X_op = O_symbol;
1191 expr.X_add_symbol = beg;
1192 expr.X_add_number = 0;
1193 emit_expr (&expr, addr_size);
1194
1195 expr.X_op = O_subtract;
1196 expr.X_add_symbol = end;
1197 expr.X_op_symbol = beg;
1198 expr.X_add_number = 0;
1199 emit_expr (&expr, addr_size);
1200 }
1201
1202 p = frag_more (2 * addr_size);
1203 md_number_to_chars (p, 0, addr_size);
1204 md_number_to_chars (p + addr_size, 0, addr_size);
1205 }
1206
1207 /* Emit data for .debug_abbrev. Note that this must be kept in
1208 sync with out_debug_info below. */
1209
1210 static void
out_debug_abbrev(segT abbrev_seg)1211 out_debug_abbrev (segT abbrev_seg)
1212 {
1213 subseg_set (abbrev_seg, 0);
1214
1215 out_uleb128 (1);
1216 out_uleb128 (DW_TAG_compile_unit);
1217 out_byte (DW_CHILDREN_no);
1218 out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1219 if (all_segs->next == NULL)
1220 {
1221 out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1222 out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1223 }
1224 out_abbrev (DW_AT_name, DW_FORM_string);
1225 out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1226 out_abbrev (DW_AT_producer, DW_FORM_string);
1227 out_abbrev (DW_AT_language, DW_FORM_data2);
1228 out_abbrev (0, 0);
1229
1230 /* Terminate the abbreviations for this compilation unit. */
1231 out_byte (0);
1232 }
1233
1234 /* Emit a description of this compilation unit for .debug_info. */
1235
1236 static void
out_debug_info(segT info_seg,segT abbrev_seg,segT line_seg)1237 out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg)
1238 {
1239 char producer[128];
1240 char *comp_dir;
1241 expressionS expr;
1242 symbolS *info_start;
1243 symbolS *info_end;
1244 char *p;
1245 int len;
1246 enum dwarf2_format d2f;
1247 int sizeof_offset;
1248
1249 subseg_set (info_seg, 0);
1250
1251 info_start = symbol_temp_new_now ();
1252 info_end = symbol_temp_make ();
1253
1254 /* Compilation Unit length. */
1255 expr.X_op = O_subtract;
1256 expr.X_add_symbol = info_end;
1257 expr.X_op_symbol = info_start;
1258
1259 d2f = DWARF2_FORMAT ();
1260 if (d2f == dwarf2_format_32bit)
1261 {
1262 expr.X_add_number = -4;
1263 emit_expr (&expr, 4);
1264 sizeof_offset = 4;
1265 }
1266 else if (d2f == dwarf2_format_64bit)
1267 {
1268 expr.X_add_number = -12;
1269 out_four (-1);
1270 emit_expr (&expr, 8);
1271 sizeof_offset = 8;
1272 }
1273 else if (d2f == dwarf2_format_64bit_irix)
1274 {
1275 expr.X_add_number = -8;
1276 emit_expr (&expr, 8);
1277 sizeof_offset = 8;
1278 }
1279 else
1280 {
1281 as_fatal (_("internal error: unknown dwarf2 format"));
1282 }
1283
1284 /* DWARF version. */
1285 out_two (2);
1286
1287 /* .debug_abbrev offset */
1288 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset);
1289
1290 /* Target address size. */
1291 out_byte (sizeof_address);
1292
1293 /* DW_TAG_compile_unit DIE abbrev */
1294 out_uleb128 (1);
1295
1296 /* DW_AT_stmt_list */
1297 /* ??? sizeof_offset */
1298 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 4);
1299
1300 /* These two attributes may only be emitted if all of the code is
1301 contiguous. Multiple sections are not that. */
1302 if (all_segs->next == NULL)
1303 {
1304 /* DW_AT_low_pc */
1305 expr.X_op = O_symbol;
1306 expr.X_add_symbol = all_segs->text_start;
1307 expr.X_add_number = 0;
1308 emit_expr (&expr, sizeof_address);
1309
1310 /* DW_AT_high_pc */
1311 expr.X_op = O_symbol;
1312 expr.X_add_symbol = all_segs->text_end;
1313 expr.X_add_number = 0;
1314 emit_expr (&expr, sizeof_address);
1315 }
1316
1317 /* DW_AT_name. We don't have the actual file name that was present
1318 on the command line, so assume files[1] is the main input file.
1319 We're not supposed to get called unless at least one line number
1320 entry was emitted, so this should always be defined. */
1321 if (!files || files_in_use < 1)
1322 abort ();
1323 if (files[1].dir)
1324 {
1325 len = strlen (dirs[files[1].dir]);
1326 p = frag_more (len + 1);
1327 memcpy (p, dirs[files[1].dir], len);
1328 p[len] = '/';
1329 }
1330 len = strlen (files[1].filename) + 1;
1331 p = frag_more (len);
1332 memcpy (p, files[1].filename, len);
1333
1334 /* DW_AT_comp_dir */
1335 comp_dir = getpwd ();
1336 len = strlen (comp_dir) + 1;
1337 p = frag_more (len);
1338 memcpy (p, comp_dir, len);
1339
1340 /* DW_AT_producer */
1341 sprintf (producer, "GNU AS %s", VERSION);
1342 len = strlen (producer) + 1;
1343 p = frag_more (len);
1344 memcpy (p, producer, len);
1345
1346 /* DW_AT_language. Yes, this is probably not really MIPS, but the
1347 dwarf2 draft has no standard code for assembler. */
1348 out_two (DW_LANG_Mips_Assembler);
1349
1350 symbol_set_value_now (info_end);
1351 }
1352
1353 /* Finish the dwarf2 debug sections. We emit .debug.line if there
1354 were any .file/.loc directives, or --gdwarf2 was given, or if the
1355 file has a non-empty .debug_info section. If we emit .debug_line,
1356 and the .debug_info section is empty, we also emit .debug_info,
1357 .debug_aranges and .debug_abbrev. ALL_SEGS will be non-null if
1358 there were any .file/.loc directives, or --gdwarf2 was given and
1359 there were any located instructions emitted. */
1360
1361 void
dwarf2_finish(void)1362 dwarf2_finish (void)
1363 {
1364 segT line_seg;
1365 struct line_seg *s;
1366 segT info_seg;
1367 int emit_other_sections = 0;
1368
1369 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info");
1370 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg);
1371
1372 if (!all_segs && emit_other_sections)
1373 /* There is no line information and no non-empty .debug_info
1374 section. */
1375 return;
1376
1377 /* Calculate the size of an address for the target machine. */
1378 sizeof_address = DWARF2_ADDR_SIZE (stdoutput);
1379
1380 /* Create and switch to the line number section. */
1381 line_seg = subseg_new (".debug_line", 0);
1382 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING);
1383
1384 /* For each subsection, chain the debug entries together. */
1385 for (s = all_segs; s; s = s->next)
1386 {
1387 struct line_subseg *ss = s->head;
1388 struct line_entry **ptail = ss->ptail;
1389
1390 while ((ss = ss->next) != NULL)
1391 {
1392 *ptail = ss->head;
1393 ptail = ss->ptail;
1394 }
1395 }
1396
1397 out_debug_line (line_seg);
1398
1399 /* If this is assembler generated line info, and there is no
1400 debug_info already, we need .debug_info and .debug_abbrev
1401 sections as well. */
1402 if (emit_other_sections)
1403 {
1404 segT abbrev_seg;
1405 segT aranges_seg;
1406
1407 assert (all_segs);
1408
1409 info_seg = subseg_new (".debug_info", 0);
1410 abbrev_seg = subseg_new (".debug_abbrev", 0);
1411 aranges_seg = subseg_new (".debug_aranges", 0);
1412
1413 bfd_set_section_flags (stdoutput, info_seg,
1414 SEC_READONLY | SEC_DEBUGGING);
1415 bfd_set_section_flags (stdoutput, abbrev_seg,
1416 SEC_READONLY | SEC_DEBUGGING);
1417 bfd_set_section_flags (stdoutput, aranges_seg,
1418 SEC_READONLY | SEC_DEBUGGING);
1419
1420 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1421
1422 out_debug_aranges (aranges_seg, info_seg);
1423 out_debug_abbrev (abbrev_seg);
1424 out_debug_info (info_seg, abbrev_seg, line_seg);
1425 }
1426 }
1427
1428 #else
1429 void
dwarf2_finish()1430 dwarf2_finish ()
1431 {
1432 }
1433
1434 int
dwarf2dbg_estimate_size_before_relax(frag)1435 dwarf2dbg_estimate_size_before_relax (frag)
1436 fragS *frag ATTRIBUTE_UNUSED;
1437 {
1438 as_fatal (_("dwarf2 is not supported for this object file format"));
1439 return 0;
1440 }
1441
1442 int
dwarf2dbg_relax_frag(frag)1443 dwarf2dbg_relax_frag (frag)
1444 fragS *frag ATTRIBUTE_UNUSED;
1445 {
1446 as_fatal (_("dwarf2 is not supported for this object file format"));
1447 return 0;
1448 }
1449
1450 void
dwarf2dbg_convert_frag(frag)1451 dwarf2dbg_convert_frag (frag)
1452 fragS *frag ATTRIBUTE_UNUSED;
1453 {
1454 as_fatal (_("dwarf2 is not supported for this object file format"));
1455 }
1456
1457 void
dwarf2_emit_insn(size)1458 dwarf2_emit_insn (size)
1459 int size ATTRIBUTE_UNUSED;
1460 {
1461 }
1462
1463 char *
dwarf2_directive_file(dummy)1464 dwarf2_directive_file (dummy)
1465 int dummy ATTRIBUTE_UNUSED;
1466 {
1467 s_app_file (0);
1468 return NULL;
1469 }
1470
1471 void
dwarf2_directive_loc(dummy)1472 dwarf2_directive_loc (dummy)
1473 int dummy ATTRIBUTE_UNUSED;
1474 {
1475 as_fatal (_("dwarf2 is not supported for this object file format"));
1476 }
1477 #endif /* BFD_ASSEMBLER */
1478