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.
23 # include "irmode_t.h"
29 static long long count = 0;
30 # define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
32 # define ANNOUNCE() ((void)0)
40 /** dynamic array to hold all modes */
41 static struct obstack modes;
43 /** number of defined modes */
51 * Compare modes that don't need to have their code field
54 * TODO: Add other fields
56 INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n)
59 if (m->sort == n->sort &&
60 m->arithmetic == n->arithmetic &&
62 m->align == n->align &&
64 m->modulo_shift == n->modulo_shift &&
65 m->vector_elem == n->vector_elem)
72 * calculates the next obstack address
74 static void *next_obstack_adr(struct obstack *o, void *p, size_t s)
76 PTR_INT_TYPE adr = __PTR_TO_INT((char *)p);
77 int mask = obstack_alignment_mask(o);
81 return __INT_TO_PTR(adr & ~mask);
85 * searches the modes obstack for the given mode and returns
86 * a pointer on an equal mode already in the array, NULL if
89 static ir_mode *find_mode(const ir_mode *m)
92 struct _obstack_chunk *p;
95 n = (ir_mode *)p->contents;
96 nn = next_obstack_adr(&modes, n, sizeof(*n));
97 for (; (char *)nn <= modes.next_free;) {
99 if (modes_are_equal(n, m))
103 nn = next_obstack_adr(&modes, n, sizeof(*n));
106 for (p = p->prev; p; p = p->prev) {
107 n = (ir_mode *)p->contents;
108 nn = next_obstack_adr(&modes, n, sizeof(*n));
109 for (; (char *)nn < p->limit;) {
111 if (modes_are_equal(n, m))
115 nn = next_obstack_adr(&modes, n, sizeof(*n));
123 * sets special values of modes
125 static void set_mode_values(ir_mode* mode)
127 switch (get_mode_sort(mode))
130 case irms_int_number:
131 case irms_float_number:
132 mode->min = get_tarval_min(mode);
133 mode->max = get_tarval_max(mode);
134 mode->null = get_tarval_null(mode);
135 mode->one = get_tarval_one(mode);
138 case irms_internal_boolean:
139 mode->min = tarval_b_false;
140 mode->max = tarval_b_true;
141 mode->null = tarval_b_false;
142 mode->one = tarval_b_true;
146 mode->min = tarval_bad;
147 mode->max = tarval_bad;
148 mode->null = (get_mode_modecode(mode) == irm_P) ? tarval_P_void : tarval_bad;
149 mode->one = tarval_bad;
154 case irms_control_flow:
155 mode->min = tarval_bad;
156 mode->max = tarval_bad;
157 mode->null = tarval_bad;
158 mode->one = tarval_bad;
164 * globals defined in irmode.h
167 /* --- Predefined modes --- */
169 /* FIRM internal modes: */
177 /* predefined numerical modes: */
178 ir_mode *mode_F; /* float */
179 ir_mode *mode_D; /* double */
180 ir_mode *mode_E; /* long double */
182 ir_mode *mode_Bs; /* integral values, signed and unsigned */
183 ir_mode *mode_Bu; /* 8 bit */
184 ir_mode *mode_Hs; /* 16 bit */
186 ir_mode *mode_Is; /* 32 bit */
188 ir_mode *mode_Ls; /* 64 bit */
196 /* machine specific modes */
197 ir_mode *mode_P_mach; /* machine specific pointer mode */
200 * functions defined in irmode.h
203 /* JNI access functions */
204 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
205 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
206 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
207 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
208 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
209 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
210 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
211 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
212 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
213 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
214 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
215 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
216 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
217 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
218 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
219 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
220 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
221 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
222 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
223 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
224 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
227 ir_mode *get_modeP_mach(void) { ANNOUNCE(); return mode_P_mach; }
228 void set_modeP_mach(ir_mode *p) {
230 assert(mode_is_reference(p));
235 * Registers a new mode if not defined yet, else returns
236 * the "equivalent" one.
238 static ir_mode *register_mode(const ir_mode* new_mode)
240 ir_mode *mode = NULL;
245 /* copy mode struct to modes array */
246 mode = (ir_mode*)obstack_copy(&modes, new_mode, sizeof(ir_mode));
248 mode->kind = k_ir_mode;
249 if(num_modes>=irm_max) mode->code = num_modes;
252 set_mode_values(mode);
258 * Creates a new mode.
260 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign,
261 mode_arithmetic arithmetic, unsigned int modulo_shift )
266 mode_tmpl.name = new_id_from_str(name);
267 mode_tmpl.sort = sort;
268 mode_tmpl.size = bit_size;
269 mode_tmpl.align = align;
270 mode_tmpl.sign = sign ? 1 : 0;
271 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
272 mode_tmpl.vector_elem = 1;
273 mode_tmpl.arithmetic = arithmetic;
274 mode_tmpl.link = NULL;
275 mode_tmpl.tv_priv = NULL;
277 mode = find_mode(&mode_tmpl);
287 case irms_control_flow:
289 case irms_internal_boolean:
290 assert(0 && "internal modes cannot be user defined");
293 case irms_float_number:
294 case irms_int_number:
297 return register_mode(&mode_tmpl);
299 return NULL; /* to shut up gcc */
303 * Creates a new vector mode.
305 ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int align, int sign,
306 mode_arithmetic arithmetic, unsigned int modulo_shift )
311 mode_tmpl.name = new_id_from_str(name);
312 mode_tmpl.sort = sort;
313 mode_tmpl.size = bit_size * num_of_elem;
314 mode_tmpl.align = align;
315 mode_tmpl.sign = sign ? 1 : 0;
316 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
317 mode_tmpl.vector_elem = num_of_elem;
318 mode_tmpl.arithmetic = arithmetic;
319 mode_tmpl.link = NULL;
320 mode_tmpl.tv_priv = NULL;
322 mode = find_mode(&mode_tmpl);
326 if (num_of_elem <= 1) {
327 assert(0 && "vector modes should have at least 2 elements");
335 case irms_control_flow:
337 case irms_internal_boolean:
338 assert(0 && "internal modes cannot be user defined");
343 assert(0 && "only integer and floating point modes can be vectorized");
346 case irms_float_number:
347 assert(0 && "not yet implemented");
350 case irms_int_number:
351 return register_mode(&mode_tmpl);
353 return NULL; /* to shut up gcc */
356 /* Functions for the direct access to all attributes od a ir_mode */
358 get_mode_modecode(const ir_mode *mode)
365 get_mode_ident(const ir_mode *mode)
372 get_mode_name(const ir_mode *mode)
375 return get_id_str(mode->name);
379 get_mode_sort(const ir_mode* mode)
386 get_mode_size_bits(const ir_mode *mode)
392 int get_mode_size_bytes(const ir_mode *mode) {
393 int size = get_mode_size_bits(mode);
395 if ((size & 7) != 0) return -1;
400 get_mode_align (const ir_mode *mode)
407 get_mode_sign (const ir_mode *mode)
413 int get_mode_arithmetic (const ir_mode *mode)
416 return mode->arithmetic;
420 /* Attribute modulo shift specifies for modes of kind irms_int_number
421 * whether shift applies modulo to value of bits to shift. Asserts
422 * if mode is not irms_int_number.
424 unsigned int get_mode_modulo_shift(const ir_mode *mode) {
425 return mode->modulo_shift;
428 unsigned int get_mode_vector_elems(const ir_mode *mode) {
429 return mode->vector_elem;
432 void *get_mode_link(const ir_mode *mode)
438 void set_mode_link(ir_mode *mode, void *l)
445 get_mode_min (ir_mode *mode)
449 assert(get_mode_modecode(mode) < num_modes);
450 assert(mode_is_data(mode));
456 get_mode_max (ir_mode *mode)
460 assert(get_mode_modecode(mode) < num_modes);
461 assert(mode_is_data(mode));
467 get_mode_null (ir_mode *mode)
471 assert(get_mode_modecode(mode) < num_modes);
472 assert(mode_is_data(mode));
478 get_mode_one (ir_mode *mode)
482 assert(get_mode_modecode(mode) < num_modes);
483 assert(mode_is_data(mode));
489 get_mode_infinite(ir_mode *mode)
493 assert(get_mode_modecode(mode) < num_modes);
494 assert(mode_is_float(mode));
496 return get_tarval_inf(mode);
500 get_mode_NAN(ir_mode *mode)
504 assert(get_mode_modecode(mode) < num_modes);
505 assert(mode_is_float(mode));
507 return get_tarval_nan(mode);
511 is_mode (void *thing) {
513 if (get_kind(thing) == k_ir_mode)
519 /* Functions to check, whether a modecode is signed, float, int, num, data,
520 datab or dataM. For more exact definitions read the corresponding pages
521 in the firm documentation or the followingenumeration
523 The set of "float" is defined as:
524 ---------------------------------
525 float = {irm_F, irm_D, irm_E}
527 The set of "int" is defined as:
528 -------------------------------
529 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
531 The set of "num" is defined as:
532 -------------------------------
533 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
534 irm_Is, irm_Iu, irm_Ls, irm_Lu}
537 The set of "data" is defined as:
538 -------------------------------
539 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
540 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
541 = {num || irm_C || irm_U || irm_P}
543 The set of "datab" is defined as:
544 ---------------------------------
545 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
546 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
549 The set of "dataM" is defined as:
550 ---------------------------------
551 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
552 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
556 #ifdef MODE_ACCESS_DEFINES
557 # undef mode_is_signed
558 # undef mode_is_float
563 # undef mode_is_datab
564 # undef mode_is_dataM
567 mode_is_signed (const ir_mode *mode)
575 mode_is_float (const ir_mode *mode)
579 return (get_mode_sort(mode) == irms_float_number);
583 mode_is_int (const ir_mode *mode)
587 return (get_mode_sort(mode) == irms_int_number);
590 int mode_is_character (const ir_mode *mode)
594 return (get_mode_sort(mode) == irms_character);
597 int mode_is_reference (const ir_mode *mode)
601 return (get_mode_sort(mode) == irms_reference);
605 mode_is_num (const ir_mode *mode)
609 return (mode_is_int(mode) || mode_is_float(mode));
613 mode_is_numP (const ir_mode *mode)
617 return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
621 mode_is_data (const ir_mode *mode)
625 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
629 mode_is_datab (const ir_mode *mode)
633 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
637 mode_is_dataM (const ir_mode *mode)
641 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
645 mode_is_float_vector (const ir_mode *mode)
649 return (get_mode_sort(mode) == irms_float_number) && (get_mode_vector_elems(mode) > 1);
653 mode_is_int_vector (const ir_mode *mode)
657 return (get_mode_sort(mode) == irms_int_number) && (get_mode_vector_elems(mode) > 1);
660 #ifdef MODE_ACCESS_DEFINES
661 # define mode_is_signed(mode) (mode)->sign
662 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
663 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
664 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
665 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
666 # define mode_is_datab(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference) || ((mode)->sort == irms_internal_boolean))
667 # define mode_is_dataM(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference) || ((mode)->code == irm_M))
668 # define mode_is_float_vector(mode) (((mode)->sort == irms_float_number) && ((mode)->vector_elem > 1))
669 # define mode_is_int_vector(mode) (((mode)->sort == irms_int_number) && ((mode)->vector_elem > 1))
671 /* Returns true if sm can be converted to lm without loss. */
673 smaller_mode(const ir_mode *sm, const ir_mode *lm)
675 int sm_bits, lm_bits;
681 if (sm == lm) return 1;
683 sm_bits = get_mode_size_bits(sm);
684 lm_bits = get_mode_size_bits(lm);
686 switch(get_mode_sort(sm))
688 case irms_int_number:
689 switch(get_mode_sort(lm))
691 case irms_int_number:
692 /* integers are convertable if
693 * - both have the same sign and lm is the larger one
694 * - lm is the signed one and is at least two bits larger
695 * (one for the sign, one for the highest bit of sm)
696 * - sm & lm are two_complement and lm has greater or equal number of bits
698 if ( get_mode_arithmetic(sm) == get_mode_arithmetic(lm)
699 && get_mode_arithmetic(sm) == irma_twos_complement) {
700 return lm_bits >= sm_bits;
702 else if (mode_is_signed(sm))
704 if ( mode_is_signed(lm) && (lm_bits >= sm_bits) )
707 else if (mode_is_signed(lm))
709 if (lm_bits > sm_bits + 1)
712 else if (lm_bits >= sm_bits)
718 case irms_float_number:
719 /* int to float works if the float is large enough */
727 case irms_float_number:
728 if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
729 if ( (get_mode_sort(lm) == irms_float_number)
730 && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
736 /* do exist machines out there with different pointer lenghts ?*/
747 /* ** initialization ** */
753 /* init flexible array */
755 obstack_init(&modes);
758 /* initialize predefined modes */
761 newmode.arithmetic = irma_none;
765 newmode.modulo_shift = 0;
766 newmode.vector_elem = 0;
768 newmode.tv_priv = NULL;
770 /* Control Flow Modes*/
771 newmode.sort = irms_control_flow;
774 newmode.name = id_from_str("BB", 2);
775 newmode.code = irm_BB;
777 mode_BB = register_mode(&newmode);
780 newmode.name = id_from_str("X", 1);
781 newmode.code = irm_X;
783 mode_X = register_mode(&newmode);
786 newmode.sort = irms_memory;
789 newmode.name = id_from_str("M", 1);
790 newmode.code = irm_M;
792 mode_M = register_mode(&newmode);
794 /* Auxiliary Modes */
795 newmode.sort = irms_auxiliary,
798 newmode.name = id_from_str("T", 1);
799 newmode.code = irm_T;
801 mode_T = register_mode(&newmode);
804 newmode.name = id_from_str("ANY", 3);
805 newmode.code = irm_ANY;
807 mode_ANY = register_mode(&newmode);
810 newmode.name = id_from_str("BAD", 3);
811 newmode.code = irm_BAD;
813 mode_BAD = register_mode(&newmode);
815 /* Internal Boolean Modes */
816 newmode.sort = irms_internal_boolean;
819 newmode.name = id_from_str("b", 1);
820 newmode.code = irm_b;
822 mode_b = register_mode(&newmode);
825 newmode.vector_elem = 1;
827 /* Float Number Modes */
828 newmode.sort = irms_float_number;
829 newmode.arithmetic = irma_ieee754;
832 newmode.name = id_from_str("F", 1);
833 newmode.code = irm_F;
838 mode_F = register_mode(&newmode);
841 newmode.name = id_from_str("D", 1);
842 newmode.code = irm_D;
847 mode_D = register_mode(&newmode);
850 newmode.name = id_from_str("E", 1);
851 newmode.code = irm_E;
856 mode_E = register_mode(&newmode);
858 /* Integer Number Modes */
859 newmode.sort = irms_int_number;
860 newmode.arithmetic = irma_twos_complement;
863 newmode.name = id_from_str("Bs", 2);
864 newmode.code = irm_Bs;
868 newmode.modulo_shift = 32;
870 mode_Bs = register_mode(&newmode);
873 newmode.name = id_from_str("Bu", 2);
874 newmode.code = irm_Bu;
875 newmode.arithmetic = irma_twos_complement;
879 newmode.modulo_shift = 32;
881 mode_Bu = register_mode(&newmode);
883 /* signed short integer */
884 newmode.name = id_from_str("Hs", 2);
885 newmode.code = irm_Hs;
889 newmode.modulo_shift = 32;
891 mode_Hs = register_mode(&newmode);
893 /* unsigned short integer */
894 newmode.name = id_from_str("Hu", 2);
895 newmode.code = irm_Hu;
899 newmode.modulo_shift = 32;
901 mode_Hu = register_mode(&newmode);
904 newmode.name = id_from_str("Is", 2);
905 newmode.code = irm_Is;
909 newmode.modulo_shift = 32;
911 mode_Is = register_mode(&newmode);
913 /* unsigned integer */
914 newmode.name = id_from_str("Iu", 2);
915 newmode.code = irm_Iu;
919 newmode.modulo_shift = 32;
921 mode_Iu = register_mode(&newmode);
923 /* signed long integer */
924 newmode.name = id_from_str("Ls", 2);
925 newmode.code = irm_Ls;
929 newmode.modulo_shift = 64;
931 mode_Ls = register_mode(&newmode);
933 /* unsigned long integer */
934 newmode.name = id_from_str("Lu", 2);
935 newmode.code = irm_Lu;
939 newmode.modulo_shift = 64;
941 mode_Lu = register_mode(&newmode);
943 /* Character Modes */
944 newmode.sort = irms_character;
945 newmode.arithmetic = irma_none;
948 newmode.name = id_from_str("C", 1);
949 newmode.code = irm_C;
953 newmode.modulo_shift = 32;
955 mode_C = register_mode(&newmode);
957 /* Unicode character */
958 newmode.name = id_from_str("U", 1);
959 newmode.code = irm_U;
963 newmode.modulo_shift = 32;
965 mode_U = register_mode(&newmode);
967 /* Reference Modes */
968 newmode.sort = irms_reference;
969 newmode.arithmetic = irma_twos_complement;
972 newmode.name = id_from_str("P", 1);
973 newmode.code = irm_P;
977 newmode.modulo_shift = 0;
979 mode_P = register_mode(&newmode);
981 /* set the machine specific modes to the predifined ones */
982 mode_P_mach = mode_P;
986 void finish_mode(void) {
987 obstack_free(&modes, 0);