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