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

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