nsz Git - libfirm/blob - ir/ir/irmode.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/ir/irmode.c
   4  * Purpose:     Data modes of operations.
   5  * Author:      Martin Trapp, Christian Schaefer
   6  * Modified by: Goetz Lindenmaier, Mathias Heil
   7  * Created:
   8  * CVS-ID:      $Id$
   9  * Copyright:   (c) 1998-2003 Universität Karlsruhe
  10  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  11  */
  12
  13
  14 #ifdef HAVE_CONFIG_H
  15 # include <config.h>
  16 #endif
  17
  18 # include <stdlib.h>
  19 # include <stddef.h>
  20 # include <string.h>
  21 # include <stdbool.h>
  22
  23 # include "irmode_t.h"
  24 # include "ident.h"
  25 # include "tv.h"
  26 # include "obst.h"
  27
  28 #if 0
  29 static long long count = 0;
  30 #  define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
  31 #else
  32 #  define ANNOUNCE() ((void)0)
  33 #endif
  34
  35 /* * *
  36  * local values
  37  * * */
  38
  39
  40 /** dynamic array to hold all modes */
  41 static struct obstack modes;
  42
  43 /** number of defined modes */
  44 static int num_modes;
  45
  46 /* * *
  47  * local functions
  48  * * */
  49
  50 /**
  51  * Compare modes that don't need to have their code field
  52  * correctly set
  53  *
  54  * TODO: Add other fields
  55  **/
  56 INLINE static int modes_are_equal(const ir_mode *m, const ir_mode *n)
  57 {
  58   if (m == n) return 1;
  59   if (m->sort == n->sort &&
  60       m->arithmetic == n->arithmetic &&
  61       m->size == n->size &&
  62       m->align == n->align &&
  63       m->sign == n->sign  &&
  64       m->modulo_shift == n->modulo_shift)
  65     return 1;
  66
  67   return 0;
  68 }
  69
  70 /*
  71  * calculates the next obstack address
  72  */
  73 static void *next_obstack_adr(struct obstack *o, void *p, size_t s)
  74 {
  75   PTR_INT_TYPE adr = __PTR_TO_INT((char *)p);
  76   int mask = obstack_alignment_mask(o);
  77
  78   adr += s + o->alignment_mask;
  79
  80   return __INT_TO_PTR(adr & ~o->alignment_mask);
  81 }
  82
  83 /**
  84  * searches the modes obstack for the given mode and returns
  85  * a pointer on an equal mode already in the array, NULL if
  86  * none found
  87  */
  88 static ir_mode *find_mode(const ir_mode *m)
  89 {
  90   ir_mode *n, *nn;
  91   struct _obstack_chunk *p;
  92
  93   p  = modes.chunk;
  94   n  = (ir_mode *)p->contents;
  95   nn = next_obstack_adr(&modes, n, sizeof(*n));
  96   for (; (char *)nn <= modes.next_free;) {
  97     assert(is_mode(n));
  98     if (modes_are_equal(n, m))
  99       return n;
 100
 101     n  = nn;
 102     nn = next_obstack_adr(&modes, n, sizeof(*n));
 103   }
 104
 105   for (p = p->prev; p; p = p->prev) {
 106     n  = (ir_mode *)p->contents;
 107     nn = next_obstack_adr(&modes, n, sizeof(*n));
 108     for (; (char *)nn < p->limit;) {
 109       assert(is_mode(n));
 110       if (modes_are_equal(n, m))
 111         return n;
 112
 113       n  = nn;
 114       nn = next_obstack_adr(&modes, n, sizeof(*n));
 115     }
 116   }
 117
 118   return NULL;
 119 }
 120
 121 /**
 122  * sets special values of modes
 123  */
 124 static void set_mode_values(ir_mode* mode)
 125 {
 126   switch (get_mode_sort(mode))
 127   {
 128     case irms_character:
 129     case irms_int_number:
 130     case irms_float_number:
 131       mode->min = get_tarval_min(mode);
 132       mode->max = get_tarval_max(mode);
 133       mode->null = get_tarval_null(mode);
 134       mode->one = get_tarval_one(mode);
 135       break;
 136
 137     case irms_internal_boolean:
 138       mode->min = tarval_b_false;
 139       mode->max = tarval_b_true;
 140       mode->null = tarval_b_false;
 141       mode->one = tarval_b_true;
 142       break;
 143
 144     case irms_reference:
 145       mode->min = tarval_bad;
 146       mode->max = tarval_bad;
 147       mode->null = (get_mode_modecode(mode) == irm_P) ? tarval_P_void : tarval_bad;
 148       mode->one = tarval_bad;
 149       break;
 150
 151     case irms_auxiliary:
 152     case irms_memory:
 153     case irms_control_flow:
 154       mode->min = tarval_bad;
 155       mode->max = tarval_bad;
 156       mode->null = tarval_bad;
 157       mode->one = tarval_bad;
 158       break;
 159   }
 160 }
 161
 162 /* * *
 163  * globals defined in irmode.h
 164  * * */
 165
 166 /* --- Predefined modes --- */
 167
 168 /* FIRM internal modes: */
 169 ir_mode *mode_T;
 170 ir_mode *mode_X;
 171 ir_mode *mode_M;
 172 ir_mode *mode_BB;
 173 ir_mode *mode_ANY;
 174 ir_mode *mode_BAD;
 175
 176 /* predefined numerical modes: */
 177 ir_mode *mode_F;    /* float */
 178 ir_mode *mode_D;    /* double */
 179 ir_mode *mode_E;    /* long double */
 180
 181 ir_mode *mode_Bs;   /* integral values, signed and unsigned */
 182 ir_mode *mode_Bu;   /* 8 bit */
 183 ir_mode *mode_Hs;   /* 16 bit */
 184 ir_mode *mode_Hu;
 185 ir_mode *mode_Is;   /* 32 bit */
 186 ir_mode *mode_Iu;
 187 ir_mode *mode_Ls;   /* 64 bit */
 188 ir_mode *mode_Lu;
 189
 190 ir_mode *mode_C;
 191 ir_mode *mode_U;
 192 ir_mode *mode_b;
 193 ir_mode *mode_P;
 194
 195 /* machine specific modes */
 196 ir_mode *mode_P_mach;   /* machine specific pointer mode */
 197
 198 /* * *
 199  * functions defined in irmode.h
 200  * * */
 201
 202 /* JNI access functions */
 203 INLINE ir_mode *get_modeT(void) { ANNOUNCE(); return mode_T; }
 204 INLINE ir_mode *get_modeF(void) { ANNOUNCE(); return mode_F; }
 205 INLINE ir_mode *get_modeD(void) { ANNOUNCE(); return mode_D; }
 206 INLINE ir_mode *get_modeE(void) { ANNOUNCE(); return mode_E; }
 207 INLINE ir_mode *get_modeBs(void) { ANNOUNCE(); return mode_Bs; }
 208 INLINE ir_mode *get_modeBu(void) { ANNOUNCE(); return mode_Bu; }
 209 INLINE ir_mode *get_modeHs(void) { ANNOUNCE(); return mode_Hs; }
 210 INLINE ir_mode *get_modeHu(void) { ANNOUNCE(); return mode_Hu; }
 211 INLINE ir_mode *get_modeIs(void) { ANNOUNCE(); return mode_Is; }
 212 INLINE ir_mode *get_modeIu(void) { ANNOUNCE(); return mode_Iu; }
 213 INLINE ir_mode *get_modeLs(void) { ANNOUNCE(); return mode_Ls; }
 214 INLINE ir_mode *get_modeLu(void) { ANNOUNCE(); return mode_Lu; }
 215 INLINE ir_mode *get_modeC(void) { ANNOUNCE(); return mode_C; }
 216 INLINE ir_mode *get_modeU(void) { ANNOUNCE(); return mode_U; }
 217 INLINE ir_mode *get_modeb(void) { ANNOUNCE(); return mode_b; }
 218 INLINE ir_mode *get_modeP(void) { ANNOUNCE(); return mode_P; }
 219 INLINE ir_mode *get_modeX(void) { ANNOUNCE(); return mode_X; }
 220 INLINE ir_mode *get_modeM(void) { ANNOUNCE(); return mode_M; }
 221 INLINE ir_mode *get_modeBB(void) { ANNOUNCE(); return mode_BB; }
 222 INLINE ir_mode *get_modeANY(void) { ANNOUNCE(); return mode_ANY; }
 223 INLINE ir_mode *get_modeBAD(void) { ANNOUNCE(); return mode_BAD; }
 224
 225
 226 ir_mode *get_modeP_mach(void)  { ANNOUNCE(); return mode_P_mach; }
 227 void     set_modeP_mach(ir_mode *p) {
 228   ANNOUNCE();
 229   assert(mode_is_reference(p));
 230   mode_P_mach = p;
 231  }
 232
 233 /**
 234  * Registers a new mode if not defined yet, else returns
 235  * the "equivalent" one.
 236  */
 237 static ir_mode *register_mode(const ir_mode* new_mode)
 238 {
 239   ir_mode *mode = NULL;
 240
 241   ANNOUNCE();
 242   assert(new_mode);
 243
 244   /* copy mode struct to modes array */
 245   mode=(ir_mode*) obstack_copy(&modes, new_mode, sizeof(ir_mode));
 246
 247   mode->kind = k_ir_mode;
 248   if(num_modes>=irm_max) mode->code = num_modes;
 249   num_modes++;
 250
 251   set_mode_values(mode);
 252
 253   return mode;
 254 }
 255
 256 /*
 257  * Creates a new mode.
 258  */
 259 ir_mode *new_ir_mode(const char *name, mode_sort sort, int bit_size, int align, int sign,
 260                      mode_arithmetic arithmetic, unsigned int modulo_shift )
 261 {
 262   ir_mode mode_tmpl;
 263   ir_mode *mode;
 264
 265   mode_tmpl.name         = new_id_from_str(name);
 266   mode_tmpl.sort         = sort;
 267   mode_tmpl.size         = bit_size;
 268   mode_tmpl.align        = align;
 269   mode_tmpl.sign         = sign ? 1 : 0;
 270   mode_tmpl.modulo_shift = (mode_tmpl.sort == irms_int_number) ? modulo_shift : 0;
 271   mode_tmpl.arithmetic   = arithmetic;
 272   mode_tmpl.link         = NULL;
 273   mode_tmpl.tv_priv      = NULL;
 274
 275   mode = find_mode(&mode_tmpl);
 276   if (mode)
 277   {
 278     return mode;
 279   }
 280
 281   /* sanity checks */
 282   switch (sort)
 283   {
 284     case irms_auxiliary:
 285     case irms_control_flow:
 286     case irms_memory:
 287     case irms_internal_boolean:
 288       assert(0 && "internal modes cannot be user defined");
 289       return NULL;
 290
 291     case irms_float_number:
 292       assert(0 && "not yet implemented");
 293       return NULL;
 294
 295     case irms_int_number:
 296     case irms_reference:
 297     case irms_character:
 298       return register_mode(&mode_tmpl);
 299   }
 300   return NULL; /* to shut up gcc */
 301 }
 302
 303 /* Functions for the direct access to all attributes od a ir_mode */
 304 modecode
 305 get_mode_modecode(const ir_mode *mode)
 306 {
 307   ANNOUNCE();
 308   return mode->code;
 309 }
 310
 311 ident *
 312 get_mode_ident(const ir_mode *mode)
 313 {
 314   ANNOUNCE();
 315   return mode->name;
 316 }
 317
 318 const char *
 319 get_mode_name(const ir_mode *mode)
 320 {
 321   ANNOUNCE();
 322   return get_id_str(mode->name);
 323 }
 324
 325 mode_sort
 326 get_mode_sort(const ir_mode* mode)
 327 {
 328   ANNOUNCE();
 329   return mode->sort;
 330 }
 331
 332 INLINE int
 333 get_mode_size_bits(const ir_mode *mode)
 334 {
 335   ANNOUNCE();
 336   return mode->size;
 337 }
 338
 339 int get_mode_size_bytes(const ir_mode *mode) {
 340   int size = get_mode_size_bits(mode);
 341   ANNOUNCE();
 342   if ((size & 7) != 0) return -1;
 343   return size >> 3;
 344 }
 345
 346 int
 347 get_mode_align (const ir_mode *mode)
 348 {
 349   ANNOUNCE();
 350   return mode->align;
 351 }
 352
 353 int
 354 get_mode_sign (const ir_mode *mode)
 355 {
 356   ANNOUNCE();
 357   return mode->sign;
 358 }
 359
 360 int get_mode_arithmetic (const ir_mode *mode)
 361 {
 362   ANNOUNCE();
 363   return mode->arithmetic;
 364 }
 365
 366
 367 /* Attribute modulo shift specifies for modes of kind irms_int_number
 368  *  whether shift applies modulo to value of bits to shift.  Asserts
 369  *  if mode is not irms_int_number.
 370  */
 371 unsigned int get_mode_modulo_shift(const ir_mode *mode) {
 372   return mode->modulo_shift;
 373 }
 374
 375 void* get_mode_link(const ir_mode *mode)
 376 {
 377   ANNOUNCE();
 378   return mode->link;
 379 }
 380
 381 void set_mode_link(ir_mode *mode, void *l)
 382 {
 383   mode->link=l;
 384   return;
 385 }
 386
 387 tarval *
 388 get_mode_min (ir_mode *mode)
 389 {
 390   ANNOUNCE();
 391   assert(mode);
 392   assert(get_mode_modecode(mode) < num_modes);
 393   assert(mode_is_data(mode));
 394
 395   return mode->min;
 396 }
 397
 398 tarval *
 399 get_mode_max (ir_mode *mode)
 400 {
 401   ANNOUNCE();
 402   assert(mode);
 403   assert(get_mode_modecode(mode) < num_modes);
 404   assert(mode_is_data(mode));
 405
 406   return mode->max;
 407 }
 408
 409 tarval *
 410 get_mode_null (ir_mode *mode)
 411 {
 412   ANNOUNCE();
 413   assert(mode);
 414   assert(get_mode_modecode(mode) < num_modes);
 415   assert(mode_is_data(mode));
 416
 417   return mode->null;
 418 }
 419
 420 tarval *
 421 get_mode_one (ir_mode *mode)
 422 {
 423   ANNOUNCE();
 424   assert(mode);
 425   assert(get_mode_modecode(mode) < num_modes);
 426   assert(mode_is_data(mode));
 427
 428   return mode->one;
 429 }
 430
 431 tarval *
 432 get_mode_infinite(ir_mode *mode)
 433 {
 434   ANNOUNCE();
 435   assert(mode);
 436   assert(get_mode_modecode(mode) < num_modes);
 437   assert(mode_is_float(mode));
 438
 439   return get_tarval_inf(mode);
 440 }
 441
 442 tarval *
 443 get_mode_NAN(ir_mode *mode)
 444 {
 445   ANNOUNCE();
 446   assert(mode);
 447   assert(get_mode_modecode(mode) < num_modes);
 448   assert(mode_is_float(mode));
 449
 450   return get_tarval_nan(mode);
 451 }
 452
 453 int
 454 is_mode (void *thing) {
 455   assert(thing);
 456   if (get_kind(thing) == k_ir_mode)
 457     return 1;
 458   else
 459     return 0;
 460 }
 461
 462 /* Functions to check, whether a modecode is signed, float, int, num, data,
 463    datab or dataM. For more exact definitions read the corresponding pages
 464    in the firm documentation or the followingenumeration
 465
 466    The set of "float" is defined as:
 467    ---------------------------------
 468    float = {irm_F, irm_D, irm_E}
 469
 470    The set of "int" is defined as:
 471    -------------------------------
 472    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 473
 474    The set of "num" is defined as:
 475    -------------------------------
 476    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 477             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 478             = {float || int}
 479
 480    The set of "data" is defined as:
 481    -------------------------------
 482    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 483             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
 484             = {num || irm_C || irm_U || irm_P}
 485
 486    The set of "datab" is defined as:
 487    ---------------------------------
 488    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 489             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 490             = {data || irm_b }
 491
 492    The set of "dataM" is defined as:
 493    ---------------------------------
 494    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 495             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 496             = {data || irm_M}
 497 */
 498
 499 #ifdef MODE_ACCESS_DEFINES
 500 #  undef mode_is_signed
 501 #  undef mode_is_float
 502 #  undef mode_is_int
 503 #  undef mode_is_num
 504 #  undef mode_is_numP
 505 #  undef mode_is_data
 506 #  undef mode_is_datab
 507 #  undef mode_is_dataM
 508 #endif
 509 int
 510 mode_is_signed (const ir_mode *mode)
 511 {
 512   ANNOUNCE();
 513   assert(mode);
 514   return mode->sign;
 515 }
 516
 517 int
 518 mode_is_float (const ir_mode *mode)
 519 {
 520   ANNOUNCE();
 521   assert(mode);
 522   return (get_mode_sort(mode) == irms_float_number);
 523 }
 524
 525 int
 526 mode_is_int (const ir_mode *mode)
 527 {
 528   ANNOUNCE();
 529   assert(mode);
 530   return (get_mode_sort(mode) == irms_int_number);
 531 }
 532
 533 int mode_is_character (const ir_mode *mode)
 534 {
 535   ANNOUNCE();
 536   assert(mode);
 537   return (get_mode_sort(mode) == irms_character);
 538 }
 539
 540 int mode_is_reference (const ir_mode *mode)
 541 {
 542   ANNOUNCE();
 543   assert(mode);
 544   return (get_mode_sort(mode) == irms_reference);
 545 }
 546
 547 int
 548 mode_is_num (const ir_mode *mode)
 549 {
 550   ANNOUNCE();
 551   assert(mode);
 552   return (mode_is_int(mode) || mode_is_float(mode));
 553 }
 554
 555 int
 556 mode_is_numP (const ir_mode *mode)
 557 {
 558   ANNOUNCE();
 559   assert(mode);
 560   return (mode_is_int(mode) || mode_is_float(mode) || mode_is_reference(mode));
 561 }
 562
 563 int
 564 mode_is_data (const ir_mode *mode)
 565 {
 566   ANNOUNCE();
 567   assert(mode);
 568   return (mode_is_num(mode) || get_mode_sort(mode) == irms_character || get_mode_sort(mode) == irms_reference);
 569 }
 570
 571 int
 572 mode_is_datab (const ir_mode *mode)
 573 {
 574   ANNOUNCE();
 575   assert(mode);
 576   return (mode_is_data(mode) || get_mode_sort(mode) == irms_internal_boolean);
 577 }
 578
 579 int
 580 mode_is_dataM (const ir_mode *mode)
 581 {
 582   ANNOUNCE();
 583   assert(mode);
 584   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 585 }
 586 #ifdef MODE_ACCESS_DEFINES
 587 #  define mode_is_signed(mode) (mode)->sign
 588 #  define mode_is_float(mode) ((mode)->sort == irms_float_number)
 589 #  define mode_is_int(mode) ((mode)->sort == irms_int_number)
 590 #  define mode_is_num(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number))
 591 #  define mode_is_data(mode) (((mode)->sort == irms_float_number) || ((mode)->sort == irms_int_number) || ((mode)->sort == irms_character) || ((mode)->sort == irms_reference))
 592 #  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))
 593 #  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))
 594 #endif
 595 /* Returns true if sm can be converted to lm without loss. */
 596 int
 597 smaller_mode(const ir_mode *sm, const ir_mode *lm)
 598 {
 599   int sm_bits, lm_bits;
 600
 601   ANNOUNCE();
 602   assert(sm);
 603   assert(lm);
 604
 605   if (sm == lm) return 1;
 606
 607   sm_bits = get_mode_size_bits(sm);
 608   lm_bits = get_mode_size_bits(lm);
 609
 610   switch(get_mode_sort(sm))
 611   {
 612     case irms_int_number:
 613       switch(get_mode_sort(lm))
 614       {
 615         case irms_int_number:
 616           /* integers are convertable if
 617            *   - both have the same sign and lm is the larger one
 618            *   - lm is the signed one and is at least two bits larger
 619            *     (one for the sign, one for the highest bit of sm)
 620            *   - sm & lm are two_complement and lm has greater or equal number of bits
 621            */
 622           if (   get_mode_arithmetic(sm) == get_mode_arithmetic(lm)
 623               && get_mode_arithmetic(sm) == irma_twos_complement) {
 624             return lm_bits >= sm_bits;
 625           }
 626           else if (mode_is_signed(sm))
 627           {
 628             if ( mode_is_signed(lm) && (lm_bits >= sm_bits) )
 629               return 1;
 630           }
 631           else if (mode_is_signed(lm))
 632           {
 633             if (lm_bits > sm_bits + 1)
 634               return 1;
 635           }
 636           else if (lm_bits >= sm_bits)
 637           {
 638             return 1;
 639           }
 640           break;
 641
 642         case irms_float_number:
 643           /* int to float works if the float is large enough */
 644           return 0;
 645
 646         default:
 647           break;
 648       }
 649       break;
 650
 651     case irms_float_number:
 652       if (get_mode_arithmetic(sm) == get_mode_arithmetic(lm)) {
 653         if ( (get_mode_sort(lm) == irms_float_number)
 654            && (get_mode_size_bits(lm) >= get_mode_size_bits(sm)) )
 655           return 1;
 656       }
 657       break;
 658
 659     case irms_reference:
 660        /* do exist machines out there with different pointer lenghts ?*/
 661       return 0;
 662
 663     default:
 664       break;
 665   }
 666
 667   /* else */
 668   return 0;
 669 }
 670
 671 /* ** initialization ** */
 672 void
 673 init_mode (void)
 674 {
 675   ir_mode newmode;
 676   ANNOUNCE();
 677   /* init flexible array */
 678
 679   obstack_init(&modes);
 680
 681   num_modes  =  0;
 682   /* initialize predefined modes */
 683
 684   /* Internal Modes */
 685   newmode.arithmetic   = irma_none;
 686   newmode.size         = 0;
 687   newmode.align        = 0;
 688   newmode.sign         = 0;
 689   newmode.modulo_shift = 0;
 690   newmode.link         = NULL;
 691   newmode.tv_priv      = NULL;
 692
 693   /* Control Flow Modes*/
 694   newmode.sort    = irms_control_flow;
 695
 696   /* Basic Block */
 697   newmode.name    = id_from_str("BB", 2);
 698   newmode.code    = irm_BB;
 699
 700   mode_BB = register_mode(&newmode);
 701
 702 /* eXecution */
 703   newmode.name    = id_from_str("X", 1);
 704   newmode.code    = irm_X;
 705
 706   mode_X = register_mode(&newmode);
 707
 708   /* Memory Modes */
 709   newmode.sort    = irms_memory;
 710
 711   /* Memory */
 712   newmode.name    = id_from_str("M", 1);
 713   newmode.code    = irm_M;
 714
 715   mode_M = register_mode(&newmode);
 716
 717   /* Auxiliary Modes */
 718   newmode.sort    = irms_auxiliary,
 719
 720   /* Tuple */
 721   newmode.name    = id_from_str("T", 1);
 722   newmode.code    = irm_T;
 723
 724   mode_T = register_mode(&newmode);
 725
 726   /* ANY */
 727   newmode.name    = id_from_str("ANY", 3);
 728   newmode.code    = irm_ANY;
 729
 730   mode_ANY = register_mode(&newmode);
 731
 732   /* BAD */
 733   newmode.name    = id_from_str("BAD", 3);
 734   newmode.code    = irm_BAD;
 735
 736   mode_BAD = register_mode(&newmode);
 737
 738   /* Internal Boolean Modes */
 739   newmode.sort    = irms_internal_boolean;
 740
 741   /* boolean */
 742   newmode.name    = id_from_str("b", 1);
 743   newmode.code    = irm_b;
 744
 745   mode_b = register_mode(&newmode);
 746
 747 /* Data Modes */
 748
 749   /* Float Number Modes */
 750   newmode.sort    = irms_float_number;
 751   newmode.arithmetic = irma_ieee754;
 752
 753   /* float */
 754   newmode.name    = id_from_str("F", 1);
 755   newmode.code    = irm_F;
 756   newmode.sign    = 1;
 757   newmode.align   = 4;
 758   newmode.size    = 32;
 759
 760   mode_F = register_mode(&newmode);
 761
 762   /* double */
 763   newmode.name    = id_from_str("D", 1);
 764   newmode.code    = irm_D;
 765   newmode.sign    = 1;
 766   newmode.align   = 4;
 767   newmode.size    = 64;
 768
 769   mode_D = register_mode(&newmode);
 770
 771   /* extended */
 772   newmode.name    = id_from_str("E", 1);
 773   newmode.code    = irm_E;
 774   newmode.sign    = 1;
 775   newmode.align   = 4;
 776   newmode.size    = 80;
 777
 778   mode_E = register_mode(&newmode);
 779
 780   /* Integer Number Modes */
 781   newmode.sort    = irms_int_number;
 782   newmode.arithmetic = irma_twos_complement;
 783
 784   /* signed byte */
 785   newmode.name    = id_from_str("Bs", 2);
 786   newmode.code    = irm_Bs;
 787   newmode.sign    = 1;
 788   newmode.align   = 1;
 789   newmode.size    = 8;
 790   newmode.modulo_shift = 32;
 791
 792   mode_Bs = register_mode(&newmode);
 793
 794   /* unsigned byte */
 795   newmode.name    = id_from_str("Bu", 2);
 796   newmode.code    = irm_Bu;
 797   newmode.arithmetic = irma_twos_complement;
 798   newmode.sign    = 0;
 799   newmode.align   = 1;
 800   newmode.size    = 8;
 801   newmode.modulo_shift = 32;
 802
 803   mode_Bu = register_mode(&newmode);
 804
 805   /* signed short integer */
 806   newmode.name    = id_from_str("Hs", 2);
 807   newmode.code    = irm_Hs;
 808   newmode.sign    = 1;
 809   newmode.align   = 2;
 810   newmode.size    = 16;
 811   newmode.modulo_shift = 32;
 812
 813   mode_Hs = register_mode(&newmode);
 814
 815   /* unsigned short integer */
 816   newmode.name    = id_from_str("Hu", 2);
 817   newmode.code    = irm_Hu;
 818   newmode.sign    = 0;
 819   newmode.align   = 2;
 820   newmode.size    = 16;
 821   newmode.modulo_shift = 32;
 822
 823   mode_Hu = register_mode(&newmode);
 824
 825   /* signed integer */
 826   newmode.name    = id_from_str("Is", 2);
 827   newmode.code    = irm_Is;
 828   newmode.sign    = 1;
 829   newmode.align   = 4;
 830   newmode.size    = 32;
 831   newmode.modulo_shift = 32;
 832
 833   mode_Is = register_mode(&newmode);
 834
 835   /* unsigned integer */
 836   newmode.name    = id_from_str("Iu", 2);
 837   newmode.code    = irm_Iu;
 838   newmode.sign    = 0;
 839   newmode.align   = 4;
 840   newmode.size    = 32;
 841   newmode.modulo_shift = 32;
 842
 843   mode_Iu = register_mode(&newmode);
 844
 845   /* signed long integer */
 846   newmode.name    = id_from_str("Ls", 2);
 847   newmode.code    = irm_Ls;
 848   newmode.sign    = 1;
 849   newmode.align   = 4;
 850   newmode.size    = 64;
 851   newmode.modulo_shift = 64;
 852
 853   mode_Ls = register_mode(&newmode);
 854
 855   /* unsigned long integer */
 856   newmode.name    = id_from_str("Lu", 2);
 857   newmode.code    = irm_Lu;
 858   newmode.sign    = 0;
 859   newmode.align   = 4;
 860   newmode.size    = 64;
 861   newmode.modulo_shift = 64;
 862
 863   mode_Lu = register_mode(&newmode);
 864
 865   /* Character Modes */
 866   newmode.sort    = irms_character;
 867   newmode.arithmetic = irma_none;
 868
 869   /* Character */
 870   newmode.name    = id_from_str("C", 1);
 871   newmode.code    = irm_C;
 872   newmode.sign    = 0;
 873   newmode.align   = 1;
 874   newmode.size    = 8;
 875   newmode.modulo_shift = 32;
 876
 877   mode_C = register_mode(&newmode);
 878
 879   /* Unicode character */
 880   newmode.name    = id_from_str("U", 1);
 881   newmode.code    = irm_U;
 882   newmode.sign    = 0;
 883   newmode.align   = 2;
 884   newmode.size    = 16;
 885   newmode.modulo_shift = 32;
 886
 887   mode_U = register_mode(&newmode);
 888
 889   /* Reference Modes */
 890   newmode.sort    = irms_reference;
 891   newmode.arithmetic = irma_twos_complement;
 892
 893   /* pointer */
 894   newmode.name    = id_from_str("P", 1);
 895   newmode.code    = irm_P;
 896   newmode.sign    = 0;
 897   newmode.align   = 4;
 898   newmode.size    = 32;
 899   newmode.modulo_shift = 0;
 900
 901   mode_P = register_mode(&newmode);
 902
 903   /* set the machine specific modes to the predifined ones */
 904   mode_P_mach = mode_P;
 905 }