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