nsz Git - libfirm/blob - ir/ir/irmode.c

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