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