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

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