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