include/iflag.h

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