gas/dwarf2dbg.c

   1 /* dwarf2dbg.c - DWARF2 debug support
   2    Copyright 1999, 2000, 2001 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 #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
  99 struct line_entry {
 100   struct line_entry *next;
 101   fragS *frag;
 102   addressT frag_ofs;
 103   struct dwarf2_line_info loc;
 104 };
 105
 106 struct line_subseg {
 107   struct line_subseg *next;
 108   subsegT subseg;
 109   struct line_entry *head;
 110   struct line_entry **ptail;
 111 };
 112
 113 struct 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.  */
 122 static struct line_seg *all_segs;
 123
 124 struct file_entry {
 125   char *filename;
 126   unsigned int dir;
 127 };
 128
 129 /* Table of files used by .debug_line.  */
 130 static struct file_entry *files;
 131 static unsigned int files_in_use;
 132 static 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.  */
 136 static boolean loc_directive_seen;
 137
 138 /* Current location as indicated by the most recent .loc directive.  */
 139 static struct dwarf2_line_info current;
 140
 141 /* Fake label name.  */
 142 static char const fake_label_name[] = ".L0\001";
 143
 144 /* The size of an address on the target.  */
 145 static unsigned int sizeof_address;
 146 \f
 147 static struct line_subseg *get_line_subseg PARAMS ((segT, subsegT));
 148 static unsigned int get_filenum PARAMS ((const char *));
 149 static struct frag *first_frag_for_seg PARAMS ((segT));
 150 static struct frag *last_frag_for_seg PARAMS ((segT));
 151 static void out_byte PARAMS ((int));
 152 static void out_opcode PARAMS ((int));
 153 static void out_two PARAMS ((int));
 154 static void out_four PARAMS ((int));
 155 static void out_abbrev PARAMS ((int, int));
 156 static void out_uleb128 PARAMS ((addressT));
 157 static symbolS *symbol_new_now PARAMS ((void));
 158 static void set_symbol_value_now PARAMS ((symbolS *));
 159 static offsetT get_frag_fix PARAMS ((fragS *));
 160 static void out_set_addr PARAMS ((segT, fragS *, addressT));
 161 static int size_inc_line_addr PARAMS ((int, addressT));
 162 static void emit_inc_line_addr PARAMS ((int, addressT, char *, int));
 163 static void out_inc_line_addr PARAMS ((int, addressT));
 164 static void relax_inc_line_addr PARAMS ((int, segT, fragS *, addressT,
 165                                          fragS *, addressT));
 166 static void process_entries PARAMS ((segT, struct line_entry *));
 167 static void out_file_list PARAMS ((void));
 168 static void out_debug_line PARAMS ((segT));
 169 static void out_debug_aranges PARAMS ((segT, segT));
 170 static void out_debug_abbrev PARAMS ((segT));
 171 static void out_debug_info PARAMS ((segT, segT, segT));
 172 \f
 173 /* Find or create an entry for SEG+SUBSEG in ALL_SEGS.  */
 174
 175 static struct line_subseg *
 176 get_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
 226 void
 227 dwarf2_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
 262 void
 263 dwarf2_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
 283 void
 284 dwarf2_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
 313 static unsigned int
 314 get_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 the .file directive.  */
 348
 349 void
 350 dwarf2_directive_file (dummy)
 351      int dummy ATTRIBUTE_UNUSED;
 352 {
 353   offsetT num;
 354   char *filename;
 355   int filename_len;
 356
 357   /* Continue to accept a bare string and pass it off.  */
 358   SKIP_WHITESPACE ();
 359   if (*input_line_pointer == '"')
 360     {
 361       s_app_file (0);
 362       return;
 363     }
 364
 365   num = get_absolute_expression ();
 366   filename = demand_copy_C_string (&filename_len);
 367   demand_empty_rest_of_line ();
 368
 369   if (num < 1)
 370     {
 371       as_bad (_("file number less than one"));
 372       return;
 373     }
 374
 375   if (num < (int) files_in_use && files[num].filename != 0)
 376     {
 377       as_bad (_("file number %ld already allocated"), (long) num);
 378       return;
 379     }
 380
 381   if (num >= (int) files_allocated)
 382     {
 383       unsigned int old = files_allocated;
 384
 385       files_allocated = num + 16;
 386       files = (struct file_entry *)
 387         xrealloc (files, (num + 16) * sizeof (struct file_entry));
 388
 389       /* Zero the new memory.  */
 390       memset (files + old, 0, (num + 16 - old) * sizeof (struct file_entry));
 391     }
 392
 393   files[num].filename = filename;
 394   files[num].dir = 0;
 395   files_in_use = num + 1;
 396 }
 397
 398 void
 399 dwarf2_directive_loc (dummy)
 400      int dummy ATTRIBUTE_UNUSED;
 401 {
 402   offsetT filenum, line, column;
 403
 404   filenum = get_absolute_expression ();
 405   SKIP_WHITESPACE ();
 406   line = get_absolute_expression ();
 407   SKIP_WHITESPACE ();
 408   column = get_absolute_expression ();
 409   demand_empty_rest_of_line ();
 410
 411   if (filenum < 1)
 412     {
 413       as_bad (_("file number less than one"));
 414       return;
 415     }
 416   if (filenum >= (int) files_in_use || files[filenum].filename == 0)
 417     {
 418       as_bad (_("unassigned file number %ld"), (long) filenum);
 419       return;
 420     }
 421
 422   current.filenum = filenum;
 423   current.line = line;
 424   current.column = column;
 425   current.flags = DWARF2_FLAG_BEGIN_STMT;
 426
 427   loc_directive_seen = true;
 428
 429 #ifndef NO_LISTING
 430   if (listing)
 431     {
 432       listing_source_file (files[filenum].filename);
 433       listing_source_line (line);
 434     }
 435 #endif
 436 }
 437 \f
 438 static struct frag *
 439 first_frag_for_seg (seg)
 440      segT seg;
 441 {
 442   frchainS *f, *first = NULL;
 443
 444   for (f = frchain_root; f; f = f->frch_next)
 445     if (f->frch_seg == seg
 446         && (! first || first->frch_subseg > f->frch_subseg))
 447       first = f;
 448
 449   return first ? first->frch_root : NULL;
 450 }
 451
 452 static struct frag *
 453 last_frag_for_seg (seg)
 454      segT seg;
 455 {
 456   frchainS *f, *last = NULL;
 457
 458   for (f = frchain_root; f; f = f->frch_next)
 459     if (f->frch_seg == seg
 460         && (! last || last->frch_subseg < f->frch_subseg))
 461       last= f;
 462
 463   return last ? last->frch_last : NULL;
 464 }
 465 \f
 466 /* Emit a single byte into the current segment.  */
 467
 468 static inline void
 469 out_byte (byte)
 470      int byte;
 471 {
 472   FRAG_APPEND_1_CHAR (byte);
 473 }
 474
 475 /* Emit a statement program opcode into the current segment.  */
 476
 477 static inline void
 478 out_opcode (opc)
 479      int opc;
 480 {
 481   out_byte (opc);
 482 }
 483
 484 /* Emit a two-byte word into the current segment.  */
 485
 486 static inline void
 487 out_two (data)
 488      int data;
 489 {
 490   md_number_to_chars (frag_more (2), data, 2);
 491 }
 492
 493 /* Emit a four byte word into the current segment.  */
 494
 495 static inline void
 496 out_four (data)
 497      int data;
 498 {
 499   md_number_to_chars (frag_more (4), data, 4);
 500 }
 501
 502 /* Emit an unsigned "little-endian base 128" number.  */
 503
 504 static void
 505 out_uleb128 (value)
 506      addressT value;
 507 {
 508   output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
 509 }
 510
 511 /* Emit a tuple for .debug_abbrev.  */
 512
 513 static inline void
 514 out_abbrev (name, form)
 515      int name, form;
 516 {
 517   out_uleb128 (name);
 518   out_uleb128 (form);
 519 }
 520
 521 /* Create a new fake symbol whose value is the current position.  */
 522
 523 static symbolS *
 524 symbol_new_now ()
 525 {
 526   return symbol_new (fake_label_name, now_seg, frag_now_fix (), frag_now);
 527 }
 528
 529 /* Set the value of SYM to the current position in the current segment.  */
 530
 531 static void
 532 set_symbol_value_now (sym)
 533      symbolS *sym;
 534 {
 535   S_SET_SEGMENT (sym, now_seg);
 536   S_SET_VALUE (sym, frag_now_fix ());
 537   symbol_set_frag (sym, frag_now);
 538 }
 539
 540 /* Get the size of a fragment.  */
 541
 542 static offsetT
 543 get_frag_fix (frag)
 544      fragS *frag;
 545 {
 546   frchainS *fr;
 547
 548   if (frag->fr_next)
 549     return frag->fr_fix;
 550
 551   /* If a fragment is the last in the chain, special measures must be
 552      taken to find its size before relaxation, since it may be pending
 553      on some subsegment chain.  */
 554   for (fr = frchain_root; fr; fr = fr->frch_next)
 555     if (fr->frch_last == frag)
 556       {
 557         long align_mask = -1 << get_recorded_alignment (fr->frch_seg);
 558         return (((char *) obstack_next_free (&fr->frch_obstack)
 559                  - frag->fr_literal) + ~align_mask) & align_mask;
 560       }
 561
 562   abort ();
 563 }
 564
 565 /* Set an absolute address (may result in a relocation entry).  */
 566
 567 static void
 568 out_set_addr (seg, frag, ofs)
 569      segT seg;
 570      fragS *frag;
 571      addressT ofs;
 572 {
 573   expressionS expr;
 574   symbolS *sym;
 575
 576   sym = symbol_new (fake_label_name, seg, ofs, frag);
 577
 578   out_opcode (DW_LNS_extended_op);
 579   out_uleb128 (sizeof_address + 1);
 580
 581   out_opcode (DW_LNE_set_address);
 582   expr.X_op = O_symbol;
 583   expr.X_add_symbol = sym;
 584   expr.X_add_number = 0;
 585   emit_expr (&expr, sizeof_address);
 586 }
 587
 588 /* Encode a pair of line and address skips as efficiently as possible.
 589    Note that the line skip is signed, whereas the address skip is unsigned.
 590
 591    The following two routines *must* be kept in sync.  This is
 592    enforced by making emit_inc_line_addr abort if we do not emit
 593    exactly the expected number of bytes.  */
 594
 595 static int
 596 size_inc_line_addr (line_delta, addr_delta)
 597      int line_delta;
 598      addressT addr_delta;
 599 {
 600   unsigned int tmp, opcode;
 601   int len = 0;
 602
 603   /* Scale the address delta by the minimum instruction length.  */
 604 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
 605   assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
 606   addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
 607 #endif
 608
 609   /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
 610      We cannot use special opcodes here, since we want the end_sequence
 611      to emit the matrix entry.  */
 612   if (line_delta == INT_MAX)
 613     {
 614       if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
 615         len = 1;
 616       else
 617         len = 1 + sizeof_leb128 (addr_delta, 0);
 618       return len + 3;
 619     }
 620
 621   /* Bias the line delta by the base.  */
 622   tmp = line_delta - DWARF2_LINE_BASE;
 623
 624   /* If the line increment is out of range of a special opcode, we
 625      must encode it with DW_LNS_advance_line.  */
 626   if (tmp >= DWARF2_LINE_RANGE)
 627     {
 628       len = 1 + sizeof_leb128 (line_delta, 1);
 629       line_delta = 0;
 630       tmp = 0 - DWARF2_LINE_BASE;
 631     }
 632
 633   /* Bias the opcode by the special opcode base.  */
 634   tmp += DWARF2_LINE_OPCODE_BASE;
 635
 636   /* Avoid overflow when addr_delta is large.  */
 637   if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
 638     {
 639       /* Try using a special opcode.  */
 640       opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
 641       if (opcode <= 255)
 642         return len + 1;
 643
 644       /* Try using DW_LNS_const_add_pc followed by special op.  */
 645       opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
 646       if (opcode <= 255)
 647         return len + 2;
 648     }
 649
 650   /* Otherwise use DW_LNS_advance_pc.  */
 651   len += 1 + sizeof_leb128 (addr_delta, 0);
 652
 653   /* DW_LNS_copy or special opcode.  */
 654   len += 1;
 655
 656   return len;
 657 }
 658
 659 static void
 660 emit_inc_line_addr (line_delta, addr_delta, p, len)
 661      int line_delta;
 662      addressT addr_delta;
 663      char *p;
 664      int len;
 665 {
 666   unsigned int tmp, opcode;
 667   int need_copy = 0;
 668   char *end = p + len;
 669
 670 #if DWARF2_LINE_MIN_INSN_LENGTH > 1
 671   /* Scale the address delta by the minimum instruction length.  */
 672   assert (addr_delta % DWARF2_LINE_MIN_INSN_LENGTH == 0);
 673   addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH;
 674 #endif
 675   /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence.
 676      We cannot use special opcodes here, since we want the end_sequence
 677      to emit the matrix entry.  */
 678   if (line_delta == INT_MAX)
 679     {
 680       if (addr_delta == MAX_SPECIAL_ADDR_DELTA)
 681         *p++ = DW_LNS_const_add_pc;
 682       else
 683         {
 684           *p++ = DW_LNS_advance_pc;
 685           p += output_leb128 (p, addr_delta, 0);
 686         }
 687
 688       *p++ = DW_LNS_extended_op;
 689       *p++ = 1;
 690       *p++ = DW_LNE_end_sequence;
 691       goto done;
 692     }
 693
 694   /* Bias the line delta by the base.  */
 695   tmp = line_delta - DWARF2_LINE_BASE;
 696
 697   /* If the line increment is out of range of a special opcode, we
 698      must encode it with DW_LNS_advance_line.  */
 699   if (tmp >= DWARF2_LINE_RANGE)
 700     {
 701       *p++ = DW_LNS_advance_line;
 702       p += output_leb128 (p, line_delta, 1);
 703
 704       /* Prettier, I think, to use DW_LNS_copy instead of a
 705          "line +0, addr +0" special opcode.  */
 706       if (addr_delta == 0)
 707         {
 708           *p++ = DW_LNS_copy;
 709           goto done;
 710         }
 711
 712       line_delta = 0;
 713       tmp = 0 - DWARF2_LINE_BASE;
 714       need_copy = 1;
 715     }
 716
 717   /* Bias the opcode by the special opcode base.  */
 718   tmp += DWARF2_LINE_OPCODE_BASE;
 719
 720   /* Avoid overflow when addr_delta is large.  */
 721   if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA)
 722     {
 723       /* Try using a special opcode.  */
 724       opcode = tmp + addr_delta * DWARF2_LINE_RANGE;
 725       if (opcode <= 255)
 726         {
 727           *p++ = opcode;
 728           goto done;
 729         }
 730
 731       /* Try using DW_LNS_const_add_pc followed by special op.  */
 732       opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE;
 733       if (opcode <= 255)
 734         {
 735           *p++ = DW_LNS_const_add_pc;
 736           *p++ = opcode;
 737           goto done;
 738         }
 739     }
 740
 741   /* Otherwise use DW_LNS_advance_pc.  */
 742   *p++ = DW_LNS_advance_pc;
 743   p += output_leb128 (p, addr_delta, 0);
 744
 745   if (need_copy)
 746     *p++ = DW_LNS_copy;
 747   else
 748     *p++ = tmp;
 749
 750  done:
 751   assert (p == end);
 752 }
 753
 754 /* Handy routine to combine calls to the above two routines.  */
 755
 756 static void
 757 out_inc_line_addr (line_delta, addr_delta)
 758      int line_delta;
 759      addressT addr_delta;
 760 {
 761   int len = size_inc_line_addr (line_delta, addr_delta);
 762   emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len);
 763 }
 764
 765 /* Generate a variant frag that we can use to relax address/line
 766    increments between fragments of the target segment.  */
 767
 768 static void
 769 relax_inc_line_addr (line_delta, seg, to_frag, to_ofs, from_frag, from_ofs)
 770      int line_delta;
 771      segT seg;
 772      fragS *to_frag, *from_frag;
 773      addressT to_ofs, from_ofs;
 774 {
 775   symbolS *to_sym, *from_sym;
 776   expressionS expr;
 777   int max_chars;
 778
 779   to_sym = symbol_new (fake_label_name, seg, to_ofs, to_frag);
 780   from_sym = symbol_new (fake_label_name, seg, from_ofs, from_frag);
 781
 782   expr.X_op = O_subtract;
 783   expr.X_add_symbol = to_sym;
 784   expr.X_op_symbol = from_sym;
 785   expr.X_add_number = 0;
 786
 787   /* The maximum size of the frag is the line delta with a maximum
 788      sized address delta.  */
 789   max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH);
 790
 791   frag_var (rs_dwarf2dbg, max_chars, max_chars, 1,
 792             make_expr_symbol (&expr), line_delta, NULL);
 793 }
 794
 795 /* The function estimates the size of a rs_dwarf2dbg variant frag
 796    based on the current values of the symbols.  It is called before
 797    the relaxation loop.  We set fr_subtype to the expected length.  */
 798
 799 int
 800 dwarf2dbg_estimate_size_before_relax (frag)
 801      fragS *frag;
 802 {
 803   offsetT addr_delta;
 804   int size;
 805
 806   addr_delta = resolve_symbol_value (frag->fr_symbol);
 807   size = size_inc_line_addr (frag->fr_offset, addr_delta);
 808
 809   frag->fr_subtype = size;
 810
 811   return size;
 812 }
 813
 814 /* This function relaxes a rs_dwarf2dbg variant frag based on the
 815    current values of the symbols.  fr_subtype is the current length
 816    of the frag.  This returns the change in frag length.  */
 817
 818 int
 819 dwarf2dbg_relax_frag (frag)
 820      fragS *frag;
 821 {
 822   int old_size, new_size;
 823
 824   old_size = frag->fr_subtype;
 825   new_size = dwarf2dbg_estimate_size_before_relax (frag);
 826
 827   return new_size - old_size;
 828 }
 829
 830 /* This function converts a rs_dwarf2dbg variant frag into a normal
 831    fill frag.  This is called after all relaxation has been done.
 832    fr_subtype will be the desired length of the frag.  */
 833
 834 void
 835 dwarf2dbg_convert_frag (frag)
 836      fragS *frag;
 837 {
 838   offsetT addr_diff;
 839
 840   addr_diff = resolve_symbol_value (frag->fr_symbol);
 841
 842   /* fr_var carries the max_chars that we created the fragment with.
 843      fr_subtype carries the current expected length.  We must, of
 844      course, have allocated enough memory earlier.  */
 845   assert (frag->fr_var >= (int) frag->fr_subtype);
 846
 847   emit_inc_line_addr (frag->fr_offset, addr_diff,
 848                       frag->fr_literal + frag->fr_fix, frag->fr_subtype);
 849
 850   frag->fr_fix += frag->fr_subtype;
 851   frag->fr_type = rs_fill;
 852   frag->fr_var = 0;
 853   frag->fr_offset = 0;
 854 }
 855
 856 /* Generate .debug_line content for the chain of line number entries
 857    beginning at E, for segment SEG.  */
 858
 859 static void
 860 process_entries (seg, e)
 861      segT seg;
 862      struct line_entry *e;
 863 {
 864   unsigned filenum = 1;
 865   unsigned line = 1;
 866   unsigned column = 0;
 867   unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_BEGIN_STMT : 0;
 868   fragS *frag = NULL;
 869   fragS *last_frag;
 870   addressT frag_ofs = 0;
 871   addressT last_frag_ofs;
 872   struct line_entry *next;
 873
 874   while (e)
 875     {
 876       int changed = 0;
 877
 878       if (filenum != e->loc.filenum)
 879         {
 880           filenum = e->loc.filenum;
 881           out_opcode (DW_LNS_set_file);
 882           out_uleb128 (filenum);
 883           changed = 1;
 884         }
 885
 886       if (column != e->loc.column)
 887         {
 888           column = e->loc.column;
 889           out_opcode (DW_LNS_set_column);
 890           out_uleb128 (column);
 891           changed = 1;
 892         }
 893
 894       if ((e->loc.flags ^ flags) & DWARF2_FLAG_BEGIN_STMT)
 895         {
 896           flags = e->loc.flags;
 897           out_opcode (DW_LNS_negate_stmt);
 898           changed = 1;
 899         }
 900
 901       if (e->loc.flags & DWARF2_FLAG_BEGIN_BLOCK)
 902         {
 903           out_opcode (DW_LNS_set_basic_block);
 904           changed = 1;
 905         }
 906
 907       /* Don't try to optimize away redundant entries; gdb wants two
 908          entries for a function where the code starts on the same line as
 909          the {, and there's no way to identify that case here.  Trust gcc
 910          to optimize appropriately.  */
 911       if (1 /* line != e->loc.line || changed */)
 912         {
 913           int line_delta = e->loc.line - line;
 914           if (frag == NULL)
 915             {
 916               out_set_addr (seg, e->frag, e->frag_ofs);
 917               out_inc_line_addr (line_delta, 0);
 918             }
 919           else if (frag == e->frag)
 920             out_inc_line_addr (line_delta, e->frag_ofs - frag_ofs);
 921           else
 922             relax_inc_line_addr (line_delta, seg, e->frag, e->frag_ofs,
 923                                  frag, frag_ofs);
 924
 925           frag = e->frag;
 926           frag_ofs = e->frag_ofs;
 927           line = e->loc.line;
 928         }
 929       else if (frag == NULL)
 930         {
 931           out_set_addr (seg, e->frag, e->frag_ofs);
 932           frag = e->frag;
 933           frag_ofs = e->frag_ofs;
 934         }
 935
 936       next = e->next;
 937       free (e);
 938       e = next;
 939     }
 940
 941   /* Emit a DW_LNE_end_sequence for the end of the section.  */
 942   last_frag = last_frag_for_seg (seg);
 943   last_frag_ofs = get_frag_fix (last_frag);
 944   if (frag == last_frag)
 945     out_inc_line_addr (INT_MAX, last_frag_ofs - frag_ofs);
 946   else
 947     relax_inc_line_addr (INT_MAX, seg, last_frag, last_frag_ofs,
 948                          frag, frag_ofs);
 949 }
 950
 951 /* Emit the directory and file tables for .debug_line.  */
 952
 953 static void
 954 out_file_list ()
 955 {
 956   size_t size;
 957   char *cp;
 958   unsigned int i;
 959
 960   /* Terminate directory list.  */
 961   out_byte ('\0');
 962
 963   for (i = 1; i < files_in_use; ++i)
 964     {
 965       if (files[i].filename == NULL)
 966         {
 967           as_bad (_("unassigned file number %ld"), (long) i);
 968           continue;
 969         }
 970
 971       size = strlen (files[i].filename) + 1;
 972       cp = frag_more (size);
 973       memcpy (cp, files[i].filename, size);
 974
 975       out_uleb128 (files[i].dir);       /* directory number */
 976       out_uleb128 (0);                  /* last modification timestamp */
 977       out_uleb128 (0);                  /* filesize */
 978     }
 979
 980   /* Terminate filename list.  */
 981   out_byte (0);
 982 }
 983
 984 /* Emit the collected .debug_line data.  */
 985
 986 static void
 987 out_debug_line (line_seg)
 988      segT line_seg;
 989 {
 990   expressionS expr;
 991   symbolS *line_start;
 992   symbolS *prologue_end;
 993   symbolS *line_end;
 994   struct line_seg *s;
 995
 996   subseg_set (line_seg, 0);
 997
 998   line_start = symbol_new_now ();
 999   prologue_end = symbol_make (fake_label_name);
1000   line_end = symbol_make (fake_label_name);
1001
1002   /* Total length of the information for this compilation unit.  */
1003   expr.X_op = O_subtract;
1004   expr.X_add_symbol = line_end;
1005   expr.X_op_symbol = line_start;
1006   expr.X_add_number = -4;
1007   emit_expr (&expr, 4);
1008
1009   /* Version.  */
1010   out_two (2);
1011
1012   /* Length of the prologue following this length.  */
1013   expr.X_op = O_subtract;
1014   expr.X_add_symbol = prologue_end;
1015   expr.X_op_symbol = line_start;
1016   expr.X_add_number = - (4 + 2 + 4);
1017   emit_expr (&expr, 4);
1018
1019   /* Parameters of the state machine.  */
1020   out_byte (DWARF2_LINE_MIN_INSN_LENGTH);
1021   out_byte (DWARF2_LINE_DEFAULT_IS_STMT);
1022   out_byte (DWARF2_LINE_BASE);
1023   out_byte (DWARF2_LINE_RANGE);
1024   out_byte (DWARF2_LINE_OPCODE_BASE);
1025
1026   /* Standard opcode lengths.  */
1027   out_byte (0);                 /* DW_LNS_copy */
1028   out_byte (1);                 /* DW_LNS_advance_pc */
1029   out_byte (1);                 /* DW_LNS_advance_line */
1030   out_byte (1);                 /* DW_LNS_set_file */
1031   out_byte (1);                 /* DW_LNS_set_column */
1032   out_byte (0);                 /* DW_LNS_negate_stmt */
1033   out_byte (0);                 /* DW_LNS_set_basic_block */
1034   out_byte (0);                 /* DW_LNS_const_add_pc */
1035   out_byte (1);                 /* DW_LNS_fixed_advance_pc */
1036
1037   out_file_list ();
1038
1039   set_symbol_value_now (prologue_end);
1040
1041   /* For each section, emit a statement program.  */
1042   for (s = all_segs; s; s = s->next)
1043     process_entries (s->seg, s->head->head);
1044
1045   set_symbol_value_now (line_end);
1046 }
1047
1048 /* Emit data for .debug_aranges.  */
1049
1050 static void
1051 out_debug_aranges (aranges_seg, info_seg)
1052      segT aranges_seg;
1053      segT info_seg;
1054 {
1055   unsigned int addr_size = sizeof_address;
1056   addressT size, skip;
1057   struct line_seg *s;
1058   expressionS expr;
1059   char *p;
1060
1061   size = 4 + 2 + 4 + 1 + 1;
1062
1063   skip = 2 * addr_size - (size & (2 * addr_size - 1));
1064   if (skip == 2 * addr_size)
1065     skip = 0;
1066   size += skip;
1067
1068   for (s = all_segs; s; s = s->next)
1069     size += 2 * addr_size;
1070
1071   size += 2 * addr_size;
1072
1073   subseg_set (aranges_seg, 0);
1074
1075   /* Length of the compilation unit.  */
1076   out_four (size - 4);
1077
1078   /* Version.  */
1079   out_two (2);
1080
1081   /* Offset to .debug_info.  */
1082   expr.X_op = O_symbol;
1083   expr.X_add_symbol = section_symbol (info_seg);
1084   expr.X_add_number = 0;
1085   emit_expr (&expr, 4);
1086
1087   /* Size of an address (offset portion).  */
1088   out_byte (addr_size);
1089
1090   /* Size of a segment descriptor.  */
1091   out_byte (0);
1092
1093   /* Align the header.  */
1094   if (skip)
1095     frag_align (ffs (2 * addr_size) - 1, 0, 0);
1096
1097   for (s = all_segs; s; s = s->next)
1098     {
1099       fragS *frag;
1100       symbolS *beg, *end;
1101
1102       frag = first_frag_for_seg (s->seg);
1103       beg = symbol_new (fake_label_name, s->seg, 0, frag);
1104       s->text_start = beg;
1105
1106       frag = last_frag_for_seg (s->seg);
1107       end = symbol_new (fake_label_name, s->seg, get_frag_fix (frag), frag);
1108       s->text_end = end;
1109
1110       expr.X_op = O_symbol;
1111       expr.X_add_symbol = beg;
1112       expr.X_add_number = 0;
1113       emit_expr (&expr, addr_size);
1114
1115       expr.X_op = O_subtract;
1116       expr.X_add_symbol = end;
1117       expr.X_op_symbol = beg;
1118       expr.X_add_number = 0;
1119       emit_expr (&expr, addr_size);
1120     }
1121
1122   p = frag_more (2 * addr_size);
1123   md_number_to_chars (p, 0, addr_size);
1124   md_number_to_chars (p + addr_size, 0, addr_size);
1125 }
1126
1127 /* Emit data for .debug_abbrev.  Note that this must be kept in
1128    sync with out_debug_info below.  */
1129
1130 static void
1131 out_debug_abbrev (abbrev_seg)
1132      segT abbrev_seg;
1133 {
1134   subseg_set (abbrev_seg, 0);
1135
1136   out_uleb128 (1);
1137   out_uleb128 (DW_TAG_compile_unit);
1138   out_byte (DW_CHILDREN_no);
1139   out_abbrev (DW_AT_stmt_list, DW_FORM_data4);
1140   if (all_segs->next == NULL)
1141     {
1142       out_abbrev (DW_AT_low_pc, DW_FORM_addr);
1143       out_abbrev (DW_AT_high_pc, DW_FORM_addr);
1144     }
1145   out_abbrev (DW_AT_comp_dir, DW_FORM_string);
1146   out_abbrev (DW_AT_producer, DW_FORM_string);
1147   out_abbrev (DW_AT_language, DW_FORM_data2);
1148   out_abbrev (0, 0);
1149
1150   /* Terminate the abbreviations for this compilation unit.  */
1151   out_byte (0);
1152 }
1153
1154 /* Emit a description of this compilation unit for .debug_info.  */
1155
1156 static void
1157 out_debug_info (info_seg, abbrev_seg, line_seg)
1158      segT info_seg;
1159      segT abbrev_seg;
1160      segT line_seg;
1161 {
1162   char producer[128];
1163   char *comp_dir;
1164   expressionS expr;
1165   symbolS *info_start;
1166   symbolS *info_end;
1167   char *p;
1168   int len;
1169
1170   subseg_set (info_seg, 0);
1171
1172   info_start = symbol_new_now ();
1173   info_end = symbol_make (fake_label_name);
1174
1175   /* Compilation Unit length.  */
1176   expr.X_op = O_subtract;
1177   expr.X_add_symbol = info_end;
1178   expr.X_op_symbol = info_start;
1179   expr.X_add_number = -4;
1180   emit_expr (&expr, 4);
1181
1182   /* DWARF version.  */
1183   out_two (2);
1184
1185   /* .debug_abbrev offset */
1186   expr.X_op = O_symbol;
1187   expr.X_add_symbol = section_symbol (abbrev_seg);
1188   expr.X_add_number = 0;
1189   emit_expr (&expr, 4);
1190
1191   /* Target address size.  */
1192   out_byte (sizeof_address);
1193
1194   /* DW_TAG_compile_unit DIE abbrev */
1195   out_uleb128 (1);
1196
1197   /* DW_AT_stmt_list */
1198   expr.X_op = O_symbol;
1199   expr.X_add_symbol = section_symbol (line_seg);
1200   expr.X_add_number = 0;
1201   emit_expr (&expr, 4);
1202
1203   /* These two attributes may only be emitted if all of the code is
1204      contiguous.  Multiple sections are not that.  */
1205   if (all_segs->next == NULL)
1206     {
1207       /* DW_AT_low_pc */
1208       expr.X_op = O_symbol;
1209       expr.X_add_symbol = all_segs->text_start;
1210       expr.X_add_number = 0;
1211       emit_expr (&expr, sizeof_address);
1212
1213       /* DW_AT_high_pc */
1214       expr.X_op = O_symbol;
1215       expr.X_add_symbol = all_segs->text_end;
1216       expr.X_add_number = 0;
1217       emit_expr (&expr, sizeof_address);
1218     }
1219
1220   /* DW_AT_comp_dir */
1221   comp_dir = getpwd ();
1222   len = strlen (comp_dir) + 1;
1223   p = frag_more (len);
1224   memcpy (p, comp_dir, len);
1225
1226   /* DW_AT_producer */
1227   sprintf (producer, "GNU AS %s", VERSION);
1228   len = strlen (producer) + 1;
1229   p = frag_more (len);
1230   memcpy (p, producer, len);
1231
1232   /* DW_AT_language.  Yes, this is probably not really MIPS, but the
1233      dwarf2 draft has no standard code for assembler.  */
1234   out_two (DW_LANG_Mips_Assembler);
1235
1236   set_symbol_value_now (info_end);
1237 }
1238
1239 void
1240 dwarf2_finish ()
1241 {
1242   segT line_seg;
1243   struct line_seg *s;
1244
1245   /* If no debug information was recorded, nothing to do.  */
1246   if (all_segs == NULL && files_in_use <= 1)
1247     return;
1248
1249   /* Calculate the size of an address for the target machine.  */
1250   sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1251
1252   /* Create and switch to the line number section.  */
1253   line_seg = subseg_new (".debug_line", 0);
1254   bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1255
1256   /* For each subsection, chain the debug entries together.  */
1257   for (s = all_segs; s; s = s->next)
1258     {
1259       struct line_subseg *ss = s->head;
1260       struct line_entry **ptail = ss->ptail;
1261
1262       while ((ss = ss->next) != NULL)
1263         {
1264           *ptail = ss->head;
1265           ptail = ss->ptail;
1266         }
1267     }
1268
1269   out_debug_line (line_seg);
1270
1271   /* If this is assembler generated line info, we need .debug_info
1272      and .debug_abbrev sections as well.  */
1273   if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1274     {
1275       segT abbrev_seg;
1276       segT info_seg;
1277       segT aranges_seg;
1278
1279       info_seg = subseg_new (".debug_info", 0);
1280       abbrev_seg = subseg_new (".debug_abbrev", 0);
1281       aranges_seg = subseg_new (".debug_aranges", 0);
1282
1283       bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1284       bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1285       bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1286
1287       record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1288
1289       out_debug_aranges (aranges_seg, info_seg);
1290       out_debug_abbrev (abbrev_seg);
1291       out_debug_info (info_seg, abbrev_seg, line_seg);
1292     }
1293 }
1294
1295 #else
1296 void
1297 dwarf2_finish ()
1298 {
1299 }
1300
1301 int
1302 dwarf2dbg_estimate_size_before_relax (frag)
1303      fragS *frag ATTRIBUTE_UNUSED;
1304 {
1305   as_fatal (_("dwarf2 is not supported for this object file format"));
1306   return 0;
1307 }
1308
1309 int
1310 dwarf2dbg_relax_frag (frag)
1311      fragS *frag ATTRIBUTE_UNUSED;
1312 {
1313   as_fatal (_("dwarf2 is not supported for this object file format"));
1314   return 0;
1315 }
1316
1317 void
1318 dwarf2dbg_convert_frag (frag)
1319      fragS *frag ATTRIBUTE_UNUSED;
1320 {
1321   as_fatal (_("dwarf2 is not supported for this object file format"));
1322 }
1323
1324 void
1325 dwarf2_emit_insn (size)
1326      int size ATTRIBUTE_UNUSED;
1327 {
1328 }
1329
1330 void
1331 dwarf2_directive_file (dummy)
1332      int dummy ATTRIBUTE_UNUSED;
1333 {
1334   s_app_file (0);
1335 }
1336
1337 void
1338 dwarf2_directive_loc (dummy)
1339      int dummy ATTRIBUTE_UNUSED;
1340 {
1341   as_fatal (_("dwarf2 is not supported for this object file format"));
1342 }
1343 #endif /* BFD_ASSEMBLER */