1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer
14 # include "irmode_t.h"
23 # define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
25 # define ANNOUNCE() ((void)0)
32 static long long count = 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 */
49 /* compare modes that don't need to have their code field
51 static int modes_are_equal(ir_mode *m, ir_mode *n)
54 if ( (m->sort == n->sort) && (m->size == n->size) &&
55 (m->align == n->align) && (m->sign == n->sign) &&
56 (m->name == n->name) )
62 /* searches the modes array for the given mode and returns
63 * a pointer on an equal mode already in the array, NULL if
65 static ir_mode *find_mode(ir_mode *m)
69 for (i = 0; i < num_modes; i++)
71 if (modes_are_equal(m, &modes[i])) return &modes[i];
77 /* sets special values of modes */
78 static void set_mode_values(ir_mode* mode)
80 modes_min[get_mode_modecode(mode)] = get_tarval_min(mode);
81 modes_max[get_mode_modecode(mode)] = get_tarval_max(mode);
82 modes_null[get_mode_modecode(mode)] = get_tarval_null(mode);
83 modes_one[get_mode_modecode(mode)] = get_tarval_one(mode);
86 * globals defined in irmode.h
89 /** Predefined modes **/
91 /* FIRM internal modes: */
97 /* predefined numerical modes: */
98 ir_mode *mode_F; /* float */
99 ir_mode *mode_D; /* double */
100 ir_mode *mode_E; /* long double */
102 ir_mode *mode_Bs; /* integral values, signed and unsigned */
103 ir_mode *mode_Bu; /* 8 bit */
104 ir_mode *mode_Hs; /* 16 bit */
106 ir_mode *mode_Is; /* 32 bit */
108 ir_mode *mode_Ls; /* 64 bit */
117 * functions defined in irmode.h
120 /* JNI access functions */
121 INLINE ir_mode *get_modeT() { ANNOUNCE(); return mode_T; }
122 INLINE ir_mode *get_modeF() { ANNOUNCE(); return mode_F; }
123 INLINE ir_mode *get_modeD() { ANNOUNCE(); return mode_D; }
124 INLINE ir_mode *get_modeE() { ANNOUNCE(); return mode_E; }
125 INLINE ir_mode *get_modeBs() { ANNOUNCE(); return mode_Bs; }
126 INLINE ir_mode *get_modeBu() { ANNOUNCE(); return mode_Bu; }
127 INLINE ir_mode *get_modeHs() { ANNOUNCE(); return mode_Hs; }
128 INLINE ir_mode *get_modeHu() { ANNOUNCE(); return mode_Hu; }
129 INLINE ir_mode *get_modeIs() { ANNOUNCE(); return mode_Is; }
130 INLINE ir_mode *get_modeIu() { ANNOUNCE(); return mode_Iu; }
131 INLINE ir_mode *get_modeLs() { ANNOUNCE(); return mode_Ls; }
132 INLINE ir_mode *get_modeLu() { ANNOUNCE(); return mode_Lu; }
133 INLINE ir_mode *get_modeC() { ANNOUNCE(); return mode_C; }
134 INLINE ir_mode *get_modeU() { ANNOUNCE(); return mode_U; }
135 INLINE ir_mode *get_modeb() { ANNOUNCE(); return mode_b; }
136 INLINE ir_mode *get_modeP() { ANNOUNCE(); return mode_P; }
137 INLINE ir_mode *get_modeX() { ANNOUNCE(); return mode_X; }
138 INLINE ir_mode *get_modeM() { ANNOUNCE(); return mode_M; }
139 INLINE ir_mode *get_modeBB() { ANNOUNCE(); return mode_BB; }
141 /* ** Constructor ** */
143 register_mode(ir_mode* new_mode)
150 /* first check if there already is a matching mode */
151 mode = find_mode(new_mode);
152 if (mode) return mode;
155 switch (new_mode->sort)
158 case internal_boolean:
159 assert(0 && "internal modes cannot be user defined");
163 assert(0 && "not yet implemented");
175 /* copy mode struct to modes array */
176 ARR_EXTEND(ir_mode, modes, 1);
177 ARR_EXTEND(tarval*, modes_min, 1);
178 ARR_EXTEND(tarval*, modes_max, 1);
179 ARR_EXTEND(tarval*, modes_null, 1);
180 ARR_EXTEND(tarval*, modes_one, 1);
181 mode = &modes[num_modes];
183 memcpy(mode, new_mode, sizeof(ir_mode));
184 mode->code = num_modes;
187 set_mode_values(mode);
192 /* Functions for the direct access to all attributes od a ir_mode */
193 #ifdef MODE_ACCESS_DEFINES
194 # undef get_mode_modecode
195 # undef get_mode_ident
196 # undef get_mode_name
197 # undef get_mode_sort
198 # undef get_mode_size
199 # undef get_mode_align
202 get_mode_modecode(ir_mode *mode)
209 get_mode_ident(ir_mode *mode)
216 get_mode_name(ir_mode *mode)
219 return id_to_str(mode->name);
223 get_mode_sort(ir_mode* mode)
230 get_mode_size(ir_mode *mode)
237 get_mode_align (ir_mode *mode)
242 #ifdef MODE_ACCESS_DEFINES
243 # define get_mode_modecode(mode) (mode)->code
244 # define get_mode_ident(mode) (mode)->name
245 # define get_mode_name(mode) id_to_str((mode)->name)
246 # define get_mode_sort(mode) (mode)->sort
247 # define get_mode_size(mode) (mode)->size
248 # define get_mode_align(mode) (mode)->align
251 get_mode_sign (ir_mode *mode)
258 get_mode_min (ir_mode *mode)
262 assert(get_mode_modecode(mode) < num_modes);
263 assert(mode_is_data(mode));
265 return modes_min[get_mode_modecode(mode)];
269 get_mode_max (ir_mode *mode)
273 assert(get_mode_modecode(mode) < num_modes);
274 assert(mode_is_data(mode));
276 return modes_max[get_mode_modecode(mode)];
280 get_mode_null (ir_mode *mode)
284 assert(get_mode_modecode(mode) < num_modes);
285 assert(mode_is_data(mode));
287 return modes_null[get_mode_modecode(mode)];
291 get_mode_one (ir_mode *mode)
295 assert(get_mode_modecode(mode) < num_modes);
296 assert(mode_is_data(mode));
298 return modes_one[get_mode_modecode(mode)];
302 get_mode_infinite(ir_mode *mode)
306 assert(get_mode_modecode(mode) < num_modes);
307 assert(mode_is_float(mode));
309 return get_tarval_inf(mode);
313 get_mode_NAN(ir_mode *mode)
317 assert(get_mode_modecode(mode) < num_modes);
318 assert(mode_is_float(mode));
320 return get_tarval_nan(mode);
323 /* Functions to check, whether a modecode is signed, float, int, num, data,
324 datab or dataM. For more exact definitions read the corresponding pages
325 in the firm documentation or the followingenumeration
327 The set of "float" is defined as:
328 ---------------------------------
329 float = {irm_F, irm_D, irm_E}
331 The set of "int" is defined as:
332 -------------------------------
333 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
335 The set of "num" is defined as:
336 -------------------------------
337 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
338 irm_Is, irm_Iu, irm_Ls, irm_Lu}
341 The set of "data" is defined as:
342 -------------------------------
343 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
344 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
345 = {num || irm_C || irm_U || irm_P}
347 The set of "datab" is defined as:
348 ---------------------------------
349 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
350 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
353 The set of "dataM" is defined as:
354 ---------------------------------
355 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
356 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
360 #ifdef MODE_ACCESS_DEFINES
361 # undef mode_is_signed
362 # undef mode_is_float
366 # undef mode_is_datab
367 # undef mode_is_dataM
370 mode_is_signed (ir_mode *mode)
378 mode_is_float (ir_mode *mode)
382 return (get_mode_sort(mode) == float_number);
386 mode_is_int (ir_mode *mode)
390 return (get_mode_sort(mode) == int_number);
394 mode_is_num (ir_mode *mode)
398 return (mode_is_int(mode) || mode_is_float(mode));
402 mode_is_data (ir_mode *mode)
406 return (mode_is_num(mode) || get_mode_sort(mode) == character || get_mode_sort(mode) == reference);
410 mode_is_datab (ir_mode *mode)
414 return (mode_is_data(mode) || get_mode_sort(mode) == internal_boolean);
418 mode_is_dataM (ir_mode *mode)
422 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
424 #ifdef MODE_ACCESS_DEFINES
425 # define mode_is_signed(mode) (mode)->sign
426 # define mode_is_float(mode) ((mode)->sort == float_number)
427 # define mode_is_int(mode) ((mode)->sort == int_number)
428 # define mode_is_num(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number))
429 # define mode_is_data(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference))
430 # define mode_is_datab(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->sort == internal_boolean))
431 # define mode_is_dataM(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->code == irm_M))
433 /* Returns true if sm can be converted to lm without loss. */
435 smaller_mode(ir_mode *sm, ir_mode *lm)
441 if (sm == lm) return 1;
443 switch(get_mode_sort(sm))
446 switch(get_mode_sort(lm))
449 /* integers are convertable if
450 * - both have the same sign and lm is the larger one
451 * - lm is the signed one and is at least two bits larger
452 * (one for the sign, one for the highest bit of sm)
454 if (mode_is_signed(sm))
456 if ( mode_is_signed(lm) && (get_mode_size(lm) > get_mode_size(sm)) )
459 else if (mode_is_signed(lm))
461 if (get_mode_size(lm) > get_mode_size(sm) + 1)
464 else if (get_mode_size(lm) > get_mode_size(sm))
471 /* int to float works if the float is large enough */
480 /* XXX currently only the three standard 32,64,80 bit floats
481 * are supported which can safely be converted */
482 if ( (get_mode_sort(lm) == float_number)
483 && (get_mode_size(lm) > get_mode_size(sm)) )
488 /* do exist machines out there with different pointer lenghts ?*/
499 /** ** initialization ** **/
504 /* init flexible array */
505 modes = NEW_ARR_F(ir_mode, irm_max);
506 modes_min = NEW_ARR_F(tarval*, irm_max);
507 modes_max = NEW_ARR_F(tarval*, irm_max);
508 modes_null = NEW_ARR_F(tarval*, irm_max);
509 modes_one = NEW_ARR_F(tarval*, irm_max);
511 /* initialize predefined modes */
513 mode_BB = &modes[irm_BB];
514 mode_BB->name = id_from_str("BB", 2);
515 mode_BB->code = irm_BB;
516 mode_BB->sort = auxiliary;
520 mode_X = &modes[irm_X];
521 mode_X->name = id_from_str("X", 1);
522 mode_X->code = irm_X;
523 mode_X->sort = auxiliary;
527 mode_M = &modes[irm_M];
528 mode_M->name = id_from_str("M", 1);
529 mode_M->code = irm_M;
530 mode_M->sort = auxiliary;
534 mode_T = &modes[irm_T];
535 mode_T->name = id_from_str("T", 1);
536 mode_T->code = irm_T;
540 mode_b = &modes[irm_b];
541 mode_b->name = id_from_str("b", 1);
542 mode_b->code = irm_b;
543 mode_b->sort = internal_boolean;
547 mode_F = &modes[irm_F];
548 mode_F->name = id_from_str("F", 1);
549 mode_F->code = irm_F;
550 mode_F->sort = float_number;
555 set_mode_values(mode_F);
558 mode_D = &modes[irm_D];
559 mode_D->name = id_from_str("D", 1);
560 mode_D->code = irm_D;
561 mode_D->sort = float_number;
566 set_mode_values(mode_D);
569 mode_E = &modes[irm_E];
570 mode_E->name = id_from_str("E", 1);
571 mode_E->code = irm_E;
572 mode_E->sort = float_number;
577 set_mode_values(mode_E);
580 mode_Bs = &modes[irm_Bs];
581 mode_Bs->name = id_from_str("Bs", 2);
582 mode_Bs->code = irm_Bs;
583 mode_Bs->sort = int_number;
588 set_mode_values(mode_Bs);
591 mode_Bu = &modes[irm_Bu];
592 mode_Bu->name = id_from_str("Bu", 2);
593 mode_Bu->code = irm_Bu;
594 mode_Bu->sort = int_number;
599 set_mode_values(mode_Bu);
601 /* signed short integer */
602 mode_Hs = &modes[irm_Hs];
603 mode_Hs->name = id_from_str("Hs", 2);
604 mode_Hs->code = irm_Hs;
605 mode_Hs->sort = int_number;
610 set_mode_values(mode_Hs);
612 /* unsigned short integer */
613 mode_Hu = &modes[irm_Hu];
614 mode_Hu->name = id_from_str("Hu", 2);
615 mode_Hu->code = irm_Hu;
616 mode_Hu->sort = int_number;
621 set_mode_values(mode_Hu);
624 mode_Is = &modes[irm_Is];
625 mode_Is->name = id_from_str("Is", 2);
626 mode_Is->code = irm_Is;
627 mode_Is->sort = int_number;
632 set_mode_values(mode_Is);
634 /* unsigned integer */
635 mode_Iu = &modes[irm_Iu];
636 mode_Iu->name = id_from_str("Iu", 2);
637 mode_Iu->code = irm_Iu;
638 mode_Iu->sort = int_number;
643 set_mode_values(mode_Iu);
645 /* signed long integer */
646 mode_Ls = &modes[irm_Ls];
647 mode_Ls->name = id_from_str("Ls", 2);
648 mode_Ls->code = irm_Ls;
649 mode_Ls->sort = int_number;
654 set_mode_values(mode_Ls);
656 /* unsigned long integer */
657 mode_Lu = &modes[irm_Lu];
658 mode_Lu->name = id_from_str("Lu", 2);
659 mode_Lu->code = irm_Lu;
660 mode_Lu->sort = int_number;
665 set_mode_values(mode_Lu);
668 mode_C = &modes[irm_C];
669 mode_C->name = id_from_str("C", 1);
670 mode_C->code = irm_C;
671 mode_C->sort = character;
676 set_mode_values(mode_C);
678 /* Unicode character */
679 mode_U = &modes[irm_U];
680 mode_U->name = id_from_str("U", 1);
681 mode_U->code = irm_U;
682 mode_U->sort = character;
687 set_mode_values(mode_U);
690 mode_P = &modes[irm_P];
691 mode_P->name = id_from_str("P", 1);
692 mode_P->code = irm_P;
693 mode_P->sort = reference;