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 if(arithmetic != irma_ieee754) {
242 assert(0 && "not yet implemented");
247 case irms_int_number:
252 mode_tmpl.name = new_id_from_str(name);
253 mode_tmpl.sort = sort;
254 mode_tmpl.size = bit_size;
255 mode_tmpl.align = align;
256 mode_tmpl.sign = sign ? 1 : 0;
257 mode_tmpl.arithmetic = arithmetic;
258 mode_tmpl.link = NULL;
259 mode_tmpl.tv_priv = NULL;
261 /* first check if there already is a matching mode */
262 mode = find_mode(&mode_tmpl);
269 return register_mode(&mode_tmpl);
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 id_to_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;