| /* |
| * DWARF2 debugging format - line information |
| * |
| * Copyright (C) 2006-2007 Peter Johnson |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * 3. Neither the name of the author nor the names of other contributors |
| * may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS'' |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| #include <util.h> |
| /*@unused@*/ RCSID("$Id$"); |
| |
| #include <libyasm.h> |
| |
| #include "dwarf2-dbgfmt.h" |
| |
| /* DWARF line number opcodes */ |
| typedef enum { |
| DW_LNS_extended_op = 0, |
| DW_LNS_copy, |
| DW_LNS_advance_pc, |
| DW_LNS_advance_line, |
| DW_LNS_set_file, |
| DW_LNS_set_column, |
| DW_LNS_negate_stmt, |
| DW_LNS_set_basic_block, |
| DW_LNS_const_add_pc, |
| DW_LNS_fixed_advance_pc, |
| #ifdef WITH_DWARF3 |
| /* DWARF 3 extensions */ |
| DW_LNS_set_prologue_end, |
| DW_LNS_set_epilogue_begin, |
| DW_LNS_set_isa, |
| #endif |
| DWARF2_LINE_OPCODE_BASE |
| } dwarf_line_number_op; |
| |
| /* # of LEB128 operands needed for each of the above opcodes */ |
| static unsigned char line_opcode_num_operands[DWARF2_LINE_OPCODE_BASE-1] = { |
| 0, /* DW_LNS_copy */ |
| 1, /* DW_LNS_advance_pc */ |
| 1, /* DW_LNS_advance_line */ |
| 1, /* DW_LNS_set_file */ |
| 1, /* DW_LNS_set_column */ |
| 0, /* DW_LNS_negate_stmt */ |
| 0, /* DW_LNS_set_basic_block */ |
| 0, /* DW_LNS_const_add_pc */ |
| 1, /* DW_LNS_fixed_advance_pc */ |
| #ifdef WITH_DWARF3 |
| 0, /* DW_LNS_set_prologue_end */ |
| 0, /* DW_LNS_set_epilogue_begin */ |
| 1 /* DW_LNS_set_isa */ |
| #endif |
| }; |
| |
| /* Line number extended opcodes */ |
| typedef enum { |
| DW_LNE_end_sequence = 1, |
| DW_LNE_set_address, |
| DW_LNE_define_file |
| } dwarf_line_number_ext_op; |
| |
| /* Base and range for line offsets in special opcodes */ |
| #define DWARF2_LINE_BASE -5 |
| #define DWARF2_LINE_RANGE 14 |
| |
| #define DWARF2_MAX_SPECIAL_ADDR_DELTA \ |
| (((255-DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE)*\ |
| dbgfmt_dwarf2->min_insn_len) |
| |
| /* Initial value of is_stmt register */ |
| #define DWARF2_LINE_DEFAULT_IS_STMT 1 |
| |
| /* Line number state machine register state */ |
| typedef struct dwarf2_line_state { |
| /* static configuration */ |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2; |
| |
| /* DWARF2 state machine registers */ |
| unsigned long address; |
| unsigned long file; |
| unsigned long line; |
| unsigned long column; |
| unsigned long isa; |
| int is_stmt; |
| |
| /* other state information */ |
| /*@null@*/ yasm_bytecode *precbc; |
| } dwarf2_line_state; |
| |
| typedef struct dwarf2_spp { |
| yasm_bytecode *line_start_prevbc; |
| yasm_bytecode *line_end_prevbc; |
| } dwarf2_spp; |
| |
| typedef struct dwarf2_line_op { |
| dwarf_line_number_op opcode; |
| /*@owned@*/ /*@null@*/ yasm_intnum *operand; |
| |
| /* extended opcode */ |
| dwarf_line_number_ext_op ext_opcode; |
| /*@null@*/ /*@dependent@*/ yasm_symrec *ext_operand; /* unsigned */ |
| unsigned long ext_operandsize; |
| } dwarf2_line_op; |
| |
| /* Bytecode callback function prototypes */ |
| static void dwarf2_spp_bc_destroy(void *contents); |
| static void dwarf2_spp_bc_print(const void *contents, FILE *f, |
| int indent_level); |
| static int dwarf2_spp_bc_calc_len |
| (yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data); |
| static int dwarf2_spp_bc_tobytes |
| (yasm_bytecode *bc, unsigned char **bufp, void *d, |
| yasm_output_value_func output_value, |
| /*@null@*/ yasm_output_reloc_func output_reloc); |
| |
| static void dwarf2_line_op_bc_destroy(void *contents); |
| static void dwarf2_line_op_bc_print(const void *contents, FILE *f, |
| int indent_level); |
| static int dwarf2_line_op_bc_calc_len |
| (yasm_bytecode *bc, yasm_bc_add_span_func add_span, void *add_span_data); |
| static int dwarf2_line_op_bc_tobytes |
| (yasm_bytecode *bc, unsigned char **bufp, void *d, |
| yasm_output_value_func output_value, |
| /*@null@*/ yasm_output_reloc_func output_reloc); |
| |
| /* Bytecode callback structures */ |
| static const yasm_bytecode_callback dwarf2_spp_bc_callback = { |
| dwarf2_spp_bc_destroy, |
| dwarf2_spp_bc_print, |
| yasm_bc_finalize_common, |
| dwarf2_spp_bc_calc_len, |
| yasm_bc_expand_common, |
| dwarf2_spp_bc_tobytes, |
| 0 |
| }; |
| |
| static const yasm_bytecode_callback dwarf2_line_op_bc_callback = { |
| dwarf2_line_op_bc_destroy, |
| dwarf2_line_op_bc_print, |
| yasm_bc_finalize_common, |
| dwarf2_line_op_bc_calc_len, |
| yasm_bc_expand_common, |
| dwarf2_line_op_bc_tobytes, |
| 0 |
| }; |
| |
| |
| static size_t |
| dwarf2_dbgfmt_add_file(yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2, unsigned long filenum, |
| const char *pathname) |
| { |
| size_t dirlen; |
| const char *filename; |
| unsigned long i, dir; |
| |
| /* Put the directory into the directory table */ |
| dir = 0; |
| dirlen = yasm__splitpath(pathname, &filename); |
| if (dirlen > 0) { |
| /* Look to see if we already have that dir in the table */ |
| for (dir=1; dir<dbgfmt_dwarf2->dirs_size+1; dir++) { |
| if (strncmp(dbgfmt_dwarf2->dirs[dir-1], pathname, dirlen) == 0 |
| && dbgfmt_dwarf2->dirs[dir-1][dirlen] == '\0') |
| break; |
| } |
| if (dir >= dbgfmt_dwarf2->dirs_size+1) { |
| /* Not found in table, add to end, reallocing if necessary */ |
| if (dir >= dbgfmt_dwarf2->dirs_allocated+1) { |
| dbgfmt_dwarf2->dirs_allocated = dir+32; |
| dbgfmt_dwarf2->dirs = yasm_xrealloc(dbgfmt_dwarf2->dirs, |
| sizeof(char *)*dbgfmt_dwarf2->dirs_allocated); |
| } |
| dbgfmt_dwarf2->dirs[dir-1] = yasm__xstrndup(pathname, dirlen); |
| dbgfmt_dwarf2->dirs_size = dir; |
| } |
| } |
| |
| /* Put the filename into the filename table */ |
| if (filenum == 0) { |
| /* Look to see if we already have that filename in the table */ |
| for (; filenum<dbgfmt_dwarf2->filenames_size; filenum++) { |
| if (!dbgfmt_dwarf2->filenames[filenum].filename || |
| (dbgfmt_dwarf2->filenames[filenum].dir == dir |
| && strcmp(dbgfmt_dwarf2->filenames[filenum].filename, |
| filename) == 0)) |
| break; |
| } |
| } else |
| filenum--; /* array index is 0-based */ |
| |
| /* Realloc table if necessary */ |
| if (filenum >= dbgfmt_dwarf2->filenames_allocated) { |
| unsigned long old_allocated = dbgfmt_dwarf2->filenames_allocated; |
| dbgfmt_dwarf2->filenames_allocated = filenum+32; |
| dbgfmt_dwarf2->filenames = yasm_xrealloc(dbgfmt_dwarf2->filenames, |
| sizeof(dwarf2_filename)*dbgfmt_dwarf2->filenames_allocated); |
| for (i=old_allocated; i<dbgfmt_dwarf2->filenames_allocated; i++) { |
| dbgfmt_dwarf2->filenames[i].pathname = NULL; |
| dbgfmt_dwarf2->filenames[i].filename = NULL; |
| dbgfmt_dwarf2->filenames[i].dir = 0; |
| } |
| } |
| |
| /* Actually save in table */ |
| if (dbgfmt_dwarf2->filenames[filenum].pathname) |
| yasm_xfree(dbgfmt_dwarf2->filenames[filenum].pathname); |
| if (dbgfmt_dwarf2->filenames[filenum].filename) |
| yasm_xfree(dbgfmt_dwarf2->filenames[filenum].filename); |
| dbgfmt_dwarf2->filenames[filenum].pathname = yasm__xstrdup(pathname); |
| dbgfmt_dwarf2->filenames[filenum].filename = yasm__xstrdup(filename); |
| dbgfmt_dwarf2->filenames[filenum].dir = dir; |
| |
| /* Update table size */ |
| if (filenum >= dbgfmt_dwarf2->filenames_size) |
| dbgfmt_dwarf2->filenames_size = filenum + 1; |
| |
| return filenum; |
| } |
| |
| /* Create and add a new line opcode to a section, updating offset on insertion; |
| * no optimization necessary. |
| */ |
| static yasm_bytecode * |
| dwarf2_dbgfmt_append_line_op(yasm_section *sect, dwarf_line_number_op opcode, |
| /*@only@*/ /*@null@*/ yasm_intnum *operand) |
| { |
| dwarf2_line_op *line_op = yasm_xmalloc(sizeof(dwarf2_line_op)); |
| yasm_bytecode *bc; |
| |
| line_op->opcode = opcode; |
| line_op->operand = operand; |
| line_op->ext_opcode = 0; |
| line_op->ext_operand = NULL; |
| line_op->ext_operandsize = 0; |
| |
| bc = yasm_bc_create_common(&dwarf2_line_op_bc_callback, line_op, 0); |
| bc->len = 1; |
| if (operand) |
| bc->len += yasm_intnum_size_leb128(operand, |
| opcode == DW_LNS_advance_line); |
| |
| yasm_dwarf2__append_bc(sect, bc); |
| return bc; |
| } |
| |
| /* Create and add a new extended line opcode to a section, updating offset on |
| * insertion; no optimization necessary. |
| */ |
| static yasm_bytecode * |
| dwarf2_dbgfmt_append_line_ext_op(yasm_section *sect, |
| dwarf_line_number_ext_op ext_opcode, |
| unsigned long ext_operandsize, |
| /*@null@*/ yasm_symrec *ext_operand) |
| { |
| dwarf2_line_op *line_op = yasm_xmalloc(sizeof(dwarf2_line_op)); |
| yasm_bytecode *bc; |
| |
| line_op->opcode = DW_LNS_extended_op; |
| line_op->operand = yasm_intnum_create_uint(ext_operandsize+1); |
| line_op->ext_opcode = ext_opcode; |
| line_op->ext_operand = ext_operand; |
| line_op->ext_operandsize = ext_operandsize; |
| |
| bc = yasm_bc_create_common(&dwarf2_line_op_bc_callback, line_op, 0); |
| bc->len = 2 + yasm_intnum_size_leb128(line_op->operand, 0) + |
| ext_operandsize; |
| |
| yasm_dwarf2__append_bc(sect, bc); |
| return bc; |
| } |
| |
| static void |
| dwarf2_dbgfmt_finalize_locs(yasm_section *sect, dwarf2_section_data *dsd) |
| { |
| /*@dependent@*/ yasm_symrec *lastsym = NULL; |
| /*@null@*/ yasm_bytecode *bc; |
| /*@null@*/ dwarf2_loc *loc; |
| |
| bc = yasm_section_bcs_first(sect); |
| STAILQ_FOREACH(loc, &dsd->locs, link) { |
| /* Find the first bytecode following this loc by looking at |
| * the virtual line numbers. XXX: this assumes the source file |
| * order will be the same as the actual section order. If we ever |
| * implement subsegs this will NOT necessarily be true and this logic |
| * will need to be fixed to handle it! |
| * |
| * Keep track of last symbol seen prior to the loc. |
| */ |
| while (bc && bc->line <= loc->vline) { |
| if (bc->symrecs) { |
| int i = 0; |
| while (bc->symrecs[i]) { |
| lastsym = bc->symrecs[i]; |
| i++; |
| } |
| } |
| bc = yasm_bc__next(bc); |
| } |
| loc->sym = lastsym; |
| loc->bc = bc; |
| } |
| } |
| |
| static int |
| dwarf2_dbgfmt_gen_line_op(yasm_section *debug_line, dwarf2_line_state *state, |
| const dwarf2_loc *loc, |
| /*@null@*/ const dwarf2_loc *nextloc) |
| { |
| unsigned long addr_delta; |
| long line_delta; |
| int opcode1, opcode2; |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = state->dbgfmt_dwarf2; |
| |
| if (state->file != loc->file) { |
| state->file = loc->file; |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_set_file, |
| yasm_intnum_create_uint(state->file)); |
| } |
| if (state->column != loc->column) { |
| state->column = loc->column; |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_set_column, |
| yasm_intnum_create_uint(state->column)); |
| } |
| #ifdef WITH_DWARF3 |
| if (loc->isa_change) { |
| state->isa = loc->isa; |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_set_isa, |
| yasm_intnum_create_uint(state->isa)); |
| } |
| #endif |
| if (state->is_stmt == 0 && loc->is_stmt == IS_STMT_SET) { |
| state->is_stmt = 1; |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_negate_stmt, NULL); |
| } else if (state->is_stmt == 1 && loc->is_stmt == IS_STMT_CLEAR) { |
| state->is_stmt = 0; |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_negate_stmt, NULL); |
| } |
| if (loc->basic_block) { |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_set_basic_block, NULL); |
| } |
| #ifdef WITH_DWARF3 |
| if (loc->prologue_end) { |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_set_prologue_end, NULL); |
| } |
| if (loc->epilogue_begin) { |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_set_epilogue_begin, |
| NULL); |
| } |
| #endif |
| |
| /* If multiple loc for the same location, use last */ |
| if (nextloc && nextloc->bc->offset == loc->bc->offset) |
| return 0; |
| |
| if (!state->precbc) { |
| /* Set the starting address for the section */ |
| if (!loc->sym) { |
| /* shouldn't happen! */ |
| yasm_error_set(YASM_ERROR_GENERAL, |
| N_("could not find label prior to loc")); |
| return 1; |
| } |
| dwarf2_dbgfmt_append_line_ext_op(debug_line, DW_LNE_set_address, |
| dbgfmt_dwarf2->sizeof_address, loc->sym); |
| addr_delta = 0; |
| } else if (loc->bc) { |
| if (state->precbc->offset > loc->bc->offset) |
| yasm_internal_error(N_("dwarf2 address went backwards?")); |
| addr_delta = loc->bc->offset - state->precbc->offset; |
| } else |
| return 0; /* ran out of bytecodes! XXX: do something? */ |
| |
| /* Generate appropriate opcode(s). Address can only increment, |
| * whereas line number can go backwards. |
| */ |
| line_delta = loc->line - state->line; |
| state->line = loc->line; |
| |
| /* First handle the line delta */ |
| if (line_delta < DWARF2_LINE_BASE |
| || line_delta >= DWARF2_LINE_BASE+DWARF2_LINE_RANGE) { |
| /* Won't fit in special opcode, use (signed) line advance */ |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_advance_line, |
| yasm_intnum_create_int(line_delta)); |
| line_delta = 0; |
| } |
| |
| /* Next handle the address delta */ |
| opcode1 = DWARF2_LINE_OPCODE_BASE + line_delta - DWARF2_LINE_BASE + |
| DWARF2_LINE_RANGE * (addr_delta / dbgfmt_dwarf2->min_insn_len); |
| opcode2 = DWARF2_LINE_OPCODE_BASE + line_delta - DWARF2_LINE_BASE + |
| DWARF2_LINE_RANGE * ((addr_delta - DWARF2_MAX_SPECIAL_ADDR_DELTA) / |
| dbgfmt_dwarf2->min_insn_len); |
| if (line_delta == 0 && addr_delta == 0) { |
| /* Both line and addr deltas are 0: do DW_LNS_copy */ |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_copy, NULL); |
| } else if (addr_delta <= DWARF2_MAX_SPECIAL_ADDR_DELTA && opcode1 <= 255) { |
| /* Addr delta in range of special opcode */ |
| dwarf2_dbgfmt_append_line_op(debug_line, opcode1, NULL); |
| } else if (addr_delta <= 2*DWARF2_MAX_SPECIAL_ADDR_DELTA |
| && opcode2 <= 255) { |
| /* Addr delta in range of const_add_pc + special */ |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_const_add_pc, NULL); |
| dwarf2_dbgfmt_append_line_op(debug_line, opcode2, NULL); |
| } else { |
| /* Need advance_pc */ |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_advance_pc, |
| yasm_intnum_create_uint(addr_delta)); |
| /* Take care of any remaining line_delta and add entry to matrix */ |
| if (line_delta == 0) |
| dwarf2_dbgfmt_append_line_op(debug_line, DW_LNS_copy, NULL); |
| else { |
| unsigned int opcode; |
| opcode = DWARF2_LINE_OPCODE_BASE + line_delta - DWARF2_LINE_BASE; |
| dwarf2_dbgfmt_append_line_op(debug_line, opcode, NULL); |
| } |
| } |
| state->precbc = loc->bc; |
| return 0; |
| } |
| |
| typedef struct dwarf2_line_bc_info { |
| yasm_section *debug_line; |
| yasm_object *object; |
| yasm_linemap *linemap; |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2; |
| dwarf2_line_state *state; |
| dwarf2_loc loc; |
| unsigned long lastfile; |
| } dwarf2_line_bc_info; |
| |
| static int |
| dwarf2_generate_line_bc(yasm_bytecode *bc, /*@null@*/ void *d) |
| { |
| dwarf2_line_bc_info *info = (dwarf2_line_bc_info *)d; |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = info->dbgfmt_dwarf2; |
| unsigned long i; |
| const char *filename; |
| /*@null@*/ yasm_bytecode *nextbc = yasm_bc__next(bc); |
| |
| if (nextbc && bc->offset == nextbc->offset) |
| return 0; |
| |
| info->loc.vline = bc->line; |
| info->loc.bc = bc; |
| |
| /* Keep track of last symbol seen */ |
| if (bc->symrecs) { |
| i = 0; |
| while (bc->symrecs[i]) { |
| info->loc.sym = bc->symrecs[i]; |
| i++; |
| } |
| } |
| |
| yasm_linemap_lookup(info->linemap, bc->line, &filename, &info->loc.line); |
| /* Find file index; just linear search it unless it was the last used */ |
| if (info->lastfile > 0 |
| && strcmp(filename, dbgfmt_dwarf2->filenames[info->lastfile-1].pathname) |
| == 0) |
| info->loc.file = info->lastfile; |
| else { |
| for (i=0; i<dbgfmt_dwarf2->filenames_size; i++) { |
| if (strcmp(filename, dbgfmt_dwarf2->filenames[i].pathname) == 0) |
| break; |
| } |
| if (i >= dbgfmt_dwarf2->filenames_size) |
| yasm_internal_error(N_("could not find filename in table")); |
| info->loc.file = i+1; |
| info->lastfile = i+1; |
| } |
| if (dwarf2_dbgfmt_gen_line_op(info->debug_line, info->state, &info->loc, |
| NULL)) |
| return 1; |
| return 0; |
| } |
| |
| typedef struct dwarf2_line_info { |
| yasm_section *debug_line; /* section to which line number info goes */ |
| yasm_object *object; |
| yasm_linemap *linemap; |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2; |
| yasm_errwarns *errwarns; |
| |
| /* Generate based on bytecodes (1) or locs (0)? Use bytecodes if we're |
| * generating line numbers for the actual assembly source file. |
| */ |
| int asm_source; |
| |
| /* number of sections line number info generated for */ |
| size_t num_sections; |
| /* last section line number info generated for */ |
| /*@null@*/ yasm_section *last_code; |
| } dwarf2_line_info; |
| |
| static int |
| dwarf2_generate_line_section(yasm_section *sect, /*@null@*/ void *d) |
| { |
| dwarf2_line_info *info = (dwarf2_line_info *)d; |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = info->dbgfmt_dwarf2; |
| /*@null@*/ dwarf2_section_data *dsd; |
| /*@null@*/ yasm_bytecode *bc; |
| dwarf2_line_state state; |
| unsigned long addr_delta; |
| |
| dsd = yasm_section_get_data(sect, &yasm_dwarf2__section_data_cb); |
| if (!dsd) { |
| if (info->asm_source && yasm_section_is_code(sect)) { |
| /* Create line data for asm code sections */ |
| dsd = yasm_xmalloc(sizeof(dwarf2_section_data)); |
| STAILQ_INIT(&dsd->locs); |
| yasm_section_add_data(sect, &yasm_dwarf2__section_data_cb, dsd); |
| } else |
| return 0; /* no line data for this section */ |
| } |
| |
| info->num_sections++; |
| info->last_code = sect; |
| |
| /* initialize state machine registers for each sequence */ |
| state.dbgfmt_dwarf2 = dbgfmt_dwarf2; |
| state.address = 0; |
| state.file = 1; |
| state.line = 1; |
| state.column = 0; |
| state.isa = 0; |
| state.is_stmt = DWARF2_LINE_DEFAULT_IS_STMT; |
| state.precbc = NULL; |
| |
| if (info->asm_source) { |
| dwarf2_line_bc_info bcinfo; |
| |
| bcinfo.debug_line = info->debug_line; |
| bcinfo.object = info->object; |
| bcinfo.linemap = info->linemap; |
| bcinfo.dbgfmt_dwarf2 = dbgfmt_dwarf2; |
| bcinfo.state = &state; |
| bcinfo.lastfile = 0; |
| bcinfo.loc.isa_change = 0; |
| bcinfo.loc.column = 0; |
| bcinfo.loc.is_stmt = IS_STMT_NOCHANGE; |
| bcinfo.loc.basic_block = 0; |
| bcinfo.loc.prologue_end = 0; |
| bcinfo.loc.epilogue_begin = 0; |
| bcinfo.loc.sym = NULL; |
| |
| /* bcs_traverse() skips first "dummy" bytecode, so look at it |
| * separately to determine the initial symrec. |
| */ |
| bc = yasm_section_bcs_first(sect); |
| if (bc->symrecs) { |
| size_t i = 0; |
| while (bc->symrecs[i]) { |
| bcinfo.loc.sym = bc->symrecs[i]; |
| i++; |
| } |
| } |
| |
| yasm_section_bcs_traverse(sect, info->errwarns, &bcinfo, |
| dwarf2_generate_line_bc); |
| } else { |
| /*@null@*/ dwarf2_loc *loc; |
| |
| dwarf2_dbgfmt_finalize_locs(sect, dsd); |
| |
| STAILQ_FOREACH(loc, &dsd->locs, link) { |
| if (dwarf2_dbgfmt_gen_line_op(info->debug_line, &state, loc, |
| STAILQ_NEXT(loc, link))) |
| return 1; |
| } |
| } |
| |
| /* End sequence: bring address to end of section, then output end |
| * sequence opcode. Don't use a special opcode to do this as we don't |
| * want an extra entry in the line matrix. |
| */ |
| if (!state.precbc) |
| state.precbc = yasm_section_bcs_first(sect); |
| bc = yasm_section_bcs_last(sect); |
| addr_delta = yasm_bc_next_offset(bc) - state.precbc->offset; |
| if (addr_delta == DWARF2_MAX_SPECIAL_ADDR_DELTA) |
| dwarf2_dbgfmt_append_line_op(info->debug_line, DW_LNS_const_add_pc, |
| NULL); |
| else if (addr_delta > 0) |
| dwarf2_dbgfmt_append_line_op(info->debug_line, DW_LNS_advance_pc, |
| yasm_intnum_create_uint(addr_delta)); |
| dwarf2_dbgfmt_append_line_ext_op(info->debug_line, DW_LNE_end_sequence, 0, |
| NULL); |
| |
| return 0; |
| } |
| |
| static int |
| dwarf2_generate_filename(const char *filename, void *d) |
| { |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = (yasm_dbgfmt_dwarf2 *)d; |
| dwarf2_dbgfmt_add_file(dbgfmt_dwarf2, 0, filename); |
| return 0; |
| } |
| |
| yasm_section * |
| yasm_dwarf2__generate_line(yasm_object *object, yasm_linemap *linemap, |
| yasm_errwarns *errwarns, int asm_source, |
| /*@out@*/ yasm_section **main_code, |
| /*@out@*/ size_t *num_line_sections) |
| { |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = (yasm_dbgfmt_dwarf2 *)object->dbgfmt; |
| dwarf2_line_info info; |
| int new; |
| size_t i; |
| yasm_bytecode *last, *sppbc; |
| dwarf2_spp *spp; |
| dwarf2_head *head; |
| |
| if (asm_source) { |
| /* Generate dirs and filenames based on linemap */ |
| yasm_linemap_traverse_filenames(linemap, dbgfmt_dwarf2, |
| dwarf2_generate_filename); |
| } |
| |
| info.num_sections = 0; |
| info.last_code = NULL; |
| info.asm_source = asm_source; |
| info.object = object; |
| info.linemap = linemap; |
| info.dbgfmt_dwarf2 = dbgfmt_dwarf2; |
| info.debug_line = yasm_object_get_general(object, ".debug_line", 1, 0, 0, |
| &new, 0); |
| last = yasm_section_bcs_last(info.debug_line); |
| |
| /* header */ |
| head = yasm_dwarf2__add_head(dbgfmt_dwarf2, info.debug_line, NULL, 0, 0); |
| |
| /* statement program prologue */ |
| spp = yasm_xmalloc(sizeof(dwarf2_spp)); |
| sppbc = yasm_bc_create_common(&dwarf2_spp_bc_callback, spp, 0); |
| sppbc->len = dbgfmt_dwarf2->sizeof_offset + 5 + |
| NELEMS(line_opcode_num_operands); |
| |
| /* directory list */ |
| for (i=0; i<dbgfmt_dwarf2->dirs_size; i++) |
| sppbc->len += (unsigned long)strlen(dbgfmt_dwarf2->dirs[i])+1; |
| sppbc->len++; |
| |
| /* filename list */ |
| for (i=0; i<dbgfmt_dwarf2->filenames_size; i++) { |
| if (!dbgfmt_dwarf2->filenames[i].filename) { |
| yasm_error_set(YASM_ERROR_GENERAL, |
| N_("dwarf2 file number %d unassigned"), i+1); |
| yasm_errwarn_propagate(errwarns, 0); |
| continue; |
| } |
| sppbc->len += |
| (unsigned long)strlen(dbgfmt_dwarf2->filenames[i].filename) + 1 + |
| yasm_size_uleb128(dbgfmt_dwarf2->filenames[i].dir) + 2; |
| } |
| sppbc->len++; |
| yasm_dwarf2__append_bc(info.debug_line, sppbc); |
| |
| /* statement program */ |
| yasm_object_sections_traverse(object, (void *)&info, |
| dwarf2_generate_line_section); |
| |
| /* mark end of line information */ |
| yasm_dwarf2__set_head_end(head, yasm_section_bcs_last(info.debug_line)); |
| |
| *num_line_sections = info.num_sections; |
| if (info.num_sections == 1) |
| *main_code = info.last_code; |
| else |
| *main_code = NULL; |
| return info.debug_line; |
| } |
| |
| static void |
| dwarf2_spp_bc_destroy(void *contents) |
| { |
| yasm_xfree(contents); |
| } |
| |
| static void |
| dwarf2_spp_bc_print(const void *contents, FILE *f, int indent_level) |
| { |
| /* TODO */ |
| } |
| |
| static int |
| dwarf2_spp_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span, |
| void *add_span_data) |
| { |
| yasm_internal_error(N_("tried to calc_len a dwarf2 spp bytecode")); |
| /*@notreached@*/ |
| return 0; |
| } |
| |
| static int |
| dwarf2_spp_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d, |
| yasm_output_value_func output_value, |
| yasm_output_reloc_func output_reloc) |
| { |
| yasm_object *object = yasm_section_get_object(bc->section); |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = (yasm_dbgfmt_dwarf2 *)object->dbgfmt; |
| unsigned char *buf = *bufp; |
| yasm_intnum *cval; |
| size_t i, len; |
| |
| /* Prologue length (following this field) */ |
| cval = yasm_intnum_create_uint(bc->len - (unsigned long)(buf-*bufp) - |
| dbgfmt_dwarf2->sizeof_offset); |
| yasm_arch_intnum_tobytes(object->arch, cval, buf, |
| dbgfmt_dwarf2->sizeof_offset, |
| dbgfmt_dwarf2->sizeof_offset*8, 0, bc, 0); |
| buf += dbgfmt_dwarf2->sizeof_offset; |
| |
| YASM_WRITE_8(buf, dbgfmt_dwarf2->min_insn_len); /* minimum_instr_len */ |
| YASM_WRITE_8(buf, DWARF2_LINE_DEFAULT_IS_STMT); /* default_is_stmt */ |
| YASM_WRITE_8(buf, DWARF2_LINE_BASE); /* line_base */ |
| YASM_WRITE_8(buf, DWARF2_LINE_RANGE); /* line_range */ |
| YASM_WRITE_8(buf, DWARF2_LINE_OPCODE_BASE); /* opcode_base */ |
| |
| /* Standard opcode # operands array */ |
| for (i=0; i<NELEMS(line_opcode_num_operands); i++) |
| YASM_WRITE_8(buf, line_opcode_num_operands[i]); |
| |
| /* directory list */ |
| for (i=0; i<dbgfmt_dwarf2->dirs_size; i++) { |
| len = strlen(dbgfmt_dwarf2->dirs[i])+1; |
| memcpy(buf, dbgfmt_dwarf2->dirs[i], len); |
| buf += len; |
| } |
| /* finish with single 0 byte */ |
| YASM_WRITE_8(buf, 0); |
| |
| /* filename list */ |
| for (i=0; i<dbgfmt_dwarf2->filenames_size; i++) { |
| len = strlen(dbgfmt_dwarf2->filenames[i].filename)+1; |
| memcpy(buf, dbgfmt_dwarf2->filenames[i].filename, len); |
| buf += len; |
| |
| /* dir */ |
| buf += yasm_get_uleb128(dbgfmt_dwarf2->filenames[i].dir, buf); |
| YASM_WRITE_8(buf, 0); /* time */ |
| YASM_WRITE_8(buf, 0); /* length */ |
| } |
| /* finish with single 0 byte */ |
| YASM_WRITE_8(buf, 0); |
| |
| *bufp = buf; |
| |
| yasm_intnum_destroy(cval); |
| return 0; |
| } |
| |
| static void |
| dwarf2_line_op_bc_destroy(void *contents) |
| { |
| dwarf2_line_op *line_op = (dwarf2_line_op *)contents; |
| if (line_op->operand) |
| yasm_intnum_destroy(line_op->operand); |
| yasm_xfree(contents); |
| } |
| |
| static void |
| dwarf2_line_op_bc_print(const void *contents, FILE *f, int indent_level) |
| { |
| /* TODO */ |
| } |
| |
| static int |
| dwarf2_line_op_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span, |
| void *add_span_data) |
| { |
| yasm_internal_error(N_("tried to calc_len a dwarf2 line_op bytecode")); |
| /*@notreached@*/ |
| return 0; |
| } |
| |
| static int |
| dwarf2_line_op_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp, void *d, |
| yasm_output_value_func output_value, |
| yasm_output_reloc_func output_reloc) |
| { |
| dwarf2_line_op *line_op = (dwarf2_line_op *)bc->contents; |
| unsigned char *buf = *bufp; |
| |
| YASM_WRITE_8(buf, line_op->opcode); |
| if (line_op->operand) |
| buf += yasm_intnum_get_leb128(line_op->operand, buf, |
| line_op->opcode == DW_LNS_advance_line); |
| if (line_op->ext_opcode > 0) { |
| YASM_WRITE_8(buf, line_op->ext_opcode); |
| if (line_op->ext_operand) { |
| yasm_value value; |
| yasm_value_init_sym(&value, line_op->ext_operand, |
| line_op->ext_operandsize*8); |
| output_value(&value, buf, line_op->ext_operandsize, |
| (unsigned long)(buf-*bufp), bc, 0, d); |
| buf += line_op->ext_operandsize; |
| } |
| } |
| |
| *bufp = buf; |
| return 0; |
| } |
| |
| void |
| yasm_dwarf2__dir_loc(yasm_object *object, yasm_valparamhead *valparams, |
| yasm_valparamhead *objext_valparams, unsigned long line) |
| { |
| yasm_valparam *vp; |
| int in_is_stmt = 0, in_isa = 0; |
| |
| /*@dependent@*/ /*@null@*/ const yasm_intnum *intn; |
| dwarf2_section_data *dsd; |
| dwarf2_loc *loc = yasm_xmalloc(sizeof(dwarf2_loc)); |
| |
| /* File number (required) */ |
| if (!valparams || !(vp = yasm_vps_first(valparams)) || |
| vp->val || vp->type != YASM_PARAM_EXPR) { |
| yasm_error_set(YASM_ERROR_SYNTAX, N_("file number required")); |
| yasm_xfree(loc); |
| return; |
| } |
| intn = yasm_expr_get_intnum(&vp->param.e, 0); |
| if (!intn) { |
| yasm_error_set(YASM_ERROR_NOT_CONSTANT, |
| N_("file number is not a constant")); |
| yasm_xfree(loc); |
| return; |
| } |
| if (yasm_intnum_sign(intn) != 1) { |
| yasm_error_set(YASM_ERROR_VALUE, N_("file number less than one")); |
| yasm_xfree(loc); |
| return; |
| } |
| loc->file = yasm_intnum_get_uint(intn); |
| |
| /* Line number (required) */ |
| vp = yasm_vps_next(vp); |
| if (!vp || vp->val || vp->type != YASM_PARAM_EXPR) { |
| yasm_error_set(YASM_ERROR_SYNTAX, N_("line number required")); |
| yasm_xfree(loc); |
| return; |
| } |
| intn = yasm_expr_get_intnum(&vp->param.e, 0); |
| if (!intn) { |
| yasm_error_set(YASM_ERROR_NOT_CONSTANT, |
| N_("line number is not a constant")); |
| yasm_xfree(loc); |
| return; |
| } |
| loc->line = yasm_intnum_get_uint(intn); |
| |
| /* Generate new section data if it doesn't already exist */ |
| if (!object->cur_section) { |
| yasm_error_set(YASM_ERROR_SYNTAX, |
| N_("[%s] can only be used inside of a section"), "loc"); |
| yasm_xfree(loc); |
| return; |
| } |
| dsd = yasm_section_get_data(object->cur_section, |
| &yasm_dwarf2__section_data_cb); |
| if (!dsd) { |
| dsd = yasm_xmalloc(sizeof(dwarf2_section_data)); |
| STAILQ_INIT(&dsd->locs); |
| yasm_section_add_data(object->cur_section, |
| &yasm_dwarf2__section_data_cb, dsd); |
| } |
| |
| /* Defaults for optional settings */ |
| loc->column = 0; |
| loc->isa_change = 0; |
| loc->isa = 0; |
| loc->is_stmt = IS_STMT_NOCHANGE; |
| loc->basic_block = 0; |
| loc->prologue_end = 0; |
| loc->epilogue_begin = 0; |
| |
| /* Optional column number */ |
| vp = yasm_vps_next(vp); |
| if (vp && !vp->val && vp->type == YASM_PARAM_EXPR) { |
| intn = yasm_expr_get_intnum(&vp->param.e, 0); |
| if (!intn) { |
| yasm_error_set(YASM_ERROR_NOT_CONSTANT, |
| N_("column number is not a constant")); |
| yasm_xfree(loc); |
| return; |
| } |
| loc->column = yasm_intnum_get_uint(intn); |
| vp = yasm_vps_next(vp); |
| } |
| |
| /* Other options; note for GAS compatibility we need to support both: |
| * is_stmt=1 (NASM) and |
| * is_stmt 1 (GAS) |
| */ |
| while (vp) { |
| /*@null@*/ /*@dependent@*/ const char *s; |
| /*@null@*/ /*@only@*/ yasm_expr *e; |
| |
| restart: |
| if (in_is_stmt) { |
| in_is_stmt = 0; |
| if (!(e = yasm_vp_expr(vp, object->symtab, line)) || |
| !(intn = yasm_expr_get_intnum(&e, 0))) { |
| yasm_error_set(YASM_ERROR_NOT_CONSTANT, |
| N_("is_stmt value is not a constant")); |
| yasm_xfree(loc); |
| if (e) |
| yasm_expr_destroy(e); |
| return; |
| } |
| if (yasm_intnum_is_zero(intn)) |
| loc->is_stmt = IS_STMT_SET; |
| else if (yasm_intnum_is_pos1(intn)) |
| loc->is_stmt = IS_STMT_CLEAR; |
| else { |
| yasm_error_set(YASM_ERROR_VALUE, |
| N_("is_stmt value not 0 or 1")); |
| yasm_xfree(loc); |
| yasm_expr_destroy(e); |
| return; |
| } |
| yasm_expr_destroy(e); |
| } else if (in_isa) { |
| in_isa = 0; |
| if (!(e = yasm_vp_expr(vp, object->symtab, line)) || |
| !(intn = yasm_expr_get_intnum(&e, 0))) { |
| yasm_error_set(YASM_ERROR_NOT_CONSTANT, |
| N_("isa value is not a constant")); |
| yasm_xfree(loc); |
| if (e) |
| yasm_expr_destroy(e); |
| return; |
| } |
| if (yasm_intnum_sign(intn) < 0) { |
| yasm_error_set(YASM_ERROR_VALUE, |
| N_("isa value less than zero")); |
| yasm_xfree(loc); |
| yasm_expr_destroy(e); |
| return; |
| } |
| loc->isa_change = 1; |
| loc->isa = yasm_intnum_get_uint(intn); |
| yasm_expr_destroy(e); |
| } else if (!vp->val && (s = yasm_vp_id(vp))) { |
| if (yasm__strcasecmp(s, "is_stmt") == 0) |
| in_is_stmt = 1; |
| else if (yasm__strcasecmp(s, "isa") == 0) |
| in_isa = 1; |
| else if (yasm__strcasecmp(s, "basic_block") == 0) |
| loc->basic_block = 1; |
| else if (yasm__strcasecmp(s, "prologue_end") == 0) |
| loc->prologue_end = 1; |
| else if (yasm__strcasecmp(s, "epilogue_begin") == 0) |
| loc->epilogue_begin = 1; |
| else |
| yasm_warn_set(YASM_WARN_GENERAL, |
| N_("unrecognized loc option `%s'"), s); |
| } else if (!vp->val) { |
| yasm_warn_set(YASM_WARN_GENERAL, |
| N_("unrecognized numeric qualifier")); |
| } else if (yasm__strcasecmp(vp->val, "is_stmt") == 0) { |
| in_is_stmt = 1; |
| goto restart; /* don't go to the next valparam */ |
| } else if (yasm__strcasecmp(vp->val, "isa") == 0) { |
| in_isa = 1; |
| goto restart; /* don't go to the next valparam */ |
| } else |
| yasm_warn_set(YASM_WARN_GENERAL, |
| N_("unrecognized loc option `%s'"), vp->val); |
| vp = yasm_vps_next(vp); |
| } |
| |
| if (in_is_stmt || in_isa) { |
| yasm_error_set(YASM_ERROR_SYNTAX, N_("%s requires value"), |
| in_is_stmt ? "is_stmt" : "isa"); |
| yasm_xfree(loc); |
| return; |
| } |
| |
| /* Append new location */ |
| loc->vline = line; |
| loc->bc = NULL; |
| loc->sym = NULL; |
| STAILQ_INSERT_TAIL(&dsd->locs, loc, link); |
| } |
| |
| void |
| yasm_dwarf2__dir_file(yasm_object *object, yasm_valparamhead *valparams, |
| yasm_valparamhead *objext_valparams, unsigned long line) |
| { |
| yasm_dbgfmt_dwarf2 *dbgfmt_dwarf2 = (yasm_dbgfmt_dwarf2 *)object->dbgfmt; |
| yasm_valparam *vp; |
| /*@dependent@*/ /*@null@*/ const yasm_intnum *file_intn; |
| unsigned long filenum; |
| |
| if (!valparams) { |
| yasm_error_set(YASM_ERROR_SYNTAX, N_("[%s] requires an argument"), |
| "FILE"); |
| return; |
| } |
| |
| vp = yasm_vps_first(valparams); |
| if (yasm_vp_string(vp)) { |
| /* Just a bare filename */ |
| yasm_object_set_source_fn(object, yasm_vp_string(vp)); |
| return; |
| } |
| |
| /* Otherwise.. first vp is the file number */ |
| if (vp->type != YASM_PARAM_EXPR || |
| !(file_intn = yasm_expr_get_intnum(&vp->param.e, 0))) { |
| yasm_error_set(YASM_ERROR_NOT_CONSTANT, |
| N_("file number is not a constant")); |
| return; |
| } |
| filenum = yasm_intnum_get_uint(file_intn); |
| |
| vp = yasm_vps_next(vp); |
| if (!yasm_vp_string(vp)) { |
| yasm_error_set(YASM_ERROR_SYNTAX, |
| N_("file number given but no filename")); |
| return; |
| } |
| |
| dwarf2_dbgfmt_add_file(dbgfmt_dwarf2, filenum, yasm_vp_string(vp)); |
| } |
