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