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 | |
52 | static enum directive_result output_pragma(const struct pragma *pragma); |
53 | static 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 | */ |
88 | static 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 | */ |
111 | static 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 | |
132 | found_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 | |
179 | void 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 | */ |
246 | static 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 | */ |
271 | static enum directive_result limit_pragma(const struct pragma *pragma) |
272 | { |
273 | return nasm_set_limit(pragma->opname, pragma->tail); |
274 | } |
275 | |