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