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) &&
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: */
104 /* predefined numerical modes: */
105 ir_mode *mode_F; /* float */
106 ir_mode *mode_D; /* double */
107 ir_mode *mode_E; /* long double */
109 ir_mode *mode_Bs; /* integral values, signed and unsigned */
110 ir_mode *mode_Bu; /* 8 bit */
111 ir_mode *mode_Hs; /* 16 bit */
113 ir_mode *mode_Is; /* 32 bit */
115 ir_mode *mode_Ls; /* 64 bit */
124 * functions defined in irmode.h
127 /* JNI access functions */
128 INLINE ir_mode *get_modeT() { ANNOUNCE(); return mode_T; }
129 INLINE ir_mode *get_modeF() { ANNOUNCE(); return mode_F; }
130 INLINE ir_mode *get_modeD() { ANNOUNCE(); return mode_D; }
131 INLINE ir_mode *get_modeE() { ANNOUNCE(); return mode_E; }
132 INLINE ir_mode *get_modeBs() { ANNOUNCE(); return mode_Bs; }
133 INLINE ir_mode *get_modeBu() { ANNOUNCE(); return mode_Bu; }
134 INLINE ir_mode *get_modeHs() { ANNOUNCE(); return mode_Hs; }
135 INLINE ir_mode *get_modeHu() { ANNOUNCE(); return mode_Hu; }
136 INLINE ir_mode *get_modeIs() { ANNOUNCE(); return mode_Is; }
137 INLINE ir_mode *get_modeIu() { ANNOUNCE(); return mode_Iu; }
138 INLINE ir_mode *get_modeLs() { ANNOUNCE(); return mode_Ls; }
139 INLINE ir_mode *get_modeLu() { ANNOUNCE(); return mode_Lu; }
140 INLINE ir_mode *get_modeC() { ANNOUNCE(); return mode_C; }
141 INLINE ir_mode *get_modeU() { ANNOUNCE(); return mode_U; }
142 INLINE ir_mode *get_modeb() { ANNOUNCE(); return mode_b; }
143 INLINE ir_mode *get_modeP() { ANNOUNCE(); return mode_P; }
144 INLINE ir_mode *get_modeX() { ANNOUNCE(); return mode_X; }
145 INLINE ir_mode *get_modeM() { ANNOUNCE(); return mode_M; }
146 INLINE ir_mode *get_modeBB() { ANNOUNCE(); return mode_BB; }
149 * Registers a new mode if not defined yet, else returns
150 * the "equivalent" one.
152 static ir_mode *register_mode(ir_mode* new_mode)
159 /* first check if there already is a matching mode */
160 mode = find_mode(new_mode);
161 if (mode) return mode;
164 switch (new_mode->sort)
167 case irms_internal_boolean:
168 assert(0 && "internal modes cannot be user defined");
172 case irms_float_number:
173 assert(0 && "not yet implemented");
177 case irms_int_number:
183 assert(0 && "wrong mode sort");
187 /* copy mode struct to modes array */
188 ARR_EXTEND(ir_mode, modes, 1);
189 ARR_EXTEND(tarval*, modes_min, 1);
190 ARR_EXTEND(tarval*, modes_max, 1);
191 ARR_EXTEND(tarval*, modes_null, 1);
192 ARR_EXTEND(tarval*, modes_one, 1);
193 mode = &modes[num_modes];
195 memcpy(mode, new_mode, sizeof(ir_mode));
196 mode->code = num_modes;
199 set_mode_values(mode);
205 * Creates a new mode.
207 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign)
209 ir_mode mode_tmpl, *res;
211 mode_tmpl.name = new_id_from_str(name);
212 mode_tmpl.sort = sort;
213 mode_tmpl.size = bit_size;
214 mode_tmpl.align = align;
215 mode_tmpl.sign = sign ? 1 : 0;
216 mode_tmpl.tv_priv = NULL;
218 return register_mode(&mode_tmpl);
221 /* Functions for the direct access to all attributes od a ir_mode */
223 get_mode_modecode(ir_mode *mode)
230 get_mode_ident(ir_mode *mode)
237 get_mode_name(ir_mode *mode)
240 return id_to_str(mode->name);
244 get_mode_sort(ir_mode* mode)
251 get_mode_size_bits(ir_mode *mode)
257 int get_mode_size_bytes(ir_mode *mode) {
259 int size = get_mode_size_bits(mode);
260 if ((size % 8) != 0) return -1;
265 get_mode_align (ir_mode *mode)
272 get_mode_sign (ir_mode *mode)
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) == irms_float_number);
407 mode_is_int (ir_mode *mode)
411 return (get_mode_sort(mode) == irms_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) == irms_character || get_mode_sort(mode) == irms_reference);
431 mode_is_datab (ir_mode *mode)
435 return (mode_is_data(mode) || get_mode_sort(mode) == irms_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 == irms_float_number)
448 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
449 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
450 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
451 # 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))
452 # 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))
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))
466 case irms_int_number:
467 switch(get_mode_sort(lm))
469 case irms_int_number:
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))
491 case irms_float_number:
492 /* int to float works if the float is large enough */
500 case irms_float_number:
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) == irms_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 = irms_auxiliary;
541 mode_BB->tv_priv = NULL;
544 mode_X = &modes[irm_X];
545 mode_X->name = id_from_str("X", 1);
546 mode_X->code = irm_X;
547 mode_X->sort = irms_auxiliary;
551 mode_X->tv_priv = NULL;
554 mode_M = &modes[irm_M];
555 mode_M->name = id_from_str("M", 1);
556 mode_M->code = irm_M;
557 mode_M->sort = irms_auxiliary;
561 mode_M->tv_priv = NULL;
564 mode_T = &modes[irm_T];
565 mode_T->name = id_from_str("T", 1);
566 mode_T->code = irm_T;
567 mode_T->sort = irms_auxiliary,
571 mode_T->tv_priv = NULL;
574 mode_b = &modes[irm_b];
575 mode_b->name = id_from_str("b", 1);
576 mode_b->code = irm_b;
577 mode_b->sort = irms_internal_boolean;
581 mode_b->tv_priv = NULL;
584 mode_F = &modes[irm_F];
585 mode_F->name = id_from_str("F", 1);
586 mode_F->code = irm_F;
587 mode_F->sort = irms_float_number;
591 mode_F->tv_priv = NULL;
593 set_mode_values(mode_F);
596 mode_D = &modes[irm_D];
597 mode_D->name = id_from_str("D", 1);
598 mode_D->code = irm_D;
599 mode_D->sort = irms_float_number;
603 mode_D->tv_priv = NULL;
605 set_mode_values(mode_D);
608 mode_E = &modes[irm_E];
609 mode_E->name = id_from_str("E", 1);
610 mode_E->code = irm_E;
611 mode_E->sort = irms_float_number;
615 mode_E->tv_priv = NULL;
617 set_mode_values(mode_E);
620 mode_Bs = &modes[irm_Bs];
621 mode_Bs->name = id_from_str("Bs", 2);
622 mode_Bs->code = irm_Bs;
623 mode_Bs->sort = irms_int_number;
627 mode_Bs->tv_priv = NULL;
629 set_mode_values(mode_Bs);
632 mode_Bu = &modes[irm_Bu];
633 mode_Bu->name = id_from_str("Bu", 2);
634 mode_Bu->code = irm_Bu;
635 mode_Bu->sort = irms_int_number;
639 mode_Bu->tv_priv = NULL;
641 set_mode_values(mode_Bu);
643 /* signed short integer */
644 mode_Hs = &modes[irm_Hs];
645 mode_Hs->name = id_from_str("Hs", 2);
646 mode_Hs->code = irm_Hs;
647 mode_Hs->sort = irms_int_number;
651 mode_Hs->tv_priv = NULL;
653 set_mode_values(mode_Hs);
655 /* unsigned short integer */
656 mode_Hu = &modes[irm_Hu];
657 mode_Hu->name = id_from_str("Hu", 2);
658 mode_Hu->code = irm_Hu;
659 mode_Hu->sort = irms_int_number;
663 mode_Hu->tv_priv = NULL;
665 set_mode_values(mode_Hu);
668 mode_Is = &modes[irm_Is];
669 mode_Is->name = id_from_str("Is", 2);
670 mode_Is->code = irm_Is;
671 mode_Is->sort = irms_int_number;
675 mode_Is->tv_priv = NULL;
677 set_mode_values(mode_Is);
679 /* unsigned integer */
680 mode_Iu = &modes[irm_Iu];
681 mode_Iu->name = id_from_str("Iu", 2);
682 mode_Iu->code = irm_Iu;
683 mode_Iu->sort = irms_int_number;
687 mode_Iu->tv_priv = NULL;
689 set_mode_values(mode_Iu);
691 /* signed long integer */
692 mode_Ls = &modes[irm_Ls];
693 mode_Ls->name = id_from_str("Ls", 2);
694 mode_Ls->code = irm_Ls;
695 mode_Ls->sort = irms_int_number;
699 mode_Ls->tv_priv = NULL;
701 set_mode_values(mode_Ls);
703 /* unsigned long integer */
704 mode_Lu = &modes[irm_Lu];
705 mode_Lu->name = id_from_str("Lu", 2);
706 mode_Lu->code = irm_Lu;
707 mode_Lu->sort = irms_int_number;
711 mode_Lu->tv_priv = NULL;
713 set_mode_values(mode_Lu);
716 mode_C = &modes[irm_C];
717 mode_C->name = id_from_str("C", 1);
718 mode_C->code = irm_C;
719 mode_C->sort = irms_character;
723 mode_C->tv_priv = NULL;
725 set_mode_values(mode_C);
727 /* Unicode character */
728 mode_U = &modes[irm_U];
729 mode_U->name = id_from_str("U", 1);
730 mode_U->code = irm_U;
731 mode_U->sort = irms_character;
735 mode_U->tv_priv = NULL;
737 set_mode_values(mode_U);
740 mode_P = &modes[irm_P];
741 mode_P->name = id_from_str("P", 1);
742 mode_P->code = irm_P;
743 mode_P->sort = irms_reference;
747 mode_P->tv_priv = NULL;