1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
2 ** All rights reserved.
4 ** Authors: Martin Trapp, Christian Schaefer
14 # include "irmode_t.h"
24 static long long count = 0;
25 # define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
27 # define ANNOUNCE() ((void)0)
35 /** dynamic array to hold all modes */
36 static struct obstack modes;
38 /** number of defined modes */
46 * Compare modes that don't need to have their code field
49 * TODO: Add other fields
51 inline static int modes_are_equal(const ir_mode *m, const ir_mode *n)
54 if(!bcmp( m + offsetof(ir_mode,sort) , n + offsetof(ir_mode,sort), offsetof(ir_mode,min)-offsetof(ir_mode,min))) return 1;
60 * searches the modes obstack for the given mode and returns
61 * a pointer on an equal mode already in the array, NULL if
64 static ir_mode *find_mode(const ir_mode *m)
67 struct _obstack_chunk *p;
70 for( n=(ir_mode*) p->contents; (char *)n < modes.next_free; n+=sizeof(ir_mode) )
72 if(modes_are_equal(n,m)) return n;
75 for (p = p->prev; p; p = p->prev)
77 for( n=(ir_mode*) p->contents; (char *)n < p->limit; n+=sizeof(ir_mode) )
79 if(modes_are_equal(n,m)) return n;
87 * sets special values of modes
89 static void set_mode_values(ir_mode* mode)
91 mode->min = get_tarval_min(mode);
92 mode->max= get_tarval_max(mode);
93 mode->null= get_tarval_null(mode);
94 mode->one= get_tarval_one(mode);
97 * globals defined in irmode.h
100 /* --- Predefined modes --- */
102 /* FIRM internal modes: */
110 /* predefined numerical modes: */
111 ir_mode *mode_F; /* float */
112 ir_mode *mode_D; /* double */
113 ir_mode *mode_E; /* long double */
115 ir_mode *mode_Bs; /* integral values, signed and unsigned */
116 ir_mode *mode_Bu; /* 8 bit */
117 ir_mode *mode_Hs; /* 16 bit */
119 ir_mode *mode_Is; /* 32 bit */
121 ir_mode *mode_Ls; /* 64 bit */
130 * functions defined in irmode.h
133 /* JNI access functions */
134 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
135 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
136 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
137 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
138 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
139 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
140 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
141 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
142 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
143 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
144 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
145 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
146 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
147 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
148 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
149 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
150 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
151 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
152 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
153 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
154 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
157 * Registers a new mode if not defined yet, else returns
158 * the "equivalent" one.
160 static ir_mode *register_mode(const ir_mode* new_mode)
162 ir_mode *mode = NULL;
169 /* copy mode struct to modes array */
170 mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
172 mode->kind = k_ir_mode;
173 if(num_modes>=irm_max) mode->code = num_modes;
176 if(mode->sort==irms_int_number || mode->sort==irms_float_number || mode->sort==irms_character) set_mode_values(mode);
182 * Creates a new mode.
184 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic )
193 case irms_control_flow:
195 case irms_internal_boolean:
196 assert(0 && "internal modes cannot be user defined");
200 case irms_float_number:
201 assert(0 && "not yet implemented");
205 case irms_int_number:
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.arithmetic = arithmetic;
216 mode_tmpl.tv_priv = NULL;
218 /* first check if there already is a matching mode */
219 mode = find_mode(&mode_tmpl);
226 return register_mode(&mode_tmpl);
230 /* Functions for the direct access to all attributes od a ir_mode */
232 get_mode_modecode(const ir_mode *mode)
239 get_mode_ident(const ir_mode *mode)
246 get_mode_name(const ir_mode *mode)
249 return id_to_str(mode->name);
253 get_mode_sort(const ir_mode* mode)
260 get_mode_size_bits(const ir_mode *mode)
266 int get_mode_size_bytes(const ir_mode *mode) {
267 int size = get_mode_size_bits(mode);
269 if ((size & 7) != 0) return -1;
274 get_mode_align (const ir_mode *mode)
281 get_mode_sign (const ir_mode *mode)
287 int get_mode_arithmetic (const ir_mode *mode)
290 return mode->arithmetic;
293 void* get_mode_link(const ir_mode *mode)
299 void set_mode_link(ir_mode *mode, void *l)
306 get_mode_min (ir_mode *mode)
310 assert(get_mode_modecode(mode) < num_modes);
311 assert(mode_is_data(mode));
317 get_mode_max (ir_mode *mode)
321 assert(get_mode_modecode(mode) < num_modes);
322 assert(mode_is_data(mode));
328 get_mode_null (ir_mode *mode)
332 assert(get_mode_modecode(mode) < num_modes);
333 assert(mode_is_data(mode));
339 get_mode_one (ir_mode *mode)
343 assert(get_mode_modecode(mode) < num_modes);
344 assert(mode_is_data(mode));
350 get_mode_infinite(ir_mode *mode)
354 assert(get_mode_modecode(mode) < num_modes);
355 assert(mode_is_float(mode));
357 return get_tarval_inf(mode);
361 get_mode_NAN(ir_mode *mode)
365 assert(get_mode_modecode(mode) < num_modes);
366 assert(mode_is_float(mode));
368 return get_tarval_nan(mode);
372 is_mode (void *thing) {
374 if (get_kind(thing) == k_ir_mode)
380 /* Functions to check, whether a modecode is signed, float, int, num, data,
381 datab or dataM. For more exact definitions read the corresponding pages
382 in the firm documentation or the followingenumeration
384 The set of "float" is defined as:
385 ---------------------------------
386 float = {irm_F, irm_D, irm_E}
388 The set of "int" is defined as:
389 -------------------------------
390 int = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
392 The set of "num" is defined as:
393 -------------------------------
394 num = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
395 irm_Is, irm_Iu, irm_Ls, irm_Lu}
398 The set of "data" is defined as:
399 -------------------------------
400 data = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
401 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
402 = {num || irm_C || irm_U || irm_P}
404 The set of "datab" is defined as:
405 ---------------------------------
406 datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
407 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
410 The set of "dataM" is defined as:
411 ---------------------------------
412 dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
413 irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
417 #ifdef MODE_ACCESS_DEFINES
418 # undef mode_is_signed
419 # undef mode_is_float
423 # undef mode_is_datab
424 # undef mode_is_dataM
427 mode_is_signed (const ir_mode *mode)
435 mode_is_float (const ir_mode *mode)
439 return (get_mode_sort(mode) == irms_float_number);
443 mode_is_int (const ir_mode *mode)
447 return (get_mode_sort(mode) == irms_int_number);
450 int mode_is_character (const ir_mode *mode)
454 return (get_mode_sort(mode) == irms_character);
457 int mode_is_reference (const ir_mode *mode)
461 return (get_mode_sort(mode) == irms_reference);
465 mode_is_num (const ir_mode *mode)
469 return (mode_is_int(mode) || mode_is_float(mode));
473 mode_is_data (const ir_mode *mode)
477 return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
481 mode_is_datab (const ir_mode *mode)
485 return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
489 mode_is_dataM (const ir_mode *mode)
493 return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
495 #ifdef MODE_ACCESS_DEFINES
496 # define mode_is_signed(mode) (mode)->sign
497 # define mode_is_float(mode) ((mode)->sort == irms_float_number)
498 # define mode_is_int(mode) ((mode)->sort == irms_int_number)
499 # define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
500 # define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
501 # 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))
502 # 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))
504 /* Returns true if sm can be converted to lm without loss. */
506 smaller_mode(const ir_mode *sm, const ir_mode *lm)
512 if (sm == lm) return 1;
514 switch(get_mode_sort(sm))
516 case irms_int_number:
517 switch(get_mode_sort(lm))
519 case irms_int_number:
520 /* integers are convertable if
521 * - both have the same sign and lm is the larger one
522 * - lm is the signed one and is at least two bits larger
523 * (one for the sign, one for the highest bit of sm)
525 if (mode_is_signed(sm))
527 if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
530 else if (mode_is_signed(lm))
532 if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
535 else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
541 case irms_float_number:
542 /* int to float works if the float is large enough */
550 case irms_float_number:
551 /* XXX currently only the three standard 32,64,80 bit floats
552 * are supported which can safely be converted */
553 if ( (get_mode_sort(lm) == irms_float_number)
554 && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
559 /* do exist machines out there with different pointer lenghts ?*/
570 /* ** initialization ** */
576 /* init flexible array */
578 obstack_init(&modes);
581 /* initialize predefined modes */
584 newmode.arithmetic = irma_none;
588 newmode.tv_priv = NULL;
590 /* Control Flow Modes*/
591 newmode.sort = irms_control_flow;
594 newmode.name = id_from_str("BB", 2);
595 newmode.code = irm_BB;
597 mode_BB = register_mode(&newmode);
600 newmode.name = id_from_str("X", 1);
601 newmode.code = irm_X;
603 mode_X = register_mode(&newmode);
606 newmode.sort = irms_memory;
609 newmode.name = id_from_str("M", 1);
610 newmode.code = irm_M;
612 mode_M = register_mode(&newmode);
614 /* Auxiliary Modes */
615 newmode.sort = irms_auxiliary,
618 newmode.name = id_from_str("T", 1);
619 newmode.code = irm_T;
621 mode_T = register_mode(&newmode);
624 newmode.name = id_from_str("ANY", 3);
625 newmode.code = irm_ANY;
627 mode_ANY = register_mode(&newmode);
630 newmode.name = id_from_str("BAD", 3);
631 newmode.code = irm_BAD;
633 mode_BAD = register_mode(&newmode);
635 /* Internal Boolean Modes */
636 newmode.sort = irms_internal_boolean;
639 newmode.name = id_from_str("b", 1);
640 newmode.code = irm_b;
642 mode_b = register_mode(&newmode);
646 /* Float Number Modes */
647 newmode.sort = irms_float_number;
648 newmode.arithmetic = irma_ieee754;
651 newmode.name = id_from_str("F", 1);
652 newmode.code = irm_F;
657 mode_F = register_mode(&newmode);
660 newmode.name = id_from_str("D", 1);
661 newmode.code = irm_D;
666 mode_D = register_mode(&newmode);
669 newmode.name = id_from_str("E", 1);
670 newmode.code = irm_E;
675 mode_E = register_mode(&newmode);
677 /* Integer Number Modes */
678 newmode.sort = irms_int_number;
679 newmode.arithmetic = irma_twos_complement;
682 newmode.name = id_from_str("Bs", 2);
683 newmode.code = irm_Bs;
688 mode_Bs = register_mode(&newmode);
691 newmode.name = id_from_str("Bu", 2);
692 newmode.code = irm_Bu;
693 newmode.arithmetic = irma_twos_complement;
698 mode_Bu = register_mode(&newmode);
700 /* signed short integer */
701 newmode.name = id_from_str("Hs", 2);
702 newmode.code = irm_Hs;
707 mode_Hs = register_mode(&newmode);
709 /* unsigned short integer */
710 newmode.name = id_from_str("Hu", 2);
711 newmode.code = irm_Hu;
716 mode_Hu = register_mode(&newmode);
719 newmode.name = id_from_str("Is", 2);
720 newmode.code = irm_Is;
725 mode_Is = register_mode(&newmode);
727 /* unsigned integer */
728 newmode.name = id_from_str("Iu", 2);
729 newmode.code = irm_Iu;
734 mode_Iu = register_mode(&newmode);
736 /* signed long integer */
737 newmode.name = id_from_str("Ls", 2);
738 newmode.code = irm_Ls;
743 mode_Ls = register_mode(&newmode);
745 /* unsigned long integer */
746 newmode.name = id_from_str("Lu", 2);
747 newmode.code = irm_Lu;
752 mode_Lu = register_mode(&newmode);
754 /* Integer Number Modes */
755 newmode.sort = irms_character;
756 newmode.arithmetic = irma_none;
759 newmode.name = id_from_str("C", 1);
760 newmode.code = irm_C;
765 mode_C = register_mode(&newmode);
767 /* Unicode character */
768 newmode.name = id_from_str("U", 1);
769 newmode.code = irm_U;
774 mode_U = register_mode(&newmode);
776 /* Reference Modes */
777 newmode.sort = irms_reference;
778 newmode.arithmetic = irma_twos_complement;
781 newmode.name = id_from_str("P", 1);
782 newmode.code = irm_P;
787 mode_P = register_mode(&newmode);