1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer
14 # include "irmode_t.h"
23 static long long count = 0;
24 # define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
26 # define ANNOUNCE() ((void)0)
34 /** dynamic array to hold all modes */
35 static ir_mode * modes;
36 /* dynamic arrays to hold special modes' values */
37 static tarval** modes_min;
38 static tarval** modes_max;
39 static tarval** modes_null;
40 static tarval** modes_one;
42 /** number of defined modes */
50 * Compare modes that don't need to have their code field
53 static int modes_are_equal(const ir_mode *m, const ir_mode *n)
56 if ( (m->sort == n->sort) && (m->size == n->size) &&
57 (m->align == n->align) && (m->sign == n->sign) &&
66 * searches the modes array for the given mode and returns
67 * a pointer on an equal mode already in the array, NULL if
70 static ir_mode *find_mode(ir_mode *m)
74 for (i = 0; i < num_modes; i++)
76 if (modes_are_equal(m, &modes[i])) return &modes[i];
83 * sets special values of modes
85 static void set_mode_values(ir_mode* mode)
87 modes_min[get_mode_modecode(mode)] = get_tarval_min(mode);
88 modes_max[get_mode_modecode(mode)] = get_tarval_max(mode);
89 modes_null[get_mode_modecode(mode)] = get_tarval_null(mode);
90 modes_one[get_mode_modecode(mode)] = get_tarval_one(mode);
93 * globals defined in irmode.h
96 /* --- Predefined modes --- */
98 /* FIRM internal modes: */
106 /* predefined numerical modes: */
107 ir_mode *mode_F; /* float */
108 ir_mode *mode_D; /* double */
109 ir_mode *mode_E; /* long double */
111 ir_mode *mode_Bs; /* integral values, signed and unsigned */
112 ir_mode *mode_Bu; /* 8 bit */
113 ir_mode *mode_Hs; /* 16 bit */
115 ir_mode *mode_Is; /* 32 bit */
117 ir_mode *mode_Ls; /* 64 bit */
126 * functions defined in irmode.h
129 /* JNI access functions */
130 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
131 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
132 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
133 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
134 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
135 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
136 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
137 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
138 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
139 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
140 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
141 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
142 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
143 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
144 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
145 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
146 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
147 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
148 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
149 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
150 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
153 * Registers a new mode if not defined yet, else returns
154 * the "equivalent" one.
156 static ir_mode *register_mode(ir_mode* new_mode)
163 /* first check if there already is a matching mode */
164 mode = find_mode(new_mode);
165 if (mode) return mode;
168 switch (new_mode->sort)
171 case irms_internal_boolean:
172 assert(0 && "internal modes cannot be user defined");
176 case irms_float_number:
177 assert(0 && "not yet implemented");
181 case irms_int_number:
187 assert(0 && "wrong mode sort");
191 /* copy mode struct to modes array */
192 ARR_EXTEND(ir_mode, modes, 1);
193 ARR_EXTEND(tarval*, modes_min, 1);
194 ARR_EXTEND(tarval*, modes_max, 1);
195 ARR_EXTEND(tarval*, modes_null, 1);
196 ARR_EXTEND(tarval*, modes_one, 1);
197 mode = &modes[num_modes];
199 memcpy(mode, new_mode, sizeof(ir_mode));
200 mode->code = num_modes;
203 set_mode_values(mode);
209 * Creates a new mode.
211 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign)
215 mode_tmpl.name = new_id_from_str(name);
216 mode_tmpl.sort = sort;
217 mode_tmpl.size = bit_size;
218 mode_tmpl.align = align;
219 mode_tmpl.sign = sign ? 1 : 0;
220 mode_tmpl.tv_priv = NULL;
222 return register_mode(&mode_tmpl);
225 /* Functions for the direct access to all attributes od a ir_mode */
227 get_mode_modecode(const ir_mode *mode)
234 get_mode_ident(const ir_mode *mode)
241 get_mode_name(const ir_mode *mode)
244 return id_to_str(mode->name);
248 get_mode_sort(const ir_mode* mode)
255 get_mode_size_bits(const ir_mode *mode)
261 int get_mode_size_bytes(const ir_mode *mode) {
263 int size = get_mode_size_bits(mode);
264 if ((size & 7) != 0) return -1;
269 get_mode_align (const ir_mode *mode)
276 get_mode_sign (const ir_mode *mode)
283 get_mode_min (ir_mode *mode)
287 assert(get_mode_modecode(mode) < num_modes);
288 assert(mode_is_data(mode));
290 return modes_min[get_mode_modecode(mode)];
294 get_mode_max (ir_mode *mode)
298 assert(get_mode_modecode(mode) < num_modes);
299 assert(mode_is_data(mode));
301 return modes_max[get_mode_modecode(mode)];
305 get_mode_null (ir_mode *mode)
309 assert(get_mode_modecode(mode) < num_modes);
310 assert(mode_is_data(mode));
312 return modes_null[get_mode_modecode(mode)];
316 get_mode_one (ir_mode *mode)
320 assert(get_mode_modecode(mode) < num_modes);
321 assert(mode_is_data(mode));
323 return modes_one[get_mode_modecode(mode)];
327 get_mode_infinite(ir_mode *mode)
331 assert(get_mode_modecode(mode) < num_modes);
332 assert(mode_is_float(mode));
334 return get_tarval_inf(mode);
338 get_mode_NAN(ir_mode *mode)
342 assert(get_mode_modecode(mode) < num_modes);
343 assert(mode_is_float(mode));
345 return get_tarval_nan(mode);
348 /* Functions to check, whether a modecode is signed, float, int, num, data,
349 datab or dataM. For more exact definitions read the corresponding pages
350 in the firm documentation or the followingenumeration
352 The set of "float" is defined as:
353 ---------------------------------
354 float = {irm_F, irm_D, irm_E}
356 The set of "int" is defined as:
357 -------------------------------
358 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
360 The set of "num" is defined as:
361 -------------------------------
362 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
363 irm_Is, irm_Iu, irm_Ls, irm_Lu}
366 The set of "data" is defined as:
367 -------------------------------
368 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
369 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
370 = {num || irm_C || irm_U || irm_P}
372 The set of "datab" is defined as:
373 ---------------------------------
374 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
375 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
378 The set of "dataM" is defined as:
379 ---------------------------------
380 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
381 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
385 #ifdef MODE_ACCESS_DEFINES
386 # undef mode_is_signed
387 # undef mode_is_float
391 # undef mode_is_datab
392 # undef mode_is_dataM
395 mode_is_signed (const ir_mode *mode)
403 mode_is_float (const ir_mode *mode)
407 return (get_mode_sort(mode) == irms_float_number);
411 mode_is_int (const ir_mode *mode)
415 return (get_mode_sort(mode) == irms_int_number);
418 int mode_is_character (const ir_mode *mode)
422 return (get_mode_sort(mode) == irms_character);
425 int mode_is_reference (const ir_mode *mode)
429 return (get_mode_sort(mode) == irms_reference);
433 mode_is_num (const ir_mode *mode)
437 return (mode_is_int(mode) || mode_is_float(mode));
441 mode_is_data (const ir_mode *mode)
445 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
449 mode_is_datab (const ir_mode *mode)
453 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
457 mode_is_dataM (const ir_mode *mode)
461 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
463 #ifdef MODE_ACCESS_DEFINES
464 # define mode_is_signed(mode) (mode)->sign
465 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
466 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
467 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
468 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
469 # 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))
470 # 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))
472 /* Returns true if sm can be converted to lm without loss. */
474 smaller_mode(const ir_mode *sm, const ir_mode *lm)
480 if (sm == lm) return 1;
482 switch(get_mode_sort(sm))
484 case irms_int_number:
485 switch(get_mode_sort(lm))
487 case irms_int_number:
488 /* integers are convertable if
489 * - both have the same sign and lm is the larger one
490 * - lm is the signed one and is at least two bits larger
491 * (one for the sign, one for the highest bit of sm)
493 if (mode_is_signed(sm))
495 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
498 else if (mode_is_signed(lm))
500 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
503 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
509 case irms_float_number:
510 /* int to float works if the float is large enough */
518 case irms_float_number:
519 /* XXX currently only the three standard 32,64,80 bit floats
520 * are supported which can safely be converted */
521 if ( (get_mode_sort(lm) == irms_float_number)
522 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
527 /* do exist machines out there with different pointer lenghts ?*/
538 /* ** initialization ** */
543 /* init flexible array */
544 modes = NEW_ARR_F(ir_mode, irm_max);
545 modes_min = NEW_ARR_F(tarval*, irm_max);
546 modes_max = NEW_ARR_F(tarval*, irm_max);
547 modes_null = NEW_ARR_F(tarval*, irm_max);
548 modes_one = NEW_ARR_F(tarval*, irm_max);
550 /* initialize predefined modes */
552 mode_BB = &modes[irm_BB];
553 mode_BB->name = id_from_str("BB", 2);
554 mode_BB->code = irm_BB;
555 mode_BB->sort = irms_auxiliary;
559 mode_BB->tv_priv = NULL;
562 mode_X = &modes[irm_X];
563 mode_X->name = id_from_str("X", 1);
564 mode_X->code = irm_X;
565 mode_X->sort = irms_auxiliary;
569 mode_X->tv_priv = NULL;
572 mode_M = &modes[irm_M];
573 mode_M->name = id_from_str("M", 1);
574 mode_M->code = irm_M;
575 mode_M->sort = irms_auxiliary;
579 mode_M->tv_priv = NULL;
582 mode_T = &modes[irm_T];
583 mode_T->name = id_from_str("T", 1);
584 mode_T->code = irm_T;
585 mode_T->sort = irms_auxiliary,
589 mode_T->tv_priv = NULL;
592 mode_ANY = &modes[irm_ANY];
593 mode_ANY->name = id_from_str("ANY", 3);
594 mode_ANY->code = irm_ANY;
595 mode_ANY->sort = irms_auxiliary;
599 mode_ANY->tv_priv = NULL;
602 mode_BAD = &modes[irm_BAD];
603 mode_BAD->name = id_from_str("BAD", 3);
604 mode_BAD->code = irm_BAD;
605 mode_BAD->sort = irms_auxiliary;
609 mode_BAD->tv_priv = NULL;
612 mode_b = &modes[irm_b];
613 mode_b->name = id_from_str("b", 1);
614 mode_b->code = irm_b;
615 mode_b->sort = irms_internal_boolean;
619 mode_b->tv_priv = NULL;
622 mode_F = &modes[irm_F];
623 mode_F->name = id_from_str("F", 1);
624 mode_F->code = irm_F;
625 mode_F->sort = irms_float_number;
629 mode_F->tv_priv = NULL;
631 set_mode_values(mode_F);
634 mode_D = &modes[irm_D];
635 mode_D->name = id_from_str("D", 1);
636 mode_D->code = irm_D;
637 mode_D->sort = irms_float_number;
641 mode_D->tv_priv = NULL;
643 set_mode_values(mode_D);
646 mode_E = &modes[irm_E];
647 mode_E->name = id_from_str("E", 1);
648 mode_E->code = irm_E;
649 mode_E->sort = irms_float_number;
653 mode_E->tv_priv = NULL;
655 set_mode_values(mode_E);
658 mode_Bs = &modes[irm_Bs];
659 mode_Bs->name = id_from_str("Bs", 2);
660 mode_Bs->code = irm_Bs;
661 mode_Bs->sort = irms_int_number;
665 mode_Bs->tv_priv = NULL;
667 set_mode_values(mode_Bs);
670 mode_Bu = &modes[irm_Bu];
671 mode_Bu->name = id_from_str("Bu", 2);
672 mode_Bu->code = irm_Bu;
673 mode_Bu->sort = irms_int_number;
677 mode_Bu->tv_priv = NULL;
679 set_mode_values(mode_Bu);
681 /* signed short integer */
682 mode_Hs = &modes[irm_Hs];
683 mode_Hs->name = id_from_str("Hs", 2);
684 mode_Hs->code = irm_Hs;
685 mode_Hs->sort = irms_int_number;
689 mode_Hs->tv_priv = NULL;
691 set_mode_values(mode_Hs);
693 /* unsigned short integer */
694 mode_Hu = &modes[irm_Hu];
695 mode_Hu->name = id_from_str("Hu", 2);
696 mode_Hu->code = irm_Hu;
697 mode_Hu->sort = irms_int_number;
701 mode_Hu->tv_priv = NULL;
703 set_mode_values(mode_Hu);
706 mode_Is = &modes[irm_Is];
707 mode_Is->name = id_from_str("Is", 2);
708 mode_Is->code = irm_Is;
709 mode_Is->sort = irms_int_number;
713 mode_Is->tv_priv = NULL;
715 set_mode_values(mode_Is);
717 /* unsigned integer */
718 mode_Iu = &modes[irm_Iu];
719 mode_Iu->name = id_from_str("Iu", 2);
720 mode_Iu->code = irm_Iu;
721 mode_Iu->sort = irms_int_number;
725 mode_Iu->tv_priv = NULL;
727 set_mode_values(mode_Iu);
729 /* signed long integer */
730 mode_Ls = &modes[irm_Ls];
731 mode_Ls->name = id_from_str("Ls", 2);
732 mode_Ls->code = irm_Ls;
733 mode_Ls->sort = irms_int_number;
737 mode_Ls->tv_priv = NULL;
739 set_mode_values(mode_Ls);
741 /* unsigned long integer */
742 mode_Lu = &modes[irm_Lu];
743 mode_Lu->name = id_from_str("Lu", 2);
744 mode_Lu->code = irm_Lu;
745 mode_Lu->sort = irms_int_number;
749 mode_Lu->tv_priv = NULL;
751 set_mode_values(mode_Lu);
754 mode_C = &modes[irm_C];
755 mode_C->name = id_from_str("C", 1);
756 mode_C->code = irm_C;
757 mode_C->sort = irms_character;
761 mode_C->tv_priv = NULL;
763 set_mode_values(mode_C);
765 /* Unicode character */
766 mode_U = &modes[irm_U];
767 mode_U->name = id_from_str("U", 1);
768 mode_U->code = irm_U;
769 mode_U->sort = irms_character;
773 mode_U->tv_priv = NULL;
775 set_mode_values(mode_U);
778 mode_P = &modes[irm_P];
779 mode_P->name = id_from_str("P", 1);
780 mode_P->code = irm_P;
781 mode_P->sort = irms_reference;
785 mode_P->tv_priv = NULL;