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

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