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       (m->name == n->name) )
  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 /* ** Constructor ** */
 148 ir_mode *
 149 register_mode(ir_mode* new_mode)
 150 {
 151   ir_mode *mode;
 152
 153   ANNOUNCE();
 154   assert(new_mode);
 155
 156   /* first check if there already is a matching mode */
 157   mode = find_mode(new_mode);
 158   if (mode) return mode;
 159
 160   /* sanity checks */
 161   switch (new_mode->sort)
 162   {
 163     case auxiliary:
 164     case internal_boolean:
 165       assert(0 && "internal modes cannot be user defined");
 166       return NULL;
 167       break;
 168
 169     case float_number:
 170       assert(0 && "not yet implemented");
 171       return NULL;
 172       break;
 173
 174     case int_number:
 175     case reference:
 176     case character:
 177       break;
 178
 179     default:
 180       assert(0);
 181       return NULL;
 182   }
 183
 184   /* copy mode struct to modes array */
 185   ARR_EXTEND(ir_mode, modes, 1);
 186   ARR_EXTEND(tarval*, modes_min, 1);
 187   ARR_EXTEND(tarval*, modes_max, 1);
 188   ARR_EXTEND(tarval*, modes_null, 1);
 189   ARR_EXTEND(tarval*, modes_one, 1);
 190   mode = &modes[num_modes];
 191
 192   memcpy(mode, new_mode, sizeof(ir_mode));
 193   mode->code = num_modes;
 194   num_modes++;
 195
 196   set_mode_values(mode);
 197
 198   return mode;
 199 }
 200
 201 /* Functions for the direct access to all attributes of a ir_mode */
 202 #ifdef MODE_ACCESS_DEFINES
 203 #  undef get_mode_modecode
 204 #  undef get_mode_ident
 205 #  undef get_mode_name
 206 #  undef get_mode_sort
 207 #  undef get_mode_size_bits
 208 #  undef get_mode_align
 209 #  undef get_mode_sign
 210 #endif
 211
 212 modecode
 213 get_mode_modecode(ir_mode *mode)
 214 {
 215   ANNOUNCE();
 216   return mode->code;
 217 }
 218
 219 ident *
 220 get_mode_ident(ir_mode *mode)
 221 {
 222   ANNOUNCE();
 223   return mode->name;
 224 }
 225
 226 const char *
 227 get_mode_name(ir_mode *mode)
 228 {
 229   ANNOUNCE();
 230   return id_to_str(mode->name);
 231 }
 232
 233 mode_sort
 234 get_mode_sort(ir_mode* mode)
 235 {
 236   ANNOUNCE();
 237   return mode->sort;
 238 }
 239
 240 INLINE int
 241 get_mode_size_bits(ir_mode *mode)
 242 {
 243   ANNOUNCE();
 244   return mode->size;
 245 }
 246
 247 int get_mode_size_bytes(ir_mode *mode) {
 248   ANNOUNCE();
 249   int size = get_mode_size_bits(mode);
 250   if ((size % 8) != 0) return -1;
 251   return size / 8;
 252 }
 253
 254 int
 255 get_mode_align (ir_mode *mode)
 256 {
 257   ANNOUNCE();
 258   return mode->align;
 259 }
 260
 261 int
 262 get_mode_sign (ir_mode *mode)
 263 {
 264   ANNOUNCE();
 265   return mode->sign;
 266 }
 267
 268 #ifdef MODE_ACCESS_DEFINES
 269 #  define get_mode_modecode(mode) (mode)->code
 270 #  define get_mode_ident(mode) (mode)->name
 271 #  define get_mode_name(mode) id_to_str((mode)->name)
 272 #  define get_mode_sort(mode) (mode)->sort
 273 #  define get_mode_size_bits(mode) (mode)->size
 274 #  define get_mode_align(mode) (mode)->align
 275 #  define get_mode_sign(mode) (mode)->sign
 276 #endif
 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) == 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) == 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) == character || get_mode_sort(mode) == 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) == 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 == float_number)
 448 #  define mode_is_int(mode) ((mode)->sort == int_number)
 449 #  define mode_is_num(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number))
 450 #  define mode_is_data(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference))
 451 #  define mode_is_datab(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->sort == internal_boolean))
 452 #  define mode_is_dataM(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == 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 int_number:
 467       switch(get_mode_sort(lm))
 468       {
 469         case 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 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 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) == float_number)
 504            && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 505          return 1;
 506       break;
 507
 508     case 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 = auxiliary;
 538   mode_BB->sign = 0;
 539   mode_BB->tv_priv = NULL;
 540
 541   /* eXecution */
 542   mode_X = &modes[irm_X];
 543   mode_X->name = id_from_str("X", 1);
 544   mode_X->code = irm_X;
 545   mode_X->sort = auxiliary;
 546   mode_X->sign = 0;
 547   mode_X->tv_priv = NULL;
 548
 549   /* Memory */
 550   mode_M = &modes[irm_M];
 551   mode_M->name = id_from_str("M", 1);
 552   mode_M->code = irm_M;
 553   mode_M->sort = auxiliary;
 554   mode_M->sign = 0;
 555   mode_M->tv_priv = NULL;
 556
 557   /* Tuple */
 558   mode_T = &modes[irm_T];
 559   mode_T->name = id_from_str("T", 1);
 560   mode_T->code = irm_T;
 561   mode_T->sign = 0;
 562   mode_T->tv_priv = NULL;
 563
 564   /* boolean */
 565   mode_b = &modes[irm_b];
 566   mode_b->name = id_from_str("b", 1);
 567   mode_b->code = irm_b;
 568   mode_b->sort = internal_boolean;
 569   mode_b->sign = 0;
 570   mode_b->tv_priv = NULL;
 571
 572   /* float */
 573   mode_F = &modes[irm_F];
 574   mode_F->name = id_from_str("F", 1);
 575   mode_F->code = irm_F;
 576   mode_F->sort = float_number;
 577   mode_F->sign = 1;
 578   mode_F->align = 32;
 579   mode_F->size = 32;
 580   mode_F->tv_priv = NULL;
 581
 582   set_mode_values(mode_F);
 583
 584   /* double */
 585   mode_D = &modes[irm_D];
 586   mode_D->name = id_from_str("D", 1);
 587   mode_D->code = irm_D;
 588   mode_D->sort = float_number;
 589   mode_D->sign = 1;
 590   mode_D->align = 32;
 591   mode_D->size = 64;
 592   mode_D->tv_priv = NULL;
 593
 594   set_mode_values(mode_D);
 595
 596   /* extended */
 597   mode_E = &modes[irm_E];
 598   mode_E->name = id_from_str("E", 1);
 599   mode_E->code = irm_E;
 600   mode_E->sort = float_number;
 601   mode_E->sign = 1;
 602   mode_E->align = 32;
 603   mode_E->size = 80;
 604   mode_E->tv_priv = NULL;
 605
 606   set_mode_values(mode_E);
 607
 608   /* signed byte */
 609   mode_Bs = &modes[irm_Bs];
 610   mode_Bs->name = id_from_str("Bs", 2);
 611   mode_Bs->code = irm_Bs;
 612   mode_Bs->sort = int_number;
 613   mode_Bs->sign = 1;
 614   mode_Bs->align = 8;
 615   mode_Bs->size = 8;
 616   mode_Bs->tv_priv = NULL;
 617
 618   set_mode_values(mode_Bs);
 619
 620   /* unsigned byte */
 621   mode_Bu = &modes[irm_Bu];
 622   mode_Bu->name = id_from_str("Bu", 2);
 623   mode_Bu->code = irm_Bu;
 624   mode_Bu->sort = int_number;
 625   mode_Bu->sign = 0;
 626   mode_Bu->align = 8;
 627   mode_Bu->size = 8;
 628   mode_Bu->tv_priv = NULL;
 629
 630   set_mode_values(mode_Bu);
 631
 632   /* signed short integer */
 633   mode_Hs = &modes[irm_Hs];
 634   mode_Hs->name = id_from_str("Hs", 2);
 635   mode_Hs->code = irm_Hs;
 636   mode_Hs->sort = int_number;
 637   mode_Hs->sign = 1;
 638   mode_Hs->align = 16;
 639   mode_Hs->size = 16;
 640   mode_Hs->tv_priv = NULL;
 641
 642   set_mode_values(mode_Hs);
 643
 644   /* unsigned short integer */
 645   mode_Hu = &modes[irm_Hu];
 646   mode_Hu->name = id_from_str("Hu", 2);
 647   mode_Hu->code = irm_Hu;
 648   mode_Hu->sort = int_number;
 649   mode_Hu->sign = 0;
 650   mode_Hu->align = 16;
 651   mode_Hu->size = 16;
 652   mode_Hu->tv_priv = NULL;
 653
 654   set_mode_values(mode_Hu);
 655
 656   /* signed integer */
 657   mode_Is = &modes[irm_Is];
 658   mode_Is->name = id_from_str("Is", 2);
 659   mode_Is->code = irm_Is;
 660   mode_Is->sort = int_number;
 661   mode_Is->sign = 1;
 662   mode_Is->align = 32;
 663   mode_Is->size = 32;
 664   mode_Is->tv_priv = NULL;
 665
 666   set_mode_values(mode_Is);
 667
 668   /* unsigned integer */
 669   mode_Iu = &modes[irm_Iu];
 670   mode_Iu->name = id_from_str("Iu", 2);
 671   mode_Iu->code = irm_Iu;
 672   mode_Iu->sort = int_number;
 673   mode_Iu->sign = 0;
 674   mode_Iu->align = 32;
 675   mode_Iu->size = 32;
 676   mode_Iu->tv_priv = NULL;
 677
 678   set_mode_values(mode_Iu);
 679
 680   /* signed long integer */
 681   mode_Ls = &modes[irm_Ls];
 682   mode_Ls->name = id_from_str("Ls", 2);
 683   mode_Ls->code = irm_Ls;
 684   mode_Ls->sort = int_number;
 685   mode_Ls->sign = 1;
 686   mode_Ls->align = 32;
 687   mode_Ls->size = 64;
 688   mode_Ls->tv_priv = NULL;
 689
 690   set_mode_values(mode_Ls);
 691
 692   /* unsigned long integer */
 693   mode_Lu = &modes[irm_Lu];
 694   mode_Lu->name = id_from_str("Lu", 2);
 695   mode_Lu->code = irm_Lu;
 696   mode_Lu->sort = int_number;
 697   mode_Lu->sign = 0;
 698   mode_Lu->align = 32;
 699   mode_Lu->size = 64;
 700   mode_Lu->tv_priv = NULL;
 701
 702   set_mode_values(mode_Lu);
 703
 704   /* Character */
 705   mode_C = &modes[irm_C];
 706   mode_C->name = id_from_str("C", 1);
 707   mode_C->code = irm_C;
 708   mode_C->sort = character;
 709   mode_C->sign = 0;
 710   mode_C->align = 8;
 711   mode_C->size = 8;
 712   mode_C->tv_priv = NULL;
 713
 714   set_mode_values(mode_C);
 715
 716   /* Unicode character */
 717   mode_U = &modes[irm_U];
 718   mode_U->name = id_from_str("U", 1);
 719   mode_U->code = irm_U;
 720   mode_U->sort = character;
 721   mode_U->sign = 0;
 722   mode_U->align = 16;
 723   mode_U->size = 16;
 724   mode_U->tv_priv = NULL;
 725
 726   set_mode_values(mode_U);
 727
 728   /* pointer */
 729   mode_P = &modes[irm_P];
 730   mode_P->name = id_from_str("P", 1);
 731   mode_P->code = irm_P;
 732   mode_P->sort = reference;
 733   mode_P->sign = 0;
 734   mode_P->align = 32;
 735   mode_P->size = 32;
 736   mode_P->tv_priv = NULL;
 737
 738   num_modes = irm_max;
 739 }