gas/dwarf2dbg.c

   1 /* dwarf2dbg.c - DWARF2 debug support
   2    Copyright (C) 1999 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
  32 #include "as.h"
  33 #include "dwarf2dbg.h"
  34 #include "subsegs.h"
  35
  36 #include "elf/dwarf2.h"
  37
  38 /* Since we can't generate the prolog until the body is complete, we
  39    use three different subsegments for .debug_line: one holding the
  40    prolog, one for the directory and filename info, and one for the
  41    body ("statement program").  */
  42 #define DL_PROLOG       0
  43 #define DL_FILES        1
  44 #define DL_BODY         2
  45
  46 /* First special line opcde - leave room for the standard opcodes.
  47    Note: If you want to change this, you'll have to update the
  48    "standard_opcode_lengths" table that is emitted below in
  49    dwarf2_finish().  */
  50 #define DWARF2_LINE_OPCODE_BASE         10
  51
  52 #ifndef DWARF2_LINE_BASE
  53   /* Minimum line offset in a special line info. opcode.  This value
  54      was chosen to give a reasonable range of values.  */
  55 # define DWARF2_LINE_BASE               -5
  56 #endif
  57
  58 /* Range of line offsets in a special line info. opcode.  */
  59 #ifndef DWARF2_LINE_RANGE
  60 # define DWARF2_LINE_RANGE              14
  61 #endif
  62
  63 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
  64   /* Define the architecture-dependent minimum instruction length (in
  65      bytes).  This value should be rather too small than too big.  */
  66 # define DWARF2_LINE_MIN_INSN_LENGTH    4
  67 #endif
  68
  69 /* Flag that indicates the initial value of the is_stmt_start flag.
  70    In the present implementation, we do not mark any lines as
  71    the beginning of a source statement, because that information
  72    is not made available by the GCC front-end.  */
  73 #define DWARF2_LINE_DEFAULT_IS_STMT     1
  74
  75 /* Flag that indicates the initial value of the is_stmt_start flag.
  76    In the present implementation, we do not mark any lines as
  77    the beginning of a source statement, because that information
  78    is not made available by the GCC front-end.  */
  79 #define DWARF2_LINE_DEFAULT_IS_STMT     1
  80
  81 /* Given a special op, return the line skip amount: */
  82 #define SPECIAL_LINE(op) \
  83         (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE)
  84
  85 /* Given a special op, return the address skip amount (in units of
  86    DWARF2_LINE_MIN_INSN_LENGTH.  */
  87 #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)
  88
  89 /* The maximum address skip amont that can be encoded with a special op: */
  90 #define MAX_SPECIAL_ADDR_DELTA          SPECIAL_ADDR(255)
  91
  92 #define INITIAL_STATE                                           \
  93   /* initialize as per DWARF2.0 standard: */                    \
  94   0,                                    /* address */           \
  95   1,                                    /* file */              \
  96   1,                                    /* line */              \
  97   0,                                    /* column */            \
  98   DWARF2_LINE_DEFAULT_IS_STMT,          /* is_stmt */           \
  99   0,                                    /* basic_block */       \
 100   1                                     /* empty_sequence */
 101
 102 static struct
 103   {
 104     /* state machine state as per DWARF2 manual: */
 105     struct dwarf2_sm
 106       {
 107         addressT addr;
 108         unsigned int filenum;
 109         unsigned int line;
 110         unsigned int column;
 111         unsigned int
 112           is_stmt : 1,
 113           basic_block : 1,
 114           empty_sequence : 1;           /* current code sequence has no DWARF2 directives? */
 115       }
 116     sm;
 117
 118     unsigned int
 119       any_dwarf2_directives : 1;        /* did we emit any DWARF2 line debug directives? */
 120
 121     segT text_seg;      /* text segment "addr" is relative to */
 122     subsegT text_subseg;
 123     segT line_seg;      /* ".debug_line" segment */
 124     int last_filename;  /* index of last filename that was used */
 125     int num_filenames;  /* index of last filename in use */
 126     int filename_len;   /* length of the filename array */
 127     struct
 128       {
 129         int dir;        /* valid after gen_dir_list() only */
 130         char *name; /* full path before gen_dir_list(), filename afterwards */
 131       }
 132     *file;
 133
 134     struct dwarf2_line_info current;    /* current source info: */
 135
 136     /* counters for statistical purposes: */
 137     unsigned int num_line_entries;
 138     unsigned int opcode_hist[256];      /* histogram of opcode frequencies */
 139   }
 140 ls =
 141   {
 142     {
 143       INITIAL_STATE
 144     },
 145     0,
 146     0,
 147     0,
 148     0,
 149     0,
 150     0,
 151     0,
 152     NULL,
 153     { NULL, 0, 0, 0, 0 },
 154     0,
 155     {
 156       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 157       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 158       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 159       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 160       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 161       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 162       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 163       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 164       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 165       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 166       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 167       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 168       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 169       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 170       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 171       0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 172     }
 173   };
 174
 175
 176 /* Function prototypes: */
 177 static void out_uleb128 PARAMS ((addressT));
 178 static void out_sleb128 PARAMS ((offsetT));
 179 static void gen_addr_line PARAMS ((int, addressT));
 180 static void reset_state_machine PARAMS ((void));
 181 static void out_set_addr PARAMS ((addressT));
 182 static void out_end_sequence PARAMS ((void));
 183 static int get_filenum PARAMS ((int, char *));
 184 static void gen_dir_list PARAMS ((void));
 185 static void gen_file_list PARAMS ((void));
 186 static void print_stats PARAMS ((unsigned long));
 187
 188
 189 #define out_byte(byte)  FRAG_APPEND_1_CHAR(byte)
 190 #define out_opcode(opc) (out_byte ((opc)), ++ls.opcode_hist[(opc) & 0xff])
 191
 192 /* Output an unsigned "little-endian base 128" number.  */
 193 static void
 194 out_uleb128 (value)
 195      addressT value;
 196 {
 197   unsigned char byte, more = 0x80;
 198
 199   do
 200     {
 201       byte = value & 0x7f;
 202       value >>= 7;
 203       if (value == 0)
 204         more = 0;
 205       out_byte (more | byte);
 206     }
 207   while (more);
 208 }
 209
 210 /* Output a signed "little-endian base 128" number.  */
 211 static void
 212 out_sleb128 (value)
 213      offsetT value;
 214 {
 215   unsigned char byte, more = 0x80;
 216
 217   do
 218     {
 219       byte = value & 0x7f;
 220       value >>= 7;
 221       if (((value == 0) && ((byte & 0x40) == 0))
 222           || ((value == -1) && ((byte & 0x40) != 0)))
 223         more = 0;
 224       out_byte (more | byte);
 225     }
 226   while (more);
 227 }
 228
 229 /* Encode a pair of line and address skips as efficiently as possible.
 230    Note that the line skip is signed, whereas the address skip is
 231    unsigned.  */
 232 static void
 233 gen_addr_line (line_delta, addr_delta)
 234      int line_delta;
 235      addressT addr_delta;
 236 {
 237   unsigned int tmp, opcode;
 238
 239   tmp = line_delta - DWARF2_LINE_BASE;
 240
 241   if (tmp >= DWARF2_LINE_RANGE)
 242     {
 243       out_opcode (DW_LNS_advance_line);
 244       out_sleb128 (line_delta);
 245       tmp = 0 - DWARF2_LINE_BASE;
 246       line_delta = 0;
 247     }
 248
 249   tmp += DWARF2_LINE_OPCODE_BASE;
 250
 251   /* try using a special opcode: */
 252   opcode = tmp + addr_delta*DWARF2_LINE_RANGE;
 253   if (opcode <= 255)
 254     {
 255       out_opcode (opcode);
 256       return;
 257     }
 258
 259   /* try using DW_LNS_const_add_pc followed by special op: */
 260   opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA)*DWARF2_LINE_RANGE;
 261   if (opcode <= 255)
 262     {
 263       out_opcode (DW_LNS_const_add_pc);
 264       out_opcode (opcode);
 265       return;
 266     }
 267
 268   out_opcode (DW_LNS_advance_pc);
 269   out_uleb128 (addr_delta);
 270
 271   if (line_delta)
 272     out_opcode (tmp);           /* output line-delta */
 273   else
 274     out_opcode (DW_LNS_copy);   /* append new row with current info */
 275 }
 276
 277 static void
 278 reset_state_machine ()
 279 {
 280   static const struct dwarf2_sm initial_state = { INITIAL_STATE };
 281
 282   ls.sm = initial_state;
 283 }
 284
 285 /* Set an absolute address (may results in a relocation entry): */
 286 static void
 287 out_set_addr (addr)
 288      addressT addr;
 289 {
 290   subsegT saved_subseg;
 291   segT saved_seg;
 292   expressionS expr;
 293   symbolS *sym;
 294   int bytes_per_address;
 295
 296   saved_seg = now_seg;
 297   saved_subseg = now_subseg;
 298
 299   subseg_set (ls.text_seg, ls.text_subseg);
 300   sym = symbol_new (".L0\001", now_seg, addr, frag_now);
 301
 302   subseg_set (saved_seg, saved_subseg);
 303
 304 #ifdef BFD_ASSEMBLER
 305   bytes_per_address = bfd_arch_bits_per_address (stdoutput) / 8;
 306 #else
 307   /* FIXME.  */
 308   bytes_per_address = 4;
 309 #endif
 310
 311   out_opcode (DW_LNS_extended_op);
 312   out_uleb128 (bytes_per_address + 1);
 313
 314   out_opcode (DW_LNE_set_address);
 315   expr.X_op = O_symbol;
 316   expr.X_add_symbol = sym;
 317   expr.X_add_number = 0;
 318   emit_expr (&expr, bytes_per_address);
 319 }
 320
 321 /* Emit DW_LNS_end_sequence and reset state machine.  Does not
 322    preserve the current segment/sub-segment!  */
 323 static void
 324 out_end_sequence ()
 325 {
 326   addressT addr, delta;
 327
 328   if (ls.text_seg)
 329     {
 330       subseg_set (ls.text_seg, ls.text_subseg);
 331 #ifdef md_current_text_addr
 332       addr = md_current_text_addr ();
 333 #else
 334       addr = frag_now_fix ();
 335 #endif
 336       subseg_set (ls.line_seg, DL_BODY);
 337       if (addr < ls.sm.addr)
 338         {
 339           out_set_addr (addr);
 340           ls.sm.addr = addr;
 341         }
 342       else
 343         {
 344           delta = (addr - ls.sm.addr) / DWARF2_LINE_MIN_INSN_LENGTH;
 345           if (delta > 0)
 346             {
 347               /* Advance address without updating the line-debug
 348                  matrix---the end_sequence entry is used only to tell
 349                  the debugger the end of the sequence.*/
 350               out_opcode (DW_LNS_advance_pc);
 351               out_uleb128 (delta);
 352             }
 353         }
 354     }
 355   else
 356     subseg_set (ls.line_seg, DL_BODY);
 357
 358   out_opcode (DW_LNS_extended_op);
 359   out_uleb128 (1);
 360   out_byte (DW_LNE_end_sequence);
 361
 362   reset_state_machine ();
 363 }
 364
 365 /* Look up a filenumber either by filename or by filenumber.  If both
 366    a filenumber and a filename are specified, lookup by filename takes
 367    precedence.  If the filename cannot be found, it is added to the
 368    filetable and the filenumber for the new entry is returned.  */
 369 static int
 370 get_filenum (filenum, file)
 371      int filenum;
 372      char *file;
 373 {
 374   int i, last = filenum - 1;
 375   char char0 = file[0];
 376
 377   /* If filenum is out of range of the filename table, then try using the
 378      table entry returned from the previous call.  */
 379   if (last >= ls.num_filenames || last < 0)
 380     last = ls.last_filename;
 381
 382   /* Do a quick check against the specified or previously used filenum.  */
 383   if (ls.num_filenames > 0 && ls.file[last].name[0] == char0
 384       && strcmp (ls.file[last].name + 1, file + 1) == 0)
 385     return last + 1;
 386
 387   /* no match, fall back to simple linear scan: */
 388   for (i = 0; i < ls.num_filenames; ++i)
 389     {
 390       if (ls.file[i].name[0] == char0
 391           && strcmp (ls.file[i].name + 1, file + 1) == 0)
 392         {
 393           ls.last_filename = i;
 394           return i + 1;
 395         }
 396     }
 397
 398   /* no match: enter new filename */
 399   if (ls.num_filenames >= ls.filename_len)
 400     {
 401       ls.filename_len += 13;
 402       ls.file = xrealloc (ls.file, ls.filename_len * sizeof (ls.file[0]));
 403     }
 404   ls.file[ls.num_filenames].dir = 0;
 405   ls.file[ls.num_filenames].name = file;
 406   ls.last_filename = ls.num_filenames;
 407   return ++ls.num_filenames;
 408 }
 409
 410 void
 411 dwarf2_gen_line_info (addr, l)
 412      addressT addr;
 413      struct dwarf2_line_info *l;
 414 {
 415   unsigned int filenum = l->filenum;
 416   unsigned int any_output = 0;
 417   subsegT saved_subseg;
 418   segT saved_seg;
 419
 420   if (flag_debug)
 421     fprintf (stderr, "line: addr %lx file `%s' line %u col %u flags %x\n",
 422              (unsigned long) addr, l->filename, l->line, l->column, l->flags);
 423
 424   if (filenum > 0 && !l->filename)
 425     {
 426       if (filenum >= (unsigned int) ls.num_filenames)
 427         {
 428           as_warn ("Encountered bad file number in line number debug info!");
 429           return;
 430         }
 431     }
 432   else if (l->filename)
 433     filenum = get_filenum (filenum, l->filename);
 434   else
 435     return;     /* no filename, no filnum => no play */
 436
 437   /* Must save these before the subseg_new call, as that call will change
 438      them.  */
 439   saved_seg = now_seg;
 440   saved_subseg = now_subseg;
 441
 442   if (!ls.line_seg)
 443     {
 444 #ifdef BFD_ASSEMBLER
 445       symbolS *secsym;
 446 #endif
 447
 448       ls.line_seg = subseg_new (".debug_line", 0);
 449
 450 #ifdef BFD_ASSEMBLER
 451       bfd_set_section_flags (stdoutput, ls.line_seg, SEC_READONLY);
 452
 453       /* We're going to need this symbol.  */
 454       secsym = symbol_find (".debug_line");
 455       if (secsym != NULL)
 456         symbol_set_bfdsym (secsym, ls.line_seg->symbol);
 457       else
 458         symbol_table_insert (section_symbol (ls.line_seg));
 459 #endif
 460     }
 461
 462   subseg_set (ls.line_seg, DL_BODY);
 463
 464   if (ls.text_seg != saved_seg || ls.text_subseg != saved_subseg)
 465     {
 466       if (!ls.sm.empty_sequence)
 467         {
 468           out_end_sequence ();          /* terminate previous sequence */
 469           ls.sm.empty_sequence = 1;
 470         }
 471       any_output = 1;
 472       ls.text_seg = saved_seg;
 473       ls.text_subseg = saved_subseg;
 474       out_set_addr (addr);
 475       ls.sm.addr = addr;
 476     }
 477
 478   if (ls.sm.filenum != filenum)
 479     {
 480       any_output = 1;
 481       out_opcode (DW_LNS_set_file);
 482       out_uleb128 (filenum);
 483       ls.sm.filenum = filenum;
 484     }
 485
 486   if (ls.sm.column != l->column)
 487     {
 488       any_output = 1;
 489       out_opcode (DW_LNS_set_column);
 490       out_uleb128 (l->column);
 491       ls.sm.column = l->column;
 492     }
 493
 494   if (((l->flags & DWARF2_FLAG_BEGIN_STMT) != 0) != ls.sm.is_stmt)
 495     {
 496       any_output = 1;
 497       out_opcode (DW_LNS_negate_stmt);
 498     }
 499
 500   if (l->flags & DWARF2_FLAG_BEGIN_BLOCK)
 501     {
 502       any_output = 1;
 503       out_opcode (DW_LNS_set_basic_block);
 504     }
 505
 506   if (ls.sm.line != l->line)
 507     {
 508       any_output = 1;
 509       if (addr < ls.sm.addr)
 510         {
 511           /* This happens when a new frag got allocated (for whatever
 512              reason).  Deal with it by generating a reference symbol.
 513              Note: no end_sequence needs to be generated because the
 514              address did not really decrease (only the reference point
 515              changed).
 516
 517              ??? Perhaps we should directly check for a change of
 518              frag_now instead?  */
 519           out_set_addr (addr);
 520           ls.sm.addr = addr;
 521         }
 522       gen_addr_line (l->line - ls.sm.line,
 523                      (addr - ls.sm.addr) / DWARF2_LINE_MIN_INSN_LENGTH);
 524       ls.sm.basic_block = 0;
 525       ls.sm.line = l->line;
 526       ls.sm.addr = addr;
 527     }
 528
 529   subseg_set (saved_seg, saved_subseg);
 530
 531   ls.num_line_entries += any_output;
 532   if (any_output)
 533     ls.sm.empty_sequence = 0;
 534 }
 535
 536 static void
 537 gen_dir_list ()
 538 {
 539   char *str, *slash, *dir_list, *dp, *cp;
 540   int i, j, num_dirs;
 541
 542   dir_list = frag_more (0);
 543   num_dirs = 0;
 544
 545   for (i = 0; i < ls.num_filenames; ++i)
 546     {
 547       str = ls.file[i].name;
 548       slash = strrchr (str, '/');
 549       if (slash)
 550         {
 551           *slash = '\0';
 552           for (j = 0, dp = dir_list; j < num_dirs; ++j)
 553             {
 554               if (strcmp (str, dp) == 0)
 555                 {
 556                   ls.file[i].dir = j + 1;
 557                   break;
 558                 }
 559               dp += strlen (dp);
 560             }
 561           if (j >= num_dirs)
 562             {
 563               /* didn't find this directory: append it to the list */
 564               size_t size = strlen (str) + 1;
 565               cp = frag_more (size);
 566               memcpy (cp, str, size);
 567               ls.file[i].dir = ++num_dirs;
 568             }
 569           *slash = '/';
 570           ls.file[i].name = slash + 1;
 571         }
 572     }
 573   out_byte ('\0');      /* terminate directory list */
 574 }
 575
 576 static void
 577 gen_file_list ()
 578 {
 579   size_t size;
 580   char *cp;
 581   int i;
 582
 583   for (i = 0; i < ls.num_filenames; ++i)
 584     {
 585       size = strlen (ls.file[i].name) + 1;
 586       cp = frag_more (size);
 587       memcpy (cp, ls.file[i].name, size);
 588
 589       out_uleb128 (ls.file[i].dir);     /* directory number */
 590       out_uleb128 (0);                  /* last modification timestamp */
 591       out_uleb128 (0);                  /* filesize */
 592     }
 593   out_byte (0);         /* terminate filename list */
 594 }
 595
 596 static void
 597 print_stats (total_size)
 598      unsigned long total_size;
 599 {
 600   static const char *opc_name[] =
 601     {
 602       "extended", "copy", "advance_pc", "advance_line", "set_file",
 603       "set_column", "negate_stmt", "set_basic_block", "const_add_pc",
 604       "fixed_advance_pc"
 605     };
 606   size_t i;
 607   int j;
 608
 609   fprintf (stderr, "Average size: %g bytes/line\n",
 610            total_size / (double) ls.num_line_entries);
 611
 612   fprintf (stderr, "\nStandard opcode histogram:\n");
 613
 614   for (i = 0; i < sizeof (opc_name)/sizeof (opc_name[0]); ++i)
 615     {
 616       fprintf (stderr, "%s", opc_name[i]);
 617       for (j = strlen (opc_name[i]); j < 16; ++j)
 618         fprintf (stderr, " ");
 619       fprintf (stderr, ": %u\n", ls.opcode_hist[i]);
 620     }
 621
 622   fprintf (stderr, "\nSpecial opcodes:\naddr\t\t\t\tline skip\n");
 623
 624   fprintf (stderr, "skip: ");
 625   for (j = DWARF2_LINE_BASE; j < DWARF2_LINE_BASE + DWARF2_LINE_RANGE; ++j)
 626     fprintf (stderr, "%3d", j);
 627   fprintf (stderr, "\n-----");
 628
 629   for (; i < 256; ++i)
 630     {
 631       j = SPECIAL_LINE (i);
 632       if (j == DWARF2_LINE_BASE)
 633         fprintf (stderr, "\n%4u: ",
 634                  DWARF2_LINE_MIN_INSN_LENGTH*SPECIAL_ADDR (i));
 635       fprintf (stderr, " %2u", ls.opcode_hist[i]);
 636     }
 637   fprintf (stderr, "\n");
 638 }
 639
 640 void
 641 dwarf2_finish ()
 642 {
 643   addressT body_size, total_size, prolog_size;
 644   subsegT saved_subseg;
 645   segT saved_seg;
 646   char *cp;
 647
 648   if (!ls.line_seg)
 649     /* no .debug_line segment, no work to do... */
 650     return;
 651
 652   saved_seg = now_seg;
 653   saved_subseg = now_subseg;
 654
 655   if (!ls.sm.empty_sequence)
 656     out_end_sequence ();
 657   total_size = body_size = frag_now_fix ();
 658
 659   /* now generate the directory and file lists: */
 660   subseg_set (ls.line_seg, DL_FILES);
 661   gen_dir_list ();
 662   gen_file_list ();
 663   total_size += frag_now_fix ();
 664
 665   /* and now the header ("statement program prolog", in DWARF2 lingo...) */
 666   subseg_set (ls.line_seg, DL_PROLOG);
 667
 668   cp = frag_more (15 + DWARF2_LINE_OPCODE_BASE - 1);
 669
 670   total_size += frag_now_fix ();
 671   prolog_size = total_size - body_size - 10;
 672
 673 # define STUFF(val,size)        md_number_to_chars (cp, val, size); cp += size;
 674   STUFF (total_size - 4, 4);    /* length */
 675   STUFF (2, 2);                 /* version */
 676   STUFF (prolog_size, 4);       /* prologue_length */
 677   STUFF (DWARF2_LINE_MIN_INSN_LENGTH, 1);
 678   STUFF (DWARF2_LINE_DEFAULT_IS_STMT, 1);
 679   STUFF (DWARF2_LINE_BASE, 1);
 680   STUFF (DWARF2_LINE_RANGE, 1);
 681   STUFF (DWARF2_LINE_OPCODE_BASE, 1);
 682
 683   /* standard_opcode_lengths: */
 684   STUFF (0, 1);                 /* DW_LNS_copy */
 685   STUFF (1, 1);                 /* DW_LNS_advance_pc */
 686   STUFF (1, 1);                 /* DW_LNS_advance_line */
 687   STUFF (1, 1);                 /* DW_LNS_set_file */
 688   STUFF (1, 1);                 /* DW_LNS_set_column */
 689   STUFF (0, 1);                 /* DW_LNS_negate_stmt */
 690   STUFF (0, 1);                 /* DW_LNS_set_basic_block */
 691   STUFF (0, 1);                 /* DW_LNS_const_add_pc */
 692   STUFF (1, 1);                 /* DW_LNS_fixed_advance_pc */
 693
 694   subseg_set (saved_seg, saved_subseg);
 695
 696   if (flag_debug)
 697     print_stats (total_size);
 698 }
 699
 700 void
 701 dwarf2_directive_file (dummy)
 702      int dummy ATTRIBUTE_UNUSED;
 703 {
 704   int len;
 705
 706   /* Continue to accept a bare string and pass it off.  */
 707   SKIP_WHITESPACE ();
 708   if (*input_line_pointer == '"')
 709     {
 710       s_app_file (0);
 711       return;
 712     }
 713
 714   ls.any_dwarf2_directives = 1;
 715
 716   if (debug_type == DEBUG_NONE)
 717     /* Automatically turn on DWARF2 debug info unless something else
 718        has been selected.  */
 719     debug_type = DEBUG_DWARF2;
 720
 721   ls.current.filenum = get_absolute_expression ();
 722   ls.current.filename = demand_copy_C_string (&len);
 723
 724   demand_empty_rest_of_line ();
 725 }
 726
 727 void
 728 dwarf2_directive_loc (dummy)
 729      int dummy ATTRIBUTE_UNUSED;
 730 {
 731   ls.any_dwarf2_directives = 1;
 732
 733   ls.current.filenum = get_absolute_expression ();
 734   SKIP_WHITESPACE ();
 735   ls.current.line = get_absolute_expression ();
 736   SKIP_WHITESPACE ();
 737   ls.current.column = get_absolute_expression ();
 738   demand_empty_rest_of_line ();
 739
 740   ls.current.flags = DWARF2_FLAG_BEGIN_STMT;
 741
 742 #ifndef NO_LISTING
 743   if (listing)
 744     listing_source_line (ls.current.line);
 745 #endif
 746 }
 747
 748 void
 749 dwarf2_where (line)
 750      struct dwarf2_line_info *line;
 751 {
 752   if (ls.any_dwarf2_directives)
 753     *line = ls.current;
 754   else
 755     {
 756       as_where (&line->filename, &line->line);
 757       line->filenum = 0;
 758       line->column = 0;
 759       line->flags = DWARF2_FLAG_BEGIN_STMT;
 760     }
 761 }