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