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

   1 /* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
   2 ** All rights reserved.
   3 **
   4 ** Authors: Martin Trapp, Christian Schaefer
   5 **
   6 */
   7
   8 /* $Id$ */
   9
  10 #ifdef HAVE_CONFIG_H
  11 # include <config.h>
  12 #endif
  13
  14 # include "irmode_t.h"
  15 # include "ident.h"
  16 # include <malloc.h>
  17 # include <stddef.h>
  18 # include <string.h>
  19 # include "tv.h"
  20 # include "array.h"
  21
  22 #if 0
  23 #  define ANNOUNCE() printf(__FILE__": call no. %lld (%s)\n", count++, __FUNCTION__)
  24 #else
  25 #  define ANNOUNCE() ((void)0)
  26 #endif
  27
  28 /* * *
  29  * local values
  30  * * */
  31
  32 static long long count = 0;
  33
  34 /* dynamic array to hold all modes */
  35 static ir_mode * modes;
  36 /* dynamic arrays to hold special modes' values */
  37 static tarval** modes_min;
  38 static tarval** modes_max;
  39 static tarval** modes_null;
  40 static tarval** modes_one;
  41
  42 /* number of defined modes */
  43 static int num_modes;
  44
  45 /* * *
  46  * local functions
  47  * * */
  48
  49 /* compare modes that don't need to have their code field
  50  * correctly set */
  51 static int modes_are_equal(ir_mode *m, ir_mode *n)
  52 {
  53   if (m == n) return 1;
  54   if ( (m->sort == n->sort) && (m->size == n->size) &&
  55       (m->align == n->align) && (m->sign == n->sign) &&
  56       (m->name == n->name) )
  57     return 1;
  58
  59   return 0;
  60 }
  61
  62 /* searches the modes array for the given mode and returns
  63  * a pointer on an equal mode already in the array, NULL if
  64  * none found */
  65 static ir_mode *find_mode(ir_mode *m)
  66 {
  67   int i;
  68
  69   for (i = 0; i < num_modes; i++)
  70   {
  71     if (modes_are_equal(m, &modes[i])) return &modes[i];
  72   }
  73
  74   return NULL;
  75 }
  76
  77 /* sets special values of modes */
  78 static void set_mode_values(ir_mode* mode)
  79 {
  80   modes_min[get_mode_modecode(mode)] = get_tarval_min(mode);
  81   modes_max[get_mode_modecode(mode)] = get_tarval_max(mode);
  82   modes_null[get_mode_modecode(mode)] = get_tarval_null(mode);
  83   modes_one[get_mode_modecode(mode)] = get_tarval_one(mode);
  84 }
  85 /* * *
  86  * globals defined in irmode.h
  87  * * */
  88
  89 /** Predefined modes **/
  90
  91 /* FIRM internal modes: */
  92 ir_mode *mode_T;
  93 ir_mode *mode_X;
  94 ir_mode *mode_M;
  95 ir_mode *mode_BB;
  96
  97 /* predefined numerical modes: */
  98 ir_mode *mode_F;    /* float */
  99 ir_mode *mode_D;    /* double */
 100 ir_mode *mode_E;    /* long double */
 101
 102 ir_mode *mode_Bs;   /* integral values, signed and unsigned */
 103 ir_mode *mode_Bu;   /* 8 bit */
 104 ir_mode *mode_Hs;   /* 16 bit */
 105 ir_mode *mode_Hu;
 106 ir_mode *mode_Is;   /* 32 bit */
 107 ir_mode *mode_Iu;
 108 ir_mode *mode_Ls;   /* 64 bit */
 109 ir_mode *mode_Lu;
 110
 111 ir_mode *mode_C;
 112 ir_mode *mode_U;
 113 ir_mode *mode_b;
 114 ir_mode *mode_P;
 115
 116 /* * *
 117  * functions defined in irmode.h
 118  * * */
 119
 120 /* JNI access functions */
 121 INLINE ir_mode *get_modeT() { ANNOUNCE(); return mode_T; }
 122 INLINE ir_mode *get_modeF() { ANNOUNCE(); return mode_F; }
 123 INLINE ir_mode *get_modeD() { ANNOUNCE(); return mode_D; }
 124 INLINE ir_mode *get_modeE() { ANNOUNCE(); return mode_E; }
 125 INLINE ir_mode *get_modeBs() { ANNOUNCE(); return mode_Bs; }
 126 INLINE ir_mode *get_modeBu() { ANNOUNCE(); return mode_Bu; }
 127 INLINE ir_mode *get_modeHs() { ANNOUNCE(); return mode_Hs; }
 128 INLINE ir_mode *get_modeHu() { ANNOUNCE(); return mode_Hu; }
 129 INLINE ir_mode *get_modeIs() { ANNOUNCE(); return mode_Is; }
 130 INLINE ir_mode *get_modeIu() { ANNOUNCE(); return mode_Iu; }
 131 INLINE ir_mode *get_modeLs() { ANNOUNCE(); return mode_Ls; }
 132 INLINE ir_mode *get_modeLu() { ANNOUNCE(); return mode_Lu; }
 133 INLINE ir_mode *get_modeC() { ANNOUNCE(); return mode_C; }
 134 INLINE ir_mode *get_modeU() { ANNOUNCE(); return mode_U; }
 135 INLINE ir_mode *get_modeb() { ANNOUNCE(); return mode_b; }
 136 INLINE ir_mode *get_modeP() { ANNOUNCE(); return mode_P; }
 137 INLINE ir_mode *get_modeX() { ANNOUNCE(); return mode_X; }
 138 INLINE ir_mode *get_modeM() { ANNOUNCE(); return mode_M; }
 139 INLINE ir_mode *get_modeBB() { ANNOUNCE(); return mode_BB; }
 140
 141 /* ** Constructor ** */
 142 ir_mode *
 143 register_mode(ir_mode* new_mode)
 144 {
 145   ir_mode *mode;
 146
 147   ANNOUNCE();
 148   assert(new_mode);
 149
 150   /* first check if there already is a matching mode */
 151   mode = find_mode(new_mode);
 152   if (mode) return mode;
 153
 154   /* sanity checks */
 155   switch (new_mode->sort)
 156   {
 157     case auxiliary:
 158     case internal_boolean:
 159       assert(0 && "internal modes cannot be user defined");
 160       break;
 161
 162     case float_number:
 163       assert(0 && "not yet implemented");
 164       break;
 165
 166     case int_number:
 167     case reference:
 168     case character:
 169       break;
 170
 171     default:
 172       assert(0);
 173   }
 174
 175   /* copy mode struct to modes array */
 176   ARR_EXTEND(ir_mode, modes, 1);
 177   ARR_EXTEND(tarval*, modes_min, 1);
 178   ARR_EXTEND(tarval*, modes_max, 1);
 179   ARR_EXTEND(tarval*, modes_null, 1);
 180   ARR_EXTEND(tarval*, modes_one, 1);
 181   mode = &modes[num_modes];
 182
 183   memcpy(mode, new_mode, sizeof(ir_mode));
 184   mode->code = num_modes;
 185   num_modes++;
 186
 187   set_mode_values(mode);
 188
 189   return mode;
 190 }
 191
 192 /* Functions for the direct access to all attributes od a ir_mode */
 193 #ifdef MODE_ACCESS_DEFINES
 194 #  undef get_mode_modecode
 195 #  undef get_mode_ident
 196 #  undef get_mode_name
 197 #  undef get_mode_sort
 198 #  undef get_mode_size
 199 #  undef get_mode_align
 200 #endif
 201 modecode
 202 get_mode_modecode(ir_mode *mode)
 203 {
 204   ANNOUNCE();
 205   return mode->code;
 206 }
 207
 208 ident *
 209 get_mode_ident(ir_mode *mode)
 210 {
 211   ANNOUNCE();
 212   return mode->name;
 213 }
 214
 215 const char *
 216 get_mode_name(ir_mode *mode)
 217 {
 218   ANNOUNCE();
 219   return id_to_str(mode->name);
 220 }
 221
 222 mode_sort
 223 get_mode_sort(ir_mode* mode)
 224 {
 225   ANNOUNCE();
 226   return mode->sort;
 227 }
 228
 229 int
 230 get_mode_size(ir_mode *mode)
 231 {
 232   ANNOUNCE();
 233   return mode->size;
 234 }
 235
 236 int
 237 get_mode_align (ir_mode *mode)
 238 {
 239   ANNOUNCE();
 240   return mode->align;
 241 }
 242 #ifdef MODE_ACCESS_DEFINES
 243 #  define get_mode_modecode(mode) (mode)->code
 244 #  define get_mode_ident(mode) (mode)->name
 245 #  define get_mode_name(mode) id_to_str((mode)->name)
 246 #  define get_mode_sort(mode) (mode)->sort
 247 #  define get_mode_size(mode) (mode)->size
 248 #  define get_mode_align(mode) (mode)->align
 249 #endif
 250 int
 251 get_mode_sign (ir_mode *mode)
 252 {
 253   ANNOUNCE();
 254   return mode->sign;
 255 }
 256
 257 tarval *
 258 get_mode_min (ir_mode *mode)
 259 {
 260   ANNOUNCE();
 261   assert(mode);
 262   assert(get_mode_modecode(mode) < num_modes);
 263   assert(mode_is_data(mode));
 264
 265   return modes_min[get_mode_modecode(mode)];
 266 }
 267
 268 tarval *
 269 get_mode_max (ir_mode *mode)
 270 {
 271   ANNOUNCE();
 272   assert(mode);
 273   assert(get_mode_modecode(mode) < num_modes);
 274   assert(mode_is_data(mode));
 275
 276   return modes_max[get_mode_modecode(mode)];
 277 }
 278
 279 tarval *
 280 get_mode_null (ir_mode *mode)
 281 {
 282   ANNOUNCE();
 283   assert(mode);
 284   assert(get_mode_modecode(mode) < num_modes);
 285   assert(mode_is_data(mode));
 286
 287   return modes_null[get_mode_modecode(mode)];
 288 }
 289
 290 tarval *
 291 get_mode_one (ir_mode *mode)
 292 {
 293   ANNOUNCE();
 294   assert(mode);
 295   assert(get_mode_modecode(mode) < num_modes);
 296   assert(mode_is_data(mode));
 297
 298   return modes_one[get_mode_modecode(mode)];
 299 }
 300
 301 tarval *
 302 get_mode_infinite(ir_mode *mode)
 303 {
 304   ANNOUNCE();
 305   assert(mode);
 306   assert(get_mode_modecode(mode) < num_modes);
 307   assert(mode_is_float(mode));
 308
 309   return get_tarval_inf(mode);
 310 }
 311
 312 tarval *
 313 get_mode_NAN(ir_mode *mode)
 314 {
 315   ANNOUNCE();
 316   assert(mode);
 317   assert(get_mode_modecode(mode) < num_modes);
 318   assert(mode_is_float(mode));
 319
 320   return get_tarval_nan(mode);
 321 }
 322
 323 /* Functions to check, whether a modecode is signed, float, int, num, data,
 324    datab or dataM. For more exact definitions read the corresponding pages
 325    in the firm documentation or the followingenumeration
 326
 327    The set of "float" is defined as:
 328    ---------------------------------
 329    float = {irm_F, irm_D, irm_E}
 330
 331    The set of "int" is defined as:
 332    -------------------------------
 333    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 334
 335    The set of "num" is defined as:
 336    -------------------------------
 337    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 338             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 339             = {float || int}
 340
 341    The set of "data" is defined as:
 342    -------------------------------
 343    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 344             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P}
 345             = {num || irm_C || irm_U || irm_P}
 346
 347    The set of "datab" is defined as:
 348    ---------------------------------
 349    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 350             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 351             = {data || irm_b }
 352
 353    The set of "dataM" is defined as:
 354    ---------------------------------
 355    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 356             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 357             = {data || irm_M}
 358 */
 359
 360 #ifdef MODE_ACCESS_DEFINES
 361 #  undef mode_is_signed
 362 #  undef mode_is_float
 363 #  undef mode_is_int
 364 #  undef mode_is_num
 365 #  undef mode_is_data
 366 #  undef mode_is_datab
 367 #  undef mode_is_dataM
 368 #endif
 369 int
 370 mode_is_signed (ir_mode *mode)
 371 {
 372   ANNOUNCE();
 373   assert(mode);
 374   return mode->sign;
 375 }
 376
 377 int
 378 mode_is_float (ir_mode *mode)
 379 {
 380   ANNOUNCE();
 381   assert(mode);
 382   return (get_mode_sort(mode) == float_number);
 383 }
 384
 385 int
 386 mode_is_int (ir_mode *mode)
 387 {
 388   ANNOUNCE();
 389   assert(mode);
 390   return (get_mode_sort(mode) == int_number);
 391 }
 392
 393 int
 394 mode_is_num (ir_mode *mode)
 395 {
 396   ANNOUNCE();
 397   assert(mode);
 398   return (mode_is_int(mode) || mode_is_float(mode));
 399 }
 400
 401 int
 402 mode_is_data (ir_mode *mode)
 403 {
 404   ANNOUNCE();
 405   assert(mode);
 406   return (mode_is_num(mode) || get_mode_sort(mode) == character || get_mode_sort(mode) == reference);
 407 }
 408
 409 int
 410 mode_is_datab (ir_mode *mode)
 411 {
 412   ANNOUNCE();
 413   assert(mode);
 414   return (mode_is_data(mode) || get_mode_sort(mode) == internal_boolean);
 415 }
 416
 417 int
 418 mode_is_dataM (ir_mode *mode)
 419 {
 420   ANNOUNCE();
 421   assert(mode);
 422   return (mode_is_data(mode) || get_mode_modecode(mode) == irm_M);
 423 }
 424 #ifdef MODE_ACCESS_DEFINES
 425 #  define mode_is_signed(mode) (mode)->sign
 426 #  define mode_is_float(mode) ((mode)->sort == float_number)
 427 #  define mode_is_int(mode) ((mode)->sort == int_number)
 428 #  define mode_is_num(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number))
 429 #  define mode_is_data(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference))
 430 #  define mode_is_datab(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->sort == internal_boolean))
 431 #  define mode_is_dataM(mode) (((mode)->sort == float_number) || ((mode)->sort == int_number) || ((mode)->sort == character) || ((mode)->sort == reference) || ((mode)->code == irm_M))
 432 #endif
 433 /* Returns true if sm can be converted to lm without loss. */
 434 int
 435 smaller_mode(ir_mode *sm, ir_mode *lm)
 436 {
 437   ANNOUNCE();
 438   assert(sm);
 439   assert(lm);
 440
 441   if (sm == lm) return 1;
 442
 443   switch(get_mode_sort(sm))
 444   {
 445     case int_number:
 446       switch(get_mode_sort(lm))
 447       {
 448         case int_number:
 449           /* integers are convertable if
 450            *   - both have the same sign and lm is the larger one
 451            *   - lm is the signed one and is at least two bits larger
 452            *     (one for the sign, one for the highest bit of sm)
 453            */
 454           if (mode_is_signed(sm))
 455           {
 456             if ( mode_is_signed(lm) && (get_mode_size(lm) > get_mode_size(sm)) )
 457               return 1;
 458           }
 459           else if (mode_is_signed(lm))
 460           {
 461             if (get_mode_size(lm) > get_mode_size(sm) + 1)
 462               return 1;
 463           }
 464           else if (get_mode_size(lm) > get_mode_size(sm))
 465           {
 466             return 1;
 467           }
 468           break;
 469
 470         case float_number:
 471           /* int to float works if the float is large enough */
 472           return 0;
 473
 474         default:
 475           break;
 476       }
 477       break;
 478
 479     case float_number:
 480       /* XXX currently only the three standard 32,64,80 bit floats
 481        * are supported which can safely be converted */
 482       if ( (get_mode_sort(lm) == float_number)
 483            && (get_mode_size(lm) > get_mode_size(sm)) )
 484          return 1;
 485       break;
 486
 487     case reference:
 488        /* do exist machines out there with different pointer lenghts ?*/
 489       return 0;
 490
 491     default:
 492       break;
 493   }
 494
 495   /* else */
 496   return 0;
 497 }
 498
 499 /** ** initialization ** **/
 500 void
 501 init_mode (void)
 502 {
 503   ANNOUNCE();
 504   /* init flexible array */
 505   modes = NEW_ARR_F(ir_mode, irm_max);
 506   modes_min = NEW_ARR_F(tarval*, irm_max);
 507   modes_max = NEW_ARR_F(tarval*, irm_max);
 508   modes_null = NEW_ARR_F(tarval*, irm_max);
 509   modes_one = NEW_ARR_F(tarval*, irm_max);
 510
 511   /* initialize predefined modes */
 512   /* Basic Block */
 513   mode_BB = &modes[irm_BB];
 514   mode_BB->name = id_from_str("BB", 2);
 515   mode_BB->code = irm_BB;
 516   mode_BB->sort = auxiliary;
 517   mode_BB->sign = 0;
 518
 519   /* eXecution */
 520   mode_X = &modes[irm_X];
 521   mode_X->name = id_from_str("X", 1);
 522   mode_X->code = irm_X;
 523   mode_X->sort = auxiliary;
 524   mode_X->sign = 0;
 525
 526   /* Memory */
 527   mode_M = &modes[irm_M];
 528   mode_M->name = id_from_str("M", 1);
 529   mode_M->code = irm_M;
 530   mode_M->sort = auxiliary;
 531   mode_M->sign = 0;
 532
 533   /* Tuple */
 534   mode_T = &modes[irm_T];
 535   mode_T->name = id_from_str("T", 1);
 536   mode_T->code = irm_T;
 537   mode_T->sign = 0;
 538
 539   /* boolean */
 540   mode_b = &modes[irm_b];
 541   mode_b->name = id_from_str("b", 1);
 542   mode_b->code = irm_b;
 543   mode_b->sort = internal_boolean;
 544   mode_b->sign = 0;
 545
 546   /* float */
 547   mode_F = &modes[irm_F];
 548   mode_F->name = id_from_str("F", 1);
 549   mode_F->code = irm_F;
 550   mode_F->sort = float_number;
 551   mode_F->sign = 1;
 552   mode_F->align = 32;
 553   mode_F->size = 32;
 554
 555   set_mode_values(mode_F);
 556
 557   /* double */
 558   mode_D = &modes[irm_D];
 559   mode_D->name = id_from_str("D", 1);
 560   mode_D->code = irm_D;
 561   mode_D->sort = float_number;
 562   mode_D->sign = 1;
 563   mode_D->align = 32;
 564   mode_D->size = 64;
 565
 566   set_mode_values(mode_D);
 567
 568   /* extended */
 569   mode_E = &modes[irm_E];
 570   mode_E->name = id_from_str("E", 1);
 571   mode_E->code = irm_E;
 572   mode_E->sort = float_number;
 573   mode_E->sign = 1;
 574   mode_E->align = 32;
 575   mode_E->size = 80;
 576
 577   set_mode_values(mode_E);
 578
 579   /* signed byte */
 580   mode_Bs = &modes[irm_Bs];
 581   mode_Bs->name = id_from_str("Bs", 2);
 582   mode_Bs->code = irm_Bs;
 583   mode_Bs->sort = int_number;
 584   mode_Bs->sign = 1;
 585   mode_Bs->align = 8;
 586   mode_Bs->size = 8;
 587
 588   set_mode_values(mode_Bs);
 589
 590   /* unsigned byte */
 591   mode_Bu = &modes[irm_Bu];
 592   mode_Bu->name = id_from_str("Bu", 2);
 593   mode_Bu->code = irm_Bu;
 594   mode_Bu->sort = int_number;
 595   mode_Bu->sign = 0;
 596   mode_Bu->align = 8;
 597   mode_Bu->size = 8;
 598
 599   set_mode_values(mode_Bu);
 600
 601   /* signed short integer */
 602   mode_Hs = &modes[irm_Hs];
 603   mode_Hs->name = id_from_str("Hs", 2);
 604   mode_Hs->code = irm_Hs;
 605   mode_Hs->sort = int_number;
 606   mode_Hs->sign = 1;
 607   mode_Hs->align = 16;
 608   mode_Hs->size = 16;
 609
 610   set_mode_values(mode_Hs);
 611
 612   /* unsigned short integer */
 613   mode_Hu = &modes[irm_Hu];
 614   mode_Hu->name = id_from_str("Hu", 2);
 615   mode_Hu->code = irm_Hu;
 616   mode_Hu->sort = int_number;
 617   mode_Hu->sign = 0;
 618   mode_Hu->align = 16;
 619   mode_Hu->size = 16;
 620
 621   set_mode_values(mode_Hu);
 622
 623   /* signed integer */
 624   mode_Is = &modes[irm_Is];
 625   mode_Is->name = id_from_str("Is", 2);
 626   mode_Is->code = irm_Is;
 627   mode_Is->sort = int_number;
 628   mode_Is->sign = 1;
 629   mode_Is->align = 32;
 630   mode_Is->size = 32;
 631
 632   set_mode_values(mode_Is);
 633
 634   /* unsigned integer */
 635   mode_Iu = &modes[irm_Iu];
 636   mode_Iu->name = id_from_str("Iu", 2);
 637   mode_Iu->code = irm_Iu;
 638   mode_Iu->sort = int_number;
 639   mode_Iu->sign = 0;
 640   mode_Iu->align = 32;
 641   mode_Iu->size = 32;
 642
 643   set_mode_values(mode_Iu);
 644
 645   /* signed long integer */
 646   mode_Ls = &modes[irm_Ls];
 647   mode_Ls->name = id_from_str("Ls", 2);
 648   mode_Ls->code = irm_Ls;
 649   mode_Ls->sort = int_number;
 650   mode_Ls->sign = 1;
 651   mode_Ls->align = 32;
 652   mode_Ls->size = 64;
 653
 654   set_mode_values(mode_Ls);
 655
 656   /* unsigned long integer */
 657   mode_Lu = &modes[irm_Lu];
 658   mode_Lu->name = id_from_str("Lu", 2);
 659   mode_Lu->code = irm_Lu;
 660   mode_Lu->sort = int_number;
 661   mode_Lu->sign = 0;
 662   mode_Lu->align = 32;
 663   mode_Lu->size = 64;
 664
 665   set_mode_values(mode_Lu);
 666
 667   /* Character */
 668   mode_C = &modes[irm_C];
 669   mode_C->name = id_from_str("C", 1);
 670   mode_C->code = irm_C;
 671   mode_C->sort = character;
 672   mode_C->sign = 0;
 673   mode_C->align = 8;
 674   mode_C->size = 8;
 675
 676   set_mode_values(mode_C);
 677
 678   /* Unicode character */
 679   mode_U = &modes[irm_U];
 680   mode_U->name = id_from_str("U", 1);
 681   mode_U->code = irm_U;
 682   mode_U->sort = character;
 683   mode_U->sign = 0;
 684   mode_U->align = 16;
 685   mode_U->size = 16;
 686
 687   set_mode_values(mode_U);
 688
 689   /* pointer */
 690   mode_P = &modes[irm_P];
 691   mode_P->name = id_from_str("P", 1);
 692   mode_P->code = irm_P;
 693   mode_P->sort = reference;
 694   mode_P->sign = 0;
 695   mode_P->align = 32;
 696   mode_P->size = 32;
 697
 698   num_modes = irm_max;
 699 }