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)
71 * searches the modes obstack for the given mode and returns
72 * a pointer on an equal mode already in the array, NULL if
75 static ir_mode *find_mode(const ir_mode *m)
78 struct _obstack_chunk *p;
81 for ( n = (ir_mode *)p->contents; (char *)(n+1) <= modes.next_free; ++n) {
83 if (modes_are_equal(n, m))
87 for (p = p->prev; p; p = p->prev) {
88 for (n = (ir_mode *)p->contents; (char *)(n+1) < p->limit; ++n)
90 if (modes_are_equal(n, m))
98 * sets special values of modes
100 static void set_mode_values(ir_mode* mode)
102 switch (get_mode_sort(mode))
104 case irms_int_number:
105 case irms_float_number:
106 mode->min = get_tarval_min(mode);
107 mode->max = get_tarval_max(mode);
108 mode->null = get_tarval_null(mode);
109 mode->one = get_tarval_one(mode);
112 case irms_internal_boolean:
113 mode->min = tarval_b_false;
114 mode->max = tarval_b_true;
115 mode->null = tarval_b_false;
116 mode->one = tarval_b_true;
120 mode->min = tarval_bad;
121 mode->max = tarval_bad;
122 mode->null = (get_mode_modecode(mode)==irm_P)?tarval_P_void:tarval_bad;
123 mode->one = tarval_bad;
129 case irms_control_flow:
130 mode->min = tarval_bad;
131 mode->max = tarval_bad;
132 mode->null = tarval_bad;
133 mode->one = tarval_bad;
139 * globals defined in irmode.h
142 /* --- Predefined modes --- */
144 /* FIRM internal modes: */
152 /* predefined numerical modes: */
153 ir_mode *mode_F; /* float */
154 ir_mode *mode_D; /* double */
155 ir_mode *mode_E; /* long double */
157 ir_mode *mode_Bs; /* integral values, signed and unsigned */
158 ir_mode *mode_Bu; /* 8 bit */
159 ir_mode *mode_Hs; /* 16 bit */
161 ir_mode *mode_Is; /* 32 bit */
163 ir_mode *mode_Ls; /* 64 bit */
171 /* machine specific modes */
172 ir_mode *mode_P_mach; /* machine specific pointer mode */
175 * functions defined in irmode.h
178 /* JNI access functions */
179 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
180 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
181 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
182 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
183 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
184 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
185 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
186 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
187 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
188 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
189 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
190 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
191 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
192 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
193 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
194 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
195 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
196 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
197 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
198 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
199 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
202 ir_mode *get_modeP_mach(void) { ANNOUNCE(); return mode_P_mach; }
203 void set_modeP_mach(ir_mode *p) {
205 assert(mode_is_reference(p));
210 * Registers a new mode if not defined yet, else returns
211 * the "equivalent" one.
213 static ir_mode *register_mode(const ir_mode* new_mode)
215 ir_mode *mode = NULL;
220 /* copy mode struct to modes array */
221 mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
223 mode->kind = k_ir_mode;
224 if(num_modes>=irm_max) mode->code = num_modes;
227 set_mode_values(mode);
233 * Creates a new mode.
235 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign,
236 mode_arithmetic arithmetic, unsigned int modulo_shift )
241 mode_tmpl.name = new_id_from_str(name);
242 mode_tmpl.sort = sort;
243 mode_tmpl.size = bit_size;
244 mode_tmpl.align = align;
245 mode_tmpl.sign = sign ? 1 : 0;
246 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
247 mode_tmpl.arithmetic = arithmetic;
248 mode_tmpl.link = NULL;
249 mode_tmpl.tv_priv = NULL;
251 mode = find_mode(&mode_tmpl);
261 case irms_control_flow:
263 case irms_internal_boolean:
264 assert(0 && "internal modes cannot be user defined");
267 case irms_float_number:
268 assert(0 && "not yet implemented");
271 case irms_int_number:
274 return register_mode(&mode_tmpl);
276 return NULL; /* to shut up gcc */
279 /* Functions for the direct access to all attributes od a ir_mode */
281 get_mode_modecode(const ir_mode *mode)
288 get_mode_ident(const ir_mode *mode)
295 get_mode_name(const ir_mode *mode)
298 return get_id_str(mode->name);
302 get_mode_sort(const ir_mode* mode)
309 get_mode_size_bits(const ir_mode *mode)
315 int get_mode_size_bytes(const ir_mode *mode) {
316 int size = get_mode_size_bits(mode);
318 if ((size & 7) != 0) return -1;
323 get_mode_align (const ir_mode *mode)
330 get_mode_sign (const ir_mode *mode)
336 int get_mode_arithmetic (const ir_mode *mode)
339 return mode->arithmetic;
343 /* Attribute modulo shift specifies for modes of kind irms_int_number
344 * whether shift applies modulo to value of bits to shift. Asserts
345 * if mode is not irms_int_number.
347 unsigned int get_mode_modulo_shift(const ir_mode *mode) {
348 return mode->modulo_shift;
351 void* get_mode_link(const ir_mode *mode)
357 void set_mode_link(ir_mode *mode, void *l)
364 get_mode_min (ir_mode *mode)
368 assert(get_mode_modecode(mode) < num_modes);
369 assert(mode_is_data(mode));
375 get_mode_max (ir_mode *mode)
379 assert(get_mode_modecode(mode) < num_modes);
380 assert(mode_is_data(mode));
386 get_mode_null (ir_mode *mode)
390 assert(get_mode_modecode(mode) < num_modes);
391 assert(mode_is_data(mode));
397 get_mode_one (ir_mode *mode)
401 assert(get_mode_modecode(mode) < num_modes);
402 assert(mode_is_data(mode));
408 get_mode_infinite(ir_mode *mode)
412 assert(get_mode_modecode(mode) < num_modes);
413 assert(mode_is_float(mode));
415 return get_tarval_inf(mode);
419 get_mode_NAN(ir_mode *mode)
423 assert(get_mode_modecode(mode) < num_modes);
424 assert(mode_is_float(mode));
426 return get_tarval_nan(mode);
430 is_mode (void *thing) {
432 if (get_kind(thing) == k_ir_mode)
438 /* Functions to check, whether a modecode is signed, float, int, num, data,
439 datab or dataM. For more exact definitions read the corresponding pages
440 in the firm documentation or the followingenumeration
442 The set of "float" is defined as:
443 ---------------------------------
444 float = {irm_F, irm_D, irm_E}
446 The set of "int" is defined as:
447 -------------------------------
448 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
450 The set of "num" is defined as:
451 -------------------------------
452 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
453 irm_Is, irm_Iu, irm_Ls, irm_Lu}
456 The set of "data" is defined as:
457 -------------------------------
458 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
459 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
460 = {num || irm_C || irm_U || irm_P}
462 The set of "datab" is defined as:
463 ---------------------------------
464 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
465 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
468 The set of "dataM" is defined as:
469 ---------------------------------
470 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
471 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
475 #ifdef MODE_ACCESS_DEFINES
476 # undef mode_is_signed
477 # undef mode_is_float
482 # undef mode_is_datab
483 # undef mode_is_dataM
486 mode_is_signed (const ir_mode *mode)
494 mode_is_float (const ir_mode *mode)
498 return (get_mode_sort(mode) == irms_float_number);
502 mode_is_int (const ir_mode *mode)
506 return (get_mode_sort(mode) == irms_int_number);
509 int mode_is_character (const ir_mode *mode)
513 return (get_mode_sort(mode) == irms_character);
516 int mode_is_reference (const ir_mode *mode)
520 return (get_mode_sort(mode) == irms_reference);
524 mode_is_num (const ir_mode *mode)
528 return (mode_is_int(mode) || mode_is_float(mode));
532 mode_is_numP (const ir_mode *mode)
536 return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
540 mode_is_data (const ir_mode *mode)
544 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
548 mode_is_datab (const ir_mode *mode)
552 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
556 mode_is_dataM (const ir_mode *mode)
560 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
562 #ifdef MODE_ACCESS_DEFINES
563 # define mode_is_signed(mode) (mode)->sign
564 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
565 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
566 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
567 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
568 # 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))
569 # 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))
571 /* Returns true if sm can be converted to lm without loss. */
573 smaller_mode(const ir_mode *sm, const ir_mode *lm)
579 if (sm == lm) return 1;
581 switch(get_mode_sort(sm))
583 case irms_int_number:
584 switch(get_mode_sort(lm))
586 case irms_int_number:
587 /* integers are convertable if
588 * - both have the same sign and lm is the larger one
589 * - lm is the signed one and is at least two bits larger
590 * (one for the sign, one for the highest bit of sm)
592 if (mode_is_signed(sm))
594 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
597 else if (mode_is_signed(lm))
599 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
602 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
608 case irms_float_number:
609 /* int to float works if the float is large enough */
617 case irms_float_number:
618 /* XXX currently only the three standard 32,64,80 bit floats
619 * are supported which can safely be converted */
620 if ( (get_mode_sort(lm) == irms_float_number)
621 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
626 /* do exist machines out there with different pointer lenghts ?*/
637 /* ** initialization ** */
643 /* init flexible array */
645 obstack_init(&modes);
648 /* initialize predefined modes */
651 newmode.arithmetic = irma_none;
655 newmode.modulo_shift = 0;
657 newmode.tv_priv = NULL;
659 /* Control Flow Modes*/
660 newmode.sort = irms_control_flow;
663 newmode.name = id_from_str("BB", 2);
664 newmode.code = irm_BB;
666 mode_BB = register_mode(&newmode);
669 newmode.name = id_from_str("X", 1);
670 newmode.code = irm_X;
672 mode_X = register_mode(&newmode);
675 newmode.sort = irms_memory;
678 newmode.name = id_from_str("M", 1);
679 newmode.code = irm_M;
681 mode_M = register_mode(&newmode);
683 /* Auxiliary Modes */
684 newmode.sort = irms_auxiliary,
687 newmode.name = id_from_str("T", 1);
688 newmode.code = irm_T;
690 mode_T = register_mode(&newmode);
693 newmode.name = id_from_str("ANY", 3);
694 newmode.code = irm_ANY;
696 mode_ANY = register_mode(&newmode);
699 newmode.name = id_from_str("BAD", 3);
700 newmode.code = irm_BAD;
702 mode_BAD = register_mode(&newmode);
704 /* Internal Boolean Modes */
705 newmode.sort = irms_internal_boolean;
708 newmode.name = id_from_str("b", 1);
709 newmode.code = irm_b;
711 mode_b = register_mode(&newmode);
715 /* Float Number Modes */
716 newmode.sort = irms_float_number;
717 newmode.arithmetic = irma_ieee754;
720 newmode.name = id_from_str("F", 1);
721 newmode.code = irm_F;
726 mode_F = register_mode(&newmode);
729 newmode.name = id_from_str("D", 1);
730 newmode.code = irm_D;
735 mode_D = register_mode(&newmode);
738 newmode.name = id_from_str("E", 1);
739 newmode.code = irm_E;
744 mode_E = register_mode(&newmode);
746 /* Integer Number Modes */
747 newmode.sort = irms_int_number;
748 newmode.arithmetic = irma_twos_complement;
751 newmode.name = id_from_str("Bs", 2);
752 newmode.code = irm_Bs;
756 newmode.modulo_shift = 32;
758 mode_Bs = register_mode(&newmode);
761 newmode.name = id_from_str("Bu", 2);
762 newmode.code = irm_Bu;
763 newmode.arithmetic = irma_twos_complement;
767 newmode.modulo_shift = 32;
769 mode_Bu = register_mode(&newmode);
771 /* signed short integer */
772 newmode.name = id_from_str("Hs", 2);
773 newmode.code = irm_Hs;
777 newmode.modulo_shift = 32;
779 mode_Hs = register_mode(&newmode);
781 /* unsigned short integer */
782 newmode.name = id_from_str("Hu", 2);
783 newmode.code = irm_Hu;
787 newmode.modulo_shift = 32;
789 mode_Hu = register_mode(&newmode);
792 newmode.name = id_from_str("Is", 2);
793 newmode.code = irm_Is;
797 newmode.modulo_shift = 32;
799 mode_Is = register_mode(&newmode);
801 /* unsigned integer */
802 newmode.name = id_from_str("Iu", 2);
803 newmode.code = irm_Iu;
807 newmode.modulo_shift = 32;
809 mode_Iu = register_mode(&newmode);
811 /* signed long integer */
812 newmode.name = id_from_str("Ls", 2);
813 newmode.code = irm_Ls;
817 newmode.modulo_shift = 64;
819 mode_Ls = register_mode(&newmode);
821 /* unsigned long integer */
822 newmode.name = id_from_str("Lu", 2);
823 newmode.code = irm_Lu;
827 newmode.modulo_shift = 64;
829 mode_Lu = register_mode(&newmode);
831 /* Character Modes */
832 newmode.sort = irms_character;
833 newmode.arithmetic = irma_none;
836 newmode.name = id_from_str("C", 1);
837 newmode.code = irm_C;
841 newmode.modulo_shift = 32;
843 mode_C = register_mode(&newmode);
845 /* Unicode character */
846 newmode.name = id_from_str("U", 1);
847 newmode.code = irm_U;
851 newmode.modulo_shift = 32;
853 mode_U = register_mode(&newmode);
855 /* Reference Modes */
856 newmode.sort = irms_reference;
857 newmode.arithmetic = irma_twos_complement;
860 newmode.name = id_from_str("P", 1);
861 newmode.code = irm_P;
865 newmode.modulo_shift = 0;
867 mode_P = register_mode(&newmode);
869 /* set the machine specific modes to the predifined ones */
870 mode_P_mach = mode_P;