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