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