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