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 (m->sort == n->sort && m->arithmetic == n->arithmetic && m->size == n->size && m->align == n->align && m->sign == n->sign)
56 // if (0 == memcmp(&m->sort, &n->sort, offsetof(ir_mode,min) - offsetof(ir_mode,sort))) return 1;
62 * searches the modes obstack for the given mode and returns
63 * a pointer on an equal mode already in the array, NULL if
66 static ir_mode *find_mode(const ir_mode *m)
69 struct _obstack_chunk *p;
72 for ( n = (ir_mode *)p->contents; (char *)(n+1) <= modes.next_free; ++n) {
74 if (modes_are_equal(n, m))
78 for (p = p->prev; p; p = p->prev) {
79 for (n = (ir_mode *)p->contents; (char *)(n+1) < p->limit; ++n)
81 if (modes_are_equal(n, m))
89 * sets special values of modes
91 static void set_mode_values(ir_mode* mode)
93 switch (get_mode_sort(mode))
96 case irms_float_number:
97 mode->min = get_tarval_min(mode);
98 mode->max = get_tarval_max(mode);
99 mode->null = get_tarval_null(mode);
100 mode->one = get_tarval_one(mode);
103 case irms_internal_boolean:
104 mode->min = tarval_b_false;
105 mode->max = tarval_b_true;
106 mode->null = tarval_b_false;
107 mode->one = tarval_b_true;
111 mode->min = tarval_bad;
112 mode->max = tarval_bad;
113 mode->null = (get_mode_modecode(mode)==irm_P)?tarval_P_void:tarval_bad;
114 mode->one = tarval_bad;
120 case irms_control_flow:
121 mode->min = tarval_bad;
122 mode->max = tarval_bad;
123 mode->null = tarval_bad;
124 mode->one = tarval_bad;
130 * globals defined in irmode.h
133 /* --- Predefined modes --- */
135 /* FIRM internal modes: */
143 /* predefined numerical modes: */
144 ir_mode *mode_F; /* float */
145 ir_mode *mode_D; /* double */
146 ir_mode *mode_E; /* long double */
148 ir_mode *mode_Bs; /* integral values, signed and unsigned */
149 ir_mode *mode_Bu; /* 8 bit */
150 ir_mode *mode_Hs; /* 16 bit */
152 ir_mode *mode_Is; /* 32 bit */
154 ir_mode *mode_Ls; /* 64 bit */
162 /* machine specific modes */
163 ir_mode *mode_P_mach; /* machine specific pointer mode */
166 * functions defined in irmode.h
169 /* JNI access functions */
170 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
171 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
172 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
173 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
174 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
175 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
176 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
177 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
178 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
179 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
180 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
181 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
182 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
183 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
184 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
185 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
186 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
187 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
188 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
189 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
190 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
193 ir_mode *get_modeP_mach(void) { ANNOUNCE(); return mode_P_mach; }
194 void set_modeP_mach(ir_mode *p) {
196 assert(mode_is_reference(p));
201 * Registers a new mode if not defined yet, else returns
202 * the "equivalent" one.
204 static ir_mode *register_mode(const ir_mode* new_mode)
206 ir_mode *mode = NULL;
211 /* copy mode struct to modes array */
212 mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
214 mode->kind = k_ir_mode;
215 if(num_modes>=irm_max) mode->code = num_modes;
218 set_mode_values(mode);
224 * Creates a new mode.
226 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic )
231 mode_tmpl.name = new_id_from_str(name);
232 mode_tmpl.sort = sort;
233 mode_tmpl.size = bit_size;
234 mode_tmpl.align = align;
235 mode_tmpl.sign = sign ? 1 : 0;
236 mode_tmpl.arithmetic = arithmetic;
237 mode_tmpl.link = NULL;
238 mode_tmpl.tv_priv = NULL;
240 mode = find_mode(&mode_tmpl);
250 case irms_control_flow:
252 case irms_internal_boolean:
253 assert(0 && "internal modes cannot be user defined");
256 case irms_float_number:
257 assert(0 && "not yet implemented");
260 case irms_int_number:
263 return register_mode(&mode_tmpl);
265 return NULL; /* to shut up gcc */
268 /* Functions for the direct access to all attributes od a ir_mode */
270 get_mode_modecode(const ir_mode *mode)
277 get_mode_ident(const ir_mode *mode)
284 get_mode_name(const ir_mode *mode)
287 return get_id_str(mode->name);
291 get_mode_sort(const ir_mode* mode)
298 get_mode_size_bits(const ir_mode *mode)
304 int get_mode_size_bytes(const ir_mode *mode) {
305 int size = get_mode_size_bits(mode);
307 if ((size & 7) != 0) return -1;
312 get_mode_align (const ir_mode *mode)
319 get_mode_sign (const ir_mode *mode)
325 int get_mode_arithmetic (const ir_mode *mode)
328 return mode->arithmetic;
331 void* get_mode_link(const ir_mode *mode)
337 void set_mode_link(ir_mode *mode, void *l)
344 get_mode_min (ir_mode *mode)
348 assert(get_mode_modecode(mode) < num_modes);
349 assert(mode_is_data(mode));
355 get_mode_max (ir_mode *mode)
359 assert(get_mode_modecode(mode) < num_modes);
360 assert(mode_is_data(mode));
366 get_mode_null (ir_mode *mode)
370 assert(get_mode_modecode(mode) < num_modes);
371 assert(mode_is_data(mode));
377 get_mode_one (ir_mode *mode)
381 assert(get_mode_modecode(mode) < num_modes);
382 assert(mode_is_data(mode));
388 get_mode_infinite(ir_mode *mode)
392 assert(get_mode_modecode(mode) < num_modes);
393 assert(mode_is_float(mode));
395 return get_tarval_inf(mode);
399 get_mode_NAN(ir_mode *mode)
403 assert(get_mode_modecode(mode) < num_modes);
404 assert(mode_is_float(mode));
406 return get_tarval_nan(mode);
410 is_mode (void *thing) {
412 if (get_kind(thing) == k_ir_mode)
418 /* Functions to check, whether a modecode is signed, float, int, num, data,
419 datab or dataM. For more exact definitions read the corresponding pages
420 in the firm documentation or the followingenumeration
422 The set of "float" is defined as:
423 ---------------------------------
424 float = {irm_F, irm_D, irm_E}
426 The set of "int" is defined as:
427 -------------------------------
428 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
430 The set of "num" is defined as:
431 -------------------------------
432 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
433 irm_Is, irm_Iu, irm_Ls, irm_Lu}
436 The set of "data" is defined as:
437 -------------------------------
438 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
439 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
440 = {num || irm_C || irm_U || irm_P}
442 The set of "datab" is defined as:
443 ---------------------------------
444 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
445 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
448 The set of "dataM" is defined as:
449 ---------------------------------
450 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
451 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
455 #ifdef MODE_ACCESS_DEFINES
456 # undef mode_is_signed
457 # undef mode_is_float
462 # undef mode_is_datab
463 # undef mode_is_dataM
466 mode_is_signed (const ir_mode *mode)
474 mode_is_float (const ir_mode *mode)
478 return (get_mode_sort(mode) == irms_float_number);
482 mode_is_int (const ir_mode *mode)
486 return (get_mode_sort(mode) == irms_int_number);
489 int mode_is_character (const ir_mode *mode)
493 return (get_mode_sort(mode) == irms_character);
496 int mode_is_reference (const ir_mode *mode)
500 return (get_mode_sort(mode) == irms_reference);
504 mode_is_num (const ir_mode *mode)
508 return (mode_is_int(mode) || mode_is_float(mode));
512 mode_is_numP (const ir_mode *mode)
516 return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
520 mode_is_data (const ir_mode *mode)
524 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
528 mode_is_datab (const ir_mode *mode)
532 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
536 mode_is_dataM (const ir_mode *mode)
540 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
542 #ifdef MODE_ACCESS_DEFINES
543 # define mode_is_signed(mode) (mode)->sign
544 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
545 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
546 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
547 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
548 # 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))
549 # 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))
551 /* Returns true if sm can be converted to lm without loss. */
553 smaller_mode(const ir_mode *sm, const ir_mode *lm)
559 if (sm == lm) return 1;
561 switch(get_mode_sort(sm))
563 case irms_int_number:
564 switch(get_mode_sort(lm))
566 case irms_int_number:
567 /* integers are convertable if
568 * - both have the same sign and lm is the larger one
569 * - lm is the signed one and is at least two bits larger
570 * (one for the sign, one for the highest bit of sm)
572 if (mode_is_signed(sm))
574 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
577 else if (mode_is_signed(lm))
579 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
582 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
588 case irms_float_number:
589 /* int to float works if the float is large enough */
597 case irms_float_number:
598 /* XXX currently only the three standard 32,64,80 bit floats
599 * are supported which can safely be converted */
600 if ( (get_mode_sort(lm) == irms_float_number)
601 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
606 /* do exist machines out there with different pointer lenghts ?*/
617 /* ** initialization ** */
623 /* init flexible array */
625 obstack_init(&modes);
628 /* initialize predefined modes */
631 newmode.arithmetic = irma_none;
636 newmode.tv_priv = NULL;
638 /* Control Flow Modes*/
639 newmode.sort = irms_control_flow;
642 newmode.name = id_from_str("BB", 2);
643 newmode.code = irm_BB;
645 mode_BB = register_mode(&newmode);
648 newmode.name = id_from_str("X", 1);
649 newmode.code = irm_X;
651 mode_X = register_mode(&newmode);
654 newmode.sort = irms_memory;
657 newmode.name = id_from_str("M", 1);
658 newmode.code = irm_M;
660 mode_M = register_mode(&newmode);
662 /* Auxiliary Modes */
663 newmode.sort = irms_auxiliary,
666 newmode.name = id_from_str("T", 1);
667 newmode.code = irm_T;
669 mode_T = register_mode(&newmode);
672 newmode.name = id_from_str("ANY", 3);
673 newmode.code = irm_ANY;
675 mode_ANY = register_mode(&newmode);
678 newmode.name = id_from_str("BAD", 3);
679 newmode.code = irm_BAD;
681 mode_BAD = register_mode(&newmode);
683 /* Internal Boolean Modes */
684 newmode.sort = irms_internal_boolean;
687 newmode.name = id_from_str("b", 1);
688 newmode.code = irm_b;
690 mode_b = register_mode(&newmode);
694 /* Float Number Modes */
695 newmode.sort = irms_float_number;
696 newmode.arithmetic = irma_ieee754;
699 newmode.name = id_from_str("F", 1);
700 newmode.code = irm_F;
705 mode_F = register_mode(&newmode);
708 newmode.name = id_from_str("D", 1);
709 newmode.code = irm_D;
714 mode_D = register_mode(&newmode);
717 newmode.name = id_from_str("E", 1);
718 newmode.code = irm_E;
723 mode_E = register_mode(&newmode);
725 /* Integer Number Modes */
726 newmode.sort = irms_int_number;
727 newmode.arithmetic = irma_twos_complement;
730 newmode.name = id_from_str("Bs", 2);
731 newmode.code = irm_Bs;
736 mode_Bs = register_mode(&newmode);
739 newmode.name = id_from_str("Bu", 2);
740 newmode.code = irm_Bu;
741 newmode.arithmetic = irma_twos_complement;
746 mode_Bu = register_mode(&newmode);
748 /* signed short integer */
749 newmode.name = id_from_str("Hs", 2);
750 newmode.code = irm_Hs;
755 mode_Hs = register_mode(&newmode);
757 /* unsigned short integer */
758 newmode.name = id_from_str("Hu", 2);
759 newmode.code = irm_Hu;
764 mode_Hu = register_mode(&newmode);
767 newmode.name = id_from_str("Is", 2);
768 newmode.code = irm_Is;
773 mode_Is = register_mode(&newmode);
775 /* unsigned integer */
776 newmode.name = id_from_str("Iu", 2);
777 newmode.code = irm_Iu;
782 mode_Iu = register_mode(&newmode);
784 /* signed long integer */
785 newmode.name = id_from_str("Ls", 2);
786 newmode.code = irm_Ls;
791 mode_Ls = register_mode(&newmode);
793 /* unsigned long integer */
794 newmode.name = id_from_str("Lu", 2);
795 newmode.code = irm_Lu;
800 mode_Lu = register_mode(&newmode);
802 /* Character Modes */
803 newmode.sort = irms_character;
804 newmode.arithmetic = irma_none;
807 newmode.name = id_from_str("C", 1);
808 newmode.code = irm_C;
813 mode_C = register_mode(&newmode);
815 /* Unicode character */
816 newmode.name = id_from_str("U", 1);
817 newmode.code = irm_U;
822 mode_U = register_mode(&newmode);
824 /* Reference Modes */
825 newmode.sort = irms_reference;
826 newmode.arithmetic = irma_twos_complement;
829 newmode.name = id_from_str("P", 1);
830 newmode.code = irm_P;
835 mode_P = register_mode(&newmode);
837 /* set the machine specific modes to the predifined ones */
838 mode_P_mach = mode_P;