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