Update our yasm copy to yasm 1.1.0 (Part 1: yasm side)...

third_party/yasm/patched-yasm/libyasm/section.c

 /*
  * Section utility functions
  *
  *  Copyright (C) 2001-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.
  *
  * 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: section.c 2109 2008-06-08 09:06:05Z peter $");
+/*@unused@*/ RCSID("$Id: section.c 2310 2010-03-28 19:28:54Z peter $");
 
 #include <limits.h>
 
 #include "libyasm-stdint.h"
 #include "coretype.h"
 #include "hamt.h"
 #include "valparam.h"
 #include "assocdat.h"
 
 #include "linemap.h"
@@ skipping 300 matching lines @@
     STAILQ_INSERT_TAIL(&s->bcs, bc, link);
 
     /* Initialize relocs */
     STAILQ_INIT(&s->relocs);
     s->destroy_reloc = NULL;
 
     s->code = code;
     s->res_only = res_only;
     s->def = 0;
 
+    /* Initialize object format specific data */
+    yasm_objfmt_init_new_section(s, line);
+
     *isnew = 1;
     return s;
 }
 /*@=onlytrans@*/
 
 int
 yasm_object_directive(yasm_object *object, const char *name,
                       const char *parser, yasm_valparamhead *valparams,
                       yasm_valparamhead *objext_valparams,
                       unsigned long line)
@@ skipping 498 matching lines @@
     long pos_thres;
 
     int id;
 
     int active;
 
     /* NULL-terminated array of spans that led to this span.  Used only for
      * checking for circular references (cycles) with id=0 spans.
      */
     yasm_span **backtrace;
+    int backtrace_size;
 
     /* First offset setter following this span's bytecode */
     yasm_offset_setter *os;
 };
 
 typedef struct optimize_data {
-    /*@reldef@*/ TAILQ_HEAD(, yasm_span) spans;
-    /*@reldef@*/ STAILQ_HEAD(, yasm_span) QA, QB;
+    /*@reldef@*/ TAILQ_HEAD(yasm_span_head, yasm_span) spans;
+    /*@reldef@*/ STAILQ_HEAD(yasm_span_shead, yasm_span) QA, QB;
     /*@only@*/ IntervalTree *itree;
-    /*@reldef@*/ STAILQ_HEAD(, yasm_offset_setter) offset_setters;
+    /*@reldef@*/ STAILQ_HEAD(offset_setters_head, yasm_offset_setter)
+        offset_setters;
     long len_diff;      /* used only for optimize_term_expand */
     yasm_span *span;    /* used only for check_cycle */
     yasm_offset_setter *os;
 } optimize_data;
 
 static yasm_span *
 create_span(yasm_bytecode *bc, int id, /*@null@*/ const yasm_value *value, 
             long neg_thres, long pos_thres, yasm_offset_setter *os)
 {
     yasm_span *span = yasm_xmalloc(sizeof(yasm_span));
 
     span->bc = bc;
     if (value)
         yasm_value_init_copy(&span->depval, value);
     else
         yasm_value_initialize(&span->depval, NULL, 0);
     span->rel_term = NULL;
     span->terms = NULL;
     span->items = NULL;
     span->num_terms = 0;
     span->cur_val = 0;
     span->new_val = 0;
     span->neg_thres = neg_thres;
     span->pos_thres = pos_thres;
     span->id = id;
     span->active = 1;
     span->backtrace = NULL;
+    span->backtrace_size = 0;
     span->os = os;
 
     return span;
 }
 
 static void
 optimize_add_span(void *add_span_data, yasm_bytecode *bc, int id,
                   const yasm_value *value, long neg_thres, long pos_thres)
 {
     optimize_data *optd = (optimize_data *)add_span_data;
@@ skipping 239 matching lines @@
 
     IT_insert(itree, (long)low, (long)high, term);
 }
 
 static void
 check_cycle(IntervalTreeNode *node, void *d)
 {
     optimize_data *optd = d;
     yasm_span_term *term = node->data;
     yasm_span *depspan = term->span;
-    int bt_size = 0, dep_bt_size = 0;
+    int i;
+    int depspan_bt_alloc;
 
     /* Only check for cycles in id=0 spans */
     if (depspan->id > 0)
         return;
 
     /* Check for a circular reference by looking to see if this dependent
      * span is in our backtrace.
      */
     if (optd->span->backtrace) {
-        yasm_span *s;
-        while ((s = optd->span->backtrace[bt_size])) {
-            bt_size++;
-            if (s == depspan)
+        for (i=0; i<optd->span->backtrace_size; i++) {
+            if (optd->span->backtrace[i] == depspan)
                 yasm_error_set(YASM_ERROR_VALUE,
                                N_("circular reference detected"));
         }
     }
 
     /* Add our complete backtrace and ourselves to backtrace of dependent
      * span.
      */
     if (!depspan->backtrace) {
-        depspan->backtrace = yasm_xmalloc((bt_size+2)*sizeof(yasm_span *));
-        if (bt_size > 0)
+        depspan->backtrace = yasm_xmalloc((optd->span->backtrace_size+1)*
+                                          sizeof(yasm_span *));
+        if (optd->span->backtrace_size > 0)
             memcpy(depspan->backtrace, optd->span->backtrace,
-                   bt_size*sizeof(yasm_span *));
-        depspan->backtrace[bt_size] = optd->span;
-        depspan->backtrace[bt_size+1] = NULL;
+                   optd->span->backtrace_size*sizeof(yasm_span *));
+        depspan->backtrace[optd->span->backtrace_size] = optd->span;
+        depspan->backtrace_size = optd->span->backtrace_size+1;
         return;
     }
 
-    while (depspan->backtrace[dep_bt_size])
-        dep_bt_size++;
-    depspan->backtrace =
-        yasm_xrealloc(depspan->backtrace,
-                      (dep_bt_size+bt_size+2)*sizeof(yasm_span *));
-    if (bt_size > 0)
-        memcpy(&depspan->backtrace[dep_bt_size], optd->span->backtrace,
-               (bt_size-1)*sizeof(yasm_span *));
-    depspan->backtrace[dep_bt_size+bt_size] = optd->span;
-    depspan->backtrace[dep_bt_size+bt_size+1] = NULL;
+    /* Add our complete backtrace, checking for duplicates */
+    depspan_bt_alloc = depspan->backtrace_size;
+    for (i=0; i<optd->span->backtrace_size; i++) {
+        int present = 0;
+        int j;
+        for (j=0; j<depspan->backtrace_size; j++) {
+            if (optd->span->backtrace[i] == optd->span->backtrace[j]) {
+                present = 1;
+                break;
+            }
+        }
+        if (present)
+            continue;
+        /* Not already in array; add it. */
+        if (depspan->backtrace_size >= depspan_bt_alloc)
+        {
+            depspan_bt_alloc *= 2;
+            depspan->backtrace =
+                yasm_xrealloc(depspan->backtrace,
+                              depspan_bt_alloc*sizeof(yasm_span *));
+        }
+        depspan->backtrace[depspan->backtrace_size] = optd->span->backtrace[i];
+        depspan->backtrace_size++;
+    }
+
+    /* Add ourselves. */
+    if (depspan->backtrace_size >= depspan_bt_alloc)
+    {
+        depspan_bt_alloc++;
+        depspan->backtrace =
+            yasm_xrealloc(depspan->backtrace,
+                          depspan_bt_alloc*sizeof(yasm_span *));
+    }
+    depspan->backtrace[depspan->backtrace_size] = optd->span;
+    depspan->backtrace_size++;
 }
 
 static void
 optimize_term_expand(IntervalTreeNode *node, void *d)
 {
     optimize_data *optd = d;
     yasm_span_term *term = node->data;
     yasm_span *span = term->span;
     long len_diff = optd->len_diff;
     long precbc_index, precbc2_index;
@@ skipping 326 matching lines @@
 
     if (saw_error) {
         optimize_cleanup(&optd);
         return;
     }
 
     /* Step 3 */
     update_all_bc_offsets(object, errwarns);
     optimize_cleanup(&optd);
 }