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 assert(0 && "not yet implemented");
297 case irms_int_number:
300 return register_mode(&mode_tmpl);
302 return NULL; /* to shut up gcc */
306 * Creates a new vector mode.
308 ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int align, int sign,
309 mode_arithmetic arithmetic, unsigned int modulo_shift )
314 mode_tmpl.name = new_id_from_str(name);
315 mode_tmpl.sort = sort;
316 mode_tmpl.size = bit_size * num_of_elem;
317 mode_tmpl.align = align;
318 mode_tmpl.sign = sign ? 1 : 0;
319 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
320 mode_tmpl.vector_elem = num_of_elem;
321 mode_tmpl.arithmetic = arithmetic;
322 mode_tmpl.link = NULL;
323 mode_tmpl.tv_priv = NULL;
325 mode = find_mode(&mode_tmpl);
329 if (num_of_elem <= 1) {
330 assert(0 && "vector modes should have at least 2 elements");
338 case irms_control_flow:
340 case irms_internal_boolean:
341 assert(0 && "internal modes cannot be user defined");
346 assert(0 && "only integer and floating point modes can be vectorized");
349 case irms_float_number:
350 assert(0 && "not yet implemented");
353 case irms_int_number:
354 return register_mode(&mode_tmpl);
356 return NULL; /* to shut up gcc */
359 /* Functions for the direct access to all attributes od a ir_mode */
361 get_mode_modecode(const ir_mode *mode)
368 get_mode_ident(const ir_mode *mode)
375 get_mode_name(const ir_mode *mode)
378 return get_id_str(mode->name);
382 get_mode_sort(const ir_mode* mode)
389 get_mode_size_bits(const ir_mode *mode)
395 int get_mode_size_bytes(const ir_mode *mode) {
396 int size = get_mode_size_bits(mode);
398 if ((size & 7) != 0) return -1;
403 get_mode_align (const ir_mode *mode)
410 get_mode_sign (const ir_mode *mode)
416 int get_mode_arithmetic (const ir_mode *mode)
419 return mode->arithmetic;
423 /* Attribute modulo shift specifies for modes of kind irms_int_number
424 * whether shift applies modulo to value of bits to shift. Asserts
425 * if mode is not irms_int_number.
427 unsigned int get_mode_modulo_shift(const ir_mode *mode) {
428 return mode->modulo_shift;
431 unsigned int get_mode_vector_elems(const ir_mode *mode) {
432 return mode->vector_elem;
435 void *get_mode_link(const ir_mode *mode)
441 void set_mode_link(ir_mode *mode, void *l)
448 get_mode_min (ir_mode *mode)
452 assert(get_mode_modecode(mode) < num_modes);
453 assert(mode_is_data(mode));
459 get_mode_max (ir_mode *mode)
463 assert(get_mode_modecode(mode) < num_modes);
464 assert(mode_is_data(mode));
470 get_mode_null (ir_mode *mode)
474 assert(get_mode_modecode(mode) < num_modes);
475 assert(mode_is_data(mode));
481 get_mode_one (ir_mode *mode)
485 assert(get_mode_modecode(mode) < num_modes);
486 assert(mode_is_data(mode));
492 get_mode_infinite(ir_mode *mode)
496 assert(get_mode_modecode(mode) < num_modes);
497 assert(mode_is_float(mode));
499 return get_tarval_inf(mode);
503 get_mode_NAN(ir_mode *mode)
507 assert(get_mode_modecode(mode) < num_modes);
508 assert(mode_is_float(mode));
510 return get_tarval_nan(mode);
514 is_mode (void *thing) {
516 if (get_kind(thing) == k_ir_mode)
522 /* Functions to check, whether a modecode is signed, float, int, num, data,
523 datab or dataM. For more exact definitions read the corresponding pages
524 in the firm documentation or the followingenumeration
526 The set of "float" is defined as:
527 ---------------------------------
528 float = {irm_F, irm_D, irm_E}
530 The set of "int" is defined as:
531 -------------------------------
532 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
534 The set of "num" is defined as:
535 -------------------------------
536 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
537 irm_Is, irm_Iu, irm_Ls, irm_Lu}
540 The set of "data" is defined as:
541 -------------------------------
542 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
543 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
544 = {num || irm_C || irm_U || irm_P}
546 The set of "datab" is defined as:
547 ---------------------------------
548 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
549 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
552 The set of "dataM" is defined as:
553 ---------------------------------
554 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
555 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
559 #ifdef MODE_ACCESS_DEFINES
560 # undef mode_is_signed
561 # undef mode_is_float
566 # undef mode_is_datab
567 # undef mode_is_dataM
570 mode_is_signed (const ir_mode *mode)
578 mode_is_float (const ir_mode *mode)
582 return (get_mode_sort(mode) == irms_float_number);
586 mode_is_int (const ir_mode *mode)
590 return (get_mode_sort(mode) == irms_int_number);
593 int mode_is_character (const ir_mode *mode)
597 return (get_mode_sort(mode) == irms_character);
600 int mode_is_reference (const ir_mode *mode)
604 return (get_mode_sort(mode) == irms_reference);
608 mode_is_num (const ir_mode *mode)
612 return (mode_is_int(mode) || mode_is_float(mode));
616 mode_is_numP (const ir_mode *mode)
620 return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
624 mode_is_data (const ir_mode *mode)
628 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
632 mode_is_datab (const ir_mode *mode)
636 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
640 mode_is_dataM (const ir_mode *mode)
644 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
648 mode_is_float_vector (const ir_mode *mode)
652 return (get_mode_sort(mode) == irms_float_number) && (get_mode_vector_elems(mode) > 1);
656 mode_is_int_vector (const ir_mode *mode)
660 return (get_mode_sort(mode) == irms_int_number) && (get_mode_vector_elems(mode) > 1);
663 #ifdef MODE_ACCESS_DEFINES
664 # define mode_is_signed(mode) (mode)->sign
665 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
666 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
667 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
668 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
669 # 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))
670 # 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))
671 # define mode_is_float_vector(mode) (((mode)->sort == irms_float_number) && ((mode)->vector_elem > 1))
672 # define mode_is_int_vector(mode) (((mode)->sort == irms_int_number) && ((mode)->vector_elem > 1))
674 /* Returns true if sm can be converted to lm without loss. */
676 smaller_mode(const ir_mode *sm, const ir_mode *lm)
678 int sm_bits, lm_bits;
684 if (sm == lm) return 1;
686 sm_bits = get_mode_size_bits(sm);
687 lm_bits = get_mode_size_bits(lm);
689 switch(get_mode_sort(sm))
691 case irms_int_number:
692 switch(get_mode_sort(lm))
694 case irms_int_number:
695 /* integers are convertable if
696 * - both have the same sign and lm is the larger one
697 * - lm is the signed one and is at least two bits larger
698 * (one for the sign, one for the highest bit of sm)
699 * - sm & lm are two_complement and lm has greater or equal number of bits
701 if ( get_mode_arithmetic(sm) == get_mode_arithmetic(lm)
702 && get_mode_arithmetic(sm) == irma_twos_complement) {
703 return lm_bits >= sm_bits;
705 else if (mode_is_signed(sm))
707 if ( mode_is_signed(lm) && (lm_bits >= sm_bits) )
710 else if (mode_is_signed(lm))
712 if (lm_bits > sm_bits + 1)
715 else if (lm_bits >= sm_bits)
721 case irms_float_number:
722 /* int to float works if the float is large enough */
730 case irms_float_number:
731 if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
732 if ( (get_mode_sort(lm) == irms_float_number)
733 && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
739 /* do exist machines out there with different pointer lenghts ?*/
750 /* ** initialization ** */
756 /* init flexible array */
758 obstack_init(&modes);
761 /* initialize predefined modes */
764 newmode.arithmetic = irma_none;
768 newmode.modulo_shift = 0;
769 newmode.vector_elem = 0;
771 newmode.tv_priv = NULL;
773 /* Control Flow Modes*/
774 newmode.sort = irms_control_flow;
777 newmode.name = id_from_str("BB", 2);
778 newmode.code = irm_BB;
780 mode_BB = register_mode(&newmode);
783 newmode.name = id_from_str("X", 1);
784 newmode.code = irm_X;
786 mode_X = register_mode(&newmode);
789 newmode.sort = irms_memory;
792 newmode.name = id_from_str("M", 1);
793 newmode.code = irm_M;
795 mode_M = register_mode(&newmode);
797 /* Auxiliary Modes */
798 newmode.sort = irms_auxiliary,
801 newmode.name = id_from_str("T", 1);
802 newmode.code = irm_T;
804 mode_T = register_mode(&newmode);
807 newmode.name = id_from_str("ANY", 3);
808 newmode.code = irm_ANY;
810 mode_ANY = register_mode(&newmode);
813 newmode.name = id_from_str("BAD", 3);
814 newmode.code = irm_BAD;
816 mode_BAD = register_mode(&newmode);
818 /* Internal Boolean Modes */
819 newmode.sort = irms_internal_boolean;
822 newmode.name = id_from_str("b", 1);
823 newmode.code = irm_b;
825 mode_b = register_mode(&newmode);
828 newmode.vector_elem = 1;
830 /* Float Number Modes */
831 newmode.sort = irms_float_number;
832 newmode.arithmetic = irma_ieee754;
835 newmode.name = id_from_str("F", 1);
836 newmode.code = irm_F;
841 mode_F = register_mode(&newmode);
844 newmode.name = id_from_str("D", 1);
845 newmode.code = irm_D;
850 mode_D = register_mode(&newmode);
853 newmode.name = id_from_str("E", 1);
854 newmode.code = irm_E;
859 mode_E = register_mode(&newmode);
861 /* Integer Number Modes */
862 newmode.sort = irms_int_number;
863 newmode.arithmetic = irma_twos_complement;
866 newmode.name = id_from_str("Bs", 2);
867 newmode.code = irm_Bs;
871 newmode.modulo_shift = 32;
873 mode_Bs = register_mode(&newmode);
876 newmode.name = id_from_str("Bu", 2);
877 newmode.code = irm_Bu;
878 newmode.arithmetic = irma_twos_complement;
882 newmode.modulo_shift = 32;
884 mode_Bu = register_mode(&newmode);
886 /* signed short integer */
887 newmode.name = id_from_str("Hs", 2);
888 newmode.code = irm_Hs;
892 newmode.modulo_shift = 32;
894 mode_Hs = register_mode(&newmode);
896 /* unsigned short integer */
897 newmode.name = id_from_str("Hu", 2);
898 newmode.code = irm_Hu;
902 newmode.modulo_shift = 32;
904 mode_Hu = register_mode(&newmode);
907 newmode.name = id_from_str("Is", 2);
908 newmode.code = irm_Is;
912 newmode.modulo_shift = 32;
914 mode_Is = register_mode(&newmode);
916 /* unsigned integer */
917 newmode.name = id_from_str("Iu", 2);
918 newmode.code = irm_Iu;
922 newmode.modulo_shift = 32;
924 mode_Iu = register_mode(&newmode);
926 /* signed long integer */
927 newmode.name = id_from_str("Ls", 2);
928 newmode.code = irm_Ls;
932 newmode.modulo_shift = 64;
934 mode_Ls = register_mode(&newmode);
936 /* unsigned long integer */
937 newmode.name = id_from_str("Lu", 2);
938 newmode.code = irm_Lu;
942 newmode.modulo_shift = 64;
944 mode_Lu = register_mode(&newmode);
946 /* Character Modes */
947 newmode.sort = irms_character;
948 newmode.arithmetic = irma_none;
951 newmode.name = id_from_str("C", 1);
952 newmode.code = irm_C;
956 newmode.modulo_shift = 32;
958 mode_C = register_mode(&newmode);
960 /* Unicode character */
961 newmode.name = id_from_str("U", 1);
962 newmode.code = irm_U;
966 newmode.modulo_shift = 32;
968 mode_U = register_mode(&newmode);
970 /* Reference Modes */
971 newmode.sort = irms_reference;
972 newmode.arithmetic = irma_twos_complement;
975 newmode.name = id_from_str("P", 1);
976 newmode.code = irm_P;
980 newmode.modulo_shift = 0;
982 mode_P = register_mode(&newmode);
984 /* set the machine specific modes to the predifined ones */
985 mode_P_mach = mode_P;
989 void finish_mode(void) {
990 obstack_free(&modes, 0);