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   /* sanity checks */
 230   switch (sort)
 231   {
 232     case irms_auxiliary:
 233     case irms_control_flow:
 234     case irms_memory:
 235     case irms_internal_boolean:
 236       assert(0 && "internal modes cannot be user defined");
 237       return NULL;
 238       break;
 239
 240     case irms_float_number:
 241       assert(0 && "not yet implemented");
 242       return NULL;
 243       break;
 244
 245     case irms_int_number:
 246     case irms_reference:
 247     case irms_character:
 248       break;
 249   }
 250   mode_tmpl.name        = new_id_from_str(name);
 251   mode_tmpl.sort        = sort;
 252   mode_tmpl.size        = bit_size;
 253   mode_tmpl.align       = align;
 254   mode_tmpl.sign        = sign ? 1 : 0;
 255   mode_tmpl.arithmetic  = arithmetic;
 256   mode_tmpl.tv_priv     = NULL;
 257
 258   /* first check if there already is a matching mode */
 259   mode = find_mode(&mode_tmpl);
 260   if (mode)
 261   {
 262     return mode;
 263   }
 264   else
 265   {
 266     return register_mode(&mode_tmpl);
 267   }
 268 }
 269
 270 /* Functions for the direct access to all attributes od a ir_mode */
 271 modecode
 272 get_mode_modecode(const ir_mode *mode)
 273 {
 274   ANNOUNCE();
 275   return mode->code;
 276 }
 277
 278 ident *
 279 get_mode_ident(const ir_mode *mode)
 280 {
 281   ANNOUNCE();
 282   return mode->name;
 283 }
 284
 285 const char *
 286 get_mode_name(const ir_mode *mode)
 287 {
 288   ANNOUNCE();
 289   return id_to_str(mode->name);
 290 }
 291
 292 mode_sort
 293 get_mode_sort(const ir_mode* mode)
 294 {
 295   ANNOUNCE();
 296   return mode->sort;
 297 }
 298
 299 INLINE int
 300 get_mode_size_bits(const ir_mode *mode)
 301 {
 302   ANNOUNCE();
 303   return mode->size;
 304 }
 305
 306 int get_mode_size_bytes(const ir_mode *mode) {
 307   int size = get_mode_size_bits(mode);
 308   ANNOUNCE();
 309   if ((size & 7) != 0) return -1;
 310   return size >> 3;
 311 }
 312
 313 int
 314 get_mode_align (const ir_mode *mode)
 315 {
 316   ANNOUNCE();
 317   return mode->align;
 318 }
 319
 320 int
 321 get_mode_sign (const ir_mode *mode)
 322 {
 323   ANNOUNCE();
 324   return mode->sign;
 325 }
 326
 327 int get_mode_arithmetic (const ir_mode *mode)
 328 {
 329   ANNOUNCE();
 330   return mode->arithmetic;
 331 }
 332
 333 void* get_mode_link(const ir_mode *mode)
 334 {
 335   ANNOUNCE();
 336   return mode->link;
 337 }
 338
 339 void set_mode_link(ir_mode *mode, void *l)
 340 {
 341   mode->link=l;
 342   return;
 343 }
 344
 345 tarval *
 346 get_mode_min (ir_mode *mode)
 347 {
 348   ANNOUNCE();
 349   assert(mode);
 350   assert(get_mode_modecode(mode) < num_modes);
 351   assert(mode_is_data(mode));
 352
 353   return mode->min;
 354 }
 355
 356 tarval *
 357 get_mode_max (ir_mode *mode)
 358 {
 359   ANNOUNCE();
 360   assert(mode);
 361   assert(get_mode_modecode(mode) < num_modes);
 362   assert(mode_is_data(mode));
 363
 364   return mode->max;
 365 }
 366
 367 tarval *
 368 get_mode_null (ir_mode *mode)
 369 {
 370   ANNOUNCE();
 371   assert(mode);
 372   assert(get_mode_modecode(mode) < num_modes);
 373   assert(mode_is_data(mode));
 374
 375   return mode->null;
 376 }
 377
 378 tarval *
 379 get_mode_one (ir_mode *mode)
 380 {
 381   ANNOUNCE();
 382   assert(mode);
 383   assert(get_mode_modecode(mode) < num_modes);
 384   assert(mode_is_data(mode));
 385
 386   return mode->one;
 387 }
 388
 389 tarval *
 390 get_mode_infinite(ir_mode *mode)
 391 {
 392   ANNOUNCE();
 393   assert(mode);
 394   assert(get_mode_modecode(mode) < num_modes);
 395   assert(mode_is_float(mode));
 396
 397   return get_tarval_inf(mode);
 398 }
 399
 400 tarval *
 401 get_mode_NAN(ir_mode *mode)
 402 {
 403   ANNOUNCE();
 404   assert(mode);
 405   assert(get_mode_modecode(mode) < num_modes);
 406   assert(mode_is_float(mode));
 407
 408   return get_tarval_nan(mode);
 409 }
 410
 411 int
 412 is_mode (void *thing) {
 413   assert(thing);
 414   if (get_kind(thing) == k_ir_mode)
 415     return 1;
 416   else
 417     return 0;
 418 }
 419
 420 /* Functions to check, whether a modecode is signed, float, int, num, data,
 421    datab or dataM. For more exact definitions read the corresponding pages
 422    in the firm documentation or the followingenumeration
 423
 424    The set of "float" is defined as:
 425    ---------------------------------
 426    float = {irm_F, irm_D, irm_E}
 427
 428    The set of "int" is defined as:
 429    -------------------------------
 430    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 431
 432    The set of "num" is defined as:
 433    -------------------------------
 434    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 435             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 436             = {float || int}
 437
 438    The set of "data" is defined as:
 439    -------------------------------
 440    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 441             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
 442             = {num || irm_C || irm_U || irm_P}
 443
 444    The set of "datab" is defined as:
 445    ---------------------------------
 446    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 447             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 448             = {data || irm_b }
 449
 450    The set of "dataM" is defined as:
 451    ---------------------------------
 452    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 453             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 454             = {data || irm_M}
 455 */
 456
 457 #ifdef MODE_ACCESS_DEFINES
 458 #  undef mode_is_signed
 459 #  undef mode_is_float
 460 #  undef mode_is_int
 461 #  undef mode_is_num
 462 #  undef mode_is_numP
 463 #  undef mode_is_data
 464 #  undef mode_is_datab
 465 #  undef mode_is_dataM
 466 #endif
 467 int
 468 mode_is_signed (const ir_mode *mode)
 469 {
 470   ANNOUNCE();
 471   assert(mode);
 472   return mode->sign;
 473 }
 474
 475 int
 476 mode_is_float (const ir_mode *mode)
 477 {
 478   ANNOUNCE();
 479   assert(mode);
 480   return (get_mode_sort(mode) == irms_float_number);
 481 }
 482
 483 int
 484 mode_is_int (const ir_mode *mode)
 485 {
 486   ANNOUNCE();
 487   assert(mode);
 488   return (get_mode_sort(mode) == irms_int_number);
 489 }
 490
 491 int mode_is_character (const ir_mode *mode)
 492 {
 493   ANNOUNCE();
 494   assert(mode);
 495   return (get_mode_sort(mode) == irms_character);
 496 }
 497
 498 int mode_is_reference (const ir_mode *mode)
 499 {
 500   ANNOUNCE();
 501   assert(mode);
 502   return (get_mode_sort(mode) == irms_reference);
 503 }
 504
 505 int
 506 mode_is_num (const ir_mode *mode)
 507 {
 508   ANNOUNCE();
 509   assert(mode);
 510   return (mode_is_int(mode) || mode_is_float(mode));
 511 }
 512
 513 int
 514 mode_is_numP (const ir_mode *mode)
 515 {
 516   ANNOUNCE();
 517   assert(mode);
 518   return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
 519 }
 520
 521 int
 522 mode_is_data (const ir_mode *mode)
 523 {
 524   ANNOUNCE();
 525   assert(mode);
 526   return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
 527 }
 528
 529 int
 530 mode_is_datab (const ir_mode *mode)
 531 {
 532   ANNOUNCE();
 533   assert(mode);
 534   return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
 535 }
 536
 537 int
 538 mode_is_dataM (const ir_mode *mode)
 539 {
 540   ANNOUNCE();
 541   assert(mode);
 542   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 543 }
 544 #ifdef MODE_ACCESS_DEFINES
 545 #  define mode_is_signed(mode) (mode)->sign
 546 #  define mode_is_float(mode) ((mode)->sort == irms_float_number)
 547 #  define mode_is_int(mode) ((mode)->sort == irms_int_number)
 548 #  define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
 549 #  define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
 550 #  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))
 551 #  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))
 552 #endif
 553 /* Returns true if sm can be converted to lm without loss. */
 554 int
 555 smaller_mode(const ir_mode *sm, const ir_mode *lm)
 556 {
 557   ANNOUNCE();
 558   assert(sm);
 559   assert(lm);
 560
 561   if (sm == lm) return 1;
 562
 563   switch(get_mode_sort(sm))
 564   {
 565     case irms_int_number:
 566       switch(get_mode_sort(lm))
 567       {
 568         case irms_int_number:
 569           /* integers are convertable if
 570            *   - both have the same sign and lm is the larger one
 571            *   - lm is the signed one and is at least two bits larger
 572            *     (one for the sign, one for the highest bit of sm)
 573            */
 574           if (mode_is_signed(sm))
 575           {
 576             if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 577               return 1;
 578           }
 579           else if (mode_is_signed(lm))
 580           {
 581             if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
 582               return 1;
 583           }
 584           else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
 585           {
 586             return 1;
 587           }
 588           break;
 589
 590         case irms_float_number:
 591           /* int to float works if the float is large enough */
 592           return 0;
 593
 594         default:
 595           break;
 596       }
 597       break;
 598
 599     case irms_float_number:
 600       /* XXX currently only the three standard 32,64,80 bit floats
 601        * are supported which can safely be converted */
 602       if ( (get_mode_sort(lm) == irms_float_number)
 603            && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 604          return 1;
 605       break;
 606
 607     case irms_reference:
 608        /* do exist machines out there with different pointer lenghts ?*/
 609       return 0;
 610
 611     default:
 612       break;
 613   }
 614
 615   /* else */
 616   return 0;
 617 }
 618
 619 /* ** initialization ** */
 620 void
 621 init_mode (void)
 622 {
 623   ir_mode newmode;
 624   ANNOUNCE();
 625   /* init flexible array */
 626
 627   obstack_init(&modes);
 628
 629   num_modes  =  0;
 630   /* initialize predefined modes */
 631
 632   /* Internal Modes */
 633   newmode.arithmetic = irma_none;
 634   newmode.size    = 0;
 635   newmode.align   = 0;
 636   newmode.sign    = 0;
 637   newmode.tv_priv = NULL;
 638
 639   /* Control Flow Modes*/
 640   newmode.sort    = irms_control_flow;
 641
 642   /* Basic Block */
 643   newmode.name    = id_from_str("BB", 2);
 644   newmode.code    = irm_BB;
 645
 646   mode_BB = register_mode(&newmode);
 647
 648 /* eXecution */
 649   newmode.name    = id_from_str("X", 1);
 650   newmode.code    = irm_X;
 651
 652   mode_X = register_mode(&newmode);
 653
 654   /* Memory Modes */
 655   newmode.sort    = irms_memory;
 656
 657   /* Memory */
 658   newmode.name    = id_from_str("M", 1);
 659   newmode.code    = irm_M;
 660
 661   mode_M = register_mode(&newmode);
 662
 663   /* Auxiliary Modes */
 664   newmode.sort    = irms_auxiliary,
 665
 666   /* Tuple */
 667   newmode.name    = id_from_str("T", 1);
 668   newmode.code    = irm_T;
 669
 670   mode_T = register_mode(&newmode);
 671
 672   /* ANY */
 673   newmode.name    = id_from_str("ANY", 3);
 674   newmode.code    = irm_ANY;
 675
 676   mode_ANY = register_mode(&newmode);
 677
 678   /* BAD */
 679   newmode.name    = id_from_str("BAD", 3);
 680   newmode.code    = irm_BAD;
 681
 682   mode_BAD = register_mode(&newmode);
 683
 684   /* Internal Boolean Modes */
 685   newmode.sort    = irms_internal_boolean;
 686
 687   /* boolean */
 688   newmode.name    = id_from_str("b", 1);
 689   newmode.code    = irm_b;
 690
 691   mode_b = register_mode(&newmode);
 692
 693 /* Data Modes */
 694
 695   /* Float Number Modes */
 696   newmode.sort    = irms_float_number;
 697   newmode.arithmetic = irma_ieee754;
 698
 699   /* float */
 700   newmode.name    = id_from_str("F", 1);
 701   newmode.code    = irm_F;
 702   newmode.sign    = 1;
 703   newmode.align   = 4;
 704   newmode.size    = 32;
 705
 706   mode_F = register_mode(&newmode);
 707
 708   /* double */
 709   newmode.name    = id_from_str("D", 1);
 710   newmode.code    = irm_D;
 711   newmode.sign    = 1;
 712   newmode.align   = 4;
 713   newmode.size    = 64;
 714
 715   mode_D = register_mode(&newmode);
 716
 717   /* extended */
 718   newmode.name    = id_from_str("E", 1);
 719   newmode.code    = irm_E;
 720   newmode.sign    = 1;
 721   newmode.align   = 4;
 722   newmode.size    = 80;
 723
 724   mode_E = register_mode(&newmode);
 725
 726   /* Integer Number Modes */
 727   newmode.sort    = irms_int_number;
 728   newmode.arithmetic = irma_twos_complement;
 729
 730   /* signed byte */
 731   newmode.name    = id_from_str("Bs", 2);
 732   newmode.code    = irm_Bs;
 733   newmode.sign    = 1;
 734   newmode.align   = 1;
 735   newmode.size    = 8;
 736
 737   mode_Bs = register_mode(&newmode);
 738
 739   /* unsigned byte */
 740   newmode.name    = id_from_str("Bu", 2);
 741   newmode.code    = irm_Bu;
 742   newmode.arithmetic = irma_twos_complement;
 743   newmode.sign    = 0;
 744   newmode.align   = 1;
 745   newmode.size    = 8;
 746
 747   mode_Bu = register_mode(&newmode);
 748
 749   /* signed short integer */
 750   newmode.name    = id_from_str("Hs", 2);
 751   newmode.code    = irm_Hs;
 752   newmode.sign    = 1;
 753   newmode.align   = 2;
 754   newmode.size    = 16;
 755
 756   mode_Hs = register_mode(&newmode);
 757
 758   /* unsigned short integer */
 759   newmode.name    = id_from_str("Hu", 2);
 760   newmode.code    = irm_Hu;
 761   newmode.sign    = 0;
 762   newmode.align   = 2;
 763   newmode.size    = 16;
 764
 765   mode_Hu = register_mode(&newmode);
 766
 767   /* signed integer */
 768   newmode.name    = id_from_str("Is", 2);
 769   newmode.code    = irm_Is;
 770   newmode.sign    = 1;
 771   newmode.align   = 4;
 772   newmode.size    = 32;
 773
 774   mode_Is = register_mode(&newmode);
 775
 776   /* unsigned integer */
 777   newmode.name    = id_from_str("Iu", 2);
 778   newmode.code    = irm_Iu;
 779   newmode.sign    = 0;
 780   newmode.align   = 4;
 781   newmode.size    = 32;
 782
 783   mode_Iu = register_mode(&newmode);
 784
 785   /* signed long integer */
 786   newmode.name    = id_from_str("Ls", 2);
 787   newmode.code    = irm_Ls;
 788   newmode.sign    = 1;
 789   newmode.align   = 4;
 790   newmode.size    = 64;
 791
 792   mode_Ls = register_mode(&newmode);
 793
 794   /* unsigned long integer */
 795   newmode.name    = id_from_str("Lu", 2);
 796   newmode.code    = irm_Lu;
 797   newmode.sign    = 0;
 798   newmode.align   = 4;
 799   newmode.size    = 64;
 800
 801   mode_Lu = register_mode(&newmode);
 802
 803   /* Character Modes */
 804   newmode.sort    = irms_character;
 805   newmode.arithmetic = irma_none;
 806
 807   /* Character */
 808   newmode.name    = id_from_str("C", 1);
 809   newmode.code    = irm_C;
 810   newmode.sign    = 0;
 811   newmode.align   = 1;
 812   newmode.size    = 8;
 813
 814   mode_C = register_mode(&newmode);
 815
 816   /* Unicode character */
 817   newmode.name    = id_from_str("U", 1);
 818   newmode.code    = irm_U;
 819   newmode.sign    = 0;
 820   newmode.align   = 2;
 821   newmode.size    = 16;
 822
 823   mode_U = register_mode(&newmode);
 824
 825   /* Reference Modes */
 826   newmode.sort    = irms_reference;
 827   newmode.arithmetic = irma_twos_complement;
 828
 829   /* pointer */
 830   newmode.name    = id_from_str("P", 1);
 831   newmode.code    = irm_P;
 832   newmode.sign    = 0;
 833   newmode.align   = 4;
 834   newmode.size    = 32;
 835
 836   mode_P = register_mode(&newmode);
 837
 838   /* set the machine specific modes to the predifined ones */
 839   mode_P_mach = mode_P;
 840 }