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