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 ir_mode *mode_P_mach;
 160
 161 /* * *
 162  * functions defined in irmode.h
 163  * * */
 164
 165 /* JNI access functions */
 166 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
 167 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
 168 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
 169 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
 170 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
 171 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
 172 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
 173 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
 174 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
 175 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
 176 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
 177 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
 178 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
 179 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
 180 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
 181 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
 182 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
 183 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
 184 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
 185 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
 186 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
 187
 188
 189 ir_mode *get_modeP_mach(void)  { ANNOUNCE(); return mode_P_mach; }
 190 void     set_modeP_mach(ir_mode *p) {
 191   ANNOUNCE();
 192   assert(mode_is_reference(p));
 193   mode_P_mach = p;
 194  }
 195
 196 /**
 197  * Registers a new mode if not defined yet, else returns
 198  * the "equivalent" one.
 199  */
 200 static ir_mode *register_mode(const ir_mode* new_mode)
 201 {
 202   ir_mode *mode = NULL;
 203
 204   ANNOUNCE();
 205   assert(new_mode);
 206
 207   /* copy mode struct to modes array */
 208   mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
 209
 210   mode->kind = k_ir_mode;
 211   if(num_modes>=irm_max) mode->code = num_modes;
 212   num_modes++;
 213
 214   set_mode_values(mode);
 215
 216   return mode;
 217 }
 218
 219 /*
 220  * Creates a new mode.
 221  */
 222 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign, mode_arithmetic arithmetic )
 223 {
 224   ir_mode mode_tmpl;
 225   ir_mode *mode;
 226
 227   /* sanity checks */
 228   switch (sort)
 229   {
 230     case irms_auxiliary:
 231     case irms_control_flow:
 232     case irms_memory:
 233     case irms_internal_boolean:
 234       assert(0 && "internal modes cannot be user defined");
 235       return NULL;
 236       break;
 237
 238     case irms_float_number:
 239       assert(0 && "not yet implemented");
 240       return NULL;
 241       break;
 242
 243     case irms_int_number:
 244     case irms_reference:
 245     case irms_character:
 246       break;
 247   }
 248   mode_tmpl.name        = new_id_from_str(name);
 249   mode_tmpl.sort        = sort;
 250   mode_tmpl.size        = bit_size;
 251   mode_tmpl.align       = align;
 252   mode_tmpl.sign        = sign ? 1 : 0;
 253   mode_tmpl.arithmetic  = arithmetic;
 254   mode_tmpl.tv_priv     = NULL;
 255
 256   /* first check if there already is a matching mode */
 257   mode = find_mode(&mode_tmpl);
 258   if (mode)
 259   {
 260     return mode;
 261   }
 262   else
 263   {
 264     return register_mode(&mode_tmpl);
 265   }
 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 id_to_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_data
 461 #  undef mode_is_datab
 462 #  undef mode_is_dataM
 463 #endif
 464 int
 465 mode_is_signed (const ir_mode *mode)
 466 {
 467   ANNOUNCE();
 468   assert(mode);
 469   return mode->sign;
 470 }
 471
 472 int
 473 mode_is_float (const ir_mode *mode)
 474 {
 475   ANNOUNCE();
 476   assert(mode);
 477   return (get_mode_sort(mode) == irms_float_number);
 478 }
 479
 480 int
 481 mode_is_int (const ir_mode *mode)
 482 {
 483   ANNOUNCE();
 484   assert(mode);
 485   return (get_mode_sort(mode) == irms_int_number);
 486 }
 487
 488 int mode_is_character (const ir_mode *mode)
 489 {
 490   ANNOUNCE();
 491   assert(mode);
 492   return (get_mode_sort(mode) == irms_character);
 493 }
 494
 495 int mode_is_reference (const ir_mode *mode)
 496 {
 497   ANNOUNCE();
 498   assert(mode);
 499   return (get_mode_sort(mode) == irms_reference);
 500 }
 501
 502 int
 503 mode_is_num (const ir_mode *mode)
 504 {
 505   ANNOUNCE();
 506   assert(mode);
 507   return (mode_is_int(mode) || mode_is_float(mode));
 508 }
 509
 510 int
 511 mode_is_data (const ir_mode *mode)
 512 {
 513   ANNOUNCE();
 514   assert(mode);
 515   return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
 516 }
 517
 518 int
 519 mode_is_datab (const ir_mode *mode)
 520 {
 521   ANNOUNCE();
 522   assert(mode);
 523   return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
 524 }
 525
 526 int
 527 mode_is_dataM (const ir_mode *mode)
 528 {
 529   ANNOUNCE();
 530   assert(mode);
 531   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 532 }
 533 #ifdef MODE_ACCESS_DEFINES
 534 #  define mode_is_signed(mode) (mode)->sign
 535 #  define mode_is_float(mode) ((mode)->sort == irms_float_number)
 536 #  define mode_is_int(mode) ((mode)->sort == irms_int_number)
 537 #  define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
 538 #  define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
 539 #  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))
 540 #  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))
 541 #endif
 542 /* Returns true if sm can be converted to lm without loss. */
 543 int
 544 smaller_mode(const ir_mode *sm, const ir_mode *lm)
 545 {
 546   ANNOUNCE();
 547   assert(sm);
 548   assert(lm);
 549
 550   if (sm == lm) return 1;
 551
 552   switch(get_mode_sort(sm))
 553   {
 554     case irms_int_number:
 555       switch(get_mode_sort(lm))
 556       {
 557         case irms_int_number:
 558           /* integers are convertable if
 559            *   - both have the same sign and lm is the larger one
 560            *   - lm is the signed one and is at least two bits larger
 561            *     (one for the sign, one for the highest bit of sm)
 562            */
 563           if (mode_is_signed(sm))
 564           {
 565             if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 566               return 1;
 567           }
 568           else if (mode_is_signed(lm))
 569           {
 570             if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
 571               return 1;
 572           }
 573           else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
 574           {
 575             return 1;
 576           }
 577           break;
 578
 579         case irms_float_number:
 580           /* int to float works if the float is large enough */
 581           return 0;
 582
 583         default:
 584           break;
 585       }
 586       break;
 587
 588     case irms_float_number:
 589       /* XXX currently only the three standard 32,64,80 bit floats
 590        * are supported which can safely be converted */
 591       if ( (get_mode_sort(lm) == irms_float_number)
 592            && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 593          return 1;
 594       break;
 595
 596     case irms_reference:
 597        /* do exist machines out there with different pointer lenghts ?*/
 598       return 0;
 599
 600     default:
 601       break;
 602   }
 603
 604   /* else */
 605   return 0;
 606 }
 607
 608 /* ** initialization ** */
 609 void
 610 init_mode (void)
 611 {
 612   ir_mode newmode;
 613   ANNOUNCE();
 614   /* init flexible array */
 615
 616   obstack_init(&modes);
 617
 618   num_modes  =  0;
 619   /* initialize predefined modes */
 620
 621   /* Internal Modes */
 622   newmode.arithmetic = irma_none;
 623   newmode.size    = 0;
 624   newmode.align   = 0;
 625   newmode.sign    = 0;
 626   newmode.tv_priv = NULL;
 627
 628   /* Control Flow Modes*/
 629   newmode.sort    = irms_control_flow;
 630
 631   /* Basic Block */
 632   newmode.name    = id_from_str("BB", 2);
 633   newmode.code    = irm_BB;
 634
 635   mode_BB = register_mode(&newmode);
 636
 637 /* eXecution */
 638   newmode.name    = id_from_str("X", 1);
 639   newmode.code    = irm_X;
 640
 641   mode_X = register_mode(&newmode);
 642
 643   /* Memory Modes */
 644   newmode.sort    = irms_memory;
 645
 646   /* Memory */
 647   newmode.name    = id_from_str("M", 1);
 648   newmode.code    = irm_M;
 649
 650   mode_M = register_mode(&newmode);
 651
 652   /* Auxiliary Modes */
 653   newmode.sort    = irms_auxiliary,
 654
 655   /* Tuple */
 656   newmode.name    = id_from_str("T", 1);
 657   newmode.code    = irm_T;
 658
 659   mode_T = register_mode(&newmode);
 660
 661   /* ANY */
 662   newmode.name    = id_from_str("ANY", 3);
 663   newmode.code    = irm_ANY;
 664
 665   mode_ANY = register_mode(&newmode);
 666
 667   /* BAD */
 668   newmode.name    = id_from_str("BAD", 3);
 669   newmode.code    = irm_BAD;
 670
 671   mode_BAD = register_mode(&newmode);
 672
 673   /* Internal Boolean Modes */
 674   newmode.sort    = irms_internal_boolean;
 675
 676   /* boolean */
 677   newmode.name    = id_from_str("b", 1);
 678   newmode.code    = irm_b;
 679
 680   mode_b = register_mode(&newmode);
 681
 682 /* Data Modes */
 683
 684   /* Float Number Modes */
 685   newmode.sort    = irms_float_number;
 686   newmode.arithmetic = irma_ieee754;
 687
 688   /* float */
 689   newmode.name    = id_from_str("F", 1);
 690   newmode.code    = irm_F;
 691   newmode.sign    = 1;
 692   newmode.align   = 4;
 693   newmode.size    = 32;
 694
 695   mode_F = register_mode(&newmode);
 696
 697   /* double */
 698   newmode.name    = id_from_str("D", 1);
 699   newmode.code    = irm_D;
 700   newmode.sign    = 1;
 701   newmode.align   = 4;
 702   newmode.size    = 64;
 703
 704   mode_D = register_mode(&newmode);
 705
 706   /* extended */
 707   newmode.name    = id_from_str("E", 1);
 708   newmode.code    = irm_E;
 709   newmode.sign    = 1;
 710   newmode.align   = 4;
 711   newmode.size    = 80;
 712
 713   mode_E = register_mode(&newmode);
 714
 715   /* Integer Number Modes */
 716   newmode.sort    = irms_int_number;
 717   newmode.arithmetic = irma_twos_complement;
 718
 719   /* signed byte */
 720   newmode.name    = id_from_str("Bs", 2);
 721   newmode.code    = irm_Bs;
 722   newmode.sign    = 1;
 723   newmode.align   = 1;
 724   newmode.size    = 8;
 725
 726   mode_Bs = register_mode(&newmode);
 727
 728   /* unsigned byte */
 729   newmode.name    = id_from_str("Bu", 2);
 730   newmode.code    = irm_Bu;
 731   newmode.arithmetic = irma_twos_complement;
 732   newmode.sign    = 0;
 733   newmode.align   = 1;
 734   newmode.size    = 8;
 735
 736   mode_Bu = register_mode(&newmode);
 737
 738   /* signed short integer */
 739   newmode.name    = id_from_str("Hs", 2);
 740   newmode.code    = irm_Hs;
 741   newmode.sign    = 1;
 742   newmode.align   = 2;
 743   newmode.size    = 16;
 744
 745   mode_Hs = register_mode(&newmode);
 746
 747   /* unsigned short integer */
 748   newmode.name    = id_from_str("Hu", 2);
 749   newmode.code    = irm_Hu;
 750   newmode.sign    = 0;
 751   newmode.align   = 2;
 752   newmode.size    = 16;
 753
 754   mode_Hu = register_mode(&newmode);
 755
 756   /* signed integer */
 757   newmode.name    = id_from_str("Is", 2);
 758   newmode.code    = irm_Is;
 759   newmode.sign    = 1;
 760   newmode.align   = 4;
 761   newmode.size    = 32;
 762
 763   mode_Is = register_mode(&newmode);
 764
 765   /* unsigned integer */
 766   newmode.name    = id_from_str("Iu", 2);
 767   newmode.code    = irm_Iu;
 768   newmode.sign    = 0;
 769   newmode.align   = 4;
 770   newmode.size    = 32;
 771
 772   mode_Iu = register_mode(&newmode);
 773
 774   /* signed long integer */
 775   newmode.name    = id_from_str("Ls", 2);
 776   newmode.code    = irm_Ls;
 777   newmode.sign    = 1;
 778   newmode.align   = 4;
 779   newmode.size    = 64;
 780
 781   mode_Ls = register_mode(&newmode);
 782
 783   /* unsigned long integer */
 784   newmode.name    = id_from_str("Lu", 2);
 785   newmode.code    = irm_Lu;
 786   newmode.sign    = 0;
 787   newmode.align   = 4;
 788   newmode.size    = 64;
 789
 790   mode_Lu = register_mode(&newmode);
 791
 792   /* Character Modes */
 793   newmode.sort    = irms_character;
 794   newmode.arithmetic = irma_none;
 795
 796   /* Character */
 797   newmode.name    = id_from_str("C", 1);
 798   newmode.code    = irm_C;
 799   newmode.sign    = 0;
 800   newmode.align   = 1;
 801   newmode.size    = 8;
 802
 803   mode_C = register_mode(&newmode);
 804
 805   /* Unicode character */
 806   newmode.name    = id_from_str("U", 1);
 807   newmode.code    = irm_U;
 808   newmode.sign    = 0;
 809   newmode.align   = 2;
 810   newmode.size    = 16;
 811
 812   mode_U = register_mode(&newmode);
 813
 814   /* Reference Modes */
 815   newmode.sort    = irms_reference;
 816   newmode.arithmetic = irma_twos_complement;
 817
 818   /* pointer */
 819   newmode.name    = id_from_str("P", 1);
 820   newmode.code    = irm_P;
 821   newmode.sign    = 0;
 822   newmode.align   = 4;
 823   newmode.size    = 32;
 824
 825   mode_P = register_mode(&newmode);
 826 }