X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gas%2Fdwarf2dbg.c;h=61268a8cd1e3f43982b3ff212f47ec396713d388;hb=fe779266b39080e49b04e61160e6af8be439c182;hp=c23b7f677ee010da61261845cccb1cc056e09352;hpb=58b5739a4e998799ab1b3bf8bb7720d176f50b72;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/dwarf2dbg.c b/gas/dwarf2dbg.c index c23b7f677e..61268a8cd1 100644 --- a/gas/dwarf2dbg.c +++ b/gas/dwarf2dbg.c @@ -1,12 +1,12 @@ /* dwarf2dbg.c - DWARF2 debug support - Copyright (C) 1999 Hewlett-Packard Co + Copyright (C) 1999-2016 Free Software Foundation, Inc. Contributed by David Mosberger-Tang This file is part of GAS, the GNU Assembler. GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2, or (at your option) + the Free Software Foundation; either version 3, or (at your option) any later version. GAS is distributed in the hope that it will be useful, @@ -16,26 +16,95 @@ You should have received a copy of the GNU General Public License along with GAS; see the file COPYING. If not, write to the Free - Software Foundation, 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. + Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA + 02110-1301, USA. */ - Logical line numbers can be controlled by the compiler via the - following two directives: +/* Logical line numbers can be controlled by the compiler via the + following directives: .file FILENO "file.c" - .loc FILENO LINENO [COLUMN] + .loc FILENO LINENO [COLUMN] [basic_block] [prologue_end] \ + [epilogue_begin] [is_stmt VALUE] [isa VALUE] \ + [discriminator VALUE] +*/ - FILENO is the filenumber. */ +#include "as.h" +#include "safe-ctype.h" -#include "ansidecl.h" +#ifdef HAVE_LIMITS_H +#include +#else +#ifdef HAVE_SYS_PARAM_H +#include +#endif +#ifndef INT_MAX +#define INT_MAX (int) (((unsigned) (-1)) >> 1) +#endif +#endif -#include "as.h" #include "dwarf2dbg.h" -#include "subsegs.h" +#include + +#ifdef HAVE_DOS_BASED_FILE_SYSTEM +/* We need to decide which character to use as a directory separator. + Just because HAVE_DOS_BASED_FILE_SYSTEM is defined, it does not + necessarily mean that the backslash character is the one to use. + Some environments, eg Cygwin, can support both naming conventions. + So we use the heuristic that we only need to use the backslash if + the path is an absolute path starting with a DOS style drive + selector. eg C: or D: */ +# define INSERT_DIR_SEPARATOR(string, offset) \ + do \ + { \ + if (offset > 1 \ + && string[0] != 0 \ + && string[1] == ':') \ + string [offset] = '\\'; \ + else \ + string [offset] = '/'; \ + } \ + while (0) +#else +# define INSERT_DIR_SEPARATOR(string, offset) string[offset] = '/' +#endif + +#ifndef DWARF2_FORMAT +# define DWARF2_FORMAT(SEC) dwarf2_format_32bit +#endif + +#ifndef DWARF2_ADDR_SIZE +# define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8) +#endif + +#ifndef DWARF2_FILE_NAME +#define DWARF2_FILE_NAME(FILENAME, DIRNAME) FILENAME +#endif + +#ifndef DWARF2_FILE_TIME_NAME +#define DWARF2_FILE_TIME_NAME(FILENAME,DIRNAME) 0 +#endif + +#ifndef DWARF2_FILE_SIZE_NAME +#define DWARF2_FILE_SIZE_NAME(FILENAME,DIRNAME) 0 +#endif + +#ifndef DWARF2_VERSION +#define DWARF2_VERSION 2 +#endif + +/* The .debug_aranges version has been 2 in DWARF version 2, 3 and 4. */ +#ifndef DWARF2_ARANGES_VERSION +#define DWARF2_ARANGES_VERSION 2 +#endif + +/* This implementation output version 2 .debug_line information. */ +#ifndef DWARF2_LINE_VERSION +#define DWARF2_LINE_VERSION 2 +#endif -#include +#include "subsegs.h" -#define BYTES_PER_ADDRESS (BFD_ARCH_SIZE / 8) +#include "dwarf2.h" /* Since we can't generate the prolog until the body is complete, we use three different subsegments for .debug_line: one holding the @@ -45,11 +114,18 @@ #define DL_FILES 1 #define DL_BODY 2 +/* If linker relaxation might change offsets in the code, the DWARF special + opcodes and variable-length operands cannot be used. If this macro is + nonzero, use the DW_LNS_fixed_advance_pc opcode instead. */ +#ifndef DWARF2_USE_FIXED_ADVANCE_PC +# define DWARF2_USE_FIXED_ADVANCE_PC linkrelax +#endif + /* First special line opcde - leave room for the standard opcodes. Note: If you want to change this, you'll have to update the "standard_opcode_lengths" table that is emitted below in - dwarf2_finish(). */ -#define DWARF2_LINE_OPCODE_BASE 10 + out_debug_line(). */ +#define DWARF2_LINE_OPCODE_BASE 13 #ifndef DWARF2_LINE_BASE /* Minimum line offset in a special line info. opcode. This value @@ -65,22 +141,13 @@ #ifndef DWARF2_LINE_MIN_INSN_LENGTH /* Define the architecture-dependent minimum instruction length (in bytes). This value should be rather too small than too big. */ -# define DWARF2_LINE_MIN_INSN_LENGTH 4 +# define DWARF2_LINE_MIN_INSN_LENGTH 1 #endif -/* Flag that indicates the initial value of the is_stmt_start flag. - In the present implementation, we do not mark any lines as - the beginning of a source statement, because that information - is not made available by the GCC front-end. */ +/* Flag that indicates the initial value of the is_stmt_start flag. */ #define DWARF2_LINE_DEFAULT_IS_STMT 1 -/* Flag that indicates the initial value of the is_stmt_start flag. - In the present implementation, we do not mark any lines as - the beginning of a source statement, because that information - is not made available by the GCC front-end. */ -#define DWARF2_LINE_DEFAULT_IS_STMT 1 - -/* Given a special op, return the line skip amount: */ +/* Given a special op, return the line skip amount. */ #define SPECIAL_LINE(op) \ (((op) - DWARF2_LINE_OPCODE_BASE)%DWARF2_LINE_RANGE + DWARF2_LINE_BASE) @@ -88,613 +155,1794 @@ DWARF2_LINE_MIN_INSN_LENGTH. */ #define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE) -/* The maximum address skip amont that can be encoded with a special op: */ +/* The maximum address skip amount that can be encoded with a special op. */ #define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255) -#define INITIAL_STATE \ - /* initialize as per DWARF2.0 standard: */ \ - 0, /* address */ \ - 1, /* file */ \ - 1, /* line */ \ - 0, /* column */ \ - DWARF2_LINE_DEFAULT_IS_STMT, /* is_stmt */ \ - 0, /* basic_block */ \ - 1 /* empty_sequence */ - -static struct - { - /* state machine state as per DWARF2 manual: */ - struct dwarf2_sm - { - bfd_vma addr; - unsigned int filenum; - unsigned int line; - unsigned int column; - unsigned int - is_stmt : 1, - basic_block : 1, - empty_sequence : 1; /* current code sequence has no DWARF2 directives? */ - } - sm; - - unsigned int - any_dwarf2_directives : 1; /* did we emit any DWARF2 line debug directives? */ - - segT text_seg; /* text segment "addr" is relative to */ - subsegT text_subseg; - segT line_seg; /* ".debug_line" segment */ - int last_filename; /* index of last filename that was used */ - int num_filenames; /* index of last filename in use */ - int filename_len; /* length of the filename array */ - struct - { - int dir; /* valid after gen_dir_list() only */ - char *name; /* full path before gen_dir_list(), filename afterwards */ - } - *file; - - struct dwarf2_line_info current; /* current source info: */ - - /* counters for statistical purposes: */ - unsigned int num_line_entries; - unsigned int opcode_hist[256]; /* histogram of opcode frequencies */ - } -ls = - { - { - INITIAL_STATE - }, - }; - - -/* Function prototypes: */ -static void out_uleb128 PARAMS ((bfd_vma)); -static void out_sleb128 PARAMS ((bfd_signed_vma)); -static void gen_addr_line PARAMS ((int, bfd_vma)); -static void reset_state_machine PARAMS ((void)); -static void out_set_addr PARAMS ((bfd_vma)); -static void out_end_sequence PARAMS ((void)); -static int get_filenum PARAMS ((int, char *)); -static void gen_dir_list PARAMS ((void)); -static void gen_file_list PARAMS ((void)); -static void print_stats PARAMS ((unsigned long)); - - -#define out_byte(byte) FRAG_APPEND_1_CHAR(byte) -#define out_opcode(opc) (out_byte ((opc)), ++ls.opcode_hist[(opc) & 0xff]) - -/* Output an unsigned "little-endian base 128" number. */ +#ifndef TC_PARSE_CONS_RETURN_NONE +#define TC_PARSE_CONS_RETURN_NONE BFD_RELOC_NONE +#endif + +struct line_entry { + struct line_entry *next; + symbolS *label; + struct dwarf2_line_info loc; +}; + +struct line_subseg { + struct line_subseg *next; + subsegT subseg; + struct line_entry *head; + struct line_entry **ptail; + struct line_entry **pmove_tail; +}; + +struct line_seg { + struct line_seg *next; + segT seg; + struct line_subseg *head; + symbolS *text_start; + symbolS *text_end; +}; + +/* Collects data for all line table entries during assembly. */ +static struct line_seg *all_segs; +static struct line_seg **last_seg_ptr; + +struct file_entry { + const char *filename; + unsigned int dir; +}; + +/* Table of files used by .debug_line. */ +static struct file_entry *files; +static unsigned int files_in_use; +static unsigned int files_allocated; + +/* Table of directories used by .debug_line. */ +static char **dirs; +static unsigned int dirs_in_use; +static unsigned int dirs_allocated; + +/* TRUE when we've seen a .loc directive recently. Used to avoid + doing work when there's nothing to do. */ +bfd_boolean dwarf2_loc_directive_seen; + +/* TRUE when we're supposed to set the basic block mark whenever a + label is seen. */ +bfd_boolean dwarf2_loc_mark_labels; + +/* Current location as indicated by the most recent .loc directive. */ +static struct dwarf2_line_info current = { + 1, 1, 0, 0, + DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0, + 0 +}; + +/* The size of an address on the target. */ +static unsigned int sizeof_address; + +static unsigned int get_filenum (const char *, unsigned int); + +#ifndef TC_DWARF2_EMIT_OFFSET +#define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset + +/* Create an offset to .dwarf2_*. */ + static void -out_uleb128 (value) - bfd_vma value; +generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size) { - unsigned char byte, more = 0x80; + expressionS exp; - do - { - byte = value & 0x7f; - value >>= 7; - if (value == 0) - more = 0; - out_byte (more | byte); - } - while (more); + exp.X_op = O_symbol; + exp.X_add_symbol = symbol; + exp.X_add_number = 0; + emit_expr (&exp, size); } +#endif -/* Output a signed "little-endian base 128" number. */ -static void -out_sleb128 (value) - bfd_signed_vma value; +/* Find or create (if CREATE_P) an entry for SEG+SUBSEG in ALL_SEGS. */ + +static struct line_subseg * +get_line_subseg (segT seg, subsegT subseg, bfd_boolean create_p) { - unsigned char byte, more = 0x80; + struct line_seg *s = seg_info (seg)->dwarf2_line_seg; + struct line_subseg **pss, *lss; - do + if (s == NULL) { - byte = value & 0x7f; - value >>= 7; - if (((value == 0) && ((byte & 0x40) == 0)) - || ((value == -1) && ((byte & 0x40) != 0))) - more = 0; - out_byte (more | byte); + if (!create_p) + return NULL; + + s = XNEW (struct line_seg); + s->next = NULL; + s->seg = seg; + s->head = NULL; + *last_seg_ptr = s; + last_seg_ptr = &s->next; + seg_info (seg)->dwarf2_line_seg = s; } - while (more); + gas_assert (seg == s->seg); + + for (pss = &s->head; (lss = *pss) != NULL ; pss = &lss->next) + { + if (lss->subseg == subseg) + goto found_subseg; + if (lss->subseg > subseg) + break; + } + + lss = XNEW (struct line_subseg); + lss->next = *pss; + lss->subseg = subseg; + lss->head = NULL; + lss->ptail = &lss->head; + lss->pmove_tail = &lss->head; + *pss = lss; + + found_subseg: + return lss; } -/* Encode a pair of line and address skips as efficiently as possible. - Note that the line skip is signed, whereas the address skip is - unsigned. */ +/* Record an entry for LOC occurring at LABEL. */ + static void -gen_addr_line (line_delta, addr_delta) - int line_delta; - bfd_vma addr_delta; +dwarf2_gen_line_info_1 (symbolS *label, struct dwarf2_line_info *loc) { - unsigned int tmp, opcode; + struct line_subseg *lss; + struct line_entry *e; - tmp = line_delta - DWARF2_LINE_BASE; + e = XNEW (struct line_entry); + e->next = NULL; + e->label = label; + e->loc = *loc; - if (tmp >= DWARF2_LINE_RANGE) - { - out_opcode (DW_LNS_advance_line); - out_sleb128 (line_delta); - tmp = 0 - DWARF2_LINE_BASE; - line_delta = 0; - } + lss = get_line_subseg (now_seg, now_subseg, TRUE); + *lss->ptail = e; + lss->ptail = &e->next; +} - tmp += DWARF2_LINE_OPCODE_BASE; +/* Record an entry for LOC occurring at OFS within the current fragment. */ + +void +dwarf2_gen_line_info (addressT ofs, struct dwarf2_line_info *loc) +{ + static unsigned int line = -1; + static unsigned int filenum = -1; + + symbolS *sym; + + /* Early out for as-yet incomplete location information. */ + if (loc->filenum == 0 || loc->line == 0) + return; + + /* Don't emit sequences of line symbols for the same line when the + symbols apply to assembler code. It is necessary to emit + duplicate line symbols when a compiler asks for them, because GDB + uses them to determine the end of the prologue. */ + if (debug_type == DEBUG_DWARF2 + && line == loc->line && filenum == loc->filenum) + return; + + line = loc->line; + filenum = loc->filenum; - /* try using a special opcode: */ - opcode = tmp + addr_delta*DWARF2_LINE_RANGE; - if (opcode <= 255) + if (linkrelax) { - out_opcode (opcode); - return; + char name[120]; + + /* Use a non-fake name for the line number location, + so that it can be referred to by relocations. */ + sprintf (name, ".Loc.%u.%u", line, filenum); + sym = symbol_new (name, now_seg, ofs, frag_now); } + else + sym = symbol_temp_new (now_seg, ofs, frag_now); + dwarf2_gen_line_info_1 (sym, loc); +} - /* try using DW_LNS_const_add_pc followed by special op: */ - opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA)*DWARF2_LINE_RANGE; - if (opcode <= 255) +/* Returns the current source information. If .file directives have + been encountered, the info for the corresponding source file is + returned. Otherwise, the info for the assembly source file is + returned. */ + +void +dwarf2_where (struct dwarf2_line_info *line) +{ + if (debug_type == DEBUG_DWARF2) { - out_opcode (DW_LNS_const_add_pc); - out_opcode (opcode); - return; + const char *filename = as_where (&line->line); + line->filenum = get_filenum (filename, 0); + line->column = 0; + line->flags = DWARF2_FLAG_IS_STMT; + line->isa = current.isa; + line->discriminator = current.discriminator; } + else + *line = current; +} - out_opcode (DW_LNS_advance_pc); - out_uleb128 (addr_delta); +/* A hook to allow the target backend to inform the line number state + machine of isa changes when assembler debug info is enabled. */ - if (line_delta) - out_opcode (tmp); /* output line-delta */ - else - out_opcode (DW_LNS_copy); /* append new row with current info */ +void +dwarf2_set_isa (unsigned int isa) +{ + current.isa = isa; } -static void -reset_state_machine () +/* Called for each machine instruction, or relatively atomic group of + machine instructions (ie built-in macro). The instruction or group + is SIZE bytes in length. If dwarf2 line number generation is called + for, emit a line statement appropriately. */ + +void +dwarf2_emit_insn (int size) { - static const struct dwarf2_sm initial_state = { INITIAL_STATE }; + struct dwarf2_line_info loc; + + if (!dwarf2_loc_directive_seen && debug_type != DEBUG_DWARF2) + return; + + dwarf2_where (&loc); - ls.sm = initial_state; + dwarf2_gen_line_info (frag_now_fix () - size, &loc); + dwarf2_consume_line_info (); } -/* Set an absolute address (may results in a relocation entry): */ -static void -out_set_addr (addr) - bfd_vma addr; +/* Move all previously-emitted line entries for the current position by + DELTA bytes. This function cannot be used to move the same entries + twice. */ + +void +dwarf2_move_insn (int delta) { - subsegT saved_subseg; - segT saved_seg; - expressionS expr; - symbolS *sym; + struct line_subseg *lss; + struct line_entry *e; + valueT now; - saved_seg = now_seg; - saved_subseg = now_subseg; + if (delta == 0) + return; - subseg_set (ls.text_seg, ls.text_subseg); - sym = symbol_new (".L0\001", now_seg, addr, frag_now); + lss = get_line_subseg (now_seg, now_subseg, FALSE); + if (!lss) + return; - subseg_set (saved_seg, saved_subseg); + now = frag_now_fix (); + while ((e = *lss->pmove_tail)) + { + if (S_GET_VALUE (e->label) == now) + S_SET_VALUE (e->label, now + delta); + lss->pmove_tail = &e->next; + } +} - out_opcode (DW_LNS_extended_op); - out_uleb128 (BYTES_PER_ADDRESS + 1); +/* Called after the current line information has been either used with + dwarf2_gen_line_info or saved with a machine instruction for later use. + This resets the state of the line number information to reflect that + it has been used. */ - out_opcode (DW_LNE_set_address); - expr.X_op = O_symbol; - expr.X_add_symbol = sym; - expr.X_add_number = 0; - emit_expr (&expr, BYTES_PER_ADDRESS); +void +dwarf2_consume_line_info (void) +{ + /* Unless we generate DWARF2 debugging information for each + assembler line, we only emit one line symbol for one LOC. */ + dwarf2_loc_directive_seen = FALSE; + + current.flags &= ~(DWARF2_FLAG_BASIC_BLOCK + | DWARF2_FLAG_PROLOGUE_END + | DWARF2_FLAG_EPILOGUE_BEGIN); + current.discriminator = 0; } -/* Emit DW_LNS_end_sequence and reset state machine. Does not - preserve the current segment/sub-segment! */ -static void -out_end_sequence () +/* Called for each (preferably code) label. If dwarf2_loc_mark_labels + is enabled, emit a basic block marker. */ + +void +dwarf2_emit_label (symbolS *label) +{ + struct dwarf2_line_info loc; + + if (!dwarf2_loc_mark_labels) + return; + if (S_GET_SEGMENT (label) != now_seg) + return; + if (!(bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE)) + return; + if (files_in_use == 0 && debug_type != DEBUG_DWARF2) + return; + + dwarf2_where (&loc); + + loc.flags |= DWARF2_FLAG_BASIC_BLOCK; + + dwarf2_gen_line_info_1 (label, &loc); + dwarf2_consume_line_info (); +} + +/* Get a .debug_line file number for FILENAME. If NUM is nonzero, + allocate it on that file table slot, otherwise return the first + empty one. */ + +static unsigned int +get_filenum (const char *filename, unsigned int num) { - bfd_vma addr, delta; + static unsigned int last_used, last_used_dir_len; + const char *file; + size_t dir_len; + unsigned int i, dir; - if (ls.text_seg) + if (num == 0 && last_used) { - subseg_set (ls.text_seg, ls.text_subseg); -#ifdef md_current_text_addr - addr = md_current_text_addr (); + if (! files[last_used].dir + && filename_cmp (filename, files[last_used].filename) == 0) + return last_used; + if (files[last_used].dir + && filename_ncmp (filename, dirs[files[last_used].dir], + last_used_dir_len) == 0 + && IS_DIR_SEPARATOR (filename [last_used_dir_len]) + && filename_cmp (filename + last_used_dir_len + 1, + files[last_used].filename) == 0) + return last_used; + } + + file = lbasename (filename); + /* Don't make empty string from / or A: from A:/ . */ +#ifdef HAVE_DOS_BASED_FILE_SYSTEM + if (file <= filename + 3) + file = filename; #else - addr = frag_now_fix (); + if (file == filename + 1) + file = filename; #endif - subseg_set (ls.line_seg, DL_BODY); - if (addr < ls.sm.addr) - { - out_set_addr (addr); - ls.sm.addr = addr; - } - else + dir_len = file - filename; + + dir = 0; + if (dir_len) + { +#ifndef DWARF2_DIR_SHOULD_END_WITH_SEPARATOR + --dir_len; +#endif + for (dir = 1; dir < dirs_in_use; ++dir) + if (filename_ncmp (filename, dirs[dir], dir_len) == 0 + && dirs[dir][dir_len] == '\0') + break; + + if (dir >= dirs_in_use) { - delta = addr - ls.sm.addr; - if (delta > 0) - gen_addr_line (0, delta / DWARF2_LINE_MIN_INSN_LENGTH); + if (dir >= dirs_allocated) + { + dirs_allocated = dir + 32; + dirs = XRESIZEVEC (char *, dirs, dirs_allocated); + } + + dirs[dir] = xmemdup0 (filename, dir_len); + dirs_in_use = dir + 1; } } + + if (num == 0) + { + for (i = 1; i < files_in_use; ++i) + if (files[i].dir == dir + && files[i].filename + && filename_cmp (file, files[i].filename) == 0) + { + last_used = i; + last_used_dir_len = dir_len; + return i; + } + } else - subseg_set (ls.line_seg, DL_BODY); + i = num; - out_opcode (DW_LNS_extended_op); - out_uleb128 (1); - out_byte (DW_LNE_end_sequence); + if (i >= files_allocated) + { + unsigned int old = files_allocated; + + files_allocated = i + 32; + files = XRESIZEVEC (struct file_entry, files, files_allocated); + + memset (files + old, 0, (i + 32 - old) * sizeof (struct file_entry)); + } + + files[i].filename = num ? file : xstrdup (file); + files[i].dir = dir; + if (files_in_use < i + 1) + files_in_use = i + 1; + last_used = i; + last_used_dir_len = dir_len; - reset_state_machine (); + return i; } -/* Look up a filenumber either by filename or by filenumber. If both - a filenumber and a filename are specified, lookup by filename takes - precedence. If the filename cannot be found, it is added to the - filetable the filenumber for the new entry is returned. */ -static int -get_filenum (filenum, file) - int filenum; - char *file; +/* Handle two forms of .file directive: + - Pass .file "source.c" to s_app_file + - Handle .file 1 "source.c" by adding an entry to the DWARF-2 file table + + If an entry is added to the file table, return a pointer to the filename. */ + +char * +dwarf2_directive_file (int dummy ATTRIBUTE_UNUSED) { - int i, last = filenum - 1; - char char0 = file[0]; + offsetT num; + char *filename; + int filename_len; - if ((unsigned) last >= ls.num_filenames) - last = ls.last_filename; + /* Continue to accept a bare string and pass it off. */ + SKIP_WHITESPACE (); + if (*input_line_pointer == '"') + { + s_app_file (0); + return NULL; + } - /* do a quick check against the previously used filename: */ - if (ls.num_filenames > 0 && ls.file[last].name[0] == char0 - && strcmp (ls.file[last].name + 1, file + 1) == 0) - return last + 1; + num = get_absolute_expression (); + filename = demand_copy_C_string (&filename_len); + if (filename == NULL) + return NULL; + demand_empty_rest_of_line (); - /* no match, fall back to simple linear scan: */ - for (i = 0; i < ls.num_filenames; ++i) + if (num < 1) { - if (ls.file[i].name[0] == char0 - && strcmp (ls.file[i].name + 1, file + 1) == 0) - { - ls.last_filename = i; - return i + 1; - } + as_bad (_("file number less than one")); + return NULL; } - /* no match: enter new filename */ - if (ls.num_filenames >= ls.filename_len) + /* A .file directive implies compiler generated debug information is + being supplied. Turn off gas generated debug info. */ + debug_type = DEBUG_NONE; + + if (num < (int) files_in_use && files[num].filename != 0) { - ls.filename_len += 13; - ls.file = xrealloc (ls.file, ls.filename_len * sizeof (ls.file[0])); + as_bad (_("file number %ld already allocated"), (long) num); + return NULL; } - ls.file[ls.num_filenames].dir = 0; - ls.file[ls.num_filenames].name = file; - return ++ls.num_filenames; + + get_filenum (filename, num); + + return filename; } void -dwarf2_gen_line_info (addr, l) - bfd_vma addr; - struct dwarf2_line_info *l; +dwarf2_directive_loc (int dummy ATTRIBUTE_UNUSED) { - unsigned int filenum = l->filenum; - unsigned int any_output = 0; - subsegT saved_subseg; - segT saved_seg; + offsetT filenum, line; + + /* If we see two .loc directives in a row, force the first one to be + output now. */ + if (dwarf2_loc_directive_seen) + dwarf2_emit_insn (0); - if (flag_debug) - fprintf (stderr, "line: addr %llx file `%s' line %u col %u flags %x\n", - (long long) addr, l->filename, l->line, l->column, l->flags); + filenum = get_absolute_expression (); + SKIP_WHITESPACE (); + line = get_absolute_expression (); - if (filenum > 0 && !l->filename) + if (filenum < 1) { - if (filenum >= ls.num_filenames) - { - as_warn ("Encountered bad file number in line number debug info!"); - return; - } + as_bad (_("file number less than one")); + return; } - else if (l->filename) - filenum = get_filenum (filenum, l->filename); - else - return; /* no filename, no filnum => no play */ - - if (!ls.line_seg) + if (filenum >= (int) files_in_use || files[filenum].filename == 0) { - ls.line_seg = subseg_new (".debug_line", 0); - bfd_set_section_flags (stdoutput, ls.line_seg, SEC_READONLY); - - /* We're going to need this symbol. */ - (void) section_symbol (ls.line_seg); + as_bad (_("unassigned file number %ld"), (long) filenum); + return; } - saved_seg = now_seg; - saved_subseg = now_subseg; - subseg_set (ls.line_seg, DL_BODY); + current.filenum = filenum; + current.line = line; + current.discriminator = 0; - if (ls.text_seg != saved_seg || ls.text_subseg != saved_subseg) +#ifndef NO_LISTING + if (listing) { - if (!ls.sm.empty_sequence) + if (files[filenum].dir) { - out_end_sequence (); /* terminate previous sequence */ - ls.sm.empty_sequence = 1; + size_t dir_len = strlen (dirs[files[filenum].dir]); + size_t file_len = strlen (files[filenum].filename); + char *cp = XNEWVEC (char, dir_len + 1 + file_len + 1); + + memcpy (cp, dirs[files[filenum].dir], dir_len); + INSERT_DIR_SEPARATOR (cp, dir_len); + memcpy (cp + dir_len + 1, files[filenum].filename, file_len); + cp[dir_len + file_len + 1] = '\0'; + listing_source_file (cp); + free (cp); } - any_output = 1; - ls.text_seg = saved_seg; - ls.text_subseg = saved_subseg; - out_set_addr (addr); - ls.sm.addr = addr; - } - - if (ls.sm.filenum != filenum) - { - any_output = 1; - out_opcode (DW_LNS_set_file); - out_uleb128 (filenum); - ls.sm.filenum = filenum; + else + listing_source_file (files[filenum].filename); + listing_source_line (line); } +#endif - if (ls.sm.column != l->column) + SKIP_WHITESPACE (); + if (ISDIGIT (*input_line_pointer)) { - any_output = 1; - out_opcode (DW_LNS_set_column); - out_uleb128 (l->column); - ls.sm.column = l->column; + current.column = get_absolute_expression (); + SKIP_WHITESPACE (); } - if (((l->flags & DWARF2_FLAG_BEGIN_STMT) != 0) != ls.sm.is_stmt) + while (ISALPHA (*input_line_pointer)) { - any_output = 1; - out_opcode (DW_LNS_negate_stmt); - } + char *p, c; + offsetT value; - if (l->flags & DWARF2_FLAG_BEGIN_BLOCK) - { - any_output = 1; - out_opcode (DW_LNS_set_basic_block); - } + c = get_symbol_name (& p); - if (ls.sm.line != l->line) - { - any_output = 1; - if (addr < ls.sm.addr) + if (strcmp (p, "basic_block") == 0) + { + current.flags |= DWARF2_FLAG_BASIC_BLOCK; + *input_line_pointer = c; + } + else if (strcmp (p, "prologue_end") == 0) + { + current.flags |= DWARF2_FLAG_PROLOGUE_END; + *input_line_pointer = c; + } + else if (strcmp (p, "epilogue_begin") == 0) + { + current.flags |= DWARF2_FLAG_EPILOGUE_BEGIN; + *input_line_pointer = c; + } + else if (strcmp (p, "is_stmt") == 0) { - if (!ls.sm.empty_sequence) + (void) restore_line_pointer (c); + value = get_absolute_expression (); + if (value == 0) + current.flags &= ~DWARF2_FLAG_IS_STMT; + else if (value == 1) + current.flags |= DWARF2_FLAG_IS_STMT; + else { - out_end_sequence (); - ls.sm.empty_sequence = 1; + as_bad (_("is_stmt value not 0 or 1")); + return; } - out_set_addr (addr); - ls.sm.addr = addr; } - gen_addr_line (l->line - ls.sm.line, - (addr - ls.sm.addr) / DWARF2_LINE_MIN_INSN_LENGTH); - ls.sm.basic_block = 0; - ls.sm.line = l->line; - ls.sm.addr = addr; - } - - subseg_set (saved_seg, saved_subseg); - - ls.num_line_entries += any_output; - if (any_output) - ls.sm.empty_sequence = 0; -} - -static void -gen_dir_list () -{ - char *str, *slash, *dir_list, *dp, *cp; - int i, j, num_dirs; - - dir_list = frag_more (0); - num_dirs = 0; - - for (i = 0; i < ls.num_filenames; ++i) - { - str = ls.file[i].name; - slash = strrchr (str, '/'); - if (slash) + else if (strcmp (p, "isa") == 0) { - *slash = '\0'; - for (j = 0, dp = dir_list; j < num_dirs; ++j) + (void) restore_line_pointer (c); + value = get_absolute_expression (); + if (value >= 0) + current.isa = value; + else { - if (strcmp (str, dp) == 0) - { - ls.file[i].dir = j; - break; - } - dp += strlen (dp); + as_bad (_("isa number less than zero")); + return; } - if (j >= num_dirs) + } + else if (strcmp (p, "discriminator") == 0) + { + (void) restore_line_pointer (c); + value = get_absolute_expression (); + if (value >= 0) + current.discriminator = value; + else { - /* didn't find this directory: append it to the list */ - size_t size = strlen (str) + 1; - cp = frag_more (size); - memcpy (cp, str, size); - ls.file[i].dir = ++num_dirs; + as_bad (_("discriminator less than zero")); + return; } - *slash = '/'; - ls.file[i].name = slash + 1; } + else + { + as_bad (_("unknown .loc sub-directive `%s'"), p); + (void) restore_line_pointer (c); + return; + } + + SKIP_WHITESPACE_AFTER_NAME (); } - out_byte ('\0'); /* terminate directory list */ + + demand_empty_rest_of_line (); + dwarf2_loc_directive_seen = TRUE; + debug_type = DEBUG_NONE; } -static void -gen_file_list () +void +dwarf2_directive_loc_mark_labels (int dummy ATTRIBUTE_UNUSED) { - size_t size; - char *cp; - int i; + offsetT value = get_absolute_expression (); - for (i = 0; i < ls.num_filenames; ++i) + if (value != 0 && value != 1) { - size = strlen (ls.file[i].name) + 1; - cp = frag_more (size); - memcpy (cp, ls.file[i].name, size); - - out_uleb128 (ls.file[i].dir); /* directory number */ - out_uleb128 (0); /* last modification timestamp */ - out_uleb128 (0); /* filesize */ + as_bad (_("expected 0 or 1")); + ignore_rest_of_line (); } - out_byte (0); /* terminate filename list */ + else + { + dwarf2_loc_mark_labels = value != 0; + demand_empty_rest_of_line (); + } +} + +static struct frag * +first_frag_for_seg (segT seg) +{ + return seg_info (seg)->frchainP->frch_root; } -static void -print_stats (total_size) - unsigned long total_size; +static struct frag * +last_frag_for_seg (segT seg) { - static const char *opc_name[] = - { - "extended", "copy", "advance_pc", "advance_line", "set_file", - "set_column", "negate_stmt", "set_basic_block", "const_add_pc", - "fixed_advance_pc" - }; - int i, j; + frchainS *f = seg_info (seg)->frchainP; - fprintf (stderr, "Average size: %g bytes/line\n", - total_size / (double) ls.num_line_entries); + while (f->frch_next != NULL) + f = f->frch_next; - fprintf (stderr, "\nStandard opcode histogram:\n"); + return f->frch_last; +} + +/* Emit a single byte into the current segment. */ - for (i = 0; i < sizeof (opc_name)/sizeof (opc_name[0]); ++i) - { - fprintf (stderr, "%s", opc_name[i]); - for (j = strlen (opc_name[i]); j < 16; ++j) - fprintf (stderr, " "); - fprintf (stderr, ": %u\n", ls.opcode_hist[i]); - } +static inline void +out_byte (int byte) +{ + FRAG_APPEND_1_CHAR (byte); +} - fprintf (stderr, "\nSpecial opcodes:\naddr\t\t\t\tline skip\n"); +/* Emit a statement program opcode into the current segment. */ - fprintf (stderr, "skip: "); - for (j = DWARF2_LINE_BASE; j < DWARF2_LINE_BASE + DWARF2_LINE_RANGE; ++j) - fprintf (stderr, "%3d", j); - fprintf (stderr, "\n-----"); +static inline void +out_opcode (int opc) +{ + out_byte (opc); +} - for (; i < 256; ++i) - { - j = SPECIAL_LINE (i); - if (j == DWARF2_LINE_BASE) - fprintf (stderr, "\n%4u: ", - DWARF2_LINE_MIN_INSN_LENGTH*SPECIAL_ADDR (i)); - fprintf (stderr, " %2u", ls.opcode_hist[i]); - } - fprintf (stderr, "\n"); +/* Emit a two-byte word into the current segment. */ + +static inline void +out_two (int data) +{ + md_number_to_chars (frag_more (2), data, 2); } -void -dwarf2_finish () +/* Emit a four byte word into the current segment. */ + +static inline void +out_four (int data) { - bfd_vma body_size, total_size, prolog_size; - subsegT saved_subseg; - segT saved_seg; - char *cp; + md_number_to_chars (frag_more (4), data, 4); +} - if (!ls.line_seg) - /* no .debug_line segment, no work to do... */ - return; +/* Emit an unsigned "little-endian base 128" number. */ - saved_seg = now_seg; - saved_subseg = now_subseg; +static void +out_uleb128 (addressT value) +{ + output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0); +} - if (!ls.sm.empty_sequence) - out_end_sequence (); - total_size = body_size = frag_now_fix (); +/* Emit a signed "little-endian base 128" number. */ - /* now generate the directory and file lists: */ - subseg_set (ls.line_seg, DL_FILES); - gen_dir_list (); - gen_file_list (); - total_size += frag_now_fix (); +static void +out_leb128 (addressT value) +{ + output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); +} - /* and now the header ("statement program prolog", in DWARF2 lingo...) */ - subseg_set (ls.line_seg, DL_PROLOG); +/* Emit a tuple for .debug_abbrev. */ - cp = frag_more (15 + DWARF2_LINE_OPCODE_BASE - 1); +static inline void +out_abbrev (int name, int form) +{ + out_uleb128 (name); + out_uleb128 (form); +} - total_size += frag_now_fix (); - prolog_size = total_size - body_size - 10; +/* Get the size of a fragment. */ -# define STUFF(val,size) md_number_to_chars (cp, val, size); cp += size; - STUFF (total_size - 4, 4); /* length */ - STUFF (2, 2); /* version */ - STUFF (prolog_size, 4); /* prologue_length */ - STUFF (DWARF2_LINE_MIN_INSN_LENGTH, 1); - STUFF (DWARF2_LINE_DEFAULT_IS_STMT, 1); - STUFF (DWARF2_LINE_BASE, 1); - STUFF (DWARF2_LINE_RANGE, 1); - STUFF (DWARF2_LINE_OPCODE_BASE, 1); +static offsetT +get_frag_fix (fragS *frag, segT seg) +{ + frchainS *fr; - /* standard_opcode_lengths: */ - STUFF (0, 1); /* DW_LNS_copy */ - STUFF (1, 1); /* DW_LNS_advance_pc */ - STUFF (1, 1); /* DW_LNS_advance_line */ - STUFF (1, 1); /* DW_LNS_set_file */ - STUFF (1, 1); /* DW_LNS_set_column */ - STUFF (0, 1); /* DW_LNS_negate_stmt */ - STUFF (0, 1); /* DW_LNS_set_basic_block */ - STUFF (0, 1); /* DW_LNS_const_add_pc */ - STUFF (1, 1); /* DW_LNS_fixed_advance_pc */ + if (frag->fr_next) + return frag->fr_fix; - subseg_set (saved_seg, saved_subseg); + /* If a fragment is the last in the chain, special measures must be + taken to find its size before relaxation, since it may be pending + on some subsegment chain. */ + for (fr = seg_info (seg)->frchainP; fr; fr = fr->frch_next) + if (fr->frch_last == frag) + return (char *) obstack_next_free (&fr->frch_obstack) - frag->fr_literal; - if (flag_debug) - print_stats (total_size); + abort (); } -void -dwarf2_directive_file (dummy) - int dummy; -{ - int len; +/* Set an absolute address (may result in a relocation entry). */ - /* Continue to accept a bare string and pass it off. */ - SKIP_WHITESPACE (); - if (*input_line_pointer == '"') - { - s_app_file (0); - return; - } +static void +out_set_addr (symbolS *sym) +{ + expressionS exp; - ls.any_dwarf2_directives = 1; + out_opcode (DW_LNS_extended_op); + out_uleb128 (sizeof_address + 1); - if (debug_type == DEBUG_NONE) - /* Automatically turn on DWARF2 debug info unless something else - has been selected. */ - debug_type = DEBUG_DWARF2; + out_opcode (DW_LNE_set_address); + exp.X_op = O_symbol; + exp.X_add_symbol = sym; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_address); +} - ls.current.filenum = get_absolute_expression (); - ls.current.filename = demand_copy_C_string (&len); +static void scale_addr_delta (addressT *); - demand_empty_rest_of_line (); +static void +scale_addr_delta (addressT *addr_delta) +{ + static int printed_this = 0; + if (DWARF2_LINE_MIN_INSN_LENGTH > 1) + { + if (*addr_delta % DWARF2_LINE_MIN_INSN_LENGTH != 0 && !printed_this) + { + as_bad("unaligned opcodes detected in executable segment"); + printed_this = 1; + } + *addr_delta /= DWARF2_LINE_MIN_INSN_LENGTH; + } } +/* Encode a pair of line and address skips as efficiently as possible. + Note that the line skip is signed, whereas the address skip is unsigned. + + The following two routines *must* be kept in sync. This is + enforced by making emit_inc_line_addr abort if we do not emit + exactly the expected number of bytes. */ + +static int +size_inc_line_addr (int line_delta, addressT addr_delta) +{ + unsigned int tmp, opcode; + int len = 0; + + /* Scale the address delta by the minimum instruction length. */ + scale_addr_delta (&addr_delta); + + /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. + We cannot use special opcodes here, since we want the end_sequence + to emit the matrix entry. */ + if (line_delta == INT_MAX) + { + if (addr_delta == MAX_SPECIAL_ADDR_DELTA) + len = 1; + else + len = 1 + sizeof_leb128 (addr_delta, 0); + return len + 3; + } + + /* Bias the line delta by the base. */ + tmp = line_delta - DWARF2_LINE_BASE; + + /* If the line increment is out of range of a special opcode, we + must encode it with DW_LNS_advance_line. */ + if (tmp >= DWARF2_LINE_RANGE) + { + len = 1 + sizeof_leb128 (line_delta, 1); + line_delta = 0; + tmp = 0 - DWARF2_LINE_BASE; + } + + /* Bias the opcode by the special opcode base. */ + tmp += DWARF2_LINE_OPCODE_BASE; + + /* Avoid overflow when addr_delta is large. */ + if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA) + { + /* Try using a special opcode. */ + opcode = tmp + addr_delta * DWARF2_LINE_RANGE; + if (opcode <= 255) + return len + 1; + + /* Try using DW_LNS_const_add_pc followed by special op. */ + opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE; + if (opcode <= 255) + return len + 2; + } + + /* Otherwise use DW_LNS_advance_pc. */ + len += 1 + sizeof_leb128 (addr_delta, 0); + + /* DW_LNS_copy or special opcode. */ + len += 1; + + return len; +} + +static void +emit_inc_line_addr (int line_delta, addressT addr_delta, char *p, int len) +{ + unsigned int tmp, opcode; + int need_copy = 0; + char *end = p + len; + + /* Line number sequences cannot go backward in addresses. This means + we've incorrectly ordered the statements in the sequence. */ + gas_assert ((offsetT) addr_delta >= 0); + + /* Scale the address delta by the minimum instruction length. */ + scale_addr_delta (&addr_delta); + + /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. + We cannot use special opcodes here, since we want the end_sequence + to emit the matrix entry. */ + if (line_delta == INT_MAX) + { + if (addr_delta == MAX_SPECIAL_ADDR_DELTA) + *p++ = DW_LNS_const_add_pc; + else + { + *p++ = DW_LNS_advance_pc; + p += output_leb128 (p, addr_delta, 0); + } + + *p++ = DW_LNS_extended_op; + *p++ = 1; + *p++ = DW_LNE_end_sequence; + goto done; + } + + /* Bias the line delta by the base. */ + tmp = line_delta - DWARF2_LINE_BASE; + + /* If the line increment is out of range of a special opcode, we + must encode it with DW_LNS_advance_line. */ + if (tmp >= DWARF2_LINE_RANGE) + { + *p++ = DW_LNS_advance_line; + p += output_leb128 (p, line_delta, 1); + + line_delta = 0; + tmp = 0 - DWARF2_LINE_BASE; + need_copy = 1; + } + + /* Prettier, I think, to use DW_LNS_copy instead of a "line +0, addr +0" + special opcode. */ + if (line_delta == 0 && addr_delta == 0) + { + *p++ = DW_LNS_copy; + goto done; + } + + /* Bias the opcode by the special opcode base. */ + tmp += DWARF2_LINE_OPCODE_BASE; + + /* Avoid overflow when addr_delta is large. */ + if (addr_delta < 256 + MAX_SPECIAL_ADDR_DELTA) + { + /* Try using a special opcode. */ + opcode = tmp + addr_delta * DWARF2_LINE_RANGE; + if (opcode <= 255) + { + *p++ = opcode; + goto done; + } + + /* Try using DW_LNS_const_add_pc followed by special op. */ + opcode = tmp + (addr_delta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE; + if (opcode <= 255) + { + *p++ = DW_LNS_const_add_pc; + *p++ = opcode; + goto done; + } + } + + /* Otherwise use DW_LNS_advance_pc. */ + *p++ = DW_LNS_advance_pc; + p += output_leb128 (p, addr_delta, 0); + + if (need_copy) + *p++ = DW_LNS_copy; + else + *p++ = tmp; + + done: + gas_assert (p == end); +} + +/* Handy routine to combine calls to the above two routines. */ + +static void +out_inc_line_addr (int line_delta, addressT addr_delta) +{ + int len = size_inc_line_addr (line_delta, addr_delta); + emit_inc_line_addr (line_delta, addr_delta, frag_more (len), len); +} + +/* Write out an alternative form of line and address skips using + DW_LNS_fixed_advance_pc opcodes. This uses more space than the default + line and address information, but it is required if linker relaxation + could change the code offsets. The following two routines *must* be + kept in sync. */ +#define ADDR_DELTA_LIMIT 50000 + +static int +size_fixed_inc_line_addr (int line_delta, addressT addr_delta) +{ + int len = 0; + + /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */ + if (line_delta != INT_MAX) + len = 1 + sizeof_leb128 (line_delta, 1); + + if (addr_delta > ADDR_DELTA_LIMIT) + { + /* DW_LNS_extended_op */ + len += 1 + sizeof_leb128 (sizeof_address + 1, 0); + /* DW_LNE_set_address */ + len += 1 + sizeof_address; + } + else + /* DW_LNS_fixed_advance_pc */ + len += 3; + + if (line_delta == INT_MAX) + /* DW_LNS_extended_op + DW_LNE_end_sequence */ + len += 3; + else + /* DW_LNS_copy */ + len += 1; + + return len; +} + +static void +emit_fixed_inc_line_addr (int line_delta, addressT addr_delta, fragS *frag, + char *p, int len) +{ + expressionS *pexp; + char *end = p + len; + + /* Line number sequences cannot go backward in addresses. This means + we've incorrectly ordered the statements in the sequence. */ + gas_assert ((offsetT) addr_delta >= 0); + + /* Verify that we have kept in sync with size_fixed_inc_line_addr. */ + gas_assert (len == size_fixed_inc_line_addr (line_delta, addr_delta)); + + /* INT_MAX is a signal that this is actually a DW_LNE_end_sequence. */ + if (line_delta != INT_MAX) + { + *p++ = DW_LNS_advance_line; + p += output_leb128 (p, line_delta, 1); + } + + pexp = symbol_get_value_expression (frag->fr_symbol); + + /* The DW_LNS_fixed_advance_pc opcode has a 2-byte operand so it can + advance the address by at most 64K. Linker relaxation (without + which this function would not be used) could change the operand by + an unknown amount. If the address increment is getting close to + the limit, just reset the address. */ + if (addr_delta > ADDR_DELTA_LIMIT) + { + symbolS *to_sym; + expressionS exp; + + gas_assert (pexp->X_op == O_subtract); + to_sym = pexp->X_add_symbol; + + *p++ = DW_LNS_extended_op; + p += output_leb128 (p, sizeof_address + 1, 0); + *p++ = DW_LNE_set_address; + exp.X_op = O_symbol; + exp.X_add_symbol = to_sym; + exp.X_add_number = 0; + emit_expr_fix (&exp, sizeof_address, frag, p, TC_PARSE_CONS_RETURN_NONE); + p += sizeof_address; + } + else + { + *p++ = DW_LNS_fixed_advance_pc; + emit_expr_fix (pexp, 2, frag, p, TC_PARSE_CONS_RETURN_NONE); + p += 2; + } + + if (line_delta == INT_MAX) + { + *p++ = DW_LNS_extended_op; + *p++ = 1; + *p++ = DW_LNE_end_sequence; + } + else + *p++ = DW_LNS_copy; + + gas_assert (p == end); +} + +/* Generate a variant frag that we can use to relax address/line + increments between fragments of the target segment. */ + +static void +relax_inc_line_addr (int line_delta, symbolS *to_sym, symbolS *from_sym) +{ + expressionS exp; + int max_chars; + + exp.X_op = O_subtract; + exp.X_add_symbol = to_sym; + exp.X_op_symbol = from_sym; + exp.X_add_number = 0; + + /* The maximum size of the frag is the line delta with a maximum + sized address delta. */ + if (DWARF2_USE_FIXED_ADVANCE_PC) + max_chars = size_fixed_inc_line_addr (line_delta, + -DWARF2_LINE_MIN_INSN_LENGTH); + else + max_chars = size_inc_line_addr (line_delta, -DWARF2_LINE_MIN_INSN_LENGTH); + + frag_var (rs_dwarf2dbg, max_chars, max_chars, 1, + make_expr_symbol (&exp), line_delta, NULL); +} + +/* The function estimates the size of a rs_dwarf2dbg variant frag + based on the current values of the symbols. It is called before + the relaxation loop. We set fr_subtype to the expected length. */ + +int +dwarf2dbg_estimate_size_before_relax (fragS *frag) +{ + offsetT addr_delta; + int size; + + addr_delta = resolve_symbol_value (frag->fr_symbol); + if (DWARF2_USE_FIXED_ADVANCE_PC) + size = size_fixed_inc_line_addr (frag->fr_offset, addr_delta); + else + size = size_inc_line_addr (frag->fr_offset, addr_delta); + + frag->fr_subtype = size; + + return size; +} + +/* This function relaxes a rs_dwarf2dbg variant frag based on the + current values of the symbols. fr_subtype is the current length + of the frag. This returns the change in frag length. */ + +int +dwarf2dbg_relax_frag (fragS *frag) +{ + int old_size, new_size; + + old_size = frag->fr_subtype; + new_size = dwarf2dbg_estimate_size_before_relax (frag); + + return new_size - old_size; +} + +/* This function converts a rs_dwarf2dbg variant frag into a normal + fill frag. This is called after all relaxation has been done. + fr_subtype will be the desired length of the frag. */ + void -dwarf2_directive_loc (dummy) - int dummy; +dwarf2dbg_convert_frag (fragS *frag) { - ls.any_dwarf2_directives = 1; + offsetT addr_diff; - ls.current.filenum = get_absolute_expression (); - SKIP_WHITESPACE (); - ls.current.line = get_absolute_expression (); - SKIP_WHITESPACE (); - ls.current.column = get_absolute_expression (); - demand_empty_rest_of_line (); + if (DWARF2_USE_FIXED_ADVANCE_PC) + { + /* If linker relaxation is enabled then the distance bewteen the two + symbols in the frag->fr_symbol expression might change. Hence we + cannot rely upon the value computed by resolve_symbol_value. + Instead we leave the expression unfinalized and allow + emit_fixed_inc_line_addr to create a fixup (which later becomes a + relocation) that will allow the linker to correctly compute the + actual address difference. We have to use a fixed line advance for + this as we cannot (easily) relocate leb128 encoded values. */ + int saved_finalize_syms = finalize_syms; + + finalize_syms = 0; + addr_diff = resolve_symbol_value (frag->fr_symbol); + finalize_syms = saved_finalize_syms; + } + else + addr_diff = resolve_symbol_value (frag->fr_symbol); - ls.current.flags = DWARF2_FLAG_BEGIN_STMT; + /* fr_var carries the max_chars that we created the fragment with. + fr_subtype carries the current expected length. We must, of + course, have allocated enough memory earlier. */ + gas_assert (frag->fr_var >= (int) frag->fr_subtype); -#ifndef NO_LISTING - if (listing) - listing_source_line (ls.current.line); + if (DWARF2_USE_FIXED_ADVANCE_PC) + emit_fixed_inc_line_addr (frag->fr_offset, addr_diff, frag, + frag->fr_literal + frag->fr_fix, + frag->fr_subtype); + else + emit_inc_line_addr (frag->fr_offset, addr_diff, + frag->fr_literal + frag->fr_fix, frag->fr_subtype); + + frag->fr_fix += frag->fr_subtype; + frag->fr_type = rs_fill; + frag->fr_var = 0; + frag->fr_offset = 0; +} + +/* Generate .debug_line content for the chain of line number entries + beginning at E, for segment SEG. */ + +static void +process_entries (segT seg, struct line_entry *e) +{ + unsigned filenum = 1; + unsigned line = 1; + unsigned column = 0; + unsigned isa = 0; + unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0; + fragS *last_frag = NULL, *frag; + addressT last_frag_ofs = 0, frag_ofs; + symbolS *last_lab = NULL, *lab; + struct line_entry *next; + + if (flag_dwarf_sections) + { + char * name; + const char * sec_name; + + /* Switch to the relevent sub-section before we start to emit + the line number table. + + FIXME: These sub-sections do not have a normal Line Number + Program Header, thus strictly speaking they are not valid + DWARF sections. Unfortunately the DWARF standard assumes + a one-to-one relationship between compilation units and + line number tables. Thus we have to have a .debug_line + section, as well as our sub-sections, and we have to ensure + that all of the sub-sections are merged into a proper + .debug_line section before a debugger sees them. */ + + sec_name = bfd_get_section_name (stdoutput, seg); + if (strcmp (sec_name, ".text") != 0) + { + name = concat (".debug_line", sec_name, (char *) NULL); + subseg_set (subseg_get (name, FALSE), 0); + } + else + /* Don't create a .debug_line.text section - + that is redundant. Instead just switch back to the + normal .debug_line section. */ + subseg_set (subseg_get (".debug_line", FALSE), 0); + } + + do + { + int line_delta; + + if (filenum != e->loc.filenum) + { + filenum = e->loc.filenum; + out_opcode (DW_LNS_set_file); + out_uleb128 (filenum); + } + + if (column != e->loc.column) + { + column = e->loc.column; + out_opcode (DW_LNS_set_column); + out_uleb128 (column); + } + + if (e->loc.discriminator != 0) + { + out_opcode (DW_LNS_extended_op); + out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0)); + out_opcode (DW_LNE_set_discriminator); + out_uleb128 (e->loc.discriminator); + } + + if (isa != e->loc.isa) + { + isa = e->loc.isa; + out_opcode (DW_LNS_set_isa); + out_uleb128 (isa); + } + + if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT) + { + flags = e->loc.flags; + out_opcode (DW_LNS_negate_stmt); + } + + if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK) + out_opcode (DW_LNS_set_basic_block); + + if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END) + out_opcode (DW_LNS_set_prologue_end); + + if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN) + out_opcode (DW_LNS_set_epilogue_begin); + + /* Don't try to optimize away redundant entries; gdb wants two + entries for a function where the code starts on the same line as + the {, and there's no way to identify that case here. Trust gcc + to optimize appropriately. */ + line_delta = e->loc.line - line; + lab = e->label; + frag = symbol_get_frag (lab); + frag_ofs = S_GET_VALUE (lab); + + if (last_frag == NULL) + { + out_set_addr (lab); + out_inc_line_addr (line_delta, 0); + } + else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC) + out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs); + else + relax_inc_line_addr (line_delta, lab, last_lab); + + line = e->loc.line; + last_lab = lab; + last_frag = frag; + last_frag_ofs = frag_ofs; + + next = e->next; + free (e); + e = next; + } + while (e); + + /* Emit a DW_LNE_end_sequence for the end of the section. */ + frag = last_frag_for_seg (seg); + frag_ofs = get_frag_fix (frag, seg); + if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC) + out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs); + else + { + lab = symbol_temp_new (seg, frag_ofs, frag); + relax_inc_line_addr (INT_MAX, lab, last_lab); + } +} + +/* Emit the directory and file tables for .debug_line. */ + +static void +out_file_list (void) +{ + size_t size; + const char *dir; + char *cp; + unsigned int i; + + /* Emit directory list. */ + for (i = 1; i < dirs_in_use; ++i) + { + dir = remap_debug_filename (dirs[i]); + size = strlen (dir) + 1; + cp = frag_more (size); + memcpy (cp, dir, size); + } + /* Terminate it. */ + out_byte ('\0'); + + for (i = 1; i < files_in_use; ++i) + { + const char *fullfilename; + + if (files[i].filename == NULL) + { + as_bad (_("unassigned file number %ld"), (long) i); + /* Prevent a crash later, particularly for file 1. */ + files[i].filename = ""; + continue; + } + + fullfilename = DWARF2_FILE_NAME (files[i].filename, + files[i].dir ? dirs [files [i].dir] : ""); + size = strlen (fullfilename) + 1; + cp = frag_more (size); + memcpy (cp, fullfilename, size); + + out_uleb128 (files[i].dir); /* directory number */ + /* Output the last modification timestamp. */ + out_uleb128 (DWARF2_FILE_TIME_NAME (files[i].filename, + files[i].dir ? dirs [files [i].dir] : "")); + /* Output the filesize. */ + out_uleb128 (DWARF2_FILE_SIZE_NAME (files[i].filename, + files[i].dir ? dirs [files [i].dir] : "")); + } + + /* Terminate filename list. */ + out_byte (0); +} + +/* Switch to SEC and output a header length field. Return the size of + offsets used in SEC. The caller must set EXPR->X_add_symbol value + to the end of the section. EXPR->X_add_number will be set to the + negative size of the header. */ + +static int +out_header (asection *sec, expressionS *exp) +{ + symbolS *start_sym; + symbolS *end_sym; + + subseg_set (sec, 0); + + if (flag_dwarf_sections) + { + /* If we are going to put the start and end symbols in different + sections, then we need real symbols, not just fake, local ones. */ + frag_now_fix (); + start_sym = symbol_make (".Ldebug_line_start"); + end_sym = symbol_make (".Ldebug_line_end"); + symbol_set_value_now (start_sym); + } + else + { + start_sym = symbol_temp_new_now (); + end_sym = symbol_temp_make (); + } + + /* Total length of the information. */ + exp->X_op = O_subtract; + exp->X_add_symbol = end_sym; + exp->X_op_symbol = start_sym; + + switch (DWARF2_FORMAT (sec)) + { + case dwarf2_format_32bit: + exp->X_add_number = -4; + emit_expr (exp, 4); + return 4; + + case dwarf2_format_64bit: + exp->X_add_number = -12; + out_four (-1); + emit_expr (exp, 8); + return 8; + + case dwarf2_format_64bit_irix: + exp->X_add_number = -8; + emit_expr (exp, 8); + return 8; + } + + as_fatal (_("internal error: unknown dwarf2 format")); + return 0; +} + +/* Emit the collected .debug_line data. */ + +static void +out_debug_line (segT line_seg) +{ + expressionS exp; + symbolS *prologue_start, *prologue_end; + symbolS *line_end; + struct line_seg *s; + int sizeof_offset; + + sizeof_offset = out_header (line_seg, &exp); + line_end = exp.X_add_symbol; + + /* Version. */ + out_two (DWARF2_LINE_VERSION); + + /* Length of the prologue following this length. */ + prologue_start = symbol_temp_make (); + prologue_end = symbol_temp_make (); + exp.X_op = O_subtract; + exp.X_add_symbol = prologue_end; + exp.X_op_symbol = prologue_start; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_offset); + symbol_set_value_now (prologue_start); + + /* Parameters of the state machine. */ + out_byte (DWARF2_LINE_MIN_INSN_LENGTH); + out_byte (DWARF2_LINE_DEFAULT_IS_STMT); + out_byte (DWARF2_LINE_BASE); + out_byte (DWARF2_LINE_RANGE); + out_byte (DWARF2_LINE_OPCODE_BASE); + + /* Standard opcode lengths. */ + out_byte (0); /* DW_LNS_copy */ + out_byte (1); /* DW_LNS_advance_pc */ + out_byte (1); /* DW_LNS_advance_line */ + out_byte (1); /* DW_LNS_set_file */ + out_byte (1); /* DW_LNS_set_column */ + out_byte (0); /* DW_LNS_negate_stmt */ + out_byte (0); /* DW_LNS_set_basic_block */ + out_byte (0); /* DW_LNS_const_add_pc */ + out_byte (1); /* DW_LNS_fixed_advance_pc */ + out_byte (0); /* DW_LNS_set_prologue_end */ + out_byte (0); /* DW_LNS_set_epilogue_begin */ + out_byte (1); /* DW_LNS_set_isa */ + + out_file_list (); + + symbol_set_value_now (prologue_end); + + /* For each section, emit a statement program. */ + for (s = all_segs; s; s = s->next) + if (SEG_NORMAL (s->seg)) + process_entries (s->seg, s->head->head); + else + as_warn ("dwarf line number information for %s ignored", + segment_name (s->seg)); + + if (flag_dwarf_sections) + /* We have to switch to the special .debug_line_end section + before emitting the end-of-debug_line symbol. The linker + script arranges for this section to be placed after all the + (potentially garbage collected) .debug_line. sections. + This section contains the line_end symbol which is used to + compute the size of the linked .debug_line section, as seen + in the DWARF Line Number header. */ + subseg_set (subseg_get (".debug_line_end", FALSE), 0); + + symbol_set_value_now (line_end); +} + +static void +out_debug_ranges (segT ranges_seg) +{ + unsigned int addr_size = sizeof_address; + struct line_seg *s; + expressionS exp; + unsigned int i; + + subseg_set (ranges_seg, 0); + + /* Base Address Entry. */ + for (i = 0; i < addr_size; i++) + out_byte (0xff); + for (i = 0; i < addr_size; i++) + out_byte (0); + + /* Range List Entry. */ + for (s = all_segs; s; s = s->next) + { + fragS *frag; + symbolS *beg, *end; + + frag = first_frag_for_seg (s->seg); + beg = symbol_temp_new (s->seg, 0, frag); + s->text_start = beg; + + frag = last_frag_for_seg (s->seg); + end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag); + s->text_end = end; + + exp.X_op = O_symbol; + exp.X_add_symbol = beg; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); + + exp.X_op = O_symbol; + exp.X_add_symbol = end; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); + } + + /* End of Range Entry. */ + for (i = 0; i < addr_size; i++) + out_byte (0); + for (i = 0; i < addr_size; i++) + out_byte (0); +} + +/* Emit data for .debug_aranges. */ + +static void +out_debug_aranges (segT aranges_seg, segT info_seg) +{ + unsigned int addr_size = sizeof_address; + offsetT size; + struct line_seg *s; + expressionS exp; + symbolS *aranges_end; + char *p; + int sizeof_offset; + + sizeof_offset = out_header (aranges_seg, &exp); + aranges_end = exp.X_add_symbol; + size = -exp.X_add_number; + + /* Version. */ + out_two (DWARF2_ARANGES_VERSION); + size += 2; + + /* Offset to .debug_info. */ + TC_DWARF2_EMIT_OFFSET (section_symbol (info_seg), sizeof_offset); + size += sizeof_offset; + + /* Size of an address (offset portion). */ + out_byte (addr_size); + size++; + + /* Size of a segment descriptor. */ + out_byte (0); + size++; + + /* Align the header. */ + while ((size++ % (2 * addr_size)) > 0) + out_byte (0); + + for (s = all_segs; s; s = s->next) + { + fragS *frag; + symbolS *beg, *end; + + frag = first_frag_for_seg (s->seg); + beg = symbol_temp_new (s->seg, 0, frag); + s->text_start = beg; + + frag = last_frag_for_seg (s->seg); + end = symbol_temp_new (s->seg, get_frag_fix (frag, s->seg), frag); + s->text_end = end; + + exp.X_op = O_symbol; + exp.X_add_symbol = beg; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); + + exp.X_op = O_subtract; + exp.X_add_symbol = end; + exp.X_op_symbol = beg; + exp.X_add_number = 0; + emit_expr (&exp, addr_size); + } + + p = frag_more (2 * addr_size); + md_number_to_chars (p, 0, addr_size); + md_number_to_chars (p + addr_size, 0, addr_size); + + symbol_set_value_now (aranges_end); +} + +/* Emit data for .debug_abbrev. Note that this must be kept in + sync with out_debug_info below. */ + +static void +out_debug_abbrev (segT abbrev_seg, + segT info_seg ATTRIBUTE_UNUSED, + segT line_seg ATTRIBUTE_UNUSED) +{ + subseg_set (abbrev_seg, 0); + + out_uleb128 (1); + out_uleb128 (DW_TAG_compile_unit); + out_byte (DW_CHILDREN_no); + if (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit) + out_abbrev (DW_AT_stmt_list, DW_FORM_data4); + else + out_abbrev (DW_AT_stmt_list, DW_FORM_data8); + if (all_segs->next == NULL) + { + out_abbrev (DW_AT_low_pc, DW_FORM_addr); + if (DWARF2_VERSION < 4) + out_abbrev (DW_AT_high_pc, DW_FORM_addr); + else + out_abbrev (DW_AT_high_pc, (sizeof_address == 4 + ? DW_FORM_data4 : DW_FORM_data8)); + } + else + { + if (DWARF2_FORMAT (info_seg) == dwarf2_format_32bit) + out_abbrev (DW_AT_ranges, DW_FORM_data4); + else + out_abbrev (DW_AT_ranges, DW_FORM_data8); + } + out_abbrev (DW_AT_name, DW_FORM_string); + out_abbrev (DW_AT_comp_dir, DW_FORM_string); + out_abbrev (DW_AT_producer, DW_FORM_string); + out_abbrev (DW_AT_language, DW_FORM_data2); + out_abbrev (0, 0); + + /* Terminate the abbreviations for this compilation unit. */ + out_byte (0); +} + +/* Emit a description of this compilation unit for .debug_info. */ + +static void +out_debug_info (segT info_seg, segT abbrev_seg, segT line_seg, segT ranges_seg) +{ + char producer[128]; + const char *comp_dir; + const char *dirname; + expressionS exp; + symbolS *info_end; + char *p; + int len; + int sizeof_offset; + + sizeof_offset = out_header (info_seg, &exp); + info_end = exp.X_add_symbol; + + /* DWARF version. */ + out_two (DWARF2_VERSION); + + /* .debug_abbrev offset */ + TC_DWARF2_EMIT_OFFSET (section_symbol (abbrev_seg), sizeof_offset); + + /* Target address size. */ + out_byte (sizeof_address); + + /* DW_TAG_compile_unit DIE abbrev */ + out_uleb128 (1); + + /* DW_AT_stmt_list */ + TC_DWARF2_EMIT_OFFSET (section_symbol (line_seg), + (DWARF2_FORMAT (line_seg) == dwarf2_format_32bit + ? 4 : 8)); + + /* These two attributes are emitted if all of the code is contiguous. */ + if (all_segs->next == NULL) + { + /* DW_AT_low_pc */ + exp.X_op = O_symbol; + exp.X_add_symbol = all_segs->text_start; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_address); + + /* DW_AT_high_pc */ + if (DWARF2_VERSION < 4) + exp.X_op = O_symbol; + else + { + exp.X_op = O_subtract; + exp.X_op_symbol = all_segs->text_start; + } + exp.X_add_symbol = all_segs->text_end; + exp.X_add_number = 0; + emit_expr (&exp, sizeof_address); + } + else + { + /* This attribute is emitted if the code is disjoint. */ + /* DW_AT_ranges. */ + TC_DWARF2_EMIT_OFFSET (section_symbol (ranges_seg), sizeof_offset); + } + + /* DW_AT_name. We don't have the actual file name that was present + on the command line, so assume files[1] is the main input file. + We're not supposed to get called unless at least one line number + entry was emitted, so this should always be defined. */ + if (files_in_use == 0) + abort (); + if (files[1].dir) + { + dirname = remap_debug_filename (dirs[files[1].dir]); + len = strlen (dirname); +#ifdef TE_VMS + /* Already has trailing slash. */ + p = frag_more (len); + memcpy (p, dirname, len); +#else + p = frag_more (len + 1); + memcpy (p, dirname, len); + INSERT_DIR_SEPARATOR (p, len); #endif + } + len = strlen (files[1].filename) + 1; + p = frag_more (len); + memcpy (p, files[1].filename, len); + + /* DW_AT_comp_dir */ + comp_dir = remap_debug_filename (getpwd ()); + len = strlen (comp_dir) + 1; + p = frag_more (len); + memcpy (p, comp_dir, len); + + /* DW_AT_producer */ + sprintf (producer, "GNU AS %s", VERSION); + len = strlen (producer) + 1; + p = frag_more (len); + memcpy (p, producer, len); + + /* DW_AT_language. Yes, this is probably not really MIPS, but the + dwarf2 draft has no standard code for assembler. */ + out_two (DW_LANG_Mips_Assembler); + + symbol_set_value_now (info_end); } void -dwarf2_where (line) - struct dwarf2_line_info *line; +dwarf2_init (void) { - if (ls.any_dwarf2_directives) - *line = ls.current; - else + last_seg_ptr = &all_segs; +} + + +/* Finish the dwarf2 debug sections. We emit .debug.line if there + were any .file/.loc directives, or --gdwarf2 was given, or if the + file has a non-empty .debug_info section and an empty .debug_line + section. If we emit .debug_line, and the .debug_info section is + empty, we also emit .debug_info, .debug_aranges and .debug_abbrev. + ALL_SEGS will be non-null if there were any .file/.loc directives, + or --gdwarf2 was given and there were any located instructions + emitted. */ + +void +dwarf2_finish (void) +{ + segT line_seg; + struct line_seg *s; + segT info_seg; + int emit_other_sections = 0; + int empty_debug_line = 0; + + info_seg = bfd_get_section_by_name (stdoutput, ".debug_info"); + emit_other_sections = info_seg == NULL || !seg_not_empty_p (info_seg); + + line_seg = bfd_get_section_by_name (stdoutput, ".debug_line"); + empty_debug_line = line_seg == NULL || !seg_not_empty_p (line_seg); + + /* We can't construct a new debug_line section if we already have one. + Give an error. */ + if (all_segs && !empty_debug_line) + as_fatal ("duplicate .debug_line sections"); + + if ((!all_segs && emit_other_sections) + || (!emit_other_sections && !empty_debug_line)) + /* If there is no line information and no non-empty .debug_info + section, or if there is both a non-empty .debug_info and a non-empty + .debug_line, then we do nothing. */ + return; + + /* Calculate the size of an address for the target machine. */ + sizeof_address = DWARF2_ADDR_SIZE (stdoutput); + + /* Create and switch to the line number section. */ + line_seg = subseg_new (".debug_line", 0); + bfd_set_section_flags (stdoutput, line_seg, SEC_READONLY | SEC_DEBUGGING); + + /* For each subsection, chain the debug entries together. */ + for (s = all_segs; s; s = s->next) { - as_where (&line->filename, &line->line); - line->filenum = 0; - line->column = 0; - line->flags = DWARF2_FLAG_BEGIN_STMT; + struct line_subseg *lss = s->head; + struct line_entry **ptail = lss->ptail; + + while ((lss = lss->next) != NULL) + { + *ptail = lss->head; + ptail = lss->ptail; + } + } + + out_debug_line (line_seg); + + /* If this is assembler generated line info, and there is no + debug_info already, we need .debug_info and .debug_abbrev + sections as well. */ + if (emit_other_sections) + { + segT abbrev_seg; + segT aranges_seg; + segT ranges_seg; + + gas_assert (all_segs); + + info_seg = subseg_new (".debug_info", 0); + abbrev_seg = subseg_new (".debug_abbrev", 0); + aranges_seg = subseg_new (".debug_aranges", 0); + + bfd_set_section_flags (stdoutput, info_seg, + SEC_READONLY | SEC_DEBUGGING); + bfd_set_section_flags (stdoutput, abbrev_seg, + SEC_READONLY | SEC_DEBUGGING); + bfd_set_section_flags (stdoutput, aranges_seg, + SEC_READONLY | SEC_DEBUGGING); + + record_alignment (aranges_seg, ffs (2 * sizeof_address) - 1); + + if (all_segs->next == NULL) + ranges_seg = NULL; + else + { + ranges_seg = subseg_new (".debug_ranges", 0); + bfd_set_section_flags (stdoutput, ranges_seg, + SEC_READONLY | SEC_DEBUGGING); + record_alignment (ranges_seg, ffs (2 * sizeof_address) - 1); + out_debug_ranges (ranges_seg); + } + + out_debug_aranges (aranges_seg, info_seg); + out_debug_abbrev (abbrev_seg, info_seg, line_seg); + out_debug_info (info_seg, abbrev_seg, line_seg, ranges_seg); } }