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