1 /* ----------------------------------------------------------------------- *
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.
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
14 * Patches submitted to this file are required to be dual licensed
15 * under the LGPL 2.1+ and the 2-clause BSD license:
17 * Copyright 1996-2009 the NASM Authors - All rights reserved.
19 * Redistribution and use in source and binary forms, with or without
20 * modification, are permitted provided that the following
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.
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.
44 * ----------------------------------------------------------------------- */
47 * nasmlib.c library routines for the Netwide Assembler
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 */
69 /* Uninitialized -> all zero by C spec */
70 const uint8_t zero_buffer[ZERO_BUF_SIZE];
73 * Prepare a table of tolower() results. This avoids function calls
77 unsigned char nasm_tolower_tab[256];
79 void tolower_init(void)
83 for (i = 0; i < 256; i++)
84 nasm_tolower_tab[i] = tolower(i);
87 void nasm_set_malloc_error(efunc error)
89 nasm_malloc_error = error;
91 logfp = fopen("malloc.log", "w");
92 setvbuf(logfp, NULL, _IOLBF, BUFSIZ);
93 fprintf(logfp, "null pointer is %p\n", NULL);
98 void *nasm_malloc_log(const char *file, int line, size_t size)
100 void *nasm_malloc(size_t size)
103 void *p = malloc(size);
105 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
108 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
109 file, line, (long)size, p);
115 void *nasm_zalloc_log(const char *file, int line, size_t size)
117 void *nasm_zalloc(size_t size)
120 void *p = calloc(size, 1);
122 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
125 fprintf(logfp, "%s %d calloc(%ld, 1) returns %p\n",
126 file, line, (long)size, p);
132 void *nasm_realloc_log(const char *file, int line, void *q, size_t size)
134 void *nasm_realloc(void *q, size_t size)
137 void *p = q ? realloc(q, size) : malloc(size);
139 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
142 fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
143 file, line, q, (long)size, p);
145 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
146 file, line, (long)size, p);
152 void nasm_free_log(const char *file, int line, void *q)
154 void nasm_free(void *q)
159 fprintf(logfp, "%s %d free(%p)\n", file, line, q);
166 char *nasm_strdup_log(const char *file, int line, const char *s)
168 char *nasm_strdup(const char *s)
172 int size = strlen(s) + 1;
176 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
179 fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
180 file, line, (long)size, p);
187 char *nasm_strndup_log(const char *file, int line, const char *s, size_t len)
189 char *nasm_strndup(const char *s, size_t len)
197 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
200 fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
201 file, line, (long)size, p);
208 no_return nasm_assert_failed(const char *file, int line, const char *msg)
210 nasm_malloc_error(ERR_FATAL, "assertion %s failed at %s:%d",
216 int nasm_stricmp(const char *s1, const char *s2)
218 unsigned char c1, c2;
222 c1 = nasm_tolower(*s1++);
223 c2 = nasm_tolower(*s2++);
235 #ifndef nasm_strnicmp
236 int nasm_strnicmp(const char *s1, const char *s2, size_t n)
238 unsigned char c1, c2;
242 c1 = nasm_tolower(*s1++);
243 c2 = nasm_tolower(*s2++);
255 int nasm_memicmp(const char *s1, const char *s2, size_t n)
257 unsigned char c1, c2;
261 c1 = nasm_tolower(*s1++);
262 c2 = nasm_tolower(*s2++);
271 char *nasm_strsep(char **stringp, const char *delim)
279 e = strpbrk(s, delim);
289 #define lib_isnumchar(c) (nasm_isalnum(c) || (c) == '$' || (c) == '_')
290 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
292 static int radix_letter(char c)
297 return 2; /* Binary */
300 return 8; /* Octal */
303 return 16; /* Hexadecimal */
306 return 10; /* Decimal */
308 return 0; /* Not a known radix letter */
312 int64_t readnum(char *str, bool *error)
315 int32_t pradix, sradix, radix;
317 uint64_t result, checklimit;
324 while (nasm_isspace(*r))
325 r++; /* find start of number */
328 * If the number came from make_tok_num (as a result of an %assign), it
329 * might have a '-' built into it (rather than in a preceeding token).
338 while (lib_isnumchar(*q))
339 q++; /* find end of number */
349 * Handle radix formats:
351 * 0<radix-letter><string>
352 * $<string> (hexadecimal)
353 * <string><radix-letter>
358 if (len > 2 && *r == '0' && (pradix = radix_letter(r[1])) != 0)
360 else if (len > 1 && *r == '$')
361 pradix = 16, plen = 1;
363 if (len > 1 && (sradix = radix_letter(q[-1])) != 0)
366 if (pradix > sradix) {
369 } else if (sradix > pradix) {
373 /* Either decimal, or invalid -- if invalid, we'll trip up
379 * `checklimit' must be 2**64 / radix. We can't do that in
380 * 64-bit arithmetic, which we're (probably) using, so we
381 * cheat: since we know that all radices we use are even, we
382 * can divide 2**63 by radix/2 instead.
384 checklimit = 0x8000000000000000ULL / (radix >> 1);
387 * Calculate the highest allowable value for the last digit of a
388 * 64-bit constant... in radix 10, it is 6, otherwise it is 0
390 last = (radix == 10 ? 6 : 0);
393 while (*r && r < q) {
395 if (*r < '0' || (*r > '9' && *r < 'A')
396 || (digit = numvalue(*r)) >= radix) {
400 if (result > checklimit ||
401 (result == checklimit && digit >= last)) {
405 result = radix * result + digit;
411 nasm_malloc_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
412 "numeric constant %s does not fit in 64 bits",
415 return result * sign;
418 int64_t readstrnum(char *str, int length, bool *warn)
420 int64_t charconst = 0;
426 if (globalbits == 64) {
427 for (i = 0; i < length; i++) {
428 if (charconst & 0xFF00000000000000ULL)
430 charconst = (charconst << 8) + (uint8_t)*--str;
433 for (i = 0; i < length; i++) {
434 if (charconst & 0xFF000000UL)
436 charconst = (charconst << 8) + (uint8_t)*--str;
442 static int32_t next_seg;
449 int32_t seg_alloc(void)
451 return (next_seg += 2) - 2;
454 #ifdef WORDS_LITTLEENDIAN
456 void fwriteint16_t(uint16_t data, FILE * fp)
458 fwrite(&data, 1, 2, fp);
461 void fwriteint32_t(uint32_t data, FILE * fp)
463 fwrite(&data, 1, 4, fp);
466 void fwriteint64_t(uint64_t data, FILE * fp)
468 fwrite(&data, 1, 8, fp);
471 void fwriteaddr(uint64_t data, int size, FILE * fp)
473 fwrite(&data, 1, size, fp);
476 #else /* not WORDS_LITTLEENDIAN */
478 void fwriteint16_t(uint16_t data, FILE * fp)
480 char buffer[2], *p = buffer;
482 fwrite(buffer, 1, 2, fp);
485 void fwriteint32_t(uint32_t data, FILE * fp)
487 char buffer[4], *p = buffer;
489 fwrite(buffer, 1, 4, fp);
492 void fwriteint64_t(uint64_t data, FILE * fp)
494 char buffer[8], *p = buffer;
496 fwrite(buffer, 1, 8, fp);
499 void fwriteaddr(uint64_t data, int size, FILE * fp)
501 char buffer[8], *p = buffer;
502 WRITEADDR(p, data, size);
503 fwrite(buffer, 1, size, fp);
508 size_t fwritezero(size_t bytes, FILE *fp)
515 blksize = (bytes < ZERO_BUF_SIZE) ? bytes : ZERO_BUF_SIZE;
517 rv = fwrite(zero_buffer, 1, blksize, fp);
528 void standard_extension(char *inname, char *outname, char *extension,
533 if (*outname) /* file name already exists, */
534 return; /* so do nothing */
538 *p++ = *q++; /* copy, and find end of string */
539 *p = '\0'; /* terminate it */
540 while (p > outname && *--p != '.') ; /* find final period (or whatever) */
543 p++; /* go back to end if none found */
544 if (!strcmp(p, extension)) { /* is the extension already there? */
546 error(ERR_WARNING | ERR_NOFILE,
547 "file name already ends in `%s': "
548 "output will be in `nasm.out'", extension);
550 error(ERR_WARNING | ERR_NOFILE,
551 "file name already has no extension: "
552 "output will be in `nasm.out'");
553 strcpy(outname, "nasm.out");
555 strcpy(p, extension);
559 * Common list of prefix names
561 static const char *prefix_names[] = {
562 "a16", "a32", "a64", "asp", "lock", "o16", "o32", "o64", "osp",
563 "rep", "repe", "repne", "repnz", "repz", "times", "wait"
566 const char *prefix_name(int token)
568 unsigned int prefix = token-PREFIX_ENUM_START;
569 if (prefix > elements(prefix_names))
572 return prefix_names[prefix];
578 int bsi(const char *string, const char **array, int size)
580 int i = -1, j = size; /* always, i < index < j */
583 int l = strcmp(string, array[k]);
584 if (l < 0) /* it's in the first half */
586 else if (l > 0) /* it's in the second half */
588 else /* we've got it :) */
591 return -1; /* we haven't got it :( */
594 int bsii(const char *string, const char **array, int size)
596 int i = -1, j = size; /* always, i < index < j */
599 int l = nasm_stricmp(string, array[k]);
600 if (l < 0) /* it's in the first half */
602 else if (l > 0) /* it's in the second half */
604 else /* we've got it :) */
607 return -1; /* we haven't got it :( */
610 static char *file_name = NULL;
611 static int32_t line_number = 0;
613 char *src_set_fname(char *newname)
615 char *oldname = file_name;
620 int32_t src_set_linnum(int32_t newline)
622 int32_t oldline = line_number;
623 line_number = newline;
627 int32_t src_get_linnum(void)
632 int src_get(int32_t *xline, char **xname)
634 if (!file_name || !*xname || strcmp(*xname, file_name)) {
636 *xname = file_name ? nasm_strdup(file_name) : NULL;
637 *xline = line_number;
640 if (*xline != line_number) {
641 int32_t tmp = line_number - *xline;
642 *xline = line_number;
648 char *nasm_strcat(const char *one, const char *two)
651 int l1 = strlen(one);
652 rslt = nasm_malloc(l1 + strlen(two) + 1);
654 strcpy(rslt + l1, two);