1 /* nasmlib.c library routines for the Netwide Assembler
3 * The Netwide Assembler is copyright (C) 1996 Simon Tatham and
4 * Julian Hall. All rights reserved. The software is
5 * redistributable under the licence given in the file "Licence"
6 * distributed in the NASM archive.
21 int globalbits = 0; /* defined in nasm.h, works better here for ASM+DISASM */
22 efunc nasm_malloc_error; /* Exported for the benefit of vsnprintf.c */
28 void nasm_set_malloc_error(efunc error)
30 nasm_malloc_error = error;
32 logfp = fopen("malloc.log", "w");
33 setvbuf(logfp, NULL, _IOLBF, BUFSIZ);
34 fprintf(logfp, "null pointer is %p\n", NULL);
39 void *nasm_malloc_log(char *file, int line, size_t size)
41 void *nasm_malloc(size_t size)
44 void *p = malloc(size);
46 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
49 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
50 file, line, (long)size, p);
56 void *nasm_zalloc_log(char *file, int line, size_t size)
58 void *nasm_zalloc(size_t size)
61 void *p = calloc(size, 1);
63 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
66 fprintf(logfp, "%s %d calloc(%ld, 1) returns %p\n",
67 file, line, (long)size, p);
73 void *nasm_realloc_log(char *file, int line, void *q, size_t size)
75 void *nasm_realloc(void *q, size_t size)
78 void *p = q ? realloc(q, size) : malloc(size);
80 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
83 fprintf(logfp, "%s %d realloc(%p,%ld) returns %p\n",
84 file, line, q, (long)size, p);
86 fprintf(logfp, "%s %d malloc(%ld) returns %p\n",
87 file, line, (long)size, p);
93 void nasm_free_log(char *file, int line, void *q)
95 void nasm_free(void *q)
101 fprintf(logfp, "%s %d free(%p)\n", file, line, q);
107 char *nasm_strdup_log(char *file, int line, const char *s)
109 char *nasm_strdup(const char *s)
113 int size = strlen(s) + 1;
117 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
120 fprintf(logfp, "%s %d strdup(%ld) returns %p\n",
121 file, line, (long)size, p);
128 char *nasm_strndup_log(char *file, int line, char *s, size_t len)
130 char *nasm_strndup(char *s, size_t len)
138 nasm_malloc_error(ERR_FATAL | ERR_NOFILE, "out of memory");
141 fprintf(logfp, "%s %d strndup(%ld) returns %p\n",
142 file, line, (long)size, p);
150 int nasm_stricmp(const char *s1, const char *s2)
152 while (*s1 && tolower(*s1) == tolower(*s2))
156 else if (tolower(*s1) < tolower(*s2))
163 #ifndef nasm_strnicmp
164 int nasm_strnicmp(const char *s1, const char *s2, int n)
166 while (n > 0 && *s1 && tolower(*s1) == tolower(*s2))
168 if ((!*s1 && !*s2) || n == 0)
170 else if (tolower(*s1) < tolower(*s2))
178 char *nasm_strsep(char **stringp, const char *delim)
186 e = strpbrk(s, delim);
196 #define lib_isnumchar(c) ( isalnum(c) || (c) == '$')
197 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
199 int64_t readnum(char *str, int *error)
203 uint64_t result, checklimit;
211 r++; /* find start of number */
214 * If the number came from make_tok_num (as a result of an %assign), it
215 * might have a '-' built into it (rather than in a preceeding token).
224 while (lib_isnumchar(*q))
225 q++; /* find end of number */
228 * If it begins 0x, 0X or $, or ends in H, it's in hex. if it
229 * ends in Q, it's octal. if it ends in B, it's binary.
230 * Otherwise, it's ordinary decimal.
232 if (*r == '0' && (r[1] == 'x' || r[1] == 'X'))
236 else if (q[-1] == 'H' || q[-1] == 'h')
238 else if (q[-1] == 'Q' || q[-1] == 'q' || q[-1] == 'O' || q[-1] == 'o')
240 else if (q[-1] == 'B' || q[-1] == 'b')
246 * If this number has been found for us by something other than
247 * the ordinary scanners, then it might be malformed by having
248 * nothing between the prefix and the suffix. Check this case
257 * `checklimit' must be 2**(32|64) / radix. We can't do that in
258 * 32/64-bit arithmetic, which we're (probably) using, so we
259 * cheat: since we know that all radices we use are even, we
260 * can divide 2**(31|63) by radix/2 instead.
262 if (globalbits == 64)
263 checklimit = 0x8000000000000000ULL / (radix >> 1);
265 checklimit = 0x80000000UL / (radix >> 1);
268 * Calculate the highest allowable value for the last digit of a
269 * 32-bit constant... in radix 10, it is 6, otherwise it is 0
271 last = (radix == 10 ? 6 : 0);
274 while (*r && r < q) {
275 if (*r < '0' || (*r > '9' && *r < 'A')
276 || (digit = numvalue(*r)) >= radix) {
280 if (result > checklimit || (result == checklimit && digit >= last)) {
284 result = radix * result + digit;
289 nasm_malloc_error(ERR_WARNING | ERR_PASS1 | ERR_WARN_NOV,
290 "numeric constant %s does not fit in 32 bits",
293 return result * sign;
296 int64_t readstrnum(char *str, int length, int *warn)
298 int64_t charconst = 0;
304 if (globalbits == 64) {
305 for (i = 0; i < length; i++) {
306 if (charconst & 0xFF00000000000000ULL)
308 charconst = (charconst << 8) + (uint8_t)*--str;
311 for (i = 0; i < length; i++) {
312 if (charconst & 0xFF000000UL)
314 charconst = (charconst << 8) + (uint8_t)*--str;
320 static int32_t next_seg;
327 int32_t seg_alloc(void)
329 return (next_seg += 2) - 2;
332 void fwriteint16_t(int data, FILE * fp)
334 fputc((int)(data & 255), fp);
335 fputc((int)((data >> 8) & 255), fp);
338 void fwriteint32_t(int32_t data, FILE * fp)
340 fputc((int)(data & 255), fp);
341 fputc((int)((data >> 8) & 255), fp);
342 fputc((int)((data >> 16) & 255), fp);
343 fputc((int)((data >> 24) & 255), fp);
346 void fwriteint64_t(int64_t data, FILE * fp)
348 fputc((int)(data & 255), fp);
349 fputc((int)((data >> 8) & 255), fp);
350 fputc((int)((data >> 16) & 255), fp);
351 fputc((int)((data >> 24) & 255), fp);
352 fputc((int)((data >> 32) & 255), fp);
353 fputc((int)((data >> 40) & 255), fp);
354 fputc((int)((data >> 48) & 255), fp);
355 fputc((int)((data >> 56) & 255), fp);
358 void standard_extension(char *inname, char *outname, char *extension,
363 if (*outname) /* file name already exists, */
364 return; /* so do nothing */
368 *p++ = *q++; /* copy, and find end of string */
369 *p = '\0'; /* terminate it */
370 while (p > outname && *--p != '.') ; /* find final period (or whatever) */
373 p++; /* go back to end if none found */
374 if (!strcmp(p, extension)) { /* is the extension already there? */
376 error(ERR_WARNING | ERR_NOFILE,
377 "file name already ends in `%s': "
378 "output will be in `nasm.out'", extension);
380 error(ERR_WARNING | ERR_NOFILE,
381 "file name already has no extension: "
382 "output will be in `nasm.out'");
383 strcpy(outname, "nasm.out");
385 strcpy(p, extension);
388 #define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
389 #define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
391 #define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE )
393 static struct RAA *real_raa_init(int layers)
399 r = nasm_zalloc(LEAFSIZ);
402 r = nasm_malloc(BRANCHSIZ);
404 for (i = 0; i < RAA_LAYERSIZE; i++)
405 r->u.b.data[i] = NULL;
406 r->stepsize = RAA_BLKSIZE;
408 r->stepsize *= RAA_LAYERSIZE;
413 struct RAA *raa_init(void)
415 return real_raa_init(0);
418 void raa_free(struct RAA *r)
424 for (p = r->u.b.data; p - r->u.b.data < RAA_LAYERSIZE; p++)
430 int32_t raa_read(struct RAA *r, int32_t posn)
432 if (posn >= r->stepsize * LAYERSIZ(r))
433 return 0; /* Return 0 for undefined entries */
434 while (r->layers > 0) {
436 l = ldiv(posn, r->stepsize);
437 r = r->u.b.data[l.quot];
440 return 0; /* Return 0 for undefined entries */
442 return r->u.l.data[posn];
445 struct RAA *raa_write(struct RAA *r, int32_t posn, int32_t value)
450 nasm_malloc_error(ERR_PANIC, "negative position in raa_write");
452 while (r->stepsize * LAYERSIZ(r) <= posn) {
459 s = nasm_malloc(BRANCHSIZ);
460 for (i = 0; i < RAA_LAYERSIZE; i++)
461 s->u.b.data[i] = NULL;
462 s->layers = r->layers + 1;
463 s->stepsize = LAYERSIZ(r) * r->stepsize;
470 while (r->layers > 0) {
473 l = ldiv(posn, r->stepsize);
474 s = &r->u.b.data[l.quot];
476 *s = real_raa_init(r->layers - 1);
481 r->u.l.data[posn] = value;
486 /* Aggregate SAA components smaller than this */
487 #define SAA_BLKLEN 65536
489 struct SAA *saa_init(size_t elem_len)
494 s = nasm_zalloc(sizeof(struct SAA));
496 if (elem_len >= SAA_BLKLEN)
497 s->blk_len = elem_len;
499 s->blk_len = SAA_BLKLEN - (SAA_BLKLEN % elem_len);
501 s->elem_len = elem_len;
502 s->length = s->blk_len;
503 data = nasm_malloc(s->blk_len);
504 s->nblkptrs = s->nblks = 1;
505 s->blk_ptrs = nasm_malloc(sizeof(char *));
506 s->blk_ptrs[0] = data;
507 s->wblk = s->rblk = &s->blk_ptrs[0];
512 void saa_free(struct SAA *s)
517 for (p = s->blk_ptrs, n = s->nblks; n; p++, n--)
520 nasm_free(s->blk_ptrs);
524 /* Add one allocation block to an SAA */
525 static void saa_extend(struct SAA *s)
527 size_t blkn = s->nblks++;
529 if (blkn >= s->nblkptrs) {
530 size_t rindex = s->rblk - s->blk_ptrs;
531 size_t windex = s->wblk - s->blk_ptrs;
534 s->blk_ptrs = nasm_realloc(s->blk_ptrs, s->nblkptrs*sizeof(char *));
536 s->rblk = s->blk_ptrs + rindex;
537 s->wblk = s->blk_ptrs + windex;
540 s->blk_ptrs[blkn] = nasm_malloc(s->blk_len);
541 s->length += s->blk_len;
544 void *saa_wstruct(struct SAA *s)
548 if (s->wpos % s->elem_len)
549 nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
550 "misaligned wpos in saa_wstruct");
552 if (s->wpos + s->elem_len > s->blk_len) {
553 if (s->wpos != s->blk_len)
554 nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
555 "unfilled block in saa_wstruct");
557 if (s->wptr + s->elem_len > s->length)
563 p = *s->wblk + s->wpos;
564 s->wpos += s->elem_len;
565 s->wptr += s->elem_len;
567 if (s->wptr > s->datalen)
568 s->datalen = s->wptr;
573 void saa_wbytes(struct SAA *s, const void *data, size_t len)
575 const char *d = data;
578 size_t l = s->blk_len - s->wpos;
583 memcpy(*s->wblk + s->wpos, d, l);
586 memset(*s->wblk + s->wpos, 0, l);
591 if (s->datalen < s->wptr)
592 s->datalen = s->wptr;
595 if (s->wptr >= s->length)
603 void saa_rewind(struct SAA *s)
605 s->rblk = s->blk_ptrs;
606 s->rpos = s->rptr = 0;
609 void *saa_rstruct(struct SAA *s)
613 if (s->rptr + s->elem_len < s->datalen)
616 if (s->rpos % s->elem_len)
617 nasm_malloc_error(ERR_PANIC|ERR_NOFILE,
618 "misaligned rpos in saa_rstruct");
620 if (s->rpos + s->elem_len > s->blk_len) {
625 p = *s->rblk + s->rpos;
626 s->rpos += s->elem_len;
627 s->rptr += s->elem_len;
632 const void *saa_rbytes(struct SAA *s, size_t *lenp)
637 if (s->rptr >= s->datalen) {
642 if (s->rpos >= s->blk_len) {
648 if (len > s->datalen - s->rptr)
649 len = s->datalen - s->rptr;
650 if (len > s->blk_len - s->rpos)
651 len = s->blk_len - s->rpos;
654 p = *s->rblk + s->rpos;
662 void saa_rnbytes(struct SAA *s, void *data, size_t len)
666 if (s->rptr + len > s->datalen) {
667 nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_rnbytes");
676 p = saa_rbytes(s, &l);
684 /* Same as saa_rnbytes, except position the counter first */
685 void saa_fread(struct SAA *s, size_t posn, void *data, size_t len)
689 if (posn+len > s->datalen) {
690 nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_fread");
694 ix = posn / s->blk_len;
695 s->rpos = posn % s->blk_len;
696 s->rblk = &s->blk_ptrs[ix];
698 saa_rnbytes(s, data, len);
701 /* Same as saa_wbytes, except position the counter first */
702 void saa_fwrite(struct SAA *s, size_t posn, const void *data, size_t len)
706 if (posn > s->datalen) {
707 /* Seek beyond the end of the existing array not supported */
708 nasm_malloc_error(ERR_PANIC|ERR_NOFILE, "overrun in saa_fwrite");
712 ix = posn / s->blk_len;
713 s->wpos = posn % s->blk_len;
714 s->wblk = &s->blk_ptrs[ix];
717 s->wpos = s->blk_len;
721 saa_wbytes(s, data, len);
724 void saa_fpwrite(struct SAA *s, FILE * fp)
731 while ((data = saa_rbytes(s, &len)) != NULL)
732 fwrite(data, 1, len, fp);
736 * Common list of prefix names
738 static const char *prefix_names[] = {
739 "a16", "a32", "lock", "o16", "o32", "rep", "repe", "repne",
740 "repnz", "repz", "times"
743 const char *prefix_name(int token)
745 unsigned int prefix = token-PREFIX_ENUM_START;
746 if (prefix > sizeof prefix_names / sizeof(const char *))
749 return prefix_names[prefix];
755 int bsi(char *string, const char **array, int size)
757 int i = -1, j = size; /* always, i < index < j */
760 int l = strcmp(string, array[k]);
761 if (l < 0) /* it's in the first half */
763 else if (l > 0) /* it's in the second half */
765 else /* we've got it :) */
768 return -1; /* we haven't got it :( */
771 int bsii(char *string, const char **array, int size)
773 int i = -1, j = size; /* always, i < index < j */
776 int l = nasm_stricmp(string, array[k]);
777 if (l < 0) /* it's in the first half */
779 else if (l > 0) /* it's in the second half */
781 else /* we've got it :) */
784 return -1; /* we haven't got it :( */
787 static char *file_name = NULL;
788 static int32_t line_number = 0;
790 char *src_set_fname(char *newname)
792 char *oldname = file_name;
797 int32_t src_set_linnum(int32_t newline)
799 int32_t oldline = line_number;
800 line_number = newline;
804 int32_t src_get_linnum(void)
809 int src_get(int32_t *xline, char **xname)
811 if (!file_name || !*xname || strcmp(*xname, file_name)) {
813 *xname = file_name ? nasm_strdup(file_name) : NULL;
814 *xline = line_number;
817 if (*xline != line_number) {
818 int32_t tmp = line_number - *xline;
819 *xline = line_number;
825 void nasm_quote(char **str)
827 int ln = strlen(*str);
830 if (ln > 1 && (*str)[ln - 1] == q && (q == '"' || q == '\''))
835 p = nasm_malloc(ln + 3);
838 p[ln + 1] = p[0] = q;
843 char *nasm_strcat(char *one, char *two)
846 int l1 = strlen(one);
847 rslt = nasm_malloc(l1 + strlen(two) + 1);
849 strcpy(rslt + l1, two);
853 void null_debug_init(struct ofmt *of, void *id, FILE * fp, efunc error)
860 void null_debug_linenum(const char *filename, int32_t linenumber, int32_t segto)
866 void null_debug_deflabel(char *name, int32_t segment, int32_t offset,
867 int is_global, char *special)
875 void null_debug_routine(const char *directive, const char *params)
880 void null_debug_typevalue(int32_t type)
884 void null_debug_output(int type, void *param)
889 void null_debug_cleanup(void)
893 struct dfmt null_debug_form = {
900 null_debug_typevalue,
905 struct dfmt *null_debug_arr[2] = { &null_debug_form, NULL };