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 od a ir_mode */
203 get_mode_modecode(ir_mode *mode)
210 get_mode_ident(ir_mode *mode)
217 get_mode_name(ir_mode *mode)
220 return id_to_str(mode->name);
224 get_mode_sort(ir_mode* mode)
231 get_mode_size_bits(ir_mode *mode)
237 int get_mode_size_bytes(ir_mode *mode) {
239 int size = get_mode_size_bits(mode);
240 if ((size % 8) != 0) return -1;
245 get_mode_align (ir_mode *mode)
252 get_mode_sign (ir_mode *mode)
259 get_mode_min (ir_mode *mode)
263 assert(get_mode_modecode(mode) < num_modes);
264 assert(mode_is_data(mode));
266 return modes_min[get_mode_modecode(mode)];
270 get_mode_max (ir_mode *mode)
274 assert(get_mode_modecode(mode) < num_modes);
275 assert(mode_is_data(mode));
277 return modes_max[get_mode_modecode(mode)];
281 get_mode_null (ir_mode *mode)
285 assert(get_mode_modecode(mode) < num_modes);
286 assert(mode_is_data(mode));
288 return modes_null[get_mode_modecode(mode)];
292 get_mode_one (ir_mode *mode)
296 assert(get_mode_modecode(mode) < num_modes);
297 assert(mode_is_data(mode));
299 return modes_one[get_mode_modecode(mode)];
303 get_mode_infinite(ir_mode *mode)
307 assert(get_mode_modecode(mode) < num_modes);
308 assert(mode_is_float(mode));
310 return get_tarval_inf(mode);
314 get_mode_NAN(ir_mode *mode)
318 assert(get_mode_modecode(mode) < num_modes);
319 assert(mode_is_float(mode));
321 return get_tarval_nan(mode);
324 /* Functions to check, whether a modecode is signed, float, int, num, data,
325 datab or dataM. For more exact definitions read the corresponding pages
326 in the firm documentation or the followingenumeration
328 The set of "float" is defined as:
329 ---------------------------------
330 float = {irm_F, irm_D, irm_E}
332 The set of "int" is defined as:
333 -------------------------------
334 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
336 The set of "num" is defined as:
337 -------------------------------
338 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
339 irm_Is, irm_Iu, irm_Ls, irm_Lu}
342 The set of "data" is defined as:
343 -------------------------------
344 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
345 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
346 = {num || irm_C || irm_U || irm_P}
348 The set of "datab" is defined as:
349 ---------------------------------
350 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
351 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
354 The set of "dataM" is defined as:
355 ---------------------------------
356 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
357 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
361 #ifdef MODE_ACCESS_DEFINES
362 # undef mode_is_signed
363 # undef mode_is_float
367 # undef mode_is_datab
368 # undef mode_is_dataM
371 mode_is_signed (ir_mode *mode)
379 mode_is_float (ir_mode *mode)
383 return (get_mode_sort(mode) == float_number);
387 mode_is_int (ir_mode *mode)
391 return (get_mode_sort(mode) == int_number);
395 mode_is_num (ir_mode *mode)
399 return (mode_is_int(mode) || mode_is_float(mode));
403 mode_is_data (ir_mode *mode)
407 return (mode_is_num(mode) || get_mode_sort(mode) == character || get_mode_sort(mode) == reference);
411 mode_is_datab (ir_mode *mode)
415 return (mode_is_data(mode) || get_mode_sort(mode) == internal_boolean);
419 mode_is_dataM (ir_mode *mode)
423 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
425 #ifdef MODE_ACCESS_DEFINES
426 # define mode_is_signed(mode) (mode)->sign
427 # define mode_is_float(mode) ((mode)->sort == float_number)
428 # define mode_is_int(mode) ((mode)->sort == int_number)
429 # define mode_is_num(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number))
430 # define mode_is_data(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference))
431 # define mode_is_datab(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->sort == internal_boolean))
432 # define mode_is_dataM(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->code == irm_M))
434 /* Returns true if sm can be converted to lm without loss. */
436 smaller_mode(ir_mode *sm, ir_mode *lm)
442 if (sm == lm) return 1;
444 switch(get_mode_sort(sm))
447 switch(get_mode_sort(lm))
450 /* integers are convertable if
451 * - both have the same sign and lm is the larger one
452 * - lm is the signed one and is at least two bits larger
453 * (one for the sign, one for the highest bit of sm)
455 if (mode_is_signed(sm))
457 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
460 else if (mode_is_signed(lm))
462 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
465 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
472 /* int to float works if the float is large enough */
481 /* XXX currently only the three standard 32,64,80 bit floats
482 * are supported which can safely be converted */
483 if ( (get_mode_sort(lm) == float_number)
484 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
489 /* do exist machines out there with different pointer lenghts ?*/
500 /* ** initialization ** */
505 /* init flexible array */
506 modes = NEW_ARR_F(ir_mode, irm_max);
507 modes_min = NEW_ARR_F(tarval*, irm_max);
508 modes_max = NEW_ARR_F(tarval*, irm_max);
509 modes_null = NEW_ARR_F(tarval*, irm_max);
510 modes_one = NEW_ARR_F(tarval*, irm_max);
512 /* initialize predefined modes */
514 mode_BB = &modes[irm_BB];
515 mode_BB->name = id_from_str("BB", 2);
516 mode_BB->code = irm_BB;
517 mode_BB->sort = auxiliary;
519 mode_BB->tv_priv = NULL;
522 mode_X = &modes[irm_X];
523 mode_X->name = id_from_str("X", 1);
524 mode_X->code = irm_X;
525 mode_X->sort = auxiliary;
527 mode_X->tv_priv = NULL;
530 mode_M = &modes[irm_M];
531 mode_M->name = id_from_str("M", 1);
532 mode_M->code = irm_M;
533 mode_M->sort = auxiliary;
535 mode_M->tv_priv = NULL;
538 mode_T = &modes[irm_T];
539 mode_T->name = id_from_str("T", 1);
540 mode_T->code = irm_T;
542 mode_T->tv_priv = NULL;
545 mode_b = &modes[irm_b];
546 mode_b->name = id_from_str("b", 1);
547 mode_b->code = irm_b;
548 mode_b->sort = internal_boolean;
550 mode_b->tv_priv = NULL;
553 mode_F = &modes[irm_F];
554 mode_F->name = id_from_str("F", 1);
555 mode_F->code = irm_F;
556 mode_F->sort = float_number;
560 mode_F->tv_priv = NULL;
562 set_mode_values(mode_F);
565 mode_D = &modes[irm_D];
566 mode_D->name = id_from_str("D", 1);
567 mode_D->code = irm_D;
568 mode_D->sort = float_number;
572 mode_D->tv_priv = NULL;
574 set_mode_values(mode_D);
577 mode_E = &modes[irm_E];
578 mode_E->name = id_from_str("E", 1);
579 mode_E->code = irm_E;
580 mode_E->sort = float_number;
584 mode_E->tv_priv = NULL;
586 set_mode_values(mode_E);
589 mode_Bs = &modes[irm_Bs];
590 mode_Bs->name = id_from_str("Bs", 2);
591 mode_Bs->code = irm_Bs;
592 mode_Bs->sort = int_number;
596 mode_Bs->tv_priv = NULL;
598 set_mode_values(mode_Bs);
601 mode_Bu = &modes[irm_Bu];
602 mode_Bu->name = id_from_str("Bu", 2);
603 mode_Bu->code = irm_Bu;
604 mode_Bu->sort = int_number;
608 mode_Bu->tv_priv = NULL;
610 set_mode_values(mode_Bu);
612 /* signed short integer */
613 mode_Hs = &modes[irm_Hs];
614 mode_Hs->name = id_from_str("Hs", 2);
615 mode_Hs->code = irm_Hs;
616 mode_Hs->sort = int_number;
620 mode_Hs->tv_priv = NULL;
622 set_mode_values(mode_Hs);
624 /* unsigned short integer */
625 mode_Hu = &modes[irm_Hu];
626 mode_Hu->name = id_from_str("Hu", 2);
627 mode_Hu->code = irm_Hu;
628 mode_Hu->sort = int_number;
632 mode_Hu->tv_priv = NULL;
634 set_mode_values(mode_Hu);
637 mode_Is = &modes[irm_Is];
638 mode_Is->name = id_from_str("Is", 2);
639 mode_Is->code = irm_Is;
640 mode_Is->sort = int_number;
644 mode_Is->tv_priv = NULL;
646 set_mode_values(mode_Is);
648 /* unsigned integer */
649 mode_Iu = &modes[irm_Iu];
650 mode_Iu->name = id_from_str("Iu", 2);
651 mode_Iu->code = irm_Iu;
652 mode_Iu->sort = int_number;
656 mode_Iu->tv_priv = NULL;
658 set_mode_values(mode_Iu);
660 /* signed long integer */
661 mode_Ls = &modes[irm_Ls];
662 mode_Ls->name = id_from_str("Ls", 2);
663 mode_Ls->code = irm_Ls;
664 mode_Ls->sort = int_number;
668 mode_Ls->tv_priv = NULL;
670 set_mode_values(mode_Ls);
672 /* unsigned long integer */
673 mode_Lu = &modes[irm_Lu];
674 mode_Lu->name = id_from_str("Lu", 2);
675 mode_Lu->code = irm_Lu;
676 mode_Lu->sort = int_number;
680 mode_Lu->tv_priv = NULL;
682 set_mode_values(mode_Lu);
685 mode_C = &modes[irm_C];
686 mode_C->name = id_from_str("C", 1);
687 mode_C->code = irm_C;
688 mode_C->sort = character;
692 mode_C->tv_priv = NULL;
694 set_mode_values(mode_C);
696 /* Unicode character */
697 mode_U = &modes[irm_U];
698 mode_U->name = id_from_str("U", 1);
699 mode_U->code = irm_U;
700 mode_U->sort = character;
704 mode_U->tv_priv = NULL;
706 set_mode_values(mode_U);
709 mode_P = &modes[irm_P];
710 mode_P->name = id_from_str("P", 1);
711 mode_P->code = irm_P;
712 mode_P->sort = reference;
716 mode_P->tv_priv = NULL;