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 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
 353 char *
 354 dwarf2_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
 404 void
 405 dwarf2_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 \f
 444 static struct frag *
 445 first_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
 458 static struct frag *
 459 last_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 \f
 472 /* Emit a single byte into the current segment.  */
 473
 474 static inline void
 475 out_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
 483 static inline void
 484 out_opcode (opc)
 485      int opc;
 486 {
 487   out_byte (opc);
 488 }
 489
 490 /* Emit a two-byte word into the current segment.  */
 491
 492 static inline void
 493 out_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
 501 static inline void
 502 out_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
 510 static void
 511 out_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
 519 static inline void
 520 out_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
 529 static symbolS *
 530 symbol_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
 537 static void
 538 set_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
 548 static offsetT
 549 get_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
 573 static void
 574 out_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
 601 static int
 602 size_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
 665 static void
 666 emit_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
 762 static void
 763 out_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
 774 static void
 775 relax_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
 805 int
 806 dwarf2dbg_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
 824 int
 825 dwarf2dbg_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
 840 void
 841 dwarf2dbg_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
 865 static void
 866 process_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
 959 static void
 960 out_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
 992 static void
 993 out_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
1056 static void
1057 out_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
1136 static void
1137 out_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_comp_dir, DW_FORM_string);
1152   out_abbrev (DW_AT_producer, DW_FORM_string);
1153   out_abbrev (DW_AT_language, DW_FORM_data2);
1154   out_abbrev (0, 0);
1155
1156   /* Terminate the abbreviations for this compilation unit.  */
1157   out_byte (0);
1158 }
1159
1160 /* Emit a description of this compilation unit for .debug_info.  */
1161
1162 static void
1163 out_debug_info (info_seg, abbrev_seg, line_seg)
1164      segT info_seg;
1165      segT abbrev_seg;
1166      segT line_seg;
1167 {
1168   char producer[128];
1169   char *comp_dir;
1170   expressionS expr;
1171   symbolS *info_start;
1172   symbolS *info_end;
1173   char *p;
1174   int len;
1175
1176   subseg_set (info_seg, 0);
1177
1178   info_start = symbol_new_now ();
1179   info_end = symbol_make (fake_label_name);
1180
1181   /* Compilation Unit length.  */
1182   expr.X_op = O_subtract;
1183   expr.X_add_symbol = info_end;
1184   expr.X_op_symbol = info_start;
1185   expr.X_add_number = -4;
1186   emit_expr (&expr, 4);
1187
1188   /* DWARF version.  */
1189   out_two (2);
1190
1191   /* .debug_abbrev offset */
1192   expr.X_op = O_symbol;
1193   expr.X_add_symbol = section_symbol (abbrev_seg);
1194   expr.X_add_number = 0;
1195   emit_expr (&expr, 4);
1196
1197   /* Target address size.  */
1198   out_byte (sizeof_address);
1199
1200   /* DW_TAG_compile_unit DIE abbrev */
1201   out_uleb128 (1);
1202
1203   /* DW_AT_stmt_list */
1204   expr.X_op = O_symbol;
1205   expr.X_add_symbol = section_symbol (line_seg);
1206   expr.X_add_number = 0;
1207   emit_expr (&expr, 4);
1208
1209   /* These two attributes may only be emitted if all of the code is
1210      contiguous.  Multiple sections are not that.  */
1211   if (all_segs->next == NULL)
1212     {
1213       /* DW_AT_low_pc */
1214       expr.X_op = O_symbol;
1215       expr.X_add_symbol = all_segs->text_start;
1216       expr.X_add_number = 0;
1217       emit_expr (&expr, sizeof_address);
1218
1219       /* DW_AT_high_pc */
1220       expr.X_op = O_symbol;
1221       expr.X_add_symbol = all_segs->text_end;
1222       expr.X_add_number = 0;
1223       emit_expr (&expr, sizeof_address);
1224     }
1225
1226   /* DW_AT_comp_dir */
1227   comp_dir = getpwd ();
1228   len = strlen (comp_dir) + 1;
1229   p = frag_more (len);
1230   memcpy (p, comp_dir, len);
1231
1232   /* DW_AT_producer */
1233   sprintf (producer, "GNU AS %s", VERSION);
1234   len = strlen (producer) + 1;
1235   p = frag_more (len);
1236   memcpy (p, producer, len);
1237
1238   /* DW_AT_language.  Yes, this is probably not really MIPS, but the
1239      dwarf2 draft has no standard code for assembler.  */
1240   out_two (DW_LANG_Mips_Assembler);
1241
1242   set_symbol_value_now (info_end);
1243 }
1244
1245 void
1246 dwarf2_finish ()
1247 {
1248   segT line_seg;
1249   struct line_seg *s;
1250
1251   /* If no debug information was recorded, nothing to do.  */
1252   if (all_segs == NULL && files_in_use <= 1)
1253     return;
1254
1255   /* Calculate the size of an address for the target machine.  */
1256   sizeof_address = bfd_arch_bits_per_address (stdoutput) / 8;
1257
1258   /* Create and switch to the line number section.  */
1259   line_seg = subseg_new (".debug_line", 0);
1260   bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY);
1261
1262   /* For each subsection, chain the debug entries together.  */
1263   for (s = all_segs; s; s = s->next)
1264     {
1265       struct line_subseg *ss = s->head;
1266       struct line_entry **ptail = ss->ptail;
1267
1268       while ((ss = ss->next) != NULL)
1269         {
1270           *ptail = ss->head;
1271           ptail = ss->ptail;
1272         }
1273     }
1274
1275   out_debug_line (line_seg);
1276
1277   /* If this is assembler generated line info, we need .debug_info
1278      and .debug_abbrev sections as well.  */
1279   if (all_segs != NULL && debug_type == DEBUG_DWARF2)
1280     {
1281       segT abbrev_seg;
1282       segT info_seg;
1283       segT aranges_seg;
1284
1285       info_seg = subseg_new (".debug_info", 0);
1286       abbrev_seg = subseg_new (".debug_abbrev", 0);
1287       aranges_seg = subseg_new (".debug_aranges", 0);
1288
1289       bfd_set_section_flags (stdoutput, info_seg, SEC_READONLY);
1290       bfd_set_section_flags (stdoutput, abbrev_seg, SEC_READONLY);
1291       bfd_set_section_flags (stdoutput, aranges_seg, SEC_READONLY);
1292
1293       record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1);
1294
1295       out_debug_aranges (aranges_seg, info_seg);
1296       out_debug_abbrev (abbrev_seg);
1297       out_debug_info (info_seg, abbrev_seg, line_seg);
1298     }
1299 }
1300
1301 #else
1302 void
1303 dwarf2_finish ()
1304 {
1305 }
1306
1307 int
1308 dwarf2dbg_estimate_size_before_relax (frag)
1309      fragS *frag ATTRIBUTE_UNUSED;
1310 {
1311   as_fatal (_("dwarf2 is not supported for this object file format"));
1312   return 0;
1313 }
1314
1315 int
1316 dwarf2dbg_relax_frag (frag)
1317      fragS *frag ATTRIBUTE_UNUSED;
1318 {
1319   as_fatal (_("dwarf2 is not supported for this object file format"));
1320   return 0;
1321 }
1322
1323 void
1324 dwarf2dbg_convert_frag (frag)
1325      fragS *frag ATTRIBUTE_UNUSED;
1326 {
1327   as_fatal (_("dwarf2 is not supported for this object file format"));
1328 }
1329
1330 void
1331 dwarf2_emit_insn (size)
1332      int size ATTRIBUTE_UNUSED;
1333 {
1334 }
1335
1336 void
1337 dwarf2_directive_file (dummy)
1338      int dummy ATTRIBUTE_UNUSED;
1339 {
1340   s_app_file (0);
1341 }
1342
1343 void
1344 dwarf2_directive_loc (dummy)
1345      int dummy ATTRIBUTE_UNUSED;
1346 {
1347   as_fatal (_("dwarf2 is not supported for this object file format"));
1348 }
1349 #endif /* BFD_ASSEMBLER */