1 /* ----------------------------------------------------------------------- *
3 * Copyright 1996-2010 The NASM Authors - All Rights Reserved
4 * See the file AUTHORS included with the NASM distribution for
5 * the specific copyright holders.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
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.
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.
32 * ----------------------------------------------------------------------- */
35 * nasmlib.c library routines for the Netwide Assembler
50 int globalbits = 0; /* defined in nasm.h, works better here for ASM+DISASM */
51 static vefunc nasm_verror; /* Global error handling function */
57 /* Uninitialized -> all zero by C spec */
58 const uint8_t zero_buffer[ZERO_BUF_SIZE];
61 * Prepare a table of tolower() results. This avoids function calls
65 unsigned char nasm_tolower_tab[256];
67 void tolower_init(void)
71 for (i = 0; i < 256; i++)
72 nasm_tolower_tab[i] = tolower(i);
75 void nasm_set_verror(vefunc ve)
80 void nasm_error(int severity, const char *fmt, ...)
85 nasm_verror(severity, fmt, ap);
89 void nasm_init_malloc_error(void)
92 logfp = fopen("malloc.log", "w");
94 setvbuf(logfp, NULL, _IOLBF, BUFSIZ);
96 nasm_error(ERR_NONFATAL | ERR_NOFILE, "Unable to open %s", logfp);
99 fprintf(logfp, "null pointer is %p\n", NULL);
104 void *nasm_malloc_log(const char *file, int line, size_t size)
106 void *nasm_malloc(size_t size)
109 void *p = malloc(size);
111 nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
114 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
115 file, line, (long)size, p);
121 void *nasm_zalloc_log(const char *file, int line, size_t size)
123 void *nasm_zalloc(size_t size)
126 void *p = calloc(size, 1);
128 nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
131 fprintf(logfp, "%s %d calloc(%ld, 1) returns %p\n",
132 file, line, (long)size, p);
138 void *nasm_realloc_log(const char *file, int line, void *q, size_t size)
140 void *nasm_realloc(void *q, size_t size)
143 void *p = q ? realloc(q, size) : malloc(size);
145 nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
148 fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
149 file, line, q, (long)size, p);
151 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
152 file, line, (long)size, p);
158 void nasm_free_log(const char *file, int line, void *q)
160 void nasm_free(void *q)
165 fprintf(logfp, "%s %d free(%p)\n", file, line, q);
172 char *nasm_strdup_log(const char *file, int line, const char *s)
174 char *nasm_strdup(const char *s)
178 int size = strlen(s) + 1;
182 nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
185 fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
186 file, line, (long)size, p);
193 char *nasm_strndup_log(const char *file, int line, const char *s, size_t len)
195 char *nasm_strndup(const char *s, size_t len)
203 nasm_error(ERR_FATAL | ERR_NOFILE, "out of memory");
206 fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
207 file, line, (long)size, p);
214 no_return nasm_assert_failed(const char *file, int line, const char *msg)
216 nasm_error(ERR_FATAL, "assertion %s failed at %s:%d", msg, file, line);
221 int nasm_stricmp(const char *s1, const char *s2)
223 unsigned char c1, c2;
227 c1 = nasm_tolower(*s1++);
228 c2 = nasm_tolower(*s2++);
240 #ifndef nasm_strnicmp
241 int nasm_strnicmp(const char *s1, const char *s2, size_t n)
243 unsigned char c1, c2;
247 c1 = nasm_tolower(*s1++);
248 c2 = nasm_tolower(*s2++);
260 int nasm_memicmp(const char *s1, const char *s2, size_t n)
262 unsigned char c1, c2;
266 c1 = nasm_tolower(*s1++);
267 c2 = nasm_tolower(*s2++);
276 char *nasm_strsep(char **stringp, const char *delim)
284 e = strpbrk(s, delim);
294 #define lib_isnumchar(c) (nasm_isalnum(c) || (c) == '$' || (c) == '_')
295 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
297 static int radix_letter(char c)
302 return 2; /* Binary */
305 return 8; /* Octal */
308 return 16; /* Hexadecimal */
311 return 10; /* Decimal */
313 return 0; /* Not a known radix letter */
317 int64_t readnum(char *str, bool *error)
320 int32_t pradix, sradix, radix;
322 uint64_t result, checklimit;
329 while (nasm_isspace(*r))
330 r++; /* find start of number */
333 * If the number came from make_tok_num (as a result of an %assign), it
334 * might have a '-' built into it (rather than in a preceeding token).
343 while (lib_isnumchar(*q))
344 q++; /* find end of number */
354 * Handle radix formats:
356 * 0<radix-letter><string>
357 * $<string> (hexadecimal)
358 * <string><radix-letter>
363 if (len > 2 && *r == '0' && (pradix = radix_letter(r[1])) != 0)
365 else if (len > 1 && *r == '$')
366 pradix = 16, plen = 1;
368 if (len > 1 && (sradix = radix_letter(q[-1])) != 0)
371 if (pradix > sradix) {
374 } else if (sradix > pradix) {
378 /* Either decimal, or invalid -- if invalid, we'll trip up
384 * `checklimit' must be 2**64 / radix. We can't do that in
385 * 64-bit arithmetic, which we're (probably) using, so we
386 * cheat: since we know that all radices we use are even, we
387 * can divide 2**63 by radix/2 instead.
389 checklimit = UINT64_C(0x8000000000000000) / (radix >> 1);
392 * Calculate the highest allowable value for the last digit of a
393 * 64-bit constant... in radix 10, it is 6, otherwise it is 0
395 last = (radix == 10 ? 6 : 0);
398 while (*r && r < q) {
400 if (*r < '0' || (*r > '9' && *r < 'A')
401 || (digit = numvalue(*r)) >= radix) {
405 if (result > checklimit ||
406 (result == checklimit && digit >= last)) {
410 result = radix * result + digit;
416 nasm_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
417 "numeric constant %s does not fit in 64 bits",
420 return result * sign;
423 int64_t readstrnum(char *str, int length, bool *warn)
425 int64_t charconst = 0;
431 if (globalbits == 64) {
432 for (i = 0; i < length; i++) {
433 if (charconst & UINT64_C(0xFF00000000000000))
435 charconst = (charconst << 8) + (uint8_t)*--str;
438 for (i = 0; i < length; i++) {
439 if (charconst & 0xFF000000UL)
441 charconst = (charconst << 8) + (uint8_t)*--str;
447 static int32_t next_seg;
454 int32_t seg_alloc(void)
456 return (next_seg += 2) - 2;
459 #ifdef WORDS_LITTLEENDIAN
461 void fwriteint16_t(uint16_t data, FILE * fp)
463 fwrite(&data, 1, 2, fp);
466 void fwriteint32_t(uint32_t data, FILE * fp)
468 fwrite(&data, 1, 4, fp);
471 void fwriteint64_t(uint64_t data, FILE * fp)
473 fwrite(&data, 1, 8, fp);
476 void fwriteaddr(uint64_t data, int size, FILE * fp)
478 fwrite(&data, 1, size, fp);
481 #else /* not WORDS_LITTLEENDIAN */
483 void fwriteint16_t(uint16_t data, FILE * fp)
485 char buffer[2], *p = buffer;
487 fwrite(buffer, 1, 2, fp);
490 void fwriteint32_t(uint32_t data, FILE * fp)
492 char buffer[4], *p = buffer;
494 fwrite(buffer, 1, 4, fp);
497 void fwriteint64_t(uint64_t data, FILE * fp)
499 char buffer[8], *p = buffer;
501 fwrite(buffer, 1, 8, fp);
504 void fwriteaddr(uint64_t data, int size, FILE * fp)
506 char buffer[8], *p = buffer;
507 WRITEADDR(p, data, size);
508 fwrite(buffer, 1, size, fp);
513 size_t fwritezero(size_t bytes, FILE *fp)
520 blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
522 rv = fwrite(zero_buffer, 1, blksize, fp);
533 void standard_extension(char *inname, char *outname, char *extension)
537 if (*outname) /* file name already exists, */
538 return; /* so do nothing */
542 *p++ = *q++; /* copy, and find end of string */
543 *p = '\0'; /* terminate it */
544 while (p > outname && *--p != '.') ; /* find final period (or whatever) */
547 p++; /* go back to end if none found */
548 if (!strcmp(p, extension)) { /* is the extension already there? */
550 nasm_error(ERR_WARNING | ERR_NOFILE,
551 "file name already ends in `%s': "
552 "output will be in `nasm.out'", extension);
554 nasm_error(ERR_WARNING | ERR_NOFILE,
555 "file name already has no extension: "
556 "output will be in `nasm.out'");
557 strcpy(outname, "nasm.out");
559 strcpy(p, extension);
563 * Common list of prefix names
565 static const char *prefix_names[] = {
566 "a16", "a32", "a64", "asp", "lock", "o16", "o32", "o64", "osp",
567 "rep", "repe", "repne", "repnz", "repz", "times", "wait"
570 const char *prefix_name(int token)
572 unsigned int prefix = token-PREFIX_ENUM_START;
573 if (prefix >= ARRAY_SIZE(prefix_names))
576 return prefix_names[prefix];
582 int bsi(const char *string, const char **array, int size)
584 int i = -1, j = size; /* always, i < index < j */
587 int l = strcmp(string, array[k]);
588 if (l < 0) /* it's in the first half */
590 else if (l > 0) /* it's in the second half */
592 else /* we've got it :) */
595 return -1; /* we haven't got it :( */
598 int bsii(const char *string, const char **array, int size)
600 int i = -1, j = size; /* always, i < index < j */
603 int l = nasm_stricmp(string, array[k]);
604 if (l < 0) /* it's in the first half */
606 else if (l > 0) /* it's in the second half */
608 else /* we've got it :) */
611 return -1; /* we haven't got it :( */
614 static char *file_name = NULL;
615 static int32_t line_number = 0;
617 char *src_set_fname(char *newname)
619 char *oldname = file_name;
624 int32_t src_set_linnum(int32_t newline)
626 int32_t oldline = line_number;
627 line_number = newline;
631 int32_t src_get_linnum(void)
636 int src_get(int32_t *xline, char **xname)
638 if (!file_name || !*xname || strcmp(*xname, file_name)) {
640 *xname = file_name ? nasm_strdup(file_name) : NULL;
641 *xline = line_number;
644 if (*xline != line_number) {
645 int32_t tmp = line_number - *xline;
646 *xline = line_number;
652 char *nasm_strcat(const char *one, const char *two)
655 int l1 = strlen(one);
656 rslt = nasm_malloc(l1 + strlen(two) + 1);
658 strcpy(rslt + l1, two);
662 /* skip leading spaces */
663 char *nasm_skip_spaces(const char *p)
666 while (*p && nasm_isspace(*p))
671 /* skip leading non-spaces */
672 char *nasm_skip_word(const char *p)
675 while (*p && !nasm_isspace(*p))
680 /* zap leading spaces with zero */
681 char *nasm_zap_spaces_fwd(char *p)
684 while (*p && nasm_isspace(*p))
689 /* zap spaces with zero in reverse order */
690 char *nasm_zap_spaces_rev(char *p)
693 while (*p && nasm_isspace(*p))
698 /* zap leading and trailing spaces */
699 char *nasm_trim_spaces(char *p)
701 p = nasm_zap_spaces_fwd(p);
702 nasm_zap_spaces_fwd(nasm_skip_word(p));
708 * return the word extracted from a stream
709 * or NULL if nothing left
711 char *nasm_get_word(char *p, char **tail)
713 char *word = nasm_skip_spaces(p);
714 char *next = nasm_skip_word(word);
722 /* NOTE: the tail may start with spaces */
729 * Extract "opt=val" values from the stream and
733 * 1) If "=val" passed the NULL returned though
734 * you may continue handling the tail via "next"
735 * 2) If "=" passed the NULL is returned and "val"
736 * is set to NULL as well
738 char *nasm_opt_val(char *p, char **val, char **next)
742 opt = *val = *next = NULL;
744 p = nasm_get_word(p, &nxt);
756 q = nasm_get_word(q + 1, &nxt);
761 q = nasm_skip_spaces(nxt);
762 if (q && *q == '=') {
763 q = nasm_get_word(q + 1, &nxt);
774 * initialized data bytes length from opcode
776 int idata_bytes(int opcode)