1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer
14 # include "irmode_t.h"
24 static long long count = 0;
25 # define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
27 # define ANNOUNCE() ((void)0)
35 /** dynamic array to hold all modes */
36 static struct obstack modes;
38 /** number of defined modes */
46 * Compare modes that don't need to have their code field
49 * TODO: Add other fields
51 INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n)
54 if (0 == memcmp(&m->sort, &n->sort, offsetof(ir_mode,min) - offsetof(ir_mode,sort))) return 1;
60 * searches the modes obstack for the given mode and returns
61 * a pointer on an equal mode already in the array, NULL if
64 static ir_mode *find_mode(const ir_mode *m)
67 struct _obstack_chunk *p;
70 for( n=(ir_mode*) p->contents; (char *)n < modes.next_free; n+=sizeof(ir_mode) )
72 if(modes_are_equal(n,m)) return n;
75 for (p = p->prev; p; p = p->prev)
77 for( n=(ir_mode*) p->contents; (char *)n < p->limit; n+=sizeof(ir_mode) )
79 if(modes_are_equal(n,m)) return n;
87 * sets special values of modes
89 static void set_mode_values(ir_mode* mode)
91 switch (get_mode_sort(mode))
94 case irms_float_number:
95 mode->min = get_tarval_min(mode);
96 mode->max = get_tarval_max(mode);
97 mode->null = get_tarval_null(mode);
98 mode->one = get_tarval_one(mode);
101 case irms_internal_boolean:
102 mode->min = tarval_b_false;
103 mode->max = tarval_b_true;
104 mode->null = tarval_b_false;
105 mode->one = tarval_b_true;
109 mode->min = tarval_bad;
110 mode->max = tarval_bad;
111 mode->null = (get_mode_modecode(mode)==irm_P)?tarval_P_void:tarval_bad;
112 mode->one = tarval_bad;
118 case irms_control_flow:
119 mode->min = tarval_bad;
120 mode->max = tarval_bad;
121 mode->null = tarval_bad;
122 mode->one = tarval_bad;
128 * globals defined in irmode.h
131 /* --- Predefined modes --- */
133 /* FIRM internal modes: */
141 /* predefined numerical modes: */
142 ir_mode *mode_F; /* float */
143 ir_mode *mode_D; /* double */
144 ir_mode *mode_E; /* long double */
146 ir_mode *mode_Bs; /* integral values, signed and unsigned */
147 ir_mode *mode_Bu; /* 8 bit */
148 ir_mode *mode_Hs; /* 16 bit */
150 ir_mode *mode_Is; /* 32 bit */
152 ir_mode *mode_Ls; /* 64 bit */
160 /* machine specific modes */
161 ir_mode *mode_P_mach; /* machine specific pointer mode */
164 * functions defined in irmode.h
167 /* JNI access functions */
168 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
169 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
170 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
171 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
172 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
173 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
174 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
175 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
176 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
177 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
178 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
179 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
180 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
181 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
182 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
183 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
184 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
185 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
186 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
187 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
188 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
191 ir_mode *get_modeP_mach(void) { ANNOUNCE(); return mode_P_mach; }
192 void set_modeP_mach(ir_mode *p) {
194 assert(mode_is_reference(p));
199 * Registers a new mode if not defined yet, else returns
200 * the "equivalent" one.
202 static ir_mode *register_mode(const ir_mode* new_mode)
204 ir_mode *mode = NULL;
209 /* copy mode struct to modes array */
210 mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
212 mode->kind = k_ir_mode;
213 if(num_modes>=irm_max) mode->code = num_modes;
216 set_mode_values(mode);
222 * Creates a new mode.
224 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic )
233 case irms_control_flow:
235 case irms_internal_boolean:
236 assert(0 && "internal modes cannot be user defined");
240 case irms_float_number:
241 assert(0 && "not yet implemented");
245 case irms_int_number:
250 mode_tmpl.name = new_id_from_str(name);
251 mode_tmpl.sort = sort;
252 mode_tmpl.size = bit_size;
253 mode_tmpl.align = align;
254 mode_tmpl.sign = sign ? 1 : 0;
255 mode_tmpl.arithmetic = arithmetic;
256 mode_tmpl.link = NULL;
257 mode_tmpl.tv_priv = NULL;
259 /* first check if there already is a matching mode */
260 mode = find_mode(&mode_tmpl);
267 return register_mode(&mode_tmpl);
271 /* Functions for the direct access to all attributes od a ir_mode */
273 get_mode_modecode(const ir_mode *mode)
280 get_mode_ident(const ir_mode *mode)
287 get_mode_name(const ir_mode *mode)
290 return id_to_str(mode->name);
294 get_mode_sort(const ir_mode* mode)
301 get_mode_size_bits(const ir_mode *mode)
307 int get_mode_size_bytes(const ir_mode *mode) {
308 int size = get_mode_size_bits(mode);
310 if ((size & 7) != 0) return -1;
315 get_mode_align (const ir_mode *mode)
322 get_mode_sign (const ir_mode *mode)
328 int get_mode_arithmetic (const ir_mode *mode)
331 return mode->arithmetic;
334 void* get_mode_link(const ir_mode *mode)
340 void set_mode_link(ir_mode *mode, void *l)
347 get_mode_min (ir_mode *mode)
351 assert(get_mode_modecode(mode) < num_modes);
352 assert(mode_is_data(mode));
358 get_mode_max (ir_mode *mode)
362 assert(get_mode_modecode(mode) < num_modes);
363 assert(mode_is_data(mode));
369 get_mode_null (ir_mode *mode)
373 assert(get_mode_modecode(mode) < num_modes);
374 assert(mode_is_data(mode));
380 get_mode_one (ir_mode *mode)
384 assert(get_mode_modecode(mode) < num_modes);
385 assert(mode_is_data(mode));
391 get_mode_infinite(ir_mode *mode)
395 assert(get_mode_modecode(mode) < num_modes);
396 assert(mode_is_float(mode));
398 return get_tarval_inf(mode);
402 get_mode_NAN(ir_mode *mode)
406 assert(get_mode_modecode(mode) < num_modes);
407 assert(mode_is_float(mode));
409 return get_tarval_nan(mode);
413 is_mode (void *thing) {
415 if (get_kind(thing) == k_ir_mode)
421 /* Functions to check, whether a modecode is signed, float, int, num, data,
422 datab or dataM. For more exact definitions read the corresponding pages
423 in the firm documentation or the followingenumeration
425 The set of "float" is defined as:
426 ---------------------------------
427 float = {irm_F, irm_D, irm_E}
429 The set of "int" is defined as:
430 -------------------------------
431 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
433 The set of "num" is defined as:
434 -------------------------------
435 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
436 irm_Is, irm_Iu, irm_Ls, irm_Lu}
439 The set of "data" is defined as:
440 -------------------------------
441 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
442 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
443 = {num || irm_C || irm_U || irm_P}
445 The set of "datab" is defined as:
446 ---------------------------------
447 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
448 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
451 The set of "dataM" is defined as:
452 ---------------------------------
453 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
454 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
458 #ifdef MODE_ACCESS_DEFINES
459 # undef mode_is_signed
460 # undef mode_is_float
465 # undef mode_is_datab
466 # undef mode_is_dataM
469 mode_is_signed (const ir_mode *mode)
477 mode_is_float (const ir_mode *mode)
481 return (get_mode_sort(mode) == irms_float_number);
485 mode_is_int (const ir_mode *mode)
489 return (get_mode_sort(mode) == irms_int_number);
492 int mode_is_character (const ir_mode *mode)
496 return (get_mode_sort(mode) == irms_character);
499 int mode_is_reference (const ir_mode *mode)
503 return (get_mode_sort(mode) == irms_reference);
507 mode_is_num (const ir_mode *mode)
511 return (mode_is_int(mode) || mode_is_float(mode));
515 mode_is_numP (const ir_mode *mode)
519 return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
523 mode_is_data (const ir_mode *mode)
527 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
531 mode_is_datab (const ir_mode *mode)
535 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
539 mode_is_dataM (const ir_mode *mode)
543 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
545 #ifdef MODE_ACCESS_DEFINES
546 # define mode_is_signed(mode) (mode)->sign
547 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
548 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
549 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
550 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
551 # 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))
552 # 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))
554 /* Returns true if sm can be converted to lm without loss. */
556 smaller_mode(const ir_mode *sm, const ir_mode *lm)
562 if (sm == lm) return 1;
564 switch(get_mode_sort(sm))
566 case irms_int_number:
567 switch(get_mode_sort(lm))
569 case irms_int_number:
570 /* integers are convertable if
571 * - both have the same sign and lm is the larger one
572 * - lm is the signed one and is at least two bits larger
573 * (one for the sign, one for the highest bit of sm)
575 if (mode_is_signed(sm))
577 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
580 else if (mode_is_signed(lm))
582 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
585 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
591 case irms_float_number:
592 /* int to float works if the float is large enough */
600 case irms_float_number:
601 /* XXX currently only the three standard 32,64,80 bit floats
602 * are supported which can safely be converted */
603 if ( (get_mode_sort(lm) == irms_float_number)
604 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
609 /* do exist machines out there with different pointer lenghts ?*/
620 /* ** initialization ** */
626 /* init flexible array */
628 obstack_init(&modes);
631 /* initialize predefined modes */
634 newmode.arithmetic = irma_none;
639 newmode.tv_priv = NULL;
641 /* Control Flow Modes*/
642 newmode.sort = irms_control_flow;
645 newmode.name = id_from_str("BB", 2);
646 newmode.code = irm_BB;
648 mode_BB = register_mode(&newmode);
651 newmode.name = id_from_str("X", 1);
652 newmode.code = irm_X;
654 mode_X = register_mode(&newmode);
657 newmode.sort = irms_memory;
660 newmode.name = id_from_str("M", 1);
661 newmode.code = irm_M;
663 mode_M = register_mode(&newmode);
665 /* Auxiliary Modes */
666 newmode.sort = irms_auxiliary,
669 newmode.name = id_from_str("T", 1);
670 newmode.code = irm_T;
672 mode_T = register_mode(&newmode);
675 newmode.name = id_from_str("ANY", 3);
676 newmode.code = irm_ANY;
678 mode_ANY = register_mode(&newmode);
681 newmode.name = id_from_str("BAD", 3);
682 newmode.code = irm_BAD;
684 mode_BAD = register_mode(&newmode);
686 /* Internal Boolean Modes */
687 newmode.sort = irms_internal_boolean;
690 newmode.name = id_from_str("b", 1);
691 newmode.code = irm_b;
693 mode_b = register_mode(&newmode);
697 /* Float Number Modes */
698 newmode.sort = irms_float_number;
699 newmode.arithmetic = irma_ieee754;
702 newmode.name = id_from_str("F", 1);
703 newmode.code = irm_F;
708 mode_F = register_mode(&newmode);
711 newmode.name = id_from_str("D", 1);
712 newmode.code = irm_D;
717 mode_D = register_mode(&newmode);
720 newmode.name = id_from_str("E", 1);
721 newmode.code = irm_E;
726 mode_E = register_mode(&newmode);
728 /* Integer Number Modes */
729 newmode.sort = irms_int_number;
730 newmode.arithmetic = irma_twos_complement;
733 newmode.name = id_from_str("Bs", 2);
734 newmode.code = irm_Bs;
739 mode_Bs = register_mode(&newmode);
742 newmode.name = id_from_str("Bu", 2);
743 newmode.code = irm_Bu;
744 newmode.arithmetic = irma_twos_complement;
749 mode_Bu = register_mode(&newmode);
751 /* signed short integer */
752 newmode.name = id_from_str("Hs", 2);
753 newmode.code = irm_Hs;
758 mode_Hs = register_mode(&newmode);
760 /* unsigned short integer */
761 newmode.name = id_from_str("Hu", 2);
762 newmode.code = irm_Hu;
767 mode_Hu = register_mode(&newmode);
770 newmode.name = id_from_str("Is", 2);
771 newmode.code = irm_Is;
776 mode_Is = register_mode(&newmode);
778 /* unsigned integer */
779 newmode.name = id_from_str("Iu", 2);
780 newmode.code = irm_Iu;
785 mode_Iu = register_mode(&newmode);
787 /* signed long integer */
788 newmode.name = id_from_str("Ls", 2);
789 newmode.code = irm_Ls;
794 mode_Ls = register_mode(&newmode);
796 /* unsigned long integer */
797 newmode.name = id_from_str("Lu", 2);
798 newmode.code = irm_Lu;
803 mode_Lu = register_mode(&newmode);
805 /* Character Modes */
806 newmode.sort = irms_character;
807 newmode.arithmetic = irma_none;
810 newmode.name = id_from_str("C", 1);
811 newmode.code = irm_C;
816 mode_C = register_mode(&newmode);
818 /* Unicode character */
819 newmode.name = id_from_str("U", 1);
820 newmode.code = irm_U;
825 mode_U = register_mode(&newmode);
827 /* Reference Modes */
828 newmode.sort = irms_reference;
829 newmode.arithmetic = irma_twos_complement;
832 newmode.name = id_from_str("P", 1);
833 newmode.code = irm_P;
838 mode_P = register_mode(&newmode);
840 /* set the machine specific modes to the predifined ones */
841 mode_P_mach = mode_P;