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