nsz Git - libfirm/blob - ir/ir/irmode_t.h

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irmode_t.h
   4  * Purpose:     Data modes of operations -- private header.
   5  * Author:      Martin Trapp, Christian Schaefer
   6  * Modified by: Goetz Lindenmaier, Mathias Heil
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13
  14 /**
  15  * @file irmode_t.h
  16  */
  17
  18 # ifndef _IRMODE_T_H_
  19 # define _IRMODE_T_H_
  20
  21 # include "irmode.h"
  22 # include "tv.h"
  23
  24 /** This struct is supposed to completely define a mode. **/
  25 struct ir_mode {
  26   firm_kind         kind;       /**< distinguishes this node from others */
  27   modecode          code;       /**< unambiguous identifier of a mode */
  28   ident             *name;      /**< Name ident of this mode */
  29
  30   /* ----------------------------------------------------------------------- */
  31   /* On changing this struct you have to evaluate the mode_are_equal function!*/
  32   mode_sort         sort;          /**< coarse classification of this mode:
  33                                      int, float, reference ...
  34                                      (see irmode.h) */
  35   mode_arithmetic   arithmetic;    /**< different arithmetic operations possible with a mode */
  36   int               size;          /**< size of the mode in Bits. */
  37   unsigned          sign:1;        /**< signedness of this mode */
  38   unsigned int      modulo_shift;  /**< number of bits a valus of this mode will be shifted */
  39   unsigned          vector_elem;   /**< if this is not equal 1, this is a vector mode with
  40                                         vector_elem number of elements, size contains the size
  41                                         of all bits and must be dividable by vector_elem */
  42
  43   /* ----------------------------------------------------------------------- */
  44   tarval            *min;       /**< the minimum value that can be expressed */
  45   tarval            *max;       /**< the maximum value that can be expressed */
  46   tarval            *null;      /**< the value 0 */
  47   tarval            *one;       /**< the value 1 */
  48   void              *link;      /**< To store some intermediate information */
  49   const void        *tv_priv;   /**< tarval module will save private data here */
  50 };
  51
  52
  53 /* ------------------------------- *
  54  * inline functions                *
  55  * ------------------------------- */
  56 extern ir_mode *mode_P_mach;
  57
  58 static INLINE ir_mode *
  59 __get_modeP_mach(void) { return mode_P_mach; }
  60
  61 static INLINE void
  62 __set_modeP_mach(ir_mode *p) {
  63   assert(mode_is_reference(p));
  64   mode_P_mach = p;
  65 }
  66
  67 static INLINE modecode
  68 __get_mode_modecode(const ir_mode *mode) { return mode->code; }
  69
  70 static INLINE ident *
  71 __get_mode_ident(const ir_mode *mode) { return mode->name; }
  72
  73 static INLINE mode_sort
  74 __get_mode_sort(const ir_mode* mode) { return mode->sort; }
  75
  76 static INLINE int
  77 __get_mode_size_bits(const ir_mode *mode) { return mode->size; }
  78
  79 static INLINE int
  80 __get_mode_size_bytes(const ir_mode *mode) {
  81   int size = __get_mode_size_bits(mode);
  82   if ((size & 7) != 0) return -1;
  83   return size >> 3;
  84 }
  85
  86 static INLINE int
  87 __get_mode_sign(const ir_mode *mode) { return mode->sign; }
  88
  89 static INLINE int
  90 __get_mode_arithmetic(const ir_mode *mode) { return mode->arithmetic; }
  91
  92 static INLINE unsigned int
  93 __get_mode_modulo_shift(const ir_mode *mode) { return mode->modulo_shift; }
  94
  95 static INLINE unsigned int
  96 __get_mode_vector_elems(const ir_mode *mode) { return mode->vector_elem; }
  97
  98 static INLINE void *
  99 __get_mode_link(const ir_mode *mode) { return mode->link; }
 100
 101 static INLINE void
 102 __set_mode_link(ir_mode *mode, void *l) { mode->link = l; }
 103
 104 /* Functions to check, whether a modecode is signed, float, int, num, data,
 105    datab or dataM. For more exact definitions read the corresponding pages
 106    in the firm documentation or the followingenumeration
 107
 108    The set of "float" is defined as:
 109    ---------------------------------
 110    float = {irm_F, irm_D, irm_E}
 111
 112    The set of "int" is defined as:
 113    -------------------------------
 114    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 115
 116    The set of "num" is defined as:
 117    -------------------------------
 118    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 119             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 120             = {float || int}
 121
 122    The set of "data" is defined as:
 123    -------------------------------
 124    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 125             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
 126             = {num || irm_C || irm_U || irm_P}
 127
 128    The set of "datab" is defined as:
 129    ---------------------------------
 130    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 131             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 132             = {data || irm_b }
 133
 134    The set of "dataM" is defined as:
 135    ---------------------------------
 136    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 137             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 138             = {data || irm_M}
 139 */
 140
 141 static INLINE int
 142 __mode_is_signed(const ir_mode *mode) {
 143   assert(mode);
 144   return mode->sign;
 145 }
 146
 147 static INLINE int
 148 __mode_is_float(const ir_mode *mode) {
 149   assert(mode);
 150   return (__get_mode_sort(mode) == irms_float_number);
 151 }
 152
 153 static INLINE int
 154 __mode_is_int(const ir_mode *mode) {
 155   assert(mode);
 156   return (__get_mode_sort(mode) == irms_int_number);
 157 }
 158
 159 static INLINE int
 160 __mode_is_character(const ir_mode *mode) {
 161   assert(mode);
 162   return (__get_mode_sort(mode) == irms_character);
 163 }
 164
 165 static INLINE int
 166 __mode_is_reference(const ir_mode *mode) {
 167   assert(mode);
 168   return (__get_mode_sort(mode) == irms_reference);
 169 }
 170
 171 static INLINE int
 172 __mode_is_num(const ir_mode *mode) {
 173   assert(mode);
 174   return (__mode_is_int(mode) || __mode_is_float(mode));
 175 }
 176
 177 static INLINE int
 178 __mode_is_numP(const ir_mode *mode) {
 179   assert(mode);
 180   return (__mode_is_int(mode) || __mode_is_float(mode) || __mode_is_reference(mode));
 181 }
 182
 183 static INLINE int
 184 __mode_is_data(const ir_mode *mode) {
 185   assert(mode);
 186   return (__mode_is_num(mode) || __get_mode_sort(mode) == irms_character || __get_mode_sort(mode) == irms_reference);
 187 }
 188
 189 static INLINE int
 190 __mode_is_datab(const ir_mode *mode) {
 191   assert(mode);
 192   return (__mode_is_data(mode) || __get_mode_sort(mode) == irms_internal_boolean);
 193 }
 194
 195 static INLINE int
 196 __mode_is_dataM(const ir_mode *mode) {
 197   assert(mode);
 198   return (__mode_is_data(mode) || __get_mode_modecode(mode) == irm_M);
 199 }
 200
 201 static INLINE int
 202 __mode_is_float_vector(const ir_mode *mode) {
 203   assert(mode);
 204   return (__get_mode_sort(mode) == irms_float_number) && (__get_mode_vector_elems(mode) > 1);
 205 }
 206
 207 static INLINE int
 208 __mode_is_int_vector(const ir_mode *mode) {
 209   assert(mode);
 210   return (__get_mode_sort(mode) == irms_int_number) && (__get_mode_vector_elems(mode) > 1);
 211 }
 212
 213 /** mode module initialization, call once before use of any other function **/
 214 void init_mode(void);
 215
 216 /** mode module finalization. frees all memory.  */
 217 void finish_mode(void);
 218
 219 #define get_modeP_mach()               __get_modeP_mach()
 220 #define set_modeP_mach(p)              __set_modeP_mach(p)
 221 #define get_mode_modecode(mode)        __get_mode_modecode(mode)
 222 #define get_mode_ident(mode)           __get_mode_ident(mode)
 223 #define get_mode_sort(mode)            __get_mode_sort(mode)
 224 #define get_mode_size_bits(mode)       __get_mode_size_bits(mode)
 225 #define get_mode_size_bytes(mode)      __get_mode_size_bytes(mode)
 226 #define get_mode_sign(mode)            __get_mode_sign(mode)
 227 #define get_mode_arithmetic(mode)      __get_mode_arithmetic(mode)
 228 #define get_mode_modulo_shift(mode)    __get_mode_modulo_shift(mode)
 229 #define get_mode_n_vector_elems(mode)  __get_mode_vector_elems(mode)
 230 #define get_mode_link(mode)            __get_mode_link(mode)
 231 #define set_mode_link(mode, l)         __set_mode_link(mode, l)
 232 #define mode_is_signed(mode)           __mode_is_signed(mode)
 233 #define mode_is_float(mode)            __mode_is_float(mode)
 234 #define mode_is_int(mode)              __mode_is_int(mode)
 235 #define mode_is_character(mode)        __mode_is_character(mode)
 236 #define mode_is_reference(mode)        __mode_is_reference(mode)
 237 #define mode_is_num(mode)              __mode_is_num(mode)
 238 #define mode_is_numP(mode)             __mode_is_numP(mode)
 239 #define mode_is_data(mode)             __mode_is_data(mode)
 240 #define mode_is_datab(mode)            __mode_is_datab(mode)
 241 #define mode_is_dataM(mode)            __mode_is_dataM(mode)
 242 #define mode_is_float_vector(mode)     __mode_is_float_vector(mode)
 243 #define mode_is_int_vector(mode)       __mode_is_int_vector(mode)
 244
 245 #endif /* _IRMODE_T_H_ */