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