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