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