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(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       (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() { ANNOUNCE(); return mode_T; }
 129 INLINE ir_mode *get_modeF() { ANNOUNCE(); return mode_F; }
 130 INLINE ir_mode *get_modeD() { ANNOUNCE(); return mode_D; }
 131 INLINE ir_mode *get_modeE() { ANNOUNCE(); return mode_E; }
 132 INLINE ir_mode *get_modeBs() { ANNOUNCE(); return mode_Bs; }
 133 INLINE ir_mode *get_modeBu() { ANNOUNCE(); return mode_Bu; }
 134 INLINE ir_mode *get_modeHs() { ANNOUNCE(); return mode_Hs; }
 135 INLINE ir_mode *get_modeHu() { ANNOUNCE(); return mode_Hu; }
 136 INLINE ir_mode *get_modeIs() { ANNOUNCE(); return mode_Is; }
 137 INLINE ir_mode *get_modeIu() { ANNOUNCE(); return mode_Iu; }
 138 INLINE ir_mode *get_modeLs() { ANNOUNCE(); return mode_Ls; }
 139 INLINE ir_mode *get_modeLu() { ANNOUNCE(); return mode_Lu; }
 140 INLINE ir_mode *get_modeC() { ANNOUNCE(); return mode_C; }
 141 INLINE ir_mode *get_modeU() { ANNOUNCE(); return mode_U; }
 142 INLINE ir_mode *get_modeb() { ANNOUNCE(); return mode_b; }
 143 INLINE ir_mode *get_modeP() { ANNOUNCE(); return mode_P; }
 144 INLINE ir_mode *get_modeX() { ANNOUNCE(); return mode_X; }
 145 INLINE ir_mode *get_modeM() { ANNOUNCE(); return mode_M; }
 146 INLINE ir_mode *get_modeBB() { 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, *res;
 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(ir_mode *mode)
 224 {
 225   ANNOUNCE();
 226   return mode->code;
 227 }
 228
 229 ident *
 230 get_mode_ident(ir_mode *mode)
 231 {
 232   ANNOUNCE();
 233   return mode->name;
 234 }
 235
 236 const char *
 237 get_mode_name(ir_mode *mode)
 238 {
 239   ANNOUNCE();
 240   return id_to_str(mode->name);
 241 }
 242
 243 mode_sort
 244 get_mode_sort(ir_mode* mode)
 245 {
 246   ANNOUNCE();
 247   return mode->sort;
 248 }
 249
 250 INLINE int
 251 get_mode_size_bits(ir_mode *mode)
 252 {
 253   ANNOUNCE();
 254   return mode->size;
 255 }
 256
 257 int get_mode_size_bytes(ir_mode *mode) {
 258   ANNOUNCE();
 259   int size = get_mode_size_bits(mode);
 260   if ((size % 8) != 0) return -1;
 261   return size / 8;
 262 }
 263
 264 int
 265 get_mode_align (ir_mode *mode)
 266 {
 267   ANNOUNCE();
 268   return mode->align;
 269 }
 270
 271 int
 272 get_mode_sign (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 (ir_mode *mode)
 392 {
 393   ANNOUNCE();
 394   assert(mode);
 395   return mode->sign;
 396 }
 397
 398 int
 399 mode_is_float (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 (ir_mode *mode)
 408 {
 409   ANNOUNCE();
 410   assert(mode);
 411   return (get_mode_sort(mode) == irms_int_number);
 412 }
 413
 414 int
 415 mode_is_num (ir_mode *mode)
 416 {
 417   ANNOUNCE();
 418   assert(mode);
 419   return (mode_is_int(mode) || mode_is_float(mode));
 420 }
 421
 422 int
 423 mode_is_data (ir_mode *mode)
 424 {
 425   ANNOUNCE();
 426   assert(mode);
 427   return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
 428 }
 429
 430 int
 431 mode_is_datab (ir_mode *mode)
 432 {
 433   ANNOUNCE();
 434   assert(mode);
 435   return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
 436 }
 437
 438 int
 439 mode_is_dataM (ir_mode *mode)
 440 {
 441   ANNOUNCE();
 442   assert(mode);
 443   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 444 }
 445 #ifdef MODE_ACCESS_DEFINES
 446 #  define mode_is_signed(mode) (mode)->sign
 447 #  define mode_is_float(mode) ((mode)->sort == irms_float_number)
 448 #  define mode_is_int(mode) ((mode)->sort == irms_int_number)
 449 #  define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
 450 #  define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
 451 #  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))
 452 #  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))
 453 #endif
 454 /* Returns true if sm can be converted to lm without loss. */
 455 int
 456 smaller_mode(ir_mode *sm, ir_mode *lm)
 457 {
 458   ANNOUNCE();
 459   assert(sm);
 460   assert(lm);
 461
 462   if (sm == lm) return 1;
 463
 464   switch(get_mode_sort(sm))
 465   {
 466     case irms_int_number:
 467       switch(get_mode_sort(lm))
 468       {
 469         case irms_int_number:
 470           /* integers are convertable if
 471            *   - both have the same sign and lm is the larger one
 472            *   - lm is the signed one and is at least two bits larger
 473            *     (one for the sign, one for the highest bit of sm)
 474            */
 475           if (mode_is_signed(sm))
 476           {
 477             if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 478               return 1;
 479           }
 480           else if (mode_is_signed(lm))
 481           {
 482             if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
 483               return 1;
 484           }
 485           else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
 486           {
 487             return 1;
 488           }
 489           break;
 490
 491         case irms_float_number:
 492           /* int to float works if the float is large enough */
 493           return 0;
 494
 495         default:
 496           break;
 497       }
 498       break;
 499
 500     case irms_float_number:
 501       /* XXX currently only the three standard 32,64,80 bit floats
 502        * are supported which can safely be converted */
 503       if ( (get_mode_sort(lm) == irms_float_number)
 504            && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 505          return 1;
 506       break;
 507
 508     case irms_reference:
 509        /* do exist machines out there with different pointer lenghts ?*/
 510       return 0;
 511
 512     default:
 513       break;
 514   }
 515
 516   /* else */
 517   return 0;
 518 }
 519
 520 /* ** initialization ** */
 521 void
 522 init_mode (void)
 523 {
 524   ANNOUNCE();
 525   /* init flexible array */
 526   modes      = NEW_ARR_F(ir_mode, irm_max);
 527   modes_min  = NEW_ARR_F(tarval*, irm_max);
 528   modes_max  = NEW_ARR_F(tarval*, irm_max);
 529   modes_null = NEW_ARR_F(tarval*, irm_max);
 530   modes_one  = NEW_ARR_F(tarval*, irm_max);
 531
 532   /* initialize predefined modes */
 533   /* Basic Block */
 534   mode_BB = &modes[irm_BB];
 535   mode_BB->name    = id_from_str("BB", 2);
 536   mode_BB->code    = irm_BB;
 537   mode_BB->sort    = irms_auxiliary;
 538   mode_BB->size    = 0;
 539   mode_BB->align   = 0;
 540   mode_BB->sign    = 0;
 541   mode_BB->tv_priv = NULL;
 542
 543   /* eXecution */
 544   mode_X = &modes[irm_X];
 545   mode_X->name    = id_from_str("X", 1);
 546   mode_X->code    = irm_X;
 547   mode_X->sort    = irms_auxiliary;
 548   mode_X->size    = 0;
 549   mode_X->align   = 0;
 550   mode_X->sign    = 0;
 551   mode_X->tv_priv = NULL;
 552
 553   /* Memory */
 554   mode_M = &modes[irm_M];
 555   mode_M->name    = id_from_str("M", 1);
 556   mode_M->code    = irm_M;
 557   mode_M->sort    = irms_auxiliary;
 558   mode_M->size    = 0;
 559   mode_M->align   = 0;
 560   mode_M->sign    = 0;
 561   mode_M->tv_priv = NULL;
 562
 563   /* Tuple */
 564   mode_T = &modes[irm_T];
 565   mode_T->name    = id_from_str("T", 1);
 566   mode_T->code    = irm_T;
 567   mode_T->sort    = irms_auxiliary,
 568   mode_T->size    = 0;
 569   mode_T->align   = 0;
 570   mode_T->sign    = 0;
 571   mode_T->tv_priv = NULL;
 572
 573   /* boolean */
 574   mode_b = &modes[irm_b];
 575   mode_b->name    = id_from_str("b", 1);
 576   mode_b->code    = irm_b;
 577   mode_b->sort    = irms_internal_boolean;
 578   mode_b->size    = 0;
 579   mode_b->align   = 0;
 580   mode_b->sign    = 0;
 581   mode_b->tv_priv = NULL;
 582
 583   /* float */
 584   mode_F = &modes[irm_F];
 585   mode_F->name    = id_from_str("F", 1);
 586   mode_F->code    = irm_F;
 587   mode_F->sort    = irms_float_number;
 588   mode_F->sign    = 1;
 589   mode_F->align   = 4;
 590   mode_F->size    = 32;
 591   mode_F->tv_priv = NULL;
 592
 593   set_mode_values(mode_F);
 594
 595   /* double */
 596   mode_D = &modes[irm_D];
 597   mode_D->name    = id_from_str("D", 1);
 598   mode_D->code    = irm_D;
 599   mode_D->sort    = irms_float_number;
 600   mode_D->sign    = 1;
 601   mode_D->align   = 4;
 602   mode_D->size    = 64;
 603   mode_D->tv_priv = NULL;
 604
 605   set_mode_values(mode_D);
 606
 607   /* extended */
 608   mode_E = &modes[irm_E];
 609   mode_E->name    = id_from_str("E", 1);
 610   mode_E->code    = irm_E;
 611   mode_E->sort    = irms_float_number;
 612   mode_E->sign    = 1;
 613   mode_E->align   = 4;
 614   mode_E->size    = 80;
 615   mode_E->tv_priv = NULL;
 616
 617   set_mode_values(mode_E);
 618
 619   /* signed byte */
 620   mode_Bs = &modes[irm_Bs];
 621   mode_Bs->name    = id_from_str("Bs", 2);
 622   mode_Bs->code    = irm_Bs;
 623   mode_Bs->sort    = irms_int_number;
 624   mode_Bs->sign    = 1;
 625   mode_Bs->align   = 1;
 626   mode_Bs->size    = 8;
 627   mode_Bs->tv_priv = NULL;
 628
 629   set_mode_values(mode_Bs);
 630
 631   /* unsigned byte */
 632   mode_Bu = &modes[irm_Bu];
 633   mode_Bu->name    = id_from_str("Bu", 2);
 634   mode_Bu->code    = irm_Bu;
 635   mode_Bu->sort    = irms_int_number;
 636   mode_Bu->sign    = 0;
 637   mode_Bu->align   = 1;
 638   mode_Bu->size    = 8;
 639   mode_Bu->tv_priv = NULL;
 640
 641   set_mode_values(mode_Bu);
 642
 643   /* signed short integer */
 644   mode_Hs = &modes[irm_Hs];
 645   mode_Hs->name    = id_from_str("Hs", 2);
 646   mode_Hs->code    = irm_Hs;
 647   mode_Hs->sort    = irms_int_number;
 648   mode_Hs->sign    = 1;
 649   mode_Hs->align   = 2;
 650   mode_Hs->size    = 16;
 651   mode_Hs->tv_priv = NULL;
 652
 653   set_mode_values(mode_Hs);
 654
 655   /* unsigned short integer */
 656   mode_Hu = &modes[irm_Hu];
 657   mode_Hu->name    = id_from_str("Hu", 2);
 658   mode_Hu->code    = irm_Hu;
 659   mode_Hu->sort    = irms_int_number;
 660   mode_Hu->sign    = 0;
 661   mode_Hu->align   = 2;
 662   mode_Hu->size    = 16;
 663   mode_Hu->tv_priv = NULL;
 664
 665   set_mode_values(mode_Hu);
 666
 667   /* signed integer */
 668   mode_Is = &modes[irm_Is];
 669   mode_Is->name    = id_from_str("Is", 2);
 670   mode_Is->code    = irm_Is;
 671   mode_Is->sort    = irms_int_number;
 672   mode_Is->sign    = 1;
 673   mode_Is->align   = 4;
 674   mode_Is->size    = 32;
 675   mode_Is->tv_priv = NULL;
 676
 677   set_mode_values(mode_Is);
 678
 679   /* unsigned integer */
 680   mode_Iu = &modes[irm_Iu];
 681   mode_Iu->name    = id_from_str("Iu", 2);
 682   mode_Iu->code    = irm_Iu;
 683   mode_Iu->sort    = irms_int_number;
 684   mode_Iu->sign    = 0;
 685   mode_Iu->align   = 4;
 686   mode_Iu->size    = 32;
 687   mode_Iu->tv_priv = NULL;
 688
 689   set_mode_values(mode_Iu);
 690
 691   /* signed long integer */
 692   mode_Ls = &modes[irm_Ls];
 693   mode_Ls->name    = id_from_str("Ls", 2);
 694   mode_Ls->code    = irm_Ls;
 695   mode_Ls->sort    = irms_int_number;
 696   mode_Ls->sign    = 1;
 697   mode_Ls->align   = 4;
 698   mode_Ls->size    = 64;
 699   mode_Ls->tv_priv = NULL;
 700
 701   set_mode_values(mode_Ls);
 702
 703   /* unsigned long integer */
 704   mode_Lu = &modes[irm_Lu];
 705   mode_Lu->name    = id_from_str("Lu", 2);
 706   mode_Lu->code    = irm_Lu;
 707   mode_Lu->sort    = irms_int_number;
 708   mode_Lu->sign    = 0;
 709   mode_Lu->align   = 4;
 710   mode_Lu->size    = 64;
 711   mode_Lu->tv_priv = NULL;
 712
 713   set_mode_values(mode_Lu);
 714
 715   /* Character */
 716   mode_C = &modes[irm_C];
 717   mode_C->name    = id_from_str("C", 1);
 718   mode_C->code    = irm_C;
 719   mode_C->sort    = irms_character;
 720   mode_C->sign    = 0;
 721   mode_C->align   = 1;
 722   mode_C->size    = 8;
 723   mode_C->tv_priv = NULL;
 724
 725   set_mode_values(mode_C);
 726
 727   /* Unicode character */
 728   mode_U = &modes[irm_U];
 729   mode_U->name    = id_from_str("U", 1);
 730   mode_U->code    = irm_U;
 731   mode_U->sort    = irms_character;
 732   mode_U->sign    = 0;
 733   mode_U->align   = 2;
 734   mode_U->size    = 16;
 735   mode_U->tv_priv = NULL;
 736
 737   set_mode_values(mode_U);
 738
 739   /* pointer */
 740   mode_P = &modes[irm_P];
 741   mode_P->name    = id_from_str("P", 1);
 742   mode_P->code    = irm_P;
 743   mode_P->sort    = irms_reference;
 744   mode_P->sign    = 0;
 745   mode_P->align   = 4;
 746   mode_P->size    = 32;
 747   mode_P->tv_priv = NULL;
 748
 749   num_modes = irm_max;
 750 }