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 && m->arithmetic == n->arithmetic && m->size == n->size && m->align == n->align && m->sign == n->sign)
61 // if (0 == memcmp(&m->sort, &n->sort, offsetof(ir_mode,min) - offsetof(ir_mode,sort))) return 1;
67 * searches the modes obstack for the given mode and returns
68 * a pointer on an equal mode already in the array, NULL if
71 static ir_mode *find_mode(const ir_mode *m)
74 struct _obstack_chunk *p;
77 for ( n = (ir_mode *)p->contents; (char *)(n+1) <= modes.next_free; ++n) {
79 if (modes_are_equal(n, m))
83 for (p = p->prev; p; p = p->prev) {
84 for (n = (ir_mode *)p->contents; (char *)(n+1) < p->limit; ++n)
86 if (modes_are_equal(n, m))
94 * sets special values of modes
96 static void set_mode_values(ir_mode* mode)
98 switch (get_mode_sort(mode))
100 case irms_int_number:
101 case irms_float_number:
102 mode->min = get_tarval_min(mode);
103 mode->max = get_tarval_max(mode);
104 mode->null = get_tarval_null(mode);
105 mode->one = get_tarval_one(mode);
108 case irms_internal_boolean:
109 mode->min = tarval_b_false;
110 mode->max = tarval_b_true;
111 mode->null = tarval_b_false;
112 mode->one = tarval_b_true;
116 mode->min = tarval_bad;
117 mode->max = tarval_bad;
118 mode->null = (get_mode_modecode(mode)==irm_P)?tarval_P_void:tarval_bad;
119 mode->one = tarval_bad;
125 case irms_control_flow:
126 mode->min = tarval_bad;
127 mode->max = tarval_bad;
128 mode->null = tarval_bad;
129 mode->one = tarval_bad;
135 * globals defined in irmode.h
138 /* --- Predefined modes --- */
140 /* FIRM internal modes: */
148 /* predefined numerical modes: */
149 ir_mode *mode_F; /* float */
150 ir_mode *mode_D; /* double */
151 ir_mode *mode_E; /* long double */
153 ir_mode *mode_Bs; /* integral values, signed and unsigned */
154 ir_mode *mode_Bu; /* 8 bit */
155 ir_mode *mode_Hs; /* 16 bit */
157 ir_mode *mode_Is; /* 32 bit */
159 ir_mode *mode_Ls; /* 64 bit */
167 /* machine specific modes */
168 ir_mode *mode_P_mach; /* machine specific pointer mode */
171 * functions defined in irmode.h
174 /* JNI access functions */
175 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
176 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
177 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
178 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
179 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
180 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
181 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
182 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
183 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
184 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
185 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
186 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
187 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
188 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
189 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
190 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
191 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
192 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
193 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
194 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
195 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
198 ir_mode *get_modeP_mach(void) { ANNOUNCE(); return mode_P_mach; }
199 void set_modeP_mach(ir_mode *p) {
201 assert(mode_is_reference(p));
206 * Registers a new mode if not defined yet, else returns
207 * the "equivalent" one.
209 static ir_mode *register_mode(const ir_mode* new_mode)
211 ir_mode *mode = NULL;
216 /* copy mode struct to modes array */
217 mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
219 mode->kind = k_ir_mode;
220 if(num_modes>=irm_max) mode->code = num_modes;
223 set_mode_values(mode);
229 * Creates a new mode.
231 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic )
236 mode_tmpl.name = new_id_from_str(name);
237 mode_tmpl.sort = sort;
238 mode_tmpl.size = bit_size;
239 mode_tmpl.align = align;
240 mode_tmpl.sign = sign ? 1 : 0;
241 mode_tmpl.arithmetic = arithmetic;
242 mode_tmpl.link = NULL;
243 mode_tmpl.tv_priv = NULL;
245 mode = find_mode(&mode_tmpl);
255 case irms_control_flow:
257 case irms_internal_boolean:
258 assert(0 && "internal modes cannot be user defined");
261 case irms_float_number:
262 assert(0 && "not yet implemented");
265 case irms_int_number:
268 return register_mode(&mode_tmpl);
270 return NULL; /* to shut up gcc */
273 /* Functions for the direct access to all attributes od a ir_mode */
275 get_mode_modecode(const ir_mode *mode)
282 get_mode_ident(const ir_mode *mode)
289 get_mode_name(const ir_mode *mode)
292 return get_id_str(mode->name);
296 get_mode_sort(const ir_mode* mode)
303 get_mode_size_bits(const ir_mode *mode)
309 int get_mode_size_bytes(const ir_mode *mode) {
310 int size = get_mode_size_bits(mode);
312 if ((size & 7) != 0) return -1;
317 get_mode_align (const ir_mode *mode)
324 get_mode_sign (const ir_mode *mode)
330 int get_mode_arithmetic (const ir_mode *mode)
333 return mode->arithmetic;
336 void* get_mode_link(const ir_mode *mode)
342 void set_mode_link(ir_mode *mode, void *l)
349 get_mode_min (ir_mode *mode)
353 assert(get_mode_modecode(mode) < num_modes);
354 assert(mode_is_data(mode));
360 get_mode_max (ir_mode *mode)
364 assert(get_mode_modecode(mode) < num_modes);
365 assert(mode_is_data(mode));
371 get_mode_null (ir_mode *mode)
375 assert(get_mode_modecode(mode) < num_modes);
376 assert(mode_is_data(mode));
382 get_mode_one (ir_mode *mode)
386 assert(get_mode_modecode(mode) < num_modes);
387 assert(mode_is_data(mode));
393 get_mode_infinite(ir_mode *mode)
397 assert(get_mode_modecode(mode) < num_modes);
398 assert(mode_is_float(mode));
400 return get_tarval_inf(mode);
404 get_mode_NAN(ir_mode *mode)
408 assert(get_mode_modecode(mode) < num_modes);
409 assert(mode_is_float(mode));
411 return get_tarval_nan(mode);
415 is_mode (void *thing) {
417 if (get_kind(thing) == k_ir_mode)
423 /* Functions to check, whether a modecode is signed, float, int, num, data,
424 datab or dataM. For more exact definitions read the corresponding pages
425 in the firm documentation or the followingenumeration
427 The set of "float" is defined as:
428 ---------------------------------
429 float = {irm_F, irm_D, irm_E}
431 The set of "int" is defined as:
432 -------------------------------
433 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
435 The set of "num" is defined as:
436 -------------------------------
437 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
438 irm_Is, irm_Iu, irm_Ls, irm_Lu}
441 The set of "data" is defined as:
442 -------------------------------
443 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
444 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
445 = {num || irm_C || irm_U || irm_P}
447 The set of "datab" is defined as:
448 ---------------------------------
449 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
450 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
453 The set of "dataM" is defined as:
454 ---------------------------------
455 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
456 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
460 #ifdef MODE_ACCESS_DEFINES
461 # undef mode_is_signed
462 # undef mode_is_float
467 # undef mode_is_datab
468 # undef mode_is_dataM
471 mode_is_signed (const ir_mode *mode)
479 mode_is_float (const ir_mode *mode)
483 return (get_mode_sort(mode) == irms_float_number);
487 mode_is_int (const ir_mode *mode)
491 return (get_mode_sort(mode) == irms_int_number);
494 int mode_is_character (const ir_mode *mode)
498 return (get_mode_sort(mode) == irms_character);
501 int mode_is_reference (const ir_mode *mode)
505 return (get_mode_sort(mode) == irms_reference);
509 mode_is_num (const ir_mode *mode)
513 return (mode_is_int(mode) || mode_is_float(mode));
517 mode_is_numP (const ir_mode *mode)
521 return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
525 mode_is_data (const ir_mode *mode)
529 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
533 mode_is_datab (const ir_mode *mode)
537 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
541 mode_is_dataM (const ir_mode *mode)
545 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
547 #ifdef MODE_ACCESS_DEFINES
548 # define mode_is_signed(mode) (mode)->sign
549 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
550 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
551 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
552 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
553 # 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))
554 # 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))
556 /* Returns true if sm can be converted to lm without loss. */
558 smaller_mode(const ir_mode *sm, const ir_mode *lm)
564 if (sm == lm) return 1;
566 switch(get_mode_sort(sm))
568 case irms_int_number:
569 switch(get_mode_sort(lm))
571 case irms_int_number:
572 /* integers are convertable if
573 * - both have the same sign and lm is the larger one
574 * - lm is the signed one and is at least two bits larger
575 * (one for the sign, one for the highest bit of sm)
577 if (mode_is_signed(sm))
579 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
582 else if (mode_is_signed(lm))
584 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
587 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
593 case irms_float_number:
594 /* int to float works if the float is large enough */
602 case irms_float_number:
603 /* XXX currently only the three standard 32,64,80 bit floats
604 * are supported which can safely be converted */
605 if ( (get_mode_sort(lm) == irms_float_number)
606 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
611 /* do exist machines out there with different pointer lenghts ?*/
622 /* ** initialization ** */
628 /* init flexible array */
630 obstack_init(&modes);
633 /* initialize predefined modes */
636 newmode.arithmetic = irma_none;
641 newmode.tv_priv = NULL;
643 /* Control Flow Modes*/
644 newmode.sort = irms_control_flow;
647 newmode.name = id_from_str("BB", 2);
648 newmode.code = irm_BB;
650 mode_BB = register_mode(&newmode);
653 newmode.name = id_from_str("X", 1);
654 newmode.code = irm_X;
656 mode_X = register_mode(&newmode);
659 newmode.sort = irms_memory;
662 newmode.name = id_from_str("M", 1);
663 newmode.code = irm_M;
665 mode_M = register_mode(&newmode);
667 /* Auxiliary Modes */
668 newmode.sort = irms_auxiliary,
671 newmode.name = id_from_str("T", 1);
672 newmode.code = irm_T;
674 mode_T = register_mode(&newmode);
677 newmode.name = id_from_str("ANY", 3);
678 newmode.code = irm_ANY;
680 mode_ANY = register_mode(&newmode);
683 newmode.name = id_from_str("BAD", 3);
684 newmode.code = irm_BAD;
686 mode_BAD = register_mode(&newmode);
688 /* Internal Boolean Modes */
689 newmode.sort = irms_internal_boolean;
692 newmode.name = id_from_str("b", 1);
693 newmode.code = irm_b;
695 mode_b = register_mode(&newmode);
699 /* Float Number Modes */
700 newmode.sort = irms_float_number;
701 newmode.arithmetic = irma_ieee754;
704 newmode.name = id_from_str("F", 1);
705 newmode.code = irm_F;
710 mode_F = register_mode(&newmode);
713 newmode.name = id_from_str("D", 1);
714 newmode.code = irm_D;
719 mode_D = register_mode(&newmode);
722 newmode.name = id_from_str("E", 1);
723 newmode.code = irm_E;
728 mode_E = register_mode(&newmode);
730 /* Integer Number Modes */
731 newmode.sort = irms_int_number;
732 newmode.arithmetic = irma_twos_complement;
735 newmode.name = id_from_str("Bs", 2);
736 newmode.code = irm_Bs;
741 mode_Bs = register_mode(&newmode);
744 newmode.name = id_from_str("Bu", 2);
745 newmode.code = irm_Bu;
746 newmode.arithmetic = irma_twos_complement;
751 mode_Bu = register_mode(&newmode);
753 /* signed short integer */
754 newmode.name = id_from_str("Hs", 2);
755 newmode.code = irm_Hs;
760 mode_Hs = register_mode(&newmode);
762 /* unsigned short integer */
763 newmode.name = id_from_str("Hu", 2);
764 newmode.code = irm_Hu;
769 mode_Hu = register_mode(&newmode);
772 newmode.name = id_from_str("Is", 2);
773 newmode.code = irm_Is;
778 mode_Is = register_mode(&newmode);
780 /* unsigned integer */
781 newmode.name = id_from_str("Iu", 2);
782 newmode.code = irm_Iu;
787 mode_Iu = register_mode(&newmode);
789 /* signed long integer */
790 newmode.name = id_from_str("Ls", 2);
791 newmode.code = irm_Ls;
796 mode_Ls = register_mode(&newmode);
798 /* unsigned long integer */
799 newmode.name = id_from_str("Lu", 2);
800 newmode.code = irm_Lu;
805 mode_Lu = register_mode(&newmode);
807 /* Character Modes */
808 newmode.sort = irms_character;
809 newmode.arithmetic = irma_none;
812 newmode.name = id_from_str("C", 1);
813 newmode.code = irm_C;
818 mode_C = register_mode(&newmode);
820 /* Unicode character */
821 newmode.name = id_from_str("U", 1);
822 newmode.code = irm_U;
827 mode_U = register_mode(&newmode);
829 /* Reference Modes */
830 newmode.sort = irms_reference;
831 newmode.arithmetic = irma_twos_complement;
834 newmode.name = id_from_str("P", 1);
835 newmode.code = irm_P;
840 mode_P = register_mode(&newmode);
842 /* set the machine specific modes to the predifined ones */
843 mode_P_mach = mode_P;