nsz Git - libfirm/blob - ir/tv/strcalc.h

   1 /*
   2  * Copyright (C) 1995-2007 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  * Project:     libFIRM
  22  * File name:   ir/tv/strcalc.h
  23  * Purpose:     Provides basic mathematical operations on values represented as strings.
  24  * Author:      Mathias Heil
  25  * Modified by:
  26  * Created:
  27  * CVS-ID:      $Id$
  28  * Copyright:   (c) 2003 Universität Karlsruhe
  29  */
  30
  31 /**
  32  * @file strcalc.h
  33  *
  34  * The module uses a string to represent values, and provides operations
  35  * to perform calculations with these values.
  36  * Results are stored in an internal buffer, so you have to make a copy
  37  * of them if you need to store the result.
  38  *
  39  */
  40
  41 #ifndef _STRCALC_H_
  42 #define _STRCALC_H_
  43
  44 #include "irmode.h"
  45
  46 #ifdef STRCALC_DEBUG_ALL             /* switch on all debug options */
  47 #  ifndef STRCALC_DEBUG
  48 #    define STRCALC_DEBUG            /* switch on debug output */
  49 #  endif
  50 #  ifndef STRCALC_DEBUG_PRINTCOMP    /* print arguments and result of each computation */
  51 #    define STRCALC_DEBUG_PRINTCOMP
  52 #  endif
  53 #  ifndef STRCALC_DEBUG_FULLPRINT
  54 #    define STRCALC_DEBUG_FULLPRINT  /* print full length of values (e.g. 128 bit instead of 64 bit using default init) */
  55 #  endif
  56 #  ifndef STRCALC_DEBUG_GROUPPRINT
  57 #    define STRCALC_DEBUG_GROUPPRINT /* print spaces after each 8 bits */
  58 #  endif
  59 #endif
  60
  61 /*
  62  * constants, typedefs, enums
  63  */
  64
  65 #define SC_DEFAULT_PRECISION 64
  66
  67 enum {
  68   SC_0 = 0,
  69   SC_1,
  70   SC_2,
  71   SC_3,
  72   SC_4,
  73   SC_5,
  74   SC_6,
  75   SC_7,
  76   SC_8,
  77   SC_9,
  78   SC_A,
  79   SC_B,
  80   SC_C,
  81   SC_D,
  82   SC_E,
  83   SC_F
  84 };
  85
  86 /**
  87  * Possible operations on integer values.
  88  */
  89 typedef enum {
  90   SC_ADD = 0,   /**< Addition */
  91   SC_SUB,       /**< Substraction */
  92   SC_NEG,       /**< Unary Minus */
  93   SC_MUL,       /**< Multiplication */
  94   SC_DIV,       /**< Integer Division (with rounding toward zero ?) */
  95   SC_MOD,       /**< Devision Remainder */
  96   SC_SHL,       /**< Left Shift */
  97   SC_SHR,       /**< Logical (unsigned) Right Shift */
  98   SC_SHRS,      /**< Arithmetic (signed) Right Shift */
  99   SC_ROT,       /**< Rotation (both directions) */
 100   SC_AND,       /**< Bitwise And */
 101   SC_OR,        /**< Bitwise Or */
 102   SC_NOT,       /**< Bitwise Not */
 103   SC_XOR        /**< Bitwise Exclusive Or */
 104 } sc_op_t;
 105
 106 /**
 107  * The output mode for integer values.
 108  */
 109 enum base_t {
 110   SC_hex,   /**< hexadecimal output with small letters */
 111   SC_HEX,   /**< hexadecimal output with BIG letters */
 112   SC_DEC,   /**< decimal output */
 113   SC_OCT,   /**< octal output */
 114   SC_BIN    /**< binary output */
 115 };
 116
 117 /*
 118  * definitions and macros
 119  */
 120 #define sc_add(a, b, c) sc_calc((a), (b), SC_ADD, (c))
 121 #define sc_sub(a, b, c) sc_calc((a), (b), SC_SUB, (c))
 122 #define sc_neg(a, c)    sc_calc((a), NULL, SC_NEG, (c))
 123 #define sc_and(a, b, c) sc_calc((a), (b), SC_AND, (c))
 124 #define sc_or(a, b, c)  sc_calc((a), (b), SC_OR, (c))
 125 #define sc_xor(a, b, c) sc_calc((a), (b), SC_XOR, (c))
 126 #define sc_not(a, c)    sc_calc((a), NULL, SC_NOT, (c))
 127 #define sc_mul(a, b, c) sc_calc((a), (b), SC_MUL, (c))
 128 #define sc_div(a, b, c) sc_calc((a), (b), SC_DIV, (c))
 129 #define sc_mod(a, b, c) sc_calc((a), (b), SC_MOD, (c))
 130 #define sc_shl(a, b, c, d, e)  sc_bitcalc((a), (b), (c), (d), SC_SHL, (e))
 131 #define sc_shr(a, b, c, d, e)  sc_bitcalc((a), (b), (c), (d), SC_SHR, (e))
 132 #define sc_shrs(a, b, c, d, e) sc_bitcalc((a), (b), (c), (d), SC_SHRS, (e))
 133 #define sc_rot(a, b, c, d, e)  sc_bitcalc((a), (b), (c), (d), SC_ROT, (e))
 134
 135 /*
 136  * function declarations
 137  */
 138 const void *sc_get_buffer(void);
 139 int sc_get_buffer_length(void);
 140
 141 void sign_extend(char *calc_buffer, ir_mode *mode);
 142
 143 /** create an value form a string representation */
 144 void sc_val_from_str(const char *str, unsigned int len, void *buffer, ir_mode *mode);
 145
 146 /** create a value from a long */
 147 void sc_val_from_long(long l, void *buffer);
 148
 149 /** create a value form an unsigned long */
 150 void sc_val_from_ulong(unsigned long l, void *buffer);
 151
 152 /** converts a value to a long */
 153 long sc_val_to_long(const void *val);
 154 void sc_min_from_bits(unsigned int num_bits, unsigned int sign, void *buffer);
 155 void sc_max_from_bits(unsigned int num_bits, unsigned int sign, void *buffer);
 156
 157 void sc_calc(const void *val1, const void *val2, unsigned op, void *buffer);
 158 void sc_bitcalc(const void *val1, const void *val2, int radius, int sign, unsigned op, void *buffer);
 159 int  sc_comp(const void *val1, const void *val2);
 160
 161 int sc_get_highest_set_bit(const void *value);
 162 int sc_get_lowest_set_bit(const void *value);
 163 int sc_is_zero(const void *value);
 164 int sc_is_negative(const void *value);
 165 int sc_had_carry(void);
 166 unsigned char sc_sub_bits(const void *value, int len, unsigned byte_ofs);
 167
 168 /**
 169  * Converts a tarval into a string.
 170  *
 171  * @param val1        the value pointer
 172  * @param bits        number of valid bits in this value
 173  * @param base        output base
 174  * @param signed_mode print it signed (only decimal mode supported
 175  */
 176 const char *sc_print(const void *val1, unsigned bits, enum base_t base, int signed_mode);
 177
 178 /** Initialize the strcalc module.
 179  * Sets up internal data structures and constants
 180  * After the first call subsequent calls have no effect
 181  *
 182  * @param precision_in_bytes Specifies internal precision to be used
 183  *   for calculations. The reason for being multiples of 8 eludes me
 184  */
 185 void init_strcalc(int precision_in_bytes);
 186 void finish_strcalc(void);
 187 int sc_get_precision(void);
 188
 189 #endif /* _STRCALC_H_ */