1/* dwarf2dbg.c - DWARF2 debug support 2 Copyright (C) 1999-2020 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) -1 85#endif 86 87#ifndef DWARF2_FILE_SIZE_NAME 88#define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) -1 89#endif 90 91#ifndef DWARF2_VERSION 92#define DWARF2_VERSION dwarf_level 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 outputs version 3 .debug_line information. */ 101#ifndef DWARF2_LINE_VERSION 102#define DWARF2_LINE_VERSION (dwarf_level > 3 ? dwarf_level : 3) 103#endif 104 105/* The .debug_rnglists has only been in DWARF version 5. */ 106#ifndef DWARF2_RNGLISTS_VERSION 107#define DWARF2_RNGLISTS_VERSION 5 108#endif 109 110#include "subsegs.h" 111 112#include "dwarf2.h" 113 114/* Since we can't generate the prolog until the body is complete, we 115 use three different subsegments for .debug_line: one holding the 116 prolog, one for the directory and filename info, and one for the 117 body ("statement program"). */ 118#define DL_PROLOG 0 119#define DL_FILES 1 120#define DL_BODY 2 121 122/* If linker relaxation might change offsets in the code, the DWARF special 123 opcodes and variable-length operands cannot be used. If this macro is 124 nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */ 125#ifndef DWARF2_USE_FIXED_ADVANCE_PC 126# define DWARF2_USE_FIXED_ADVANCE_PC linkrelax 127#endif 128 129/* First special line opcode - leave room for the standard opcodes. 130 Note: If you want to change this, you'll have to update the 131 "standard_opcode_lengths" table that is emitted below in 132 out_debug_line(). */ 133#define DWARF2_LINE_OPCODE_BASE 13 134 135#ifndef DWARF2_LINE_BASE 136 /* Minimum line offset in a special line info. opcode. This value 137 was chosen to give a reasonable range of values. */ 138# define DWARF2_LINE_BASE -5 139#endif 140 141/* Range of line offsets in a special line info. opcode. */ 142#ifndef DWARF2_LINE_RANGE 143# define DWARF2_LINE_RANGE 14 144#endif 145 146#ifndef DWARF2_LINE_MIN_INSN_LENGTH 147 /* Define the architecture-dependent minimum instruction length (in 148 bytes). This value should be rather too small than too big. */ 149# define DWARF2_LINE_MIN_INSN_LENGTH 1 150#endif 151 152/* Flag that indicates the initial value of the is_stmt_start flag. */ 153#define DWARF2_LINE_DEFAULT_IS_STMT 1 154 155#ifndef DWARF2_LINE_MAX_OPS_PER_INSN 156#define DWARF2_LINE_MAX_OPS_PER_INSN 1 157#endif 158 159/* Given a special op, return the line skip amount. */ 160#define SPECIAL_LINE(op) \ 161 (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE) 162 163/* Given a special op, return the address skip amount (in units of 164 DWARF2_LINE_MIN_INSN_LENGTH. */ 165#define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE) 166 167/* The maximum address skip amount that can be encoded with a special op. */ 168#define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255) 169 170#ifndef TC_PARSE_CONS_RETURN_NONE 171#define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE 172#endif 173 174struct line_entry 175{ 176 struct line_entry *next; 177 symbolS *label; 178 struct dwarf2_line_info loc; 179}; 180 181/* Don't change the offset of next in line_entry. set_or_check_view 182 calls in dwarf2_gen_line_info_1 depend on it. */ 183static char unused[offsetof(struct line_entry, next) ? -1 : 1] 184ATTRIBUTE_UNUSED; 185 186struct line_subseg 187{ 188 struct line_subseg *next; 189 subsegT subseg; 190 struct line_entry *head; 191 struct line_entry **ptail; 192 struct line_entry **pmove_tail; 193}; 194 195struct line_seg 196{ 197 struct line_seg *next; 198 segT seg; 199 struct line_subseg *head; 200 symbolS *text_start; 201 symbolS *text_end; 202}; 203 204/* Collects data for all line table entries during assembly. */ 205static struct line_seg *all_segs; 206static struct line_seg **last_seg_ptr; 207 208#define NUM_MD5_BYTES 16 209 210struct file_entry 211{ 212 const char * filename; 213 unsigned int dir; 214 bfd_boolean auto_assigned; 215 unsigned char md5[NUM_MD5_BYTES]; 216}; 217 218/* Table of files used by .debug_line. */ 219static struct file_entry *files; 220static unsigned int files_in_use; 221static unsigned int files_allocated; 222 223/* Table of directories used by .debug_line. */ 224static char ** dirs = NULL; 225static unsigned int dirs_in_use = 0; 226static unsigned int dirs_allocated = 0; 227 228/* TRUE when we've seen a .loc directive recently. Used to avoid 229 doing work when there's nothing to do. Will be reset by 230 dwarf2_consume_line_info. */ 231bfd_boolean dwarf2_loc_directive_seen; 232 233/* TRUE when we've seen any .loc directive at any time during parsing. 234 Indicates the user wants us to generate a .debug_line section. 235 Used in dwarf2_finish as sanity check. */ 236static bfd_boolean dwarf2_any_loc_directive_seen; 237 238/* TRUE when we're supposed to set the basic block mark whenever a 239 label is seen. */ 240bfd_boolean dwarf2_loc_mark_labels; 241 242/* Current location as indicated by the most recent .loc directive. */ 243static struct dwarf2_line_info current = 244{ 245 1, 1, 0, 0, 246 DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0, 247 0, NULL 248}; 249 250/* This symbol is used to recognize view number forced resets in loc 251 lists. */ 252static symbolS *force_reset_view; 253 254/* This symbol evaluates to an expression that, if nonzero, indicates 255 some view assert check failed. */ 256static symbolS *view_assert_failed; 257 258/* The size of an address on the target. */ 259static unsigned int sizeof_address; 260 261#ifndef TC_DWARF2_EMIT_OFFSET 262#define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset 263 264/* Create an offset to .dwarf2_*. */ 265 266static void 267generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size) 268{ 269 expressionS exp; 270 271 memset (&exp, 0, sizeof exp); 272 exp.X_op = O_symbol; 273 exp.X_add_symbol = symbol; 274 exp.X_add_number = 0; 275 emit_expr (&exp, size); 276} 277#endif 278 279/* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */ 280 281static struct line_subseg * 282get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p) 283{ 284 struct line_seg *s = seg_info (seg)->dwarf2_line_seg; 285 struct line_subseg **pss, *lss; 286 287 if (s == NULL) 288 { 289 if (!create_p) 290 return NULL; 291 292 s = XNEW (struct line_seg); 293 s->next = NULL; 294 s->seg = seg; 295 s->head = NULL; 296 *last_seg_ptr = s; 297 last_seg_ptr = &s->next; 298 seg_info (seg)->dwarf2_line_seg = s; 299 } 300 301 gas_assert (seg == s->seg); 302 303 for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next) 304 { 305 if (lss->subseg == subseg) 306 goto found_subseg; 307 if (lss->subseg > subseg) 308 break; 309 } 310 311 lss = XNEW (struct line_subseg); 312 lss->next = *pss; 313 lss->subseg = subseg; 314 lss->head = NULL; 315 lss->ptail = &lss->head; 316 lss->pmove_tail = &lss->head; 317 *pss = lss; 318 319 found_subseg: 320 return lss; 321} 322 323/* (Un)reverse the line_entry list starting from H. */ 324 325static struct line_entry * 326reverse_line_entry_list (struct line_entry *h) 327{ 328 struct line_entry *p = NULL, *e, *n; 329 330 for (e = h; e; e = n) 331 { 332 n = e->next; 333 e->next = p; 334 p = e; 335 } 336 return p; 337} 338 339/* Compute the view for E based on the previous entry P. If we 340 introduce an (undefined) view symbol for P, and H is given (P must 341 be the tail in this case), introduce view symbols for earlier list 342 entries as well, until one of them is constant. */ 343 344static void 345set_or_check_view (struct line_entry *e, struct line_entry *p, 346 struct line_entry *h) 347{ 348 expressionS viewx; 349 350 memset (&viewx, 0, sizeof (viewx)); 351 viewx.X_unsigned = 1; 352 353 /* First, compute !(E->label > P->label), to tell whether or not 354 we're to reset the view number. If we can't resolve it to a 355 constant, keep it symbolic. */ 356 if (!p || (e->loc.view == force_reset_view && force_reset_view)) 357 { 358 viewx.X_op = O_constant; 359 viewx.X_add_number = 0; 360 viewx.X_add_symbol = NULL; 361 viewx.X_op_symbol = NULL; 362 } 363 else 364 { 365 viewx.X_op = O_gt; 366 viewx.X_add_number = 0; 367 viewx.X_add_symbol = e->label; 368 viewx.X_op_symbol = p->label; 369 resolve_expression (&viewx); 370 if (viewx.X_op == O_constant) 371 viewx.X_add_number = !viewx.X_add_number; 372 else 373 { 374 viewx.X_add_symbol = make_expr_symbol (&viewx); 375 viewx.X_add_number = 0; 376 viewx.X_op_symbol = NULL; 377 viewx.X_op = O_logical_not; 378 } 379 } 380 381 if (S_IS_DEFINED (e->loc.view) && symbol_constant_p (e->loc.view)) 382 { 383 expressionS *value = symbol_get_value_expression (e->loc.view); 384 /* We can't compare the view numbers at this point, because in 385 VIEWX we've only determined whether we're to reset it so 386 far. */ 387 if (viewx.X_op == O_constant) 388 { 389 if (!value->X_add_number != !viewx.X_add_number) 390 as_bad (_("view number mismatch")); 391 } 392 /* Record the expression to check it later. It is the result of 393 a logical not, thus 0 or 1. We just add up all such deferred 394 expressions, and resolve it at the end. */ 395 else if (!value->X_add_number) 396 { 397 symbolS *deferred = make_expr_symbol (&viewx); 398 if (view_assert_failed) 399 { 400 expressionS chk; 401 402 memset (&chk, 0, sizeof (chk)); 403 chk.X_unsigned = 1; 404 chk.X_op = O_add; 405 chk.X_add_number = 0; 406 chk.X_add_symbol = view_assert_failed; 407 chk.X_op_symbol = deferred; 408 deferred = make_expr_symbol (&chk); 409 } 410 view_assert_failed = deferred; 411 } 412 } 413 414 if (viewx.X_op != O_constant || viewx.X_add_number) 415 { 416 expressionS incv; 417 418 if (!p->loc.view) 419 { 420 p->loc.view = symbol_temp_make (); 421 gas_assert (!S_IS_DEFINED (p->loc.view)); 422 } 423 424 memset (&incv, 0, sizeof (incv)); 425 incv.X_unsigned = 1; 426 incv.X_op = O_symbol; 427 incv.X_add_symbol = p->loc.view; 428 incv.X_add_number = 1; 429 430 if (viewx.X_op == O_constant) 431 { 432 gas_assert (viewx.X_add_number == 1); 433 viewx = incv; 434 } 435 else 436 { 437 viewx.X_add_symbol = make_expr_symbol (&viewx); 438 viewx.X_add_number = 0; 439 viewx.X_op_symbol = make_expr_symbol (&incv); 440 viewx.X_op = O_multiply; 441 } 442 } 443 444 if (!S_IS_DEFINED (e->loc.view)) 445 { 446 symbol_set_value_expression (e->loc.view, &viewx); 447 S_SET_SEGMENT (e->loc.view, expr_section); 448 symbol_set_frag (e->loc.view, &zero_address_frag); 449 } 450 451 /* Define and attempt to simplify any earlier views needed to 452 compute E's. */ 453 if (h && p && p->loc.view && !S_IS_DEFINED (p->loc.view)) 454 { 455 struct line_entry *h2; 456 /* Reverse the list to avoid quadratic behavior going backwards 457 in a single-linked list. */ 458 struct line_entry *r = reverse_line_entry_list (h); 459 460 gas_assert (r == p); 461 /* Set or check views until we find a defined or absent view. */ 462 do 463 { 464 /* Do not define the head of a (sub?)segment view while 465 handling others. It would be defined too early, without 466 regard to the last view of other subsegments. 467 set_or_check_view will be called for every head segment 468 that needs it. */ 469 if (r == h) 470 break; 471 set_or_check_view (r, r->next, NULL); 472 } 473 while (r->next && r->next->loc.view && !S_IS_DEFINED (r->next->loc.view) 474 && (r = r->next)); 475 476 /* Unreverse the list, so that we can go forward again. */ 477 h2 = reverse_line_entry_list (p); 478 gas_assert (h2 == h); 479 480 /* Starting from the last view we just defined, attempt to 481 simplify the view expressions, until we do so to P. */ 482 do 483 { 484 /* The head view of a subsegment may remain undefined while 485 handling other elements, before it is linked to the last 486 view of the previous subsegment. */ 487 if (r == h) 488 continue; 489 gas_assert (S_IS_DEFINED (r->loc.view)); 490 resolve_expression (symbol_get_value_expression (r->loc.view)); 491 } 492 while (r != p && (r = r->next)); 493 494 /* Now that we've defined and computed all earlier views that might 495 be needed to compute E's, attempt to simplify it. */ 496 resolve_expression (symbol_get_value_expression (e->loc.view)); 497 } 498} 499 500/* Record an entry for LOC occurring at LABEL. */ 501 502static void 503dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc) 504{ 505 struct line_subseg *lss; 506 struct line_entry *e; 507 508 e = XNEW (struct line_entry); 509 e->next = NULL; 510 e->label = label; 511 e->loc = *loc; 512 513 lss = get_line_subseg (now_seg, now_subseg, TRUE); 514 515 /* Subseg heads are chained to previous subsegs in 516 dwarf2_finish. */ 517 if (loc->view && lss->head) 518 set_or_check_view (e, 519 (struct line_entry *)lss->ptail, 520 lss->head); 521 522 *lss->ptail = e; 523 lss->ptail = &e->next; 524} 525 526/* Record an entry for LOC occurring at OFS within the current fragment. */ 527 528void 529dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc) 530{ 531 static unsigned int line = -1; 532 static unsigned int filenum = -1; 533 534 symbolS *sym; 535 536 /* Early out for as-yet incomplete location information. */ 537 if (loc->line == 0) 538 return; 539 if (loc->filenum == 0 && DWARF2_LINE_VERSION < 5) 540 return; 541 542 /* Don't emit sequences of line symbols for the same line when the 543 symbols apply to assembler code. It is necessary to emit 544 duplicate line symbols when a compiler asks for them, because GDB 545 uses them to determine the end of the prologue. */ 546 if (debug_type == DEBUG_DWARF2 547 && line == loc->line && filenum == loc->filenum) 548 return; 549 550 line = loc->line; 551 filenum = loc->filenum; 552 553 if (linkrelax) 554 { 555 char name[120]; 556 557 /* Use a non-fake name for the line number location, 558 so that it can be referred to by relocations. */ 559 sprintf (name, ".Loc.%u.%u", line, filenum); 560 sym = symbol_new (name, now_seg, frag_now, ofs); 561 } 562 else 563 sym = symbol_temp_new (now_seg, frag_now, ofs); 564 dwarf2_gen_line_info_1 (sym, loc); 565} 566 567static const char * 568get_basename (const char * pathname) 569{ 570 const char * file; 571 572 file = lbasename (pathname); 573 /* Don't make empty string from / or A: from A:/ . */ 574#ifdef HAVE_DOS_BASED_FILE_SYSTEM 575 if (file <= pathname + 3) 576 file = pathname; 577#else 578 if (file == pathname + 1) 579 file = pathname; 580#endif 581 return file; 582} 583 584static unsigned int 585get_directory_table_entry (const char * dirname, 586 size_t dirlen, 587 bfd_boolean can_use_zero) 588{ 589 unsigned int d; 590 591 if (dirlen == 0) 592 return 0; 593 594#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 595 if (IS_DIR_SEPARATOR (dirname[dirlen - 1])) 596 { 597 -- dirlen; 598 if (dirlen == 0) 599 return 0; 600 } 601#endif 602 603 for (d = 0; d < dirs_in_use; ++d) 604 { 605 if (dirs[d] != NULL 606 && filename_ncmp (dirname, dirs[d], dirlen) == 0 607 && dirs[d][dirlen] == '\0') 608 return d; 609 } 610 611 if (can_use_zero) 612 { 613 if (dirs == NULL || dirs[0] == NULL) 614 d = 0; 615 } 616 else if (d == 0) 617 d = 1; 618 619 if (d >= dirs_allocated) 620 { 621 unsigned int old = dirs_allocated; 622 623 dirs_allocated = d + 32; 624 dirs = XRESIZEVEC (char *, dirs, dirs_allocated); 625 memset (dirs + old, 0, (dirs_allocated - old) * sizeof (char *)); 626 } 627 628 dirs[d] = xmemdup0 (dirname, dirlen); 629 if (dirs_in_use <= d) 630 dirs_in_use = d + 1; 631 632 return d; 633} 634 635static bfd_boolean 636assign_file_to_slot (unsigned long i, const char *file, unsigned int dir, bfd_boolean auto_assign) 637{ 638 if (i >= files_allocated) 639 { 640 unsigned int old = files_allocated; 641 642 files_allocated = i + 32; 643 /* Catch wraparound. */ 644 if (files_allocated <= old) 645 { 646 as_bad (_("file number %lu is too big"), (unsigned long) i); 647 return FALSE; 648 } 649 650 files = XRESIZEVEC (struct file_entry, files, files_allocated); 651 memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry)); 652 } 653 654 files[i].filename = file; 655 files[i].dir = dir; 656 files[i].auto_assigned = auto_assign; 657 memset (files[i].md5, 0, NUM_MD5_BYTES); 658 659 if (files_in_use < i + 1) 660 files_in_use = i + 1; 661 662 return TRUE; 663} 664 665/* Get a .debug_line file number for PATHNAME. If there is a 666 directory component to PATHNAME, then this will be stored 667 in the directory table, if it is not already present. 668 Returns the slot number allocated to that filename or -1 669 if there was a problem. */ 670 671static signed int 672allocate_filenum (const char * pathname) 673{ 674 static signed int last_used = -1, last_used_dir_len = 0; 675 const char *file; 676 size_t dir_len; 677 unsigned int i, dir; 678 679 /* Short circuit the common case of adding the same pathname 680 as last time. */ 681 if (last_used != -1) 682 { 683 const char * dirname = NULL; 684 685 if (dirs != NULL) 686 dirname = dirs[files[last_used].dir]; 687 688 if (dirname == NULL) 689 { 690 if (filename_cmp (pathname, files[last_used].filename) == 0) 691 return last_used; 692 } 693 else 694 { 695 if (filename_ncmp (pathname, dirname, last_used_dir_len) == 0 696 && IS_DIR_SEPARATOR (pathname [last_used_dir_len]) 697 && filename_cmp (pathname + last_used_dir_len + 1, 698 files[last_used].filename) == 0) 699 return last_used; 700 } 701 } 702 703 file = get_basename (pathname); 704 dir_len = file - pathname; 705 706 dir = get_directory_table_entry (pathname, dir_len, FALSE); 707 708 /* Do not use slot-0. That is specifically reserved for use by 709 the '.file 0 "name"' directive. */ 710 for (i = 1; i < files_in_use; ++i) 711 if (files[i].dir == dir 712 && files[i].filename 713 && filename_cmp (file, files[i].filename) == 0) 714 { 715 last_used = i; 716 last_used_dir_len = dir_len; 717 return i; 718 } 719 720 if (!assign_file_to_slot (i, file, dir, TRUE)) 721 return -1; 722 723 last_used = i; 724 last_used_dir_len = dir_len; 725 726 return i; 727} 728 729/* Allocate slot NUM in the .debug_line file table to FILENAME. 730 If DIRNAME is not NULL or there is a directory component to FILENAME 731 then this will be stored in the directory table, if not already present. 732 if WITH_MD5 is TRUE then there is a md5 value in generic_bignum. 733 Returns TRUE if allocation succeeded, FALSE otherwise. */ 734 735static bfd_boolean 736allocate_filename_to_slot (const char * dirname, 737 const char * filename, 738 unsigned int num, 739 bfd_boolean with_md5) 740{ 741 const char *file; 742 size_t dirlen; 743 unsigned int i, d; 744 745 /* Short circuit the common case of adding the same pathname 746 as last time. */ 747 if (num < files_allocated && files[num].filename != NULL) 748 { 749 const char * dir = NULL; 750 751 if (dirs) 752 dir = dirs[files[num].dir]; 753 754 if (with_md5 755 && memcmp (generic_bignum, files[num].md5, NUM_MD5_BYTES) != 0) 756 goto fail; 757 758 if (dirname != NULL) 759 { 760 if (dir != NULL && filename_cmp (dir, dirname) != 0) 761 goto fail; 762 763 if (filename_cmp (filename, files[num].filename) != 0) 764 goto fail; 765 766 /* If the filenames match, but the directory table entry was 767 empty, then fill it with the provided directory name. */ 768 if (dir == NULL) 769 dirs[files[num].dir] = xmemdup0 (dirname, strlen (dirname)); 770 771 return TRUE; 772 } 773 else if (dir != NULL) 774 { 775 dirlen = strlen (dir); 776 if (filename_ncmp (filename, dir, dirlen) == 0 777 && IS_DIR_SEPARATOR (filename [dirlen]) 778 && filename_cmp (filename + dirlen + 1, files[num].filename) == 0) 779 return TRUE; 780 } 781 else /* dir == NULL */ 782 { 783 file = get_basename (filename); 784 if (filename_cmp (file, files[num].filename) == 0) 785 { 786 if (file > filename) 787 /* The filenames match, but the directory table entry is empty. 788 Fill it with the provided directory name. */ 789 dirs[files[num].dir] = xmemdup0 (filename, file - filename); 790 return TRUE; 791 } 792 } 793 794 fail: 795 /* If NUM was previously allocated automatically then 796 choose another slot for it, so that we can reuse NUM. */ 797 if (files[num].auto_assigned) 798 { 799 /* Find an unused slot. */ 800 for (i = 1; i < files_in_use; ++i) 801 if (files[i].filename == NULL) 802 break; 803 if (! assign_file_to_slot (i, files[num].filename, files[num].dir, TRUE)) 804 return FALSE; 805 files[num].filename = NULL; 806 } 807 else 808 { 809 as_bad (_("file table slot %u is already occupied by a different file (%s%s%s vs %s%s%s)"), 810 num, 811 dir == NULL ? "" : dir, 812 dir == NULL ? "" : "/", 813 files[num].filename, 814 dirname == NULL ? "" : dirname, 815 dirname == NULL ? "" : "/", 816 filename); 817 return FALSE; 818 } 819 } 820 821 if (dirname == NULL) 822 { 823 dirname = filename; 824 file = get_basename (filename); 825 dirlen = file - filename; 826 } 827 else 828 { 829 dirlen = strlen (dirname); 830 file = filename; 831 } 832 833 d = get_directory_table_entry (dirname, dirlen, num == 0); 834 i = num; 835 836 if (! assign_file_to_slot (i, file, d, FALSE)) 837 return FALSE; 838 839 if (with_md5) 840 { 841 if (target_big_endian) 842 { 843 /* md5's are stored in litte endian format. */ 844 unsigned int bits_remaining = NUM_MD5_BYTES * BITS_PER_CHAR; 845 unsigned int byte = NUM_MD5_BYTES; 846 unsigned int bignum_index = 0; 847 848 while (bits_remaining) 849 { 850 unsigned int bignum_bits_remaining = LITTLENUM_NUMBER_OF_BITS; 851 valueT bignum_value = generic_bignum [bignum_index]; 852 bignum_index ++; 853 854 while (bignum_bits_remaining) 855 { 856 files[i].md5[--byte] = bignum_value & 0xff; 857 bignum_value >>= 8; 858 bignum_bits_remaining -= 8; 859 bits_remaining -= 8; 860 } 861 } 862 } 863 else 864 { 865 unsigned int bits_remaining = NUM_MD5_BYTES * BITS_PER_CHAR; 866 unsigned int byte = 0; 867 unsigned int bignum_index = 0; 868 869 while (bits_remaining) 870 { 871 unsigned int bignum_bits_remaining = LITTLENUM_NUMBER_OF_BITS; 872 valueT bignum_value = generic_bignum [bignum_index]; 873 874 bignum_index ++; 875 876 while (bignum_bits_remaining) 877 { 878 files[i].md5[byte++] = bignum_value & 0xff; 879 bignum_value >>= 8; 880 bignum_bits_remaining -= 8; 881 bits_remaining -= 8; 882 } 883 } 884 } 885 } 886 else 887 memset (files[i].md5, 0, NUM_MD5_BYTES); 888 889 return TRUE; 890} 891 892/* Returns the current source information. If .file directives have 893 been encountered, the info for the corresponding source file is 894 returned. Otherwise, the info for the assembly source file is 895 returned. */ 896 897void 898dwarf2_where (struct dwarf2_line_info *line) 899{ 900 if (debug_type == DEBUG_DWARF2) 901 { 902 const char *filename; 903 904 memset (line, 0, sizeof (*line)); 905 filename = as_where (&line->line); 906 line->filenum = allocate_filenum (filename); 907 /* FIXME: We should check the return value from allocate_filenum. */ 908 line->column = 0; 909 line->flags = DWARF2_FLAG_IS_STMT; 910 line->isa = current.isa; 911 line->discriminator = current.discriminator; 912 line->view = NULL; 913 } 914 else 915 *line = current; 916} 917 918/* A hook to allow the target backend to inform the line number state 919 machine of isa changes when assembler debug info is enabled. */ 920 921void 922dwarf2_set_isa (unsigned int isa) 923{ 924 current.isa = isa; 925} 926 927/* Called for each machine instruction, or relatively atomic group of 928 machine instructions (ie built-in macro). The instruction or group 929 is SIZE bytes in length. If dwarf2 line number generation is called 930 for, emit a line statement appropriately. */ 931 932void 933dwarf2_emit_insn (int size) 934{ 935 struct dwarf2_line_info loc; 936 937 if (debug_type != DEBUG_DWARF2 938 ? !dwarf2_loc_directive_seen 939 : !seen_at_least_1_file ()) 940 return; 941 942 dwarf2_where (&loc); 943 944 dwarf2_gen_line_info ((frag_now_fix_octets () - size) / OCTETS_PER_BYTE, &loc); 945 dwarf2_consume_line_info (); 946} 947 948/* Move all previously-emitted line entries for the current position by 949 DELTA bytes. This function cannot be used to move the same entries 950 twice. */ 951 952void 953dwarf2_move_insn (int delta) 954{ 955 struct line_subseg *lss; 956 struct line_entry *e; 957 valueT now; 958 959 if (delta == 0) 960 return; 961 962 lss = get_line_subseg (now_seg, now_subseg, FALSE); 963 if (!lss) 964 return; 965 966 now = frag_now_fix (); 967 while ((e = *lss->pmove_tail)) 968 { 969 if (S_GET_VALUE (e->label) == now) 970 S_SET_VALUE (e->label, now + delta); 971 lss->pmove_tail = &e->next; 972 } 973} 974 975/* Called after the current line information has been either used with 976 dwarf2_gen_line_info or saved with a machine instruction for later use. 977 This resets the state of the line number information to reflect that 978 it has been used. */ 979 980void 981dwarf2_consume_line_info (void) 982{ 983 /* Unless we generate DWARF2 debugging information for each 984 assembler line, we only emit one line symbol for one LOC. */ 985 dwarf2_loc_directive_seen = FALSE; 986 987 current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK 988 | DWARF2_FLAG_PROLOGUE_END 989 | DWARF2_FLAG_EPILOGUE_BEGIN); 990 current.discriminator = 0; 991 current.view = NULL; 992} 993 994/* Called for each (preferably code) label. If dwarf2_loc_mark_labels 995 is enabled, emit a basic block marker. */ 996 997void 998dwarf2_emit_label (symbolS *label) 999{ 1000 struct dwarf2_line_info loc; 1001 1002 if (!dwarf2_loc_mark_labels) 1003 return; 1004 if (S_GET_SEGMENT (label) != now_seg) 1005 return; 1006 if (!(bfd_section_flags (now_seg) & SEC_CODE)) 1007 return; 1008 if (files_in_use == 0 && debug_type != DEBUG_DWARF2) 1009 return; 1010 1011 dwarf2_where (&loc); 1012 1013 loc.flags |= DWARF2_FLAG_BASIC_BLOCK; 1014 1015 dwarf2_gen_line_info_1 (label, &loc); 1016 dwarf2_consume_line_info (); 1017} 1018 1019/* Handle two forms of .file directive: 1020 - Pass .file "source.c" to s_app_file 1021 - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table 1022 1023 If an entry is added to the file table, return a pointer to the filename. */ 1024 1025char * 1026dwarf2_directive_filename (void) 1027{ 1028 bfd_boolean with_md5 = FALSE; 1029 valueT num; 1030 char *filename; 1031 const char * dirname = NULL; 1032 int filename_len; 1033 1034 /* Continue to accept a bare string and pass it off. */ 1035 SKIP_WHITESPACE (); 1036 if (*input_line_pointer == '"') 1037 { 1038 s_app_file (0); 1039 return NULL; 1040 } 1041 1042 num = get_absolute_expression (); 1043 1044 if ((offsetT) num < 1 && DWARF2_LINE_VERSION < 5) 1045 { 1046 as_bad (_("file number less than one")); 1047 ignore_rest_of_line (); 1048 return NULL; 1049 } 1050 1051 /* FIXME: Should we allow ".file <N>\n" as an expression meaning 1052 "switch back to the already allocated file <N> as the current 1053 file" ? */ 1054 1055 filename = demand_copy_C_string (&filename_len); 1056 if (filename == NULL) 1057 /* demand_copy_C_string will have already generated an error message. */ 1058 return NULL; 1059 1060 /* For DWARF-5 support we also accept: 1061 .file <NUM> ["<dir>"] "<file>" [md5 <NUM>] */ 1062 if (DWARF2_LINE_VERSION > 4) 1063 { 1064 SKIP_WHITESPACE (); 1065 if (*input_line_pointer == '"') 1066 { 1067 dirname = filename; 1068 filename = demand_copy_C_string (&filename_len); 1069 SKIP_WHITESPACE (); 1070 } 1071 1072 if (strncmp (input_line_pointer, "md5", 3) == 0) 1073 { 1074 input_line_pointer += 3; 1075 SKIP_WHITESPACE (); 1076 1077 expressionS exp; 1078 expression_and_evaluate (& exp); 1079 if (exp.X_op != O_big) 1080 as_bad (_("md5 value too small or not a constant")); 1081 else 1082 with_md5 = TRUE; 1083 } 1084 } 1085 1086 demand_empty_rest_of_line (); 1087 1088 /* A .file directive implies compiler generated debug information is 1089 being supplied. Turn off gas generated debug info. */ 1090 debug_type = DEBUG_NONE; 1091 1092 if (num != (unsigned int) num 1093 || num >= (size_t) -1 / sizeof (struct file_entry) - 32) 1094 { 1095 as_bad (_("file number %lu is too big"), (unsigned long) num); 1096 return NULL; 1097 } 1098 1099 if (! allocate_filename_to_slot (dirname, filename, (unsigned int) num, 1100 with_md5)) 1101 return NULL; 1102 1103 return filename; 1104} 1105 1106/* Calls dwarf2_directive_filename, but discards its result. 1107 Used in pseudo-op tables where the function result is ignored. */ 1108 1109void 1110dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) 1111{ 1112 (void) dwarf2_directive_filename (); 1113} 1114 1115void 1116dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) 1117{ 1118 offsetT filenum, line; 1119 1120 /* If we see two .loc directives in a row, force the first one to be 1121 output now. */ 1122 if (dwarf2_loc_directive_seen) 1123 dwarf2_emit_insn (0); 1124 1125 filenum = get_absolute_expression (); 1126 SKIP_WHITESPACE (); 1127 line = get_absolute_expression (); 1128 1129 if (filenum < 1) 1130 { 1131 if (filenum != 0 || DWARF2_LINE_VERSION < 5) 1132 { 1133 as_bad (_("file number less than one")); 1134 return; 1135 } 1136 } 1137 1138 if (filenum >= (int) files_in_use || files[filenum].filename == NULL) 1139 { 1140 as_bad (_("unassigned file number %ld"), (long) filenum); 1141 return; 1142 } 1143 1144 current.filenum = filenum; 1145 current.line = line; 1146 current.discriminator = 0; 1147 1148#ifndef NO_LISTING 1149 if (listing) 1150 { 1151 if (files[filenum].dir) 1152 { 1153 size_t dir_len = strlen (dirs[files[filenum].dir]); 1154 size_t file_len = strlen (files[filenum].filename); 1155 char *cp = XNEWVEC (char, dir_len + 1 + file_len + 1); 1156 1157 memcpy (cp, dirs[files[filenum].dir], dir_len); 1158 INSERT_DIR_SEPARATOR (cp, dir_len); 1159 memcpy (cp + dir_len + 1, files[filenum].filename, file_len); 1160 cp[dir_len + file_len + 1] = '\0'; 1161 listing_source_file (cp); 1162 free (cp); 1163 } 1164 else 1165 listing_source_file (files[filenum].filename); 1166 listing_source_line (line); 1167 } 1168#endif 1169 1170 SKIP_WHITESPACE (); 1171 if (ISDIGIT (*input_line_pointer)) 1172 { 1173 current.column = get_absolute_expression (); 1174 SKIP_WHITESPACE (); 1175 } 1176 1177 while (ISALPHA (*input_line_pointer)) 1178 { 1179 char *p, c; 1180 offsetT value; 1181 1182 c = get_symbol_name (& p); 1183 1184 if (strcmp (p, "basic_block") == 0) 1185 { 1186 current.flags |= DWARF2_FLAG_BASIC_BLOCK; 1187 *input_line_pointer = c; 1188 } 1189 else if (strcmp (p, "prologue_end") == 0) 1190 { 1191 current.flags |= DWARF2_FLAG_PROLOGUE_END; 1192 *input_line_pointer = c; 1193 } 1194 else if (strcmp (p, "epilogue_begin") == 0) 1195 { 1196 current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN; 1197 *input_line_pointer = c; 1198 } 1199 else if (strcmp (p, "is_stmt") == 0) 1200 { 1201 (void) restore_line_pointer (c); 1202 value = get_absolute_expression (); 1203 if (value == 0) 1204 current.flags &= ~DWARF2_FLAG_IS_STMT; 1205 else if (value == 1) 1206 current.flags |= DWARF2_FLAG_IS_STMT; 1207 else 1208 { 1209 as_bad (_("is_stmt value not 0 or 1")); 1210 return; 1211 } 1212 } 1213 else if (strcmp (p, "isa") == 0) 1214 { 1215 (void) restore_line_pointer (c); 1216 value = get_absolute_expression (); 1217 if (value >= 0) 1218 current.isa = value; 1219 else 1220 { 1221 as_bad (_("isa number less than zero")); 1222 return; 1223 } 1224 } 1225 else if (strcmp (p, "discriminator") == 0) 1226 { 1227 (void) restore_line_pointer (c); 1228 value = get_absolute_expression (); 1229 if (value >= 0) 1230 current.discriminator = value; 1231 else 1232 { 1233 as_bad (_("discriminator less than zero")); 1234 return; 1235 } 1236 } 1237 else if (strcmp (p, "view") == 0) 1238 { 1239 symbolS *sym; 1240 1241 (void) restore_line_pointer (c); 1242 SKIP_WHITESPACE (); 1243 1244 if (ISDIGIT (*input_line_pointer) 1245 || *input_line_pointer == '-') 1246 { 1247 bfd_boolean force_reset = *input_line_pointer == '-'; 1248 1249 value = get_absolute_expression (); 1250 if (value != 0) 1251 { 1252 as_bad (_("numeric view can only be asserted to zero")); 1253 return; 1254 } 1255 if (force_reset && force_reset_view) 1256 sym = force_reset_view; 1257 else 1258 { 1259 sym = symbol_temp_new (absolute_section, &zero_address_frag, 1260 value); 1261 if (force_reset) 1262 force_reset_view = sym; 1263 } 1264 } 1265 else 1266 { 1267 char *name = read_symbol_name (); 1268 1269 if (!name) 1270 return; 1271 sym = symbol_find_or_make (name); 1272 if (S_IS_DEFINED (sym) || symbol_equated_p (sym)) 1273 { 1274 if (S_IS_VOLATILE (sym)) 1275 sym = symbol_clone (sym, 1); 1276 else if (!S_CAN_BE_REDEFINED (sym)) 1277 { 1278 as_bad (_("symbol `%s' is already defined"), name); 1279 return; 1280 } 1281 } 1282 S_SET_SEGMENT (sym, undefined_section); 1283 S_SET_VALUE (sym, 0); 1284 symbol_set_frag (sym, &zero_address_frag); 1285 } 1286 current.view = sym; 1287 } 1288 else 1289 { 1290 as_bad (_("unknown .loc sub-directive `%s'"), p); 1291 (void) restore_line_pointer (c); 1292 return; 1293 } 1294 1295 SKIP_WHITESPACE_AFTER_NAME (); 1296 } 1297 1298 demand_empty_rest_of_line (); 1299 dwarf2_any_loc_directive_seen = dwarf2_loc_directive_seen = TRUE; 1300 debug_type = DEBUG_NONE; 1301 1302 /* If we were given a view id, emit the row right away. */ 1303 if (current.view) 1304 dwarf2_emit_insn (0); 1305} 1306 1307void 1308dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED) 1309{ 1310 offsetT value = get_absolute_expression (); 1311 1312 if (value != 0 && value != 1) 1313 { 1314 as_bad (_("expected 0 or 1")); 1315 ignore_rest_of_line (); 1316 } 1317 else 1318 { 1319 dwarf2_loc_mark_labels = value != 0; 1320 demand_empty_rest_of_line (); 1321 } 1322} 1323 1324static struct frag * 1325first_frag_for_seg (segT seg) 1326{ 1327 return seg_info (seg)->frchainP->frch_root; 1328} 1329 1330static struct frag * 1331last_frag_for_seg (segT seg) 1332{ 1333 frchainS *f = seg_info (seg)->frchainP; 1334 1335 while (f->frch_next != NULL) 1336 f = f->frch_next; 1337 1338 return f->frch_last; 1339} 1340 1341/* Emit a single byte into the current segment. */ 1342 1343static inline void 1344out_byte (int byte) 1345{ 1346 FRAG_APPEND_1_CHAR (byte); 1347} 1348 1349/* Emit a statement program opcode into the current segment. */ 1350 1351static inline void 1352out_opcode (int opc) 1353{ 1354 out_byte (opc); 1355} 1356 1357/* Emit a two-byte word into the current segment. */ 1358 1359static inline void 1360out_two (int data) 1361{ 1362 md_number_to_chars (frag_more (2), data, 2); 1363} 1364 1365/* Emit a four byte word into the current segment. */ 1366 1367static inline void 1368out_four (int data) 1369{ 1370 md_number_to_chars (frag_more (4), data, 4); 1371} 1372 1373/* Emit an unsigned "little-endian base 128" number. */ 1374 1375static void 1376out_uleb128 (addressT value) 1377{ 1378 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0); 1379} 1380 1381/* Emit a signed "little-endian base 128" number. */ 1382 1383static void 1384out_leb128 (addressT value) 1385{ 1386 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); 1387} 1388 1389/* Emit a tuple for .debug_abbrev. */ 1390 1391static inline void 1392out_abbrev (int name, int form) 1393{ 1394 out_uleb128 (name); 1395 out_uleb128 (form); 1396} 1397 1398/* Get the size of a fragment. */ 1399 1400static offsetT 1401get_frag_fix (fragS *frag, segT seg) 1402{ 1403 frchainS *fr; 1404 1405 if (frag->fr_next) 1406 return frag->fr_fix; 1407 1408 /* If a fragment is the last in the chain, special measures must be 1409 taken to find its size before relaxation, since it may be pending 1410 on some subsegment chain. */ 1411 for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next) 1412 if (fr->frch_last == frag) 1413 return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal; 1414 1415 abort (); 1416} 1417 1418/* Set an absolute address (may result in a relocation entry). */ 1419 1420static void 1421out_set_addr (symbolS *sym) 1422{ 1423 expressionS exp; 1424 1425 memset (&exp, 0, sizeof exp); 1426 out_opcode (DW_LNS_extended_op); 1427 out_uleb128 (sizeof_address + 1); 1428 1429 out_opcode (DW_LNE_set_address); 1430 exp.X_op = O_symbol; 1431 exp.X_add_symbol = sym; 1432 exp.X_add_number = 0; 1433 emit_expr (&exp, sizeof_address); 1434} 1435 1436static void scale_addr_delta (addressT *); 1437 1438static void 1439scale_addr_delta (addressT *addr_delta) 1440{ 1441 static int printed_this = 0; 1442 if (DWARF2_LINE_MIN_INSN_LENGTH > 1) 1443 { 1444 if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this) 1445 { 1446 as_bad("unaligned opcodes detected in executable segment"); 1447 printed_this = 1; 1448 } 1449 *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH; 1450 } 1451} 1452 1453/* Encode a pair of line and address skips as efficiently as possible. 1454 Note that the line skip is signed, whereas the address skip is unsigned. 1455 1456 The following two routines *must* be kept in sync. This is 1457 enforced by making emit_inc_line_addr abort if we do not emit 1458 exactly the expected number of bytes. */ 1459 1460static int 1461size_inc_line_addr (int line_delta, addressT addr_delta) 1462{ 1463 unsigned int tmp, opcode; 1464 int len = 0; 1465 1466 /* Scale the address delta by the minimum instruction length. */ 1467 scale_addr_delta (&addr_delta); 1468 1469 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. 1470 We cannot use special opcodes here, since we want the end_sequence 1471 to emit the matrix entry. */ 1472 if (line_delta == INT_MAX) 1473 { 1474 if (addr_delta == MAX_SPECIAL_ADDR_DELTA) 1475 len = 1; 1476 else if (addr_delta) 1477 len = 1 + sizeof_leb128 (addr_delta, 0); 1478 return len + 3; 1479 } 1480 1481 /* Bias the line delta by the base. */ 1482 tmp = line_delta - DWARF2_LINE_BASE; 1483 1484 /* If the line increment is out of range of a special opcode, we 1485 must encode it with DW_LNS_advance_line. */ 1486 if (tmp >= DWARF2_LINE_RANGE) 1487 { 1488 len = 1 + sizeof_leb128 (line_delta, 1); 1489 line_delta = 0; 1490 tmp = 0 - DWARF2_LINE_BASE; 1491 } 1492 1493 /* Bias the opcode by the special opcode base. */ 1494 tmp += DWARF2_LINE_OPCODE_BASE; 1495 1496 /* Avoid overflow when addr_delta is large. */ 1497 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA) 1498 { 1499 /* Try using a special opcode. */ 1500 opcode = tmp + addr_delta * DWARF2_LINE_RANGE; 1501 if (opcode <= 255) 1502 return len + 1; 1503 1504 /* Try using DW_LNS_const_add_pc followed by special op. */ 1505 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE; 1506 if (opcode <= 255) 1507 return len + 2; 1508 } 1509 1510 /* Otherwise use DW_LNS_advance_pc. */ 1511 len += 1 + sizeof_leb128 (addr_delta, 0); 1512 1513 /* DW_LNS_copy or special opcode. */ 1514 len += 1; 1515 1516 return len; 1517} 1518 1519static void 1520emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len) 1521{ 1522 unsigned int tmp, opcode; 1523 int need_copy = 0; 1524 char *end = p + len; 1525 1526 /* Line number sequences cannot go backward in addresses. This means 1527 we've incorrectly ordered the statements in the sequence. */ 1528 gas_assert ((offsetT) addr_delta >= 0); 1529 1530 /* Scale the address delta by the minimum instruction length. */ 1531 scale_addr_delta (&addr_delta); 1532 1533 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. 1534 We cannot use special opcodes here, since we want the end_sequence 1535 to emit the matrix entry. */ 1536 if (line_delta == INT_MAX) 1537 { 1538 if (addr_delta == MAX_SPECIAL_ADDR_DELTA) 1539 *p++ = DW_LNS_const_add_pc; 1540 else if (addr_delta) 1541 { 1542 *p++ = DW_LNS_advance_pc; 1543 p += output_leb128 (p, addr_delta, 0); 1544 } 1545 1546 *p++ = DW_LNS_extended_op; 1547 *p++ = 1; 1548 *p++ = DW_LNE_end_sequence; 1549 goto done; 1550 } 1551 1552 /* Bias the line delta by the base. */ 1553 tmp = line_delta - DWARF2_LINE_BASE; 1554 1555 /* If the line increment is out of range of a special opcode, we 1556 must encode it with DW_LNS_advance_line. */ 1557 if (tmp >= DWARF2_LINE_RANGE) 1558 { 1559 *p++ = DW_LNS_advance_line; 1560 p += output_leb128 (p, line_delta, 1); 1561 1562 line_delta = 0; 1563 tmp = 0 - DWARF2_LINE_BASE; 1564 need_copy = 1; 1565 } 1566 1567 /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0" 1568 special opcode. */ 1569 if (line_delta == 0 && addr_delta == 0) 1570 { 1571 *p++ = DW_LNS_copy; 1572 goto done; 1573 } 1574 1575 /* Bias the opcode by the special opcode base. */ 1576 tmp += DWARF2_LINE_OPCODE_BASE; 1577 1578 /* Avoid overflow when addr_delta is large. */ 1579 if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA) 1580 { 1581 /* Try using a special opcode. */ 1582 opcode = tmp + addr_delta * DWARF2_LINE_RANGE; 1583 if (opcode <= 255) 1584 { 1585 *p++ = opcode; 1586 goto done; 1587 } 1588 1589 /* Try using DW_LNS_const_add_pc followed by special op. */ 1590 opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE; 1591 if (opcode <= 255) 1592 { 1593 *p++ = DW_LNS_const_add_pc; 1594 *p++ = opcode; 1595 goto done; 1596 } 1597 } 1598 1599 /* Otherwise use DW_LNS_advance_pc. */ 1600 *p++ = DW_LNS_advance_pc; 1601 p += output_leb128 (p, addr_delta, 0); 1602 1603 if (need_copy) 1604 *p++ = DW_LNS_copy; 1605 else 1606 *p++ = tmp; 1607 1608 done: 1609 gas_assert (p == end); 1610} 1611 1612/* Handy routine to combine calls to the above two routines. */ 1613 1614static void 1615out_inc_line_addr (int line_delta, addressT addr_delta) 1616{ 1617 int len = size_inc_line_addr (line_delta, addr_delta); 1618 emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len); 1619} 1620 1621/* Write out an alternative form of line and address skips using 1622 DW_LNS_fixed_advance_pc opcodes. This uses more space than the default 1623 line and address information, but it is required if linker relaxation 1624 could change the code offsets. The following two routines *must* be 1625 kept in sync. */ 1626#define ADDR_DELTA_LIMIT 50000 1627 1628static int 1629size_fixed_inc_line_addr (int line_delta, addressT addr_delta) 1630{ 1631 int len = 0; 1632 1633 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */ 1634 if (line_delta != INT_MAX) 1635 len = 1 + sizeof_leb128 (line_delta, 1); 1636 1637 if (addr_delta > ADDR_DELTA_LIMIT) 1638 { 1639 /* DW_LNS_extended_op */ 1640 len += 1 + sizeof_leb128 (sizeof_address + 1, 0); 1641 /* DW_LNE_set_address */ 1642 len += 1 + sizeof_address; 1643 } 1644 else 1645 /* DW_LNS_fixed_advance_pc */ 1646 len += 3; 1647 1648 if (line_delta == INT_MAX) 1649 /* DW_LNS_extended_op + DW_LNE_end_sequence */ 1650 len += 3; 1651 else 1652 /* DW_LNS_copy */ 1653 len += 1; 1654 1655 return len; 1656} 1657 1658static void 1659emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag, 1660 char *p, int len) 1661{ 1662 expressionS *pexp; 1663 char *end = p + len; 1664 1665 /* Line number sequences cannot go backward in addresses. This means 1666 we've incorrectly ordered the statements in the sequence. */ 1667 gas_assert ((offsetT) addr_delta >= 0); 1668 1669 /* Verify that we have kept in sync with size_fixed_inc_line_addr. */ 1670 gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta)); 1671 1672 /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */ 1673 if (line_delta != INT_MAX) 1674 { 1675 *p++ = DW_LNS_advance_line; 1676 p += output_leb128 (p, line_delta, 1); 1677 } 1678 1679 pexp = symbol_get_value_expression (frag->fr_symbol); 1680 1681 /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can 1682 advance the address by at most 64K. Linker relaxation (without 1683 which this function would not be used) could change the operand by 1684 an unknown amount. If the address increment is getting close to 1685 the limit, just reset the address. */ 1686 if (addr_delta > ADDR_DELTA_LIMIT) 1687 { 1688 symbolS *to_sym; 1689 expressionS exp; 1690 1691 memset (&exp, 0, sizeof exp); 1692 gas_assert (pexp->X_op == O_subtract); 1693 to_sym = pexp->X_add_symbol; 1694 1695 *p++ = DW_LNS_extended_op; 1696 p += output_leb128 (p, sizeof_address + 1, 0); 1697 *p++ = DW_LNE_set_address; 1698 exp.X_op = O_symbol; 1699 exp.X_add_symbol = to_sym; 1700 exp.X_add_number = 0; 1701 emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE); 1702 p += sizeof_address; 1703 } 1704 else 1705 { 1706 *p++ = DW_LNS_fixed_advance_pc; 1707 emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE); 1708 p += 2; 1709 } 1710 1711 if (line_delta == INT_MAX) 1712 { 1713 *p++ = DW_LNS_extended_op; 1714 *p++ = 1; 1715 *p++ = DW_LNE_end_sequence; 1716 } 1717 else 1718 *p++ = DW_LNS_copy; 1719 1720 gas_assert (p == end); 1721} 1722 1723/* Generate a variant frag that we can use to relax address/line 1724 increments between fragments of the target segment. */ 1725 1726static void 1727relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) 1728{ 1729 expressionS exp; 1730 int max_chars; 1731 1732 memset (&exp, 0, sizeof exp); 1733 exp.X_op = O_subtract; 1734 exp.X_add_symbol = to_sym; 1735 exp.X_op_symbol = from_sym; 1736 exp.X_add_number = 0; 1737 1738 /* The maximum size of the frag is the line delta with a maximum 1739 sized address delta. */ 1740 if (DWARF2_USE_FIXED_ADVANCE_PC) 1741 max_chars = size_fixed_inc_line_addr (line_delta, 1742 -DWARF2_LINE_MIN_INSN_LENGTH); 1743 else 1744 max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH); 1745 1746 frag_var (rs_dwarf2dbg, max_chars, max_chars, 1, 1747 make_expr_symbol (&exp), line_delta, NULL); 1748} 1749 1750/* The function estimates the size of a rs_dwarf2dbg variant frag 1751 based on the current values of the symbols. It is called before 1752 the relaxation loop. We set fr_subtype to the expected length. */ 1753 1754int 1755dwarf2dbg_estimate_size_before_relax (fragS *frag) 1756{ 1757 offsetT addr_delta; 1758 int size; 1759 1760 addr_delta = resolve_symbol_value (frag->fr_symbol); 1761 if (DWARF2_USE_FIXED_ADVANCE_PC) 1762 size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta); 1763 else 1764 size = size_inc_line_addr (frag->fr_offset, addr_delta); 1765 1766 frag->fr_subtype = size; 1767 1768 return size; 1769} 1770 1771/* This function relaxes a rs_dwarf2dbg variant frag based on the 1772 current values of the symbols. fr_subtype is the current length 1773 of the frag. This returns the change in frag length. */ 1774 1775int 1776dwarf2dbg_relax_frag (fragS *frag) 1777{ 1778 int old_size, new_size; 1779 1780 old_size = frag->fr_subtype; 1781 new_size = dwarf2dbg_estimate_size_before_relax (frag); 1782 1783 return new_size - old_size; 1784} 1785 1786/* This function converts a rs_dwarf2dbg variant frag into a normal 1787 fill frag. This is called after all relaxation has been done. 1788 fr_subtype will be the desired length of the frag. */ 1789 1790void 1791dwarf2dbg_convert_frag (fragS *frag) 1792{ 1793 offsetT addr_diff; 1794 1795 if (DWARF2_USE_FIXED_ADVANCE_PC) 1796 { 1797 /* If linker relaxation is enabled then the distance between the two 1798 symbols in the frag->fr_symbol expression might change. Hence we 1799 cannot rely upon the value computed by resolve_symbol_value. 1800 Instead we leave the expression unfinalized and allow 1801 emit_fixed_inc_line_addr to create a fixup (which later becomes a 1802 relocation) that will allow the linker to correctly compute the 1803 actual address difference. We have to use a fixed line advance for 1804 this as we cannot (easily) relocate leb128 encoded values. */ 1805 int saved_finalize_syms = finalize_syms; 1806 1807 finalize_syms = 0; 1808 addr_diff = resolve_symbol_value (frag->fr_symbol); 1809 finalize_syms = saved_finalize_syms; 1810 } 1811 else 1812 addr_diff = resolve_symbol_value (frag->fr_symbol); 1813 1814 /* fr_var carries the max_chars that we created the fragment with. 1815 fr_subtype carries the current expected length. We must, of 1816 course, have allocated enough memory earlier. */ 1817 gas_assert (frag->fr_var >= (int) frag->fr_subtype); 1818 1819 if (DWARF2_USE_FIXED_ADVANCE_PC) 1820 emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag, 1821 frag->fr_literal + frag->fr_fix, 1822 frag->fr_subtype); 1823 else 1824 emit_inc_line_addr (frag->fr_offset, addr_diff, 1825 frag->fr_literal + frag->fr_fix, frag->fr_subtype); 1826 1827 frag->fr_fix += frag->fr_subtype; 1828 frag->fr_type = rs_fill; 1829 frag->fr_var = 0; 1830 frag->fr_offset = 0; 1831} 1832 1833/* Generate .debug_line content for the chain of line number entries 1834 beginning at E, for segment SEG. */ 1835 1836static void 1837process_entries (segT seg, struct line_entry *e) 1838{ 1839 unsigned filenum = 1; 1840 unsigned line = 1; 1841 unsigned column = 0; 1842 unsigned isa = 0; 1843 unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0; 1844 fragS *last_frag = NULL, *frag; 1845 addressT last_frag_ofs = 0, frag_ofs; 1846 symbolS *last_lab = NULL, *lab; 1847 struct line_entry *next; 1848 1849 if (flag_dwarf_sections) 1850 { 1851 char * name; 1852 const char * sec_name; 1853 1854 /* Switch to the relevant sub-section before we start to emit 1855 the line number table. 1856 1857 FIXME: These sub-sections do not have a normal Line Number 1858 Program Header, thus strictly speaking they are not valid 1859 DWARF sections. Unfortunately the DWARF standard assumes 1860 a one-to-one relationship between compilation units and 1861 line number tables. Thus we have to have a .debug_line 1862 section, as well as our sub-sections, and we have to ensure 1863 that all of the sub-sections are merged into a proper 1864 .debug_line section before a debugger sees them. */ 1865 1866 sec_name = bfd_section_name (seg); 1867 if (strcmp (sec_name, ".text") != 0) 1868 { 1869 name = concat (".debug_line", sec_name, (char *) NULL); 1870 subseg_set (subseg_get (name, FALSE), 0); 1871 } 1872 else 1873 /* Don't create a .debug_line.text section - 1874 that is redundant. Instead just switch back to the 1875 normal .debug_line section. */ 1876 subseg_set (subseg_get (".debug_line", FALSE), 0); 1877 } 1878 1879 do 1880 { 1881 int line_delta; 1882 1883 if (filenum != e->loc.filenum) 1884 { 1885 filenum = e->loc.filenum; 1886 out_opcode (DW_LNS_set_file); 1887 out_uleb128 (filenum); 1888 } 1889 1890 if (column != e->loc.column) 1891 { 1892 column = e->loc.column; 1893 out_opcode (DW_LNS_set_column); 1894 out_uleb128 (column); 1895 } 1896 1897 if (e->loc.discriminator != 0) 1898 { 1899 out_opcode (DW_LNS_extended_op); 1900 out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0)); 1901 out_opcode (DW_LNE_set_discriminator); 1902 out_uleb128 (e->loc.discriminator); 1903 } 1904 1905 if (isa != e->loc.isa) 1906 { 1907 isa = e->loc.isa; 1908 out_opcode (DW_LNS_set_isa); 1909 out_uleb128 (isa); 1910 } 1911 1912 if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT) 1913 { 1914 flags = e->loc.flags; 1915 out_opcode (DW_LNS_negate_stmt); 1916 } 1917 1918 if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK) 1919 out_opcode (DW_LNS_set_basic_block); 1920 1921 if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END) 1922 out_opcode (DW_LNS_set_prologue_end); 1923 1924 if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN) 1925 out_opcode (DW_LNS_set_epilogue_begin); 1926 1927 /* Don't try to optimize away redundant entries; gdb wants two 1928 entries for a function where the code starts on the same line as 1929 the {, and there's no way to identify that case here. Trust gcc 1930 to optimize appropriately. */ 1931 line_delta = e->loc.line - line; 1932 lab = e->label; 1933 frag = symbol_get_frag (lab); 1934 frag_ofs = S_GET_VALUE (lab); 1935 1936 if (last_frag == NULL 1937 || (e->loc.view == force_reset_view && force_reset_view 1938 /* If we're going to reset the view, but we know we're 1939 advancing the PC, we don't have to force with 1940 set_address. We know we do when we're at the same 1941 address of the same frag, and we know we might when 1942 we're in the beginning of a frag, and we were at the 1943 end of the previous frag. */ 1944 && (frag == last_frag 1945 ? (last_frag_ofs == frag_ofs) 1946 : (frag_ofs == 0 1947 && ((offsetT)last_frag_ofs 1948 >= get_frag_fix (last_frag, seg)))))) 1949 { 1950 out_set_addr (lab); 1951 out_inc_line_addr (line_delta, 0); 1952 } 1953 else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC) 1954 out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs); 1955 else 1956 relax_inc_line_addr (line_delta, lab, last_lab); 1957 1958 line = e->loc.line; 1959 last_lab = lab; 1960 last_frag = frag; 1961 last_frag_ofs = frag_ofs; 1962 1963 next = e->next; 1964 free (e); 1965 e = next; 1966 } 1967 while (e); 1968 1969 /* Emit a DW_LNE_end_sequence for the end of the section. */ 1970 frag = last_frag_for_seg (seg); 1971 frag_ofs = get_frag_fix (frag, seg); 1972 if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC) 1973 out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs); 1974 else 1975 { 1976 lab = symbol_temp_new (seg, frag, frag_ofs); 1977 relax_inc_line_addr (INT_MAX, lab, last_lab); 1978 } 1979} 1980 1981/* Switch to LINE_STR_SEG and output the given STR. Return the 1982 symbol pointing to the new string in the section. */ 1983 1984static symbolS * 1985add_line_strp (segT line_str_seg, const char *str) 1986{ 1987 char *cp; 1988 size_t size; 1989 symbolS *sym; 1990 1991 subseg_set (line_str_seg, 0); 1992 1993 sym = symbol_temp_new_now_octets (); 1994 1995 size = strlen (str) + 1; 1996 cp = frag_more (size); 1997 memcpy (cp, str, size); 1998 1999 return sym; 2000} 2001 2002 2003/* Emit the directory and file tables for .debug_line. */ 2004 2005static void 2006out_dir_and_file_list (segT line_seg, int sizeof_offset) 2007{ 2008 size_t size; 2009 const char *dir; 2010 char *cp; 2011 unsigned int i; 2012 bfd_boolean emit_md5 = FALSE; 2013 bfd_boolean emit_timestamps = TRUE; 2014 bfd_boolean emit_filesize = TRUE; 2015 segT line_str_seg = NULL; 2016 symbolS *line_strp; 2017 2018 /* Output the Directory Table. */ 2019 if (DWARF2_LINE_VERSION >= 5) 2020 { 2021 /* We only have one column in the directory table. */ 2022 out_byte (1); 2023 2024 /* Describe the purpose and format of the column. */ 2025 out_uleb128 (DW_LNCT_path); 2026 /* Store these strings in the .debug_line_str section so they 2027 can be shared. */ 2028 out_uleb128 (DW_FORM_line_strp); 2029 2030 /* Now state how many rows there are in the table. We need at 2031 least 1 if there is one or more file names to store the 2032 "working directory". */ 2033 if (dirs_in_use == 0 && files_in_use > 0) 2034 out_uleb128 (1); 2035 else 2036 out_uleb128 (dirs_in_use); 2037 } 2038 2039 /* Emit directory list. */ 2040 if (DWARF2_LINE_VERSION >= 5 && (dirs_in_use > 0 || files_in_use > 0)) 2041 { 2042 line_str_seg = subseg_new (".debug_line_str", 0); 2043 bfd_set_section_flags (line_str_seg, 2044 SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS 2045 | SEC_MERGE | SEC_STRINGS); 2046 line_str_seg->entsize = 1; 2047 2048 /* DWARF5 uses slot zero, but that is only set explicitly 2049 using a .file 0 directive. If that isn't used, but dir 2050 one is used, then use that as main file directory. 2051 Otherwise use pwd as main file directory. */ 2052 if (dirs_in_use > 0 && dirs != NULL && dirs[0] != NULL) 2053 dir = remap_debug_filename (dirs[0]); 2054 else if (dirs_in_use > 1 && dirs != NULL && dirs[1] != NULL) 2055 dir = remap_debug_filename (dirs[1]); 2056 else 2057 dir = remap_debug_filename (getpwd ()); 2058 2059 line_strp = add_line_strp (line_str_seg, dir); 2060 subseg_set (line_seg, 0); 2061 TC_DWARF2_EMIT_OFFSET (line_strp, sizeof_offset); 2062 } 2063 for (i = 1; i < dirs_in_use; ++i) 2064 { 2065 dir = remap_debug_filename (dirs[i]); 2066 if (DWARF2_LINE_VERSION < 5) 2067 { 2068 size = strlen (dir) + 1; 2069 cp = frag_more (size); 2070 memcpy (cp, dir, size); 2071 } 2072 else 2073 { 2074 line_strp = add_line_strp (line_str_seg, dir); 2075 subseg_set (line_seg, 0); 2076 TC_DWARF2_EMIT_OFFSET (line_strp, sizeof_offset); 2077 } 2078 } 2079 2080 if (DWARF2_LINE_VERSION < 5) 2081 /* Terminate it. */ 2082 out_byte ('\0'); 2083 2084 /* Output the File Name Table. */ 2085 if (DWARF2_LINE_VERSION >= 5) 2086 { 2087 unsigned int columns = 4; 2088 2089 if (((unsigned long) DWARF2_FILE_TIME_NAME ("", "")) == -1UL) 2090 { 2091 emit_timestamps = FALSE; 2092 -- columns; 2093 } 2094 2095 if (DWARF2_FILE_SIZE_NAME ("", "") == -1) 2096 { 2097 emit_filesize = FALSE; 2098 -- columns; 2099 } 2100 2101 for (i = 0; i < files_in_use; ++i) 2102 if (files[i].md5[0] != 0) 2103 break; 2104 if (i < files_in_use) 2105 { 2106 emit_md5 = TRUE; 2107 ++ columns; 2108 } 2109 2110 /* The number of format entries to follow. */ 2111 out_byte (columns); 2112 /* The format of the file name. */ 2113 out_uleb128 (DW_LNCT_path); 2114 /* Store these strings in the .debug_line_str section so they 2115 can be shared. */ 2116 out_uleb128 (DW_FORM_line_strp); 2117 2118 /* The format of the directory index. */ 2119 out_uleb128 (DW_LNCT_directory_index); 2120 out_uleb128 (DW_FORM_udata); 2121 2122 if (emit_timestamps) 2123 { 2124 /* The format of the timestamp. */ 2125 out_uleb128 (DW_LNCT_timestamp); 2126 out_uleb128 (DW_FORM_udata); 2127 } 2128 2129 if (emit_filesize) 2130 { 2131 /* The format of the file size. */ 2132 out_uleb128 (DW_LNCT_size); 2133 out_uleb128 (DW_FORM_udata); 2134 } 2135 2136 if (emit_md5) 2137 { 2138 /* The format of the MD5 sum. */ 2139 out_uleb128 (DW_LNCT_MD5); 2140 out_uleb128 (DW_FORM_data16); 2141 } 2142 2143 /* The number of entries in the table. */ 2144 out_uleb128 (files_in_use); 2145 } 2146 2147 for (i = DWARF2_LINE_VERSION > 4 ? 0 : 1; i < files_in_use; ++i) 2148 { 2149 const char *fullfilename; 2150 2151 if (files[i].filename == NULL) 2152 { 2153 /* Prevent a crash later, particularly for file 1. DWARF5 2154 uses slot zero, but that is only set explicitly using a 2155 .file 0 directive. If that isn't used, but file 1 is, 2156 then use that as main file name. */ 2157 if (DWARF2_LINE_VERSION >= 5 && i == 0 && files_in_use >= 1) 2158 files[0].filename = files[1].filename; 2159 else 2160 files[i].filename = ""; 2161 if (DWARF2_LINE_VERSION < 5 || i != 0) 2162 { 2163 as_bad (_("unassigned file number %ld"), (long) i); 2164 continue; 2165 } 2166 } 2167 2168 fullfilename = DWARF2_FILE_NAME (files[i].filename, 2169 files[i].dir ? dirs [files [i].dir] : ""); 2170 if (DWARF2_LINE_VERSION < 5) 2171 { 2172 size = strlen (fullfilename) + 1; 2173 cp = frag_more (size); 2174 memcpy (cp, fullfilename, size); 2175 } 2176 else 2177 { 2178 line_strp = add_line_strp (line_str_seg, fullfilename); 2179 subseg_set (line_seg, 0); 2180 TC_DWARF2_EMIT_OFFSET (line_strp, sizeof_offset); 2181 } 2182 2183 /* Directory number. */ 2184 out_uleb128 (files[i].dir); 2185 2186 /* Output the last modification timestamp. */ 2187 if (emit_timestamps) 2188 { 2189 offsetT timestamp; 2190 2191 timestamp = DWARF2_FILE_TIME_NAME (files[i].filename, 2192 files[i].dir ? dirs [files [i].dir] : ""); 2193 if (timestamp == -1) 2194 timestamp = 0; 2195 out_uleb128 (timestamp); 2196 } 2197 2198 /* Output the filesize. */ 2199 if (emit_filesize) 2200 { 2201 offsetT filesize; 2202 filesize = DWARF2_FILE_SIZE_NAME (files[i].filename, 2203 files[i].dir ? dirs [files [i].dir] : ""); 2204 if (filesize == -1) 2205 filesize = 0; 2206 out_uleb128 (filesize); 2207 } 2208 2209 /* Output the md5 sum. */ 2210 if (emit_md5) 2211 { 2212 int b; 2213 2214 for (b = 0; b < NUM_MD5_BYTES; b++) 2215 out_byte (files[i].md5[b]); 2216 } 2217 } 2218 2219 if (DWARF2_LINE_VERSION < 5) 2220 /* Terminate filename list. */ 2221 out_byte (0); 2222} 2223 2224/* Switch to SEC and output a header length field. Return the size of 2225 offsets used in SEC. The caller must set EXPR->X_add_symbol value 2226 to the end of the section. EXPR->X_add_number will be set to the 2227 negative size of the header. */ 2228 2229static int 2230out_header (asection *sec, expressionS *exp) 2231{ 2232 symbolS *start_sym; 2233 symbolS *end_sym; 2234 2235 subseg_set (sec, 0); 2236 2237 if (flag_dwarf_sections) 2238 { 2239 /* If we are going to put the start and end symbols in different 2240 sections, then we need real symbols, not just fake, local ones. */ 2241 frag_now_fix (); 2242 start_sym = symbol_make (".Ldebug_line_start"); 2243 end_sym = symbol_make (".Ldebug_line_end"); 2244 symbol_set_value_now (start_sym); 2245 } 2246 else 2247 { 2248 start_sym = symbol_temp_new_now_octets (); 2249 end_sym = symbol_temp_make (); 2250 } 2251 2252 /* Total length of the information. */ 2253 exp->X_op = O_subtract; 2254 exp->X_add_symbol = end_sym; 2255 exp->X_op_symbol = start_sym; 2256 2257 switch (DWARF2_FORMAT (sec)) 2258 { 2259 case dwarf2_format_32bit: 2260 exp->X_add_number = -4; 2261 emit_expr (exp, 4); 2262 return 4; 2263 2264 case dwarf2_format_64bit: 2265 exp->X_add_number = -12; 2266 out_four (-1); 2267 emit_expr (exp, 8); 2268 return 8; 2269 2270 case dwarf2_format_64bit_irix: 2271 exp->X_add_number = -8; 2272 emit_expr (exp, 8); 2273 return 8; 2274 } 2275 2276 as_fatal (_("internal error: unknown dwarf2 format")); 2277 return 0; 2278} 2279 2280/* Emit the collected .debug_line data. */ 2281 2282static void 2283out_debug_line (segT line_seg) 2284{ 2285 expressionS exp; 2286 symbolS *prologue_start, *prologue_end; 2287 symbolS *line_end; 2288 struct line_seg *s; 2289 int sizeof_offset; 2290 2291 memset (&exp, 0, sizeof exp); 2292 sizeof_offset = out_header (line_seg, &exp); 2293 line_end = exp.X_add_symbol; 2294 2295 /* Version. */ 2296 out_two (DWARF2_LINE_VERSION); 2297 2298 if (DWARF2_LINE_VERSION >= 5) 2299 { 2300 out_byte (sizeof_address); 2301 out_byte (0); /* Segment Selector size. */ 2302 } 2303 /* Length of the prologue following this length. */ 2304 prologue_start = symbol_temp_make (); 2305 prologue_end = symbol_temp_make (); 2306 exp.X_op = O_subtract; 2307 exp.X_add_symbol = prologue_end; 2308 exp.X_op_symbol = prologue_start; 2309 exp.X_add_number = 0; 2310 emit_expr (&exp, sizeof_offset); 2311 symbol_set_value_now (prologue_start); 2312 2313 /* Parameters of the state machine. */ 2314 out_byte (DWARF2_LINE_MIN_INSN_LENGTH); 2315 if (DWARF2_LINE_VERSION >= 4) 2316 out_byte (DWARF2_LINE_MAX_OPS_PER_INSN); 2317 out_byte (DWARF2_LINE_DEFAULT_IS_STMT); 2318 out_byte (DWARF2_LINE_BASE); 2319 out_byte (DWARF2_LINE_RANGE); 2320 out_byte (DWARF2_LINE_OPCODE_BASE); 2321 2322 /* Standard opcode lengths. */ 2323 out_byte (0); /* DW_LNS_copy */ 2324 out_byte (1); /* DW_LNS_advance_pc */ 2325 out_byte (1); /* DW_LNS_advance_line */ 2326 out_byte (1); /* DW_LNS_set_file */ 2327 out_byte (1); /* DW_LNS_set_column */ 2328 out_byte (0); /* DW_LNS_negate_stmt */ 2329 out_byte (0); /* DW_LNS_set_basic_block */ 2330 out_byte (0); /* DW_LNS_const_add_pc */ 2331 out_byte (1); /* DW_LNS_fixed_advance_pc */ 2332 out_byte (0); /* DW_LNS_set_prologue_end */ 2333 out_byte (0); /* DW_LNS_set_epilogue_begin */ 2334 out_byte (1); /* DW_LNS_set_isa */ 2335 /* We have emitted 12 opcode lengths, so make that this 2336 matches up to the opcode base value we have been using. */ 2337 gas_assert (DWARF2_LINE_OPCODE_BASE == 13); 2338 2339 out_dir_and_file_list (line_seg, sizeof_offset); 2340 2341 symbol_set_value_now (prologue_end); 2342 2343 /* For each section, emit a statement program. */ 2344 for (s = all_segs; s; s = s->next) 2345 if (SEG_NORMAL (s->seg)) 2346 process_entries (s->seg, s->head->head); 2347 else 2348 as_warn ("dwarf line number information for %s ignored", 2349 segment_name (s->seg)); 2350 2351 if (flag_dwarf_sections) 2352 /* We have to switch to the special .debug_line_end section 2353 before emitting the end-of-debug_line symbol. The linker 2354 script arranges for this section to be placed after all the 2355 (potentially garbage collected) .debug_line.<foo> sections. 2356 This section contains the line_end symbol which is used to 2357 compute the size of the linked .debug_line section, as seen 2358 in the DWARF Line Number header. */ 2359 subseg_set (subseg_get (".debug_line_end", FALSE), 0); 2360 2361 symbol_set_value_now (line_end); 2362} 2363 2364static void 2365out_debug_ranges (segT ranges_seg, symbolS **ranges_sym) 2366{ 2367 unsigned int addr_size = sizeof_address; 2368 struct line_seg *s; 2369 expressionS exp; 2370 unsigned int i; 2371 2372 memset (&exp, 0, sizeof exp); 2373 subseg_set (ranges_seg, 0); 2374 2375 /* For DW_AT_ranges to point at (there is no header, so really start 2376 of section, but see out_debug_rnglists). */ 2377 *ranges_sym = symbol_temp_new_now_octets (); 2378 2379 /* Base Address Entry. */ 2380 for (i = 0; i < addr_size; i++) 2381 out_byte (0xff); 2382 for (i = 0; i < addr_size; i++) 2383 out_byte (0); 2384 2385 /* Range List Entry. */ 2386 for (s = all_segs; s; s = s->next) 2387 { 2388 fragS *frag; 2389 symbolS *beg, *end; 2390 2391 frag = first_frag_for_seg (s->seg); 2392 beg = symbol_temp_new (s->seg, frag, 0); 2393 s->text_start = beg; 2394 2395 frag = last_frag_for_seg (s->seg); 2396 end = symbol_temp_new (s->seg, frag, get_frag_fix (frag, s->seg)); 2397 s->text_end = end; 2398 2399 exp.X_op = O_symbol; 2400 exp.X_add_symbol = beg; 2401 exp.X_add_number = 0; 2402 emit_expr (&exp, addr_size); 2403 2404 exp.X_op = O_symbol; 2405 exp.X_add_symbol = end; 2406 exp.X_add_number = 0; 2407 emit_expr (&exp, addr_size); 2408 } 2409 2410 /* End of Range Entry. */ 2411 for (i = 0; i < addr_size; i++) 2412 out_byte (0); 2413 for (i = 0; i < addr_size; i++) 2414 out_byte (0); 2415} 2416 2417static void 2418out_debug_rnglists (segT ranges_seg, symbolS **ranges_sym) 2419{ 2420 expressionS exp; 2421 symbolS *ranges_end; 2422 struct line_seg *s; 2423 2424 /* Unit length. */ 2425 memset (&exp, 0, sizeof exp); 2426 out_header (ranges_seg, &exp); 2427 ranges_end = exp.X_add_symbol; 2428 2429 out_two (DWARF2_RNGLISTS_VERSION); 2430 out_byte (sizeof_address); 2431 out_byte (0); /* Segment Selector size. */ 2432 out_four (0); /* Offset entry count. */ 2433 2434 /* For DW_AT_ranges to point at (must be after the header). */ 2435 *ranges_sym = symbol_temp_new_now_octets (); 2436 2437 for (s = all_segs; s; s = s->next) 2438 { 2439 fragS *frag; 2440 symbolS *beg, *end; 2441 2442 out_byte (DW_RLE_start_length); 2443 2444 frag = first_frag_for_seg (s->seg); 2445 beg = symbol_temp_new (s->seg, frag, 0); 2446 s->text_start = beg; 2447 2448 frag = last_frag_for_seg (s->seg); 2449 end = symbol_temp_new (s->seg, frag, get_frag_fix (frag, s->seg)); 2450 s->text_end = end; 2451 2452 exp.X_op = O_symbol; 2453 exp.X_add_symbol = beg; 2454 exp.X_add_number = 0; 2455 emit_expr (&exp, sizeof_address); 2456 2457 exp.X_op = O_symbol; 2458 exp.X_add_symbol = end; 2459 exp.X_add_number = 0; 2460 emit_leb128_expr (&exp, 0); 2461 } 2462 2463 out_byte (DW_RLE_end_of_list); 2464 2465 symbol_set_value_now (ranges_end); 2466} 2467 2468/* Emit data for .debug_aranges. */ 2469 2470static void 2471out_debug_aranges (segT aranges_seg, segT info_seg) 2472{ 2473 unsigned int addr_size = sizeof_address; 2474 offsetT size; 2475 struct line_seg *s; 2476 expressionS exp; 2477 symbolS *aranges_end; 2478 char *p; 2479 int sizeof_offset; 2480 2481 memset (&exp, 0, sizeof exp); 2482 sizeof_offset = out_header (aranges_seg, &exp); 2483 aranges_end = exp.X_add_symbol; 2484 size = -exp.X_add_number; 2485 2486 /* Version. */ 2487 out_two (DWARF2_ARANGES_VERSION); 2488 size += 2; 2489 2490 /* Offset to .debug_info. */ 2491 TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset); 2492 size += sizeof_offset; 2493 2494 /* Size of an address (offset portion). */ 2495 out_byte (addr_size); 2496 size++; 2497 2498 /* Size of a segment descriptor. */ 2499 out_byte (0); 2500 size++; 2501 2502 /* Align the header. */ 2503 while ((size++ % (2 * addr_size)) > 0) 2504 out_byte (0); 2505 2506 for (s = all_segs; s; s = s->next) 2507 { 2508 fragS *frag; 2509 symbolS *beg, *end; 2510 2511 frag = first_frag_for_seg (s->seg); 2512 beg = symbol_temp_new (s->seg, frag, 0); 2513 s->text_start = beg; 2514 2515 frag = last_frag_for_seg (s->seg); 2516 end = symbol_temp_new (s->seg, frag, get_frag_fix (frag, s->seg)); 2517 s->text_end = end; 2518 2519 exp.X_op = O_symbol; 2520 exp.X_add_symbol = beg; 2521 exp.X_add_number = 0; 2522 emit_expr (&exp, addr_size); 2523 2524 exp.X_op = O_subtract; 2525 exp.X_add_symbol = end; 2526 exp.X_op_symbol = beg; 2527 exp.X_add_number = 0; 2528 emit_expr (&exp, addr_size); 2529 } 2530 2531 p = frag_more (2 * addr_size); 2532 md_number_to_chars (p, 0, addr_size); 2533 md_number_to_chars (p + addr_size, 0, addr_size); 2534 2535 symbol_set_value_now (aranges_end); 2536} 2537 2538/* Emit data for .debug_abbrev. Note that this must be kept in 2539 sync with out_debug_info below. */ 2540 2541static void 2542out_debug_abbrev (segT abbrev_seg, 2543 segT info_seg ATTRIBUTE_UNUSED, 2544 segT line_seg ATTRIBUTE_UNUSED) 2545{ 2546 int secoff_form; 2547 subseg_set (abbrev_seg, 0); 2548 2549 out_uleb128 (1); 2550 out_uleb128 (DW_TAG_compile_unit); 2551 out_byte (DW_CHILDREN_no); 2552 if (DWARF2_VERSION < 4) 2553 { 2554 if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit) 2555 secoff_form = DW_FORM_data4; 2556 else 2557 secoff_form = DW_FORM_data8; 2558 } 2559 else 2560 secoff_form = DW_FORM_sec_offset; 2561 out_abbrev (DW_AT_stmt_list, secoff_form); 2562 if (all_segs->next == NULL) 2563 { 2564 out_abbrev (DW_AT_low_pc, DW_FORM_addr); 2565 if (DWARF2_VERSION < 4) 2566 out_abbrev (DW_AT_high_pc, DW_FORM_addr); 2567 else 2568 out_abbrev (DW_AT_high_pc, DW_FORM_udata); 2569 } 2570 else 2571 out_abbrev (DW_AT_ranges, secoff_form); 2572 out_abbrev (DW_AT_name, DW_FORM_strp); 2573 out_abbrev (DW_AT_comp_dir, DW_FORM_strp); 2574 out_abbrev (DW_AT_producer, DW_FORM_strp); 2575 out_abbrev (DW_AT_language, DW_FORM_data2); 2576 out_abbrev (0, 0); 2577 2578 /* Terminate the abbreviations for this compilation unit. */ 2579 out_byte (0); 2580} 2581 2582/* Emit a description of this compilation unit for .debug_info. */ 2583 2584static void 2585out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, 2586 symbolS *ranges_sym, symbolS *name_sym, 2587 symbolS *comp_dir_sym, symbolS *producer_sym) 2588{ 2589 expressionS exp; 2590 symbolS *info_end; 2591 int sizeof_offset; 2592 2593 memset (&exp, 0, sizeof exp); 2594 sizeof_offset = out_header (info_seg, &exp); 2595 info_end = exp.X_add_symbol; 2596 2597 /* DWARF version. */ 2598 out_two (DWARF2_VERSION); 2599 2600 if (DWARF2_VERSION < 5) 2601 { 2602 /* .debug_abbrev offset */ 2603 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset); 2604 } 2605 else 2606 { 2607 /* unit (header) type */ 2608 out_byte (DW_UT_compile); 2609 } 2610 2611 /* Target address size. */ 2612 out_byte (sizeof_address); 2613 2614 if (DWARF2_VERSION >= 5) 2615 { 2616 /* .debug_abbrev offset */ 2617 TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset); 2618 } 2619 2620 /* DW_TAG_compile_unit DIE abbrev */ 2621 out_uleb128 (1); 2622 2623 /* DW_AT_stmt_list */ 2624 TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), 2625 (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit 2626 ? 4 : 8)); 2627 2628 /* These two attributes are emitted if all of the code is contiguous. */ 2629 if (all_segs->next == NULL) 2630 { 2631 /* DW_AT_low_pc */ 2632 exp.X_op = O_symbol; 2633 exp.X_add_symbol = all_segs->text_start; 2634 exp.X_add_number = 0; 2635 emit_expr (&exp, sizeof_address); 2636 2637 /* DW_AT_high_pc */ 2638 if (DWARF2_VERSION < 4) 2639 exp.X_op = O_symbol; 2640 else 2641 { 2642 exp.X_op = O_subtract; 2643 exp.X_op_symbol = all_segs->text_start; 2644 } 2645 exp.X_add_symbol = all_segs->text_end; 2646 exp.X_add_number = 0; 2647 if (DWARF2_VERSION < 4) 2648 emit_expr (&exp, sizeof_address); 2649 else 2650 emit_leb128_expr (&exp, 0); 2651 } 2652 else 2653 { 2654 /* This attribute is emitted if the code is disjoint. */ 2655 /* DW_AT_ranges. */ 2656 TC_DWARF2_EMIT_OFFSET (ranges_sym, sizeof_offset); 2657 } 2658 2659 /* DW_AT_name, DW_AT_comp_dir and DW_AT_producer. Symbols in .debug_str 2660 setup in out_debug_str below. */ 2661 TC_DWARF2_EMIT_OFFSET (name_sym, sizeof_offset); 2662 TC_DWARF2_EMIT_OFFSET (comp_dir_sym, sizeof_offset); 2663 TC_DWARF2_EMIT_OFFSET (producer_sym, sizeof_offset); 2664 2665 /* DW_AT_language. Yes, this is probably not really MIPS, but the 2666 dwarf2 draft has no standard code for assembler. */ 2667 out_two (DW_LANG_Mips_Assembler); 2668 2669 symbol_set_value_now (info_end); 2670} 2671 2672/* Emit the three debug strings needed in .debug_str and setup symbols 2673 to them for use in out_debug_info. */ 2674static void 2675out_debug_str (segT str_seg, symbolS **name_sym, symbolS **comp_dir_sym, 2676 symbolS **producer_sym) 2677{ 2678 char producer[128]; 2679 const char *comp_dir; 2680 const char *dirname; 2681 char *p; 2682 int len; 2683 int first_file = DWARF2_LINE_VERSION > 4 ? 0 : 1; 2684 2685 subseg_set (str_seg, 0); 2686 2687 /* DW_AT_name. We don't have the actual file name that was present 2688 on the command line, so assume files[first_file] is the main input file. 2689 We're not supposed to get called unless at least one line number 2690 entry was emitted, so this should always be defined. */ 2691 *name_sym = symbol_temp_new_now_octets (); 2692 if (files_in_use == 0) 2693 abort (); 2694 if (files[first_file].dir) 2695 { 2696 dirname = remap_debug_filename (dirs[files[first_file].dir]); 2697 len = strlen (dirname); 2698#ifdef TE_VMS 2699 /* Already has trailing slash. */ 2700 p = frag_more (len); 2701 memcpy (p, dirname, len); 2702#else 2703 p = frag_more (len + 1); 2704 memcpy (p, dirname, len); 2705 INSERT_DIR_SEPARATOR (p, len); 2706#endif 2707 } 2708 len = strlen (files[first_file].filename) + 1; 2709 p = frag_more (len); 2710 memcpy (p, files[first_file].filename, len); 2711 2712 /* DW_AT_comp_dir */ 2713 *comp_dir_sym = symbol_temp_new_now_octets (); 2714 comp_dir = remap_debug_filename (getpwd ()); 2715 len = strlen (comp_dir) + 1; 2716 p = frag_more (len); 2717 memcpy (p, comp_dir, len); 2718 2719 /* DW_AT_producer */ 2720 *producer_sym = symbol_temp_new_now_octets (); 2721 sprintf (producer, "GNU AS %s", VERSION); 2722 len = strlen (producer) + 1; 2723 p = frag_more (len); 2724 memcpy (p, producer, len); 2725} 2726 2727void 2728dwarf2_init (void) 2729{ 2730 last_seg_ptr = &all_segs; 2731 2732 /* Select the default CIE version to produce here. The global 2733 starts with a value of -1 and will be modified to a valid value 2734 either by the user providing a command line option, or some 2735 targets will select their own default in md_after_parse_args. If 2736 we get here and the global still contains -1 then it is up to us 2737 to pick a sane default. The default we choose is 1, this is the 2738 CIE version gas has produced for a long time, and there seems no 2739 reason to change it yet. */ 2740 if (flag_dwarf_cie_version == -1) 2741 flag_dwarf_cie_version = 1; 2742} 2743 2744 2745/* Finish the dwarf2 debug sections. We emit .debug.line if there 2746 were any .file/.loc directives, or --gdwarf2 was given, and if the 2747 file has a non-empty .debug_info section and an empty .debug_line 2748 section. If we emit .debug_line, and the .debug_info section is 2749 empty, we also emit .debug_info, .debug_aranges and .debug_abbrev. 2750 ALL_SEGS will be non-null if there were any .file/.loc directives, 2751 or --gdwarf2 was given and there were any located instructions 2752 emitted. */ 2753 2754void 2755dwarf2_finish (void) 2756{ 2757 segT line_seg; 2758 struct line_seg *s; 2759 segT info_seg; 2760 int emit_other_sections = 0; 2761 int empty_debug_line = 0; 2762 2763 info_seg = bfd_get_section_by_name (stdoutput, ".debug_info"); 2764 emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg); 2765 2766 line_seg = bfd_get_section_by_name (stdoutput, ".debug_line"); 2767 empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg); 2768 2769 /* We can't construct a new debug_line section if we already have one. 2770 Give an error if we have seen any .loc, otherwise trust the user 2771 knows what they are doing and want to generate the .debug_line 2772 (and all other debug sections) themselves. */ 2773 if (all_segs && !empty_debug_line && dwarf2_any_loc_directive_seen) 2774 as_fatal ("duplicate .debug_line sections"); 2775 2776 if ((!all_segs && emit_other_sections) 2777 || (!emit_other_sections && !empty_debug_line)) 2778 /* If there is no line information and no non-empty .debug_info 2779 section, or if there is both a non-empty .debug_info and a non-empty 2780 .debug_line, then we do nothing. */ 2781 return; 2782 2783 /* Calculate the size of an address for the target machine. */ 2784 sizeof_address = DWARF2_ADDR_SIZE (stdoutput); 2785 2786 /* Create and switch to the line number section. */ 2787 if (empty_debug_line) 2788 { 2789 line_seg = subseg_new (".debug_line", 0); 2790 bfd_set_section_flags (line_seg, 2791 SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS); 2792 } 2793 2794 /* For each subsection, chain the debug entries together. */ 2795 for (s = all_segs; s; s = s->next) 2796 { 2797 struct line_subseg *lss = s->head; 2798 struct line_entry **ptail = lss->ptail; 2799 2800 /* Reset the initial view of the first subsection of the 2801 section. */ 2802 if (lss->head && lss->head->loc.view) 2803 set_or_check_view (lss->head, NULL, NULL); 2804 2805 while ((lss = lss->next) != NULL) 2806 { 2807 /* Link the first view of subsequent subsections to the 2808 previous view. */ 2809 if (lss->head && lss->head->loc.view) 2810 set_or_check_view (lss->head, 2811 !s->head ? NULL : (struct line_entry *)ptail, 2812 s->head ? s->head->head : NULL); 2813 *ptail = lss->head; 2814 ptail = lss->ptail; 2815 } 2816 } 2817 2818 if (empty_debug_line) 2819 out_debug_line (line_seg); 2820 2821 /* If this is assembler generated line info, and there is no 2822 debug_info already, we need .debug_info, .debug_abbrev and 2823 .debug_str sections as well. */ 2824 if (emit_other_sections) 2825 { 2826 segT abbrev_seg; 2827 segT aranges_seg; 2828 segT str_seg; 2829 symbolS *name_sym, *comp_dir_sym, *producer_sym, *ranges_sym; 2830 2831 gas_assert (all_segs); 2832 2833 info_seg = subseg_new (".debug_info", 0); 2834 abbrev_seg = subseg_new (".debug_abbrev", 0); 2835 aranges_seg = subseg_new (".debug_aranges", 0); 2836 str_seg = subseg_new (".debug_str", 0); 2837 2838 bfd_set_section_flags (info_seg, 2839 SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS); 2840 bfd_set_section_flags (abbrev_seg, 2841 SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS); 2842 bfd_set_section_flags (aranges_seg, 2843 SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS); 2844 bfd_set_section_flags (str_seg, 2845 SEC_READONLY | SEC_DEBUGGING | SEC_OCTETS 2846 | SEC_MERGE | SEC_STRINGS); 2847 str_seg->entsize = 1; 2848 2849 record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1); 2850 2851 if (all_segs->next == NULL) 2852 ranges_sym = NULL; 2853 else 2854 { 2855 if (DWARF2_VERSION < 5) 2856 { 2857 segT ranges_seg = subseg_new (".debug_ranges", 0); 2858 bfd_set_section_flags (ranges_seg, (SEC_READONLY 2859 | SEC_DEBUGGING 2860 | SEC_OCTETS)); 2861 record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1); 2862 out_debug_ranges (ranges_seg, &ranges_sym); 2863 } 2864 else 2865 { 2866 segT rnglists_seg = subseg_new (".debug_rnglists", 0); 2867 bfd_set_section_flags (rnglists_seg, (SEC_READONLY 2868 | SEC_DEBUGGING 2869 | SEC_OCTETS)); 2870 out_debug_rnglists (rnglists_seg, &ranges_sym); 2871 } 2872 } 2873 2874 out_debug_aranges (aranges_seg, info_seg); 2875 out_debug_abbrev (abbrev_seg, info_seg, line_seg); 2876 out_debug_str (str_seg, &name_sym, &comp_dir_sym, &producer_sym); 2877 out_debug_info (info_seg, abbrev_seg, line_seg, ranges_sym, 2878 name_sym, comp_dir_sym, producer_sym); 2879 } 2880} 2881 2882/* Perform any deferred checks pertaining to debug information. */ 2883 2884void 2885dwarf2dbg_final_check (void) 2886{ 2887 /* Perform reset-view checks. Don't evaluate view_assert_failed 2888 recursively: it could be very deep. It's a chain of adds, with 2889 each chain element pointing to the next in X_add_symbol, and 2890 holding the check value in X_op_symbol. */ 2891 while (view_assert_failed) 2892 { 2893 expressionS *exp; 2894 symbolS *sym; 2895 offsetT failed; 2896 2897 gas_assert (!symbol_resolved_p (view_assert_failed)); 2898 2899 exp = symbol_get_value_expression (view_assert_failed); 2900 sym = view_assert_failed; 2901 2902 /* If view_assert_failed looks like a compound check in the 2903 chain, break it up. */ 2904 if (exp->X_op == O_add && exp->X_add_number == 0 && exp->X_unsigned) 2905 { 2906 view_assert_failed = exp->X_add_symbol; 2907 sym = exp->X_op_symbol; 2908 } 2909 else 2910 view_assert_failed = NULL; 2911 2912 failed = resolve_symbol_value (sym); 2913 if (!symbol_resolved_p (sym) || failed) 2914 { 2915 as_bad (_("view number mismatch")); 2916 break; 2917 } 2918 } 2919} 2920