opflags.h

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 1996-2012 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  * opflags.h - operand flags
  36  */
  37
  38 #ifndef NASM_OPFLAGS_H
  39 #define NASM_OPFLAGS_H
  40
  41 #include "compiler.h"
  42
  43 /*
  44  * Here we define the operand types. These are implemented as bit
  45  * masks, since some are subsets of others; e.g. AX in a MOV
  46  * instruction is a special operand type, whereas AX in other
  47  * contexts is just another 16-bit register. (Also, consider CL in
  48  * shift instructions, DX in OUT, etc.)
  49  *
  50  * The basic concept here is that
  51  *    (class & ~operand) == 0
  52  *
  53  * if and only if "operand" belongs to class type "class".
  54  */
  55
  56 typedef uint64_t opflags_t;
  57
  58 #define OP_GENMASK(bits, shift)         (((UINT64_C(1) << (bits)) - 1) << (shift))
  59 #define OP_GENBIT(bit, shift)           (UINT64_C(1) << ((shift) + (bit)))
  60
  61 /*
  62  * Type of operand: memory reference, register, etc.
  63  *
  64  * Bits: 0 - 3
  65  */
  66 #define OPTYPE_SHIFT            (0)
  67 #define OPTYPE_BITS             (4)
  68 #define OPTYPE_MASK             OP_GENMASK(OPTYPE_BITS, OPTYPE_SHIFT)
  69 #define GEN_OPTYPE(bit)         OP_GENBIT(bit, OPTYPE_SHIFT)
  70
  71 /*
  72  * Modifiers.
  73  *
  74  * Bits: 4 - 6
  75  */
  76 #define MODIFIER_SHIFT          (4)
  77 #define MODIFIER_BITS           (3)
  78 #define MODIFIER_MASK           OP_GENMASK(MODIFIER_BITS, MODIFIER_SHIFT)
  79 #define GEN_MODIFIER(bit)       OP_GENBIT(bit, MODIFIER_SHIFT)
  80
  81 /*
  82  * Register classes.
  83  *
  84  * Bits: 7 - 16
  85  */
  86 #define REG_CLASS_SHIFT         (7)
  87 #define REG_CLASS_BITS          (10)
  88 #define REG_CLASS_MASK          OP_GENMASK(REG_CLASS_BITS, REG_CLASS_SHIFT)
  89 #define GEN_REG_CLASS(bit)      OP_GENBIT(bit, REG_CLASS_SHIFT)
  90
  91 /*
  92  * Subclasses. Depends on type of operand.
  93  *
  94  * Bits: 17 - 24
  95  */
  96 #define SUBCLASS_SHIFT          (17)
  97 #define SUBCLASS_BITS           (8)
  98 #define SUBCLASS_MASK           OP_GENMASK(SUBCLASS_BITS, SUBCLASS_SHIFT)
  99 #define GEN_SUBCLASS(bit)       OP_GENBIT(bit, SUBCLASS_SHIFT)
 100
 101 /*
 102  * Special flags. Context dependant.
 103  *
 104  * Bits: 25 - 31
 105  */
 106 #define SPECIAL_SHIFT           (25)
 107 #define SPECIAL_BITS            (7)
 108 #define SPECIAL_MASK            OP_GENMASK(SPECIAL_BITS, SPECIAL_SHIFT)
 109 #define GEN_SPECIAL(bit)        OP_GENBIT(bit, SPECIAL_SHIFT)
 110
 111 /*
 112  * Sizes of the operands and attributes.
 113  *
 114  * Bits: 32 - 42
 115  */
 116 #define SIZE_SHIFT              (32)
 117 #define SIZE_BITS               (11)
 118 #define SIZE_MASK               OP_GENMASK(SIZE_BITS, SIZE_SHIFT)
 119 #define GEN_SIZE(bit)           OP_GENBIT(bit, SIZE_SHIFT)
 120
 121 /*
 122  * Bits distribution (counted from 0)
 123  *
 124  *    6         5         4         3         2         1
 125  * 3210987654321098765432109876543210987654321098765432109876543210
 126  *                                 |
 127  *                                 | dword bound
 128  *
 129  * ............................................................1111 optypes
 130  * .........................................................111.... modifiers
 131  * ...............................................1111111111....... register classes
 132  * .......................................11111111................. subclasses
 133  * ................................1111111......................... specials
 134  * .....................11111111111................................ sizes
 135  */
 136
 137 #define REGISTER                GEN_OPTYPE(0)                   /* register number in 'basereg' */
 138 #define IMMEDIATE               GEN_OPTYPE(1)
 139 #define REGMEM                  GEN_OPTYPE(2)                   /* for r/m, ie EA, operands */
 140 #define MEMORY                  (GEN_OPTYPE(3) | REGMEM)
 141
 142 #define BITS8                   GEN_SIZE(0)                     /*   8 bits (BYTE) */
 143 #define BITS16                  GEN_SIZE(1)                     /*  16 bits (WORD) */
 144 #define BITS32                  GEN_SIZE(2)                     /*  32 bits (DWORD) */
 145 #define BITS64                  GEN_SIZE(3)                     /*  64 bits (QWORD), x64 and FPU only */
 146 #define BITS80                  GEN_SIZE(4)                     /*  80 bits (TWORD), FPU only */
 147 #define BITS128                 GEN_SIZE(5)                     /* 128 bits (OWORD) */
 148 #define BITS256                 GEN_SIZE(6)                     /* 256 bits (YWORD) */
 149 #define BITS512                 GEN_SIZE(7)                     /* 512 bits (ZWORD) */
 150 #define FAR                     GEN_SIZE(8)                     /* grotty: this means 16:16 or 16:32, like in CALL/JMP */
 151 #define NEAR                    GEN_SIZE(9)
 152 #define SHORT                   GEN_SIZE(10)                    /* and this means what it says :) */
 153
 154 #define TO                      GEN_MODIFIER(0)                 /* reverse effect in FADD, FSUB &c */
 155 #define COLON                   GEN_MODIFIER(1)                 /* operand is followed by a colon */
 156 #define STRICT                  GEN_MODIFIER(2)                 /* do not optimize this operand */
 157
 158 #define REG_CLASS_CDT           GEN_REG_CLASS(0)
 159 #define REG_CLASS_GPR           GEN_REG_CLASS(1)
 160 #define REG_CLASS_SREG          GEN_REG_CLASS(2)
 161 #define REG_CLASS_FPUREG        GEN_REG_CLASS(3)
 162 #define REG_CLASS_RM_MMX        GEN_REG_CLASS(4)
 163 #define REG_CLASS_RM_XMM        GEN_REG_CLASS(5)
 164 #define REG_CLASS_RM_YMM        GEN_REG_CLASS(6)
 165
 166 #define is_class(class, op)     (!((opflags_t)(class) & ~(opflags_t)(op)))
 167
 168 #define IS_SREG(op)             is_class(REG_SREG, nasm_reg_flags[(op)])
 169 #define IS_FSGS(op)             is_class(REG_FSGS, nasm_reg_flags[(op)])
 170
 171 /* Register classes */
 172 #define REG_EA                  (                                               REGMEM | REGISTER)      /* 'normal' reg, qualifies as EA */
 173 #define RM_GPR                  (                  REG_CLASS_GPR              | REGMEM)                 /* integer operand */
 174 #define REG_GPR                 (                  REG_CLASS_GPR              | REGMEM | REGISTER)      /* integer register */
 175 #define REG8                    (                  REG_CLASS_GPR    | BITS8   | REGMEM | REGISTER)      /*  8-bit GPR  */
 176 #define REG16                   (                  REG_CLASS_GPR    | BITS16  | REGMEM | REGISTER)      /* 16-bit GPR */
 177 #define REG32                   (                  REG_CLASS_GPR    | BITS32  | REGMEM | REGISTER)      /* 32-bit GPR */
 178 #define REG64                   (                  REG_CLASS_GPR    | BITS64  | REGMEM | REGISTER)      /* 64-bit GPR */
 179 #define FPUREG                  (                  REG_CLASS_FPUREG                    | REGISTER)      /* floating point stack registers */
 180 #define FPU0                    (GEN_SUBCLASS(1) | REG_CLASS_FPUREG                    | REGISTER)      /* FPU stack register zero */
 181 #define RM_MMX                  (                  REG_CLASS_RM_MMX           | REGMEM)                 /* MMX operand */
 182 #define MMXREG                  (                  REG_CLASS_RM_MMX           | REGMEM | REGISTER)      /* MMX register */
 183 #define RM_XMM                  (                  REG_CLASS_RM_XMM           | REGMEM)                 /* XMM (SSE) operand */
 184 #define XMMREG                  (                  REG_CLASS_RM_XMM           | REGMEM | REGISTER)      /* XMM (SSE) register */
 185 #define XMM0                    (GEN_SUBCLASS(1) | REG_CLASS_RM_XMM           | REGMEM | REGISTER)      /* XMM register zero */
 186 #define RM_YMM                  (                  REG_CLASS_RM_YMM           | REGMEM)                 /* YMM (AVX) operand */
 187 #define YMMREG                  (                  REG_CLASS_RM_YMM           | REGMEM | REGISTER)      /* YMM (AVX) register */
 188 #define YMM0                    (GEN_SUBCLASS(1) | REG_CLASS_RM_YMM           | REGMEM | REGISTER)      /* YMM register zero */
 189 #define REG_CDT                 (                  REG_CLASS_CDT    | BITS32           | REGISTER)      /* CRn, DRn and TRn */
 190 #define REG_CREG                (GEN_SUBCLASS(1) | REG_CLASS_CDT    | BITS32           | REGISTER)      /* CRn */
 191 #define REG_DREG                (GEN_SUBCLASS(2) | REG_CLASS_CDT    | BITS32           | REGISTER)      /* DRn */
 192 #define REG_TREG                (GEN_SUBCLASS(3) | REG_CLASS_CDT    | BITS32           | REGISTER)      /* TRn */
 193 #define REG_SREG                (                  REG_CLASS_SREG   | BITS16           | REGISTER)      /* any segment register */
 194 #define REG_CS                  (GEN_SUBCLASS(1) | REG_CLASS_SREG   | BITS16           | REGISTER)      /* CS */
 195 #define REG_DESS                (GEN_SUBCLASS(2) | REG_CLASS_SREG   | BITS16           | REGISTER)      /* DS, ES, SS */
 196 #define REG_FSGS                (GEN_SUBCLASS(3) | REG_CLASS_SREG   | BITS16           | REGISTER)      /* FS, GS */
 197 #define REG_SEG67               (GEN_SUBCLASS(4) | REG_CLASS_SREG   | BITS16           | REGISTER)      /* Unimplemented segment registers */
 198
 199 /* Special GPRs */
 200 #define REG_SMASK               SUBCLASS_MASK                                                                           /* a mask for the following */
 201 #define REG_ACCUM               (GEN_SUBCLASS(1)                   | REG_CLASS_GPR           | REGMEM | REGISTER)       /* accumulator: AL, AX, EAX, RAX */
 202 #define REG_AL                  (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)
 203 #define REG_AX                  (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)
 204 #define REG_EAX                 (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)
 205 #define REG_RAX                 (GEN_SUBCLASS(1)                   | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)
 206 #define REG_COUNT               (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR           | REGMEM | REGISTER)       /* counter: CL, CX, ECX, RCX */
 207 #define REG_CL                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)
 208 #define REG_CX                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)
 209 #define REG_ECX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)
 210 #define REG_RCX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(2) | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)
 211 #define REG_DL                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)       /* data: DL, DX, EDX, RDX */
 212 #define REG_DX                  (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)
 213 #define REG_EDX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)
 214 #define REG_RDX                 (GEN_SUBCLASS(5) | GEN_SUBCLASS(3) | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)
 215 #define REG_HIGH                (GEN_SUBCLASS(5) | GEN_SUBCLASS(4) | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)       /* high regs: AH, CH, DH, BH */
 216 #define REG_NOTACC              GEN_SUBCLASS(5)                                                                         /* non-accumulator register */
 217 #define REG8NA                  (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS8   | REGMEM | REGISTER)       /*  8-bit non-acc GPR  */
 218 #define REG16NA                 (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS16  | REGMEM | REGISTER)       /* 16-bit non-acc GPR */
 219 #define REG32NA                 (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS32  | REGMEM | REGISTER)       /* 32-bit non-acc GPR */
 220 #define REG64NA                 (GEN_SUBCLASS(5)                   | REG_CLASS_GPR | BITS64  | REGMEM | REGISTER)       /* 64-bit non-acc GPR */
 221
 222 /* special types of EAs */
 223 #define MEM_OFFS                (GEN_SUBCLASS(1) | MEMORY)      /* simple [address] offset - absolute! */
 224 #define IP_REL                  (GEN_SUBCLASS(2) | MEMORY)      /* IP-relative offset */
 225
 226 /* memory which matches any type of r/m operand */
 227 #define MEMORY_ANY              (MEMORY | RM_GPR | RM_MMX | RM_XMM | RM_YMM)
 228
 229 /* special type of immediate operand */
 230 #define UNITY                   (GEN_SUBCLASS(1) | IMMEDIATE)   /* for shift/rotate instructions */
 231 #define SBYTE16                 (GEN_SUBCLASS(2) | IMMEDIATE)   /* for op r16,immediate instrs. */
 232 #define SBYTE32                 (GEN_SUBCLASS(3) | IMMEDIATE)   /* for op r32,immediate instrs. */
 233 #define SBYTE64                 (GEN_SUBCLASS(4) | IMMEDIATE)   /* for op r64,immediate instrs. */
 234 #define SDWORD64                (GEN_SUBCLASS(5) | IMMEDIATE)   /* for op r64,simm32 instrs. */
 235 #define UDWORD64                (GEN_SUBCLASS(0) | IMMEDIATE)   /* for op r64,uimm32 instrs. */
 236
 237 #define BYTENESS                (GEN_SUBCLASS(2) | \
 238                                  GEN_SUBCLASS(3) | \
 239                                  GEN_SUBCLASS(4))               /* for testing for byteness */
 240
 241 /* special flags */
 242 #define SAME_AS                 GEN_SPECIAL(0)
 243
 244 #endif /* NASM_OPFLAGS_H */