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     case irms_int_number:
 295     case irms_reference:
 296     case irms_character:
 297       return register_mode(&mode_tmpl);
 298   }
 299   return NULL; /* to shut up gcc */
 300 }
 301
 302 /*
 303  * Creates a new vector mode.
 304  */
 305 ir_mode *new_ir_vector_mode(const char *name, mode_sort sort, int bit_size, unsigned num_of_elem, int align, int sign,
 306                      mode_arithmetic arithmetic, unsigned int modulo_shift )
 307 {
 308   ir_mode mode_tmpl;
 309   ir_mode *mode;
 310
 311   mode_tmpl.name         = new_id_from_str(name);
 312   mode_tmpl.sort         = sort;
 313   mode_tmpl.size         = bit_size * num_of_elem;
 314   mode_tmpl.align        = align;
 315   mode_tmpl.sign         = sign ? 1 : 0;
 316   mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
 317   mode_tmpl.vector_elem  = num_of_elem;
 318   mode_tmpl.arithmetic   = arithmetic;
 319   mode_tmpl.link         = NULL;
 320   mode_tmpl.tv_priv      = NULL;
 321
 322   mode = find_mode(&mode_tmpl);
 323   if (mode)
 324     return mode;
 325
 326   if (num_of_elem <= 1) {
 327     assert(0 && "vector modes should have at least 2 elements");
 328     return NULL;
 329   }
 330
 331   /* sanity checks */
 332   switch (sort)
 333   {
 334     case irms_auxiliary:
 335     case irms_control_flow:
 336     case irms_memory:
 337     case irms_internal_boolean:
 338       assert(0 && "internal modes cannot be user defined");
 339       return NULL;
 340
 341     case irms_reference:
 342     case irms_character:
 343       assert(0 && "only integer and floating point modes can be vectorized");
 344       return NULL;
 345
 346     case irms_float_number:
 347       assert(0 && "not yet implemented");
 348       return NULL;
 349
 350     case irms_int_number:
 351       return register_mode(&mode_tmpl);
 352   }
 353   return NULL; /* to shut up gcc */
 354 }
 355
 356 /* Functions for the direct access to all attributes od a ir_mode */
 357 modecode
 358 get_mode_modecode(const ir_mode *mode)
 359 {
 360   ANNOUNCE();
 361   return mode->code;
 362 }
 363
 364 ident *
 365 get_mode_ident(const ir_mode *mode)
 366 {
 367   ANNOUNCE();
 368   return mode->name;
 369 }
 370
 371 const char *
 372 get_mode_name(const ir_mode *mode)
 373 {
 374   ANNOUNCE();
 375   return get_id_str(mode->name);
 376 }
 377
 378 mode_sort
 379 get_mode_sort(const ir_mode* mode)
 380 {
 381   ANNOUNCE();
 382   return mode->sort;
 383 }
 384
 385 INLINE int
 386 get_mode_size_bits(const ir_mode *mode)
 387 {
 388   ANNOUNCE();
 389   return mode->size;
 390 }
 391
 392 int get_mode_size_bytes(const ir_mode *mode) {
 393   int size = get_mode_size_bits(mode);
 394   ANNOUNCE();
 395   if ((size & 7) != 0) return -1;
 396   return size >> 3;
 397 }
 398
 399 int
 400 get_mode_align (const ir_mode *mode)
 401 {
 402   ANNOUNCE();
 403   return mode->align;
 404 }
 405
 406 int
 407 get_mode_sign (const ir_mode *mode)
 408 {
 409   ANNOUNCE();
 410   return mode->sign;
 411 }
 412
 413 int get_mode_arithmetic (const ir_mode *mode)
 414 {
 415   ANNOUNCE();
 416   return mode->arithmetic;
 417 }
 418
 419
 420 /* Attribute modulo shift specifies for modes of kind irms_int_number
 421  *  whether shift applies modulo to value of bits to shift.  Asserts
 422  *  if mode is not irms_int_number.
 423  */
 424 unsigned int get_mode_modulo_shift(const ir_mode *mode) {
 425   return mode->modulo_shift;
 426 }
 427
 428 unsigned int get_mode_vector_elems(const ir_mode *mode) {
 429   return mode->vector_elem;
 430 }
 431
 432 void *get_mode_link(const ir_mode *mode)
 433 {
 434   ANNOUNCE();
 435   return mode->link;
 436 }
 437
 438 void set_mode_link(ir_mode *mode, void *l)
 439 {
 440   mode->link=l;
 441   return;
 442 }
 443
 444 tarval *
 445 get_mode_min (ir_mode *mode)
 446 {
 447   ANNOUNCE();
 448   assert(mode);
 449   assert(get_mode_modecode(mode) < num_modes);
 450   assert(mode_is_data(mode));
 451
 452   return mode->min;
 453 }
 454
 455 tarval *
 456 get_mode_max (ir_mode *mode)
 457 {
 458   ANNOUNCE();
 459   assert(mode);
 460   assert(get_mode_modecode(mode) < num_modes);
 461   assert(mode_is_data(mode));
 462
 463   return mode->max;
 464 }
 465
 466 tarval *
 467 get_mode_null (ir_mode *mode)
 468 {
 469   ANNOUNCE();
 470   assert(mode);
 471   assert(get_mode_modecode(mode) < num_modes);
 472   assert(mode_is_data(mode));
 473
 474   return mode->null;
 475 }
 476
 477 tarval *
 478 get_mode_one (ir_mode *mode)
 479 {
 480   ANNOUNCE();
 481   assert(mode);
 482   assert(get_mode_modecode(mode) < num_modes);
 483   assert(mode_is_data(mode));
 484
 485   return mode->one;
 486 }
 487
 488 tarval *
 489 get_mode_infinite(ir_mode *mode)
 490 {
 491   ANNOUNCE();
 492   assert(mode);
 493   assert(get_mode_modecode(mode) < num_modes);
 494   assert(mode_is_float(mode));
 495
 496   return get_tarval_inf(mode);
 497 }
 498
 499 tarval *
 500 get_mode_NAN(ir_mode *mode)
 501 {
 502   ANNOUNCE();
 503   assert(mode);
 504   assert(get_mode_modecode(mode) < num_modes);
 505   assert(mode_is_float(mode));
 506
 507   return get_tarval_nan(mode);
 508 }
 509
 510 int
 511 is_mode (void *thing) {
 512   assert(thing);
 513   if (get_kind(thing) == k_ir_mode)
 514     return 1;
 515   else
 516     return 0;
 517 }
 518
 519 /* Functions to check, whether a modecode is signed, float, int, num, data,
 520    datab or dataM. For more exact definitions read the corresponding pages
 521    in the firm documentation or the followingenumeration
 522
 523    The set of "float" is defined as:
 524    ---------------------------------
 525    float = {irm_F, irm_D, irm_E}
 526
 527    The set of "int" is defined as:
 528    -------------------------------
 529    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 530
 531    The set of "num" is defined as:
 532    -------------------------------
 533    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 534             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 535             = {float || int}
 536
 537    The set of "data" is defined as:
 538    -------------------------------
 539    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 540             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
 541             = {num || irm_C || irm_U || irm_P}
 542
 543    The set of "datab" is defined as:
 544    ---------------------------------
 545    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 546             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 547             = {data || irm_b }
 548
 549    The set of "dataM" is defined as:
 550    ---------------------------------
 551    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 552             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 553             = {data || irm_M}
 554 */
 555
 556 #ifdef MODE_ACCESS_DEFINES
 557 #  undef mode_is_signed
 558 #  undef mode_is_float
 559 #  undef mode_is_int
 560 #  undef mode_is_num
 561 #  undef mode_is_numP
 562 #  undef mode_is_data
 563 #  undef mode_is_datab
 564 #  undef mode_is_dataM
 565 #endif
 566 int
 567 mode_is_signed (const ir_mode *mode)
 568 {
 569   ANNOUNCE();
 570   assert(mode);
 571   return mode->sign;
 572 }
 573
 574 int
 575 mode_is_float (const ir_mode *mode)
 576 {
 577   ANNOUNCE();
 578   assert(mode);
 579   return (get_mode_sort(mode) == irms_float_number);
 580 }
 581
 582 int
 583 mode_is_int (const ir_mode *mode)
 584 {
 585   ANNOUNCE();
 586   assert(mode);
 587   return (get_mode_sort(mode) == irms_int_number);
 588 }
 589
 590 int mode_is_character (const ir_mode *mode)
 591 {
 592   ANNOUNCE();
 593   assert(mode);
 594   return (get_mode_sort(mode) == irms_character);
 595 }
 596
 597 int mode_is_reference (const ir_mode *mode)
 598 {
 599   ANNOUNCE();
 600   assert(mode);
 601   return (get_mode_sort(mode) == irms_reference);
 602 }
 603
 604 int
 605 mode_is_num (const ir_mode *mode)
 606 {
 607   ANNOUNCE();
 608   assert(mode);
 609   return (mode_is_int(mode) || mode_is_float(mode));
 610 }
 611
 612 int
 613 mode_is_numP (const ir_mode *mode)
 614 {
 615   ANNOUNCE();
 616   assert(mode);
 617   return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
 618 }
 619
 620 int
 621 mode_is_data (const ir_mode *mode)
 622 {
 623   ANNOUNCE();
 624   assert(mode);
 625   return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
 626 }
 627
 628 int
 629 mode_is_datab (const ir_mode *mode)
 630 {
 631   ANNOUNCE();
 632   assert(mode);
 633   return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
 634 }
 635
 636 int
 637 mode_is_dataM (const ir_mode *mode)
 638 {
 639   ANNOUNCE();
 640   assert(mode);
 641   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 642 }
 643
 644 int
 645 mode_is_float_vector (const ir_mode *mode)
 646 {
 647   ANNOUNCE();
 648   assert(mode);
 649   return (get_mode_sort(mode) == irms_float_number) && (get_mode_vector_elems(mode) > 1);
 650 }
 651
 652 int
 653 mode_is_int_vector (const ir_mode *mode)
 654 {
 655   ANNOUNCE();
 656   assert(mode);
 657   return (get_mode_sort(mode) == irms_int_number) && (get_mode_vector_elems(mode) > 1);
 658 }
 659
 660 #ifdef MODE_ACCESS_DEFINES
 661 #  define mode_is_signed(mode) (mode)->sign
 662 #  define mode_is_float(mode) ((mode)->sort == irms_float_number)
 663 #  define mode_is_int(mode) ((mode)->sort == irms_int_number)
 664 #  define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
 665 #  define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
 666 #  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))
 667 #  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))
 668 #  define mode_is_float_vector(mode) (((mode)->sort == irms_float_number) && ((mode)->vector_elem > 1))
 669 #  define mode_is_int_vector(mode) (((mode)->sort == irms_int_number) && ((mode)->vector_elem > 1))
 670 #endif
 671 /* Returns true if sm can be converted to lm without loss. */
 672 int
 673 smaller_mode(const ir_mode *sm, const ir_mode *lm)
 674 {
 675   int sm_bits, lm_bits;
 676
 677   ANNOUNCE();
 678   assert(sm);
 679   assert(lm);
 680
 681   if (sm == lm) return 1;
 682
 683   sm_bits = get_mode_size_bits(sm);
 684   lm_bits = get_mode_size_bits(lm);
 685
 686   switch(get_mode_sort(sm))
 687   {
 688     case irms_int_number:
 689       switch(get_mode_sort(lm))
 690       {
 691         case irms_int_number:
 692           /* integers are convertable if
 693            *   - both have the same sign and lm is the larger one
 694            *   - lm is the signed one and is at least two bits larger
 695            *     (one for the sign, one for the highest bit of sm)
 696            *   - sm & lm are two_complement and lm has greater or equal number of bits
 697            */
 698           if (   get_mode_arithmetic(sm) == get_mode_arithmetic(lm)
 699               && get_mode_arithmetic(sm) == irma_twos_complement) {
 700             return lm_bits >= sm_bits;
 701           }
 702           else if (mode_is_signed(sm))
 703           {
 704             if ( mode_is_signed(lm) && (lm_bits >= sm_bits) )
 705               return 1;
 706           }
 707           else if (mode_is_signed(lm))
 708           {
 709             if (lm_bits > sm_bits + 1)
 710               return 1;
 711           }
 712           else if (lm_bits >= sm_bits)
 713           {
 714             return 1;
 715           }
 716           break;
 717
 718         case irms_float_number:
 719           /* int to float works if the float is large enough */
 720           return 0;
 721
 722         default:
 723           break;
 724       }
 725       break;
 726
 727     case irms_float_number:
 728       if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
 729         if ( (get_mode_sort(lm) == irms_float_number)
 730            && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
 731           return 1;
 732       }
 733       break;
 734
 735     case irms_reference:
 736        /* do exist machines out there with different pointer lenghts ?*/
 737       return 0;
 738
 739     default:
 740       break;
 741   }
 742
 743   /* else */
 744   return 0;
 745 }
 746
 747 /* ** initialization ** */
 748 void
 749 init_mode (void)
 750 {
 751   ir_mode newmode;
 752   ANNOUNCE();
 753   /* init flexible array */
 754
 755   obstack_init(&modes);
 756
 757   num_modes  =  0;
 758   /* initialize predefined modes */
 759
 760   /* Internal Modes */
 761   newmode.arithmetic   = irma_none;
 762   newmode.size         = 0;
 763   newmode.align        = 0;
 764   newmode.sign         = 0;
 765   newmode.modulo_shift = 0;
 766   newmode.vector_elem  = 0;
 767   newmode.link         = NULL;
 768   newmode.tv_priv      = NULL;
 769
 770   /* Control Flow Modes*/
 771   newmode.sort    = irms_control_flow;
 772
 773   /* Basic Block */
 774   newmode.name    = id_from_str("BB", 2);
 775   newmode.code    = irm_BB;
 776
 777   mode_BB = register_mode(&newmode);
 778
 779 /* eXecution */
 780   newmode.name    = id_from_str("X", 1);
 781   newmode.code    = irm_X;
 782
 783   mode_X = register_mode(&newmode);
 784
 785   /* Memory Modes */
 786   newmode.sort    = irms_memory;
 787
 788   /* Memory */
 789   newmode.name    = id_from_str("M", 1);
 790   newmode.code    = irm_M;
 791
 792   mode_M = register_mode(&newmode);
 793
 794   /* Auxiliary Modes */
 795   newmode.sort    = irms_auxiliary,
 796
 797   /* Tuple */
 798   newmode.name    = id_from_str("T", 1);
 799   newmode.code    = irm_T;
 800
 801   mode_T = register_mode(&newmode);
 802
 803   /* ANY */
 804   newmode.name    = id_from_str("ANY", 3);
 805   newmode.code    = irm_ANY;
 806
 807   mode_ANY = register_mode(&newmode);
 808
 809   /* BAD */
 810   newmode.name    = id_from_str("BAD", 3);
 811   newmode.code    = irm_BAD;
 812
 813   mode_BAD = register_mode(&newmode);
 814
 815   /* Internal Boolean Modes */
 816   newmode.sort    = irms_internal_boolean;
 817
 818   /* boolean */
 819   newmode.name    = id_from_str("b", 1);
 820   newmode.code    = irm_b;
 821
 822   mode_b = register_mode(&newmode);
 823
 824 /* Data Modes */
 825   newmode.vector_elem = 1;
 826
 827   /* Float Number Modes */
 828   newmode.sort    = irms_float_number;
 829   newmode.arithmetic = irma_ieee754;
 830
 831   /* float */
 832   newmode.name    = id_from_str("F", 1);
 833   newmode.code    = irm_F;
 834   newmode.sign    = 1;
 835   newmode.align   = 4;
 836   newmode.size    = 32;
 837
 838   mode_F = register_mode(&newmode);
 839
 840   /* double */
 841   newmode.name    = id_from_str("D", 1);
 842   newmode.code    = irm_D;
 843   newmode.sign    = 1;
 844   newmode.align   = 4;
 845   newmode.size    = 64;
 846
 847   mode_D = register_mode(&newmode);
 848
 849   /* extended */
 850   newmode.name    = id_from_str("E", 1);
 851   newmode.code    = irm_E;
 852   newmode.sign    = 1;
 853   newmode.align   = 4;
 854   newmode.size    = 80;
 855
 856   mode_E = register_mode(&newmode);
 857
 858   /* Integer Number Modes */
 859   newmode.sort    = irms_int_number;
 860   newmode.arithmetic = irma_twos_complement;
 861
 862   /* signed byte */
 863   newmode.name    = id_from_str("Bs", 2);
 864   newmode.code    = irm_Bs;
 865   newmode.sign    = 1;
 866   newmode.align   = 1;
 867   newmode.size    = 8;
 868   newmode.modulo_shift = 32;
 869
 870   mode_Bs = register_mode(&newmode);
 871
 872   /* unsigned byte */
 873   newmode.name    = id_from_str("Bu", 2);
 874   newmode.code    = irm_Bu;
 875   newmode.arithmetic = irma_twos_complement;
 876   newmode.sign    = 0;
 877   newmode.align   = 1;
 878   newmode.size    = 8;
 879   newmode.modulo_shift = 32;
 880
 881   mode_Bu = register_mode(&newmode);
 882
 883   /* signed short integer */
 884   newmode.name    = id_from_str("Hs", 2);
 885   newmode.code    = irm_Hs;
 886   newmode.sign    = 1;
 887   newmode.align   = 2;
 888   newmode.size    = 16;
 889   newmode.modulo_shift = 32;
 890
 891   mode_Hs = register_mode(&newmode);
 892
 893   /* unsigned short integer */
 894   newmode.name    = id_from_str("Hu", 2);
 895   newmode.code    = irm_Hu;
 896   newmode.sign    = 0;
 897   newmode.align   = 2;
 898   newmode.size    = 16;
 899   newmode.modulo_shift = 32;
 900
 901   mode_Hu = register_mode(&newmode);
 902
 903   /* signed integer */
 904   newmode.name    = id_from_str("Is", 2);
 905   newmode.code    = irm_Is;
 906   newmode.sign    = 1;
 907   newmode.align   = 4;
 908   newmode.size    = 32;
 909   newmode.modulo_shift = 32;
 910
 911   mode_Is = register_mode(&newmode);
 912
 913   /* unsigned integer */
 914   newmode.name    = id_from_str("Iu", 2);
 915   newmode.code    = irm_Iu;
 916   newmode.sign    = 0;
 917   newmode.align   = 4;
 918   newmode.size    = 32;
 919   newmode.modulo_shift = 32;
 920
 921   mode_Iu = register_mode(&newmode);
 922
 923   /* signed long integer */
 924   newmode.name    = id_from_str("Ls", 2);
 925   newmode.code    = irm_Ls;
 926   newmode.sign    = 1;
 927   newmode.align   = 4;
 928   newmode.size    = 64;
 929   newmode.modulo_shift = 64;
 930
 931   mode_Ls = register_mode(&newmode);
 932
 933   /* unsigned long integer */
 934   newmode.name    = id_from_str("Lu", 2);
 935   newmode.code    = irm_Lu;
 936   newmode.sign    = 0;
 937   newmode.align   = 4;
 938   newmode.size    = 64;
 939   newmode.modulo_shift = 64;
 940
 941   mode_Lu = register_mode(&newmode);
 942
 943   /* Character Modes */
 944   newmode.sort    = irms_character;
 945   newmode.arithmetic = irma_none;
 946
 947   /* Character */
 948   newmode.name    = id_from_str("C", 1);
 949   newmode.code    = irm_C;
 950   newmode.sign    = 0;
 951   newmode.align   = 1;
 952   newmode.size    = 8;
 953   newmode.modulo_shift = 32;
 954
 955   mode_C = register_mode(&newmode);
 956
 957   /* Unicode character */
 958   newmode.name    = id_from_str("U", 1);
 959   newmode.code    = irm_U;
 960   newmode.sign    = 0;
 961   newmode.align   = 2;
 962   newmode.size    = 16;
 963   newmode.modulo_shift = 32;
 964
 965   mode_U = register_mode(&newmode);
 966
 967   /* Reference Modes */
 968   newmode.sort    = irms_reference;
 969   newmode.arithmetic = irma_twos_complement;
 970
 971   /* pointer */
 972   newmode.name    = id_from_str("P", 1);
 973   newmode.code    = irm_P;
 974   newmode.sign    = 0;
 975   newmode.align   = 4;
 976   newmode.size    = 32;
 977   newmode.modulo_shift = 0;
 978
 979   mode_P = register_mode(&newmode);
 980
 981   /* set the machine specific modes to the predifined ones */
 982   mode_P_mach = mode_P;
 983 }
 984
 985
 986 void finish_mode(void) {
 987   obstack_free(&modes, 0);
 988
 989   mode_T = NULL;
 990   mode_X = NULL;
 991   mode_M = NULL;
 992   mode_BB = NULL;
 993   mode_ANY = NULL;
 994   mode_BAD = NULL;
 995
 996   mode_F = NULL;
 997   mode_D = NULL;
 998   mode_E = NULL;
 999
1000   mode_Bs = NULL;
1001   mode_Bu = NULL;
1002   mode_Hs = NULL;
1003   mode_Hu = NULL;
1004   mode_Is = NULL;
1005   mode_Iu = NULL;
1006   mode_Ls = NULL;
1007   mode_Lu = NULL;
1008
1009   mode_C = NULL;
1010   mode_U = NULL;
1011   mode_b = NULL;
1012   mode_P = NULL;
1013
1014   mode_P_mach = NULL;
1015 }