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