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