iflag.h

   1 #ifndef NASM_IFLAG_H
   2 #define NASM_IFLAG_H
   3
   4
   5 #include <string.h>
   6
   7 #include "compiler.h"
   8
   9 int ilog2_32(uint32_t v);
  10
  11 #include "iflaggen.h"
  12
  13 #define IF_GENBIT(bit)          (UINT32_C(1) << (bit))
  14
  15 static inline unsigned int iflag_test(const iflag_t *f, unsigned int bit)
  16 {
  17     unsigned int index = bit / 32;
  18     return f->field[index] & (UINT32_C(1) << (bit - (index * 32)));
  19 }
  20
  21 static inline void iflag_set(iflag_t *f, unsigned int bit)
  22 {
  23     unsigned int index = bit / 32;
  24     f->field[index] |= (UINT32_C(1) << (bit - (index * 32)));
  25 }
  26
  27 static inline void iflag_clear(iflag_t *f, unsigned int bit)
  28 {
  29     unsigned int index = bit / 32;
  30     f->field[index] &= ~(UINT32_C(1) << (bit - (index * 32)));
  31 }
  32
  33 static inline void iflag_clear_all(iflag_t *f)
  34 {
  35      memset(f, 0, sizeof(*f));
  36 }
  37
  38 static inline void iflag_set_all(iflag_t *f)
  39 {
  40      memset(f, 0xff, sizeof(*f));
  41 }
  42
  43 static inline int iflag_cmp(const iflag_t *a, const iflag_t *b)
  44 {
  45     int i;
  46
  47     for (i = sizeof(a->field) / sizeof(a->field[0]) - 1; i >= 0; i--) {
  48         if (a->field[i] == b->field[i])
  49             continue;
  50
  51         return (a->field[i] > b->field[i]) ? 1 : -1;
  52     }
  53
  54     return 0;
  55 }
  56
  57 static inline int iflag_cmp_cpu(const iflag_t *a, const iflag_t *b)
  58 {
  59     if (a->field[3] < b->field[3])
  60         return -1;
  61     else if (a->field[3] > b->field[3])
  62         return 1;
  63     return 0;
  64 }
  65
  66 static inline unsigned int iflag_ffs(const iflag_t *a)
  67 {
  68     unsigned int i;
  69
  70     for (i = 0; i < sizeof(a->field) / sizeof(a->field[0]); i++) {
  71         if (a->field[i])
  72             return ilog2_32(a->field[i]) + (i * 32);
  73     }
  74
  75     return 0;
  76 }
  77
  78 #define IF_GEN_HELPER(name, op)                                         \
  79     static inline iflag_t iflag_##name(const iflag_t *a, const iflag_t *b) \
  80     {                                                                   \
  81         unsigned int i;                                                 \
  82         iflag_t res;                                                    \
  83                                                                         \
  84         for (i = 0; i < sizeof(a->field) / sizeof(a->field[0]); i++)    \
  85             res.field[i] = a->field[i] op b->field[i];                  \
  86                                                                         \
  87         return res;                                                     \
  88     }
  89
  90 IF_GEN_HELPER(xor, ^)
  91
  92
  93 /* Use this helper to test instruction template flags */
  94 #define itemp_has(itemp, bit)   iflag_test(&insns_flags[(itemp)->iflag_idx], bit)
  95
  96
  97 /* Maximum processor level at moment */
  98 #define IF_PLEVEL               IF_IA64
  99 /* Some helpers which are to work with predefined masks */
 100 #define IF_SMASK        \
 101     (IF_GENBIT(IF_SB)  |\
 102      IF_GENBIT(IF_SW)  |\
 103      IF_GENBIT(IF_SD)  |\
 104      IF_GENBIT(IF_SQ)  |\
 105      IF_GENBIT(IF_SO)  |\
 106      IF_GENBIT(IF_SY)  |\
 107      IF_GENBIT(IF_SZ)  |\
 108      IF_GENBIT(IF_SIZE))
 109 #define IF_ARMASK       \
 110     (IF_GENBIT(IF_AR0) |\
 111      IF_GENBIT(IF_AR1) |\
 112      IF_GENBIT(IF_AR2) |\
 113      IF_GENBIT(IF_AR3) |\
 114      IF_GENBIT(IF_AR4))
 115
 116 #define _itemp_smask(idx)      (insns_flags[(idx)].field[0] & IF_SMASK)
 117 #define _itemp_armask(idx)     (insns_flags[(idx)].field[0] & IF_ARMASK)
 118 #define _itemp_arg(idx)        ((_itemp_armask(idx) >> IF_AR0) - 1)
 119
 120 #define itemp_smask(itemp)      _itemp_smask((itemp)->iflag_idx)
 121 #define itemp_arg(itemp)        _itemp_arg((itemp)->iflag_idx)
 122 #define itemp_armask(itemp)     _itemp_armask((itemp)->iflag_idx)
 123
 124 static inline int iflag_cmp_cpu_level(const iflag_t *a, const iflag_t *b)
 125 {
 126     iflag_t v1 = *a;
 127     iflag_t v2 = *b;
 128
 129     iflag_clear(&v1, IF_CYRIX);
 130     iflag_clear(&v1, IF_AMD);
 131
 132     iflag_clear(&v2, IF_CYRIX);
 133     iflag_clear(&v2, IF_AMD);
 134
 135     if (v1.field[3] < v2.field[3])
 136         return -1;
 137     else if (v1.field[3] > v2.field[3])
 138         return 1;
 139
 140     return 0;
 141 }
 142
 143 static inline iflag_t _iflag_pfmask(const iflag_t *a)
 144 {
 145     iflag_t r;
 146
 147     iflag_clear_all(&r);
 148
 149     if (iflag_test(a, IF_CYRIX))
 150         iflag_set(&r, IF_CYRIX);
 151     if (iflag_test(a, IF_AMD))
 152         iflag_set(&r, IF_AMD);
 153
 154     return r;
 155 }
 156
 157 #define iflag_pfmask(itemp)     _iflag_pfmask(&insns_flags[(itemp)->iflag_idx])
 158
 159 #endif /* NASM_IFLAG_H */