1/* ----------------------------------------------------------------------- *
2 *
3 * Copyright 1996-2018 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 * Parse and handle [pragma] directives. The preprocessor handles
36 * %pragma preproc directives separately, all other namespaces are
37 * simply converted to [pragma].
38 */
39
40#include "compiler.h"
41
42#include <stdlib.h>
43#include <string.h>
44#include <ctype.h>
45#include <limits.h>
46
47#include "nasm.h"
48#include "nasmlib.h"
49#include "assemble.h"
50#include "error.h"
51
52static enum directive_result output_pragma(const struct pragma *pragma);
53static enum directive_result limit_pragma(const struct pragma *pragma);
54
55/*
56 * Handle [pragma] directives. [pragma] is generally produced by
57 * the %pragma preprocessor directive, which simply passes on any
58 * string that it finds *except* %pragma preproc. The idea is
59 * that pragmas are of the form:
60 *
61 * %pragma <facility> <opname> [<options>...]
62 *
63 * ... where "facility" can be either a generic facility or a backend
64 * name.
65 *
66 * The following names are currently reserved for global facilities;
67 * so far none of these have any defined pragmas at all:
68 *
69 * preproc - preprocessor
70 * limit - limit setting
71 * asm - assembler
72 * list - listing generator
73 * file - generic file handling
74 * input - input file handling
75 * output - backend-independent output handling
76 * debug - backend-independent debug handling
77 * ignore - dummy pragma (can be used to "comment out")
78 *
79 * This function should generally not error out if it doesn't understand
80 * what a pragma is for, for unknown arguments, etc; the whole point of
81 * a pragma is that future releases might add new ones that should be
82 * ignored rather than be an error. Erroring out is acceptable for
83 * known pragmas suffering from parsing errors and so on.
84 *
85 * Adding default-suppressed warnings would, however, be a good idea
86 * at some point.
87 */
88static struct pragma_facility global_pragmas[] =
89{
90 { "asm", NULL },
91 { "limit", limit_pragma },
92 { "list", NULL },
93 { "file", NULL },
94 { "input", NULL },
95
96 /* None of these should actually happen due to special handling */
97 { "preproc", NULL }, /* Handled in the preprocessor by necessity */
98 { "output", NULL },
99 { "debug", NULL },
100 { "ignore", NULL },
101 { NULL, NULL }
102};
103
104/*
105 * Search a pragma list for a known pragma facility and if so, invoke
106 * the handler. Return true if processing is complete.
107 * The "default name", if set, matches the final NULL entry (used
108 * for backends, so multiple backends can share the same list under
109 * some circumstances.)
110 */
111static bool search_pragma_list(const struct pragma_facility *list,
112 const char *default_name,
113 pragma_handler generic_handler,
114 struct pragma *pragma)
115{
116 const struct pragma_facility *pf;
117 enum directive_result rv;
118
119 if (!list)
120 return false;
121
122 for (pf = list; pf->name; pf++) {
123 if (!nasm_stricmp(pragma->facility_name, pf->name))
124 goto found_it;
125 }
126
127 if (default_name && !nasm_stricmp(pragma->facility_name, default_name))
128 goto found_it;
129
130 return false;
131
132found_it:
133 pragma->facility = pf;
134
135 /* If the handler is NULL all pragmas are unknown... */
136 if (pf->handler)
137 rv = pf->handler(pragma);
138 else
139 rv = DIRR_UNKNOWN;
140
141 /* Is there an additional, applicable generic handler? */
142 if (rv == DIRR_UNKNOWN && generic_handler)
143 rv = generic_handler(pragma);
144
145 switch (rv) {
146 case DIRR_UNKNOWN:
147 switch (pragma->opcode) {
148 case D_none:
149 nasm_error(ERR_WARNING|ERR_PASS2|WARN_BAD_PRAGMA,
150 "empty %%pragma %s", pragma->facility_name);
151 break;
152 default:
153 nasm_error(ERR_WARNING|ERR_PASS2|WARN_UNKNOWN_PRAGMA,
154 "unknown %%pragma %s %s",
155 pragma->facility_name, pragma->opname);
156 break;
157 }
158 break;
159
160 case DIRR_OK:
161 case DIRR_ERROR:
162 break; /* Nothing to do */
163
164 case DIRR_BADPARAM:
165 /*
166 * This one is an error. Don't use it if forward compatibility
167 * would be compromised, as opposed to an inherent error.
168 */
169 nasm_error(ERR_NONFATAL, "bad argument to %%pragma %s %s",
170 pragma->facility_name, pragma->opname);
171 break;
172
173 default:
174 panic();
175 }
176 return true;
177}
178
179void process_pragma(char *str)
180{
181 struct pragma pragma;
182 char *p;
183
184 nasm_zero(pragma);
185
186 pragma.facility_name = nasm_get_word(str, &p);
187 if (!pragma.facility_name) {
188 nasm_error(ERR_WARNING|ERR_PASS2|WARN_BAD_PRAGMA,
189 "empty pragma directive");
190 return; /* Empty pragma */
191 }
192
193 /*
194 * The facility "ignore" means just that; don't even complain of
195 * the absence of an operation.
196 */
197 if (!nasm_stricmp(pragma.facility_name, "ignore"))
198 return;
199
200 /*
201 * The "output" and "debug" facilities are aliases for the
202 * current output and debug formats, respectively.
203 */
204 if (!nasm_stricmp(pragma.facility_name, "output"))
205 pragma.facility_name = ofmt->shortname;
206 if (!nasm_stricmp(pragma.facility_name, "debug"))
207 pragma.facility_name = dfmt->shortname;
208
209 pragma.opname = nasm_get_word(p, &p);
210 if (!pragma.opname)
211 pragma.opcode = D_none;
212 else
213 pragma.opcode = directive_find(pragma.opname);
214
215 pragma.tail = nasm_trim_spaces(p);
216
217 /* Look for a global pragma namespace */
218 if (search_pragma_list(global_pragmas, NULL, NULL, &pragma))
219 return;
220
221 /* Look to see if it is an output backend pragma */
222 if (search_pragma_list(ofmt->pragmas, ofmt->shortname,
223 output_pragma, &pragma))
224 return;
225
226 /* Look to see if it is a debug format pragma */
227 if (search_pragma_list(dfmt->pragmas, dfmt->shortname, NULL, &pragma))
228 return;
229
230 /*
231 * Note: it would be nice to warn for an unknown namespace,
232 * but in order to do so we need to walk *ALL* the backends
233 * in order to make sure we aren't dealing with a pragma that
234 * is for another backend. On the other hand, that could
235 * also be a warning with a separate warning flag.
236 *
237 * Leave this for the future, however, the warning classes are
238 * already defined for future compatibility.
239 */
240}
241
242/*
243 * Generic pragmas that apply to all output backends; these are handled
244 * specially so they can be made selective based on the output format.
245 */
246static enum directive_result output_pragma(const struct pragma *pragma)
247{
248 switch (pragma->opcode) {
249 case D_PREFIX:
250 case D_GPREFIX:
251 set_label_mangle(LM_GPREFIX, pragma->tail);
252 return DIRR_OK;
253 case D_SUFFIX:
254 case D_GSUFFIX:
255 set_label_mangle(LM_GSUFFIX, pragma->tail);
256 return DIRR_OK;
257 case D_LPREFIX:
258 set_label_mangle(LM_LPREFIX, pragma->tail);
259 return DIRR_OK;
260 case D_LSUFFIX:
261 set_label_mangle(LM_LSUFFIX, pragma->tail);
262 return DIRR_OK;
263 default:
264 return DIRR_UNKNOWN;
265 }
266}
267
268/*
269 * %pragma limit to set resource limits
270 */
271static enum directive_result limit_pragma(const struct pragma *pragma)
272{
273 return nasm_set_limit(pragma->opname, pragma->tail);
274}
275