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 od a ir_mode */
 202 modecode
 203 get_mode_modecode(ir_mode *mode)
 204 {
 205   ANNOUNCE();
 206   return mode->code;
 207 }
 208
 209 ident *
 210 get_mode_ident(ir_mode *mode)
 211 {
 212   ANNOUNCE();
 213   return mode->name;
 214 }
 215
 216 const char *
 217 get_mode_name(ir_mode *mode)
 218 {
 219   ANNOUNCE();
 220   return id_to_str(mode->name);
 221 }
 222
 223 mode_sort
 224 get_mode_sort(ir_mode* mode)
 225 {
 226   ANNOUNCE();
 227   return mode->sort;
 228 }
 229
 230 INLINE int
 231 get_mode_size_bits(ir_mode *mode)
 232 {
 233   ANNOUNCE();
 234   return mode->size;
 235 }
 236
 237 int get_mode_size_bytes(ir_mode *mode) {
 238   ANNOUNCE();
 239   int size = get_mode_size_bits(mode);
 240   if ((size % 8) != 0) return -1;
 241   return size / 8;
 242 }
 243
 244 int
 245 get_mode_align (ir_mode *mode)
 246 {
 247   ANNOUNCE();
 248   return mode->align;
 249 }
 250
 251 int
 252 get_mode_sign (ir_mode *mode)
 253 {
 254   ANNOUNCE();
 255   return mode->sign;
 256 }
 257
 258 tarval *
 259 get_mode_min (ir_mode *mode)
 260 {
 261   ANNOUNCE();
 262   assert(mode);
 263   assert(get_mode_modecode(mode) < num_modes);
 264   assert(mode_is_data(mode));
 265
 266   return modes_min[get_mode_modecode(mode)];
 267 }
 268
 269 tarval *
 270 get_mode_max (ir_mode *mode)
 271 {
 272   ANNOUNCE();
 273   assert(mode);
 274   assert(get_mode_modecode(mode) < num_modes);
 275   assert(mode_is_data(mode));
 276
 277   return modes_max[get_mode_modecode(mode)];
 278 }
 279
 280 tarval *
 281 get_mode_null (ir_mode *mode)
 282 {
 283   ANNOUNCE();
 284   assert(mode);
 285   assert(get_mode_modecode(mode) < num_modes);
 286   assert(mode_is_data(mode));
 287
 288   return modes_null[get_mode_modecode(mode)];
 289 }
 290
 291 tarval *
 292 get_mode_one (ir_mode *mode)
 293 {
 294   ANNOUNCE();
 295   assert(mode);
 296   assert(get_mode_modecode(mode) < num_modes);
 297   assert(mode_is_data(mode));
 298
 299   return modes_one[get_mode_modecode(mode)];
 300 }
 301
 302 tarval *
 303 get_mode_infinite(ir_mode *mode)
 304 {
 305   ANNOUNCE();
 306   assert(mode);
 307   assert(get_mode_modecode(mode) < num_modes);
 308   assert(mode_is_float(mode));
 309
 310   return get_tarval_inf(mode);
 311 }
 312
 313 tarval *
 314 get_mode_NAN(ir_mode *mode)
 315 {
 316   ANNOUNCE();
 317   assert(mode);
 318   assert(get_mode_modecode(mode) < num_modes);
 319   assert(mode_is_float(mode));
 320
 321   return get_tarval_nan(mode);
 322 }
 323
 324 /* Functions to check, whether a modecode is signed, float, int, num, data,
 325    datab or dataM. For more exact definitions read the corresponding pages
 326    in the firm documentation or the followingenumeration
 327
 328    The set of "float" is defined as:
 329    ---------------------------------
 330    float = {irm_F, irm_D, irm_E}
 331
 332    The set of "int" is defined as:
 333    -------------------------------
 334    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 335
 336    The set of "num" is defined as:
 337    -------------------------------
 338    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 339             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 340             = {float || int}
 341
 342    The set of "data" is defined as:
 343    -------------------------------
 344    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 345             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
 346             = {num || irm_C || irm_U || irm_P}
 347
 348    The set of "datab" is defined as:
 349    ---------------------------------
 350    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 351             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 352             = {data || irm_b }
 353
 354    The set of "dataM" is defined as:
 355    ---------------------------------
 356    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 357             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 358             = {data || irm_M}
 359 */
 360
 361 #ifdef MODE_ACCESS_DEFINES
 362 #  undef mode_is_signed
 363 #  undef mode_is_float
 364 #  undef mode_is_int
 365 #  undef mode_is_num
 366 #  undef mode_is_data
 367 #  undef mode_is_datab
 368 #  undef mode_is_dataM
 369 #endif
 370 int
 371 mode_is_signed (ir_mode *mode)
 372 {
 373   ANNOUNCE();
 374   assert(mode);
 375   return mode->sign;
 376 }
 377
 378 int
 379 mode_is_float (ir_mode *mode)
 380 {
 381   ANNOUNCE();
 382   assert(mode);
 383   return (get_mode_sort(mode) == float_number);
 384 }
 385
 386 int
 387 mode_is_int (ir_mode *mode)
 388 {
 389   ANNOUNCE();
 390   assert(mode);
 391   return (get_mode_sort(mode) == int_number);
 392 }
 393
 394 int
 395 mode_is_num (ir_mode *mode)
 396 {
 397   ANNOUNCE();
 398   assert(mode);
 399   return (mode_is_int(mode) || mode_is_float(mode));
 400 }
 401
 402 int
 403 mode_is_data (ir_mode *mode)
 404 {
 405   ANNOUNCE();
 406   assert(mode);
 407   return (mode_is_num(mode) || get_mode_sort(mode) == character || get_mode_sort(mode) == reference);
 408 }
 409
 410 int
 411 mode_is_datab (ir_mode *mode)
 412 {
 413   ANNOUNCE();
 414   assert(mode);
 415   return (mode_is_data(mode) || get_mode_sort(mode) == internal_boolean);
 416 }
 417
 418 int
 419 mode_is_dataM (ir_mode *mode)
 420 {
 421   ANNOUNCE();
 422   assert(mode);
 423   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 424 }
 425 #ifdef MODE_ACCESS_DEFINES
 426 #  define mode_is_signed(mode) (mode)->sign
 427 #  define mode_is_float(mode) ((mode)->sort == float_number)
 428 #  define mode_is_int(mode) ((mode)->sort == int_number)
 429 #  define mode_is_num(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number))
 430 #  define mode_is_data(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference))
 431 #  define mode_is_datab(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->sort == internal_boolean))
 432 #  define mode_is_dataM(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->code == irm_M))
 433 #endif
 434 /* Returns true if sm can be converted to lm without loss. */
 435 int
 436 smaller_mode(ir_mode *sm, ir_mode *lm)
 437 {
 438   ANNOUNCE();
 439   assert(sm);
 440   assert(lm);
 441
 442   if (sm == lm) return 1;
 443
 444   switch(get_mode_sort(sm))
 445   {
 446     case int_number:
 447       switch(get_mode_sort(lm))
 448       {
 449         case int_number:
 450           /* integers are convertable if
 451            *   - both have the same sign and lm is the larger one
 452            *   - lm is the signed one and is at least two bits larger
 453            *     (one for the sign, one for the highest bit of sm)
 454            */
 455           if (mode_is_signed(sm))
 456           {
 457             if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 458               return 1;
 459           }
 460           else if (mode_is_signed(lm))
 461           {
 462             if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
 463               return 1;
 464           }
 465           else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
 466           {
 467             return 1;
 468           }
 469           break;
 470
 471         case float_number:
 472           /* int to float works if the float is large enough */
 473           return 0;
 474
 475         default:
 476           break;
 477       }
 478       break;
 479
 480     case float_number:
 481       /* XXX currently only the three standard 32,64,80 bit floats
 482        * are supported which can safely be converted */
 483       if ( (get_mode_sort(lm) == float_number)
 484            && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 485          return 1;
 486       break;
 487
 488     case reference:
 489        /* do exist machines out there with different pointer lenghts ?*/
 490       return 0;
 491
 492     default:
 493       break;
 494   }
 495
 496   /* else */
 497   return 0;
 498 }
 499
 500 /* ** initialization ** */
 501 void
 502 init_mode (void)
 503 {
 504   ANNOUNCE();
 505   /* init flexible array */
 506   modes      = NEW_ARR_F(ir_mode, irm_max);
 507   modes_min  = NEW_ARR_F(tarval*, irm_max);
 508   modes_max  = NEW_ARR_F(tarval*, irm_max);
 509   modes_null = NEW_ARR_F(tarval*, irm_max);
 510   modes_one  = NEW_ARR_F(tarval*, irm_max);
 511
 512   /* initialize predefined modes */
 513   /* Basic Block */
 514   mode_BB = &modes[irm_BB];
 515   mode_BB->name = id_from_str("BB", 2);
 516   mode_BB->code = irm_BB;
 517   mode_BB->sort = auxiliary;
 518   mode_BB->sign = 0;
 519   mode_BB->tv_priv = NULL;
 520
 521   /* eXecution */
 522   mode_X = &modes[irm_X];
 523   mode_X->name = id_from_str("X", 1);
 524   mode_X->code = irm_X;
 525   mode_X->sort = auxiliary;
 526   mode_X->sign = 0;
 527   mode_X->tv_priv = NULL;
 528
 529   /* Memory */
 530   mode_M = &modes[irm_M];
 531   mode_M->name = id_from_str("M", 1);
 532   mode_M->code = irm_M;
 533   mode_M->sort = auxiliary;
 534   mode_M->sign = 0;
 535   mode_M->tv_priv = NULL;
 536
 537   /* Tuple */
 538   mode_T = &modes[irm_T];
 539   mode_T->name = id_from_str("T", 1);
 540   mode_T->code = irm_T;
 541   mode_T->sign = 0;
 542   mode_T->tv_priv = NULL;
 543
 544   /* boolean */
 545   mode_b = &modes[irm_b];
 546   mode_b->name = id_from_str("b", 1);
 547   mode_b->code = irm_b;
 548   mode_b->sort = internal_boolean;
 549   mode_b->sign = 0;
 550   mode_b->tv_priv = NULL;
 551
 552   /* float */
 553   mode_F = &modes[irm_F];
 554   mode_F->name = id_from_str("F", 1);
 555   mode_F->code = irm_F;
 556   mode_F->sort = float_number;
 557   mode_F->sign = 1;
 558   mode_F->align = 32;
 559   mode_F->size = 32;
 560   mode_F->tv_priv = NULL;
 561
 562   set_mode_values(mode_F);
 563
 564   /* double */
 565   mode_D = &modes[irm_D];
 566   mode_D->name = id_from_str("D", 1);
 567   mode_D->code = irm_D;
 568   mode_D->sort = float_number;
 569   mode_D->sign = 1;
 570   mode_D->align = 32;
 571   mode_D->size = 64;
 572   mode_D->tv_priv = NULL;
 573
 574   set_mode_values(mode_D);
 575
 576   /* extended */
 577   mode_E = &modes[irm_E];
 578   mode_E->name = id_from_str("E", 1);
 579   mode_E->code = irm_E;
 580   mode_E->sort = float_number;
 581   mode_E->sign = 1;
 582   mode_E->align = 32;
 583   mode_E->size = 80;
 584   mode_E->tv_priv = NULL;
 585
 586   set_mode_values(mode_E);
 587
 588   /* signed byte */
 589   mode_Bs = &modes[irm_Bs];
 590   mode_Bs->name = id_from_str("Bs", 2);
 591   mode_Bs->code = irm_Bs;
 592   mode_Bs->sort = int_number;
 593   mode_Bs->sign = 1;
 594   mode_Bs->align = 8;
 595   mode_Bs->size = 8;
 596   mode_Bs->tv_priv = NULL;
 597
 598   set_mode_values(mode_Bs);
 599
 600   /* unsigned byte */
 601   mode_Bu = &modes[irm_Bu];
 602   mode_Bu->name = id_from_str("Bu", 2);
 603   mode_Bu->code = irm_Bu;
 604   mode_Bu->sort = int_number;
 605   mode_Bu->sign = 0;
 606   mode_Bu->align = 8;
 607   mode_Bu->size = 8;
 608   mode_Bu->tv_priv = NULL;
 609
 610   set_mode_values(mode_Bu);
 611
 612   /* signed short integer */
 613   mode_Hs = &modes[irm_Hs];
 614   mode_Hs->name = id_from_str("Hs", 2);
 615   mode_Hs->code = irm_Hs;
 616   mode_Hs->sort = int_number;
 617   mode_Hs->sign = 1;
 618   mode_Hs->align = 16;
 619   mode_Hs->size = 16;
 620   mode_Hs->tv_priv = NULL;
 621
 622   set_mode_values(mode_Hs);
 623
 624   /* unsigned short integer */
 625   mode_Hu = &modes[irm_Hu];
 626   mode_Hu->name = id_from_str("Hu", 2);
 627   mode_Hu->code = irm_Hu;
 628   mode_Hu->sort = int_number;
 629   mode_Hu->sign = 0;
 630   mode_Hu->align = 16;
 631   mode_Hu->size = 16;
 632   mode_Hu->tv_priv = NULL;
 633
 634   set_mode_values(mode_Hu);
 635
 636   /* signed integer */
 637   mode_Is = &modes[irm_Is];
 638   mode_Is->name = id_from_str("Is", 2);
 639   mode_Is->code = irm_Is;
 640   mode_Is->sort = int_number;
 641   mode_Is->sign = 1;
 642   mode_Is->align = 32;
 643   mode_Is->size = 32;
 644   mode_Is->tv_priv = NULL;
 645
 646   set_mode_values(mode_Is);
 647
 648   /* unsigned integer */
 649   mode_Iu = &modes[irm_Iu];
 650   mode_Iu->name = id_from_str("Iu", 2);
 651   mode_Iu->code = irm_Iu;
 652   mode_Iu->sort = int_number;
 653   mode_Iu->sign = 0;
 654   mode_Iu->align = 32;
 655   mode_Iu->size = 32;
 656   mode_Iu->tv_priv = NULL;
 657
 658   set_mode_values(mode_Iu);
 659
 660   /* signed long integer */
 661   mode_Ls = &modes[irm_Ls];
 662   mode_Ls->name = id_from_str("Ls", 2);
 663   mode_Ls->code = irm_Ls;
 664   mode_Ls->sort = int_number;
 665   mode_Ls->sign = 1;
 666   mode_Ls->align = 32;
 667   mode_Ls->size = 64;
 668   mode_Ls->tv_priv = NULL;
 669
 670   set_mode_values(mode_Ls);
 671
 672   /* unsigned long integer */
 673   mode_Lu = &modes[irm_Lu];
 674   mode_Lu->name = id_from_str("Lu", 2);
 675   mode_Lu->code = irm_Lu;
 676   mode_Lu->sort = int_number;
 677   mode_Lu->sign = 0;
 678   mode_Lu->align = 32;
 679   mode_Lu->size = 64;
 680   mode_Lu->tv_priv = NULL;
 681
 682   set_mode_values(mode_Lu);
 683
 684   /* Character */
 685   mode_C = &modes[irm_C];
 686   mode_C->name = id_from_str("C", 1);
 687   mode_C->code = irm_C;
 688   mode_C->sort = character;
 689   mode_C->sign = 0;
 690   mode_C->align = 8;
 691   mode_C->size = 8;
 692   mode_C->tv_priv = NULL;
 693
 694   set_mode_values(mode_C);
 695
 696   /* Unicode character */
 697   mode_U = &modes[irm_U];
 698   mode_U->name = id_from_str("U", 1);
 699   mode_U->code = irm_U;
 700   mode_U->sort = character;
 701   mode_U->sign = 0;
 702   mode_U->align = 16;
 703   mode_U->size = 16;
 704   mode_U->tv_priv = NULL;
 705
 706   set_mode_values(mode_U);
 707
 708   /* pointer */
 709   mode_P = &modes[irm_P];
 710   mode_P->name = id_from_str("P", 1);
 711   mode_P->code = irm_P;
 712   mode_P->sort = reference;
 713   mode_P->sign = 0;
 714   mode_P->align = 32;
 715   mode_P->size = 32;
 716   mode_P->tv_priv = NULL;
 717
 718   num_modes = irm_max;
 719 }