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