3 * File name: ir/ir/irmode.c
4 * Purpose: Data modes of operations.
5 * Author: Martin Trapp, Christian Schaefer
6 * Modified by: Goetz Lindenmaier, Mathias Heil
9 * Copyright: (c) 1998-2003 Universität Karlsruhe
10 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
25 # include "irprog_t.h"
26 # include "irmode_t.h"
34 static long long count = 0;
35 # define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
37 # define ANNOUNCE() ((void)0)
45 /** dynamic array to hold all modes */
46 static struct obstack modes;
48 /** number of defined modes */
56 * Compare modes that don't need to have their code field
59 * TODO: Add other fields
61 INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n)
64 if (m->sort == n->sort &&
65 m->arithmetic == n->arithmetic &&
68 m->modulo_shift == n->modulo_shift &&
69 m->vector_elem == n->vector_elem)
76 * calculates the next obstack address
78 static void *next_obstack_adr(struct obstack *o, void *p, size_t s)
80 PTR_INT_TYPE adr = PTR_TO_INT((char *)p);
81 int mask = obstack_alignment_mask(o);
85 return INT_TO_PTR(adr & ~mask);
89 * searches the modes obstack for the given mode and returns
90 * a pointer on an equal mode already in the array, NULL if
93 static ir_mode *find_mode(const ir_mode *m)
96 struct _obstack_chunk *p;
99 n = (ir_mode *)p->contents;
100 nn = next_obstack_adr(&modes, n, sizeof(*n));
101 for (; (char *)nn <= modes.next_free;) {
103 if (modes_are_equal(n, m))
107 nn = next_obstack_adr(&modes, n, sizeof(*n));
110 for (p = p->prev; p; p = p->prev) {
111 n = (ir_mode *)p->contents;
112 nn = next_obstack_adr(&modes, n, sizeof(*n));
113 for (; (char *)nn < p->limit;) {
115 if (modes_are_equal(n, m))
119 nn = next_obstack_adr(&modes, n, sizeof(*n));
127 * sets special values of modes
129 static void set_mode_values(ir_mode* mode)
131 switch (get_mode_sort(mode))
134 case irms_int_number:
135 case irms_float_number:
136 mode->min = get_tarval_min(mode);
137 mode->max = get_tarval_max(mode);
138 mode->null = get_tarval_null(mode);
139 mode->one = get_tarval_one(mode);
140 mode->minus_one = get_tarval_minus_one(mode);
143 case irms_internal_boolean:
144 mode->min = tarval_b_false;
145 mode->max = tarval_b_true;
146 mode->null = tarval_b_false;
147 mode->one = tarval_b_true;
148 mode->minus_one = tarval_bad;
152 mode->min = tarval_bad;
153 mode->max = tarval_bad;
154 mode->null = get_tarval_null(mode);
155 mode->one = tarval_bad;
156 mode->minus_one = tarval_bad;
161 case irms_control_flow:
162 mode->min = tarval_bad;
163 mode->max = tarval_bad;
164 mode->null = tarval_bad;
165 mode->one = tarval_bad;
166 mode->minus_one = tarval_bad;
172 * globals defined in irmode.h
175 /* --- Predefined modes --- */
177 /* FIRM internal modes: */
185 /* predefined numerical modes: */
186 ir_mode *mode_F; /* float */
187 ir_mode *mode_D; /* double */
188 ir_mode *mode_E; /* long double */
190 ir_mode *mode_Bs; /* integral values, signed and unsigned */
191 ir_mode *mode_Bu; /* 8 bit */
192 ir_mode *mode_Hs; /* 16 bit */
194 ir_mode *mode_Is; /* 32 bit */
196 ir_mode *mode_Ls; /* 64 bit */
204 /* machine specific modes */
205 ir_mode *mode_P_code; /**< machine specific pointer mode for code addresses */
206 ir_mode *mode_P_data; /**< machine specific pointer mode for data addresses */
209 * functions defined in irmode.h
212 /* JNI access functions */
213 ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
214 ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
215 ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
216 ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
217 ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
218 ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
219 ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
220 ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
221 ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
222 ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
223 ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
224 ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
225 ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
226 ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
227 ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
228 ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
229 ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
230 ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
231 ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
232 ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
233 ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
236 ir_mode *(get_modeP_code)(void) {
238 return _get_modeP_code();
241 ir_mode *(get_modeP_data)(void) {
243 return _get_modeP_data();
246 void set_modeP_code(ir_mode *p) {
247 assert(mode_is_reference(p));
252 void set_modeP_data(ir_mode *p) {
253 assert(mode_is_reference(p));
259 * Registers a new mode.
261 * @param new_mode The new mode template.
263 static ir_mode *register_mode(const ir_mode *new_mode)
265 ir_mode *mode = NULL;
270 /* copy mode struct to modes array */
271 mode = (ir_mode *)obstack_copy(&modes, new_mode, sizeof(*mode));
273 mode->kind = k_ir_mode;
274 if (num_modes >= irm_max) mode->code = num_modes;
277 /* add the new mode to the irp list of modes */
280 set_mode_values(mode);
282 hook_new_mode(new_mode, mode);
287 * Creates a new mode.
289 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int sign,
290 mode_arithmetic arithmetic, unsigned int modulo_shift )
293 ir_mode *mode = NULL;
295 mode_tmpl.name = new_id_from_str(name);
296 mode_tmpl.sort = sort;
297 mode_tmpl.size = bit_size;
298 mode_tmpl.sign = sign ? 1 : 0;
299 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
300 mode_tmpl.vector_elem = 1;
301 mode_tmpl.arithmetic = arithmetic;
302 mode_tmpl.link = NULL;
303 mode_tmpl.tv_priv = NULL;
305 mode = find_mode(&mode_tmpl);
307 hook_new_mode(&mode_tmpl, mode);
315 case irms_control_flow:
317 case irms_internal_boolean:
318 assert(0 && "internal modes cannot be user defined");
321 case irms_float_number:
322 case irms_int_number:
325 mode = register_mode(&mode_tmpl);
331 * Creates a new vector mode.
333 ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int sign,
334 mode_arithmetic arithmetic, unsigned int modulo_shift )
337 ir_mode *mode = NULL;
339 mode_tmpl.name = new_id_from_str(name);
340 mode_tmpl.sort = sort;
341 mode_tmpl.size = bit_size * num_of_elem;
342 mode_tmpl.sign = sign ? 1 : 0;
343 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
344 mode_tmpl.vector_elem = num_of_elem;
345 mode_tmpl.arithmetic = arithmetic;
346 mode_tmpl.link = NULL;
347 mode_tmpl.tv_priv = NULL;
349 mode = find_mode(&mode_tmpl);
351 hook_new_mode(&mode_tmpl, mode);
355 if (num_of_elem <= 1) {
356 assert(0 && "vector modes should have at least 2 elements");
364 case irms_control_flow:
366 case irms_internal_boolean:
367 assert(0 && "internal modes cannot be user defined");
372 assert(0 && "only integer and floating point modes can be vectorized");
375 case irms_float_number:
376 assert(0 && "not yet implemented");
379 case irms_int_number:
380 mode = register_mode(&mode_tmpl);
385 /* Functions for the direct access to all attributes of an ir_mode */
387 (get_mode_modecode)(const ir_mode *mode)
390 return _get_mode_modecode(mode);
394 (get_mode_ident)(const ir_mode *mode)
397 return _get_mode_ident(mode);
401 get_mode_name(const ir_mode *mode)
404 return get_id_str(mode->name);
408 (get_mode_sort)(const ir_mode* mode)
411 return _get_mode_sort(mode);
415 (get_mode_size_bits)(const ir_mode *mode)
418 return _get_mode_size_bits(mode);
422 (get_mode_size_bytes)(const ir_mode *mode) {
424 return _get_mode_size_bytes(mode);
428 (get_mode_sign)(const ir_mode *mode)
431 return _get_mode_sign(mode);
435 (get_mode_arithmetic)(const ir_mode *mode)
438 return get_mode_arithmetic(mode);
442 /* Attribute modulo shift specifies for modes of kind irms_int_number
443 * whether shift applies modulo to value of bits to shift. Asserts
444 * if mode is not irms_int_number.
447 (get_mode_modulo_shift)(const ir_mode *mode) {
448 return _get_mode_modulo_shift(mode);
452 (get_mode_n_vector_elems)(const ir_mode *mode) {
453 return _get_mode_vector_elems(mode);
457 (get_mode_link)(const ir_mode *mode)
460 return _get_mode_link(mode);
464 (set_mode_link)(ir_mode *mode, void *l)
466 _set_mode_link(mode, l);
470 get_mode_min (ir_mode *mode)
474 assert(get_mode_modecode(mode) < num_modes);
475 assert(mode_is_data(mode));
481 get_mode_max (ir_mode *mode)
485 assert(get_mode_modecode(mode) < num_modes);
486 assert(mode_is_data(mode));
492 get_mode_null (ir_mode *mode)
496 assert(get_mode_modecode(mode) < num_modes);
497 assert(mode_is_data(mode));
503 get_mode_one (ir_mode *mode)
507 assert(get_mode_modecode(mode) < num_modes);
508 assert(mode_is_data(mode));
514 get_mode_minus_one (ir_mode *mode)
518 assert(get_mode_modecode(mode) < num_modes);
519 assert(mode_is_data(mode));
521 return mode->minus_one;
525 get_mode_infinite(ir_mode *mode)
529 assert(get_mode_modecode(mode) < num_modes);
530 assert(mode_is_float(mode));
532 return get_tarval_plus_inf(mode);
536 get_mode_NAN(ir_mode *mode)
540 assert(get_mode_modecode(mode) < num_modes);
541 assert(mode_is_float(mode));
543 return get_tarval_nan(mode);
547 is_mode (void *thing) {
548 if (get_kind(thing) == k_ir_mode)
555 (mode_is_signed)(const ir_mode *mode) {
557 return _mode_is_signed(mode);
561 (mode_is_float)(const ir_mode *mode) {
563 return _mode_is_float(mode);
567 (mode_is_int)(const ir_mode *mode) {
569 return _mode_is_int(mode);
573 (mode_is_character)(const ir_mode *mode) {
575 return _mode_is_character(mode);
579 (mode_is_reference)(const ir_mode *mode) {
581 return _mode_is_reference(mode);
585 (mode_is_num)(const ir_mode *mode) {
587 return _mode_is_num(mode);
591 (mode_is_numP)(const ir_mode *mode) {
593 return _mode_is_numP(mode);
597 (mode_is_data)(const ir_mode *mode) {
599 return _mode_is_data(mode);
603 (mode_is_datab)(const ir_mode *mode) {
605 return _mode_is_datab(mode);
609 (mode_is_dataM)(const ir_mode *mode) {
611 return _mode_is_dataM(mode);
615 (mode_is_float_vector)(const ir_mode *mode) {
617 return _mode_is_float_vector(mode);
621 (mode_is_int_vector)(const ir_mode *mode) {
623 return _mode_is_int_vector(mode);
626 /* Returns true if sm can be converted to lm without loss. */
628 smaller_mode(const ir_mode *sm, const ir_mode *lm)
630 int sm_bits, lm_bits;
636 if (sm == lm) return 1;
638 sm_bits = get_mode_size_bits(sm);
639 lm_bits = get_mode_size_bits(lm);
641 switch(get_mode_sort(sm))
643 case irms_int_number:
644 switch(get_mode_sort(lm))
646 case irms_int_number:
647 /* integers are convertable if
648 * - both have the same sign and lm is the larger one
649 * - lm is the signed one and is at least two bits larger
650 * (one for the sign, one for the highest bit of sm)
651 * - sm & lm are two_complement and lm has greater or equal number of bits
653 if ( get_mode_arithmetic(sm) == get_mode_arithmetic(lm)
654 && get_mode_arithmetic(sm) == irma_twos_complement) {
655 return lm_bits >= sm_bits;
657 else if (mode_is_signed(sm))
659 if ( mode_is_signed(lm) && (lm_bits >= sm_bits) )
662 else if (mode_is_signed(lm))
664 if (lm_bits > sm_bits + 1)
667 else if (lm_bits >= sm_bits)
673 case irms_float_number:
674 /* int to float works if the float is large enough */
682 case irms_float_number:
683 if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
684 if ( (get_mode_sort(lm) == irms_float_number)
685 && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
691 /* do exist machines out there with different pointer lenghts ?*/
702 /* initialization, build the default modes */
708 /* init flexible array */
710 obstack_init(&modes);
713 /* initialize predefined modes */
716 newmode.arithmetic = irma_none;
719 newmode.modulo_shift = 0;
720 newmode.vector_elem = 0;
722 newmode.tv_priv = NULL;
724 /* Control Flow Modes*/
725 newmode.sort = irms_control_flow;
728 newmode.name = new_id_from_chars("BB", 2);
729 newmode.code = irm_BB;
731 mode_BB = register_mode(&newmode);
734 newmode.name = new_id_from_chars("X", 1);
735 newmode.code = irm_X;
737 mode_X = register_mode(&newmode);
740 newmode.sort = irms_memory;
743 newmode.name = new_id_from_chars("M", 1);
744 newmode.code = irm_M;
746 mode_M = register_mode(&newmode);
748 /* Auxiliary Modes */
749 newmode.sort = irms_auxiliary,
752 newmode.name = new_id_from_chars("T", 1);
753 newmode.code = irm_T;
755 mode_T = register_mode(&newmode);
758 newmode.name = new_id_from_chars("ANY", 3);
759 newmode.code = irm_ANY;
761 mode_ANY = register_mode(&newmode);
764 newmode.name = new_id_from_chars("BAD", 3);
765 newmode.code = irm_BAD;
767 mode_BAD = register_mode(&newmode);
769 /* Internal Boolean Modes */
770 newmode.sort = irms_internal_boolean;
773 newmode.name = new_id_from_chars("b", 1);
774 newmode.code = irm_b;
776 mode_b = register_mode(&newmode);
779 newmode.vector_elem = 1;
781 /* Float Number Modes */
782 newmode.sort = irms_float_number;
783 newmode.arithmetic = irma_ieee754;
786 newmode.name = new_id_from_chars("F", 1);
787 newmode.code = irm_F;
791 mode_F = register_mode(&newmode);
794 newmode.name = new_id_from_chars("D", 1);
795 newmode.code = irm_D;
799 mode_D = register_mode(&newmode);
802 newmode.name = new_id_from_chars("E", 1);
803 newmode.code = irm_E;
807 mode_E = register_mode(&newmode);
809 /* Integer Number Modes */
810 newmode.sort = irms_int_number;
811 newmode.arithmetic = irma_twos_complement;
814 newmode.name = new_id_from_chars("Bs", 2);
815 newmode.code = irm_Bs;
818 newmode.modulo_shift = 32;
820 mode_Bs = register_mode(&newmode);
823 newmode.name = new_id_from_chars("Bu", 2);
824 newmode.code = irm_Bu;
825 newmode.arithmetic = irma_twos_complement;
828 newmode.modulo_shift = 32;
830 mode_Bu = register_mode(&newmode);
832 /* signed short integer */
833 newmode.name = new_id_from_chars("Hs", 2);
834 newmode.code = irm_Hs;
837 newmode.modulo_shift = 32;
839 mode_Hs = register_mode(&newmode);
841 /* unsigned short integer */
842 newmode.name = new_id_from_chars("Hu", 2);
843 newmode.code = irm_Hu;
846 newmode.modulo_shift = 32;
848 mode_Hu = register_mode(&newmode);
851 newmode.name = new_id_from_chars("Is", 2);
852 newmode.code = irm_Is;
855 newmode.modulo_shift = 32;
857 mode_Is = register_mode(&newmode);
859 /* unsigned integer */
860 newmode.name = new_id_from_chars("Iu", 2);
861 newmode.code = irm_Iu;
864 newmode.modulo_shift = 32;
866 mode_Iu = register_mode(&newmode);
868 /* signed long integer */
869 newmode.name = new_id_from_chars("Ls", 2);
870 newmode.code = irm_Ls;
873 newmode.modulo_shift = 64;
875 mode_Ls = register_mode(&newmode);
877 /* unsigned long integer */
878 newmode.name = new_id_from_chars("Lu", 2);
879 newmode.code = irm_Lu;
882 newmode.modulo_shift = 64;
884 mode_Lu = register_mode(&newmode);
886 /* Character Modes */
887 newmode.sort = irms_character;
888 newmode.arithmetic = irma_twos_complement;
889 newmode.modulo_shift = 0;
892 newmode.name = new_id_from_chars("C", 1);
893 newmode.code = irm_C;
897 mode_C = register_mode(&newmode);
899 /* Unicode character */
900 newmode.name = new_id_from_chars("U", 1);
901 newmode.code = irm_U;
905 mode_U = register_mode(&newmode);
907 /* Reference Modes */
908 newmode.sort = irms_reference;
909 newmode.arithmetic = irma_twos_complement;
912 newmode.name = new_id_from_chars("P", 1);
913 newmode.code = irm_P;
916 newmode.modulo_shift = 0;
918 mode_P = register_mode(&newmode);
920 /* set the machine specific modes to the predefined ones */
921 mode_P_code = mode_P;
922 mode_P_data = mode_P;
925 /* find a signed mode for an unsigned integer mode */
926 ir_mode *find_unsigned_mode(const ir_mode *mode) {
929 if (mode->sort != irms_int_number);
931 return find_mode(&n);
934 /* find an unsigned mode for a signed integer mode */
935 ir_mode *find_signed_mode(const ir_mode *mode) {
938 assert(mode->sort == irms_int_number);
940 return find_mode(&n);
943 /* finds a integer mode with 2*n bits for an integer mode with n bits. */
944 ir_mode *find_double_bits_int_mode(const ir_mode *mode) {
947 assert(mode->sort == irms_int_number && mode->arithmetic == irma_twos_complement);
949 n.size = 2*mode->size;
950 return find_mode(&n);
954 * Returns non-zero if the given mode honors signed zero's, i.e.,
955 * a +0 and a -0 exists and handled differently.
957 int mode_honor_signed_zeros(const ir_mode *mode)
959 /* for floating point, we know that IEEE 754 has +0 and -0,
960 * but always handles it identical.
962 if (mode->sort == irms_float_number)
963 return mode->arithmetic == irma_ieee754 ? 0 : 1;
968 * Returns non-zero if the given mode might overflow on unary Minus.
970 * This does NOT happen on IEEE 754.
972 int mode_overflow_on_unary_Minus(const ir_mode *mode)
974 if (mode->sort == irms_float_number)
975 return mode->arithmetic == irma_ieee754 ? 0 : 1;
980 * Returns non-zero if the mode has a reversed wrap-aound
981 * logic, especially (a + x) - x == a.
983 * This is normally true for integer modes, not for floating
986 int mode_wrap_around(const ir_mode *mode) {
987 /* FIXME: better would be an extra mode property */
988 return mode_is_int(mode);
991 void finish_mode(void) {
992 obstack_free(&modes, 0);