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: */
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(void) { ANNOUNCE(); return mode_T; }
129 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
130 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
131 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
132 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
133 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
134 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
135 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
136 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
137 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
138 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
139 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
140 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
141 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
142 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
143 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
144 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
145 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
146 INLINE ir_mode *get_modeBB(void) { 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)
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(const ir_mode *mode)
230 get_mode_ident(const ir_mode *mode)
237 get_mode_name(const ir_mode *mode)
240 return id_to_str(mode->name);
244 get_mode_sort(const ir_mode* mode)
251 get_mode_size_bits(const ir_mode *mode)
257 int get_mode_size_bytes(const ir_mode *mode) {
259 int size = get_mode_size_bits(mode);
260 if ((size & 7) != 0) return -1;
265 get_mode_align (const ir_mode *mode)
272 get_mode_sign (const 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 (const ir_mode *mode)
399 mode_is_float (const ir_mode *mode)
403 return (get_mode_sort(mode) == irms_float_number);
407 mode_is_int (const ir_mode *mode)
411 return (get_mode_sort(mode) == irms_int_number);
414 int mode_is_character (const ir_mode *mode)
418 return (get_mode_sort(mode) == irms_character);
421 int mode_is_reference (const ir_mode *mode)
425 return (get_mode_sort(mode) == irms_reference);
429 mode_is_num (const ir_mode *mode)
433 return (mode_is_int(mode) || mode_is_float(mode));
437 mode_is_data (const ir_mode *mode)
441 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
445 mode_is_datab (const ir_mode *mode)
449 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
453 mode_is_dataM (const ir_mode *mode)
457 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
459 #ifdef MODE_ACCESS_DEFINES
460 # define mode_is_signed(mode) (mode)->sign
461 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
462 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
463 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
464 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
465 # 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))
466 # 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))
468 /* Returns true if sm can be converted to lm without loss. */
470 smaller_mode(const ir_mode *sm, const ir_mode *lm)
476 if (sm == lm) return 1;
478 switch(get_mode_sort(sm))
480 case irms_int_number:
481 switch(get_mode_sort(lm))
483 case irms_int_number:
484 /* integers are convertable if
485 * - both have the same sign and lm is the larger one
486 * - lm is the signed one and is at least two bits larger
487 * (one for the sign, one for the highest bit of sm)
489 if (mode_is_signed(sm))
491 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
494 else if (mode_is_signed(lm))
496 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
499 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
505 case irms_float_number:
506 /* int to float works if the float is large enough */
514 case irms_float_number:
515 /* XXX currently only the three standard 32,64,80 bit floats
516 * are supported which can safely be converted */
517 if ( (get_mode_sort(lm) == irms_float_number)
518 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
523 /* do exist machines out there with different pointer lenghts ?*/
534 /* ** initialization ** */
539 /* init flexible array */
540 modes = NEW_ARR_F(ir_mode, irm_max);
541 modes_min = NEW_ARR_F(tarval*, irm_max);
542 modes_max = NEW_ARR_F(tarval*, irm_max);
543 modes_null = NEW_ARR_F(tarval*, irm_max);
544 modes_one = NEW_ARR_F(tarval*, irm_max);
546 /* initialize predefined modes */
548 mode_BB = &modes[irm_BB];
549 mode_BB->name = id_from_str("BB", 2);
550 mode_BB->code = irm_BB;
551 mode_BB->sort = irms_auxiliary;
555 mode_BB->tv_priv = NULL;
558 mode_X = &modes[irm_X];
559 mode_X->name = id_from_str("X", 1);
560 mode_X->code = irm_X;
561 mode_X->sort = irms_auxiliary;
565 mode_X->tv_priv = NULL;
568 mode_M = &modes[irm_M];
569 mode_M->name = id_from_str("M", 1);
570 mode_M->code = irm_M;
571 mode_M->sort = irms_auxiliary;
575 mode_M->tv_priv = NULL;
578 mode_T = &modes[irm_T];
579 mode_T->name = id_from_str("T", 1);
580 mode_T->code = irm_T;
581 mode_T->sort = irms_auxiliary,
585 mode_T->tv_priv = NULL;
588 mode_b = &modes[irm_b];
589 mode_b->name = id_from_str("b", 1);
590 mode_b->code = irm_b;
591 mode_b->sort = irms_internal_boolean;
595 mode_b->tv_priv = NULL;
598 mode_F = &modes[irm_F];
599 mode_F->name = id_from_str("F", 1);
600 mode_F->code = irm_F;
601 mode_F->sort = irms_float_number;
605 mode_F->tv_priv = NULL;
607 set_mode_values(mode_F);
610 mode_D = &modes[irm_D];
611 mode_D->name = id_from_str("D", 1);
612 mode_D->code = irm_D;
613 mode_D->sort = irms_float_number;
617 mode_D->tv_priv = NULL;
619 set_mode_values(mode_D);
622 mode_E = &modes[irm_E];
623 mode_E->name = id_from_str("E", 1);
624 mode_E->code = irm_E;
625 mode_E->sort = irms_float_number;
629 mode_E->tv_priv = NULL;
631 set_mode_values(mode_E);
634 mode_Bs = &modes[irm_Bs];
635 mode_Bs->name = id_from_str("Bs", 2);
636 mode_Bs->code = irm_Bs;
637 mode_Bs->sort = irms_int_number;
641 mode_Bs->tv_priv = NULL;
643 set_mode_values(mode_Bs);
646 mode_Bu = &modes[irm_Bu];
647 mode_Bu->name = id_from_str("Bu", 2);
648 mode_Bu->code = irm_Bu;
649 mode_Bu->sort = irms_int_number;
653 mode_Bu->tv_priv = NULL;
655 set_mode_values(mode_Bu);
657 /* signed short integer */
658 mode_Hs = &modes[irm_Hs];
659 mode_Hs->name = id_from_str("Hs", 2);
660 mode_Hs->code = irm_Hs;
661 mode_Hs->sort = irms_int_number;
665 mode_Hs->tv_priv = NULL;
667 set_mode_values(mode_Hs);
669 /* unsigned short integer */
670 mode_Hu = &modes[irm_Hu];
671 mode_Hu->name = id_from_str("Hu", 2);
672 mode_Hu->code = irm_Hu;
673 mode_Hu->sort = irms_int_number;
677 mode_Hu->tv_priv = NULL;
679 set_mode_values(mode_Hu);
682 mode_Is = &modes[irm_Is];
683 mode_Is->name = id_from_str("Is", 2);
684 mode_Is->code = irm_Is;
685 mode_Is->sort = irms_int_number;
689 mode_Is->tv_priv = NULL;
691 set_mode_values(mode_Is);
693 /* unsigned integer */
694 mode_Iu = &modes[irm_Iu];
695 mode_Iu->name = id_from_str("Iu", 2);
696 mode_Iu->code = irm_Iu;
697 mode_Iu->sort = irms_int_number;
701 mode_Iu->tv_priv = NULL;
703 set_mode_values(mode_Iu);
705 /* signed long integer */
706 mode_Ls = &modes[irm_Ls];
707 mode_Ls->name = id_from_str("Ls", 2);
708 mode_Ls->code = irm_Ls;
709 mode_Ls->sort = irms_int_number;
713 mode_Ls->tv_priv = NULL;
715 set_mode_values(mode_Ls);
717 /* unsigned long integer */
718 mode_Lu = &modes[irm_Lu];
719 mode_Lu->name = id_from_str("Lu", 2);
720 mode_Lu->code = irm_Lu;
721 mode_Lu->sort = irms_int_number;
725 mode_Lu->tv_priv = NULL;
727 set_mode_values(mode_Lu);
730 mode_C = &modes[irm_C];
731 mode_C->name = id_from_str("C", 1);
732 mode_C->code = irm_C;
733 mode_C->sort = irms_character;
737 mode_C->tv_priv = NULL;
739 set_mode_values(mode_C);
741 /* Unicode character */
742 mode_U = &modes[irm_U];
743 mode_U->name = id_from_str("U", 1);
744 mode_U->code = irm_U;
745 mode_U->sort = irms_character;
749 mode_U->tv_priv = NULL;
751 set_mode_values(mode_U);
754 mode_P = &modes[irm_P];
755 mode_P->name = id_from_str("P", 1);
756 mode_P->code = irm_P;
757 mode_P->sort = irms_reference;
761 mode_P->tv_priv = NULL;