asm/pragma.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2017 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 /*
  53  * Handle [pragma] directives.  [pragma] is generally produced by
  54  * the %pragma preprocessor directive, which simply passes on any
  55  * string that it finds *except* %pragma preproc.  The idea is
  56  * that pragmas are of the form:
  57  *
  58  * %pragma <facility> <opname> [<options>...]
  59  *
  60  * ... where "facility" can be either a generic facility or a backend
  61  * name.
  62  *
  63  * The following names are currently reserved for global facilities;
  64  * so far none of these have any defined pragmas at all:
  65  *
  66  * preproc      - preprocessor
  67  * asm          - assembler
  68  * list         - listing generator
  69  * file         - generic file handling
  70  * input        - input file handling
  71  * output       - backend-independent output handling
  72  * debug        - backend-independent debug handling
  73  * ignore       - dummy pragma (can be used to "comment out")
  74  *
  75  * This function should generally not error out if it doesn't understand
  76  * what a pragma is for, for unknown arguments, etc; the whole point of
  77  * a pragma is that future releases might add new ones that should be
  78  * ignored rather than be an error.  Erroring out is acceptable for
  79  * known pragmas suffering from parsing errors and so on.
  80  *
  81  * Adding default-suppressed warnings would, however, be a good idea
  82  * at some point.
  83  */
  84 static struct pragma_facility global_pragmas[] =
  85 {
  86     { "preproc",        NULL }, /* This shouldn't happen... */
  87     { "asm",            NULL },
  88     { "list",           NULL },
  89     { "file",           NULL },
  90     { "input",          NULL },
  91     { "output",         NULL },
  92     { "debug",          NULL },
  93     { "ignore",         NULL },
  94     { NULL, NULL }
  95 };
  96
  97 /*
  98  * Search a pragma list for a known pragma facility and if so, invoke
  99  * the handler.  Return true if processing is complete.
 100  * The "default name", if set, matches the final NULL entry (used
 101  * for backends, so multiple backends can share the same list under
 102  * some circumstances.)
 103  */
 104 static bool search_pragma_list(const struct pragma_facility *list,
 105                                const char *default_name,
 106                                struct pragma *pragma)
 107 {
 108     const struct pragma_facility *pf;
 109     enum directive_result rv;
 110
 111     if (!list)
 112         return false;
 113
 114     for (pf = list; pf->name; pf++) {
 115         if (!nasm_stricmp(pragma->facility_name, pf->name))
 116             goto found_it;
 117     }
 118
 119     if (default_name && !nasm_stricmp(pragma->facility_name, default_name))
 120         goto found_it;
 121
 122     return false;
 123
 124 found_it:
 125     pragma->facility = pf;
 126
 127     /* If the handler is NULL all pragmas are unknown... */
 128     if (pf->handler)
 129         rv = pf->handler(pragma);
 130     else
 131         rv = DIRR_UNKNOWN;
 132
 133     switch (rv) {
 134     case DIRR_UNKNOWN:
 135         switch (pragma->opcode) {
 136         case D_none:
 137             nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
 138                        "empty %%pragma %s", pragma->facility_name);
 139             break;
 140         default:
 141             nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_UNKNOWN_PRAGMA,
 142                        "unknown %%pragma %s %s",
 143                        pragma->facility_name, pragma->opname);
 144             break;
 145         }
 146         break;
 147
 148     case DIRR_OK:
 149     case DIRR_ERROR:
 150         break;                  /* Nothing to do */
 151
 152     case DIRR_BADPARAM:
 153         /*
 154          * This one is an error.  Don't use it if forward compatibility
 155          * would be compromised, as opposed to an inherent error.
 156          */
 157         nasm_error(ERR_NONFATAL, "bad argument to %%pragma %s %s",
 158                    pragma->facility_name, pragma->opname);
 159         break;
 160
 161     default:
 162         panic();
 163     }
 164     return true;
 165 }
 166
 167 void process_pragma(char *str)
 168 {
 169     struct pragma pragma;
 170     char *p;
 171
 172     nasm_zero(pragma);
 173
 174     pragma.facility_name = nasm_get_word(str, &p);
 175     if (!pragma.facility_name) {
 176         nasm_error(ERR_WARNING|ERR_PASS2|ERR_WARN_BAD_PRAGMA,
 177                    "empty pragma directive");
 178         return;                 /* Empty pragma */
 179     }
 180
 181     /*
 182      * The facility "ignore" means just that; don't even complain of
 183      * the absence of an operation.
 184      */
 185     if (!nasm_stricmp(pragma.facility_name, "ignore"))
 186         return;
 187
 188     pragma.opname = nasm_get_word(p, &p);
 189     if (!pragma.opname)
 190         pragma.opcode = D_none;
 191     else
 192         pragma.opcode = directive_find(pragma.opname);
 193
 194     pragma.tail = nasm_skip_spaces(p);
 195
 196     /* Look for a global pragma namespace */
 197     if (search_pragma_list(global_pragmas, NULL, &pragma))
 198         return;
 199
 200     /* Look to see if it is an output backend pragma */
 201     if (search_pragma_list(ofmt->pragmas, ofmt->shortname, &pragma))
 202         return;
 203
 204     /* Look to see if it is a debug format pragma */
 205     if (search_pragma_list(dfmt->pragmas, dfmt->shortname, &pragma))
 206         return;
 207
 208     /*
 209      * Note: it would be nice to warn for an unknown namespace,
 210      * but in order to do so we need to walk *ALL* the backends
 211      * in order to make sure we aren't dealing with a pragma that
 212      * is for another backend.  On the other hand, that could
 213      * also be a warning with a separate warning flag.
 214      *
 215      * Leave this for the future, however, the warning classes are
 216      * already defined for future compatibility.
 217      */
 218 }