gas/dwarf2dbg.c

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