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(ir_mode *m, ir_mode *n)
56 if ( (m->sort == n->sort) && (m->size == n->size) &&
57 (m->align == n->align) && (m->sign == n->sign) &&
58 (m->name == n->name) )
65 * searches the modes array for the given mode and returns
66 * a pointer on an equal mode already in the array, NULL if
69 static ir_mode *find_mode(ir_mode *m)
73 for (i = 0; i < num_modes; i++)
75 if (modes_are_equal(m, &modes[i])) return &modes[i];
82 * sets special values of modes
84 static void set_mode_values(ir_mode* mode)
86 modes_min[get_mode_modecode(mode)] = get_tarval_min(mode);
87 modes_max[get_mode_modecode(mode)] = get_tarval_max(mode);
88 modes_null[get_mode_modecode(mode)] = get_tarval_null(mode);
89 modes_one[get_mode_modecode(mode)] = get_tarval_one(mode);
92 * globals defined in irmode.h
95 /* --- Predefined modes --- */
97 /* FIRM internal modes: */
103 /* predefined numerical modes: */
104 ir_mode *mode_F; /* float */
105 ir_mode *mode_D; /* double */
106 ir_mode *mode_E; /* long double */
108 ir_mode *mode_Bs; /* integral values, signed and unsigned */
109 ir_mode *mode_Bu; /* 8 bit */
110 ir_mode *mode_Hs; /* 16 bit */
112 ir_mode *mode_Is; /* 32 bit */
114 ir_mode *mode_Ls; /* 64 bit */
123 * functions defined in irmode.h
126 /* JNI access functions */
127 INLINE ir_mode *get_modeT() { ANNOUNCE(); return mode_T; }
128 INLINE ir_mode *get_modeF() { ANNOUNCE(); return mode_F; }
129 INLINE ir_mode *get_modeD() { ANNOUNCE(); return mode_D; }
130 INLINE ir_mode *get_modeE() { ANNOUNCE(); return mode_E; }
131 INLINE ir_mode *get_modeBs() { ANNOUNCE(); return mode_Bs; }
132 INLINE ir_mode *get_modeBu() { ANNOUNCE(); return mode_Bu; }
133 INLINE ir_mode *get_modeHs() { ANNOUNCE(); return mode_Hs; }
134 INLINE ir_mode *get_modeHu() { ANNOUNCE(); return mode_Hu; }
135 INLINE ir_mode *get_modeIs() { ANNOUNCE(); return mode_Is; }
136 INLINE ir_mode *get_modeIu() { ANNOUNCE(); return mode_Iu; }
137 INLINE ir_mode *get_modeLs() { ANNOUNCE(); return mode_Ls; }
138 INLINE ir_mode *get_modeLu() { ANNOUNCE(); return mode_Lu; }
139 INLINE ir_mode *get_modeC() { ANNOUNCE(); return mode_C; }
140 INLINE ir_mode *get_modeU() { ANNOUNCE(); return mode_U; }
141 INLINE ir_mode *get_modeb() { ANNOUNCE(); return mode_b; }
142 INLINE ir_mode *get_modeP() { ANNOUNCE(); return mode_P; }
143 INLINE ir_mode *get_modeX() { ANNOUNCE(); return mode_X; }
144 INLINE ir_mode *get_modeM() { ANNOUNCE(); return mode_M; }
145 INLINE ir_mode *get_modeBB() { ANNOUNCE(); return mode_BB; }
147 /* ** Constructor ** */
149 register_mode(ir_mode* new_mode)
156 /* first check if there already is a matching mode */
157 mode = find_mode(new_mode);
158 if (mode) return mode;
161 switch (new_mode->sort)
164 case internal_boolean:
165 assert(0 && "internal modes cannot be user defined");
170 assert(0 && "not yet implemented");
184 /* copy mode struct to modes array */
185 ARR_EXTEND(ir_mode, modes, 1);
186 ARR_EXTEND(tarval*, modes_min, 1);
187 ARR_EXTEND(tarval*, modes_max, 1);
188 ARR_EXTEND(tarval*, modes_null, 1);
189 ARR_EXTEND(tarval*, modes_one, 1);
190 mode = &modes[num_modes];
192 memcpy(mode, new_mode, sizeof(ir_mode));
193 mode->code = num_modes;
196 set_mode_values(mode);
201 /* Functions for the direct access to all attributes of a ir_mode */
202 #ifdef MODE_ACCESS_DEFINES
203 # undef get_mode_modecode
204 # undef get_mode_ident
205 # undef get_mode_name
206 # undef get_mode_sort
207 # undef get_mode_size_bits
208 # undef get_mode_align
209 # undef get_mode_sign
213 get_mode_modecode(ir_mode *mode)
220 get_mode_ident(ir_mode *mode)
227 get_mode_name(ir_mode *mode)
230 return id_to_str(mode->name);
234 get_mode_sort(ir_mode* mode)
241 get_mode_size_bits(ir_mode *mode)
247 int get_mode_size_bytes(ir_mode *mode) {
249 int size = get_mode_size_bits(mode);
250 if ((size % 8) != 0) return -1;
255 get_mode_align (ir_mode *mode)
262 get_mode_sign (ir_mode *mode)
268 #ifdef MODE_ACCESS_DEFINES
269 # define get_mode_modecode(mode) (mode)->code
270 # define get_mode_ident(mode) (mode)->name
271 # define get_mode_name(mode) id_to_str((mode)->name)
272 # define get_mode_sort(mode) (mode)->sort
273 # define get_mode_size_bits(mode) (mode)->size
274 # define get_mode_align(mode) (mode)->align
275 # define get_mode_sign(mode) (mode)->sign
279 get_mode_min (ir_mode *mode)
283 assert(get_mode_modecode(mode) < num_modes);
284 assert(mode_is_data(mode));
286 return modes_min[get_mode_modecode(mode)];
290 get_mode_max (ir_mode *mode)
294 assert(get_mode_modecode(mode) < num_modes);
295 assert(mode_is_data(mode));
297 return modes_max[get_mode_modecode(mode)];
301 get_mode_null (ir_mode *mode)
305 assert(get_mode_modecode(mode) < num_modes);
306 assert(mode_is_data(mode));
308 return modes_null[get_mode_modecode(mode)];
312 get_mode_one (ir_mode *mode)
316 assert(get_mode_modecode(mode) < num_modes);
317 assert(mode_is_data(mode));
319 return modes_one[get_mode_modecode(mode)];
323 get_mode_infinite(ir_mode *mode)
327 assert(get_mode_modecode(mode) < num_modes);
328 assert(mode_is_float(mode));
330 return get_tarval_inf(mode);
334 get_mode_NAN(ir_mode *mode)
338 assert(get_mode_modecode(mode) < num_modes);
339 assert(mode_is_float(mode));
341 return get_tarval_nan(mode);
344 /* Functions to check, whether a modecode is signed, float, int, num, data,
345 datab or dataM. For more exact definitions read the corresponding pages
346 in the firm documentation or the followingenumeration
348 The set of "float" is defined as:
349 ---------------------------------
350 float = {irm_F, irm_D, irm_E}
352 The set of "int" is defined as:
353 -------------------------------
354 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
356 The set of "num" is defined as:
357 -------------------------------
358 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
359 irm_Is, irm_Iu, irm_Ls, irm_Lu}
362 The set of "data" is defined as:
363 -------------------------------
364 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
365 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
366 = {num || irm_C || irm_U || irm_P}
368 The set of "datab" is defined as:
369 ---------------------------------
370 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
371 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
374 The set of "dataM" is defined as:
375 ---------------------------------
376 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
377 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
381 #ifdef MODE_ACCESS_DEFINES
382 # undef mode_is_signed
383 # undef mode_is_float
387 # undef mode_is_datab
388 # undef mode_is_dataM
391 mode_is_signed (ir_mode *mode)
399 mode_is_float (ir_mode *mode)
403 return (get_mode_sort(mode) == float_number);
407 mode_is_int (ir_mode *mode)
411 return (get_mode_sort(mode) == int_number);
415 mode_is_num (ir_mode *mode)
419 return (mode_is_int(mode) || mode_is_float(mode));
423 mode_is_data (ir_mode *mode)
427 return (mode_is_num(mode) || get_mode_sort(mode) == character || get_mode_sort(mode) == reference);
431 mode_is_datab (ir_mode *mode)
435 return (mode_is_data(mode) || get_mode_sort(mode) == internal_boolean);
439 mode_is_dataM (ir_mode *mode)
443 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
445 #ifdef MODE_ACCESS_DEFINES
446 # define mode_is_signed(mode) (mode)->sign
447 # define mode_is_float(mode) ((mode)->sort == float_number)
448 # define mode_is_int(mode) ((mode)->sort == int_number)
449 # define mode_is_num(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number))
450 # define mode_is_data(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference))
451 # define mode_is_datab(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->sort == internal_boolean))
452 # define mode_is_dataM(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->code == irm_M))
454 /* Returns true if sm can be converted to lm without loss. */
456 smaller_mode(ir_mode *sm, ir_mode *lm)
462 if (sm == lm) return 1;
464 switch(get_mode_sort(sm))
467 switch(get_mode_sort(lm))
470 /* integers are convertable if
471 * - both have the same sign and lm is the larger one
472 * - lm is the signed one and is at least two bits larger
473 * (one for the sign, one for the highest bit of sm)
475 if (mode_is_signed(sm))
477 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
480 else if (mode_is_signed(lm))
482 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
485 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
492 /* int to float works if the float is large enough */
501 /* XXX currently only the three standard 32,64,80 bit floats
502 * are supported which can safely be converted */
503 if ( (get_mode_sort(lm) == float_number)
504 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
509 /* do exist machines out there with different pointer lenghts ?*/
520 /* ** initialization ** */
525 /* init flexible array */
526 modes = NEW_ARR_F(ir_mode, irm_max);
527 modes_min = NEW_ARR_F(tarval*, irm_max);
528 modes_max = NEW_ARR_F(tarval*, irm_max);
529 modes_null = NEW_ARR_F(tarval*, irm_max);
530 modes_one = NEW_ARR_F(tarval*, irm_max);
532 /* initialize predefined modes */
534 mode_BB = &modes[irm_BB];
535 mode_BB->name = id_from_str("BB", 2);
536 mode_BB->code = irm_BB;
537 mode_BB->sort = auxiliary;
539 mode_BB->tv_priv = NULL;
542 mode_X = &modes[irm_X];
543 mode_X->name = id_from_str("X", 1);
544 mode_X->code = irm_X;
545 mode_X->sort = auxiliary;
547 mode_X->tv_priv = NULL;
550 mode_M = &modes[irm_M];
551 mode_M->name = id_from_str("M", 1);
552 mode_M->code = irm_M;
553 mode_M->sort = auxiliary;
555 mode_M->tv_priv = NULL;
558 mode_T = &modes[irm_T];
559 mode_T->name = id_from_str("T", 1);
560 mode_T->code = irm_T;
562 mode_T->tv_priv = NULL;
565 mode_b = &modes[irm_b];
566 mode_b->name = id_from_str("b", 1);
567 mode_b->code = irm_b;
568 mode_b->sort = internal_boolean;
570 mode_b->tv_priv = NULL;
573 mode_F = &modes[irm_F];
574 mode_F->name = id_from_str("F", 1);
575 mode_F->code = irm_F;
576 mode_F->sort = float_number;
580 mode_F->tv_priv = NULL;
582 set_mode_values(mode_F);
585 mode_D = &modes[irm_D];
586 mode_D->name = id_from_str("D", 1);
587 mode_D->code = irm_D;
588 mode_D->sort = float_number;
592 mode_D->tv_priv = NULL;
594 set_mode_values(mode_D);
597 mode_E = &modes[irm_E];
598 mode_E->name = id_from_str("E", 1);
599 mode_E->code = irm_E;
600 mode_E->sort = float_number;
604 mode_E->tv_priv = NULL;
606 set_mode_values(mode_E);
609 mode_Bs = &modes[irm_Bs];
610 mode_Bs->name = id_from_str("Bs", 2);
611 mode_Bs->code = irm_Bs;
612 mode_Bs->sort = int_number;
616 mode_Bs->tv_priv = NULL;
618 set_mode_values(mode_Bs);
621 mode_Bu = &modes[irm_Bu];
622 mode_Bu->name = id_from_str("Bu", 2);
623 mode_Bu->code = irm_Bu;
624 mode_Bu->sort = int_number;
628 mode_Bu->tv_priv = NULL;
630 set_mode_values(mode_Bu);
632 /* signed short integer */
633 mode_Hs = &modes[irm_Hs];
634 mode_Hs->name = id_from_str("Hs", 2);
635 mode_Hs->code = irm_Hs;
636 mode_Hs->sort = int_number;
640 mode_Hs->tv_priv = NULL;
642 set_mode_values(mode_Hs);
644 /* unsigned short integer */
645 mode_Hu = &modes[irm_Hu];
646 mode_Hu->name = id_from_str("Hu", 2);
647 mode_Hu->code = irm_Hu;
648 mode_Hu->sort = int_number;
652 mode_Hu->tv_priv = NULL;
654 set_mode_values(mode_Hu);
657 mode_Is = &modes[irm_Is];
658 mode_Is->name = id_from_str("Is", 2);
659 mode_Is->code = irm_Is;
660 mode_Is->sort = int_number;
664 mode_Is->tv_priv = NULL;
666 set_mode_values(mode_Is);
668 /* unsigned integer */
669 mode_Iu = &modes[irm_Iu];
670 mode_Iu->name = id_from_str("Iu", 2);
671 mode_Iu->code = irm_Iu;
672 mode_Iu->sort = int_number;
676 mode_Iu->tv_priv = NULL;
678 set_mode_values(mode_Iu);
680 /* signed long integer */
681 mode_Ls = &modes[irm_Ls];
682 mode_Ls->name = id_from_str("Ls", 2);
683 mode_Ls->code = irm_Ls;
684 mode_Ls->sort = int_number;
688 mode_Ls->tv_priv = NULL;
690 set_mode_values(mode_Ls);
692 /* unsigned long integer */
693 mode_Lu = &modes[irm_Lu];
694 mode_Lu->name = id_from_str("Lu", 2);
695 mode_Lu->code = irm_Lu;
696 mode_Lu->sort = int_number;
700 mode_Lu->tv_priv = NULL;
702 set_mode_values(mode_Lu);
705 mode_C = &modes[irm_C];
706 mode_C->name = id_from_str("C", 1);
707 mode_C->code = irm_C;
708 mode_C->sort = character;
712 mode_C->tv_priv = NULL;
714 set_mode_values(mode_C);
716 /* Unicode character */
717 mode_U = &modes[irm_U];
718 mode_U->name = id_from_str("U", 1);
719 mode_U->code = irm_U;
720 mode_U->sort = character;
724 mode_U->tv_priv = NULL;
726 set_mode_values(mode_U);
729 mode_P = &modes[irm_P];
730 mode_P->name = id_from_str("P", 1);
731 mode_P->code = irm_P;
732 mode_P->sort = reference;
736 mode_P->tv_priv = NULL;