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