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"
33 static long long count = 0;
34 # define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
36 # define ANNOUNCE() ((void)0)
44 /** dynamic array to hold all modes */
45 static struct obstack modes;
47 /** number of defined modes */
55 * Compare modes that don't need to have their code field
58 * TODO: Add other fields
60 INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n)
63 if (m->sort == n->sort &&
64 m->arithmetic == n->arithmetic &&
67 m->modulo_shift == n->modulo_shift &&
68 m->vector_elem == n->vector_elem)
75 * calculates the next obstack address
77 static void *next_obstack_adr(struct obstack *o, void *p, size_t s)
79 PTR_INT_TYPE adr = __PTR_TO_INT((char *)p);
80 int mask = obstack_alignment_mask(o);
84 return __INT_TO_PTR(adr & ~mask);
88 * searches the modes obstack for the given mode and returns
89 * a pointer on an equal mode already in the array, NULL if
92 static ir_mode *find_mode(const ir_mode *m)
95 struct _obstack_chunk *p;
98 n = (ir_mode *)p->contents;
99 nn = next_obstack_adr(&modes, n, sizeof(*n));
100 for (; (char *)nn <= modes.next_free;) {
102 if (modes_are_equal(n, m))
106 nn = next_obstack_adr(&modes, n, sizeof(*n));
109 for (p = p->prev; p; p = p->prev) {
110 n = (ir_mode *)p->contents;
111 nn = next_obstack_adr(&modes, n, sizeof(*n));
112 for (; (char *)nn < p->limit;) {
114 if (modes_are_equal(n, m))
118 nn = next_obstack_adr(&modes, n, sizeof(*n));
126 * sets special values of modes
128 static void set_mode_values(ir_mode* mode)
130 switch (get_mode_sort(mode))
133 case irms_int_number:
134 case irms_float_number:
135 mode->min = get_tarval_min(mode);
136 mode->max = get_tarval_max(mode);
137 mode->null = get_tarval_null(mode);
138 mode->one = get_tarval_one(mode);
139 mode->minus_one = get_tarval_minus_one(mode);
142 case irms_internal_boolean:
143 mode->min = tarval_b_false;
144 mode->max = tarval_b_true;
145 mode->null = tarval_b_false;
146 mode->one = tarval_b_true;
147 mode->minus_one = tarval_bad;
151 mode->min = tarval_bad;
152 mode->max = tarval_bad;
153 mode->null = get_tarval_null(mode);
154 mode->one = tarval_bad;
155 mode->minus_one = tarval_bad;
160 case irms_control_flow:
161 mode->min = tarval_bad;
162 mode->max = tarval_bad;
163 mode->null = tarval_bad;
164 mode->one = tarval_bad;
165 mode->minus_one = tarval_bad;
171 * globals defined in irmode.h
174 /* --- Predefined modes --- */
176 /* FIRM internal modes: */
184 /* predefined numerical modes: */
185 ir_mode *mode_F; /* float */
186 ir_mode *mode_D; /* double */
187 ir_mode *mode_E; /* long double */
189 ir_mode *mode_Bs; /* integral values, signed and unsigned */
190 ir_mode *mode_Bu; /* 8 bit */
191 ir_mode *mode_Hs; /* 16 bit */
193 ir_mode *mode_Is; /* 32 bit */
195 ir_mode *mode_Ls; /* 64 bit */
203 /* machine specific modes */
204 ir_mode *mode_P_code; /**< machine specific pointer mode for code addresses */
205 ir_mode *mode_P_data; /**< machine specific pointer mode for data addresses */
208 * functions defined in irmode.h
211 /* JNI access functions */
212 ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
213 ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
214 ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
215 ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
216 ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
217 ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
218 ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
219 ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
220 ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
221 ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
222 ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
223 ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
224 ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
225 ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
226 ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
227 ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
228 ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
229 ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
230 ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
231 ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
232 ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
235 ir_mode *(get_modeP_code)(void) {
237 return _get_modeP_code();
240 ir_mode *(get_modeP_data)(void) {
242 return _get_modeP_data();
245 void set_modeP_code(ir_mode *p) {
246 assert(mode_is_reference(p));
251 void set_modeP_data(ir_mode *p) {
252 assert(mode_is_reference(p));
258 * Registers a new mode.
260 * @param new_mode The new mode template.
262 static ir_mode *register_mode(const ir_mode *new_mode)
264 ir_mode *mode = NULL;
269 /* copy mode struct to modes array */
270 mode = (ir_mode *)obstack_copy(&modes, new_mode, sizeof(*mode));
272 mode->kind = k_ir_mode;
273 if (num_modes >= irm_max) mode->code = num_modes;
276 /* add the new mode to the irp list of modes */
279 set_mode_values(mode);
281 hook_new_mode(new_mode, mode);
286 * Creates a new mode.
288 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int sign,
289 mode_arithmetic arithmetic, unsigned int modulo_shift )
292 ir_mode *mode = NULL;
294 mode_tmpl.name = new_id_from_str(name);
295 mode_tmpl.sort = sort;
296 mode_tmpl.size = bit_size;
297 mode_tmpl.sign = sign ? 1 : 0;
298 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
299 mode_tmpl.vector_elem = 1;
300 mode_tmpl.arithmetic = arithmetic;
301 mode_tmpl.link = NULL;
302 mode_tmpl.tv_priv = NULL;
304 mode = find_mode(&mode_tmpl);
306 hook_new_mode(&mode_tmpl, mode);
314 case irms_control_flow:
316 case irms_internal_boolean:
317 assert(0 && "internal modes cannot be user defined");
320 case irms_float_number:
321 case irms_int_number:
324 mode = register_mode(&mode_tmpl);
330 * Creates a new vector mode.
332 ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int sign,
333 mode_arithmetic arithmetic, unsigned int modulo_shift )
336 ir_mode *mode = NULL;
338 mode_tmpl.name = new_id_from_str(name);
339 mode_tmpl.sort = sort;
340 mode_tmpl.size = bit_size * num_of_elem;
341 mode_tmpl.sign = sign ? 1 : 0;
342 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
343 mode_tmpl.vector_elem = num_of_elem;
344 mode_tmpl.arithmetic = arithmetic;
345 mode_tmpl.link = NULL;
346 mode_tmpl.tv_priv = NULL;
348 mode = find_mode(&mode_tmpl);
350 hook_new_mode(&mode_tmpl, mode);
354 if (num_of_elem <= 1) {
355 assert(0 && "vector modes should have at least 2 elements");
363 case irms_control_flow:
365 case irms_internal_boolean:
366 assert(0 && "internal modes cannot be user defined");
371 assert(0 && "only integer and floating point modes can be vectorized");
374 case irms_float_number:
375 assert(0 && "not yet implemented");
378 case irms_int_number:
379 mode = register_mode(&mode_tmpl);
384 /* Functions for the direct access to all attributes of an ir_mode */
386 (get_mode_modecode)(const ir_mode *mode)
389 return _get_mode_modecode(mode);
393 (get_mode_ident)(const ir_mode *mode)
396 return _get_mode_ident(mode);
400 get_mode_name(const ir_mode *mode)
403 return get_id_str(mode->name);
407 (get_mode_sort)(const ir_mode* mode)
410 return _get_mode_sort(mode);
414 (get_mode_size_bits)(const ir_mode *mode)
417 return _get_mode_size_bits(mode);
421 (get_mode_size_bytes)(const ir_mode *mode) {
423 return _get_mode_size_bytes(mode);
427 (get_mode_sign)(const ir_mode *mode)
430 return _get_mode_sign(mode);
434 (get_mode_arithmetic)(const ir_mode *mode)
437 return get_mode_arithmetic(mode);
441 /* Attribute modulo shift specifies for modes of kind irms_int_number
442 * whether shift applies modulo to value of bits to shift. Asserts
443 * if mode is not irms_int_number.
446 (get_mode_modulo_shift)(const ir_mode *mode) {
447 return _get_mode_modulo_shift(mode);
451 (get_mode_n_vector_elems)(const ir_mode *mode) {
452 return _get_mode_vector_elems(mode);
456 (get_mode_link)(const ir_mode *mode)
459 return _get_mode_link(mode);
463 (set_mode_link)(ir_mode *mode, void *l)
465 _set_mode_link(mode, l);
469 get_mode_min (ir_mode *mode)
473 assert(get_mode_modecode(mode) < num_modes);
474 assert(mode_is_data(mode));
480 get_mode_max (ir_mode *mode)
484 assert(get_mode_modecode(mode) < num_modes);
485 assert(mode_is_data(mode));
491 get_mode_null (ir_mode *mode)
495 assert(get_mode_modecode(mode) < num_modes);
496 assert(mode_is_data(mode));
502 get_mode_one (ir_mode *mode)
506 assert(get_mode_modecode(mode) < num_modes);
507 assert(mode_is_data(mode));
513 get_mode_minus_one (ir_mode *mode)
517 assert(get_mode_modecode(mode) < num_modes);
518 assert(mode_is_data(mode));
520 return mode->minus_one;
524 get_mode_infinite(ir_mode *mode)
528 assert(get_mode_modecode(mode) < num_modes);
529 assert(mode_is_float(mode));
531 return get_tarval_plus_inf(mode);
535 get_mode_NAN(ir_mode *mode)
539 assert(get_mode_modecode(mode) < num_modes);
540 assert(mode_is_float(mode));
542 return get_tarval_nan(mode);
546 is_mode (void *thing) {
547 if (get_kind(thing) == k_ir_mode)
554 (mode_is_signed)(const ir_mode *mode) {
556 return _mode_is_signed(mode);
560 (mode_is_float)(const ir_mode *mode) {
562 return _mode_is_float(mode);
566 (mode_is_int)(const ir_mode *mode) {
568 return _mode_is_int(mode);
572 (mode_is_character)(const ir_mode *mode) {
574 return _mode_is_character(mode);
578 (mode_is_reference)(const ir_mode *mode) {
580 return _mode_is_reference(mode);
584 (mode_is_num)(const ir_mode *mode) {
586 return _mode_is_num(mode);
590 (mode_is_numP)(const ir_mode *mode) {
592 return _mode_is_numP(mode);
596 (mode_is_data)(const ir_mode *mode) {
598 return _mode_is_data(mode);
602 (mode_is_datab)(const ir_mode *mode) {
604 return _mode_is_datab(mode);
608 (mode_is_dataM)(const ir_mode *mode) {
610 return _mode_is_dataM(mode);
614 (mode_is_float_vector)(const ir_mode *mode) {
616 return _mode_is_float_vector(mode);
620 (mode_is_int_vector)(const ir_mode *mode) {
622 return _mode_is_int_vector(mode);
625 /* Returns true if sm can be converted to lm without loss. */
627 smaller_mode(const ir_mode *sm, const ir_mode *lm)
629 int sm_bits, lm_bits;
635 if (sm == lm) return 1;
637 sm_bits = get_mode_size_bits(sm);
638 lm_bits = get_mode_size_bits(lm);
640 switch(get_mode_sort(sm))
642 case irms_int_number:
643 switch(get_mode_sort(lm))
645 case irms_int_number:
646 /* integers are convertable if
647 * - both have the same sign and lm is the larger one
648 * - lm is the signed one and is at least two bits larger
649 * (one for the sign, one for the highest bit of sm)
650 * - sm & lm are two_complement and lm has greater or equal number of bits
652 if ( get_mode_arithmetic(sm) == get_mode_arithmetic(lm)
653 && get_mode_arithmetic(sm) == irma_twos_complement) {
654 return lm_bits >= sm_bits;
656 else if (mode_is_signed(sm))
658 if ( mode_is_signed(lm) && (lm_bits >= sm_bits) )
661 else if (mode_is_signed(lm))
663 if (lm_bits > sm_bits + 1)
666 else if (lm_bits >= sm_bits)
672 case irms_float_number:
673 /* int to float works if the float is large enough */
681 case irms_float_number:
682 if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
683 if ( (get_mode_sort(lm) == irms_float_number)
684 && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
690 /* do exist machines out there with different pointer lenghts ?*/
701 /* initialization, build the default modes */
707 /* init flexible array */
709 obstack_init(&modes);
712 /* initialize predefined modes */
715 newmode.arithmetic = irma_none;
718 newmode.modulo_shift = 0;
719 newmode.vector_elem = 0;
721 newmode.tv_priv = NULL;
723 /* Control Flow Modes*/
724 newmode.sort = irms_control_flow;
727 newmode.name = new_id_from_chars("BB", 2);
728 newmode.code = irm_BB;
730 mode_BB = register_mode(&newmode);
733 newmode.name = new_id_from_chars("X", 1);
734 newmode.code = irm_X;
736 mode_X = register_mode(&newmode);
739 newmode.sort = irms_memory;
742 newmode.name = new_id_from_chars("M", 1);
743 newmode.code = irm_M;
745 mode_M = register_mode(&newmode);
747 /* Auxiliary Modes */
748 newmode.sort = irms_auxiliary,
751 newmode.name = new_id_from_chars("T", 1);
752 newmode.code = irm_T;
754 mode_T = register_mode(&newmode);
757 newmode.name = new_id_from_chars("ANY", 3);
758 newmode.code = irm_ANY;
760 mode_ANY = register_mode(&newmode);
763 newmode.name = new_id_from_chars("BAD", 3);
764 newmode.code = irm_BAD;
766 mode_BAD = register_mode(&newmode);
768 /* Internal Boolean Modes */
769 newmode.sort = irms_internal_boolean;
772 newmode.name = new_id_from_chars("b", 1);
773 newmode.code = irm_b;
775 mode_b = register_mode(&newmode);
778 newmode.vector_elem = 1;
780 /* Float Number Modes */
781 newmode.sort = irms_float_number;
782 newmode.arithmetic = irma_ieee754;
785 newmode.name = new_id_from_chars("F", 1);
786 newmode.code = irm_F;
790 mode_F = register_mode(&newmode);
793 newmode.name = new_id_from_chars("D", 1);
794 newmode.code = irm_D;
798 mode_D = register_mode(&newmode);
801 newmode.name = new_id_from_chars("E", 1);
802 newmode.code = irm_E;
806 mode_E = register_mode(&newmode);
808 /* Integer Number Modes */
809 newmode.sort = irms_int_number;
810 newmode.arithmetic = irma_twos_complement;
813 newmode.name = new_id_from_chars("Bs", 2);
814 newmode.code = irm_Bs;
817 newmode.modulo_shift = 32;
819 mode_Bs = register_mode(&newmode);
822 newmode.name = new_id_from_chars("Bu", 2);
823 newmode.code = irm_Bu;
824 newmode.arithmetic = irma_twos_complement;
827 newmode.modulo_shift = 32;
829 mode_Bu = register_mode(&newmode);
831 /* signed short integer */
832 newmode.name = new_id_from_chars("Hs", 2);
833 newmode.code = irm_Hs;
836 newmode.modulo_shift = 32;
838 mode_Hs = register_mode(&newmode);
840 /* unsigned short integer */
841 newmode.name = new_id_from_chars("Hu", 2);
842 newmode.code = irm_Hu;
845 newmode.modulo_shift = 32;
847 mode_Hu = register_mode(&newmode);
850 newmode.name = new_id_from_chars("Is", 2);
851 newmode.code = irm_Is;
854 newmode.modulo_shift = 32;
856 mode_Is = register_mode(&newmode);
858 /* unsigned integer */
859 newmode.name = new_id_from_chars("Iu", 2);
860 newmode.code = irm_Iu;
863 newmode.modulo_shift = 32;
865 mode_Iu = register_mode(&newmode);
867 /* signed long integer */
868 newmode.name = new_id_from_chars("Ls", 2);
869 newmode.code = irm_Ls;
872 newmode.modulo_shift = 64;
874 mode_Ls = register_mode(&newmode);
876 /* unsigned long integer */
877 newmode.name = new_id_from_chars("Lu", 2);
878 newmode.code = irm_Lu;
881 newmode.modulo_shift = 64;
883 mode_Lu = register_mode(&newmode);
885 /* Character Modes */
886 newmode.sort = irms_character;
887 newmode.arithmetic = irma_twos_complement;
888 newmode.modulo_shift = 0;
891 newmode.name = new_id_from_chars("C", 1);
892 newmode.code = irm_C;
896 mode_C = register_mode(&newmode);
898 /* Unicode character */
899 newmode.name = new_id_from_chars("U", 1);
900 newmode.code = irm_U;
904 mode_U = register_mode(&newmode);
906 /* Reference Modes */
907 newmode.sort = irms_reference;
908 newmode.arithmetic = irma_twos_complement;
911 newmode.name = new_id_from_chars("P", 1);
912 newmode.code = irm_P;
915 newmode.modulo_shift = 0;
917 mode_P = register_mode(&newmode);
919 /* set the machine specific modes to the predefined ones */
920 mode_P_code = mode_P;
921 mode_P_data = mode_P;
924 /* find a signed mode for an unsigned integer mode */
925 ir_mode *find_unsigned_mode(const ir_mode *mode) {
928 if (mode->sort != irms_int_number);
930 return find_mode(&n);
933 /* find an unsigned mode for a signed integer mode */
934 ir_mode *find_signed_mode(const ir_mode *mode) {
937 assert(mode->sort == irms_int_number);
939 return find_mode(&n);
942 /* finds a integer mode with 2*n bits for an integer mode with n bits. */
943 ir_mode *find_double_bits_int_mode(const ir_mode *mode) {
946 assert(mode->sort == irms_int_number && mode->arithmetic == irma_twos_complement);
948 n.size = 2*mode->size;
949 return find_mode(&n);
953 * Returns non-zero if the given mode honors signed zero's, i.e.,
954 * a +0 and a -0 exists and handled differently.
956 int mode_honor_signed_zeros(const ir_mode *mode)
958 /* for floating point, we know that IEEE 754 has +0 and -0,
959 * but always handles it identical.
961 if (mode->sort == irms_float_number)
962 return mode->arithmetic == irma_ieee754 ? 0 : 1;
967 * Returns non-zero if the given mode might overflow on unary Minus.
969 * This does NOT happen on IEEE 754.
971 int mode_overflow_on_unary_Minus(const ir_mode *mode)
973 if (mode->sort == irms_float_number)
974 return mode->arithmetic == irma_ieee754 ? 0 : 1;
979 * Returns non-zero if the mode has a reversed wrap-aound
980 * logic, especially (a + x) - x == a.
982 * This is normally true for integer modes, not for floating
985 int mode_wrap_around(const ir_mode *mode) {
986 /* FIXME: better would be an extra mode property */
987 return mode_is_int(mode);
990 void finish_mode(void) {
991 obstack_free(&modes, 0);