Update Yasm to 1.2.0 (Yasm Part 1/3)

third_party/yasm/patched-yasm/modules/dbgfmts/dwarf2/dwarf2-line.c

 /*
  * 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.
@@ skipping 10 matching lines @@
  * 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: dwarf2-line.c 2130 2008-10-07 05:38:11Z peter $");
 
 #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,
@@ skipping 28 matching lines @@
     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
+    DW_LNE_define_file,
+    DW_LNE_set_discriminator
 } 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)
 
@@ skipping 22 matching lines @@
     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 */
+    /*@null@*/ /*@dependent@*/ yasm_intnum *ext_operand_int; /* 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_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, 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_bytecode *bc, unsigned char **bufp, unsigned char *bufstart, 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,
     NULL,
     dwarf2_spp_bc_calc_len,
@@ skipping 93 matching lines @@
 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_operand_int = 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_operand_int = NULL;
     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 yasm_bytecode *
+dwarf2_dbgfmt_append_line_ext_op_int(yasm_section *sect,
+                                     dwarf_line_number_ext_op ext_opcode,
+                                     /*@only@*/ yasm_intnum *ext_operand)
+{
+    dwarf2_line_op *line_op = yasm_xmalloc(sizeof(dwarf2_line_op));
+    unsigned long ext_operandsize = yasm_intnum_size_leb128(ext_operand, 0);
+    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 = NULL;
+    line_op->ext_operand_int = 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
@@ skipping 32 matching lines @@
     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));
     }
+    if (loc->discriminator != 0) {
+        dwarf2_dbgfmt_append_line_ext_op_int(debug_line,
+            DW_LNE_set_discriminator,
+            yasm_intnum_create_uint(loc->discriminator));
+    }
 #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);
@@ skipping 89 matching lines @@
     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_filename_equals(const dwarf2_filename *fn,
+                       char **dirs,
+                       const char *pathname,
+                       unsigned long dirlen,
+                       const char *filename)
+{
+    /* check directory */
+    if (fn->dir == 0) {
+        if (dirlen != 0)
+            return 0;
+    } else {
+        if (strncmp(dirs[fn->dir-1], pathname, dirlen) != 0 ||
+            dirs[fn->dir-1][dirlen] != '\0')
+            return 0;
+    }
+
+    /* check filename */
+    return strcmp(fn->filename, filename) == 0;
+}
+
+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;
+    size_t dirlen;
+    const char *pathname, *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);
+    yasm_linemap_lookup(info->linemap, bc->line, &pathname, &info->loc.line);
+    dirlen = yasm__splitpath(pathname, &filename);
+
     /* 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)
+        && dwarf2_filename_equals(&dbgfmt_dwarf2->filenames[info->lastfile-1],
+                                  dbgfmt_dwarf2->dirs, pathname, dirlen,
+                                  filename))
         info->loc.file = info->lastfile;
     else {
         for (i=0; i<dbgfmt_dwarf2->filenames_size; i++) {
-            if (strcmp(filename, dbgfmt_dwarf2->filenames[i].pathname) == 0)
+            if (dwarf2_filename_equals(&dbgfmt_dwarf2->filenames[i],
+                                       dbgfmt_dwarf2->dirs, pathname, dirlen,
+                                       filename))
                 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;
@@ skipping 56 matching lines @@
         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.discriminator = 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);
@@ skipping 136 matching lines @@
 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,
+dwarf2_spp_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
+                      unsigned char *bufstart, 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) */
@@ skipping 42 matching lines @@
     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);
+    if (line_op->ext_operand_int)
+        yasm_intnum_destroy(line_op->ext_operand_int);
     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,
+dwarf2_line_op_bc_tobytes(yasm_bytecode *bc, unsigned char **bufp,
+                          unsigned char *bufstart, 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);
+                         (unsigned long)(buf-bufstart), bc, 0, d);
             buf += line_op->ext_operandsize;
         }
+        if (line_op->ext_operand_int) {
+            buf += yasm_intnum_get_leb128(line_op->ext_operand_int, buf, 0);
+        }
     }
 
     *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;
+    int in_is_stmt = 0, in_isa = 0, in_discriminator = 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);
@@ skipping 40 matching lines @@
                                 &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->discriminator = 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) {
@@ skipping 54 matching lines @@
             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 (in_discriminator) {
+            in_discriminator = 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_("discriminator 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_("discriminator value less than zero"));
+                yasm_xfree(loc);
+                yasm_expr_destroy(e);
+                return;
+            }
+            loc->discriminator = 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, "discriminator") == 0)
+                in_discriminator = 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 if (yasm__strcasecmp(vp->val, "discriminator") == 0) {
+            in_discriminator = 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) {
+    if (in_is_stmt || in_isa || in_discriminator) {
         yasm_error_set(YASM_ERROR_SYNTAX, N_("%s requires value"),
-                       in_is_stmt ? "is_stmt" : "isa");
+                       in_is_stmt ? "is_stmt" :
+                       (in_isa ? "isa" : "discriminator"));
         yasm_xfree(loc);
         return;
     }
 
     /* Append new location */
     loc->vline = line;
     loc->bc = NULL;
     loc->sym = NULL;
     STAILQ_INSERT_TAIL(&dsd->locs, loc, link);
 }
@@ skipping 31 matching lines @@
 
     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));
 }