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   ANNOUNCE();
 600   assert(sm);
 601   assert(lm);
 602
 603   if (sm == lm) return 1;
 604
 605   switch(get_mode_sort(sm))
 606   {
 607     case irms_int_number:
 608       switch(get_mode_sort(lm))
 609       {
 610         case irms_int_number:
 611           /* integers are convertable if
 612            *   - both have the same sign and lm is the larger one
 613            *   - lm is the signed one and is at least two bits larger
 614            *     (one for the sign, one for the highest bit of sm)
 615            */
 616           if (mode_is_signed(sm))
 617           {
 618             if ( mode_is_signed(lm) && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 619               return 1;
 620           }
 621           else if (mode_is_signed(lm))
 622           {
 623             if (get_mode_size_bits(lm) > get_mode_size_bits(sm) + 1)
 624               return 1;
 625           }
 626           else if (get_mode_size_bits(lm) > get_mode_size_bits(sm))
 627           {
 628             return 1;
 629           }
 630           break;
 631
 632         case irms_float_number:
 633           /* int to float works if the float is large enough */
 634           return 0;
 635
 636         default:
 637           break;
 638       }
 639       break;
 640
 641     case irms_float_number:
 642       /* XXX currently only the three standard 32,64,80 bit floats
 643        * are supported which can safely be converted */
 644       if ( (get_mode_sort(lm) == irms_float_number)
 645            && (get_mode_size_bits(lm) > get_mode_size_bits(sm)) )
 646          return 1;
 647       break;
 648
 649     case irms_reference:
 650        /* do exist machines out there with different pointer lenghts ?*/
 651       return 0;
 652
 653     default:
 654       break;
 655   }
 656
 657   /* else */
 658   return 0;
 659 }
 660
 661 /* ** initialization ** */
 662 void
 663 init_mode (void)
 664 {
 665   ir_mode newmode;
 666   ANNOUNCE();
 667   /* init flexible array */
 668
 669   obstack_init(&modes);
 670
 671   num_modes  =  0;
 672   /* initialize predefined modes */
 673
 674   /* Internal Modes */
 675   newmode.arithmetic   = irma_none;
 676   newmode.size         = 0;
 677   newmode.align        = 0;
 678   newmode.sign         = 0;
 679   newmode.modulo_shift = 0;
 680   newmode.link         = NULL;
 681   newmode.tv_priv      = NULL;
 682
 683   /* Control Flow Modes*/
 684   newmode.sort    = irms_control_flow;
 685
 686   /* Basic Block */
 687   newmode.name    = id_from_str("BB", 2);
 688   newmode.code    = irm_BB;
 689
 690   mode_BB = register_mode(&newmode);
 691
 692 /* eXecution */
 693   newmode.name    = id_from_str("X", 1);
 694   newmode.code    = irm_X;
 695
 696   mode_X = register_mode(&newmode);
 697
 698   /* Memory Modes */
 699   newmode.sort    = irms_memory;
 700
 701   /* Memory */
 702   newmode.name    = id_from_str("M", 1);
 703   newmode.code    = irm_M;
 704
 705   mode_M = register_mode(&newmode);
 706
 707   /* Auxiliary Modes */
 708   newmode.sort    = irms_auxiliary,
 709
 710   /* Tuple */
 711   newmode.name    = id_from_str("T", 1);
 712   newmode.code    = irm_T;
 713
 714   mode_T = register_mode(&newmode);
 715
 716   /* ANY */
 717   newmode.name    = id_from_str("ANY", 3);
 718   newmode.code    = irm_ANY;
 719
 720   mode_ANY = register_mode(&newmode);
 721
 722   /* BAD */
 723   newmode.name    = id_from_str("BAD", 3);
 724   newmode.code    = irm_BAD;
 725
 726   mode_BAD = register_mode(&newmode);
 727
 728   /* Internal Boolean Modes */
 729   newmode.sort    = irms_internal_boolean;
 730
 731   /* boolean */
 732   newmode.name    = id_from_str("b", 1);
 733   newmode.code    = irm_b;
 734
 735   mode_b = register_mode(&newmode);
 736
 737 /* Data Modes */
 738
 739   /* Float Number Modes */
 740   newmode.sort    = irms_float_number;
 741   newmode.arithmetic = irma_ieee754;
 742
 743   /* float */
 744   newmode.name    = id_from_str("F", 1);
 745   newmode.code    = irm_F;
 746   newmode.sign    = 1;
 747   newmode.align   = 4;
 748   newmode.size    = 32;
 749
 750   mode_F = register_mode(&newmode);
 751
 752   /* double */
 753   newmode.name    = id_from_str("D", 1);
 754   newmode.code    = irm_D;
 755   newmode.sign    = 1;
 756   newmode.align   = 4;
 757   newmode.size    = 64;
 758
 759   mode_D = register_mode(&newmode);
 760
 761   /* extended */
 762   newmode.name    = id_from_str("E", 1);
 763   newmode.code    = irm_E;
 764   newmode.sign    = 1;
 765   newmode.align   = 4;
 766   newmode.size    = 80;
 767
 768   mode_E = register_mode(&newmode);
 769
 770   /* Integer Number Modes */
 771   newmode.sort    = irms_int_number;
 772   newmode.arithmetic = irma_twos_complement;
 773
 774   /* signed byte */
 775   newmode.name    = id_from_str("Bs", 2);
 776   newmode.code    = irm_Bs;
 777   newmode.sign    = 1;
 778   newmode.align   = 1;
 779   newmode.size    = 8;
 780   newmode.modulo_shift = 32;
 781
 782   mode_Bs = register_mode(&newmode);
 783
 784   /* unsigned byte */
 785   newmode.name    = id_from_str("Bu", 2);
 786   newmode.code    = irm_Bu;
 787   newmode.arithmetic = irma_twos_complement;
 788   newmode.sign    = 0;
 789   newmode.align   = 1;
 790   newmode.size    = 8;
 791   newmode.modulo_shift = 32;
 792
 793   mode_Bu = register_mode(&newmode);
 794
 795   /* signed short integer */
 796   newmode.name    = id_from_str("Hs", 2);
 797   newmode.code    = irm_Hs;
 798   newmode.sign    = 1;
 799   newmode.align   = 2;
 800   newmode.size    = 16;
 801   newmode.modulo_shift = 32;
 802
 803   mode_Hs = register_mode(&newmode);
 804
 805   /* unsigned short integer */
 806   newmode.name    = id_from_str("Hu", 2);
 807   newmode.code    = irm_Hu;
 808   newmode.sign    = 0;
 809   newmode.align   = 2;
 810   newmode.size    = 16;
 811   newmode.modulo_shift = 32;
 812
 813   mode_Hu = register_mode(&newmode);
 814
 815   /* signed integer */
 816   newmode.name    = id_from_str("Is", 2);
 817   newmode.code    = irm_Is;
 818   newmode.sign    = 1;
 819   newmode.align   = 4;
 820   newmode.size    = 32;
 821   newmode.modulo_shift = 32;
 822
 823   mode_Is = register_mode(&newmode);
 824
 825   /* unsigned integer */
 826   newmode.name    = id_from_str("Iu", 2);
 827   newmode.code    = irm_Iu;
 828   newmode.sign    = 0;
 829   newmode.align   = 4;
 830   newmode.size    = 32;
 831   newmode.modulo_shift = 32;
 832
 833   mode_Iu = register_mode(&newmode);
 834
 835   /* signed long integer */
 836   newmode.name    = id_from_str("Ls", 2);
 837   newmode.code    = irm_Ls;
 838   newmode.sign    = 1;
 839   newmode.align   = 4;
 840   newmode.size    = 64;
 841   newmode.modulo_shift = 64;
 842
 843   mode_Ls = register_mode(&newmode);
 844
 845   /* unsigned long integer */
 846   newmode.name    = id_from_str("Lu", 2);
 847   newmode.code    = irm_Lu;
 848   newmode.sign    = 0;
 849   newmode.align   = 4;
 850   newmode.size    = 64;
 851   newmode.modulo_shift = 64;
 852
 853   mode_Lu = register_mode(&newmode);
 854
 855   /* Character Modes */
 856   newmode.sort    = irms_character;
 857   newmode.arithmetic = irma_none;
 858
 859   /* Character */
 860   newmode.name    = id_from_str("C", 1);
 861   newmode.code    = irm_C;
 862   newmode.sign    = 0;
 863   newmode.align   = 1;
 864   newmode.size    = 8;
 865   newmode.modulo_shift = 32;
 866
 867   mode_C = register_mode(&newmode);
 868
 869   /* Unicode character */
 870   newmode.name    = id_from_str("U", 1);
 871   newmode.code    = irm_U;
 872   newmode.sign    = 0;
 873   newmode.align   = 2;
 874   newmode.size    = 16;
 875   newmode.modulo_shift = 32;
 876
 877   mode_U = register_mode(&newmode);
 878
 879   /* Reference Modes */
 880   newmode.sort    = irms_reference;
 881   newmode.arithmetic = irma_twos_complement;
 882
 883   /* pointer */
 884   newmode.name    = id_from_str("P", 1);
 885   newmode.code    = irm_P;
 886   newmode.sign    = 0;
 887   newmode.align   = 4;
 888   newmode.size    = 32;
 889   newmode.modulo_shift = 0;
 890
 891   mode_P = register_mode(&newmode);
 892
 893   /* set the machine specific modes to the predifined ones */
 894   mode_P_mach = mode_P;
 895 }