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)
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; }
148 * Registers a new mode if not defined yet, else returns
149 * the "equivalent" one.
151 static ir_mode *register_mode(ir_mode* new_mode)
158 /* first check if there already is a matching mode */
159 mode = find_mode(new_mode);
160 if (mode) return mode;
163 switch (new_mode->sort)
166 case irms_internal_boolean:
167 assert(0 && "internal modes cannot be user defined");
171 case irms_float_number:
172 assert(0 && "not yet implemented");
176 case irms_int_number:
182 assert(0 && "wrong mode sort");
186 /* copy mode struct to modes array */
187 ARR_EXTEND(ir_mode, modes, 1);
188 ARR_EXTEND(tarval*, modes_min, 1);
189 ARR_EXTEND(tarval*, modes_max, 1);
190 ARR_EXTEND(tarval*, modes_null, 1);
191 ARR_EXTEND(tarval*, modes_one, 1);
192 mode = &modes[num_modes];
194 memcpy(mode, new_mode, sizeof(ir_mode));
195 mode->code = num_modes;
198 set_mode_values(mode);
204 * Creates a new mode.
206 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign)
208 ir_mode mode_tmpl, *res;
210 mode_tmpl.name = new_id_from_str(name);
211 mode_tmpl.sort = sort;
212 mode_tmpl.size = bit_size;
213 mode_tmpl.align = align;
214 mode_tmpl.sign = sign ? 1 : 0;
215 mode_tmpl.tv_priv = NULL;
217 return register_mode(&mode_tmpl);
220 /* Functions for the direct access to all attributes od a ir_mode */
222 get_mode_modecode(ir_mode *mode)
229 get_mode_ident(ir_mode *mode)
236 get_mode_name(ir_mode *mode)
239 return id_to_str(mode->name);
243 get_mode_sort(ir_mode* mode)
250 get_mode_size_bits(ir_mode *mode)
256 int get_mode_size_bytes(ir_mode *mode) {
258 int size = get_mode_size_bits(mode);
259 if ((size % 8) != 0) return -1;
264 get_mode_align (ir_mode *mode)
271 get_mode_sign (ir_mode *mode)
278 get_mode_min (ir_mode *mode)
282 assert(get_mode_modecode(mode) < num_modes);
283 assert(mode_is_data(mode));
285 return modes_min[get_mode_modecode(mode)];
289 get_mode_max (ir_mode *mode)
293 assert(get_mode_modecode(mode) < num_modes);
294 assert(mode_is_data(mode));
296 return modes_max[get_mode_modecode(mode)];
300 get_mode_null (ir_mode *mode)
304 assert(get_mode_modecode(mode) < num_modes);
305 assert(mode_is_data(mode));
307 return modes_null[get_mode_modecode(mode)];
311 get_mode_one (ir_mode *mode)
315 assert(get_mode_modecode(mode) < num_modes);
316 assert(mode_is_data(mode));
318 return modes_one[get_mode_modecode(mode)];
322 get_mode_infinite(ir_mode *mode)
326 assert(get_mode_modecode(mode) < num_modes);
327 assert(mode_is_float(mode));
329 return get_tarval_inf(mode);
333 get_mode_NAN(ir_mode *mode)
337 assert(get_mode_modecode(mode) < num_modes);
338 assert(mode_is_float(mode));
340 return get_tarval_nan(mode);
343 /* Functions to check, whether a modecode is signed, float, int, num, data,
344 datab or dataM. For more exact definitions read the corresponding pages
345 in the firm documentation or the followingenumeration
347 The set of "float" is defined as:
348 ---------------------------------
349 float = {irm_F, irm_D, irm_E}
351 The set of "int" is defined as:
352 -------------------------------
353 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
355 The set of "num" is defined as:
356 -------------------------------
357 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
358 irm_Is, irm_Iu, irm_Ls, irm_Lu}
361 The set of "data" is defined as:
362 -------------------------------
363 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
364 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
365 = {num || irm_C || irm_U || irm_P}
367 The set of "datab" is defined as:
368 ---------------------------------
369 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
370 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
373 The set of "dataM" is defined as:
374 ---------------------------------
375 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
376 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
380 #ifdef MODE_ACCESS_DEFINES
381 # undef mode_is_signed
382 # undef mode_is_float
386 # undef mode_is_datab
387 # undef mode_is_dataM
390 mode_is_signed (ir_mode *mode)
398 mode_is_float (ir_mode *mode)
402 return (get_mode_sort(mode) == irms_float_number);
406 mode_is_int (ir_mode *mode)
410 return (get_mode_sort(mode) == irms_int_number);
414 mode_is_num (ir_mode *mode)
418 return (mode_is_int(mode) || mode_is_float(mode));
422 mode_is_data (ir_mode *mode)
426 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
430 mode_is_datab (ir_mode *mode)
434 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
438 mode_is_dataM (ir_mode *mode)
442 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
444 #ifdef MODE_ACCESS_DEFINES
445 # define mode_is_signed(mode) (mode)->sign
446 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
447 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
448 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
449 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
450 # 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))
451 # 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))
453 /* Returns true if sm can be converted to lm without loss. */
455 smaller_mode(ir_mode *sm, ir_mode *lm)
461 if (sm == lm) return 1;
463 switch(get_mode_sort(sm))
465 case irms_int_number:
466 switch(get_mode_sort(lm))
468 case irms_int_number:
469 /* integers are convertable if
470 * - both have the same sign and lm is the larger one
471 * - lm is the signed one and is at least two bits larger
472 * (one for the sign, one for the highest bit of sm)
474 if (mode_is_signed(sm))
476 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
479 else if (mode_is_signed(lm))
481 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
484 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
490 case irms_float_number:
491 /* int to float works if the float is large enough */
499 case irms_float_number:
500 /* XXX currently only the three standard 32,64,80 bit floats
501 * are supported which can safely be converted */
502 if ( (get_mode_sort(lm) == irms_float_number)
503 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
508 /* do exist machines out there with different pointer lenghts ?*/
519 /* ** initialization ** */
524 /* init flexible array */
525 modes = NEW_ARR_F(ir_mode, irm_max);
526 modes_min = NEW_ARR_F(tarval*, irm_max);
527 modes_max = NEW_ARR_F(tarval*, irm_max);
528 modes_null = NEW_ARR_F(tarval*, irm_max);
529 modes_one = NEW_ARR_F(tarval*, irm_max);
531 /* initialize predefined modes */
533 mode_BB = &modes[irm_BB];
534 mode_BB->name = id_from_str("BB", 2);
535 mode_BB->code = irm_BB;
536 mode_BB->sort = irms_auxiliary;
538 mode_BB->tv_priv = NULL;
541 mode_X = &modes[irm_X];
542 mode_X->name = id_from_str("X", 1);
543 mode_X->code = irm_X;
544 mode_X->sort = irms_auxiliary;
546 mode_X->tv_priv = NULL;
549 mode_M = &modes[irm_M];
550 mode_M->name = id_from_str("M", 1);
551 mode_M->code = irm_M;
552 mode_M->sort = irms_auxiliary;
554 mode_M->tv_priv = NULL;
557 mode_T = &modes[irm_T];
558 mode_T->name = id_from_str("T", 1);
559 mode_T->code = irm_T;
561 mode_T->tv_priv = NULL;
564 mode_b = &modes[irm_b];
565 mode_b->name = id_from_str("b", 1);
566 mode_b->code = irm_b;
567 mode_b->sort = irms_internal_boolean;
569 mode_b->tv_priv = NULL;
572 mode_F = &modes[irm_F];
573 mode_F->name = id_from_str("F", 1);
574 mode_F->code = irm_F;
575 mode_F->sort = irms_float_number;
579 mode_F->tv_priv = NULL;
581 set_mode_values(mode_F);
584 mode_D = &modes[irm_D];
585 mode_D->name = id_from_str("D", 1);
586 mode_D->code = irm_D;
587 mode_D->sort = irms_float_number;
591 mode_D->tv_priv = NULL;
593 set_mode_values(mode_D);
596 mode_E = &modes[irm_E];
597 mode_E->name = id_from_str("E", 1);
598 mode_E->code = irm_E;
599 mode_E->sort = irms_float_number;
603 mode_E->tv_priv = NULL;
605 set_mode_values(mode_E);
608 mode_Bs = &modes[irm_Bs];
609 mode_Bs->name = id_from_str("Bs", 2);
610 mode_Bs->code = irm_Bs;
611 mode_Bs->sort = irms_int_number;
615 mode_Bs->tv_priv = NULL;
617 set_mode_values(mode_Bs);
620 mode_Bu = &modes[irm_Bu];
621 mode_Bu->name = id_from_str("Bu", 2);
622 mode_Bu->code = irm_Bu;
623 mode_Bu->sort = irms_int_number;
627 mode_Bu->tv_priv = NULL;
629 set_mode_values(mode_Bu);
631 /* signed short integer */
632 mode_Hs = &modes[irm_Hs];
633 mode_Hs->name = id_from_str("Hs", 2);
634 mode_Hs->code = irm_Hs;
635 mode_Hs->sort = irms_int_number;
639 mode_Hs->tv_priv = NULL;
641 set_mode_values(mode_Hs);
643 /* unsigned short integer */
644 mode_Hu = &modes[irm_Hu];
645 mode_Hu->name = id_from_str("Hu", 2);
646 mode_Hu->code = irm_Hu;
647 mode_Hu->sort = irms_int_number;
651 mode_Hu->tv_priv = NULL;
653 set_mode_values(mode_Hu);
656 mode_Is = &modes[irm_Is];
657 mode_Is->name = id_from_str("Is", 2);
658 mode_Is->code = irm_Is;
659 mode_Is->sort = irms_int_number;
663 mode_Is->tv_priv = NULL;
665 set_mode_values(mode_Is);
667 /* unsigned integer */
668 mode_Iu = &modes[irm_Iu];
669 mode_Iu->name = id_from_str("Iu", 2);
670 mode_Iu->code = irm_Iu;
671 mode_Iu->sort = irms_int_number;
675 mode_Iu->tv_priv = NULL;
677 set_mode_values(mode_Iu);
679 /* signed long integer */
680 mode_Ls = &modes[irm_Ls];
681 mode_Ls->name = id_from_str("Ls", 2);
682 mode_Ls->code = irm_Ls;
683 mode_Ls->sort = irms_int_number;
687 mode_Ls->tv_priv = NULL;
689 set_mode_values(mode_Ls);
691 /* unsigned long integer */
692 mode_Lu = &modes[irm_Lu];
693 mode_Lu->name = id_from_str("Lu", 2);
694 mode_Lu->code = irm_Lu;
695 mode_Lu->sort = irms_int_number;
699 mode_Lu->tv_priv = NULL;
701 set_mode_values(mode_Lu);
704 mode_C = &modes[irm_C];
705 mode_C->name = id_from_str("C", 1);
706 mode_C->code = irm_C;
707 mode_C->sort = irms_character;
711 mode_C->tv_priv = NULL;
713 set_mode_values(mode_C);
715 /* Unicode character */
716 mode_U = &modes[irm_U];
717 mode_U->name = id_from_str("U", 1);
718 mode_U->code = irm_U;
719 mode_U->sort = irms_character;
723 mode_U->tv_priv = NULL;
725 set_mode_values(mode_U);
728 mode_P = &modes[irm_P];
729 mode_P->name = id_from_str("P", 1);
730 mode_P->code = irm_P;
731 mode_P->sort = irms_reference;
735 mode_P->tv_priv = NULL;