dwarf2dbg.c revision 77298
1/* dwarf2dbg.c - DWARF2 debug support 2 Copyright (C) 1999, 2000 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 const 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 %d already allocated"), 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 if (line != e->loc.line || changed) 877 { 878 int line_delta = e->loc.line - line; 879 if (frag == NULL) 880 { 881 out_set_addr (seg, e->frag, e->frag_ofs); 882 out_inc_line_addr (line_delta, 0); 883 } 884 else if (frag == e->frag) 885 out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs); 886 else 887 relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs, 888 frag, frag_ofs); 889 890 frag = e->frag; 891 frag_ofs = e->frag_ofs; 892 line = e->loc.line; 893 } 894 else if (frag == NULL) 895 { 896 out_set_addr (seg, e->frag, e->frag_ofs); 897 frag = e->frag; 898 frag_ofs = e->frag_ofs; 899 } 900 901 next = e->next; 902 free (e); 903 e = next; 904 } 905 906 /* Emit a DW_LNE_end_sequence for the end of the section. */ 907 last_frag = last_frag_for_seg (seg); 908 last_frag_ofs = get_frag_fix (last_frag); 909 if (frag == last_frag) 910 out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs); 911 else 912 relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs, 913 frag, frag_ofs); 914} 915 916/* Emit the directory and file tables for .debug_line. */ 917 918static void 919out_file_list () 920{ 921 size_t size; 922 char *cp; 923 unsigned int i; 924 925 /* Terminate directory list. */ 926 out_byte ('\0'); 927 928 for (i = 1; i < files_in_use; ++i) 929 { 930 if (files[i].filename == NULL) 931 { 932 as_bad (_("Unassigned file number %u"), i); 933 continue; 934 } 935 936 size = strlen (files[i].filename) + 1; 937 cp = frag_more (size); 938 memcpy (cp, files[i].filename, size); 939 940 out_uleb128 (files[i].dir); /* directory number */ 941 out_uleb128 (0); /* last modification timestamp */ 942 out_uleb128 (0); /* filesize */ 943 } 944 945 /* Terminate filename list. */ 946 out_byte (0); 947} 948 949/* Emit the collected .debug_line data. */ 950 951static void 952out_debug_line (line_seg) 953 segT line_seg; 954{ 955 expressionS expr; 956 symbolS *line_start; 957 symbolS *prologue_end; 958 symbolS *line_end; 959 struct line_seg *s; 960 961 subseg_set (line_seg, 0); 962 963 line_start = symbol_new_now (); 964 prologue_end = symbol_make (fake_label_name); 965 line_end = symbol_make (fake_label_name); 966 967 /* Total length of the information for this compilation unit. */ 968 expr.X_op = O_subtract; 969 expr.X_add_symbol = line_end; 970 expr.X_op_symbol = line_start; 971 expr.X_add_number = -4; 972 emit_expr (&expr, 4); 973 974 /* Version. */ 975 out_two (2); 976 977 /* Length of the prologue following this length. */ 978 expr.X_op = O_subtract; 979 expr.X_add_symbol = prologue_end; 980 expr.X_op_symbol = line_start; 981 expr.X_add_number = - (4 + 2 + 4); 982 emit_expr (&expr, 4); 983 984 /* Parameters of the state machine. */ 985 out_byte (DWARF2_LINE_MIN_INSN_LENGTH); 986 out_byte (DWARF2_LINE_DEFAULT_IS_STMT); 987 out_byte (DWARF2_LINE_BASE); 988 out_byte (DWARF2_LINE_RANGE); 989 out_byte (DWARF2_LINE_OPCODE_BASE); 990 991 /* Standard opcode lengths. */ 992 out_byte (0); /* DW_LNS_copy */ 993 out_byte (1); /* DW_LNS_advance_pc */ 994 out_byte (1); /* DW_LNS_advance_line */ 995 out_byte (1); /* DW_LNS_set_file */ 996 out_byte (1); /* DW_LNS_set_column */ 997 out_byte (0); /* DW_LNS_negate_stmt */ 998 out_byte (0); /* DW_LNS_set_basic_block */ 999 out_byte (0); /* DW_LNS_const_add_pc */ 1000 out_byte (1); /* DW_LNS_fixed_advance_pc */ 1001 1002 out_file_list (); 1003 1004 set_symbol_value_now (prologue_end); 1005 1006 /* For each section, emit a statement program. */ 1007 for (s = all_segs; s; s = s->next) 1008 process_entries (s->seg, s->head->head); 1009 1010 set_symbol_value_now (line_end); 1011} 1012 1013/* Emit data for .debug_aranges. */ 1014 1015static void 1016out_debug_aranges (aranges_seg, info_seg) 1017 segT aranges_seg; 1018 segT info_seg; 1019{ 1020 unsigned int addr_size = sizeof_address; 1021 addressT size, skip; 1022 struct line_seg *s; 1023 expressionS expr; 1024 char *p; 1025 1026 size = 4 + 2 + 4 + 1 + 1; 1027 1028 skip = 2 * addr_size - (size & (2 * addr_size - 1)); 1029 if (skip == 2 * addr_size) 1030 skip = 0; 1031 size += skip; 1032 1033 for (s = all_segs; s; s = s->next) 1034 size += 2 * addr_size; 1035 1036 size += 2 * addr_size; 1037 1038 subseg_set (aranges_seg, 0); 1039 1040 /* Length of the compilation unit. */ 1041 out_four (size - 4); 1042 1043 /* Version. */ 1044 out_two (2); 1045 1046 /* Offset to .debug_info. */ 1047 expr.X_op = O_symbol; 1048 expr.X_add_symbol = section_symbol (info_seg); 1049 expr.X_add_number = 0; 1050 emit_expr (&expr, 4); 1051 1052 /* Size of an address (offset portion). */ 1053 out_byte (addr_size); 1054 1055 /* Size of a segment descriptor. */ 1056 out_byte (0); 1057 1058 /* Align the header. */ 1059 if (skip) 1060 frag_align (ffs (2 * addr_size) - 1, 0, 0); 1061 1062 for (s = all_segs; s; s = s->next) 1063 { 1064 fragS *frag; 1065 symbolS *beg, *end; 1066 1067 frag = first_frag_for_seg (s->seg); 1068 beg = symbol_new (fake_label_name, s->seg, 0, frag); 1069 s->text_start = beg; 1070 1071 frag = last_frag_for_seg (s->seg); 1072 end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag); 1073 s->text_end = end; 1074 1075 expr.X_op = O_symbol; 1076 expr.X_add_symbol = beg; 1077 expr.X_add_number = 0; 1078 emit_expr (&expr, addr_size); 1079 1080 expr.X_op = O_subtract; 1081 expr.X_add_symbol = end; 1082 expr.X_op_symbol = beg; 1083 expr.X_add_number = 0; 1084 emit_expr (&expr, addr_size); 1085 } 1086 1087 p = frag_more (2 * addr_size); 1088 md_number_to_chars (p, 0, addr_size); 1089 md_number_to_chars (p + addr_size, 0, addr_size); 1090} 1091 1092/* Emit data for .debug_abbrev. Note that this must be kept in 1093 sync with out_debug_info below. */ 1094 1095static void 1096out_debug_abbrev (abbrev_seg) 1097 segT abbrev_seg; 1098{ 1099 subseg_set (abbrev_seg, 0); 1100 1101 out_uleb128 (1); 1102 out_uleb128 (DW_TAG_compile_unit); 1103 out_byte (DW_CHILDREN_no); 1104 out_abbrev (DW_AT_stmt_list, DW_FORM_data4); 1105 if (all_segs->next == NULL) 1106 { 1107 out_abbrev (DW_AT_low_pc, DW_FORM_addr); 1108 out_abbrev (DW_AT_high_pc, DW_FORM_addr); 1109 } 1110 out_abbrev (DW_AT_comp_dir, DW_FORM_string); 1111 out_abbrev (DW_AT_producer, DW_FORM_string); 1112 out_abbrev (DW_AT_language, DW_FORM_data2); 1113 out_abbrev (0, 0); 1114 1115 /* Terminate the abbreviations for this compilation unit. */ 1116 out_byte (0); 1117} 1118 1119/* Emit a description of this compilation unit for .debug_info. */ 1120 1121static void 1122out_debug_info (info_seg, abbrev_seg, line_seg) 1123 segT info_seg; 1124 segT abbrev_seg; 1125 segT line_seg; 1126{ 1127 char producer[128]; 1128 char *comp_dir; 1129 expressionS expr; 1130 symbolS *info_start; 1131 symbolS *info_end; 1132 char *p; 1133 int len; 1134 1135 subseg_set (info_seg, 0); 1136 1137 info_start = symbol_new_now (); 1138 info_end = symbol_make (fake_label_name); 1139 1140 /* Compilation Unit length. */ 1141 expr.X_op = O_subtract; 1142 expr.X_add_symbol = info_end; 1143 expr.X_op_symbol = info_start; 1144 expr.X_add_number = -4; 1145 emit_expr (&expr, 4); 1146 1147 /* DWARF version. */ 1148 out_two (2); 1149 1150 /* .debug_abbrev offset */ 1151 expr.X_op = O_symbol; 1152 expr.X_add_symbol = section_symbol (abbrev_seg); 1153 expr.X_add_number = 0; 1154 emit_expr (&expr, 4); 1155 1156 /* Target address size. */ 1157 out_byte (sizeof_address); 1158 1159 /* DW_TAG_compile_unit DIE abbrev */ 1160 out_uleb128 (1); 1161 1162 /* DW_AT_stmt_list */ 1163 expr.X_op = O_symbol; 1164 expr.X_add_symbol = section_symbol (line_seg); 1165 expr.X_add_number = 0; 1166 emit_expr (&expr, 4); 1167 1168 /* These two attributes may only be emitted if all of the code is 1169 contiguous. Multiple sections are not that. */ 1170 if (all_segs->next == NULL) 1171 { 1172 /* DW_AT_low_pc */ 1173 expr.X_op = O_symbol; 1174 expr.X_add_symbol = all_segs->text_start; 1175 expr.X_add_number = 0; 1176 emit_expr (&expr, sizeof_address); 1177 1178 /* DW_AT_high_pc */ 1179 expr.X_op = O_symbol; 1180 expr.X_add_symbol = all_segs->text_end; 1181 expr.X_add_number = 0; 1182 emit_expr (&expr, sizeof_address); 1183 } 1184 1185 /* DW_AT_comp_dir */ 1186 comp_dir = getpwd (); 1187 len = strlen (comp_dir) + 1; 1188 p = frag_more (len); 1189 memcpy (p, comp_dir, len); 1190 1191 /* DW_AT_producer */ 1192 sprintf (producer, "GNU AS %s", VERSION); 1193 len = strlen (producer) + 1; 1194 p = frag_more (len); 1195 memcpy (p, producer, len); 1196 1197 /* DW_AT_language. Yes, this is probably not really MIPS, but the 1198 dwarf2 draft has no standard code for assembler. */ 1199 out_two (DW_LANG_Mips_Assembler); 1200 1201 set_symbol_value_now (info_end); 1202} 1203 1204void 1205dwarf2_finish () 1206{ 1207 segT line_seg; 1208 struct line_seg *s; 1209 1210 /* If no debug information was recorded, nothing to do. */ 1211 if (all_segs == NULL) 1212 return; 1213 1214 /* Calculate the size of an address for the target machine. */ 1215 sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8; 1216 1217 /* Create and switch to the line number section. */ 1218 line_seg = subseg_new (".debug_line", 0); 1219 bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY); 1220 1221 /* For each subsection, chain the debug entries together. */ 1222 for (s = all_segs; s; s = s->next) 1223 { 1224 struct line_subseg *ss = s->head; 1225 struct line_entry **ptail = ss->ptail; 1226 1227 while ((ss = ss->next) != NULL) 1228 { 1229 *ptail = ss->head; 1230 ptail = ss->ptail; 1231 } 1232 } 1233 1234 out_debug_line (line_seg); 1235 1236 /* If this is assembler generated line info, we need .debug_info 1237 and .debug_abbrev sections as well. */ 1238 if (debug_type == DEBUG_DWARF2) 1239 { 1240 segT abbrev_seg; 1241 segT info_seg; 1242 segT aranges_seg; 1243 1244 info_seg = subseg_new (".debug_info", 0); 1245 abbrev_seg = subseg_new (".debug_abbrev", 0); 1246 aranges_seg = subseg_new (".debug_aranges", 0); 1247 1248 bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY); 1249 bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY); 1250 bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY); 1251 1252 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1); 1253 1254 out_debug_aranges (aranges_seg, info_seg); 1255 out_debug_abbrev (abbrev_seg); 1256 out_debug_info (info_seg, abbrev_seg, line_seg); 1257 } 1258} 1259 1260#else 1261void 1262dwarf2_finish () 1263{ 1264} 1265 1266int 1267dwarf2dbg_estimate_size_before_relax (frag) 1268 fragS *frag ATTRIBUTE_UNUSED; 1269{ 1270 as_fatal (_("dwarf2 is not supported for this object file format")); 1271 return 0; 1272} 1273 1274int 1275dwarf2dbg_relax_frag (frag) 1276 fragS *frag ATTRIBUTE_UNUSED; 1277{ 1278 as_fatal (_("dwarf2 is not supported for this object file format")); 1279 return 0; 1280} 1281 1282void 1283dwarf2dbg_convert_frag (frag) 1284 fragS *frag ATTRIBUTE_UNUSED; 1285{ 1286 as_fatal (_("dwarf2 is not supported for this object file format")); 1287} 1288 1289void 1290dwarf2_emit_insn (size) 1291 int size ATTRIBUTE_UNUSED; 1292{ 1293} 1294 1295void 1296dwarf2_directive_file (dummy) 1297 int dummy ATTRIBUTE_UNUSED; 1298{ 1299 as_fatal (_("dwarf2 is not supported for this object file format")); 1300} 1301 1302void 1303dwarf2_directive_loc (dummy) 1304 int dummy ATTRIBUTE_UNUSED; 1305{ 1306 as_fatal (_("dwarf2 is not supported for this object file format")); 1307} 1308#endif /* BFD_ASSEMBLER */ 1309