nsz Git - libfirm/blob - ir/ir/irmode.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irmode.c
   4  * Purpose:     Data modes of operations.
   5  * Author:      Martin Trapp, Christian Schaefer
   6  * Modified by: Goetz Lindenmaier, Mathias Heil
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include <config.h>
  16 #endif
  17
  18 # include <stdlib.h>
  19 # include <stddef.h>
  20 # include <string.h>
  21 # include <stdbool.h>
  22
  23 # include "irmode_t.h"
  24 # include "ident.h"
  25 # include "tv.h"
  26 # include "obst.h"
  27
  28 #if 0
  29 static long long count = 0;
  30 #  define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
  31 #else
  32 #  define ANNOUNCE() ((void)0)
  33 #endif
  34
  35 /* * *
  36  * local values
  37  * * */
  38
  39
  40 /** dynamic array to hold all modes */
  41 static struct obstack modes;
  42
  43 /** number of defined modes */
  44 static int num_modes;
  45
  46 /* * *
  47  * local functions
  48  * * */
  49
  50 /**
  51  * Compare modes that don't need to have their code field
  52  * correctly set
  53  *
  54  * TODO: Add other fields
  55  **/
  56 INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n)
  57 {
  58   if (m == n) return 1;
  59   if (m->sort         == n->sort &&
  60       m->arithmetic   == n->arithmetic &&
  61       m->size         == n->size &&
  62       m->align        == n->align &&
  63       m->sign         == n->sign  &&
  64       m->modulo_shift == n->modulo_shift &&
  65       m->vector_elem  == n->vector_elem)
  66     return 1;
  67
  68   return 0;
  69 }
  70
  71 /*
  72  * calculates the next obstack address
  73  */
  74 static void *next_obstack_adr(struct obstack *o, void *p, size_t s)
  75 {
  76   PTR_INT_TYPE adr = __PTR_TO_INT((char *)p);
  77   int mask = obstack_alignment_mask(o);
  78
  79   adr += s + mask;
  80
  81   return __INT_TO_PTR(adr & ~mask);
  82 }
  83
  84 /**
  85  * searches the modes obstack for the given mode and returns
  86  * a pointer on an equal mode already in the array, NULL if
  87  * none found
  88  */
  89 static ir_mode *find_mode(const ir_mode *m)
  90 {
  91   ir_mode *n, *nn;
  92   struct _obstack_chunk *p;
  93
  94   p  = modes.chunk;
  95   n  = (ir_mode *)p->contents;
  96   nn = next_obstack_adr(&modes, n, sizeof(*n));
  97   for (; (char *)nn <= modes.next_free;) {
  98     assert(is_mode(n));
  99     if (modes_are_equal(n, m))
 100       return n;
 101
 102     n  = nn;
 103     nn = next_obstack_adr(&modes, n, sizeof(*n));
 104   }
 105
 106   for (p = p->prev; p; p = p->prev) {
 107     n  = (ir_mode *)p->contents;
 108     nn = next_obstack_adr(&modes, n, sizeof(*n));
 109     for (; (char *)nn < p->limit;) {
 110       assert(is_mode(n));
 111       if (modes_are_equal(n, m))
 112         return n;
 113
 114       n  = nn;
 115       nn = next_obstack_adr(&modes, n, sizeof(*n));
 116     }
 117   }
 118
 119   return NULL;
 120 }
 121
 122 /**
 123  * sets special values of modes
 124  */
 125 static void set_mode_values(ir_mode* mode)
 126 {
 127   switch (get_mode_sort(mode))
 128   {
 129     case irms_character:
 130     case irms_int_number:
 131     case irms_float_number:
 132       mode->min = get_tarval_min(mode);
 133       mode->max = get_tarval_max(mode);
 134       mode->null = get_tarval_null(mode);
 135       mode->one = get_tarval_one(mode);
 136       break;
 137
 138     case irms_internal_boolean:
 139       mode->min = tarval_b_false;
 140       mode->max = tarval_b_true;
 141       mode->null = tarval_b_false;
 142       mode->one = tarval_b_true;
 143       break;
 144
 145     case irms_reference:
 146       mode->min = tarval_bad;
 147       mode->max = tarval_bad;
 148       mode->null = (get_mode_modecode(mode) == irm_P) ? tarval_P_void : tarval_bad;
 149       mode->one = tarval_bad;
 150       break;
 151
 152     case irms_auxiliary:
 153     case irms_memory:
 154     case irms_control_flow:
 155       mode->min = tarval_bad;
 156       mode->max = tarval_bad;
 157       mode->null = tarval_bad;
 158       mode->one = tarval_bad;
 159       break;
 160   }
 161 }
 162
 163 /* * *
 164  * globals defined in irmode.h
 165  * * */
 166
 167 /* --- Predefined modes --- */
 168
 169 /* FIRM internal modes: */
 170 ir_mode *mode_T;
 171 ir_mode *mode_X;
 172 ir_mode *mode_M;
 173 ir_mode *mode_BB;
 174 ir_mode *mode_ANY;
 175 ir_mode *mode_BAD;
 176
 177 /* predefined numerical modes: */
 178 ir_mode *mode_F;    /* float */
 179 ir_mode *mode_D;    /* double */
 180 ir_mode *mode_E;    /* long double */
 181
 182 ir_mode *mode_Bs;   /* integral values, signed and unsigned */
 183 ir_mode *mode_Bu;   /* 8 bit */
 184 ir_mode *mode_Hs;   /* 16 bit */
 185 ir_mode *mode_Hu;
 186 ir_mode *mode_Is;   /* 32 bit */
 187 ir_mode *mode_Iu;
 188 ir_mode *mode_Ls;   /* 64 bit */
 189 ir_mode *mode_Lu;
 190
 191 ir_mode *mode_C;
 192 ir_mode *mode_U;
 193 ir_mode *mode_b;
 194 ir_mode *mode_P;
 195
 196 /* machine specific modes */
 197 ir_mode *mode_P_mach;   /* machine specific pointer mode */
 198
 199 /* * *
 200  * functions defined in irmode.h
 201  * * */
 202
 203 /* JNI access functions */
 204 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
 205 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
 206 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
 207 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
 208 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
 209 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
 210 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
 211 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
 212 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
 213 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
 214 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
 215 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
 216 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
 217 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
 218 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
 219 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
 220 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
 221 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
 222 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
 223 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
 224 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
 225
 226
 227 ir_mode *get_modeP_mach(void)  { ANNOUNCE(); return mode_P_mach; }
 228 void     set_modeP_mach(ir_mode *p) {
 229   ANNOUNCE();
 230   assert(mode_is_reference(p));
 231   mode_P_mach = p;
 232  }
 233
 234 /**
 235  * Registers a new mode if not defined yet, else returns
 236  * the "equivalent" one.
 237  */
 238 static ir_mode *register_mode(const ir_mode* new_mode)
 239 {
 240   ir_mode *mode = NULL;
 241
 242   ANNOUNCE();
 243   assert(new_mode);
 244
 245   /* copy mode struct to modes array */
 246   mode = (ir_mode*)obstack_copy(&modes, new_mode, sizeof(ir_mode));
 247
 248   mode->kind = k_ir_mode;
 249   if(num_modes>=irm_max) mode->code = num_modes;
 250   num_modes++;
 251
 252   set_mode_values(mode);
 253
 254   return mode;
 255 }
 256
 257 /*
 258  * Creates a new mode.
 259  */
 260 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign,
 261                      mode_arithmetic arithmetic, unsigned int modulo_shift )
 262 {
 263   ir_mode mode_tmpl;
 264   ir_mode *mode;
 265
 266   mode_tmpl.name         = new_id_from_str(name);
 267   mode_tmpl.sort         = sort;
 268   mode_tmpl.size         = bit_size;
 269   mode_tmpl.align        = align;
 270   mode_tmpl.sign         = sign ? 1 : 0;
 271   mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
 272   mode_tmpl.vector_elem  = 1;
 273   mode_tmpl.arithmetic   = arithmetic;
 274   mode_tmpl.link         = NULL;
 275   mode_tmpl.tv_priv      = NULL;
 276
 277   mode = find_mode(&mode_tmpl);
 278   if (mode)
 279   {
 280     return mode;
 281   }
 282
 283   /* sanity checks */
 284   switch (sort)
 285   {
 286     case irms_auxiliary:
 287     case irms_control_flow:
 288     case irms_memory:
 289     case irms_internal_boolean:
 290       assert(0 && "internal modes cannot be user defined");
 291       return NULL;
 292
 293     case irms_float_number:
 294       assert(0 && "not yet implemented");
 295       return NULL;
 296
 297     case irms_int_number:
 298     case irms_reference:
 299     case irms_character:
 300       return register_mode(&mode_tmpl);
 301   }
 302   return NULL; /* to shut up gcc */
 303 }
 304
 305 /*
 306  * Creates a new vector mode.
 307  */
 308 ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int align, int sign,
 309                      mode_arithmetic arithmetic, unsigned int modulo_shift )
 310 {
 311   ir_mode mode_tmpl;
 312   ir_mode *mode;
 313
 314   mode_tmpl.name         = new_id_from_str(name);
 315   mode_tmpl.sort         = sort;
 316   mode_tmpl.size         = bit_size * num_of_elem;
 317   mode_tmpl.align        = align;
 318   mode_tmpl.sign         = sign ? 1 : 0;
 319   mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
 320   mode_tmpl.vector_elem  = num_of_elem;
 321   mode_tmpl.arithmetic   = arithmetic;
 322   mode_tmpl.link         = NULL;
 323   mode_tmpl.tv_priv      = NULL;
 324
 325   mode = find_mode(&mode_tmpl);
 326   if (mode)
 327     return mode;
 328
 329   if (num_of_elem <= 1) {
 330     assert(0 && "vector modes should have at least 2 elements");
 331     return NULL;
 332   }
 333
 334   /* sanity checks */
 335   switch (sort)
 336   {
 337     case irms_auxiliary:
 338     case irms_control_flow:
 339     case irms_memory:
 340     case irms_internal_boolean:
 341       assert(0 && "internal modes cannot be user defined");
 342       return NULL;
 343
 344     case irms_reference:
 345     case irms_character:
 346       assert(0 && "only integer and floating point modes can be vectorized");
 347       return NULL;
 348
 349     case irms_float_number:
 350       assert(0 && "not yet implemented");
 351       return NULL;
 352
 353     case irms_int_number:
 354       return register_mode(&mode_tmpl);
 355   }
 356   return NULL; /* to shut up gcc */
 357 }
 358
 359 /* Functions for the direct access to all attributes od a ir_mode */
 360 modecode
 361 get_mode_modecode(const ir_mode *mode)
 362 {
 363   ANNOUNCE();
 364   return mode->code;
 365 }
 366
 367 ident *
 368 get_mode_ident(const ir_mode *mode)
 369 {
 370   ANNOUNCE();
 371   return mode->name;
 372 }
 373
 374 const char *
 375 get_mode_name(const ir_mode *mode)
 376 {
 377   ANNOUNCE();
 378   return get_id_str(mode->name);
 379 }
 380
 381 mode_sort
 382 get_mode_sort(const ir_mode* mode)
 383 {
 384   ANNOUNCE();
 385   return mode->sort;
 386 }
 387
 388 INLINE int
 389 get_mode_size_bits(const ir_mode *mode)
 390 {
 391   ANNOUNCE();
 392   return mode->size;
 393 }
 394
 395 int get_mode_size_bytes(const ir_mode *mode) {
 396   int size = get_mode_size_bits(mode);
 397   ANNOUNCE();
 398   if ((size & 7) != 0) return -1;
 399   return size >> 3;
 400 }
 401
 402 int
 403 get_mode_align (const ir_mode *mode)
 404 {
 405   ANNOUNCE();
 406   return mode->align;
 407 }
 408
 409 int
 410 get_mode_sign (const ir_mode *mode)
 411 {
 412   ANNOUNCE();
 413   return mode->sign;
 414 }
 415
 416 int get_mode_arithmetic (const ir_mode *mode)
 417 {
 418   ANNOUNCE();
 419   return mode->arithmetic;
 420 }
 421
 422
 423 /* Attribute modulo shift specifies for modes of kind irms_int_number
 424  *  whether shift applies modulo to value of bits to shift.  Asserts
 425  *  if mode is not irms_int_number.
 426  */
 427 unsigned int get_mode_modulo_shift(const ir_mode *mode) {
 428   return mode->modulo_shift;
 429 }
 430
 431 unsigned int get_mode_vector_elems(const ir_mode *mode) {
 432   return mode->vector_elem;
 433 }
 434
 435 void *get_mode_link(const ir_mode *mode)
 436 {
 437   ANNOUNCE();
 438   return mode->link;
 439 }
 440
 441 void set_mode_link(ir_mode *mode, void *l)
 442 {
 443   mode->link=l;
 444   return;
 445 }
 446
 447 tarval *
 448 get_mode_min (ir_mode *mode)
 449 {
 450   ANNOUNCE();
 451   assert(mode);
 452   assert(get_mode_modecode(mode) < num_modes);
 453   assert(mode_is_data(mode));
 454
 455   return mode->min;
 456 }
 457
 458 tarval *
 459 get_mode_max (ir_mode *mode)
 460 {
 461   ANNOUNCE();
 462   assert(mode);
 463   assert(get_mode_modecode(mode) < num_modes);
 464   assert(mode_is_data(mode));
 465
 466   return mode->max;
 467 }
 468
 469 tarval *
 470 get_mode_null (ir_mode *mode)
 471 {
 472   ANNOUNCE();
 473   assert(mode);
 474   assert(get_mode_modecode(mode) < num_modes);
 475   assert(mode_is_data(mode));
 476
 477   return mode->null;
 478 }
 479
 480 tarval *
 481 get_mode_one (ir_mode *mode)
 482 {
 483   ANNOUNCE();
 484   assert(mode);
 485   assert(get_mode_modecode(mode) < num_modes);
 486   assert(mode_is_data(mode));
 487
 488   return mode->one;
 489 }
 490
 491 tarval *
 492 get_mode_infinite(ir_mode *mode)
 493 {
 494   ANNOUNCE();
 495   assert(mode);
 496   assert(get_mode_modecode(mode) < num_modes);
 497   assert(mode_is_float(mode));
 498
 499   return get_tarval_inf(mode);
 500 }
 501
 502 tarval *
 503 get_mode_NAN(ir_mode *mode)
 504 {
 505   ANNOUNCE();
 506   assert(mode);
 507   assert(get_mode_modecode(mode) < num_modes);
 508   assert(mode_is_float(mode));
 509
 510   return get_tarval_nan(mode);
 511 }
 512
 513 int
 514 is_mode (void *thing) {
 515   assert(thing);
 516   if (get_kind(thing) == k_ir_mode)
 517     return 1;
 518   else
 519     return 0;
 520 }
 521
 522 /* Functions to check, whether a modecode is signed, float, int, num, data,
 523    datab or dataM. For more exact definitions read the corresponding pages
 524    in the firm documentation or the followingenumeration
 525
 526    The set of "float" is defined as:
 527    ---------------------------------
 528    float = {irm_F, irm_D, irm_E}
 529
 530    The set of "int" is defined as:
 531    -------------------------------
 532    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 533
 534    The set of "num" is defined as:
 535    -------------------------------
 536    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 537             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 538             = {float || int}
 539
 540    The set of "data" is defined as:
 541    -------------------------------
 542    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 543             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
 544             = {num || irm_C || irm_U || irm_P}
 545
 546    The set of "datab" is defined as:
 547    ---------------------------------
 548    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 549             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 550             = {data || irm_b }
 551
 552    The set of "dataM" is defined as:
 553    ---------------------------------
 554    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 555             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 556             = {data || irm_M}
 557 */
 558
 559 #ifdef MODE_ACCESS_DEFINES
 560 #  undef mode_is_signed
 561 #  undef mode_is_float
 562 #  undef mode_is_int
 563 #  undef mode_is_num
 564 #  undef mode_is_numP
 565 #  undef mode_is_data
 566 #  undef mode_is_datab
 567 #  undef mode_is_dataM
 568 #endif
 569 int
 570 mode_is_signed (const ir_mode *mode)
 571 {
 572   ANNOUNCE();
 573   assert(mode);
 574   return mode->sign;
 575 }
 576
 577 int
 578 mode_is_float (const ir_mode *mode)
 579 {
 580   ANNOUNCE();
 581   assert(mode);
 582   return (get_mode_sort(mode) == irms_float_number);
 583 }
 584
 585 int
 586 mode_is_int (const ir_mode *mode)
 587 {
 588   ANNOUNCE();
 589   assert(mode);
 590   return (get_mode_sort(mode) == irms_int_number);
 591 }
 592
 593 int mode_is_character (const ir_mode *mode)
 594 {
 595   ANNOUNCE();
 596   assert(mode);
 597   return (get_mode_sort(mode) == irms_character);
 598 }
 599
 600 int mode_is_reference (const ir_mode *mode)
 601 {
 602   ANNOUNCE();
 603   assert(mode);
 604   return (get_mode_sort(mode) == irms_reference);
 605 }
 606
 607 int
 608 mode_is_num (const ir_mode *mode)
 609 {
 610   ANNOUNCE();
 611   assert(mode);
 612   return (mode_is_int(mode) || mode_is_float(mode));
 613 }
 614
 615 int
 616 mode_is_numP (const ir_mode *mode)
 617 {
 618   ANNOUNCE();
 619   assert(mode);
 620   return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
 621 }
 622
 623 int
 624 mode_is_data (const ir_mode *mode)
 625 {
 626   ANNOUNCE();
 627   assert(mode);
 628   return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
 629 }
 630
 631 int
 632 mode_is_datab (const ir_mode *mode)
 633 {
 634   ANNOUNCE();
 635   assert(mode);
 636   return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
 637 }
 638
 639 int
 640 mode_is_dataM (const ir_mode *mode)
 641 {
 642   ANNOUNCE();
 643   assert(mode);
 644   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 645 }
 646
 647 int
 648 mode_is_float_vector (const ir_mode *mode)
 649 {
 650   ANNOUNCE();
 651   assert(mode);
 652   return (get_mode_sort(mode) == irms_float_number) && (get_mode_vector_elems(mode) > 1);
 653 }
 654
 655 int
 656 mode_is_int_vector (const ir_mode *mode)
 657 {
 658   ANNOUNCE();
 659   assert(mode);
 660   return (get_mode_sort(mode) == irms_int_number) && (get_mode_vector_elems(mode) > 1);
 661 }
 662
 663 #ifdef MODE_ACCESS_DEFINES
 664 #  define mode_is_signed(mode) (mode)->sign
 665 #  define mode_is_float(mode) ((mode)->sort == irms_float_number)
 666 #  define mode_is_int(mode) ((mode)->sort == irms_int_number)
 667 #  define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
 668 #  define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
 669 #  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))
 670 #  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))
 671 #  define mode_is_float_vector(mode) (((mode)->sort == irms_float_number) && ((mode)->vector_elem > 1))
 672 #  define mode_is_int_vector(mode) (((mode)->sort == irms_int_number) && ((mode)->vector_elem > 1))
 673 #endif
 674 /* Returns true if sm can be converted to lm without loss. */
 675 int
 676 smaller_mode(const ir_mode *sm, const ir_mode *lm)
 677 {
 678   int sm_bits, lm_bits;
 679
 680   ANNOUNCE();
 681   assert(sm);
 682   assert(lm);
 683
 684   if (sm == lm) return 1;
 685
 686   sm_bits = get_mode_size_bits(sm);
 687   lm_bits = get_mode_size_bits(lm);
 688
 689   switch(get_mode_sort(sm))
 690   {
 691     case irms_int_number:
 692       switch(get_mode_sort(lm))
 693       {
 694         case irms_int_number:
 695           /* integers are convertable if
 696            *   - both have the same sign and lm is the larger one
 697            *   - lm is the signed one and is at least two bits larger
 698            *     (one for the sign, one for the highest bit of sm)
 699            *   - sm & lm are two_complement and lm has greater or equal number of bits
 700            */
 701           if (   get_mode_arithmetic(sm) == get_mode_arithmetic(lm)
 702               && get_mode_arithmetic(sm) == irma_twos_complement) {
 703             return lm_bits >= sm_bits;
 704           }
 705           else if (mode_is_signed(sm))
 706           {
 707             if ( mode_is_signed(lm) && (lm_bits >= sm_bits) )
 708               return 1;
 709           }
 710           else if (mode_is_signed(lm))
 711           {
 712             if (lm_bits > sm_bits + 1)
 713               return 1;
 714           }
 715           else if (lm_bits >= sm_bits)
 716           {
 717             return 1;
 718           }
 719           break;
 720
 721         case irms_float_number:
 722           /* int to float works if the float is large enough */
 723           return 0;
 724
 725         default:
 726           break;
 727       }
 728       break;
 729
 730     case irms_float_number:
 731       if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
 732         if ( (get_mode_sort(lm) == irms_float_number)
 733            && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
 734           return 1;
 735       }
 736       break;
 737
 738     case irms_reference:
 739        /* do exist machines out there with different pointer lenghts ?*/
 740       return 0;
 741
 742     default:
 743       break;
 744   }
 745
 746   /* else */
 747   return 0;
 748 }
 749
 750 /* ** initialization ** */
 751 void
 752 init_mode (void)
 753 {
 754   ir_mode newmode;
 755   ANNOUNCE();
 756   /* init flexible array */
 757
 758   obstack_init(&modes);
 759
 760   num_modes  =  0;
 761   /* initialize predefined modes */
 762
 763   /* Internal Modes */
 764   newmode.arithmetic   = irma_none;
 765   newmode.size         = 0;
 766   newmode.align        = 0;
 767   newmode.sign         = 0;
 768   newmode.modulo_shift = 0;
 769   newmode.vector_elem  = 0;
 770   newmode.link         = NULL;
 771   newmode.tv_priv      = NULL;
 772
 773   /* Control Flow Modes*/
 774   newmode.sort    = irms_control_flow;
 775
 776   /* Basic Block */
 777   newmode.name    = id_from_str("BB", 2);
 778   newmode.code    = irm_BB;
 779
 780   mode_BB = register_mode(&newmode);
 781
 782 /* eXecution */
 783   newmode.name    = id_from_str("X", 1);
 784   newmode.code    = irm_X;
 785
 786   mode_X = register_mode(&newmode);
 787
 788   /* Memory Modes */
 789   newmode.sort    = irms_memory;
 790
 791   /* Memory */
 792   newmode.name    = id_from_str("M", 1);
 793   newmode.code    = irm_M;
 794
 795   mode_M = register_mode(&newmode);
 796
 797   /* Auxiliary Modes */
 798   newmode.sort    = irms_auxiliary,
 799
 800   /* Tuple */
 801   newmode.name    = id_from_str("T", 1);
 802   newmode.code    = irm_T;
 803
 804   mode_T = register_mode(&newmode);
 805
 806   /* ANY */
 807   newmode.name    = id_from_str("ANY", 3);
 808   newmode.code    = irm_ANY;
 809
 810   mode_ANY = register_mode(&newmode);
 811
 812   /* BAD */
 813   newmode.name    = id_from_str("BAD", 3);
 814   newmode.code    = irm_BAD;
 815
 816   mode_BAD = register_mode(&newmode);
 817
 818   /* Internal Boolean Modes */
 819   newmode.sort    = irms_internal_boolean;
 820
 821   /* boolean */
 822   newmode.name    = id_from_str("b", 1);
 823   newmode.code    = irm_b;
 824
 825   mode_b = register_mode(&newmode);
 826
 827 /* Data Modes */
 828   newmode.vector_elem = 1;
 829
 830   /* Float Number Modes */
 831   newmode.sort    = irms_float_number;
 832   newmode.arithmetic = irma_ieee754;
 833
 834   /* float */
 835   newmode.name    = id_from_str("F", 1);
 836   newmode.code    = irm_F;
 837   newmode.sign    = 1;
 838   newmode.align   = 4;
 839   newmode.size    = 32;
 840
 841   mode_F = register_mode(&newmode);
 842
 843   /* double */
 844   newmode.name    = id_from_str("D", 1);
 845   newmode.code    = irm_D;
 846   newmode.sign    = 1;
 847   newmode.align   = 4;
 848   newmode.size    = 64;
 849
 850   mode_D = register_mode(&newmode);
 851
 852   /* extended */
 853   newmode.name    = id_from_str("E", 1);
 854   newmode.code    = irm_E;
 855   newmode.sign    = 1;
 856   newmode.align   = 4;
 857   newmode.size    = 80;
 858
 859   mode_E = register_mode(&newmode);
 860
 861   /* Integer Number Modes */
 862   newmode.sort    = irms_int_number;
 863   newmode.arithmetic = irma_twos_complement;
 864
 865   /* signed byte */
 866   newmode.name    = id_from_str("Bs", 2);
 867   newmode.code    = irm_Bs;
 868   newmode.sign    = 1;
 869   newmode.align   = 1;
 870   newmode.size    = 8;
 871   newmode.modulo_shift = 32;
 872
 873   mode_Bs = register_mode(&newmode);
 874
 875   /* unsigned byte */
 876   newmode.name    = id_from_str("Bu", 2);
 877   newmode.code    = irm_Bu;
 878   newmode.arithmetic = irma_twos_complement;
 879   newmode.sign    = 0;
 880   newmode.align   = 1;
 881   newmode.size    = 8;
 882   newmode.modulo_shift = 32;
 883
 884   mode_Bu = register_mode(&newmode);
 885
 886   /* signed short integer */
 887   newmode.name    = id_from_str("Hs", 2);
 888   newmode.code    = irm_Hs;
 889   newmode.sign    = 1;
 890   newmode.align   = 2;
 891   newmode.size    = 16;
 892   newmode.modulo_shift = 32;
 893
 894   mode_Hs = register_mode(&newmode);
 895
 896   /* unsigned short integer */
 897   newmode.name    = id_from_str("Hu", 2);
 898   newmode.code    = irm_Hu;
 899   newmode.sign    = 0;
 900   newmode.align   = 2;
 901   newmode.size    = 16;
 902   newmode.modulo_shift = 32;
 903
 904   mode_Hu = register_mode(&newmode);
 905
 906   /* signed integer */
 907   newmode.name    = id_from_str("Is", 2);
 908   newmode.code    = irm_Is;
 909   newmode.sign    = 1;
 910   newmode.align   = 4;
 911   newmode.size    = 32;
 912   newmode.modulo_shift = 32;
 913
 914   mode_Is = register_mode(&newmode);
 915
 916   /* unsigned integer */
 917   newmode.name    = id_from_str("Iu", 2);
 918   newmode.code    = irm_Iu;
 919   newmode.sign    = 0;
 920   newmode.align   = 4;
 921   newmode.size    = 32;
 922   newmode.modulo_shift = 32;
 923
 924   mode_Iu = register_mode(&newmode);
 925
 926   /* signed long integer */
 927   newmode.name    = id_from_str("Ls", 2);
 928   newmode.code    = irm_Ls;
 929   newmode.sign    = 1;
 930   newmode.align   = 4;
 931   newmode.size    = 64;
 932   newmode.modulo_shift = 64;
 933
 934   mode_Ls = register_mode(&newmode);
 935
 936   /* unsigned long integer */
 937   newmode.name    = id_from_str("Lu", 2);
 938   newmode.code    = irm_Lu;
 939   newmode.sign    = 0;
 940   newmode.align   = 4;
 941   newmode.size    = 64;
 942   newmode.modulo_shift = 64;
 943
 944   mode_Lu = register_mode(&newmode);
 945
 946   /* Character Modes */
 947   newmode.sort    = irms_character;
 948   newmode.arithmetic = irma_none;
 949
 950   /* Character */
 951   newmode.name    = id_from_str("C", 1);
 952   newmode.code    = irm_C;
 953   newmode.sign    = 0;
 954   newmode.align   = 1;
 955   newmode.size    = 8;
 956   newmode.modulo_shift = 32;
 957
 958   mode_C = register_mode(&newmode);
 959
 960   /* Unicode character */
 961   newmode.name    = id_from_str("U", 1);
 962   newmode.code    = irm_U;
 963   newmode.sign    = 0;
 964   newmode.align   = 2;
 965   newmode.size    = 16;
 966   newmode.modulo_shift = 32;
 967
 968   mode_U = register_mode(&newmode);
 969
 970   /* Reference Modes */
 971   newmode.sort    = irms_reference;
 972   newmode.arithmetic = irma_twos_complement;
 973
 974   /* pointer */
 975   newmode.name    = id_from_str("P", 1);
 976   newmode.code    = irm_P;
 977   newmode.sign    = 0;
 978   newmode.align   = 4;
 979   newmode.size    = 32;
 980   newmode.modulo_shift = 0;
 981
 982   mode_P = register_mode(&newmode);
 983
 984   /* set the machine specific modes to the predifined ones */
 985   mode_P_mach = mode_P;
 986 }
 987
 988
 989 void finish_mode(void) {
 990   obstack_free(&modes, 0);
 991
 992   mode_T = NULL;
 993   mode_X = NULL;
 994   mode_M = NULL;
 995   mode_BB = NULL;
 996   mode_ANY = NULL;
 997   mode_BAD = NULL;
 998
 999   mode_F = NULL;
1000   mode_D = NULL;
1001   mode_E = NULL;
1002
1003   mode_Bs = NULL;
1004   mode_Bu = NULL;
1005   mode_Hs = NULL;
1006   mode_Hu = NULL;
1007   mode_Is = NULL;
1008   mode_Iu = NULL;
1009   mode_Ls = NULL;
1010   mode_Lu = NULL;
1011
1012   mode_C = NULL;
1013   mode_U = NULL;
1014   mode_b = NULL;
1015   mode_P = NULL;
1016
1017   mode_P_mach = NULL;
1018 }