2 * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
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.
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.
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
22 * @brief Data modes of operations.
23 * @author Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Mathias Heil
42 #include "pattern_dmp.h"
44 /** Obstack to hold all modes. */
45 static struct obstack modes;
47 /** The list of all currently existing modes. */
48 static ir_mode **mode_list;
50 const char *get_mode_arithmetic_name(ir_mode_arithmetic ari)
52 #define X(a) case a: return #a
54 X(irma_uninitialized);
56 X(irma_twos_complement);
58 default: return "<unknown>";
63 static inline int modes_are_equal(const ir_mode *m, const ir_mode *n)
66 if (m->sort == n->sort &&
67 m->arithmetic == n->arithmetic &&
70 m->modulo_shift == n->modulo_shift)
77 * searches the modes obstack for the given mode and returns
78 * a pointer on an equal mode already in the array, NULL if
81 static ir_mode *find_mode(const ir_mode *m)
84 for (i = 0, n_modes = ARR_LEN(mode_list); i < n_modes; ++i) {
85 ir_mode *n = mode_list[i];
86 if (modes_are_equal(n, m))
93 * sets special values of modes
95 static void set_mode_values(ir_mode* mode)
97 switch (get_mode_sort(mode)) {
100 case irms_float_number:
101 mode->min = get_tarval_min(mode);
102 mode->max = get_tarval_max(mode);
103 mode->null = get_tarval_null(mode);
104 mode->one = get_tarval_one(mode);
105 mode->minus_one = get_tarval_minus_one(mode);
106 if (get_mode_sort(mode) != irms_float_number) {
107 mode->all_one = get_tarval_all_one(mode);
109 mode->all_one = tarval_bad;
113 case irms_internal_boolean:
114 mode->min = tarval_b_false;
115 mode->max = tarval_b_true;
116 mode->null = tarval_b_false;
117 mode->one = tarval_b_true;
118 mode->minus_one = tarval_bad;
119 mode->all_one = tarval_b_true;
124 case irms_control_flow:
125 mode->min = tarval_bad;
126 mode->max = tarval_bad;
127 mode->null = tarval_bad;
128 mode->one = tarval_bad;
129 mode->minus_one = tarval_bad;
135 * globals defined in irmode.h
138 /* --- Predefined modes --- */
140 /* FIRM internal modes: */
148 /* predefined numerical modes: */
149 ir_mode *mode_F; /* float */
150 ir_mode *mode_D; /* double */
151 ir_mode *mode_E; /* long double */
153 ir_mode *mode_Bs; /* integral values, signed and unsigned */
154 ir_mode *mode_Bu; /* 8 bit */
155 ir_mode *mode_Hs; /* 16 bit */
157 ir_mode *mode_Is; /* 32 bit */
159 ir_mode *mode_Ls; /* 64 bit */
161 ir_mode *mode_LLs; /* 128 bit */
167 /* machine specific modes */
168 ir_mode *mode_P_code; /**< machine specific pointer mode for code addresses */
169 ir_mode *mode_P_data; /**< machine specific pointer mode for data addresses */
172 * functions defined in irmode.h
175 /* JNI access functions */
176 ir_mode *get_modeT(void) { return mode_T; }
177 ir_mode *get_modeF(void) { return mode_F; }
178 ir_mode *get_modeD(void) { return mode_D; }
179 ir_mode *get_modeE(void) { return mode_E; }
180 ir_mode *get_modeBs(void) { return mode_Bs; }
181 ir_mode *get_modeBu(void) { return mode_Bu; }
182 ir_mode *get_modeHs(void) { return mode_Hs; }
183 ir_mode *get_modeHu(void) { return mode_Hu; }
184 ir_mode *get_modeIs(void) { return mode_Is; }
185 ir_mode *get_modeIu(void) { return mode_Iu; }
186 ir_mode *get_modeLs(void) { return mode_Ls; }
187 ir_mode *get_modeLu(void) { return mode_Lu; }
188 ir_mode *get_modeLLs(void){ return mode_LLs; }
189 ir_mode *get_modeLLu(void){ return mode_LLu; }
190 ir_mode *get_modeb(void) { return mode_b; }
191 ir_mode *get_modeP(void) { return mode_P; }
192 ir_mode *get_modeX(void) { return mode_X; }
193 ir_mode *get_modeM(void) { return mode_M; }
194 ir_mode *get_modeBB(void) { return mode_BB; }
195 ir_mode *get_modeANY(void) { return mode_ANY; }
196 ir_mode *get_modeBAD(void) { return mode_BAD; }
199 ir_mode *(get_modeP_code)(void)
201 return get_modeP_code_();
204 ir_mode *(get_modeP_data)(void)
206 return get_modeP_data_();
209 void set_modeP_code(ir_mode *p)
211 assert(mode_is_reference(p));
215 void set_modeP_data(ir_mode *p)
217 assert(mode_is_reference(p));
223 * Registers a new mode.
225 * @param new_mode The new mode template.
227 static ir_mode *register_mode(const ir_mode *new_mode)
229 ir_mode *mode = NULL;
233 /* copy mode struct to modes array */
234 mode = (ir_mode *)obstack_copy(&modes, new_mode, sizeof(*mode));
235 ARR_APP1(ir_mode*, mode_list, mode);
237 mode->kind = k_ir_mode;
238 mode->type = new_type_primitive(mode);
240 /* add the new mode to the irp list of modes */
243 set_mode_values(mode);
245 hook_new_mode(new_mode, mode);
250 * Creates a new mode.
252 ir_mode *new_ir_mode(const char *name, ir_mode_sort sort, int bit_size, int sign,
253 ir_mode_arithmetic arithmetic, unsigned int modulo_shift)
256 ir_mode *mode = NULL;
258 mode_tmpl.name = new_id_from_str(name);
259 mode_tmpl.sort = sort;
260 mode_tmpl.size = bit_size;
261 mode_tmpl.sign = sign ? 1 : 0;
262 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number ||
263 mode_tmpl.sort == irms_reference) ? modulo_shift : 0;
264 mode_tmpl.arithmetic = arithmetic;
265 mode_tmpl.link = NULL;
266 mode_tmpl.tv_priv = NULL;
268 mode = find_mode(&mode_tmpl);
270 hook_new_mode(&mode_tmpl, mode);
277 case irms_control_flow:
279 case irms_internal_boolean:
280 panic("internal modes cannot be user defined");
282 case irms_float_number:
283 case irms_int_number:
285 mode = register_mode(&mode_tmpl);
288 assert(mode != NULL);
292 /* Functions for the direct access to all attributes of an ir_mode */
293 ident *(get_mode_ident)(const ir_mode *mode)
295 return get_mode_ident_(mode);
298 const char *get_mode_name(const ir_mode *mode)
300 return get_id_str(mode->name);
303 ir_mode_sort (get_mode_sort)(const ir_mode* mode)
305 return get_mode_sort_(mode);
308 unsigned (get_mode_size_bits)(const ir_mode *mode)
310 return get_mode_size_bits_(mode);
313 unsigned (get_mode_size_bytes)(const ir_mode *mode)
315 return get_mode_size_bytes_(mode);
318 int (get_mode_sign)(const ir_mode *mode)
320 return get_mode_sign_(mode);
323 ir_mode_arithmetic (get_mode_arithmetic)(const ir_mode *mode)
325 return get_mode_arithmetic_(mode);
329 /* Attribute modulo shift specifies for modes of kind irms_int_number
330 * whether shift applies modulo to value of bits to shift. Asserts
331 * if mode is not irms_int_number.
333 unsigned int (get_mode_modulo_shift)(const ir_mode *mode)
335 return get_mode_modulo_shift_(mode);
338 void *(get_mode_link)(const ir_mode *mode)
340 return get_mode_link_(mode);
343 void (set_mode_link)(ir_mode *mode, void *l)
345 set_mode_link_(mode, l);
348 ir_tarval *get_mode_min(ir_mode *mode)
351 assert(mode_is_data(mode));
356 ir_tarval *get_mode_max(ir_mode *mode)
359 assert(mode_is_data(mode));
364 ir_tarval *get_mode_null(ir_mode *mode)
367 assert(mode_is_datab(mode));
372 ir_tarval *get_mode_one(ir_mode *mode)
375 assert(mode_is_datab(mode));
380 ir_tarval *get_mode_minus_one(ir_mode *mode)
383 assert(mode_is_data(mode));
385 return mode->minus_one;
388 ir_tarval *get_mode_all_one(ir_mode *mode)
391 assert(mode_is_datab(mode));
392 return mode->all_one;
395 ir_tarval *get_mode_infinite(ir_mode *mode)
398 assert(mode_is_float(mode));
400 return get_tarval_plus_inf(mode);
403 ir_tarval *get_mode_NAN(ir_mode *mode)
406 assert(mode_is_float(mode));
408 return get_tarval_nan(mode);
411 int is_mode(const void *thing)
413 return get_kind(thing) == k_ir_mode;
416 int (mode_is_signed)(const ir_mode *mode)
418 return mode_is_signed_(mode);
421 int (mode_is_float)(const ir_mode *mode)
423 return mode_is_float_(mode);
426 int (mode_is_int)(const ir_mode *mode)
428 return mode_is_int_(mode);
431 int (mode_is_reference)(const ir_mode *mode)
433 return mode_is_reference_(mode);
436 int (mode_is_num)(const ir_mode *mode)
438 return mode_is_num_(mode);
441 int (mode_is_data)(const ir_mode *mode)
443 return mode_is_data_(mode);
446 int (mode_is_datab)(const ir_mode *mode)
448 return mode_is_datab_(mode);
451 int (mode_is_dataM)(const ir_mode *mode)
453 return mode_is_dataM_(mode);
456 /* Returns true if sm can be converted to lm without loss. */
457 int smaller_mode(const ir_mode *sm, const ir_mode *lm)
459 int sm_bits, lm_bits;
464 if (sm == lm) return 1;
466 sm_bits = get_mode_size_bits(sm);
467 lm_bits = get_mode_size_bits(lm);
469 switch (get_mode_sort(sm)) {
470 case irms_int_number:
471 switch (get_mode_sort(lm)) {
472 case irms_int_number:
473 if (get_mode_arithmetic(sm) != get_mode_arithmetic(lm))
476 /* only two complement implemented */
477 assert(get_mode_arithmetic(sm) == irma_twos_complement);
479 /* integers are convertable if
480 * - both have the same sign and lm is the larger one
481 * - lm is the signed one and is at least two bits larger
482 * (one for the sign, one for the highest bit of sm)
483 * - sm & lm are two_complement and lm has greater or equal number of bits
485 if (mode_is_signed(sm)) {
486 if (!mode_is_signed(lm))
488 return sm_bits <= lm_bits;
490 if (mode_is_signed(lm)) {
491 return sm_bits < lm_bits;
493 return sm_bits <= lm_bits;
496 case irms_float_number:
497 /* int to float works if the float is large enough */
505 case irms_float_number:
506 if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
507 if ( (get_mode_sort(lm) == irms_float_number)
508 && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
514 /* do exist machines out there with different pointer lengths ?*/
517 case irms_internal_boolean:
518 return mode_is_int(lm);
528 /* Returns true if a value of mode sm can be converted into mode lm
529 and backwards without loss. */
530 int values_in_mode(const ir_mode *sm, const ir_mode *lm)
532 ir_mode_arithmetic arith;
537 if (sm == lm) return 1;
540 return mode_is_int(lm);
542 arith = get_mode_arithmetic(sm);
543 if (arith != get_mode_arithmetic(lm))
547 case irma_twos_complement:
549 return get_mode_size_bits(sm) <= get_mode_size_bits(lm);
556 /* Return the signed integer equivalent mode for an reference mode. */
557 ir_mode *get_reference_mode_signed_eq(ir_mode *mode)
559 assert(mode_is_reference(mode));
560 return mode->eq_signed;
563 /* Sets the signed integer equivalent mode for an reference mode. */
564 void set_reference_mode_signed_eq(ir_mode *ref_mode, ir_mode *int_mode)
566 assert(mode_is_reference(ref_mode));
567 assert(mode_is_int(int_mode));
568 ref_mode->eq_signed = int_mode;
571 /* Return the unsigned integer equivalent mode for an reference mode. */
572 ir_mode *get_reference_mode_unsigned_eq(ir_mode *mode)
574 assert(mode_is_reference(mode));
575 return mode->eq_unsigned;
578 /* Sets the unsigned integer equivalent mode for an reference mode. */
579 void set_reference_mode_unsigned_eq(ir_mode *ref_mode, ir_mode *int_mode)
581 assert(mode_is_reference(ref_mode));
582 assert(mode_is_int(int_mode));
583 ref_mode->eq_unsigned = int_mode;
586 /* initialization, build the default modes */
591 obstack_init(&modes);
592 mode_list = NEW_ARR_F(ir_mode*, 0);
594 /* initialize predefined modes */
597 newmode.arithmetic = irma_none;
600 newmode.modulo_shift = 0;
601 newmode.eq_signed = NULL;
602 newmode.eq_unsigned = NULL;
604 newmode.tv_priv = NULL;
606 /* Control Flow Modes*/
607 newmode.sort = irms_control_flow;
610 newmode.name = new_id_from_chars("BB", 2);
611 mode_BB = register_mode(&newmode);
614 newmode.name = new_id_from_chars("X", 1);
615 mode_X = register_mode(&newmode);
618 newmode.sort = irms_memory;
621 newmode.name = new_id_from_chars("M", 1);
622 mode_M = register_mode(&newmode);
624 /* Auxiliary Modes */
625 newmode.sort = irms_auxiliary,
628 newmode.name = new_id_from_chars("T", 1);
629 mode_T = register_mode(&newmode);
632 newmode.name = new_id_from_chars("ANY", 3);
633 mode_ANY = register_mode(&newmode);
636 newmode.name = new_id_from_chars("BAD", 3);
637 mode_BAD = register_mode(&newmode);
639 /* Internal Boolean Modes */
640 newmode.sort = irms_internal_boolean;
643 newmode.name = new_id_from_chars("b", 1);
644 mode_b = register_mode(&newmode);
646 /* Float Number Modes */
647 newmode.sort = irms_float_number;
648 newmode.arithmetic = irma_ieee754;
651 newmode.name = new_id_from_chars("F", 1);
654 mode_F = register_mode(&newmode);
657 newmode.name = new_id_from_chars("D", 1);
660 mode_D = register_mode(&newmode);
663 newmode.name = new_id_from_chars("E", 1);
665 /* note that the tarval module is calculating with 80 bits, but we use
666 * 96 bits, as that is what will be stored to memory by most hardware */
668 mode_E = register_mode(&newmode);
670 /* Integer Number Modes */
671 newmode.sort = irms_int_number;
672 newmode.arithmetic = irma_twos_complement;
675 newmode.name = new_id_from_chars("Bs", 2);
678 newmode.modulo_shift = 32;
679 mode_Bs = register_mode(&newmode);
682 newmode.name = new_id_from_chars("Bu", 2);
683 newmode.arithmetic = irma_twos_complement;
686 newmode.modulo_shift = 32;
687 mode_Bu = register_mode(&newmode);
689 /* signed short integer */
690 newmode.name = new_id_from_chars("Hs", 2);
693 newmode.modulo_shift = 32;
694 mode_Hs = register_mode(&newmode);
696 /* unsigned short integer */
697 newmode.name = new_id_from_chars("Hu", 2);
700 newmode.modulo_shift = 32;
701 mode_Hu = register_mode(&newmode);
704 newmode.name = new_id_from_chars("Is", 2);
707 newmode.modulo_shift = 32;
708 mode_Is = register_mode(&newmode);
710 /* unsigned integer */
711 newmode.name = new_id_from_chars("Iu", 2);
714 newmode.modulo_shift = 32;
715 mode_Iu = register_mode(&newmode);
717 /* signed long integer */
718 newmode.name = new_id_from_chars("Ls", 2);
721 newmode.modulo_shift = 64;
722 mode_Ls = register_mode(&newmode);
724 /* unsigned long integer */
725 newmode.name = new_id_from_chars("Lu", 2);
728 newmode.modulo_shift = 64;
729 mode_Lu = register_mode(&newmode);
731 /* signed long long integer */
732 newmode.name = new_id_from_chars("LLs", 3);
735 newmode.modulo_shift = 128;
736 mode_LLs = register_mode(&newmode);
738 /* unsigned long long integer */
739 newmode.name = new_id_from_chars("LLu", 3);
742 newmode.modulo_shift = 128;
743 mode_LLu = register_mode(&newmode);
746 newmode.sort = irms_reference;
747 newmode.arithmetic = irma_twos_complement;
750 newmode.name = new_id_from_chars("P", 1);
753 newmode.modulo_shift = 32;
754 newmode.eq_signed = mode_Is;
755 newmode.eq_unsigned = mode_Iu;
756 mode_P = register_mode(&newmode);
758 /* set the machine specific modes to the predefined ones */
759 mode_P_code = mode_P;
760 mode_P_data = mode_P;
763 /* find a signed mode for an unsigned integer mode */
764 ir_mode *find_unsigned_mode(const ir_mode *mode)
768 /* allowed for reference mode */
769 if (mode->sort == irms_reference)
770 n.sort = irms_int_number;
772 assert(n.sort == irms_int_number);
774 return find_mode(&n);
777 /* find an unsigned mode for a signed integer mode */
778 ir_mode *find_signed_mode(const ir_mode *mode)
782 assert(mode->sort == irms_int_number);
784 return find_mode(&n);
787 /* finds a integer mode with 2*n bits for an integer mode with n bits. */
788 ir_mode *find_double_bits_int_mode(const ir_mode *mode)
792 assert(mode->sort == irms_int_number && mode->arithmetic == irma_twos_complement);
794 n.size = 2*mode->size;
795 return find_mode(&n);
799 * Returns non-zero if the given mode honors signed zero's, i.e.,
800 * a +0 and a -0 exists and handled differently.
802 int mode_honor_signed_zeros(const ir_mode *mode)
804 /* for floating point, we know that IEEE 754 has +0 and -0,
805 * but always handles it identical.
808 mode->sort == irms_float_number &&
809 mode->arithmetic != irma_ieee754;
813 * Returns non-zero if the given mode might overflow on unary Minus.
815 * This does NOT happen on IEEE 754.
817 int mode_overflow_on_unary_Minus(const ir_mode *mode)
819 if (mode->sort == irms_float_number)
820 return mode->arithmetic == irma_ieee754 ? 0 : 1;
825 * Returns non-zero if the mode has a reversed wrap-around
826 * logic, especially (a + x) - x == a.
828 * This is normally true for integer modes, not for floating
831 int mode_wrap_around(const ir_mode *mode)
833 /* FIXME: better would be an extra mode property */
834 return mode_is_int(mode);
838 * Returns non-zero if the cast from mode src to mode dst is a
839 * reinterpret cast (ie. only the bit pattern is reinterpreted,
840 * no conversion is done)
842 int is_reinterpret_cast(const ir_mode *src, const ir_mode *dst)
844 ir_mode_arithmetic ma;
848 if (get_mode_size_bits(src) != get_mode_size_bits(dst))
850 ma = get_mode_arithmetic(src);
851 if (ma != get_mode_arithmetic(dst))
854 return ma == irma_twos_complement;
857 ir_type *(get_type_for_mode) (const ir_mode *mode)
859 return get_type_for_mode_(mode);
862 void finish_mode(void)
864 obstack_free(&modes, 0);
865 DEL_ARR_F(mode_list);