nsz Git - libfirm/blob - include/libfirm/irmode.h

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Data modes of operations.
  23  * @author  Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Mathias Heil,
  24  *          Michael Beck
  25  */
  26 #ifndef FIRM_IR_IRMODE_H
  27 #define FIRM_IR_IRMODE_H
  28
  29 #include "firm_types.h"
  30 #include "begin.h"
  31
  32 /**
  33  * @defgroup ir_mode Value Modes
  34  *  This module specifies the modes that type the firm nodes.  It defines
  35  *  a datasturcture that describes a mode and implements constructors and
  36  *  access routines to this datastructure. Further it defines a set of
  37  *  predefined modes.
  38  *
  39  *  SEE ALSO:
  40  *    UKA tech report 1999-44 for more information about modes.
  41  * @{
  42  */
  43
  44 /**
  45  * These values represent the different arithmetic operations possible with a
  46  * mode.
  47  */
  48 typedef enum ir_mode_arithmetic {
  49         irma_uninitialized = 0,
  50         irma_none = 1,            /**< For modes for which no representation is
  51                                        specified. These are modes of sort auxiliary,
  52                                        internal_boolean and character. */
  53         irma_twos_complement = 2, /**< Values of the mode are represented as two's
  54                                        complement. Only legal for modes of sort
  55                                        int_number and reference. */
  56         irma_ieee754 = 256,       /**< Values of the mode are represented according
  57                                        to ieee754 floating point standard.  Only
  58                                        legal for modes of sort float_number. */
  59         irma_x86_extended_float,  /**< x86 extended floatingpoint values */
  60         irma_last = irma_x86_extended_float,
  61 } ir_mode_arithmetic;
  62
  63 /**
  64  * Creates a new mode.
  65  *
  66  * @param name          the name of the mode to be created
  67  * @param arithmetic    arithmetic operations possible with a mode
  68  * @param bit_size      number of bits this mode allocate
  69  * @param sign          non-zero if this is a signed mode
  70  * @param modulo_shift  Is ignored for modes other than integer.
  71  *
  72  * This function constructs a new mode given by the parameters.
  73  * If the parameters match an already defined mode, this mode is returned
  74  * (including the default modes).
  75  *
  76  * @return
  77  *   The new mode or NULL on error.
  78  */
  79 FIRM_API ir_mode *new_int_mode(const char *name,
  80                                ir_mode_arithmetic arithmetic,
  81                                unsigned bit_size, int sign,
  82                                unsigned modulo_shift);
  83
  84 /**
  85  * Create a new reference mode.
  86  *
  87  * Reference modes are always unsigned.
  88  */
  89 FIRM_API ir_mode *new_reference_mode(const char *name,
  90                                      ir_mode_arithmetic arithmetic,
  91                                      unsigned bit_size,
  92                                      unsigned modulo_shift);
  93
  94 /**
  95  * Create a new ieee754 float mode.
  96  *
  97  * float-modes are always signed and have no modulo shift.
  98  * @param name          the name of the mode to be created
  99  * @param arithmetic    arithmetic/representation of the mode
 100  * @param exponent_size size of exponent in bits
 101  * @param mantissa_size size of mantissa in bits
 102  */
 103 FIRM_API ir_mode *new_float_mode(const char *name,
 104                                  ir_mode_arithmetic arithmetic,
 105                                  unsigned exponent_size,
 106                                  unsigned mantissa_size);
 107
 108 /**
 109  * Checks whether a pointer points to a mode.
 110  *
 111  * @param thing     an arbitrary pointer
 112  *
 113  * @return
 114  *     true if the thing is a mode, else false
 115  */
 116 FIRM_API int is_mode(const void *thing);
 117
 118 /** Returns the ident* of the mode */
 119 FIRM_API ident *get_mode_ident(const ir_mode *mode);
 120
 121 /** Returns the null-terminated name of this mode. */
 122 FIRM_API const char *get_mode_name(const ir_mode *mode);
 123
 124 /** Returns the size of values of the mode in bits. */
 125 FIRM_API unsigned get_mode_size_bits(const ir_mode *mode);
 126
 127 /** Returns the size of values of the mode in bytes.
 128  *  If the size is not dividable by 8 returns -1. */
 129 FIRM_API unsigned get_mode_size_bytes(const ir_mode *mode);
 130
 131 /** Returns the signess of a mode.
 132  *
 133  * Returns the signess of a mode: 1 if mode is signed. */
 134 FIRM_API int get_mode_sign(const ir_mode *mode);
 135
 136 /** Returns the arithmetic of a mode */
 137 FIRM_API ir_mode_arithmetic get_mode_arithmetic(const ir_mode *mode);
 138
 139 /** Returns the modulo shift attribute.
 140  *
 141  *  Attribute modulo shift specifies for modes of kind irms_int_number
 142  *  whether shift applies modulo to value of bits to shift.  Zero for
 143  *  modes that are not integer.
 144  */
 145 FIRM_API unsigned int get_mode_modulo_shift(const ir_mode *mode);
 146
 147 /** Returns the stored intermediate information. */
 148 FIRM_API void *get_mode_link(const ir_mode *mode);
 149
 150 /** Stores new intermediate information. */
 151 FIRM_API void set_mode_link(ir_mode *mode, void *l);
 152
 153 /**
 154  * Returns the smallest representable value of a given mode.
 155  *
 156  * For modes of the sort float_number this is the most negative value
 157  * bigger than -infinite.
 158  */
 159 FIRM_API ir_tarval *get_mode_min(ir_mode *mode);
 160
 161 /**
 162  * Returns the biggest representable value o f a given mode.
 163  *
 164  * For modes of the sort float_number this is the largest value lower
 165  * than infinite.
 166  */
 167 FIRM_API ir_tarval *get_mode_max(ir_mode *mode);
 168
 169 /**
 170  * Returns the value Zero represented in this mode.
 171  *
 172  * Zero is the additive neutral element and as such
 173  * is defined only for modes allowing addition, i.e.
 174  * op_pin_state_floats and ints, and references (NULL-Pointer)
 175  * else returns tarval_bad.
 176  */
 177 FIRM_API ir_tarval *get_mode_null(ir_mode *mode);
 178
 179 /**
 180  * Returns the value One, represented in this mode.
 181  *
 182  * One, being the multiplicative neutral element,
 183  * is defined only for modes allowing multiplication,
 184  * i.e. ints and floats.
 185  */
 186 FIRM_API ir_tarval *get_mode_one(ir_mode *mode);
 187
 188 /**
 189  * Returns the value Minus One, represented in this mode.
 190  *
 191  * Minus One is defined only for modes allowing
 192  * multiplication with signed values, i.e. signed ints and floats.
 193  */
 194 FIRM_API ir_tarval *get_mode_minus_one(ir_mode *mode);
 195
 196 /**
 197  * Returns the value where all bits are One, represented in this mode.
 198  *
 199  * All One is defined only for modes integer, reference and boolean modes
 200  */
 201 FIRM_API ir_tarval *get_mode_all_one(ir_mode *mode);
 202
 203 /**
 204  * Returns the positive infinite value of a mode.
 205  *
 206  * This is only valid for float_numbers, other modes
 207  * will result in tarval_bad.
 208  */
 209 FIRM_API ir_tarval *get_mode_infinite(ir_mode *mode);
 210
 211 /**
 212  * Returns the NAN value of a given mode.
 213  *
 214  * This is only valid for float_numbers, other modes
 215  * will result in tarval_bad.
 216  */
 217 FIRM_API ir_tarval *get_mode_NAN(ir_mode *mode);
 218
 219 FIRM_API ir_mode *mode_M; /**< memory */
 220
 221 FIRM_API ir_mode *mode_F;   /**< ieee754 binary32 float (single precision) */
 222 FIRM_API ir_mode *mode_D;   /**< ieee754 binary64 float (double precision) */
 223 FIRM_API ir_mode *mode_Q;   /**< ieee754 binary128 float (quadruple precision)*/
 224 FIRM_API ir_mode *mode_Bs;  /**< int8 */
 225 FIRM_API ir_mode *mode_Bu;  /**< uint8 */
 226 FIRM_API ir_mode *mode_Hs;  /**< int16 */
 227 FIRM_API ir_mode *mode_Hu;  /**< uint16 */
 228 FIRM_API ir_mode *mode_Is;  /**< int32 */
 229 FIRM_API ir_mode *mode_Iu;  /**< uint32 */
 230 FIRM_API ir_mode *mode_Ls;  /**< int64 */
 231 FIRM_API ir_mode *mode_Lu;  /**< uint64 */
 232 FIRM_API ir_mode *mode_LLs; /**< int128 */
 233 FIRM_API ir_mode *mode_LLu; /**< uint128 */
 234
 235 FIRM_API ir_mode *mode_P;   /**< pointer */
 236 FIRM_API ir_mode *mode_P_code; /**< A pointer mode that is set by the client of libfirm.  This mode
 237                                   represents the pointer size of the target machine code addresses. Is initialized
 238                                   to mode_P. */
 239 FIRM_API ir_mode *mode_P_data; /**< A pointer mode that is set by the client of libfirm.  This mode
 240                                   represents the pointer size of the target machine data addresses. Is initialized
 241                                   to mode_P. */
 242
 243 FIRM_API ir_mode *mode_b;  /**< internal boolean */
 244
 245 FIRM_API ir_mode *mode_X;  /**< execution */
 246 FIRM_API ir_mode *mode_BB; /**< block */
 247
 248 FIRM_API ir_mode *mode_T;  /**< tuple (none) */
 249 FIRM_API ir_mode *mode_ANY;/**< undefined mode */
 250 FIRM_API ir_mode *mode_BAD;/**< bad mode */
 251
 252 /** Returns float mode */
 253 FIRM_API ir_mode *get_modeF(void);
 254 /** Returns double mode */
 255 FIRM_API ir_mode *get_modeD(void);
 256 /** Returns quadruple prevision mode */
 257 FIRM_API ir_mode *get_modeQ(void);
 258 /** Returns byte signed mode */
 259 FIRM_API ir_mode *get_modeBs(void);
 260 /** Returns byte unsigned mode */
 261 FIRM_API ir_mode *get_modeBu(void);
 262 /** Returns halfword signed mode */
 263 FIRM_API ir_mode *get_modeHs(void);
 264 /** Returns halfword unsigned mode */
 265 FIRM_API ir_mode *get_modeHu(void);
 266 /** Returns integer signed mode */
 267 FIRM_API ir_mode *get_modeIs(void);
 268 /** Returns integer unsigned mode */
 269 FIRM_API ir_mode *get_modeIu(void);
 270 /** Returns long signed mode */
 271 FIRM_API ir_mode *get_modeLs(void);
 272 /** Returns long unsigned mode */
 273 FIRM_API ir_mode *get_modeLu(void);
 274 /** Returns long long signed mode */
 275 FIRM_API ir_mode *get_modeLLs(void);
 276 /** Returns long long unsigned mode */
 277 FIRM_API ir_mode *get_modeLLu(void);
 278 /** Returns pointer mode */
 279 FIRM_API ir_mode *get_modeP(void);
 280 /** Returns internal boolean mode */
 281 FIRM_API ir_mode *get_modeb(void);
 282 /** Returns control-flow mode */
 283 FIRM_API ir_mode *get_modeX(void);
 284 /** Returns Basic-Block mode */
 285 FIRM_API ir_mode *get_modeBB(void);
 286 /** Returns memory mode */
 287 FIRM_API ir_mode *get_modeM(void);
 288 /** Returns tuple mode */
 289 FIRM_API ir_mode *get_modeT(void);
 290 /** Returns ANY mode */
 291 FIRM_API ir_mode *get_modeANY(void);
 292 /** Returns BAD mode */
 293 FIRM_API ir_mode *get_modeBAD(void);
 294
 295 /** Returns the machine specific pointer mode for code addresses. */
 296 FIRM_API ir_mode *get_modeP_code(void);
 297
 298 /** Returns the machine specific pointer mode for data addresses. */
 299 FIRM_API ir_mode *get_modeP_data(void);
 300
 301 /**
 302  * Sets the machine specific pointer mode for code addresses.
 303  * If not set, the predefined mode mode_P will be used.
 304  */
 305 FIRM_API void set_modeP_code(ir_mode *p);
 306
 307 /**
 308  * Sets the machine specific pointer mode for data addresses.
 309  * If not set, the predefined mode mode_P will be used.
 310  */
 311 FIRM_API void set_modeP_data(ir_mode *p);
 312
 313 /** Returns 1 if @p mode is signed, 0 otherwise */
 314 FIRM_API int mode_is_signed (const ir_mode *mode);
 315 /** Returns 1 if @p mode is for floatingpoint numbers, 0 otherwise */
 316 FIRM_API int mode_is_float (const ir_mode *mode);
 317 /** Returns 1 if @p mode is for integer numbers, 0 otherwise */
 318 FIRM_API int mode_is_int (const ir_mode *mode);
 319 /** Returns 1 if @p mode is for references/pointers, 0 otherwise */
 320 FIRM_API int mode_is_reference (const ir_mode *mode);
 321 /** Returns 1 if @p mode is for numeric values, 0 otherwise */
 322 FIRM_API int mode_is_num (const ir_mode *mode);
 323 /** Returns 1 if @p mode is for data values, 0 otherwise */
 324 FIRM_API int mode_is_data (const ir_mode *mode);
 325 /** Returns 1 if @p mode is for data values or internal booleans, 0 otherwise */
 326 FIRM_API int mode_is_datab (const ir_mode *mode);
 327 /** Returns 1 if @p mode is for data values or memory, 0 otherwise */
 328 FIRM_API int mode_is_dataM (const ir_mode *mode);
 329
 330 /**
 331  * Returns true if sm can be converted to lm without loss
 332  * according to firm definition.
 333  *
 334  * Note that mode_Iu is NOT smaller than mode_Is here.
 335  *
 336  * @see values_in_mode()
 337  */
 338 FIRM_API int smaller_mode(const ir_mode *sm, const ir_mode *lm);
 339
 340 /**
 341  * Returns true if a value of mode sm can be converted into mode lm
 342  * and backwards without loss.
 343  *
 344  * Note that mode_Iu values CAN be converted in mode_Is and back.
 345  *
 346  * @see smaller_mode()
 347  */
 348 FIRM_API int values_in_mode(const ir_mode *sm, const ir_mode *lm);
 349
 350 /**
 351  * Returns a matching unsigned mode for a given integer signed mode.
 352  * Returns NULL if no matching mode exists.
 353  */
 354 FIRM_API ir_mode *find_unsigned_mode(const ir_mode *mode);
 355
 356 /**
 357  * Returns a matching signed mode for a given integer unsigned mode.
 358  * Returns NULL if no matching mode exists.
 359  */
 360 FIRM_API ir_mode *find_signed_mode(const ir_mode *mode);
 361
 362 /**
 363  * Returns an integer mode with 2*n bits for a given integer mode with n bits.
 364  * Returns NULL if no matching mode exists.
 365  */
 366 FIRM_API ir_mode *find_double_bits_int_mode(const ir_mode *mode);
 367
 368 /**
 369  * Returns non-zero if the given mode honors signed zero's, i.e.,
 370  * a +0 and a -0 exists and handled differently.
 371  */
 372 FIRM_API int mode_honor_signed_zeros(const ir_mode *mode);
 373
 374 /**
 375  * Returns non-zero if the given mode might overflow on unary Minus.
 376  */
 377 FIRM_API int mode_overflow_on_unary_Minus(const ir_mode *mode);
 378
 379 /**
 380  * Returns non-zero if the mode has a reversed wrap-around
 381  * logic, especially (a + x) - x == a.
 382  * This is normally true for integer modes, not for floating
 383  * point modes.
 384  */
 385 FIRM_API int mode_wrap_around(const ir_mode *mode);
 386
 387 /**
 388  * Returns the signed integer equivalent mode for an reference mode.
 389  */
 390 FIRM_API ir_mode *get_reference_mode_signed_eq(ir_mode *mode);
 391
 392 /**
 393  * Sets the signed integer equivalent mode for an reference mode.
 394  */
 395 FIRM_API void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode);
 396
 397 /**
 398  * Returns the unsigned integer equivalent mode for an reference mode.
 399  */
 400 FIRM_API ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode);
 401
 402 /**
 403  * Sets the unsigned integer equivalent mode for an reference mode.
 404  */
 405 FIRM_API void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode);
 406
 407 /**
 408  * Returns size of mantissa in bits (for float modes)
 409  */
 410 FIRM_API unsigned get_mode_mantissa_size(const ir_mode *mode);
 411
 412 /**
 413  * Returns size of exponent in bits (for float modes)
 414  */
 415 FIRM_API unsigned get_mode_exponent_size(const ir_mode *mode);
 416
 417 /**
 418  * Returns non-zero if the cast from mode src to mode dst is a
 419  * reinterpret cast (ie. only the bit pattern is reinterpreted,
 420  * no conversion is done)
 421  */
 422 FIRM_API int is_reinterpret_cast(const ir_mode *src, const ir_mode *dst);
 423
 424 /**
 425  * Returns the primitive type matching the given mode
 426  */
 427 FIRM_API ir_type *get_type_for_mode(const ir_mode *mode);
 428
 429 /** @} */
 430
 431 #include "end.h"
 432
 433 #endif