nasmlib/saa.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2009 The NASM Authors - All Rights Reserved
   4  *   See the file AUTHORS included with the NASM distribution for
   5  *   the specific copyright holders.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following
   9  *   conditions are met:
  10  *
  11  *   * Redistributions of source code must retain the above copyright
  12  *     notice, this list of conditions and the following disclaimer.
  13  *   * Redistributions in binary form must reproduce the above
  14  *     copyright notice, this list of conditions and the following
  15  *     disclaimer in the documentation and/or other materials provided
  16  *     with the distribution.
  17  *
  18  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  19  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  20  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  21  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  22  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  23  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  25  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  26  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  28  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  29  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  30  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31  *
  32  * ----------------------------------------------------------------------- */
  33
  34 #include "compiler.h"
  35 #include "nasmlib.h"
  36 #include "saa.h"
  37
  38 /* Aggregate SAA components smaller than this */
  39 #define SAA_BLKSHIFT    16
  40 #define SAA_BLKLEN      ((size_t)1 << SAA_BLKSHIFT)
  41
  42 struct SAA *saa_init(size_t elem_len)
  43 {
  44     struct SAA *s;
  45     char *data;
  46
  47     s = nasm_zalloc(sizeof(struct SAA));
  48
  49     if (elem_len >= SAA_BLKLEN)
  50         s->blk_len = elem_len;
  51     else
  52         s->blk_len = SAA_BLKLEN - (SAA_BLKLEN % elem_len);
  53
  54     s->elem_len = elem_len;
  55     s->length = s->blk_len;
  56     data = nasm_malloc(s->blk_len);
  57     s->nblkptrs = s->nblks = 1;
  58     s->blk_ptrs = nasm_malloc(sizeof(char *));
  59     s->blk_ptrs[0] = data;
  60     s->wblk = s->rblk = &s->blk_ptrs[0];
  61
  62     return s;
  63 }
  64
  65 void saa_free(struct SAA *s)
  66 {
  67     char **p;
  68     size_t n;
  69
  70     for (p = s->blk_ptrs, n = s->nblks; n; p++, n--)
  71         nasm_free(*p);
  72
  73     nasm_free(s->blk_ptrs);
  74     nasm_free(s);
  75 }
  76
  77 /* Add one allocation block to an SAA */
  78 static void saa_extend(struct SAA *s)
  79 {
  80     size_t blkn = s->nblks++;
  81
  82     if (blkn >= s->nblkptrs) {
  83         size_t rindex = s->rblk - s->blk_ptrs;
  84         size_t windex = s->wblk - s->blk_ptrs;
  85
  86         s->nblkptrs <<= 1;
  87         s->blk_ptrs =
  88             nasm_realloc(s->blk_ptrs, s->nblkptrs * sizeof(char *));
  89
  90         s->rblk = s->blk_ptrs + rindex;
  91         s->wblk = s->blk_ptrs + windex;
  92     }
  93
  94     s->blk_ptrs[blkn] = nasm_malloc(s->blk_len);
  95     s->length += s->blk_len;
  96 }
  97
  98 void *saa_wstruct(struct SAA *s)
  99 {
 100     void *p;
 101
 102     nasm_assert((s->wpos % s->elem_len) == 0);
 103
 104     if (s->wpos + s->elem_len > s->blk_len) {
 105         nasm_assert(s->wpos == s->blk_len);
 106         if (s->wptr + s->elem_len > s->length)
 107             saa_extend(s);
 108         s->wblk++;
 109         s->wpos = 0;
 110     }
 111
 112     p = *s->wblk + s->wpos;
 113     s->wpos += s->elem_len;
 114     s->wptr += s->elem_len;
 115
 116     if (s->wptr > s->datalen)
 117         s->datalen = s->wptr;
 118
 119     return p;
 120 }
 121
 122 void saa_wbytes(struct SAA *s, const void *data, size_t len)
 123 {
 124     const char *d = data;
 125
 126     while (len) {
 127         size_t l = s->blk_len - s->wpos;
 128         if (l > len)
 129             l = len;
 130         if (l) {
 131             if (d) {
 132                 memcpy(*s->wblk + s->wpos, d, l);
 133                 d += l;
 134             } else
 135                 memset(*s->wblk + s->wpos, 0, l);
 136             s->wpos += l;
 137             s->wptr += l;
 138             len -= l;
 139
 140             if (s->datalen < s->wptr)
 141                 s->datalen = s->wptr;
 142         }
 143         if (len) {
 144             if (s->wptr >= s->length)
 145                 saa_extend(s);
 146             s->wblk++;
 147             s->wpos = 0;
 148         }
 149     }
 150 }
 151
 152 void saa_rewind(struct SAA *s)
 153 {
 154     s->rblk = s->blk_ptrs;
 155     s->rpos = s->rptr = 0;
 156 }
 157
 158 void *saa_rstruct(struct SAA *s)
 159 {
 160     void *p;
 161
 162     if (s->rptr + s->elem_len > s->datalen)
 163         return NULL;
 164
 165     nasm_assert((s->rpos % s->elem_len) == 0);
 166
 167     if (s->rpos + s->elem_len > s->blk_len) {
 168         s->rblk++;
 169         s->rpos = 0;
 170     }
 171
 172     p = *s->rblk + s->rpos;
 173     s->rpos += s->elem_len;
 174     s->rptr += s->elem_len;
 175
 176     return p;
 177 }
 178
 179 const void *saa_rbytes(struct SAA *s, size_t * lenp)
 180 {
 181     const void *p;
 182     size_t len;
 183
 184     if (s->rptr >= s->datalen) {
 185         *lenp = 0;
 186         return NULL;
 187     }
 188
 189     if (s->rpos >= s->blk_len) {
 190         s->rblk++;
 191         s->rpos = 0;
 192     }
 193
 194     len = *lenp;
 195     if (len > s->datalen - s->rptr)
 196         len = s->datalen - s->rptr;
 197     if (len > s->blk_len - s->rpos)
 198         len = s->blk_len - s->rpos;
 199
 200     *lenp = len;
 201     p = *s->rblk + s->rpos;
 202
 203     s->rpos += len;
 204     s->rptr += len;
 205
 206     return p;
 207 }
 208
 209 void saa_rnbytes(struct SAA *s, void *data, size_t len)
 210 {
 211     char *d = data;
 212
 213     nasm_assert(s->rptr + len <= s->datalen);
 214
 215     while (len) {
 216         size_t l;
 217         const void *p;
 218
 219         l = len;
 220         p = saa_rbytes(s, &l);
 221
 222         memcpy(d, p, l);
 223         d += l;
 224         len -= l;
 225     }
 226 }
 227
 228 /* Same as saa_rnbytes, except position the counter first */
 229 void saa_fread(struct SAA *s, size_t posn, void *data, size_t len)
 230 {
 231     size_t ix;
 232
 233     nasm_assert(posn + len <= s->datalen);
 234
 235     if (likely(s->blk_len == SAA_BLKLEN)) {
 236         ix = posn >> SAA_BLKSHIFT;
 237         s->rpos = posn & (SAA_BLKLEN - 1);
 238     } else {
 239         ix = posn / s->blk_len;
 240         s->rpos = posn % s->blk_len;
 241     }
 242     s->rptr = posn;
 243     s->rblk = &s->blk_ptrs[ix];
 244
 245     saa_rnbytes(s, data, len);
 246 }
 247
 248 /* Same as saa_wbytes, except position the counter first */
 249 void saa_fwrite(struct SAA *s, size_t posn, const void *data, size_t len)
 250 {
 251     size_t ix;
 252
 253     /* Seek beyond the end of the existing array not supported */
 254     nasm_assert(posn <= s->datalen);
 255
 256     if (likely(s->blk_len == SAA_BLKLEN)) {
 257         ix = posn >> SAA_BLKSHIFT;
 258         s->wpos = posn & (SAA_BLKLEN - 1);
 259     } else {
 260         ix = posn / s->blk_len;
 261         s->wpos = posn % s->blk_len;
 262     }
 263     s->wptr = posn;
 264     s->wblk = &s->blk_ptrs[ix];
 265
 266     if (!s->wpos) {
 267         s->wpos = s->blk_len;
 268         s->wblk--;
 269     }
 270
 271     saa_wbytes(s, data, len);
 272 }
 273
 274 void saa_fpwrite(struct SAA *s, FILE * fp)
 275 {
 276     const char *data;
 277     size_t len;
 278
 279     saa_rewind(s);
 280     while (len = s->datalen, (data = saa_rbytes(s, &len)) != NULL)
 281         nasm_write(data, len, fp);
 282 }
 283
 284 void saa_write8(struct SAA *s, uint8_t v)
 285 {
 286     saa_wbytes(s, &v, 1);
 287 }
 288
 289 #ifdef WORDS_LITTEENDIAN
 290
 291 void saa_write16(struct SAA *s, uint16_t v)
 292 {
 293     saa_wbytes(s, &v, 2);
 294 }
 295
 296 void saa_write32(struct SAA *s, uint32_t v)
 297 {
 298     saa_wbytes(s, &v, 4);
 299 }
 300
 301 void saa_write64(struct SAA *s, uint64_t v)
 302 {
 303     saa_wbytes(s, &v, 8);
 304 }
 305
 306 void saa_writeaddr(struct SAA *s, uint64_t v, size_t len)
 307 {
 308     saa_wbytes(s, &v, len);
 309 }
 310
 311 #else                           /* not WORDS_LITTLEENDIAN */
 312
 313 void saa_write16(struct SAA *s, uint16_t v)
 314 {
 315     uint8_t b[2];
 316
 317     b[0] = v;
 318     b[1] = v >> 8;
 319     saa_wbytes(s, b, 2);
 320 }
 321
 322 void saa_write32(struct SAA *s, uint32_t v)
 323 {
 324     uint8_t b[4];
 325
 326     b[0] = v;
 327     b[1] = v >> 8;
 328     b[2] = v >> 16;
 329     b[3] = v >> 24;
 330     saa_wbytes(s, b, 4);
 331 }
 332
 333 void saa_write64(struct SAA *s, uint64_t v)
 334 {
 335     uint8_t b[8];
 336
 337     b[0] = v;
 338     b[1] = v >> 8;
 339     b[2] = v >> 16;
 340     b[3] = v >> 24;
 341     b[4] = v >> 32;
 342     b[5] = v >> 40;
 343     b[6] = v >> 48;
 344     b[7] = v >> 56;
 345
 346     saa_wbytes(s, b, 8);
 347 }
 348
 349 void saa_writeaddr(struct SAA *s, uint64_t v, size_t len)
 350 {
 351     uint8_t b[8];
 352
 353     b[0] = v;
 354     b[1] = v >> 8;
 355     b[2] = v >> 16;
 356     b[3] = v >> 24;
 357     b[4] = v >> 32;
 358     b[5] = v >> 40;
 359     b[6] = v >> 48;
 360     b[7] = v >> 56;
 361
 362     saa_wbytes(s, b, len);
 363 }
 364
 365 #endif                          /* WORDS_LITTLEENDIAN */
 366
 367 /* write unsigned LEB128 value to SAA */
 368 void saa_wleb128u(struct SAA *psaa, int value)
 369 {
 370     char temp[64], *ptemp;
 371     uint8_t byte;
 372     int len;
 373
 374     ptemp = temp;
 375     len = 0;
 376     do {
 377         byte = value & 127;
 378         value >>= 7;
 379         if (value != 0)         /* more bytes to come */
 380             byte |= 0x80;
 381         *ptemp = byte;
 382         ptemp++;
 383         len++;
 384     } while (value != 0);
 385     saa_wbytes(psaa, temp, len);
 386 }
 387
 388 /* write signed LEB128 value to SAA */
 389 void saa_wleb128s(struct SAA *psaa, int value)
 390 {
 391     char temp[64], *ptemp;
 392     uint8_t byte;
 393     bool more, negative;
 394     int size, len;
 395
 396     ptemp = temp;
 397     more = 1;
 398     negative = (value < 0);
 399     size = sizeof(int) * 8;
 400     len = 0;
 401     while (more) {
 402         byte = value & 0x7f;
 403         value >>= 7;
 404         if (negative)
 405             /* sign extend */
 406             value |= -(1 << (size - 7));
 407         /* sign bit of byte is second high order bit (0x40) */
 408         if ((value == 0 && !(byte & 0x40)) ||
 409             ((value == -1) && (byte & 0x40)))
 410             more = 0;
 411         else
 412             byte |= 0x80;
 413         *ptemp = byte;
 414         ptemp++;
 415         len++;
 416     }
 417     saa_wbytes(psaa, temp, len);
 418 }