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 <stdlib.h>
  16 # include <stddef.h>
  17 # include <string.h>
  18 # include "tv.h"
  19
  20 ir_mode *mode_T;
  21 ir_mode *mode_F;
  22 ir_mode *mode_D;
  23 ir_mode *mode_E;
  24 ir_mode *mode_Bs;
  25 ir_mode *mode_Bu;
  26 ir_mode *mode_Hs;
  27 ir_mode *mode_Hu;
  28 ir_mode *mode_Is;
  29 ir_mode *mode_Iu;
  30 ir_mode *mode_Ls;
  31 ir_mode *mode_Lu;
  32 ir_mode *mode_C;
  33 ir_mode *mode_U;
  34 ir_mode *mode_b;
  35 ir_mode *mode_P;
  36 ir_mode *mode_X;
  37 ir_mode *mode_M;
  38 ir_mode *mode_BB;
  39
  40 INLINE ir_mode *get_modeT() { return mode_T; }
  41 INLINE ir_mode *get_modeF() { return mode_F; }
  42 INLINE ir_mode *get_modeD() { return mode_D; }
  43 INLINE ir_mode *get_modeE() { return mode_E; }
  44 INLINE ir_mode *get_modeBs() { return mode_Bs; }
  45 INLINE ir_mode *get_modeBu() { return mode_Bu; }
  46 INLINE ir_mode *get_modeHs() { return mode_Hs; }
  47 INLINE ir_mode *get_modeHu() { return mode_Hu; }
  48 INLINE ir_mode *get_modeIs() { return mode_Is; }
  49 INLINE ir_mode *get_modeIu() { return mode_Iu; }
  50 INLINE ir_mode *get_modeLs() { return mode_Ls; }
  51 INLINE ir_mode *get_modeLu() { return mode_Lu; }
  52 INLINE ir_mode *get_modeC() { return mode_C; }
  53 INLINE ir_mode *get_modeU() { return mode_U; }
  54 INLINE ir_mode *get_modeb() { return mode_b; }
  55 INLINE ir_mode *get_modeP() { return mode_P; }
  56 INLINE ir_mode *get_modeX() { return mode_X; }
  57 INLINE ir_mode *get_modeM() { return mode_M; }
  58 INLINE ir_mode *get_modeBB() { return mode_BB; }
  59
  60 void
  61 init_mode (void)
  62 {
  63   /* allocate all modes. We need to memset them as tarval_vrfy
  64      reads fields before they are initialized: It compares to
  65      min/max when tarvals for min/max are allocated!  */
  66   mode_T  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_T, 0, sizeof(ir_mode));
  67   mode_F  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_F, 0, sizeof(ir_mode));
  68   mode_D  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_D, 0, sizeof(ir_mode));
  69   mode_E  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_E, 0, sizeof(ir_mode));
  70   mode_Bs = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Bs, 0, sizeof(ir_mode));
  71   mode_Bu = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Bu, 0, sizeof(ir_mode));
  72   mode_Hs = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Hs, 0, sizeof(ir_mode));
  73   mode_Hu = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Hu, 0, sizeof(ir_mode));
  74   mode_Is = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Is, 0, sizeof(ir_mode));
  75   mode_Iu = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Iu, 0, sizeof(ir_mode));
  76   mode_Ls = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Ls, 0, sizeof(ir_mode));
  77   mode_Lu = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_Lu, 0, sizeof(ir_mode));
  78   mode_C  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_C, 0, sizeof(ir_mode));
  79   mode_U  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_U, 0, sizeof(ir_mode));
  80   mode_b  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_b, 0, sizeof(ir_mode));
  81   mode_P  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_P, 0, sizeof(ir_mode));
  82   mode_X  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_X, 0, sizeof(ir_mode));
  83   mode_M  = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_M, 0, sizeof(ir_mode));
  84   mode_BB = (ir_mode *) malloc (sizeof (ir_mode)); memset(mode_BB, 0, sizeof(ir_mode));
  85
  86   mode_T->code = irm_T;
  87   mode_F->code = irm_F;
  88   mode_D->code = irm_D;
  89   mode_E->code = irm_E;
  90   mode_Bs->code = irm_Bs;
  91   mode_Bu->code = irm_Bu;
  92   mode_Hs->code = irm_Hs;
  93   mode_Hu->code = irm_Hu;
  94   mode_Is->code = irm_Is;
  95   mode_Iu->code = irm_Iu;
  96   mode_Ls->code = irm_Ls;
  97   mode_Lu->code = irm_Lu;
  98   mode_C->code = irm_C;
  99   mode_U->code = irm_U;
 100   mode_b->code = irm_b;
 101   mode_P->code = irm_P;
 102   mode_X->code = irm_X;
 103   mode_M->code = irm_M;
 104   mode_BB->code = irm_BB;
 105
 106   /* initialize all modes */
 107
 108   mode_T->name = id_from_str ("T", 1);
 109   mode_T->fsigned = 0;
 110   mode_T->ffloat = 0;
 111
 112   /* float */
 113   mode_F->name = id_from_str ("F", 1);
 114   mode_F->fsigned = 1;
 115   mode_F->ffloat = 1;
 116   mode_F->ld_align = 4;
 117   mode_F->size = 4;
 118
 119   /* double */
 120   mode_D->name = id_from_str ("D", 1);
 121   mode_D->fsigned = 1;
 122   mode_D->ffloat = 1;
 123   mode_D->ld_align = 4;
 124   mode_D->size = 8;
 125
 126   /* extended */
 127   mode_E->name = id_from_str ("E", 1);
 128   mode_E->fsigned = 1;
 129   mode_E->ffloat = 1;
 130   mode_E->ld_align = 4;
 131   mode_E->size = 12;
 132
 133   /* signed byte */
 134   mode_Bs->name = id_from_str ("Bs", 1);
 135   mode_Bs->fsigned = 1;
 136   mode_Bs->ffloat = 0;
 137   mode_Bs->ld_align = 1;
 138   mode_Bs->size = 1;
 139   mode_Bs->min = tarval_from_long (mode_Ls, 0xffffff80);
 140   mode_Bs->max = tarval_from_long (mode_Ls, 0x0000007f);
 141   mode_Bs->null = tarval_from_long (mode_Bs, 0);
 142
 143   /* unsigned byte */
 144   mode_Bu->name = id_from_str ("Bu", 1);
 145   mode_Bu->fsigned = 0;
 146   mode_Bu->ffloat = 0;
 147   mode_Bu->ld_align = 1;
 148   mode_Bu->size = 1;
 149   mode_Bu->min = tarval_from_long (mode_Lu, 0x00000000);
 150   mode_Bu->max = tarval_from_long (mode_Lu, 0x000000ff);
 151   mode_Bu->null = tarval_from_long (mode_Bu, 0);
 152
 153   /* signed short integer */
 154   mode_Hs->name = id_from_str ("Hs", 1);
 155   mode_Hs->fsigned = 1;
 156   mode_Hs->ffloat = 0;
 157   mode_Hs->ld_align = 2;
 158   mode_Hs->size = 2;
 159   mode_Hs->min = tarval_from_long (mode_Ls, 0xffff8000);
 160   mode_Hs->max = tarval_from_long (mode_Ls, 0x00007fff);
 161   mode_Hs->null = tarval_from_long (mode_Hs, 0);
 162
 163   /* unsigned short integer */
 164   mode_Hu->name = id_from_str ("Hu", 1);
 165   mode_Hu->fsigned = 0;
 166   mode_Hu->ffloat = 0;
 167   mode_Hu->ld_align = 2;
 168   mode_Hu->size = 2;
 169   mode_Hu->min = tarval_from_long (mode_Lu, 0x00000000);
 170   mode_Hu->max = tarval_from_long (mode_Lu, 0x0000ffff);
 171   mode_Hu->null = tarval_from_long (mode_Hu, 0);
 172
 173   /* signed integer */
 174   mode_Is->name = id_from_str ("Is", 1);
 175   mode_Is->fsigned = 1;
 176   mode_Is->ffloat = 0;
 177   mode_Is->ld_align = 4;
 178   mode_Is->size = 4;
 179   mode_Is->min = tarval_from_long (mode_Ls, 0x80000000);
 180   mode_Is->max = tarval_from_long (mode_Ls, 0x7fffffff);
 181   mode_Is->null = tarval_from_long (mode_Is, 0);
 182
 183   /* unsigned integer */
 184   mode_Iu->name = id_from_str ("Iu", 1);
 185   mode_Iu->fsigned = 0;
 186   mode_Iu->ffloat = 0;
 187   mode_Iu->ld_align = 4;
 188   mode_Iu->size = 4;
 189   mode_Iu->min = tarval_from_long (mode_Lu, 0x00000000);
 190   mode_Iu->max = tarval_from_long (mode_Lu, 0xffffffff);
 191   mode_Iu->null = tarval_from_long (mode_Iu, 0);
 192
 193   /* signed long integer */
 194   mode_Ls->name = id_from_str ("Ls", 1);
 195   mode_Ls->fsigned = 1;
 196   mode_Ls->ffloat = 0;
 197   mode_Ls->ld_align = 8;
 198   mode_Ls->size = 8;
 199   mode_Ls->min = tarval_from_long (mode_Ls, 0x80000000);
 200   mode_Ls->max = tarval_from_long (mode_Ls, 0x7fffffff);
 201   mode_Ls->null = tarval_from_long (mode_Ls, 0);
 202
 203   /* unsigned long integer */
 204   mode_Lu->name = id_from_str ("Lu", 1);
 205   mode_Lu->fsigned = 0;
 206   mode_Lu->ffloat = 0;
 207   mode_Lu->ld_align = 8;
 208   mode_Lu->size = 8;
 209   mode_Lu->min = tarval_from_long (mode_Lu, 0x00000000);
 210   mode_Lu->max = tarval_from_long (mode_Lu, 0xffffffff);
 211   mode_Lu->null = tarval_from_long (mode_Lu, 0);
 212
 213   /* character */
 214   mode_C->name = id_from_str ("C", 1);
 215   mode_C->fsigned = 0;
 216   mode_C->ffloat = 0;
 217   mode_C->ld_align = 1;
 218   mode_C->size = 1;
 219   mode_C->min = tarval_from_long (mode_Ls, 0xffffff80);
 220   mode_C->max = tarval_from_long (mode_Ls, 0x0000007f);
 221   mode_C->null = tarval_from_long (mode_C, 0);
 222
 223   /* unicode character */
 224   mode_U->name = id_from_str ("U", 1);
 225   mode_U->fsigned = 0;
 226   mode_U->ffloat = 0;
 227   mode_U->ld_align = 1;
 228   mode_U->size = 2;
 229   mode_U->min = tarval_from_long (mode_Ls, 0xffff8000);
 230   mode_U->max = tarval_from_long (mode_Ls, 0x00007fff);
 231   mode_U->null = tarval_from_long (mode_U, 0);
 232
 233   /* boolean */
 234   mode_b->name = id_from_str ("b", 1);
 235   mode_b->fsigned = 0;
 236   mode_b->ffloat = 0;
 237
 238   /* pointer */
 239   mode_P->name = id_from_str ("P", 1);
 240   mode_P->fsigned = 0;
 241   mode_P->ffloat = 0;
 242   mode_P->ld_align = 4;
 243   mode_P->size = 4;
 244   mode_P->min = tarval_from_long (mode_Lu, 0x00000000);
 245   mode_P->max = tarval_from_long (mode_Lu, 0xffffffff);
 246   mode_P->null = tarval_from_long (mode_P, 0);
 247
 248   /* Execution */
 249   mode_X->name = id_from_str ("X", 1);
 250   mode_X->fsigned = 0;
 251   mode_X->ffloat = 0;
 252
 253   /* Memory */
 254   mode_M->name = id_from_str ("M", 1);
 255   mode_M->fsigned = 0;
 256   mode_M->ffloat = 0;
 257
 258   mode_BB->name = id_from_str ("BB", 1);
 259   mode_BB->fsigned = 0;
 260   mode_BB->ffloat = 0;
 261 }
 262
 263 /* Functions for the direct access to all attributes od a ir_mode */
 264
 265 modecode
 266 get_mode_modecode (ir_mode *mode)
 267 {
 268   assert(mode && "no mode given");
 269   return mode->code;
 270 }
 271
 272 /*
 273 INLINE void
 274 set_mode_modecode (ir_mode *mode, modecode code)
 275 {
 276   mode->code = code;
 277 }
 278 */
 279
 280 ident *
 281 get_mode_ident (ir_mode *mode)
 282 {
 283   assert(mode && "no mode given");
 284   return mode->name;
 285 }
 286
 287 /*
 288 INLINE void
 289 set_mode_ident (ir_mode *mode, ident *name)
 290 {
 291   mode->name = name;
 292 }
 293 */
 294
 295 INLINE const char *
 296 get_mode_name       (ir_mode *mode) {
 297   assert(mode);
 298   return id_to_str(mode->name);
 299 }
 300 /* void  set_mode_name       (ir_mode *mode, char *name);    */
 301
 302 int
 303 get_mode_size (ir_mode *mode)
 304 {
 305   assert(mode && "no mode given");
 306   return mode->size;
 307 }
 308 /*
 309 INLINE void
 310 set_mode_size (ir_mode *mode, int size)
 311 {
 312   mode->size = size;
 313 }
 314 */
 315
 316 int
 317 get_mode_ld_align (ir_mode *mode)
 318 {
 319   assert(mode && "no mode given");
 320   return mode->ld_align;
 321 }
 322
 323 /*
 324 INLINE void
 325 set_mode_ld_align (ir_mode *mode, int ld_align)
 326 {
 327   mode->ld_align = ld_align;
 328 }
 329 */
 330
 331 tarval *
 332 get_mode_min (ir_mode *mode)
 333 {
 334   assert(mode && "no mode given");
 335   return mode->min;
 336 }
 337
 338 /*
 339 INLINE void
 340 set_mode_min (ir_mode *mode, tarval *min)
 341 {
 342 mode->min = min;
 343 }
 344 */
 345
 346 tarval *
 347 get_mode_max (ir_mode *mode)
 348 {
 349   assert(mode && "no mode given");
 350   return mode->max;
 351 }
 352
 353 /*
 354 INLINE void
 355 set_mode_max (ir_mode *mode, tarval *max)
 356 {
 357   mode->max = max;
 358 }
 359 */
 360
 361 tarval *
 362 get_mode_null (ir_mode *mode)
 363 {
 364   assert(mode && "no mode given");
 365   return mode->null;
 366 }
 367
 368 /*
 369 INLINE void
 370 set_mode_null (ir_mode *mode, tarval *null)
 371 {
 372   mode->null = null;
 373 }
 374 */
 375
 376 unsigned
 377 get_mode_fsigned (ir_mode *mode)
 378 {
 379   assert(mode && "no mode given");
 380   return mode->fsigned;
 381 }
 382
 383 /*
 384 INLINE voida
 385 set_mode_fsigned (ir_mode *mode, unsigned fsigned)
 386 {
 387   mode->fsigned = fsigned;
 388 }
 389 */
 390
 391 unsigned
 392 get_mode_ffloat (ir_mode *mode)
 393 {
 394   assert(mode && "no mode given");
 395   return mode->ffloat;
 396 }
 397
 398 /*
 399 INLINE void
 400 set_mode_ffloat (ir_mode *mode, unsigned ffloat)
 401 {
 402   mode->ffloat = ffloat;
 403 }
 404 */
 405
 406 /* Functions to check, whether a modecode is signed, float, int, num, data,
 407    datab or dataM. For more exact definitions read the corresponding pages
 408    in the firm documentation or the followingenumeration
 409
 410    The set of "float" is defined as:
 411    ---------------------------------
 412    float = {irm_F, irm_D, irm_E}
 413
 414    The set of "int" is defined as:
 415    -------------------------------
 416    int   = {irm_Bs, irm_Bu, irm_Hs, irm_Hu, irm_Is, irm_Iu, irm_Ls, irm_Lu}
 417
 418    The set of "num" is defined as:
 419    -------------------------------
 420    num   = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 421             irm_Is, irm_Iu, irm_Ls, irm_Lu}
 422             = {float || int}
 423
 424    The set of "data" is defined as:
 425    -------------------------------
 426    data  = {irm_F, irm_D, irm_E irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 427             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_p}
 428             = {num || irm_C || irm_P}
 429
 430    The set of "datab" is defined as:
 431    ---------------------------------
 432    datab = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 433             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_b}
 434             = {data || irm_b }
 435
 436    The set of "dataM" is defined as:
 437    ---------------------------------
 438    dataM = {irm_F, irm_D, irm_E, irm_Bs, irm_Bu, irm_Hs, irm_Hu,
 439             irm_Is, irm_Iu, irm_Ls, irm_Lu, irm_C, irm_U, irm_P, irm_M}
 440             = {data || irm_M}
 441 */
 442
 443 int
 444 mode_is_signed (ir_mode *mode)
 445 {
 446   int res;
 447   unsigned fsigned;
 448
 449   assert(mode && "no mode given");
 450   fsigned = get_mode_fsigned (mode);
 451   if (fsigned == 1) {
 452     res = 1;
 453   }
 454   else {
 455     res = 0;
 456   }
 457   return res;
 458 }
 459
 460 INLINE int
 461 mode_is_float (ir_mode *mode)
 462 {
 463   int res;
 464   unsigned ffloat;
 465
 466   assert(mode && "no mode given");
 467   ffloat = get_mode_ffloat (mode);
 468   if (ffloat == 1) {
 469     res = 1;
 470   }
 471   else {
 472     res = 0;
 473   }
 474   return res;
 475 }
 476
 477
 478 INLINE int
 479 mode_is_int (ir_mode *mode)
 480 {
 481   int res;
 482   modecode code;
 483
 484   assert(mode && "no mode given");
 485   code = get_mode_modecode (mode);
 486   if ((code >= irm_Bs) &&  (code <= irm_Lu)) {
 487     res = 1;
 488   }
 489   else {
 490     res = 0;
 491   }
 492   return res;
 493 }
 494
 495
 496 INLINE int
 497 mode_is_num (ir_mode *mode)
 498 {
 499   int res;
 500
 501   assert(mode && "no mode given");
 502   if (mode_is_int (mode) || mode_is_float (mode)) {
 503     res = 1;
 504   }
 505   else {
 506     res = 0;
 507   }
 508   return res;
 509 }
 510
 511 INLINE int
 512 mode_is_data (ir_mode *mode)
 513 {
 514   int res;
 515   modecode code;
 516
 517   assert(mode && "no mode given");
 518   code = get_mode_modecode (mode);
 519   if (mode_is_num (mode) ||
 520       code == irm_C || code == irm_U || code == irm_P) {
 521     res = 1;
 522   }
 523   else {
 524     res = 0;
 525   }
 526   return res;
 527 }
 528
 529 int
 530 mode_is_datab (ir_mode *mode)
 531 {
 532   int res;
 533   modecode code;
 534
 535   assert(mode && "no mode given");
 536   code = get_mode_modecode (mode);
 537   if (mode_is_data (mode) || code == irm_b ) {
 538     res = 1;
 539   }
 540   else {
 541     res = 0;
 542   }
 543   return res;
 544 }
 545
 546 int
 547 mode_is_dataM (ir_mode *mode)
 548 {
 549   int res;
 550   modecode code;
 551
 552   assert(mode && "no mode given");
 553   code = get_mode_modecode (mode);
 554   if (mode_is_data (mode) || code == irm_M) {
 555     res = 1;
 556   }
 557   else {
 558     res = 0;
 559   }
 560   return res;
 561 }
 562
 563 /* Returns true if sm can be converted to lm without loss. */
 564 bool
 565 smaller_mode(ir_mode *sm, ir_mode *lm) {
 566   if ((mode_is_int(sm) && mode_is_int(lm)) &&
 567       get_mode_modecode(sm) <= get_mode_modecode(lm))
 568     return true;
 569   if ((mode_is_float(sm) && mode_is_float(lm)) &&
 570       get_mode_modecode(sm) <= get_mode_modecode(lm))
 571     return true;
 572   return(false);
 573 }