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