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