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) == '$' || (c) == '_')
197 #define numvalue(c) ((c)>='a' ? (c)-'a'+10 : (c)>='A' ? (c)-'A'+10 : (c)-'0')
199 static int radix_letter(char c
)
204 return 2; /* Binary */
207 return 8; /* Octal */
210 return 16; /* Hexadecimal */
213 return 10; /* Decimal */
215 return 0; /* Not a known radix letter */
219 int64_t readnum(char *str
, bool *error
)
222 int32_t pradix
, sradix
, radix
;
224 uint64_t result
, checklimit
;
232 r
++; /* find start of number */
235 * If the number came from make_tok_num (as a result of an %assign), it
236 * might have a '-' built into it (rather than in a preceeding token).
245 while (lib_isnumchar(*q
))
246 q
++; /* find end of number */
256 * Handle radix formats:
258 * 0<radix-letter><string>
259 * $<string> (hexadecimal)
260 * <string><radix-letter>
265 if (len
> 2 && *r
== '0' && (pradix
= radix_letter(r
[1])) != 0)
267 else if (len
> 1 && *r
== '$')
268 pradix
= 16, plen
= 1;
270 if (len
> 1 && (sradix
= radix_letter(q
[-1])) != 0)
273 if (pradix
> sradix
) {
276 } else if (sradix
> pradix
) {
280 /* Either decimal, or invalid -- if invalid, we'll trip up
286 * `checklimit' must be 2**(32|64) / radix. We can't do that in
287 * 32/64-bit arithmetic, which we're (probably) using, so we
288 * cheat: since we know that all radices we use are even, we
289 * can divide 2**(31|63) by radix/2 instead.
291 if (globalbits
== 64)
292 checklimit
= 0x8000000000000000ULL
/ (radix
>> 1);
294 checklimit
= 0x80000000UL
/ (radix
>> 1);
297 * Calculate the highest allowable value for the last digit of a
298 * 32-bit constant... in radix 10, it is 6, otherwise it is 0
300 last
= (radix
== 10 ? 6 : 0);
303 while (*r
&& r
< q
) {
305 if (*r
< '0' || (*r
> '9' && *r
< 'A')
306 || (digit
= numvalue(*r
)) >= radix
) {
310 if (result
> checklimit
||
311 (result
== checklimit
&& digit
>= last
)) {
315 result
= radix
* result
+ digit
;
321 nasm_malloc_error(ERR_WARNING
| ERR_PASS1
| ERR_WARN_NOV
,
322 "numeric constant %s does not fit in 32 bits",
325 return result
* sign
;
328 int64_t readstrnum(char *str
, int length
, bool *warn
)
330 int64_t charconst
= 0;
336 if (globalbits
== 64) {
337 for (i
= 0; i
< length
; i
++) {
338 if (charconst
& 0xFF00000000000000ULL
)
340 charconst
= (charconst
<< 8) + (uint8_t)*--str
;
343 for (i
= 0; i
< length
; i
++) {
344 if (charconst
& 0xFF000000UL
)
346 charconst
= (charconst
<< 8) + (uint8_t)*--str
;
352 static int32_t next_seg
;
359 int32_t seg_alloc(void)
361 return (next_seg
+= 2) - 2;
366 void fwriteint16_t(int data
, FILE * fp
)
369 fwrite(&d
, 1, 2, fp
);
372 void fwriteint32_t(int32_t data
, FILE * fp
)
375 fwrite(&d
, 1, 4, fp
);
378 void fwriteint64_t(int64_t data
, FILE * fp
)
381 fwrite(&d
, 1, 8, fp
);
384 void fwriteaddr(int64_t data
, int size
, FILE * fp
)
387 fwrite(&d
, 1, size
, fp
);
390 #else /* !X86_MEMORY */
392 void fwriteint16_t(int data
, FILE * fp
)
394 char buffer
[2], *p
= buffer
;
396 fwrite(buffer
, 1, 2, fp
);
399 void fwriteint32_t(int32_t data
, FILE * fp
)
401 char buffer
[4], *p
= buffer
;
403 fwrite(buffer
, 1, 4, fp
);
406 void fwriteint64_t(int64_t data
, FILE * fp
)
408 char buffer
[8], *p
= buffer
;
410 fwrite(buffer
, 1, 8, fp
);
413 void fwriteaddr(int64_t data
, int size
, FILE * fp
)
415 char buffer
[8], *p
= buffer
;
416 WRITEADDR(p
, data
, size
);
417 fwrite(buffer
, 1, size
, fp
);
422 void standard_extension(char *inname
, char *outname
, char *extension
,
427 if (*outname
) /* file name already exists, */
428 return; /* so do nothing */
432 *p
++ = *q
++; /* copy, and find end of string */
433 *p
= '\0'; /* terminate it */
434 while (p
> outname
&& *--p
!= '.') ; /* find final period (or whatever) */
437 p
++; /* go back to end if none found */
438 if (!strcmp(p
, extension
)) { /* is the extension already there? */
440 error(ERR_WARNING
| ERR_NOFILE
,
441 "file name already ends in `%s': "
442 "output will be in `nasm.out'", extension
);
444 error(ERR_WARNING
| ERR_NOFILE
,
445 "file name already has no extension: "
446 "output will be in `nasm.out'");
447 strcpy(outname
, "nasm.out");
449 strcpy(p
, extension
);
452 #define LEAFSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_LEAF))
453 #define BRANCHSIZ (sizeof(RAA)-sizeof(RAA_UNION)+sizeof(RAA_BRANCH))
455 #define LAYERSIZ(r) ( (r)->layers==0 ? RAA_BLKSIZE : RAA_LAYERSIZE )
457 static struct RAA
*real_raa_init(int layers
)
463 r
= nasm_zalloc(LEAFSIZ
);
466 r
= nasm_malloc(BRANCHSIZ
);
468 for (i
= 0; i
< RAA_LAYERSIZE
; i
++)
469 r
->u
.b
.data
[i
] = NULL
;
470 r
->stepsize
= RAA_BLKSIZE
;
472 r
->stepsize
*= RAA_LAYERSIZE
;
477 struct RAA
*raa_init(void)
479 return real_raa_init(0);
482 void raa_free(struct RAA
*r
)
488 for (p
= r
->u
.b
.data
; p
- r
->u
.b
.data
< RAA_LAYERSIZE
; p
++)
494 int64_t raa_read(struct RAA
*r
, int32_t posn
)
496 if (posn
>= r
->stepsize
* LAYERSIZ(r
))
497 return 0; /* Return 0 for undefined entries */
498 while (r
->layers
> 0) {
500 l
= ldiv(posn
, r
->stepsize
);
501 r
= r
->u
.b
.data
[l
.quot
];
504 return 0; /* Return 0 for undefined entries */
506 return r
->u
.l
.data
[posn
];
509 struct RAA
*raa_write(struct RAA
*r
, int32_t posn
, int64_t value
)
514 nasm_malloc_error(ERR_PANIC
, "negative position in raa_write");
516 while (r
->stepsize
* LAYERSIZ(r
) <= posn
) {
523 s
= nasm_malloc(BRANCHSIZ
);
524 for (i
= 0; i
< RAA_LAYERSIZE
; i
++)
525 s
->u
.b
.data
[i
] = NULL
;
526 s
->layers
= r
->layers
+ 1;
527 s
->stepsize
= LAYERSIZ(r
) * r
->stepsize
;
534 while (r
->layers
> 0) {
537 l
= ldiv(posn
, r
->stepsize
);
538 s
= &r
->u
.b
.data
[l
.quot
];
540 *s
= real_raa_init(r
->layers
- 1);
545 r
->u
.l
.data
[posn
] = value
;
550 /* Aggregate SAA components smaller than this */
551 #define SAA_BLKLEN 65536
553 struct SAA
*saa_init(size_t elem_len
)
558 s
= nasm_zalloc(sizeof(struct SAA
));
560 if (elem_len
>= SAA_BLKLEN
)
561 s
->blk_len
= elem_len
;
563 s
->blk_len
= SAA_BLKLEN
- (SAA_BLKLEN
% elem_len
);
565 s
->elem_len
= elem_len
;
566 s
->length
= s
->blk_len
;
567 data
= nasm_malloc(s
->blk_len
);
568 s
->nblkptrs
= s
->nblks
= 1;
569 s
->blk_ptrs
= nasm_malloc(sizeof(char *));
570 s
->blk_ptrs
[0] = data
;
571 s
->wblk
= s
->rblk
= &s
->blk_ptrs
[0];
576 void saa_free(struct SAA
*s
)
581 for (p
= s
->blk_ptrs
, n
= s
->nblks
; n
; p
++, n
--)
584 nasm_free(s
->blk_ptrs
);
588 /* Add one allocation block to an SAA */
589 static void saa_extend(struct SAA
*s
)
591 size_t blkn
= s
->nblks
++;
593 if (blkn
>= s
->nblkptrs
) {
594 size_t rindex
= s
->rblk
- s
->blk_ptrs
;
595 size_t windex
= s
->wblk
- s
->blk_ptrs
;
598 s
->blk_ptrs
= nasm_realloc(s
->blk_ptrs
, s
->nblkptrs
*sizeof(char *));
600 s
->rblk
= s
->blk_ptrs
+ rindex
;
601 s
->wblk
= s
->blk_ptrs
+ windex
;
604 s
->blk_ptrs
[blkn
] = nasm_malloc(s
->blk_len
);
605 s
->length
+= s
->blk_len
;
608 void *saa_wstruct(struct SAA
*s
)
612 if (s
->wpos
% s
->elem_len
)
613 nasm_malloc_error(ERR_PANIC
|ERR_NOFILE
,
614 "misaligned wpos in saa_wstruct");
616 if (s
->wpos
+ s
->elem_len
> s
->blk_len
) {
617 if (s
->wpos
!= s
->blk_len
)
618 nasm_malloc_error(ERR_PANIC
|ERR_NOFILE
,
619 "unfilled block in saa_wstruct");
621 if (s
->wptr
+ s
->elem_len
> s
->length
)
627 p
= *s
->wblk
+ s
->wpos
;
628 s
->wpos
+= s
->elem_len
;
629 s
->wptr
+= s
->elem_len
;
631 if (s
->wptr
> s
->datalen
)
632 s
->datalen
= s
->wptr
;
637 void saa_wbytes(struct SAA
*s
, const void *data
, size_t len
)
639 const char *d
= data
;
642 size_t l
= s
->blk_len
- s
->wpos
;
647 memcpy(*s
->wblk
+ s
->wpos
, d
, l
);
650 memset(*s
->wblk
+ s
->wpos
, 0, l
);
655 if (s
->datalen
< s
->wptr
)
656 s
->datalen
= s
->wptr
;
659 if (s
->wptr
>= s
->length
)
667 void saa_rewind(struct SAA
*s
)
669 s
->rblk
= s
->blk_ptrs
;
670 s
->rpos
= s
->rptr
= 0;
673 void *saa_rstruct(struct SAA
*s
)
677 if (s
->rptr
+ s
->elem_len
> s
->datalen
)
680 if (s
->rpos
% s
->elem_len
)
681 nasm_malloc_error(ERR_PANIC
|ERR_NOFILE
,
682 "misaligned rpos in saa_rstruct");
684 if (s
->rpos
+ s
->elem_len
> s
->blk_len
) {
689 p
= *s
->rblk
+ s
->rpos
;
690 s
->rpos
+= s
->elem_len
;
691 s
->rptr
+= s
->elem_len
;
696 const void *saa_rbytes(struct SAA
*s
, size_t *lenp
)
701 if (s
->rptr
>= s
->datalen
) {
706 if (s
->rpos
>= s
->blk_len
) {
712 if (len
> s
->datalen
- s
->rptr
)
713 len
= s
->datalen
- s
->rptr
;
714 if (len
> s
->blk_len
- s
->rpos
)
715 len
= s
->blk_len
- s
->rpos
;
718 p
= *s
->rblk
+ s
->rpos
;
726 void saa_rnbytes(struct SAA
*s
, void *data
, size_t len
)
730 if (s
->rptr
+ len
> s
->datalen
) {
731 nasm_malloc_error(ERR_PANIC
|ERR_NOFILE
, "overrun in saa_rnbytes");
740 p
= saa_rbytes(s
, &l
);
748 /* Same as saa_rnbytes, except position the counter first */
749 void saa_fread(struct SAA
*s
, size_t posn
, void *data
, size_t len
)
753 if (posn
+len
> s
->datalen
) {
754 nasm_malloc_error(ERR_PANIC
|ERR_NOFILE
, "overrun in saa_fread");
758 ix
= posn
/ s
->blk_len
;
760 s
->rpos
= posn
% s
->blk_len
;
761 s
->rblk
= &s
->blk_ptrs
[ix
];
763 saa_rnbytes(s
, data
, len
);
766 /* Same as saa_wbytes, except position the counter first */
767 void saa_fwrite(struct SAA
*s
, size_t posn
, const void *data
, size_t len
)
771 if (posn
> s
->datalen
) {
772 /* Seek beyond the end of the existing array not supported */
773 nasm_malloc_error(ERR_PANIC
|ERR_NOFILE
, "overrun in saa_fwrite");
777 ix
= posn
/ s
->blk_len
;
779 s
->wpos
= posn
% s
->blk_len
;
780 s
->wblk
= &s
->blk_ptrs
[ix
];
783 s
->wpos
= s
->blk_len
;
787 saa_wbytes(s
, data
, len
);
790 void saa_fpwrite(struct SAA
*s
, FILE * fp
)
796 while (len
= s
->datalen
, (data
= saa_rbytes(s
, &len
)) != NULL
)
797 fwrite(data
, 1, len
, fp
);
801 * Common list of prefix names
803 static const char *prefix_names
[] = {
804 "a16", "a32", "lock", "o16", "o32", "rep", "repe", "repne",
805 "repnz", "repz", "times"
808 const char *prefix_name(int token
)
810 unsigned int prefix
= token
-PREFIX_ENUM_START
;
811 if (prefix
> elements(prefix_names
))
814 return prefix_names
[prefix
];
820 int bsi(const char *string
, const char **array
, int size
)
822 int i
= -1, j
= size
; /* always, i < index < j */
825 int l
= strcmp(string
, array
[k
]);
826 if (l
< 0) /* it's in the first half */
828 else if (l
> 0) /* it's in the second half */
830 else /* we've got it :) */
833 return -1; /* we haven't got it :( */
836 int bsii(const char *string
, const char **array
, int size
)
838 int i
= -1, j
= size
; /* always, i < index < j */
841 int l
= nasm_stricmp(string
, array
[k
]);
842 if (l
< 0) /* it's in the first half */
844 else if (l
> 0) /* it's in the second half */
846 else /* we've got it :) */
849 return -1; /* we haven't got it :( */
852 static char *file_name
= NULL
;
853 static int32_t line_number
= 0;
855 char *src_set_fname(char *newname
)
857 char *oldname
= file_name
;
862 int32_t src_set_linnum(int32_t newline
)
864 int32_t oldline
= line_number
;
865 line_number
= newline
;
869 int32_t src_get_linnum(void)
874 int src_get(int32_t *xline
, char **xname
)
876 if (!file_name
|| !*xname
|| strcmp(*xname
, file_name
)) {
878 *xname
= file_name
? nasm_strdup(file_name
) : NULL
;
879 *xline
= line_number
;
882 if (*xline
!= line_number
) {
883 int32_t tmp
= line_number
- *xline
;
884 *xline
= line_number
;
890 void nasm_quote(char **str
)
892 int ln
= strlen(*str
);
895 if (ln
> 1 && (*str
)[ln
- 1] == q
&& (q
== '"' || q
== '\''))
900 p
= nasm_malloc(ln
+ 3);
903 p
[ln
+ 1] = p
[0] = q
;
908 char *nasm_strcat(char *one
, char *two
)
911 int l1
= strlen(one
);
912 rslt
= nasm_malloc(l1
+ strlen(two
) + 1);
914 strcpy(rslt
+ l1
, two
);
918 void null_debug_init(struct ofmt
*of
, void *id
, FILE * fp
, efunc error
)
925 void null_debug_linenum(const char *filename
, int32_t linenumber
, int32_t segto
)
931 void null_debug_deflabel(char *name
, int32_t segment
, int64_t offset
,
932 int is_global
, char *special
)
940 void null_debug_routine(const char *directive
, const char *params
)
945 void null_debug_typevalue(int32_t type
)
949 void null_debug_output(int type
, void *param
)
954 void null_debug_cleanup(void)
958 struct dfmt null_debug_form
= {
965 null_debug_typevalue
,
970 struct dfmt
*null_debug_arr
[2] = { &null_debug_form
, NULL
};