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