?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
NASM 2.07rc4
[nasm/avx512.git] / nasm.c
bloba938aaaecb2ac077288777425f200bfd917fa701
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 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following
9 * conditions are met:
10 *
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.
17 *
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.
31 *
32 * ----------------------------------------------------------------------- */
33
34 /*
35 * The Netwide Assembler main program module
36 */
37
38 #include "compiler.h"
39
40 #include <stdio.h>
41 #include <stdarg.h>
42 #include <stdlib.h>
43 #include <string.h>
44 #include <ctype.h>
45 #include <inttypes.h>
46 #include <limits.h>
47 #include <time.h>
48
49 #include "nasm.h"
50 #include "nasmlib.h"
51 #include "saa.h"
52 #include "raa.h"
53 #include "float.h"
54 #include "stdscan.h"
55 #include "insns.h"
56 #include "preproc.h"
57 #include "parser.h"
58 #include "eval.h"
59 #include "assemble.h"
60 #include "labels.h"
61 #include "output/outform.h"
62 #include "listing.h"
63
64 struct forwrefinfo { /* info held on forward refs. */
65 int lineno;
66 int operand;
67 };
68
69 static int get_bits(char *value);
70 static uint32_t get_cpu(char *cpu_str);
71 static void parse_cmdline(int, char **);
72 static void assemble_file(char *, StrList **);
73 static void register_output_formats(void);
74 static void report_error_gnu(int severity, const char *fmt, ...);
75 static void report_error_vc(int severity, const char *fmt, ...);
76 static void report_error_common(int severity, const char *fmt,
77 va_list args);
78 static bool is_suppressed_warning(int severity);
79 static void usage(void);
80 static efunc report_error;
81
82 static int using_debug_info, opt_verbose_info;
83 bool tasm_compatible_mode = false;
84 int pass0, passn;
85 int maxbits = 0;
86 int globalrel = 0;
87
88 time_t official_compile_time;
89
90 static char inname[FILENAME_MAX];
91 static char outname[FILENAME_MAX];
92 static char listname[FILENAME_MAX];
93 static char errname[FILENAME_MAX];
94 static int globallineno; /* for forward-reference tracking */
95 /* static int pass = 0; */
96 static struct ofmt *ofmt = NULL;
97
98 static FILE *error_file; /* Where to write error messages */
99
100 static FILE *ofile = NULL;
101 int optimizing = -1; /* number of optimization passes to take */
102 static int sb, cmd_sb = 16; /* by default */
103 static uint32_t cmd_cpu = IF_PLEVEL; /* highest level by default */
104 static uint32_t cpu = IF_PLEVEL; /* passed to insn_size & assemble.c */
105 int64_t global_offset_changed; /* referenced in labels.c */
106 int64_t prev_offset_changed;
107 int32_t stall_count;
108
109 static struct location location;
110 int in_abs_seg; /* Flag we are in ABSOLUTE seg */
111 int32_t abs_seg; /* ABSOLUTE segment basis */
112 int32_t abs_offset; /* ABSOLUTE offset */
113
114 static struct RAA *offsets;
115
116 static struct SAA *forwrefs; /* keep track of forward references */
117 static const struct forwrefinfo *forwref;
118
119 static Preproc *preproc;
120 enum op_type {
121 op_normal, /* Preprocess and assemble */
122 op_preprocess, /* Preprocess only */
123 op_depend, /* Generate dependencies */
124 };
125 static enum op_type operating_mode;
126 /* Dependency flags */
127 static bool depend_emit_phony = false;
128 static bool depend_missing_ok = false;
129 static const char *depend_target = NULL;
130 static const char *depend_file = NULL;
131
132 /*
133 * Which of the suppressible warnings are suppressed. Entry zero
134 * isn't an actual warning, but it used for -w+error/-Werror.
135 */
136
137 static bool warning_on[ERR_WARN_MAX+1]; /* Current state */
138 static bool warning_on_global[ERR_WARN_MAX+1]; /* Command-line state */
139
140 static const struct warning {
141 const char *name;
142 const char *help;
143 bool enabled;
144 } warnings[ERR_WARN_MAX+1] = {
145 {"error", "treat warnings as errors", false},
146 {"macro-params", "macro calls with wrong parameter count", true},
147 {"macro-selfref", "cyclic macro references", false},
148 {"macro-defaults", "macros with more default than optional parameters", true},
149 {"orphan-labels", "labels alone on lines without trailing `:'", true},
150 {"number-overflow", "numeric constant does not fit", true},
151 {"gnu-elf-extensions", "using 8- or 16-bit relocation in ELF32, a GNU extension", false},
152 {"float-overflow", "floating point overflow", true},
153 {"float-denorm", "floating point denormal", false},
154 {"float-underflow", "floating point underflow", false},
155 {"float-toolong", "too many digits in floating-point number", true},
156 {"user", "%warning directives", true},
157 };
158
159 /*
160 * This is a null preprocessor which just copies lines from input
161 * to output. It's used when someone explicitly requests that NASM
162 * not preprocess their source file.
163 */
164
165 static void no_pp_reset(char *, int, efunc, evalfunc, ListGen *, StrList **);
166 static char *no_pp_getline(void);
167 static void no_pp_cleanup(int);
168 static Preproc no_pp = {
169 no_pp_reset,
170 no_pp_getline,
171 no_pp_cleanup
172 };
173
174 /*
175 * get/set current offset...
176 */
177 #define GET_CURR_OFFS (in_abs_seg?abs_offset:\
178 raa_read(offsets,location.segment))
179 #define SET_CURR_OFFS(x) (in_abs_seg?(void)(abs_offset=(x)):\
180 (void)(offsets=raa_write(offsets,location.segment,(x))))
181
182 static bool want_usage;
183 static bool terminate_after_phase;
184 int user_nolist = 0; /* fbk 9/2/00 */
185
186 static void nasm_fputs(const char *line, FILE * outfile)
187 {
188 if (outfile) {
189 fputs(line, outfile);
190 putc('\n', outfile);
191 } else
192 puts(line);
193 }
194
195 /* Convert a struct tm to a POSIX-style time constant */
196 static int64_t posix_mktime(struct tm *tm)
197 {
198 int64_t t;
199 int64_t y = tm->tm_year;
200
201 /* See IEEE 1003.1:2004, section 4.14 */
202
203 t = (y-70)*365 + (y-69)/4 - (y-1)/100 + (y+299)/400;
204 t += tm->tm_yday;
205 t *= 24;
206 t += tm->tm_hour;
207 t *= 60;
208 t += tm->tm_min;
209 t *= 60;
210 t += tm->tm_sec;
211
212 return t;
213 }
214
215 static void define_macros_early(void)
216 {
217 char temp[128];
218 struct tm lt, *lt_p, gm, *gm_p;
219 int64_t posix_time;
220
221 lt_p = localtime(&official_compile_time);
222 if (lt_p) {
223 lt = *lt_p;
224
225 strftime(temp, sizeof temp, "__DATE__=\"%Y-%m-%d\"", &lt);
226 pp_pre_define(temp);
227 strftime(temp, sizeof temp, "__DATE_NUM__=%Y%m%d", &lt);
228 pp_pre_define(temp);
229 strftime(temp, sizeof temp, "__TIME__=\"%H:%M:%S\"", &lt);
230 pp_pre_define(temp);
231 strftime(temp, sizeof temp, "__TIME_NUM__=%H%M%S", &lt);
232 pp_pre_define(temp);
233 }
234
235 gm_p = gmtime(&official_compile_time);
236 if (gm_p) {
237 gm = *gm_p;
238
239 strftime(temp, sizeof temp, "__UTC_DATE__=\"%Y-%m-%d\"", &gm);
240 pp_pre_define(temp);
241 strftime(temp, sizeof temp, "__UTC_DATE_NUM__=%Y%m%d", &gm);
242 pp_pre_define(temp);
243 strftime(temp, sizeof temp, "__UTC_TIME__=\"%H:%M:%S\"", &gm);
244 pp_pre_define(temp);
245 strftime(temp, sizeof temp, "__UTC_TIME_NUM__=%H%M%S", &gm);
246 pp_pre_define(temp);
247 }
248
249 if (gm_p)
250 posix_time = posix_mktime(&gm);
251 else if (lt_p)
252 posix_time = posix_mktime(&lt);
253 else
254 posix_time = 0;
255
256 if (posix_time) {
257 snprintf(temp, sizeof temp, "__POSIX_TIME__=%"PRId64, posix_time);
258 pp_pre_define(temp);
259 }
260 }
261
262 static void define_macros_late(void)
263 {
264 char temp[128];
265
266 snprintf(temp, sizeof(temp), "__OUTPUT_FORMAT__=%s\n",
267 ofmt->shortname);
268 pp_pre_define(temp);
269 }
270
271 static void emit_dependencies(StrList *list)
272 {
273 FILE *deps;
274 int linepos, len;
275 StrList *l, *nl;
276
277 if (depend_file && strcmp(depend_file, "-")) {
278 deps = fopen(depend_file, "w");
279 if (!deps) {
280 report_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
281 "unable to write dependency file `%s'", depend_file);
282 return;
283 }
284 } else {
285 deps = stdout;
286 }
287
288 linepos = fprintf(deps, "%s:", depend_target);
289 for (l = list; l; l = l->next) {
290 len = strlen(l->str);
291 if (linepos + len > 62) {
292 fprintf(deps, " \\\n ");
293 linepos = 1;
294 }
295 fprintf(deps, " %s", l->str);
296 linepos += len+1;
297 }
298 fprintf(deps, "\n\n");
299
300 for (l = list; l; l = nl) {
301 if (depend_emit_phony)
302 fprintf(deps, "%s:\n\n", l->str);
303
304 nl = l->next;
305 nasm_free(l);
306 }
307
308 if (deps != stdout)
309 fclose(deps);
310 }
311
312 int main(int argc, char **argv)
313 {
314 StrList *depend_list = NULL, **depend_ptr;
315
316 time(&official_compile_time);
317
318 pass0 = 0;
319 want_usage = terminate_after_phase = false;
320 report_error = report_error_gnu;
321
322 error_file = stderr;
323
324 tolower_init();
325
326 nasm_set_malloc_error(report_error);
327 offsets = raa_init();
328 forwrefs = saa_init((int32_t)sizeof(struct forwrefinfo));
329
330 preproc = &nasmpp;
331 operating_mode = op_normal;
332
333 seg_init();
334
335 register_output_formats();
336
337 /* Define some macros dependent on the runtime, but not
338 on the command line. */
339 define_macros_early();
340
341 parse_cmdline(argc, argv);
342
343 if (terminate_after_phase) {
344 if (want_usage)
345 usage();
346 return 1;
347 }
348
349 /* If debugging info is disabled, suppress any debug calls */
350 if (!using_debug_info)
351 ofmt->current_dfmt = &null_debug_form;
352
353 if (ofmt->stdmac)
354 pp_extra_stdmac(ofmt->stdmac);
355 parser_global_info(ofmt, &location);
356 eval_global_info(ofmt, lookup_label, &location);
357
358 /* define some macros dependent of command-line */
359 define_macros_late();
360
361 depend_ptr = (depend_file || (operating_mode == op_depend))
362 ? &depend_list : NULL;
363 if (!depend_target)
364 depend_target = outname;
365
366 switch (operating_mode) {
367 case op_depend:
368 {
369 char *line;
370
371 if (depend_missing_ok)
372 pp_include_path(NULL); /* "assume generated" */
373
374 preproc->reset(inname, 0, report_error, evaluate, &nasmlist,
375 depend_ptr);
376 if (outname[0] == '\0')
377 ofmt->filename(inname, outname, report_error);
378 ofile = NULL;
379 while ((line = preproc->getline()))
380 nasm_free(line);
381 preproc->cleanup(0);
382 }
383 break;
384
385 case op_preprocess:
386 {
387 char *line;
388 char *file_name = NULL;
389 int32_t prior_linnum = 0;
390 int lineinc = 0;
391
392 if (*outname) {
393 ofile = fopen(outname, "w");
394 if (!ofile)
395 report_error(ERR_FATAL | ERR_NOFILE,
396 "unable to open output file `%s'",
397 outname);
398 } else
399 ofile = NULL;
400
401 location.known = false;
402
403 /* pass = 1; */
404 preproc->reset(inname, 3, report_error, evaluate, &nasmlist,
405 depend_ptr);
406
407 while ((line = preproc->getline())) {
408 /*
409 * We generate %line directives if needed for later programs
410 */
411 int32_t linnum = prior_linnum += lineinc;
412 int altline = src_get(&linnum, &file_name);
413 if (altline) {
414 if (altline == 1 && lineinc == 1)
415 nasm_fputs("", ofile);
416 else {
417 lineinc = (altline != -1 || lineinc != 1);
418 fprintf(ofile ? ofile : stdout,
419 "%%line %"PRId32"+%d %s\n", linnum, lineinc,
420 file_name);
421 }
422 prior_linnum = linnum;
423 }
424 nasm_fputs(line, ofile);
425 nasm_free(line);
426 }
427 nasm_free(file_name);
428 preproc->cleanup(0);
429 if (ofile)
430 fclose(ofile);
431 if (ofile && terminate_after_phase)
432 remove(outname);
433 }
434 break;
435
436 case op_normal:
437 {
438 /*
439 * We must call ofmt->filename _anyway_, even if the user
440 * has specified their own output file, because some
441 * formats (eg OBJ and COFF) use ofmt->filename to find out
442 * the name of the input file and then put that inside the
443 * file.
444 */
445 ofmt->filename(inname, outname, report_error);
446
447 ofile = fopen(outname, (ofmt->flags & OFMT_TEXT) ? "w" : "wb");
448 if (!ofile) {
449 report_error(ERR_FATAL | ERR_NOFILE,
450 "unable to open output file `%s'", outname);
451 }
452
453 /*
454 * We must call init_labels() before ofmt->init() since
455 * some object formats will want to define labels in their
456 * init routines. (eg OS/2 defines the FLAT group)
457 */
458 init_labels();
459
460 ofmt->init(ofile, report_error, define_label, evaluate);
461 ofmt->current_dfmt->init(ofmt, NULL, ofile, report_error);
462
463 assemble_file(inname, depend_ptr);
464
465 if (!terminate_after_phase) {
466 ofmt->cleanup(using_debug_info);
467 cleanup_labels();
468 } else {
469 /*
470 * Despite earlier comments, we need this fclose.
471 * The object output drivers only fclose on cleanup,
472 * and we just skipped that.
473 */
474 fclose (ofile);
475
476 remove(outname);
477 }
478 }
479 break;
480 }
481
482 if (depend_list && !terminate_after_phase)
483 emit_dependencies(depend_list);
484
485 if (want_usage)
486 usage();
487
488 raa_free(offsets);
489 saa_free(forwrefs);
490 eval_cleanup();
491 stdscan_cleanup();
492
493 return terminate_after_phase;
494 }
495
496 /*
497 * Get a parameter for a command line option.
498 * First arg must be in the form of e.g. -f...
499 */
500 static char *get_param(char *p, char *q, bool *advance)
501 {
502 *advance = false;
503 if (p[2]) { /* the parameter's in the option */
504 p += 2;
505 while (nasm_isspace(*p))
506 p++;
507 return p;
508 }
509 if (q && q[0]) {
510 *advance = true;
511 return q;
512 }
513 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
514 "option `-%c' requires an argument", p[1]);
515 return NULL;
516 }
517
518 /*
519 * Copy a filename
520 */
521 static void copy_filename(char *dst, const char *src)
522 {
523 size_t len = strlen(src);
524
525 if (len >= (size_t)FILENAME_MAX) {
526 report_error(ERR_FATAL | ERR_NOFILE, "file name too long");
527 return;
528 }
529 strncpy(dst, src, FILENAME_MAX);
530 }
531
532 /*
533 * Convert a string to Make-safe form
534 */
535 static char *quote_for_make(const char *str)
536 {
537 const char *p;
538 char *os, *q;
539
540 size_t n = 1; /* Terminating zero */
541 size_t nbs = 0;
542
543 if (!str)
544 return NULL;
545
546 for (p = str; *p; p++) {
547 switch (*p) {
548 case ' ':
549 case '\t':
550 /* Convert N backslashes + ws -> 2N+1 backslashes + ws */
551 n += nbs + 2;
552 nbs = 0;
553 break;
554 case '$':
555 case '#':
556 nbs = 0;
557 n += 2;
558 break;
559 case '\\':
560 nbs++;
561 n++;
562 break;
563 default:
564 nbs = 0;
565 n++;
566 break;
567 }
568 }
569
570 /* Convert N backslashes at the end of filename to 2N backslashes */
571 if (nbs)
572 n += nbs;
573
574 os = q = nasm_malloc(n);
575
576 nbs = 0;
577 for (p = str; *p; p++) {
578 switch (*p) {
579 case ' ':
580 case '\t':
581 while (nbs--)
582 *q++ = '\\';
583 *q++ = '\\';
584 *q++ = *p;
585 break;
586 case '$':
587 *q++ = *p;
588 *q++ = *p;
589 nbs = 0;
590 break;
591 case '#':
592 *q++ = '\\';
593 *q++ = *p;
594 nbs = 0;
595 break;
596 case '\\':
597 *q++ = *p;
598 nbs++;
599 break;
600 default:
601 *q++ = *p;
602 nbs = 0;
603 break;
604 }
605 }
606 while (nbs--)
607 *q++ = '\\';
608
609 *q = '\0';
610
611 return os;
612 }
613
614 struct textargs {
615 const char *label;
616 int value;
617 };
618
619 #define OPT_PREFIX 0
620 #define OPT_POSTFIX 1
621 struct textargs textopts[] = {
622 {"prefix", OPT_PREFIX},
623 {"postfix", OPT_POSTFIX},
624 {NULL, 0}
625 };
626
627 static bool stopoptions = false;
628 static bool process_arg(char *p, char *q)
629 {
630 char *param;
631 int i;
632 bool advance = false;
633 bool do_warn;
634
635 if (!p || !p[0])
636 return false;
637
638 if (p[0] == '-' && !stopoptions) {
639 if (strchr("oOfpPdDiIlFXuUZwW", p[1])) {
640 /* These parameters take values */
641 if (!(param = get_param(p, q, &advance)))
642 return advance;
643 }
644
645 switch (p[1]) {
646 case 's':
647 error_file = stdout;
648 break;
649
650 case 'o': /* output file */
651 copy_filename(outname, param);
652 break;
653
654 case 'f': /* output format */
655 ofmt = ofmt_find(param);
656 if (!ofmt) {
657 report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
658 "unrecognised output format `%s' - "
659 "use -hf for a list", param);
660 }
661 break;
662
663 case 'O': /* Optimization level */
664 {
665 int opt;
666
667 if (!*param) {
668 /* Naked -O == -Ox */
669 optimizing = INT_MAX >> 1; /* Almost unlimited */
670 } else {
671 while (*param) {
672 switch (*param) {
673 case '0': case '1': case '2': case '3': case '4':
674 case '5': case '6': case '7': case '8': case '9':
675 opt = strtoul(param, &param, 10);
676
677 /* -O0 -> optimizing == -1, 0.98 behaviour */
678 /* -O1 -> optimizing == 0, 0.98.09 behaviour */
679 if (opt < 2)
680 optimizing = opt - 1;
681 else
682 optimizing = opt;
683 break;
684
685 case 'v':
686 case '+':
687 param++;
688 opt_verbose_info = true;
689 break;
690
691 case 'x':
692 param++;
693 optimizing = INT_MAX >> 1; /* Almost unlimited */
694 break;
695
696 default:
697 report_error(ERR_FATAL,
698 "unknown optimization option -O%c\n",
699 *param);
700 break;
701 }
702 }
703 }
704 break;
705 }
706
707 case 'p': /* pre-include */
708 case 'P':
709 pp_pre_include(param);
710 break;
711
712 case 'd': /* pre-define */
713 case 'D':
714 pp_pre_define(param);
715 break;
716
717 case 'u': /* un-define */
718 case 'U':
719 pp_pre_undefine(param);
720 break;
721
722 case 'i': /* include search path */
723 case 'I':
724 pp_include_path(param);
725 break;
726
727 case 'l': /* listing file */
728 copy_filename(listname, param);
729 break;
730
731 case 'Z': /* error messages file */
732 strcpy(errname, param);
733 break;
734
735 case 'F': /* specify debug format */
736 ofmt->current_dfmt = dfmt_find(ofmt, param);
737 if (!ofmt->current_dfmt) {
738 report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
739 "unrecognized debug format `%s' for"
740 " output format `%s'",
741 param, ofmt->shortname);
742 }
743 using_debug_info = true;
744 break;
745
746 case 'X': /* specify error reporting format */
747 if (nasm_stricmp("vc", param) == 0)
748 report_error = report_error_vc;
749 else if (nasm_stricmp("gnu", param) == 0)
750 report_error = report_error_gnu;
751 else
752 report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
753 "unrecognized error reporting format `%s'",
754 param);
755 break;
756
757 case 'g':
758 using_debug_info = true;
759 break;
760
761 case 'h':
762 printf
763 ("usage: nasm [-@ response file] [-o outfile] [-f format] "
764 "[-l listfile]\n"
765 " [options...] [--] filename\n"
766 " or nasm -v for version info\n\n"
767 " -t assemble in SciTech TASM compatible mode\n"
768 " -g generate debug information in selected format.\n");
769 printf
770 (" -E (or -e) preprocess only (writes output to stdout by default)\n"
771 " -a don't preprocess (assemble only)\n"
772 " -M generate Makefile dependencies on stdout\n"
773 " -MG d:o, missing files assumed generated\n\n"
774 " -Z<file> redirect error messages to file\n"
775 " -s redirect error messages to stdout\n\n"
776 " -F format select a debugging format\n\n"
777 " -I<path> adds a pathname to the include file path\n");
778 printf
779 (" -O<digit> optimize branch offsets (-O0 disables, default)\n"
780 " -P<file> pre-includes a file\n"
781 " -D<macro>[=<value>] pre-defines a macro\n"
782 " -U<macro> undefines a macro\n"
783 " -X<format> specifies error reporting format (gnu or vc)\n"
784 " -w+foo enables warning foo (equiv. -Wfoo)\n"
785 " -w-foo disable warning foo (equiv. -Wno-foo)\n"
786 "Warnings:\n");
787 for (i = 0; i <= ERR_WARN_MAX; i++)
788 printf(" %-23s %s (default %s)\n",
789 warnings[i].name, warnings[i].help,
790 warnings[i].enabled ? "on" : "off");
791 printf
792 ("\nresponse files should contain command line parameters"
793 ", one per line.\n");
794 if (p[2] == 'f') {
795 printf("\nvalid output formats for -f are"
796 " (`*' denotes default):\n");
797 ofmt_list(ofmt, stdout);
798 } else {
799 printf("\nFor a list of valid output formats, use -hf.\n");
800 printf("For a list of debug formats, use -f <form> -y.\n");
801 }
802 exit(0); /* never need usage message here */
803 break;
804
805 case 'y':
806 printf("\nvalid debug formats for '%s' output format are"
807 " ('*' denotes default):\n", ofmt->shortname);
808 dfmt_list(ofmt, stdout);
809 exit(0);
810 break;
811
812 case 't':
813 tasm_compatible_mode = true;
814 break;
815
816 case 'v':
817 printf("NASM version %s compiled on %s%s\n",
818 nasm_version, nasm_date, nasm_compile_options);
819 exit(0); /* never need usage message here */
820 break;
821
822 case 'e': /* preprocess only */
823 case 'E':
824 operating_mode = op_preprocess;
825 break;
826
827 case 'a': /* assemble only - don't preprocess */
828 preproc = &no_pp;
829 break;
830
831 case 'W':
832 if (param[0] == 'n' && param[1] == 'o' && param[2] == '-') {
833 do_warn = false;
834 param += 3;
835 } else {
836 do_warn = true;
837 }
838 goto set_warning;
839
840 case 'w':
841 if (param[0] != '+' && param[0] != '-') {
842 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
843 "invalid option to `-w'");
844 break;
845 }
846 do_warn = (param[0] == '+');
847 param++;
848 goto set_warning;
849 set_warning:
850 for (i = 0; i <= ERR_WARN_MAX; i++)
851 if (!nasm_stricmp(param, warnings[i].name))
852 break;
853 if (i <= ERR_WARN_MAX)
854 warning_on_global[i] = do_warn;
855 else if (!nasm_stricmp(param, "all"))
856 for (i = 1; i <= ERR_WARN_MAX; i++)
857 warning_on_global[i] = do_warn;
858 else if (!nasm_stricmp(param, "none"))
859 for (i = 1; i <= ERR_WARN_MAX; i++)
860 warning_on_global[i] = !do_warn;
861 else
862 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
863 "invalid warning `%s'", param);
864 break;
865
866 case 'M':
867 switch (p[2]) {
868 case 0:
869 operating_mode = op_depend;
870 break;
871 case 'G':
872 operating_mode = op_depend;
873 depend_missing_ok = true;
874 break;
875 case 'P':
876 depend_emit_phony = true;
877 break;
878 case 'D':
879 depend_file = q;
880 advance = true;
881 break;
882 case 'T':
883 depend_target = q;
884 advance = true;
885 break;
886 case 'Q':
887 depend_target = quote_for_make(q);
888 advance = true;
889 break;
890 default:
891 report_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
892 "unknown dependency option `-M%c'", p[2]);
893 break;
894 }
895 if (advance && (!q || !q[0])) {
896 report_error(ERR_NONFATAL|ERR_NOFILE|ERR_USAGE,
897 "option `-M%c' requires a parameter", p[2]);
898 break;
899 }
900 break;
901
902 case '-':
903 {
904 int s;
905
906 if (p[2] == 0) { /* -- => stop processing options */
907 stopoptions = 1;
908 break;
909 }
910 for (s = 0; textopts[s].label; s++) {
911 if (!nasm_stricmp(p + 2, textopts[s].label)) {
912 break;
913 }
914 }
915
916 switch (s) {
917
918 case OPT_PREFIX:
919 case OPT_POSTFIX:
920 {
921 if (!q) {
922 report_error(ERR_NONFATAL | ERR_NOFILE |
923 ERR_USAGE,
924 "option `--%s' requires an argument",
925 p + 2);
926 break;
927 } else {
928 advance = 1, param = q;
929 }
930
931 if (s == OPT_PREFIX) {
932 strncpy(lprefix, param, PREFIX_MAX - 1);
933 lprefix[PREFIX_MAX - 1] = 0;
934 break;
935 }
936 if (s == OPT_POSTFIX) {
937 strncpy(lpostfix, param, POSTFIX_MAX - 1);
938 lpostfix[POSTFIX_MAX - 1] = 0;
939 break;
940 }
941 break;
942 }
943 default:
944 {
945 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
946 "unrecognised option `--%s'", p + 2);
947 break;
948 }
949 }
950 break;
951 }
952
953 default:
954 if (!ofmt->setinfo(GI_SWITCH, &p))
955 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
956 "unrecognised option `-%c'", p[1]);
957 break;
958 }
959 } else {
960 if (*inname) {
961 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
962 "more than one input file specified");
963 } else {
964 copy_filename(inname, p);
965 }
966 }
967
968 return advance;
969 }
970
971 #define ARG_BUF_DELTA 128
972
973 static void process_respfile(FILE * rfile)
974 {
975 char *buffer, *p, *q, *prevarg;
976 int bufsize, prevargsize;
977
978 bufsize = prevargsize = ARG_BUF_DELTA;
979 buffer = nasm_malloc(ARG_BUF_DELTA);
980 prevarg = nasm_malloc(ARG_BUF_DELTA);
981 prevarg[0] = '\0';
982
983 while (1) { /* Loop to handle all lines in file */
984 p = buffer;
985 while (1) { /* Loop to handle long lines */
986 q = fgets(p, bufsize - (p - buffer), rfile);
987 if (!q)
988 break;
989 p += strlen(p);
990 if (p > buffer && p[-1] == '\n')
991 break;
992 if (p - buffer > bufsize - 10) {
993 int offset;
994 offset = p - buffer;
995 bufsize += ARG_BUF_DELTA;
996 buffer = nasm_realloc(buffer, bufsize);
997 p = buffer + offset;
998 }
999 }
1000
1001 if (!q && p == buffer) {
1002 if (prevarg[0])
1003 process_arg(prevarg, NULL);
1004 nasm_free(buffer);
1005 nasm_free(prevarg);
1006 return;
1007 }
1008
1009 /*
1010 * Play safe: remove CRs, LFs and any spurious ^Zs, if any of
1011 * them are present at the end of the line.
1012 */
1013 *(p = &buffer[strcspn(buffer, "\r\n\032")]) = '\0';
1014
1015 while (p > buffer && nasm_isspace(p[-1]))
1016 *--p = '\0';
1017
1018 p = buffer;
1019 while (nasm_isspace(*p))
1020 p++;
1021
1022 if (process_arg(prevarg, p))
1023 *p = '\0';
1024
1025 if ((int) strlen(p) > prevargsize - 10) {
1026 prevargsize += ARG_BUF_DELTA;
1027 prevarg = nasm_realloc(prevarg, prevargsize);
1028 }
1029 strncpy(prevarg, p, prevargsize);
1030 }
1031 }
1032
1033 /* Function to process args from a string of args, rather than the
1034 * argv array. Used by the environment variable and response file
1035 * processing.
1036 */
1037 static void process_args(char *args)
1038 {
1039 char *p, *q, *arg, *prevarg;
1040 char separator = ' ';
1041
1042 p = args;
1043 if (*p && *p != '-')
1044 separator = *p++;
1045 arg = NULL;
1046 while (*p) {
1047 q = p;
1048 while (*p && *p != separator)
1049 p++;
1050 while (*p == separator)
1051 *p++ = '\0';
1052 prevarg = arg;
1053 arg = q;
1054 if (process_arg(prevarg, arg))
1055 arg = NULL;
1056 }
1057 if (arg)
1058 process_arg(arg, NULL);
1059 }
1060
1061 static void process_response_file(const char *file)
1062 {
1063 char str[2048];
1064 FILE *f = fopen(file, "r");
1065 if (!f) {
1066 perror(file);
1067 exit(-1);
1068 }
1069 while (fgets(str, sizeof str, f)) {
1070 process_args(str);
1071 }
1072 fclose(f);
1073 }
1074
1075 static void parse_cmdline(int argc, char **argv)
1076 {
1077 FILE *rfile;
1078 char *envreal, *envcopy = NULL, *p, *arg;
1079 int i;
1080
1081 *inname = *outname = *listname = *errname = '\0';
1082 for (i = 0; i <= ERR_WARN_MAX; i++)
1083 warning_on_global[i] = warnings[i].enabled;
1084
1085 /*
1086 * First, process the NASMENV environment variable.
1087 */
1088 envreal = getenv("NASMENV");
1089 arg = NULL;
1090 if (envreal) {
1091 envcopy = nasm_strdup(envreal);
1092 process_args(envcopy);
1093 nasm_free(envcopy);
1094 }
1095
1096 /*
1097 * Now process the actual command line.
1098 */
1099 while (--argc) {
1100 bool advance;
1101 argv++;
1102 if (argv[0][0] == '@') {
1103 /* We have a response file, so process this as a set of
1104 * arguments like the environment variable. This allows us
1105 * to have multiple arguments on a single line, which is
1106 * different to the -@resp file processing below for regular
1107 * NASM.
1108 */
1109 process_response_file(argv[0]+1);
1110 argc--;
1111 argv++;
1112 }
1113 if (!stopoptions && argv[0][0] == '-' && argv[0][1] == '@') {
1114 p = get_param(argv[0], argc > 1 ? argv[1] : NULL, &advance);
1115 if (p) {
1116 rfile = fopen(p, "r");
1117 if (rfile) {
1118 process_respfile(rfile);
1119 fclose(rfile);
1120 } else
1121 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
1122 "unable to open response file `%s'", p);
1123 }
1124 } else
1125 advance = process_arg(argv[0], argc > 1 ? argv[1] : NULL);
1126 argv += advance, argc -= advance;
1127 }
1128
1129 /* Look for basic command line typos. This definitely doesn't
1130 catch all errors, but it might help cases of fumbled fingers. */
1131 if (!*inname)
1132 report_error(ERR_NONFATAL | ERR_NOFILE | ERR_USAGE,
1133 "no input file specified");
1134 else if (!strcmp(inname, errname) ||
1135 !strcmp(inname, outname) ||
1136 !strcmp(inname, listname) ||
1137 (depend_file && !strcmp(inname, depend_file)))
1138 report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
1139 "file `%s' is both input and output file",
1140 inname);
1141
1142 if (*errname) {
1143 error_file = fopen(errname, "w");
1144 if (!error_file) {
1145 error_file = stderr; /* Revert to default! */
1146 report_error(ERR_FATAL | ERR_NOFILE | ERR_USAGE,
1147 "cannot open file `%s' for error messages",
1148 errname);
1149 }
1150 }
1151 }
1152
1153 /* List of directives */
1154 enum directives {
1155 D_NONE, D_ABSOLUTE, D_BITS, D_COMMON, D_CPU, D_DEBUG, D_DEFAULT,
1156 D_EXTERN, D_FLOAT, D_GLOBAL, D_LIST, D_SECTION, D_SEGMENT, D_WARNING
1157 };
1158 static const char *directives[] = {
1159 "", "absolute", "bits", "common", "cpu", "debug", "default",
1160 "extern", "float", "global", "list", "section", "segment", "warning"
1161 };
1162 static enum directives getkw(char **directive, char **value);
1163
1164 static void assemble_file(char *fname, StrList **depend_ptr)
1165 {
1166 char *directive, *value, *p, *q, *special, *line, debugid[80];
1167 insn output_ins;
1168 int i, validid;
1169 bool rn_error;
1170 int32_t seg;
1171 int64_t offs;
1172 struct tokenval tokval;
1173 expr *e;
1174 int pass_max;
1175
1176 if (cmd_sb == 32 && cmd_cpu < IF_386)
1177 report_error(ERR_FATAL, "command line: "
1178 "32-bit segment size requires a higher cpu");
1179
1180 pass_max = prev_offset_changed = (INT_MAX >> 1) + 2; /* Almost unlimited */
1181 for (passn = 1; pass0 <= 2; passn++) {
1182 int pass1, pass2;
1183 ldfunc def_label;
1184
1185 pass1 = pass0 == 2 ? 2 : 1; /* 1, 1, 1, ..., 1, 2 */
1186 pass2 = passn > 1 ? 2 : 1; /* 1, 2, 2, ..., 2, 2 */
1187 /* pass0 0, 0, 0, ..., 1, 2 */
1188
1189 def_label = passn > 1 ? redefine_label : define_label;
1190
1191 globalbits = sb = cmd_sb; /* set 'bits' to command line default */
1192 cpu = cmd_cpu;
1193 if (pass0 == 2) {
1194 if (*listname)
1195 nasmlist.init(listname, report_error);
1196 }
1197 in_abs_seg = false;
1198 global_offset_changed = 0; /* set by redefine_label */
1199 location.segment = ofmt->section(NULL, pass2, &sb);
1200 globalbits = sb;
1201 if (passn > 1) {
1202 saa_rewind(forwrefs);
1203 forwref = saa_rstruct(forwrefs);
1204 raa_free(offsets);
1205 offsets = raa_init();
1206 }
1207 preproc->reset(fname, pass1, report_error, evaluate, &nasmlist,
1208 pass1 == 2 ? depend_ptr : NULL);
1209 memcpy(warning_on, warning_on_global, (ERR_WARN_MAX+1) * sizeof(bool));
1210
1211 globallineno = 0;
1212 if (passn == 1)
1213 location.known = true;
1214 location.offset = offs = GET_CURR_OFFS;
1215
1216 while ((line = preproc->getline())) {
1217 enum directives d;
1218 globallineno++;
1219
1220 /*
1221 * Here we parse our directives; this is not handled by the
1222 * 'real' parser. This really should be a separate function.
1223 */
1224 directive = line;
1225 d = getkw(&directive, &value);
1226 if (d) {
1227 int err = 0;
1228
1229 switch (d) {
1230 case D_SEGMENT: /* [SEGMENT n] */
1231 case D_SECTION:
1232 seg = ofmt->section(value, pass2, &sb);
1233 if (seg == NO_SEG) {
1234 report_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
1235 "segment name `%s' not recognized",
1236 value);
1237 } else {
1238 in_abs_seg = false;
1239 location.segment = seg;
1240 }
1241 break;
1242 case D_EXTERN: /* [EXTERN label:special] */
1243 if (*value == '$')
1244 value++; /* skip initial $ if present */
1245 if (pass0 == 2) {
1246 q = value;
1247 while (*q && *q != ':')
1248 q++;
1249 if (*q == ':') {
1250 *q++ = '\0';
1251 ofmt->symdef(value, 0L, 0L, 3, q);
1252 }
1253 } else if (passn == 1) {
1254 q = value;
1255 validid = true;
1256 if (!isidstart(*q))
1257 validid = false;
1258 while (*q && *q != ':') {
1259 if (!isidchar(*q))
1260 validid = false;
1261 q++;
1262 }
1263 if (!validid) {
1264 report_error(ERR_NONFATAL,
1265 "identifier expected after EXTERN");
1266 break;
1267 }
1268 if (*q == ':') {
1269 *q++ = '\0';
1270 special = q;
1271 } else
1272 special = NULL;
1273 if (!is_extern(value)) { /* allow re-EXTERN to be ignored */
1274 int temp = pass0;
1275 pass0 = 1; /* fake pass 1 in labels.c */
1276 declare_as_global(value, special,
1277 report_error);
1278 define_label(value, seg_alloc(), 0L, NULL,
1279 false, true, ofmt, report_error);
1280 pass0 = temp;
1281 }
1282 } /* else pass0 == 1 */
1283 break;
1284 case D_BITS: /* [BITS bits] */
1285 globalbits = sb = get_bits(value);
1286 break;
1287 case D_GLOBAL: /* [GLOBAL symbol:special] */
1288 if (*value == '$')
1289 value++; /* skip initial $ if present */
1290 if (pass0 == 2) { /* pass 2 */
1291 q = value;
1292 while (*q && *q != ':')
1293 q++;
1294 if (*q == ':') {
1295 *q++ = '\0';
1296 ofmt->symdef(value, 0L, 0L, 3, q);
1297 }
1298 } else if (pass2 == 1) { /* pass == 1 */
1299 q = value;
1300 validid = true;
1301 if (!isidstart(*q))
1302 validid = false;
1303 while (*q && *q != ':') {
1304 if (!isidchar(*q))
1305 validid = false;
1306 q++;
1307 }
1308 if (!validid) {
1309 report_error(ERR_NONFATAL,
1310 "identifier expected after GLOBAL");
1311 break;
1312 }
1313 if (*q == ':') {
1314 *q++ = '\0';
1315 special = q;
1316 } else
1317 special = NULL;
1318 declare_as_global(value, special, report_error);
1319 } /* pass == 1 */
1320 break;
1321 case D_COMMON: /* [COMMON symbol size:special] */
1322 {
1323 int64_t size;
1324
1325 if (*value == '$')
1326 value++; /* skip initial $ if present */
1327 p = value;
1328 validid = true;
1329 if (!isidstart(*p))
1330 validid = false;
1331 while (*p && !nasm_isspace(*p)) {
1332 if (!isidchar(*p))
1333 validid = false;
1334 p++;
1335 }
1336 if (!validid) {
1337 report_error(ERR_NONFATAL,
1338 "identifier expected after COMMON");
1339 break;
1340 }
1341 if (*p) {
1342 while (*p && nasm_isspace(*p))
1343 *p++ = '\0';
1344 q = p;
1345 while (*q && *q != ':')
1346 q++;
1347 if (*q == ':') {
1348 *q++ = '\0';
1349 special = q;
1350 } else {
1351 special = NULL;
1352 }
1353 size = readnum(p, &rn_error);
1354 if (rn_error) {
1355 report_error(ERR_NONFATAL,
1356 "invalid size specified"
1357 " in COMMON declaration");
1358 break;
1359 }
1360 } else {
1361 report_error(ERR_NONFATAL,
1362 "no size specified in"
1363 " COMMON declaration");
1364 break;
1365 }
1366
1367 if (pass0 < 2) {
1368 define_common(value, seg_alloc(), size,
1369 special, ofmt, report_error);
1370 } else if (pass0 == 2) {
1371 ofmt->symdef(value, 0L, 0L, 3, special);
1372 }
1373 break;
1374 }
1375 case D_ABSOLUTE: /* [ABSOLUTE address] */
1376 stdscan_reset();
1377 stdscan_bufptr = value;
1378 tokval.t_type = TOKEN_INVALID;
1379 e = evaluate(stdscan, NULL, &tokval, NULL, pass2,
1380 report_error, NULL);
1381 if (e) {
1382 if (!is_reloc(e))
1383 report_error(pass0 ==
1384 1 ? ERR_NONFATAL : ERR_PANIC,
1385 "cannot use non-relocatable expression as "
1386 "ABSOLUTE address");
1387 else {
1388 abs_seg = reloc_seg(e);
1389 abs_offset = reloc_value(e);
1390 }
1391 } else if (passn == 1)
1392 abs_offset = 0x100; /* don't go near zero in case of / */
1393 else
1394 report_error(ERR_PANIC, "invalid ABSOLUTE address "
1395 "in pass two");
1396 in_abs_seg = true;
1397 location.segment = NO_SEG;
1398 break;
1399 case D_DEBUG: /* [DEBUG] */
1400 p = value;
1401 q = debugid;
1402 validid = true;
1403 if (!isidstart(*p))
1404 validid = false;
1405 while (*p && !nasm_isspace(*p)) {
1406 if (!isidchar(*p))
1407 validid = false;
1408 *q++ = *p++;
1409 }
1410 *q++ = 0;
1411 if (!validid) {
1412 report_error(passn == 1 ? ERR_NONFATAL : ERR_PANIC,
1413 "identifier expected after DEBUG");
1414 break;
1415 }
1416 while (*p && nasm_isspace(*p))
1417 p++;
1418 if (pass0 == 2)
1419 ofmt->current_dfmt->debug_directive(debugid, p);
1420 break;
1421 case D_WARNING: /* [WARNING {+|-|*}warn-name] */
1422 while (*value && nasm_isspace(*value))
1423 value++;
1424
1425 switch(*value) {
1426 case '-': validid = 0; value++; break;
1427 case '+': validid = 1; value++; break;
1428 case '*': validid = 2; value++; break;
1429 default: validid = 1; break;
1430 }
1431
1432 for (i = 1; i <= ERR_WARN_MAX; i++)
1433 if (!nasm_stricmp(value, warnings[i].name))
1434 break;
1435 if (i <= ERR_WARN_MAX) {
1436 switch(validid) {
1437 case 0:
1438 warning_on[i] = false;
1439 break;
1440 case 1:
1441 warning_on[i] = true;
1442 break;
1443 case 2:
1444 warning_on[i] = warning_on_global[i];
1445 break;
1446 }
1447 }
1448 else
1449 report_error(ERR_NONFATAL,
1450 "invalid warning id in WARNING directive");
1451 break;
1452 case D_CPU: /* [CPU] */
1453 cpu = get_cpu(value);
1454 break;
1455 case D_LIST: /* [LIST {+|-}] */
1456 while (*value && nasm_isspace(*value))
1457 value++;
1458
1459 if (*value == '+') {
1460 user_nolist = 0;
1461 } else {
1462 if (*value == '-') {
1463 user_nolist = 1;
1464 } else {
1465 err = 1;
1466 }
1467 }
1468 break;
1469 case D_DEFAULT: /* [DEFAULT] */
1470 stdscan_reset();
1471 stdscan_bufptr = value;
1472 tokval.t_type = TOKEN_INVALID;
1473 if (stdscan(NULL, &tokval) == TOKEN_SPECIAL) {
1474 switch ((int)tokval.t_integer) {
1475 case S_REL:
1476 globalrel = 1;
1477 break;
1478 case S_ABS:
1479 globalrel = 0;
1480 break;
1481 default:
1482 err = 1;
1483 break;
1484 }
1485 } else {
1486 err = 1;
1487 }
1488 break;
1489 case D_FLOAT:
1490 if (float_option(value)) {
1491 report_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
1492 "unknown 'float' directive: %s",
1493 value);
1494 }
1495 break;
1496 default:
1497 if (!ofmt->directive(directive, value, pass2))
1498 report_error(pass1 == 1 ? ERR_NONFATAL : ERR_PANIC,
1499 "unrecognised directive [%s]",
1500 directive);
1501 }
1502 if (err) {
1503 report_error(ERR_NONFATAL,
1504 "invalid parameter to [%s] directive",
1505 directive);
1506 }
1507 } else { /* it isn't a directive */
1508
1509 parse_line(pass1, line, &output_ins,
1510 report_error, evaluate, def_label);
1511
1512 if (optimizing > 0) {
1513 if (forwref != NULL && globallineno == forwref->lineno) {
1514 output_ins.forw_ref = true;
1515 do {
1516 output_ins.oprs[forwref->operand].opflags |=
1517 OPFLAG_FORWARD;
1518 forwref = saa_rstruct(forwrefs);
1519 } while (forwref != NULL
1520 && forwref->lineno == globallineno);
1521 } else
1522 output_ins.forw_ref = false;
1523
1524 if (output_ins.forw_ref) {
1525 if (passn == 1) {
1526 for (i = 0; i < output_ins.operands; i++) {
1527 if (output_ins.oprs[i].
1528 opflags & OPFLAG_FORWARD) {
1529 struct forwrefinfo *fwinf =
1530 (struct forwrefinfo *)
1531 saa_wstruct(forwrefs);
1532 fwinf->lineno = globallineno;
1533 fwinf->operand = i;
1534 }
1535 }
1536 }
1537 }
1538 }
1539
1540 /* forw_ref */
1541 if (output_ins.opcode == I_EQU) {
1542 if (pass1 == 1) {
1543 /*
1544 * Special `..' EQUs get processed in pass two,
1545 * except `..@' macro-processor EQUs which are done
1546 * in the normal place.
1547 */
1548 if (!output_ins.label)
1549 report_error(ERR_NONFATAL,
1550 "EQU not preceded by label");
1551
1552 else if (output_ins.label[0] != '.' ||
1553 output_ins.label[1] != '.' ||
1554 output_ins.label[2] == '@') {
1555 if (output_ins.operands == 1 &&
1556 (output_ins.oprs[0].type & IMMEDIATE) &&
1557 output_ins.oprs[0].wrt == NO_SEG) {
1558 bool isext = !!(output_ins.oprs[0].opflags
1559 & OPFLAG_EXTERN);
1560 def_label(output_ins.label,
1561 output_ins.oprs[0].segment,
1562 output_ins.oprs[0].offset, NULL,
1563 false, isext, ofmt,
1564 report_error);
1565 } else if (output_ins.operands == 2
1566 && (output_ins.oprs[0].type & IMMEDIATE)
1567 && (output_ins.oprs[0].type & COLON)
1568 && output_ins.oprs[0].segment == NO_SEG
1569 && output_ins.oprs[0].wrt == NO_SEG
1570 && (output_ins.oprs[1].type & IMMEDIATE)
1571 && output_ins.oprs[1].segment == NO_SEG
1572 && output_ins.oprs[1].wrt == NO_SEG) {
1573 def_label(output_ins.label,
1574 output_ins.oprs[0].offset | SEG_ABS,
1575 output_ins.oprs[1].offset,
1576 NULL, false, false, ofmt,
1577 report_error);
1578 } else
1579 report_error(ERR_NONFATAL,
1580 "bad syntax for EQU");
1581 }
1582 } else {
1583 /*
1584 * Special `..' EQUs get processed here, except
1585 * `..@' macro processor EQUs which are done above.
1586 */
1587 if (output_ins.label[0] == '.' &&
1588 output_ins.label[1] == '.' &&
1589 output_ins.label[2] != '@') {
1590 if (output_ins.operands == 1 &&
1591 (output_ins.oprs[0].type & IMMEDIATE)) {
1592 define_label(output_ins.label,
1593 output_ins.oprs[0].segment,
1594 output_ins.oprs[0].offset,
1595 NULL, false, false, ofmt,
1596 report_error);
1597 } else if (output_ins.operands == 2
1598 && (output_ins.oprs[0].
1599 type & IMMEDIATE)
1600 && (output_ins.oprs[0].type & COLON)
1601 && output_ins.oprs[0].segment ==
1602 NO_SEG
1603 && (output_ins.oprs[1].
1604 type & IMMEDIATE)
1605 && output_ins.oprs[1].segment ==
1606 NO_SEG) {
1607 define_label(output_ins.label,
1608 output_ins.oprs[0].
1609 offset | SEG_ABS,
1610 output_ins.oprs[1].offset,
1611 NULL, false, false, ofmt,
1612 report_error);
1613 } else
1614 report_error(ERR_NONFATAL,
1615 "bad syntax for EQU");
1616 }
1617 }
1618 } else { /* instruction isn't an EQU */
1619
1620 if (pass1 == 1) {
1621
1622 int64_t l = insn_size(location.segment, offs, sb, cpu,
1623 &output_ins, report_error);
1624
1625 /* if (using_debug_info) && output_ins.opcode != -1) */
1626 if (using_debug_info)
1627 { /* fbk 03/25/01 */
1628 /* this is done here so we can do debug type info */
1629 int32_t typeinfo =
1630 TYS_ELEMENTS(output_ins.operands);
1631 switch (output_ins.opcode) {
1632 case I_RESB:
1633 typeinfo =
1634 TYS_ELEMENTS(output_ins.oprs[0].
1635 offset) | TY_BYTE;
1636 break;
1637 case I_RESW:
1638 typeinfo =
1639 TYS_ELEMENTS(output_ins.oprs[0].
1640 offset) | TY_WORD;
1641 break;
1642 case I_RESD:
1643 typeinfo =
1644 TYS_ELEMENTS(output_ins.oprs[0].
1645 offset) | TY_DWORD;
1646 break;
1647 case I_RESQ:
1648 typeinfo =
1649 TYS_ELEMENTS(output_ins.oprs[0].
1650 offset) | TY_QWORD;
1651 break;
1652 case I_REST:
1653 typeinfo =
1654 TYS_ELEMENTS(output_ins.oprs[0].
1655 offset) | TY_TBYTE;
1656 break;
1657 case I_RESO:
1658 typeinfo =
1659 TYS_ELEMENTS(output_ins.oprs[0].
1660 offset) | TY_OWORD;
1661 break;
1662 case I_RESY:
1663 typeinfo =
1664 TYS_ELEMENTS(output_ins.oprs[0].
1665 offset) | TY_YWORD;
1666 break;
1667 case I_DB:
1668 typeinfo |= TY_BYTE;
1669 break;
1670 case I_DW:
1671 typeinfo |= TY_WORD;
1672 break;
1673 case I_DD:
1674 if (output_ins.eops_float)
1675 typeinfo |= TY_FLOAT;
1676 else
1677 typeinfo |= TY_DWORD;
1678 break;
1679 case I_DQ:
1680 typeinfo |= TY_QWORD;
1681 break;
1682 case I_DT:
1683 typeinfo |= TY_TBYTE;
1684 break;
1685 case I_DO:
1686 typeinfo |= TY_OWORD;
1687 break;
1688 case I_DY:
1689 typeinfo |= TY_YWORD;
1690 break;
1691 default:
1692 typeinfo = TY_LABEL;
1693
1694 }
1695
1696 ofmt->current_dfmt->debug_typevalue(typeinfo);
1697
1698 }
1699 if (l != -1) {
1700 offs += l;
1701 SET_CURR_OFFS(offs);
1702 }
1703 /*
1704 * else l == -1 => invalid instruction, which will be
1705 * flagged as an error on pass 2
1706 */
1707
1708 } else {
1709 offs += assemble(location.segment, offs, sb, cpu,
1710 &output_ins, ofmt, report_error,
1711 &nasmlist);
1712 SET_CURR_OFFS(offs);
1713
1714 }
1715 } /* not an EQU */
1716 cleanup_insn(&output_ins);
1717 }
1718 nasm_free(line);
1719 location.offset = offs = GET_CURR_OFFS;
1720 } /* end while (line = preproc->getline... */
1721
1722 if (pass0 == 2 && global_offset_changed && !terminate_after_phase)
1723 report_error(ERR_NONFATAL,
1724 "phase error detected at end of assembly.");
1725
1726 if (pass1 == 1)
1727 preproc->cleanup(1);
1728
1729 if ((passn > 1 && !global_offset_changed) || pass0 == 2) {
1730 pass0++;
1731 } else if (global_offset_changed &&
1732 global_offset_changed < prev_offset_changed) {
1733 prev_offset_changed = global_offset_changed;
1734 stall_count = 0;
1735 } else {
1736 stall_count++;
1737 }
1738
1739 if (terminate_after_phase)
1740 break;
1741
1742 if ((stall_count > 997) || (passn >= pass_max)) {
1743 /* We get here if the labels don't converge
1744 * Example: FOO equ FOO + 1
1745 */
1746 report_error(ERR_NONFATAL,
1747 "Can't find valid values for all labels "
1748 "after %d passes, giving up.", passn);
1749 report_error(ERR_NONFATAL,
1750 "Possible causes: recursive EQUs, macro abuse.");
1751 break;
1752 }
1753 }
1754
1755 preproc->cleanup(0);
1756 nasmlist.cleanup();
1757 if (!terminate_after_phase && opt_verbose_info) {
1758 /* -On and -Ov switches */
1759 fprintf(stdout, "info: assembly required 1+%d+1 passes\n", passn-3);
1760 }
1761 }
1762
1763 static enum directives getkw(char **directive, char **value)
1764 {
1765 char *p, *q, *buf;
1766
1767 buf = *directive;
1768
1769 /* allow leading spaces or tabs */
1770 while (*buf == ' ' || *buf == '\t')
1771 buf++;
1772
1773 if (*buf != '[')
1774 return 0;
1775
1776 p = buf;
1777
1778 while (*p && *p != ']')
1779 p++;
1780
1781 if (!*p)
1782 return 0;
1783
1784 q = p++;
1785
1786 while (*p && *p != ';') {
1787 if (!nasm_isspace(*p))
1788 return 0;
1789 p++;
1790 }
1791 q[1] = '\0';
1792
1793 *directive = p = buf + 1;
1794 while (*buf && *buf != ' ' && *buf != ']' && *buf != '\t')
1795 buf++;
1796 if (*buf == ']') {
1797 *buf = '\0';
1798 *value = buf;
1799 } else {
1800 *buf++ = '\0';
1801 while (nasm_isspace(*buf))
1802 buf++; /* beppu - skip leading whitespace */
1803 *value = buf;
1804 while (*buf != ']')
1805 buf++;
1806 *buf++ = '\0';
1807 }
1808
1809 return bsii(*directive, directives, elements(directives));
1810 }
1811
1812 /**
1813 * gnu style error reporting
1814 * This function prints an error message to error_file in the
1815 * style used by GNU. An example would be:
1816 * file.asm:50: error: blah blah blah
1817 * where file.asm is the name of the file, 50 is the line number on
1818 * which the error occurs (or is detected) and "error:" is one of
1819 * the possible optional diagnostics -- it can be "error" or "warning"
1820 * or something else. Finally the line terminates with the actual
1821 * error message.
1822 *
1823 * @param severity the severity of the warning or error
1824 * @param fmt the printf style format string
1825 */
1826 static void report_error_gnu(int severity, const char *fmt, ...)
1827 {
1828 va_list ap;
1829 char *currentfile = NULL;
1830 int32_t lineno = 0;
1831
1832 if (is_suppressed_warning(severity))
1833 return;
1834
1835 if (!(severity & ERR_NOFILE))
1836 src_get(&lineno, &currentfile);
1837
1838 if (currentfile) {
1839 fprintf(error_file, "%s:%"PRId32": ", currentfile, lineno);
1840 nasm_free(currentfile);
1841 } else {
1842 fputs("nasm: ", error_file);
1843 }
1844
1845 va_start(ap, fmt);
1846 report_error_common(severity, fmt, ap);
1847 va_end(ap);
1848 }
1849
1850 /**
1851 * MS style error reporting
1852 * This function prints an error message to error_file in the
1853 * style used by Visual C and some other Microsoft tools. An example
1854 * would be:
1855 * file.asm(50) : error: blah blah blah
1856 * where file.asm is the name of the file, 50 is the line number on
1857 * which the error occurs (or is detected) and "error:" is one of
1858 * the possible optional diagnostics -- it can be "error" or "warning"
1859 * or something else. Finally the line terminates with the actual
1860 * error message.
1861 *
1862 * @param severity the severity of the warning or error
1863 * @param fmt the printf style format string
1864 */
1865 static void report_error_vc(int severity, const char *fmt, ...)
1866 {
1867 va_list ap;
1868 char *currentfile = NULL;
1869 int32_t lineno = 0;
1870
1871 if (is_suppressed_warning(severity))
1872 return;
1873
1874 if (!(severity & ERR_NOFILE))
1875 src_get(&lineno, &currentfile);
1876
1877 if (currentfile) {
1878 fprintf(error_file, "%s(%"PRId32") : ", currentfile, lineno);
1879 nasm_free(currentfile);
1880 } else {
1881 fputs("nasm: ", error_file);
1882 }
1883
1884 va_start(ap, fmt);
1885 report_error_common(severity, fmt, ap);
1886 va_end(ap);
1887 }
1888
1889 /**
1890 * check for supressed warning
1891 * checks for suppressed warning or pass one only warning and we're
1892 * not in pass 1
1893 *
1894 * @param severity the severity of the warning or error
1895 * @return true if we should abort error/warning printing
1896 */
1897 static bool is_suppressed_warning(int severity)
1898 {
1899 /*
1900 * See if it's a suppressed warning.
1901 */
1902 return (severity & ERR_MASK) == ERR_WARNING &&
1903 (((severity & ERR_WARN_MASK) != 0 &&
1904 !warning_on[(severity & ERR_WARN_MASK) >> ERR_WARN_SHR]) ||
1905 /* See if it's a pass-one only warning and we're not in pass one. */
1906 ((severity & ERR_PASS1) && pass0 != 1) ||
1907 ((severity & ERR_PASS2) && pass0 != 2));
1908 }
1909
1910 /**
1911 * common error reporting
1912 * This is the common back end of the error reporting schemes currently
1913 * implemented. It prints the nature of the warning and then the
1914 * specific error message to error_file and may or may not return. It
1915 * doesn't return if the error severity is a "panic" or "debug" type.
1916 *
1917 * @param severity the severity of the warning or error
1918 * @param fmt the printf style format string
1919 */
1920 static void report_error_common(int severity, const char *fmt,
1921 va_list args)
1922 {
1923 char msg[1024];
1924 const char *pfx;
1925
1926 switch (severity & (ERR_MASK|ERR_NO_SEVERITY)) {
1927 case ERR_WARNING:
1928 pfx = "warning: ";
1929 break;
1930 case ERR_NONFATAL:
1931 pfx = "error: ";
1932 break;
1933 case ERR_FATAL:
1934 pfx = "fatal: ";
1935 break;
1936 case ERR_PANIC:
1937 pfx = "panic: ";
1938 break;
1939 case ERR_DEBUG:
1940 pfx = "debug: ";
1941 break;
1942 default:
1943 pfx = "";
1944 break;
1945 }
1946
1947 vsnprintf(msg, sizeof msg, fmt, args);
1948
1949 fprintf(error_file, "%s%s\n", pfx, msg);
1950
1951 if (*listname)
1952 nasmlist.error(severity, pfx, msg);
1953
1954 if (severity & ERR_USAGE)
1955 want_usage = true;
1956
1957 switch (severity & ERR_MASK) {
1958 case ERR_DEBUG:
1959 /* no further action, by definition */
1960 break;
1961 case ERR_WARNING:
1962 if (warning_on[0]) /* Treat warnings as errors */
1963 terminate_after_phase = true;
1964 break;
1965 case ERR_NONFATAL:
1966 terminate_after_phase = true;
1967 break;
1968 case ERR_FATAL:
1969 if (ofile) {
1970 fclose(ofile);
1971 remove(outname);
1972 }
1973 if (want_usage)
1974 usage();
1975 exit(1); /* instantly die */
1976 break; /* placate silly compilers */
1977 case ERR_PANIC:
1978 fflush(NULL);
1979 /* abort(); *//* halt, catch fire, and dump core */
1980 exit(3);
1981 break;
1982 }
1983 }
1984
1985 static void usage(void)
1986 {
1987 fputs("type `nasm -h' for help\n", error_file);
1988 }
1989
1990 static void register_output_formats(void)
1991 {
1992 ofmt = ofmt_register(report_error);
1993 }
1994
1995 #define BUF_DELTA 512
1996
1997 static FILE *no_pp_fp;
1998 static efunc no_pp_err;
1999 static ListGen *no_pp_list;
2000 static int32_t no_pp_lineinc;
2001
2002 static void no_pp_reset(char *file, int pass, efunc error, evalfunc eval,
2003 ListGen * listgen, StrList **deplist)
2004 {
2005 src_set_fname(nasm_strdup(file));
2006 src_set_linnum(0);
2007 no_pp_lineinc = 1;
2008 no_pp_err = error;
2009 no_pp_fp = fopen(file, "r");
2010 if (!no_pp_fp)
2011 no_pp_err(ERR_FATAL | ERR_NOFILE,
2012 "unable to open input file `%s'", file);
2013 no_pp_list = listgen;
2014 (void)pass; /* placate compilers */
2015 (void)eval; /* placate compilers */
2016
2017 if (deplist) {
2018 StrList *sl = nasm_malloc(strlen(file)+1+sizeof sl->next);
2019 sl->next = NULL;
2020 strcpy(sl->str, file);
2021 *deplist = sl;
2022 }
2023 }
2024
2025 static char *no_pp_getline(void)
2026 {
2027 char *buffer, *p, *q;
2028 int bufsize;
2029
2030 bufsize = BUF_DELTA;
2031 buffer = nasm_malloc(BUF_DELTA);
2032 src_set_linnum(src_get_linnum() + no_pp_lineinc);
2033
2034 while (1) { /* Loop to handle %line */
2035
2036 p = buffer;
2037 while (1) { /* Loop to handle long lines */
2038 q = fgets(p, bufsize - (p - buffer), no_pp_fp);
2039 if (!q)
2040 break;
2041 p += strlen(p);
2042 if (p > buffer && p[-1] == '\n')
2043 break;
2044 if (p - buffer > bufsize - 10) {
2045 int offset;
2046 offset = p - buffer;
2047 bufsize += BUF_DELTA;
2048 buffer = nasm_realloc(buffer, bufsize);
2049 p = buffer + offset;
2050 }
2051 }
2052
2053 if (!q && p == buffer) {
2054 nasm_free(buffer);
2055 return NULL;
2056 }
2057
2058 /*
2059 * Play safe: remove CRs, LFs and any spurious ^Zs, if any of
2060 * them are present at the end of the line.
2061 */
2062 buffer[strcspn(buffer, "\r\n\032")] = '\0';
2063
2064 if (!nasm_strnicmp(buffer, "%line", 5)) {
2065 int32_t ln;
2066 int li;
2067 char *nm = nasm_malloc(strlen(buffer));
2068 if (sscanf(buffer + 5, "%"PRId32"+%d %s", &ln, &li, nm) == 3) {
2069 nasm_free(src_set_fname(nm));
2070 src_set_linnum(ln);
2071 no_pp_lineinc = li;
2072 continue;
2073 }
2074 nasm_free(nm);
2075 }
2076 break;
2077 }
2078
2079 no_pp_list->line(LIST_READ, buffer);
2080
2081 return buffer;
2082 }
2083
2084 static void no_pp_cleanup(int pass)
2085 {
2086 (void)pass; /* placate GCC */
2087 fclose(no_pp_fp);
2088 }
2089
2090 static uint32_t get_cpu(char *value)
2091 {
2092 if (!strcmp(value, "8086"))
2093 return IF_8086;
2094 if (!strcmp(value, "186"))
2095 return IF_186;
2096 if (!strcmp(value, "286"))
2097 return IF_286;
2098 if (!strcmp(value, "386"))
2099 return IF_386;
2100 if (!strcmp(value, "486"))
2101 return IF_486;
2102 if (!strcmp(value, "586") || !nasm_stricmp(value, "pentium"))
2103 return IF_PENT;
2104 if (!strcmp(value, "686") ||
2105 !nasm_stricmp(value, "ppro") ||
2106 !nasm_stricmp(value, "pentiumpro") || !nasm_stricmp(value, "p2"))
2107 return IF_P6;
2108 if (!nasm_stricmp(value, "p3") || !nasm_stricmp(value, "katmai"))
2109 return IF_KATMAI;
2110 if (!nasm_stricmp(value, "p4") || /* is this right? -- jrc */
2111 !nasm_stricmp(value, "willamette"))
2112 return IF_WILLAMETTE;
2113 if (!nasm_stricmp(value, "prescott"))
2114 return IF_PRESCOTT;
2115 if (!nasm_stricmp(value, "x64") ||
2116 !nasm_stricmp(value, "x86-64"))
2117 return IF_X86_64;
2118 if (!nasm_stricmp(value, "ia64") ||
2119 !nasm_stricmp(value, "ia-64") ||
2120 !nasm_stricmp(value, "itanium") ||
2121 !nasm_stricmp(value, "itanic") || !nasm_stricmp(value, "merced"))
2122 return IF_IA64;
2123
2124 report_error(pass0 < 2 ? ERR_NONFATAL : ERR_FATAL,
2125 "unknown 'cpu' type");
2126
2127 return IF_PLEVEL; /* the maximum level */
2128 }
2129
2130 static int get_bits(char *value)
2131 {
2132 int i;
2133
2134 if ((i = atoi(value)) == 16)
2135 return i; /* set for a 16-bit segment */
2136 else if (i == 32) {
2137 if (cpu < IF_386) {
2138 report_error(ERR_NONFATAL,
2139 "cannot specify 32-bit segment on processor below a 386");
2140 i = 16;
2141 }
2142 } else if (i == 64) {
2143 if (cpu < IF_X86_64) {
2144 report_error(ERR_NONFATAL,
2145 "cannot specify 64-bit segment on processor below an x86-64");
2146 i = 16;
2147 }
2148 if (i != maxbits) {
2149 report_error(ERR_NONFATAL,
2150 "%s output format does not support 64-bit code",
2151 ofmt->shortname);
2152 i = 16;
2153 }
2154 } else {
2155 report_error(pass0 < 2 ? ERR_NONFATAL : ERR_FATAL,
2156 "`%s' is not a valid segment size; must be 16, 32 or 64",
2157 value);
2158 i = 16;
2159 }
2160 return i;
2161 }
2162
2163 /* end of nasm.c */
Adding AVX-512 features