nasmlib.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  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU Lesser General Public License as
   9  *   published by the Free Software Foundation, Inc.,
  10  *   51 Franklin St, Fifth Floor, Boston MA 02110-1301, USA; version 2.1,
  11  *   or, at your option, any later version, incorporated herein by
  12  *   reference.
  13  *
  14  *   Patches submitted to this file are required to be dual licensed
  15  *   under the LGPL 2.1+ and the 2-clause BSD license:
  16  *
  17  *   Copyright 1996-2009 the NASM Authors - All rights reserved.
  18  *
  19  *   Redistribution and use in source and binary forms, with or without
  20  *   modification, are permitted provided that the following
  21  *   conditions are met:
  22  *
  23  *   * Redistributions of source code must retain the above copyright
  24  *     notice, this list of conditions and the following disclaimer.
  25  *   * Redistributions in binary form must reproduce the above
  26  *     copyright notice, this list of conditions and the following
  27  *     disclaimer in the documentation and/or other materials provided
  28  *     with the distribution.
  29  *
  30  *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  31  *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  32  *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  33  *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  34  *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  35  *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  36  *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  37  *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  38  *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39  *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  40  *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  41  *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  42  *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  43  *
  44  * ----------------------------------------------------------------------- */
  45
  46 /*
  47  * nasmlib.c    library routines for the Netwide Assembler
  48  */
  49
  50 #include "compiler.h"
  51
  52 #include <stdio.h>
  53 #include <stdlib.h>
  54 #include <string.h>
  55 #include <ctype.h>
  56 #include <inttypes.h>
  57
  58 #include "nasm.h"
  59 #include "nasmlib.h"
  60 #include "insns.h"
  61
  62 int globalbits = 0;    /* defined in nasm.h, works better here for ASM+DISASM */
  63 efunc nasm_malloc_error;        /* Exported for the benefit of vsnprintf.c */
  64
  65 #ifdef LOGALLOC
  66 static FILE *logfp;
  67 #endif
  68
  69 /* Uninitialized -> all zero by C spec */
  70 const uint8_t zero_buffer[ZERO_BUF_SIZE];
  71
  72 /*
  73  * Prepare a table of tolower() results.  This avoids function calls
  74  * on some platforms.
  75  */
  76
  77 unsigned char nasm_tolower_tab[256];
  78
  79 void tolower_init(void)
  80 {
  81     int i;
  82
  83     for (i = 0; i < 256; i++)
  84         nasm_tolower_tab[i] = tolower(i);
  85 }
  86
  87 void nasm_set_malloc_error(efunc error)
  88 {
  89     nasm_malloc_error = error;
  90 #ifdef LOGALLOC
  91     logfp = fopen("malloc.log", "w");
  92     setvbuf(logfp, NULL, _IOLBF, BUFSIZ);
  93     fprintf(logfp, "null pointer is %p\n", NULL);
  94 #endif
  95 }
  96
  97 #ifdef LOGALLOC
  98 void *nasm_malloc_log(char *file, int line, size_t size)
  99 #else
 100 void *nasm_malloc(size_t size)
 101 #endif
 102 {
 103     void *p = malloc(size);
 104     if (!p)
 105         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 106 #ifdef LOGALLOC
 107     else
 108         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
 109                 file, line, (long)size, p);
 110 #endif
 111     return p;
 112 }
 113
 114 #ifdef LOGALLOC
 115 void *nasm_zalloc_log(char *file, int line, size_t size)
 116 #else
 117 void *nasm_zalloc(size_t size)
 118 #endif
 119 {
 120     void *p = calloc(size, 1);
 121     if (!p)
 122         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 123 #ifdef LOGALLOC
 124     else
 125         fprintf(logfp, "%s %d calloc(%ld, 1) returns %p\n",
 126                 file, line, (long)size, p);
 127 #endif
 128     return p;
 129 }
 130
 131 #ifdef LOGALLOC
 132 void *nasm_realloc_log(char *file, int line, void *q, size_t size)
 133 #else
 134 void *nasm_realloc(void *q, size_t size)
 135 #endif
 136 {
 137     void *p = q ? realloc(q, size) : malloc(size);
 138     if (!p)
 139         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 140 #ifdef LOGALLOC
 141     else if (q)
 142         fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
 143                 file, line, q, (long)size, p);
 144     else
 145         fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
 146                 file, line, (long)size, p);
 147 #endif
 148     return p;
 149 }
 150
 151 #ifdef LOGALLOC
 152 void nasm_free_log(char *file, int line, void *q)
 153 #else
 154 void nasm_free(void *q)
 155 #endif
 156 {
 157     if (q) {
 158 #ifdef LOGALLOC
 159         fprintf(logfp, "%s %d free(%p)\n", file, line, q);
 160 #endif
 161         free(q);
 162     }
 163 }
 164
 165 #ifdef LOGALLOC
 166 char *nasm_strdup_log(char *file, int line, const char *s)
 167 #else
 168 char *nasm_strdup(const char *s)
 169 #endif
 170 {
 171     char *p;
 172     int size = strlen(s) + 1;
 173
 174     p = malloc(size);
 175     if (!p)
 176         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 177 #ifdef LOGALLOC
 178     else
 179         fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
 180                 file, line, (long)size, p);
 181 #endif
 182     strcpy(p, s);
 183     return p;
 184 }
 185
 186 #ifdef LOGALLOC
 187 char *nasm_strndup_log(char *file, int line, char *s, size_t len)
 188 #else
 189 char *nasm_strndup(char *s, size_t len)
 190 #endif
 191 {
 192     char *p;
 193     int size = len + 1;
 194
 195     p = malloc(size);
 196     if (!p)
 197         nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
 198 #ifdef LOGALLOC
 199     else
 200         fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
 201                 file, line, (long)size, p);
 202 #endif
 203     strncpy(p, s, len);
 204     p[len] = '\0';
 205     return p;
 206 }
 207
 208 #ifndef nasm_stricmp
 209 int nasm_stricmp(const char *s1, const char *s2)
 210 {
 211     unsigned char c1, c2;
 212     int d;
 213
 214     while (1) {
 215         c1 = nasm_tolower(*s1++);
 216         c2 = nasm_tolower(*s2++);
 217         d = c1-c2;
 218
 219         if (d)
 220             return d;
 221         if (!c1)
 222             break;
 223     }
 224     return 0;
 225 }
 226 #endif
 227
 228 #ifndef nasm_strnicmp
 229 int nasm_strnicmp(const char *s1, const char *s2, size_t n)
 230 {
 231     unsigned char c1, c2;
 232     int d;
 233
 234     while (n--) {
 235         c1 = nasm_tolower(*s1++);
 236         c2 = nasm_tolower(*s2++);
 237         d = c1-c2;
 238
 239         if (d)
 240             return d;
 241         if (!c1)
 242             break;
 243     }
 244     return 0;
 245 }
 246 #endif
 247
 248 int nasm_memicmp(const char *s1, const char *s2, size_t n)
 249 {
 250     unsigned char c1, c2;
 251     int d;
 252
 253     while (n--) {
 254         c1 = nasm_tolower(*s1++);
 255         c2 = nasm_tolower(*s2++);
 256         d = c1-c2;
 257         if (d)
 258             return d;
 259     }
 260     return 0;
 261 }
 262
 263 #ifndef nasm_strsep
 264 char *nasm_strsep(char **stringp, const char *delim)
 265 {
 266         char *s = *stringp;
 267         char *e;
 268
 269         if (!s)
 270                 return NULL;
 271
 272         e = strpbrk(s, delim);
 273         if (e)
 274                 *e++ = '\0';
 275
 276         *stringp = e;
 277         return s;
 278 }
 279 #endif
 280
 281
 282 #define lib_isnumchar(c)   (nasm_isalnum(c) || (c) == '$' || (c) == '_')
 283 #define numvalue(c)  ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
 284
 285 static int radix_letter(char c)
 286 {
 287     switch (c) {
 288     case 'b': case 'B':
 289     case 'y': case 'Y':
 290         return 2;               /* Binary */
 291     case 'o': case 'O':
 292     case 'q': case 'Q':
 293         return 8;               /* Octal */
 294     case 'h': case 'H':
 295     case 'x': case 'X':
 296         return 16;              /* Hexadecimal */
 297     case 'd': case 'D':
 298     case 't': case 'T':
 299         return 10;              /* Decimal */
 300     default:
 301         return 0;               /* Not a known radix letter */
 302     }
 303 }
 304
 305 int64_t readnum(char *str, bool *error)
 306 {
 307     char *r = str, *q;
 308     int32_t pradix, sradix, radix;
 309     int plen, slen, len;
 310     uint64_t result, checklimit;
 311     int digit, last;
 312     bool warn = false;
 313     int sign = 1;
 314
 315     *error = false;
 316
 317     while (nasm_isspace(*r))
 318         r++;                    /* find start of number */
 319
 320     /*
 321      * If the number came from make_tok_num (as a result of an %assign), it
 322      * might have a '-' built into it (rather than in a preceeding token).
 323      */
 324     if (*r == '-') {
 325         r++;
 326         sign = -1;
 327     }
 328
 329     q = r;
 330
 331     while (lib_isnumchar(*q))
 332         q++;                    /* find end of number */
 333
 334     len = q-r;
 335     if (!len) {
 336         /* Not numeric */
 337         *error = true;
 338         return 0;
 339     }
 340
 341     /*
 342      * Handle radix formats:
 343      *
 344      * 0<radix-letter><string>
 345      * $<string>                (hexadecimal)
 346      * <string><radix-letter>
 347      */
 348     pradix = sradix = 0;
 349     plen = slen = 0;
 350
 351     if (len > 2 && *r == '0' && (pradix = radix_letter(r[1])) != 0)
 352         plen = 2;
 353     else if (len > 1 && *r == '$')
 354         pradix = 16, plen = 1;
 355
 356     if (len > 1 && (sradix = radix_letter(q[-1])) != 0)
 357         slen = 1;
 358
 359     if (pradix > sradix) {
 360         radix = pradix;
 361         r += plen;
 362     } else if (sradix > pradix) {
 363         radix = sradix;
 364         q -= slen;
 365     } else {
 366         /* Either decimal, or invalid -- if invalid, we'll trip up
 367            further down. */
 368         radix = 10;
 369     }
 370
 371     /*
 372      * `checklimit' must be 2**64 / radix. We can't do that in
 373      * 64-bit arithmetic, which we're (probably) using, so we
 374      * cheat: since we know that all radices we use are even, we
 375      * can divide 2**63 by radix/2 instead.
 376      */
 377     checklimit = 0x8000000000000000ULL / (radix >> 1);
 378
 379     /*
 380      * Calculate the highest allowable value for the last digit of a
 381      * 64-bit constant... in radix 10, it is 6, otherwise it is 0
 382      */
 383     last = (radix == 10 ? 6 : 0);
 384
 385     result = 0;
 386     while (*r && r < q) {
 387         if (*r != '_') {
 388             if (*r < '0' || (*r > '9' && *r < 'A')
 389                 || (digit = numvalue(*r)) >= radix) {
 390                 *error = true;
 391                 return 0;
 392             }
 393             if (result > checklimit ||
 394                 (result == checklimit && digit >= last)) {
 395                 warn = true;
 396             }
 397
 398             result = radix * result + digit;
 399         }
 400         r++;
 401     }
 402
 403     if (warn)
 404         nasm_malloc_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
 405                           "numeric constant %s does not fit in 64 bits",
 406                           str);
 407
 408     return result * sign;
 409 }
 410
 411 int64_t readstrnum(char *str, int length, bool *warn)
 412 {
 413     int64_t charconst = 0;
 414     int i;
 415
 416     *warn = false;
 417
 418     str += length;
 419     if (globalbits == 64) {
 420         for (i = 0; i < length; i++) {
 421             if (charconst & 0xFF00000000000000ULL)
 422                 *warn = true;
 423             charconst = (charconst << 8) + (uint8_t)*--str;
 424         }
 425     } else {
 426         for (i = 0; i < length; i++) {
 427             if (charconst & 0xFF000000UL)
 428                 *warn = true;
 429             charconst = (charconst << 8) + (uint8_t)*--str;
 430         }
 431     }
 432     return charconst;
 433 }
 434
 435 static int32_t next_seg;
 436
 437 void seg_init(void)
 438 {
 439     next_seg = 0;
 440 }
 441
 442 int32_t seg_alloc(void)
 443 {
 444     return (next_seg += 2) - 2;
 445 }
 446
 447 #ifdef WORDS_LITTLEENDIAN
 448
 449 void fwriteint16_t(uint16_t data, FILE * fp)
 450 {
 451     fwrite(&data, 1, 2, fp);
 452 }
 453
 454 void fwriteint32_t(uint32_t data, FILE * fp)
 455 {
 456     fwrite(&data, 1, 4, fp);
 457 }
 458
 459 void fwriteint64_t(uint64_t data, FILE * fp)
 460 {
 461     fwrite(&data, 1, 8, fp);
 462 }
 463
 464 void fwriteaddr(uint64_t data, int size, FILE * fp)
 465 {
 466     fwrite(&data, 1, size, fp);
 467 }
 468
 469 #else /* not WORDS_LITTLEENDIAN */
 470
 471 void fwriteint16_t(uint16_t data, FILE * fp)
 472 {
 473     char buffer[2], *p = buffer;
 474     WRITESHORT(p, data);
 475     fwrite(buffer, 1, 2, fp);
 476 }
 477
 478 void fwriteint32_t(uint32_t data, FILE * fp)
 479 {
 480     char buffer[4], *p = buffer;
 481     WRITELONG(p, data);
 482     fwrite(buffer, 1, 4, fp);
 483 }
 484
 485 void fwriteint64_t(uint64_t data, FILE * fp)
 486 {
 487     char buffer[8], *p = buffer;
 488     WRITEDLONG(p, data);
 489     fwrite(buffer, 1, 8, fp);
 490 }
 491
 492 void fwriteaddr(uint64_t data, int size, FILE * fp)
 493 {
 494     char buffer[8], *p = buffer;
 495     WRITEADDR(p, data, size);
 496     fwrite(buffer, 1, size, fp);
 497 }
 498
 499 #endif
 500
 501 size_t fwritezero(size_t bytes, FILE *fp)
 502 {
 503     size_t count = 0;
 504     size_t blksize;
 505     size_t rv;
 506
 507     while (bytes) {
 508         blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
 509
 510         rv = fwrite(zero_buffer, 1, blksize, fp);
 511         if (!rv)
 512             break;
 513
 514         count += rv;
 515         bytes -= rv;
 516     }
 517
 518     return count;
 519 }
 520
 521 void standard_extension(char *inname, char *outname, char *extension,
 522                         efunc error)
 523 {
 524     char *p, *q;
 525
 526     if (*outname)               /* file name already exists, */
 527         return;                 /* so do nothing */
 528     q = inname;
 529     p = outname;
 530     while (*q)
 531         *p++ = *q++;            /* copy, and find end of string */
 532     *p = '\0';                  /* terminate it */
 533     while (p > outname && *--p != '.') ;        /* find final period (or whatever) */
 534     if (*p != '.')
 535         while (*p)
 536             p++;                /* go back to end if none found */
 537     if (!strcmp(p, extension)) {        /* is the extension already there? */
 538         if (*extension)
 539             error(ERR_WARNING | ERR_NOFILE,
 540                   "file name already ends in `%s': "
 541                   "output will be in `nasm.out'", extension);
 542         else
 543             error(ERR_WARNING | ERR_NOFILE,
 544                   "file name already has no extension: "
 545                   "output will be in `nasm.out'");
 546         strcpy(outname, "nasm.out");
 547     } else
 548         strcpy(p, extension);
 549 }
 550
 551 /*
 552  * Common list of prefix names
 553  */
 554 static const char *prefix_names[] = {
 555     "a16", "a32", "a64", "asp", "lock", "o16", "o32", "o64", "osp",
 556     "rep", "repe", "repne", "repnz", "repz", "times", "wait"
 557 };
 558
 559 const char *prefix_name(int token)
 560 {
 561     unsigned int prefix = token-PREFIX_ENUM_START;
 562     if (prefix > elements(prefix_names))
 563         return NULL;
 564
 565     return prefix_names[prefix];
 566 }
 567
 568 /*
 569  * Binary search.
 570  */
 571 int bsi(const char *string, const char **array, int size)
 572 {
 573     int i = -1, j = size;       /* always, i < index < j */
 574     while (j - i >= 2) {
 575         int k = (i + j) / 2;
 576         int l = strcmp(string, array[k]);
 577         if (l < 0)              /* it's in the first half */
 578             j = k;
 579         else if (l > 0)         /* it's in the second half */
 580             i = k;
 581         else                    /* we've got it :) */
 582             return k;
 583     }
 584     return -1;                  /* we haven't got it :( */
 585 }
 586
 587 int bsii(const char *string, const char **array, int size)
 588 {
 589     int i = -1, j = size;       /* always, i < index < j */
 590     while (j - i >= 2) {
 591         int k = (i + j) / 2;
 592         int l = nasm_stricmp(string, array[k]);
 593         if (l < 0)              /* it's in the first half */
 594             j = k;
 595         else if (l > 0)         /* it's in the second half */
 596             i = k;
 597         else                    /* we've got it :) */
 598             return k;
 599     }
 600     return -1;                  /* we haven't got it :( */
 601 }
 602
 603 static char *file_name = NULL;
 604 static int32_t line_number = 0;
 605
 606 char *src_set_fname(char *newname)
 607 {
 608     char *oldname = file_name;
 609     file_name = newname;
 610     return oldname;
 611 }
 612
 613 int32_t src_set_linnum(int32_t newline)
 614 {
 615     int32_t oldline = line_number;
 616     line_number = newline;
 617     return oldline;
 618 }
 619
 620 int32_t src_get_linnum(void)
 621 {
 622     return line_number;
 623 }
 624
 625 int src_get(int32_t *xline, char **xname)
 626 {
 627     if (!file_name || !*xname || strcmp(*xname, file_name)) {
 628         nasm_free(*xname);
 629         *xname = file_name ? nasm_strdup(file_name) : NULL;
 630         *xline = line_number;
 631         return -2;
 632     }
 633     if (*xline != line_number) {
 634         int32_t tmp = line_number - *xline;
 635         *xline = line_number;
 636         return tmp;
 637     }
 638     return 0;
 639 }
 640
 641 char *nasm_strcat(const char *one, const char *two)
 642 {
 643     char *rslt;
 644     int l1 = strlen(one);
 645     rslt = nasm_malloc(l1 + strlen(two) + 1);
 646     strcpy(rslt, one);
 647     strcpy(rslt + l1, two);
 648     return rslt;
 649 }