asm/pragma.c

   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|ERR_WARN_BAD_PRAGMA,
 150                        "empty %%pragma %s", pragma->facility_name);
 151             break;
 152         default:
 153             nasm_error(ERR_WARNING|ERR_PASS2|ERR_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|ERR_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 }