libyasm/bytecode.c

   1 /*
   2  * Bytecode utility functions
   3  *
   4  *  Copyright (C) 2001-2007  Peter Johnson
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS''
  16  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE
  19  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  20  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  21  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  22  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  23  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  24  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  25  * POSSIBILITY OF SUCH DAMAGE.
  26  */
  27 #include "util.h"
  28
  29 #include "libyasm-stdint.h"
  30 #include "coretype.h"
  31
  32 #include "errwarn.h"
  33 #include "intnum.h"
  34 #include "expr.h"
  35 #include "value.h"
  36 #include "symrec.h"
  37
  38 #include "bytecode.h"
  39
  40
  41 void
  42 yasm_bc_set_multiple(yasm_bytecode *bc, yasm_expr *e)
  43 {
  44     if (bc->multiple)
  45         bc->multiple = yasm_expr_create_tree(bc->multiple, YASM_EXPR_MUL, e,
  46                                              e->line);
  47     else
  48         bc->multiple = e;
  49 }
  50
  51 void
  52 yasm_bc_finalize_common(yasm_bytecode *bc, yasm_bytecode *prev_bc)
  53 {
  54 }
  55
  56 int
  57 yasm_bc_calc_len_common(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
  58                         void *add_span_data)
  59 {
  60     yasm_internal_error(N_("bytecode length cannot be calculated"));
  61     /*@unreached@*/
  62     return 0;
  63 }
  64
  65 int
  66 yasm_bc_expand_common(yasm_bytecode *bc, int span, long old_val, long new_val,
  67                       /*@out@*/ long *neg_thres, /*@out@*/ long *pos_thres)
  68 {
  69     yasm_internal_error(N_("bytecode does not have any dependent spans"));
  70     /*@unreached@*/
  71     return 0;
  72 }
  73
  74 int
  75 yasm_bc_tobytes_common(yasm_bytecode *bc, unsigned char **buf,
  76                        unsigned char *bufstart, void *d,
  77                        yasm_output_value_func output_value,
  78                        /*@null@*/ yasm_output_reloc_func output_reloc)
  79 {
  80     yasm_internal_error(N_("bytecode cannot be converted to bytes"));
  81     /*@unreached@*/
  82     return 0;
  83 }
  84
  85 void
  86 yasm_bc_transform(yasm_bytecode *bc, const yasm_bytecode_callback *callback,
  87                   void *contents)
  88 {
  89     if (bc->callback)
  90         bc->callback->destroy(bc->contents);
  91     bc->callback = callback;
  92     bc->contents = contents;
  93 }
  94
  95 yasm_bytecode *
  96 yasm_bc_create_common(const yasm_bytecode_callback *callback, void *contents,
  97                       unsigned long line)
  98 {
  99     yasm_bytecode *bc = yasm_xmalloc(sizeof(yasm_bytecode));
 100
 101     bc->callback = callback;
 102     bc->section = NULL;
 103     bc->multiple = (yasm_expr *)NULL;
 104     bc->len = 0;
 105     bc->mult_int = 1;
 106     bc->line = line;
 107     bc->offset = ~0UL;  /* obviously incorrect / uninitialized value */
 108     bc->symrecs = NULL;
 109     bc->contents = contents;
 110
 111     return bc;
 112 }
 113
 114 yasm_section *
 115 yasm_bc_get_section(yasm_bytecode *bc)
 116 {
 117     return bc->section;
 118 }
 119
 120 void
 121 yasm_bc__add_symrec(yasm_bytecode *bc, yasm_symrec *sym)
 122 {
 123     if (!bc->symrecs) {
 124         bc->symrecs = yasm_xmalloc(2*sizeof(yasm_symrec *));
 125         bc->symrecs[0] = sym;
 126         bc->symrecs[1] = NULL;
 127     } else {
 128         /* Very inefficient implementation for large numbers of symbols.  But
 129          * that would be very unusual, so use the simple algorithm instead.
 130          */
 131         size_t count = 1;
 132         while (bc->symrecs[count])
 133             count++;
 134         bc->symrecs = yasm_xrealloc(bc->symrecs,
 135                                     (count+2)*sizeof(yasm_symrec *));
 136         bc->symrecs[count] = sym;
 137         bc->symrecs[count+1] = NULL;
 138     }
 139 }
 140
 141 void
 142 yasm_bc_destroy(yasm_bytecode *bc)
 143 {
 144     if (!bc)
 145         return;
 146
 147     if (bc->callback)
 148         bc->callback->destroy(bc->contents);
 149     yasm_expr_destroy(bc->multiple);
 150     if (bc->symrecs)
 151         yasm_xfree(bc->symrecs);
 152     yasm_xfree(bc);
 153 }
 154
 155 void
 156 yasm_bc_print(const yasm_bytecode *bc, FILE *f, int indent_level)
 157 {
 158     if (!bc->callback)
 159         fprintf(f, "%*s_Empty_\n", indent_level, "");
 160     else
 161         bc->callback->print(bc->contents, f, indent_level);
 162     fprintf(f, "%*sMultiple=", indent_level, "");
 163     if (!bc->multiple)
 164         fprintf(f, "nil (1)");
 165     else
 166         yasm_expr_print(bc->multiple, f);
 167     fprintf(f, "\n%*sLength=%lu\n", indent_level, "", bc->len);
 168     fprintf(f, "%*sLine Index=%lu\n", indent_level, "", bc->line);
 169     fprintf(f, "%*sOffset=%lx\n", indent_level, "", bc->offset);
 170 }
 171
 172 void
 173 yasm_bc_finalize(yasm_bytecode *bc, yasm_bytecode *prev_bc)
 174 {
 175     if (bc->callback)
 176         bc->callback->finalize(bc, prev_bc);
 177     if (bc->multiple) {
 178         yasm_value val;
 179
 180         if (yasm_value_finalize_expr(&val, bc->multiple, prev_bc, 0))
 181             yasm_error_set(YASM_ERROR_TOO_COMPLEX,
 182                            N_("multiple expression too complex"));
 183         else if (val.rel)
 184             yasm_error_set(YASM_ERROR_NOT_ABSOLUTE,
 185                            N_("multiple expression not absolute"));
 186         /* Finalize creates NULL output if value=0, but bc->multiple is NULL
 187          * if value=1 (this difference is to make the common case small).
 188          * However, this means we need to set bc->multiple explicitly to 0
 189          * here if val.abs is NULL.
 190          */
 191         if (val.abs)
 192             bc->multiple = val.abs;
 193         else
 194             bc->multiple = yasm_expr_create_ident(
 195                 yasm_expr_int(yasm_intnum_create_uint(0)), bc->line);
 196     }
 197 }
 198
 199 /*@null@*/ yasm_intnum *
 200 yasm_calc_bc_dist(yasm_bytecode *precbc1, yasm_bytecode *precbc2)
 201 {
 202     unsigned long dist2, dist1;
 203     yasm_intnum *intn;
 204
 205     if (precbc1->section != precbc2->section)
 206         return NULL;
 207
 208     dist1 = yasm_bc_next_offset(precbc1);
 209     dist2 = yasm_bc_next_offset(precbc2);
 210     if (dist2 < dist1) {
 211         intn = yasm_intnum_create_uint(dist1 - dist2);
 212         yasm_intnum_calc(intn, YASM_EXPR_NEG, NULL);
 213         return intn;
 214     }
 215     dist2 -= dist1;
 216     return yasm_intnum_create_uint(dist2);
 217 }
 218
 219 unsigned long
 220 yasm_bc_next_offset(yasm_bytecode *precbc)
 221 {
 222     return precbc->offset + precbc->len*precbc->mult_int;
 223 }
 224
 225 int
 226 yasm_bc_elem_size(yasm_bytecode *bc)
 227 {
 228     if (!bc->callback) {
 229         yasm_internal_error(N_("got empty bytecode in yasm_bc_elem_size"));
 230         return 0;
 231     } else if (!bc->callback->elem_size)
 232         return 0;
 233     else
 234         return bc->callback->elem_size(bc);
 235 }
 236
 237 int
 238 yasm_bc_calc_len(yasm_bytecode *bc, yasm_bc_add_span_func add_span,
 239                  void *add_span_data)
 240 {
 241     int retval = 0;
 242
 243     bc->len = 0;
 244
 245     if (!bc->callback)
 246         yasm_internal_error(N_("got empty bytecode in yasm_bc_calc_len"));
 247     else
 248         retval = bc->callback->calc_len(bc, add_span, add_span_data);
 249
 250     /* Check for multiples */
 251     bc->mult_int = 1;
 252     if (bc->multiple) {
 253         /*@dependent@*/ /*@null@*/ const yasm_intnum *num;
 254
 255         num = yasm_expr_get_intnum(&bc->multiple, 0);
 256         if (num) {
 257             if (yasm_intnum_sign(num) < 0) {
 258                 yasm_error_set(YASM_ERROR_VALUE, N_("multiple is negative"));
 259                 retval = -1;
 260             } else
 261                 bc->mult_int = yasm_intnum_get_int(num);
 262         } else {
 263             if (yasm_expr__contains(bc->multiple, YASM_EXPR_FLOAT)) {
 264                 yasm_error_set(YASM_ERROR_VALUE,
 265                     N_("expression must not contain floating point value"));
 266                 retval = -1;
 267             } else {
 268                 yasm_value value;
 269                 yasm_value_initialize(&value, bc->multiple, 0);
 270                 add_span(add_span_data, bc, 0, &value, 0, 0);
 271                 bc->mult_int = 0;   /* assume 0 to start */
 272             }
 273         }
 274     }
 275
 276     /* If we got an error somewhere along the line, clear out any calc len */
 277     if (retval < 0)
 278         bc->len = 0;
 279
 280     return retval;
 281 }
 282
 283 int
 284 yasm_bc_expand(yasm_bytecode *bc, int span, long old_val, long new_val,
 285                /*@out@*/ long *neg_thres, /*@out@*/ long *pos_thres)
 286 {
 287     if (span == 0) {
 288         bc->mult_int = new_val;
 289         return 1;
 290     }
 291     if (!bc->callback) {
 292         yasm_internal_error(N_("got empty bytecode in yasm_bc_expand"));
 293         /*@unreached@*/
 294         return -1;
 295     } else
 296         return bc->callback->expand(bc, span, old_val, new_val, neg_thres,
 297                                     pos_thres);
 298 }
 299
 300 /*@null@*/ /*@only@*/ unsigned char *
 301 yasm_bc_tobytes(yasm_bytecode *bc, unsigned char *buf, unsigned long *bufsize,
 302                 /*@out@*/ int *gap, void *d,
 303                 yasm_output_value_func output_value,
 304                 /*@null@*/ yasm_output_reloc_func output_reloc)
 305     /*@sets *buf@*/
 306 {
 307     /*@only@*/ /*@null@*/ unsigned char *mybuf = NULL;
 308     unsigned char *bufstart;
 309     unsigned char *origbuf, *destbuf;
 310     long i;
 311     int error = 0;
 312
 313     long mult;
 314     if (yasm_bc_get_multiple(bc, &mult, 1) || mult == 0) {
 315         *bufsize = 0;
 316         return NULL;
 317     }
 318     bc->mult_int = mult;
 319
 320     /* special case for reserve bytecodes */
 321     if (bc->callback->special == YASM_BC_SPECIAL_RESERVE) {
 322         *bufsize = bc->len*bc->mult_int;
 323         *gap = 1;
 324         return NULL;    /* we didn't allocate a buffer */
 325     }
 326     *gap = 0;
 327
 328     if (*bufsize < bc->len*bc->mult_int) {
 329         mybuf = yasm_xmalloc(bc->len*bc->mult_int);
 330         destbuf = mybuf;
 331     } else
 332         destbuf = buf;
 333     bufstart = destbuf;
 334
 335     *bufsize = bc->len*bc->mult_int;
 336
 337     if (!bc->callback)
 338         yasm_internal_error(N_("got empty bytecode in bc_tobytes"));
 339     else for (i=0; i<bc->mult_int; i++) {
 340         origbuf = destbuf;
 341         error = bc->callback->tobytes(bc, &destbuf, bufstart, d, output_value,
 342                                       output_reloc);
 343
 344         if (!error && ((unsigned long)(destbuf - origbuf) != bc->len))
 345             yasm_internal_error(
 346                 N_("written length does not match optimized length"));
 347     }
 348
 349     return mybuf;
 350 }
 351
 352 int
 353 yasm_bc_get_multiple(yasm_bytecode *bc, long *multiple, int calc_bc_dist)
 354 {
 355     /*@dependent@*/ /*@null@*/ const yasm_intnum *num;
 356
 357     *multiple = 1;
 358     if (bc->multiple) {
 359         num = yasm_expr_get_intnum(&bc->multiple, calc_bc_dist);
 360         if (!num) {
 361             yasm_error_set(YASM_ERROR_VALUE,
 362                            N_("could not determine multiple"));
 363             return 1;
 364         }
 365         if (yasm_intnum_sign(num) < 0) {
 366             yasm_error_set(YASM_ERROR_VALUE, N_("multiple is negative"));
 367             return 1;
 368         }
 369         *multiple = yasm_intnum_get_int(num);
 370     }
 371     return 0;
 372 }
 373
 374 const yasm_expr *
 375 yasm_bc_get_multiple_expr(const yasm_bytecode *bc)
 376 {
 377     return bc->multiple;
 378 }
 379
 380 yasm_insn *
 381 yasm_bc_get_insn(yasm_bytecode *bc)
 382 {
 383     if (bc->callback->special != YASM_BC_SPECIAL_INSN)
 384         return NULL;
 385     return (yasm_insn *)bc->contents;
 386 }