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 * calculates the next obstack address
73 static void *next_obstack_adr(struct obstack *o, void *p, size_t s)
75 PTR_INT_TYPE adr = __PTR_TO_INT((char *)p);
76 int mask = obstack_alignment_mask(o);
78 adr += s + o->alignment_mask;
80 return __INT_TO_PTR(adr & ~o->alignment_mask);
84 * searches the modes obstack for the given mode and returns
85 * a pointer on an equal mode already in the array, NULL if
88 static ir_mode *find_mode(const ir_mode *m)
91 struct _obstack_chunk *p;
94 n = (ir_mode *)p->contents;
95 nn = next_obstack_adr(&modes, n, sizeof(*n));
96 for (; (char *)nn <= modes.next_free;) {
98 if (modes_are_equal(n, m))
102 nn = next_obstack_adr(&modes, n, sizeof(*n));
105 for (p = p->prev; p; p = p->prev) {
106 n = (ir_mode *)p->contents;
107 nn = next_obstack_adr(&modes, n, sizeof(*n));
108 for (; (char *)nn < p->limit;) {
110 if (modes_are_equal(n, m))
114 nn = next_obstack_adr(&modes, n, sizeof(*n));
122 * sets special values of modes
124 static void set_mode_values(ir_mode* mode)
126 switch (get_mode_sort(mode))
129 case irms_int_number:
130 case irms_float_number:
131 mode->min = get_tarval_min(mode);
132 mode->max = get_tarval_max(mode);
133 mode->null = get_tarval_null(mode);
134 mode->one = get_tarval_one(mode);
137 case irms_internal_boolean:
138 mode->min = tarval_b_false;
139 mode->max = tarval_b_true;
140 mode->null = tarval_b_false;
141 mode->one = tarval_b_true;
145 mode->min = tarval_bad;
146 mode->max = tarval_bad;
147 mode->null = (get_mode_modecode(mode) == irm_P) ? tarval_P_void : tarval_bad;
148 mode->one = tarval_bad;
153 case irms_control_flow:
154 mode->min = tarval_bad;
155 mode->max = tarval_bad;
156 mode->null = tarval_bad;
157 mode->one = tarval_bad;
163 * globals defined in irmode.h
166 /* --- Predefined modes --- */
168 /* FIRM internal modes: */
176 /* predefined numerical modes: */
177 ir_mode *mode_F; /* float */
178 ir_mode *mode_D; /* double */
179 ir_mode *mode_E; /* long double */
181 ir_mode *mode_Bs; /* integral values, signed and unsigned */
182 ir_mode *mode_Bu; /* 8 bit */
183 ir_mode *mode_Hs; /* 16 bit */
185 ir_mode *mode_Is; /* 32 bit */
187 ir_mode *mode_Ls; /* 64 bit */
195 /* machine specific modes */
196 ir_mode *mode_P_mach; /* machine specific pointer mode */
199 * functions defined in irmode.h
202 /* JNI access functions */
203 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
204 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
205 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
206 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
207 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
208 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
209 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
210 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
211 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
212 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
213 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
214 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
215 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
216 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
217 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
218 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
219 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
220 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
221 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
222 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
223 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
226 ir_mode *get_modeP_mach(void) { ANNOUNCE(); return mode_P_mach; }
227 void set_modeP_mach(ir_mode *p) {
229 assert(mode_is_reference(p));
234 * Registers a new mode if not defined yet, else returns
235 * the "equivalent" one.
237 static ir_mode *register_mode(const ir_mode* new_mode)
239 ir_mode *mode = NULL;
244 /* copy mode struct to modes array */
245 mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
247 mode->kind = k_ir_mode;
248 if(num_modes>=irm_max) mode->code = num_modes;
251 set_mode_values(mode);
257 * Creates a new mode.
259 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign,
260 mode_arithmetic arithmetic, unsigned int modulo_shift )
265 mode_tmpl.name = new_id_from_str(name);
266 mode_tmpl.sort = sort;
267 mode_tmpl.size = bit_size;
268 mode_tmpl.align = align;
269 mode_tmpl.sign = sign ? 1 : 0;
270 mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
271 mode_tmpl.arithmetic = arithmetic;
272 mode_tmpl.link = NULL;
273 mode_tmpl.tv_priv = NULL;
275 mode = find_mode(&mode_tmpl);
285 case irms_control_flow:
287 case irms_internal_boolean:
288 assert(0 && "internal modes cannot be user defined");
291 case irms_float_number:
292 assert(0 && "not yet implemented");
295 case irms_int_number:
298 return register_mode(&mode_tmpl);
300 return NULL; /* to shut up gcc */
303 /* Functions for the direct access to all attributes od a ir_mode */
305 get_mode_modecode(const ir_mode *mode)
312 get_mode_ident(const ir_mode *mode)
319 get_mode_name(const ir_mode *mode)
322 return get_id_str(mode->name);
326 get_mode_sort(const ir_mode* mode)
333 get_mode_size_bits(const ir_mode *mode)
339 int get_mode_size_bytes(const ir_mode *mode) {
340 int size = get_mode_size_bits(mode);
342 if ((size & 7) != 0) return -1;
347 get_mode_align (const ir_mode *mode)
354 get_mode_sign (const ir_mode *mode)
360 int get_mode_arithmetic (const ir_mode *mode)
363 return mode->arithmetic;
367 /* Attribute modulo shift specifies for modes of kind irms_int_number
368 * whether shift applies modulo to value of bits to shift. Asserts
369 * if mode is not irms_int_number.
371 unsigned int get_mode_modulo_shift(const ir_mode *mode) {
372 return mode->modulo_shift;
375 void* get_mode_link(const ir_mode *mode)
381 void set_mode_link(ir_mode *mode, void *l)
388 get_mode_min (ir_mode *mode)
392 assert(get_mode_modecode(mode) < num_modes);
393 assert(mode_is_data(mode));
399 get_mode_max (ir_mode *mode)
403 assert(get_mode_modecode(mode) < num_modes);
404 assert(mode_is_data(mode));
410 get_mode_null (ir_mode *mode)
414 assert(get_mode_modecode(mode) < num_modes);
415 assert(mode_is_data(mode));
421 get_mode_one (ir_mode *mode)
425 assert(get_mode_modecode(mode) < num_modes);
426 assert(mode_is_data(mode));
432 get_mode_infinite(ir_mode *mode)
436 assert(get_mode_modecode(mode) < num_modes);
437 assert(mode_is_float(mode));
439 return get_tarval_inf(mode);
443 get_mode_NAN(ir_mode *mode)
447 assert(get_mode_modecode(mode) < num_modes);
448 assert(mode_is_float(mode));
450 return get_tarval_nan(mode);
454 is_mode (void *thing) {
456 if (get_kind(thing) == k_ir_mode)
462 /* Functions to check, whether a modecode is signed, float, int, num, data,
463 datab or dataM. For more exact definitions read the corresponding pages
464 in the firm documentation or the followingenumeration
466 The set of "float" is defined as:
467 ---------------------------------
468 float = {irm_F, irm_D, irm_E}
470 The set of "int" is defined as:
471 -------------------------------
472 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
474 The set of "num" is defined as:
475 -------------------------------
476 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
477 irm_Is, irm_Iu, irm_Ls, irm_Lu}
480 The set of "data" is defined as:
481 -------------------------------
482 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
483 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
484 = {num || irm_C || irm_U || irm_P}
486 The set of "datab" is defined as:
487 ---------------------------------
488 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
489 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
492 The set of "dataM" is defined as:
493 ---------------------------------
494 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
495 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
499 #ifdef MODE_ACCESS_DEFINES
500 # undef mode_is_signed
501 # undef mode_is_float
506 # undef mode_is_datab
507 # undef mode_is_dataM
510 mode_is_signed (const ir_mode *mode)
518 mode_is_float (const ir_mode *mode)
522 return (get_mode_sort(mode) == irms_float_number);
526 mode_is_int (const ir_mode *mode)
530 return (get_mode_sort(mode) == irms_int_number);
533 int mode_is_character (const ir_mode *mode)
537 return (get_mode_sort(mode) == irms_character);
540 int mode_is_reference (const ir_mode *mode)
544 return (get_mode_sort(mode) == irms_reference);
548 mode_is_num (const ir_mode *mode)
552 return (mode_is_int(mode) || mode_is_float(mode));
556 mode_is_numP (const ir_mode *mode)
560 return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
564 mode_is_data (const ir_mode *mode)
568 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
572 mode_is_datab (const ir_mode *mode)
576 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
580 mode_is_dataM (const ir_mode *mode)
584 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
586 #ifdef MODE_ACCESS_DEFINES
587 # define mode_is_signed(mode) (mode)->sign
588 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
589 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
590 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
591 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
592 # 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))
593 # 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))
595 /* Returns true if sm can be converted to lm without loss. */
597 smaller_mode(const ir_mode *sm, const ir_mode *lm)
603 if (sm == lm) return 1;
605 switch(get_mode_sort(sm))
607 case irms_int_number:
608 switch(get_mode_sort(lm))
610 case irms_int_number:
611 /* integers are convertable if
612 * - both have the same sign and lm is the larger one
613 * - lm is the signed one and is at least two bits larger
614 * (one for the sign, one for the highest bit of sm)
616 if (mode_is_signed(sm))
618 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
621 else if (mode_is_signed(lm))
623 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
626 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
632 case irms_float_number:
633 /* int to float works if the float is large enough */
641 case irms_float_number:
642 /* XXX currently only the three standard 32,64,80 bit floats
643 * are supported which can safely be converted */
644 if ( (get_mode_sort(lm) == irms_float_number)
645 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
650 /* do exist machines out there with different pointer lenghts ?*/
661 /* ** initialization ** */
667 /* init flexible array */
669 obstack_init(&modes);
672 /* initialize predefined modes */
675 newmode.arithmetic = irma_none;
679 newmode.modulo_shift = 0;
681 newmode.tv_priv = NULL;
683 /* Control Flow Modes*/
684 newmode.sort = irms_control_flow;
687 newmode.name = id_from_str("BB", 2);
688 newmode.code = irm_BB;
690 mode_BB = register_mode(&newmode);
693 newmode.name = id_from_str("X", 1);
694 newmode.code = irm_X;
696 mode_X = register_mode(&newmode);
699 newmode.sort = irms_memory;
702 newmode.name = id_from_str("M", 1);
703 newmode.code = irm_M;
705 mode_M = register_mode(&newmode);
707 /* Auxiliary Modes */
708 newmode.sort = irms_auxiliary,
711 newmode.name = id_from_str("T", 1);
712 newmode.code = irm_T;
714 mode_T = register_mode(&newmode);
717 newmode.name = id_from_str("ANY", 3);
718 newmode.code = irm_ANY;
720 mode_ANY = register_mode(&newmode);
723 newmode.name = id_from_str("BAD", 3);
724 newmode.code = irm_BAD;
726 mode_BAD = register_mode(&newmode);
728 /* Internal Boolean Modes */
729 newmode.sort = irms_internal_boolean;
732 newmode.name = id_from_str("b", 1);
733 newmode.code = irm_b;
735 mode_b = register_mode(&newmode);
739 /* Float Number Modes */
740 newmode.sort = irms_float_number;
741 newmode.arithmetic = irma_ieee754;
744 newmode.name = id_from_str("F", 1);
745 newmode.code = irm_F;
750 mode_F = register_mode(&newmode);
753 newmode.name = id_from_str("D", 1);
754 newmode.code = irm_D;
759 mode_D = register_mode(&newmode);
762 newmode.name = id_from_str("E", 1);
763 newmode.code = irm_E;
768 mode_E = register_mode(&newmode);
770 /* Integer Number Modes */
771 newmode.sort = irms_int_number;
772 newmode.arithmetic = irma_twos_complement;
775 newmode.name = id_from_str("Bs", 2);
776 newmode.code = irm_Bs;
780 newmode.modulo_shift = 32;
782 mode_Bs = register_mode(&newmode);
785 newmode.name = id_from_str("Bu", 2);
786 newmode.code = irm_Bu;
787 newmode.arithmetic = irma_twos_complement;
791 newmode.modulo_shift = 32;
793 mode_Bu = register_mode(&newmode);
795 /* signed short integer */
796 newmode.name = id_from_str("Hs", 2);
797 newmode.code = irm_Hs;
801 newmode.modulo_shift = 32;
803 mode_Hs = register_mode(&newmode);
805 /* unsigned short integer */
806 newmode.name = id_from_str("Hu", 2);
807 newmode.code = irm_Hu;
811 newmode.modulo_shift = 32;
813 mode_Hu = register_mode(&newmode);
816 newmode.name = id_from_str("Is", 2);
817 newmode.code = irm_Is;
821 newmode.modulo_shift = 32;
823 mode_Is = register_mode(&newmode);
825 /* unsigned integer */
826 newmode.name = id_from_str("Iu", 2);
827 newmode.code = irm_Iu;
831 newmode.modulo_shift = 32;
833 mode_Iu = register_mode(&newmode);
835 /* signed long integer */
836 newmode.name = id_from_str("Ls", 2);
837 newmode.code = irm_Ls;
841 newmode.modulo_shift = 64;
843 mode_Ls = register_mode(&newmode);
845 /* unsigned long integer */
846 newmode.name = id_from_str("Lu", 2);
847 newmode.code = irm_Lu;
851 newmode.modulo_shift = 64;
853 mode_Lu = register_mode(&newmode);
855 /* Character Modes */
856 newmode.sort = irms_character;
857 newmode.arithmetic = irma_none;
860 newmode.name = id_from_str("C", 1);
861 newmode.code = irm_C;
865 newmode.modulo_shift = 32;
867 mode_C = register_mode(&newmode);
869 /* Unicode character */
870 newmode.name = id_from_str("U", 1);
871 newmode.code = irm_U;
875 newmode.modulo_shift = 32;
877 mode_U = register_mode(&newmode);
879 /* Reference Modes */
880 newmode.sort = irms_reference;
881 newmode.arithmetic = irma_twos_complement;
884 newmode.name = id_from_str("P", 1);
885 newmode.code = irm_P;
889 newmode.modulo_shift = 0;
891 mode_P = register_mode(&newmode);
893 /* set the machine specific modes to the predifined ones */
894 mode_P_mach = mode_P;