/* TV --- Target Values, aka Constant Table.
Copyright (C) 1995, 1996 Christian von Roques */
+/* $Id$ */
+
/* This implementation assumes:
* target characters/strings can be represented as type `char'/`char *',
* host's type `long'/`unsigned long' can hold values of mode `l'/`L',
values is cheaper than the extra obstack_alloc()/free() for
discarded ones. */
+/* Defining this causes inclusions of functions renamed with new gmp.h */
+#define _TARVAL_GMP_ 0
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
+# include "xprintf.h"
#include <assert.h>
#include <limits.h>
+#include <errno.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "obst.h"
#include "ieee754.h"
#include "tune.h"
-#include "ident.h"
-#include "tv.h"
+#include "ident_t.h"
+#include "tv_t.h"
+#include "entity_t.h"
+#include "irmode.h"
static struct obstack tv_obst; /* obstack for all the target values */
static pset *tarvals; /* pset containing pointers to _all_ tarvals */
static inline bool
chil_overflow (tarval_chil chil, ir_mode *mode)
{
- assert (is_chilCHIL(mode->code));
- return (mode->min && mode->max /* only valid after firm initialization */
- && (chil < tv_val_chil (mode->min) || tv_val_chil (mode->max) < chil));
+ assert (is_chilCHIL(get_mode_modecode(mode)));
+ return (get_mode_min(mode) && get_mode_max(mode) /* only valid after firm initialization */
+ && (chil < tv_val_chil (get_mode_min(mode))
+ || tv_val_chil (get_mode_max(mode)) < chil));
}
static inline bool
CHIL_overflow (tarval_CHIL CHIL, ir_mode *mode)
{
- assert (is_chilCHIL(mode->code));
- return (mode->max /* only valid after firm initialization */
- && tv_val_CHIL (mode->max) < CHIL);
+ assert (is_chilCHIL(get_mode_modecode(mode)));
+ return (get_mode_max(mode) /* only valid after firm initialization */
+ && tv_val_CHIL (get_mode_max(mode)) < CHIL);
}
_tarval_vrfy (const tarval *val)
{
assert (val);
- switch (val->mode->code) {
+ switch (get_mode_modecode(val->mode)) {
/* floating */
case irm_f:
case irm_d:
TARVAL_VRFY (b);
if (a == b) return 0;
- if (a->mode - b->mode) return a->mode - b->mode;
+ if ((void *)a->mode - (void *)b->mode)
+ return (void *)a->mode - (void *)b->mode;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f:
return memcmp (&a->u.f, &b->u.f, sizeof (a->u.f));
}
return a->u.chil != b->u.chil;
case irm_Z:
+#if _TARVAL_GMP_
return mpz_cmp (&a->u.Z, &b->u.Z);
+#else
+ return 99; /* ?? */
+#endif
/* strange */
case irm_p:
if (a->u.p.ent || b->u.p.ent)
{
unsigned h;
- h = tv->mode->code * 0x421u;
- switch (tv->mode->code) {
+ h = get_mode_modecode(tv->mode) * 0x421u;
+ switch (get_mode_modecode(tv->mode)) {
case irm_T:
h = 0x94b527ce; break;
case irm_f:
case irm_c: case irm_h: case irm_i: case irm_l:
h ^= tv->u.chil; break;
case irm_Z:
+#if _TARVAL_GMP_
h ^= mpz_get_ui (&tv->u.Z); break;
+#else
+ h ^= (unsigned int) tv; break; /* tut das? */
+#endif
case irm_p:
if (tv->u.p.ent) {
/* @@@ lower bits not random, watch for collisions; perhaps
\f
-/******************** Initialization ****************************************/
+/*** ***************** Initialization ************************************* ***/
void
tarval_init_1 (void)
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_T;
- tv->lab = 0;
tarval_bad = tarval_identify (tv);
tarval_b_false = tarval_from_long (mode_b, 0);
/* IsInf <-> exponent == 0x7ff && ! (bits | fraction_low) */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_d;
- tv->lab = 0;
x.ieee.negative = 0;
x.ieee.exponent = 0x7ff;
x.ieee.mantissa0 = 0;
/* IsNaN <-> exponent==0x7ff && (qnan_bit | bits | fraction_low) */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_d;
- tv->lab = 0;
x.ieee_nan.negative = 0;
x.ieee_nan.exponent = 0x7ff;
x.ieee_nan.quiet_nan = 1; /* @@@ quiet or signalling? */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_p;
- tv->lab = 0;
tv->u.p.xname = NULL;
tv->u.p.ent = NULL;
tv->u.p.tv = NULL;
\f
-/************************* Constructors for tarvals *************************/
+/*** ********************** Constructors for tarvals ********************** ***/
/* copy from src to dst len chars omitting '_'. */
static char *
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_Z;
- tv->lab = 0;
+#if _TARVAL_GMP_
if (mpz_init_set_str (&tv->u.Z, buf, base)) assert (0);
+#else
+ assert(0 && "no support for Z in tv!");
+#endif
return tarval_identify (tv);
}
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_B;
- tv->lab = 0;
assert (s[0] == '0');
switch (s[1]) {
}
+tarval *
+tarval_f_from_str (const char *s, size_t len)
+{
+ tarval *tv;
+ char *buf;
+ char *eptr;
+
+ assert (!BUILDING);
+
+ buf = alloca (len+1);
+ stripcpy (buf, s, len);
+
+ tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
+ tv->mode = mode_f;
+ tv->u.f = (float)strtod (buf, &eptr);
+ assert (eptr == buf+strlen(buf));
+
+ return tarval_identify (tv);
+}
+
+
tarval *
tarval_d_from_str (const char *s, size_t len)
{
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_d;
- tv->lab = 0;
tv->u.d = strtod (buf, &eptr);
assert (eptr == buf+strlen(buf));
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_s;
- tv->lab = 0;
tv->u.s.n = len;
tv->u.s.p = obstack_copy (&tv_obst, s, len);
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_S;
- tv->lab = 0;
tv->u.s.n = len;
tv->u.s.p = obstack_copy (&tv_obst, s, len);
return tarval_identify (tv);
}
+tarval *tarval_int_from_str (const char *s, size_t len, int base, ir_mode *m) {
+ long val;
+ char *eptr;
+ char *buf;
+
+ assert (mode_is_int(m));
+ assert (!BUILDING);
+
+ buf = alloca (len+1);
+ stripcpy (buf, s, len);
+
+ errno = 0;
+ val = strtol(buf, &eptr, base); /* strtoll */
+ assert (eptr == buf+strlen(buf));
+ if ((errno == ERANGE) &&
+ ((m == mode_l) || (m == mode_L)) ) {
+ printf("WARNING: Constant %s not representable. Continuing with %ld.\n",
+ s, val);
+ }
+
+ return tarval_from_long(m, val);
+}
/* Create a tarval with mode `m' and value `i' casted to the type that
represents such tarvals on host. The resulting value must be legal
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = m;
- tv->lab = 0;
- switch (m->code) {
+ switch (get_mode_modecode(m)) {
/* floating */
case irm_f:
tv->u.f = val; break;
case irm_c: case irm_h: case irm_i: case irm_l:
tv->u.chil = val; break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init_set_si (&tv->u.Z, val);
+#else
+ assert(0 && "no support for Z in tv!");
+#endif
break;
/* strange */
case irm_p:
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_p;
- tv->lab = 0;
tv->u.p.xname = obstack_copy0 (&tv_obst, xname, strlen (xname));
tv->u.p.ent = NULL;
tv->u.p.tv = NULL;
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_p;
- tv->lab = 0;
tv->u.p.xname = NULL;
tv->u.p.ent = ent;
tv->u.p.tv = NULL;
tv = obstack_finish (&tv_obst);
p = (unsigned char *)tv + sizeof (tarval);
tv->mode = m;
- tv->lab = 0;
- switch (m->code) {
+ switch (get_mode_modecode(m)) {
case irm_C:
tv->u.CHIL = ch;
break;
\f
-/********************* Arithmethic operations on tarvals ********************/
+/*** ****************** Arithmethic operations on tarvals ***************** ***/
/* Return `src' converted to mode `m' if representable, else NULL.
@@@ lots of conversions missing */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = m;
- tv->lab = 0;
- switch (src->mode->code) {
+ switch (get_mode_modecode(src->mode)) {
case irm_d:
if (m != mode_f) goto fail;
break;
case irm_Z:
- switch (m->code) {
+#if _TARVAL_GMP_
+ switch (get_mode_modecode(m)) {
case irm_C: case irm_H: case irm_I: case irm_L:
if (mpz_cmp_si (&src->u.Z, 0) < 0) goto fail;
default: goto fail;
}
+#else
+ goto fail;
+#endif
break;
case irm_c: case irm_h: case irm_i: case irm_l:
- switch (m->code) {
+ switch (get_mode_modecode(m)) {
case irm_c: case irm_h: case irm_i: case irm_l:
tv->u.chil = src->u.chil;
if (chil_overflow (tv->u.chil, m)) goto fail;
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init_set_si (&tv->u.Z, src->u.chil);
+#else
+ goto fail;
+#endif
break;
case irm_b:
}
case irm_C: case irm_H: case irm_I: case irm_L:
- switch (m->code) {
+ switch (get_mode_modecode(m)) {
case irm_c: case irm_h: case irm_i: case irm_l:
tv->u.chil = src->u.CHIL;
if (chil_overflow (tv->u.chil, m)) goto fail;
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init_set_ui (&tv->u.Z, src->u.CHIL);
+#else
+ goto fail;
+#endif
break;
case irm_b:
break;
case irm_b:
- switch (m->code) {
+ switch (get_mode_modecode(m)) {
case irm_c: case irm_h: case irm_i: case irm_l:
tv->u.chil = src->u.b;
break;
}
+/* GL Why are there no ArmRoq comments, why is this not used? */
tarval *
tarval_neg (tarval *a)
{
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f: tv->u.f = -a->u.f; break;
case irm_d: tv->u.d = -a->u.d; break;
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
- tv->u.CHIL = -a->u.CHIL & tv_val_CHIL (a->mode->max);
+ tv->u.CHIL = -a->u.CHIL & tv_val_CHIL (get_mode_max(a->mode));
break;
/* signed */
case irm_c: case irm_h: case irm_i: case irm_l:
}
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_neg (&tv->u.Z, &a->u.Z);
+#else
+ obstack_free (&tv_obst, tv);
+ tv = a;
+ printf("\nWrong negation\n\n");
+#endif
break;
/* strange */
case irm_b: tv->u.b = !a->u.b; break;
assert (a->mode == b->mode);
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f: return ( a->u.f == b->u.f ? irpn_Eq
: a->u.f > b->u.f ? irpn_Gt
: a->u.chil > b->u.chil ? irpn_Gt
: irpn_Lt);
case irm_Z:
- { int cmp = mpz_cmp (&a->u.Z, &b->u.Z);
+ {
+#if _TARVAL_GMP_
+ int cmp = mpz_cmp (&a->u.Z, &b->u.Z);
return ( cmp == 0 ? irpn_Eq
: cmp > 0 ? irpn_Gt
: irpn_Lt);
+#else
+ return irpn_False;
+#endif
}
/* strange */
case irm_b: return ( a->u.b == b->u.b ? irpn_Eq
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f: tv->u.f = a->u.f + b->u.f; break; /* @@@ overflow etc */
case irm_d: tv->u.d = a->u.d + b->u.d; break; /* @@@ dto. */
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
- tv->u.CHIL = (a->u.CHIL + b->u.CHIL) & tv_val_CHIL (a->mode->max);
+ tv->u.CHIL = (a->u.CHIL + b->u.CHIL) & tv_val_CHIL (get_mode_max(a->mode));
break;
/* signed */
case irm_c: case irm_h: case irm_i: case irm_l:
}
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_add (&tv->u.Z, &a->u.Z, &b->u.Z);
+#else
+ obstack_free (&tv_obst, tv);
+ return NULL;
+#endif
break;
/* strange */
case irm_b: tv->u.b = a->u.b | b->u.b; break; /* u.b is in canonical form */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f: tv->u.f = a->u.f - b->u.f; break; /* @@@ overflow etc */
case irm_d: tv->u.d = a->u.d - b->u.d; break; /* @@@ dto. */
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
- tv->u.CHIL = (a->u.CHIL - b->u.CHIL) & tv_val_CHIL (a->mode->max);
+ tv->u.CHIL = (a->u.CHIL - b->u.CHIL) & tv_val_CHIL (get_mode_max(a->mode));
break;
/* signed */
case irm_c: case irm_h: case irm_i: case irm_l:
}
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_sub (&tv->u.Z, &a->u.Z, &b->u.Z);
+#else
+ obstack_free (&tv_obst, tv);
+ return NULL;
+#endif
break;
/* strange */
case irm_b: tv->u.b = a->u.b & ~b->u.b; break; /* u.b is in canonical form */
return tarval_identify (tv);
}
-
/* Return `a*b' if computable, else NULL. Modes must be equal. */
tarval *
tarval_mul (tarval *a, tarval *b)
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f: tv->u.f = a->u.f * b->u.f; break; /* @@@ overflow etc */
case irm_d: tv->u.d = a->u.d * b->u.d; break; /* @@@ dto. */
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
- tv->u.CHIL = (a->u.CHIL * b->u.CHIL) & tv_val_CHIL (a->mode->max);
+ tv->u.CHIL = (a->u.CHIL * b->u.CHIL) & tv_val_CHIL (get_mode_max(a->mode));
break;
/* signed */
case irm_c: case irm_h: case irm_i: case irm_l:
}
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_mul (&tv->u.Z, &a->u.Z, &b->u.Z);
+#else
+ obstack_free (&tv_obst, tv);
+ return NULL;
+#endif
break;
/* strange */
case irm_b: tv->u.b = a->u.b & b->u.b; break; /* u.b is in canonical form */
TARVAL_VRFY (a); TARVAL_VRFY (b);
assert (a->mode == b->mode);
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f:
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_f;
- tv->lab = 0;
tv->u.f = a->u.f / b->u.f; /* @@@ overflow etc */
break;
case irm_d:
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = mode_d;
- tv->lab = 0;
tv->u.d = a->u.d / b->u.d; /* @@@ overflow etc */
break;
default:
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f: tv->u.f = floor (a->u.f / b->u.f); break; /* @@@ overflow etc */
case irm_d: tv->u.d = floor (a->u.d / b->u.d); break; /* @@@ dto. */
/* signed */
case irm_c: case irm_h: case irm_i: case irm_l:
if ( !b->u.chil
- || ((b->u.chil == -1) && (a->u.chil == tv_val_chil (a->mode->max) ))) {
+ || ((b->u.chil == -1) && (a->u.chil == tv_val_chil (get_mode_max(a->mode)) ))) {
fail:
obstack_free (&tv_obst, tv);
return NULL;
tv->u.chil = a->u.chil / b->u.chil;
break;
case irm_Z:
+#if _TARVAL_GMP_
if (!mpz_cmp_ui (&b->u.Z, 0)) goto fail;
mpz_init (&tv->u.Z);
mpz_div (&tv->u.Z, &a->u.Z, &b->u.Z);
+#else
+ goto fail;
+#endif
break;
/* strange */
case irm_b: tv->u.b = a->u.b ^ b->u.b; break; /* u.b is in canonical form */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* floating */
case irm_f: tv->u.f = fmod (a->u.f, b->u.f); break; /* @@@ overflow etc */
case irm_d: tv->u.d = fmod (a->u.d, b->u.d); break; /* @@@ dto */
tv->u.chil = a->u.chil % b->u.chil;
break;
case irm_Z:
+#if _TARVAL_GMP_
if (!mpz_cmp_ui (&b->u.Z, 0)) goto fail;
mpz_init (&tv->u.Z);
mpz_mod (&tv->u.Z, &a->u.Z, &b->u.Z);
+#else
+ goto fail;
+#endif
break;
/* strange */
case irm_b: tv->u.b = a->u.b ^ b->u.b; break; /* u.b is in canonical form */
return tarval_identify (tv);
}
+/* Return |a| if computable, else Null. */
+/* is -max == min?? */
+tarval *
+tarval_abs (tarval *a) {
+ TARVAL_VRFY (a);
+ if (tv_is_negative(a)) return tarval_neg(a);
+ return a;
+}
+
+int
+tv_is_negative(tarval *a) {
+ TARVAL_VRFY (a);
+ switch (get_mode_modecode(a->mode)) {
+ /* floating */
+ case irm_f: return (a->u.f<0); break;
+ case irm_d: return (a->u.d<0); break;
+ /* unsigned */
+ case irm_C: case irm_H: case irm_I: case irm_L:
+ return 0;
+ break;
+ /* signed */
+ case irm_c: case irm_h: case irm_i: case irm_l:
+ return (a->u.chil < 0);
+ break;
+ case irm_Z:
+ break;
+ case irm_b: break;
+ default: assert(0);
+ }
+
+ return 0;
+}
+
/* Return `a&b'. Modes must be equal. */
tarval *
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
tv->u.CHIL = a->u.CHIL & b->u.CHIL; break;
case irm_c: case irm_h: case irm_i: case irm_l:
tv->u.chil = a->u.chil & b->u.chil; break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_and (&tv->u.Z, &a->u.Z, &b->u.Z);
+#else
+ assert(0);
+#endif
break;
/* strange */
case irm_b: tv->u.b = a->u.b & b->u.b; break; /* u.b is in canonical form */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
tv->u.CHIL = a->u.CHIL | b->u.CHIL; break;
case irm_c: case irm_h: case irm_i: case irm_l:
tv->u.chil = a->u.chil | b->u.chil; break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_ior (&tv->u.Z, &a->u.Z, &b->u.Z);
+#else
+ assert(0);
+#endif
break;
/* strange */
case irm_b: tv->u.b = a->u.b | b->u.b; break; /* u.b is in canonical form */
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
tv->u.CHIL = a->u.CHIL ^ b->u.CHIL; break;
case irm_c: case irm_h: case irm_i: case irm_l:
tv->u.chil = a->u.chil ^ b->u.chil; break;
case irm_Z:
-#if 0 /* gmp-1.3.2 declares but does not define mpz_xor() */
+#if 0
+ /* gmp-1.3.2 declares but does not define mpz_xor() */
mpz_init (&tv->u.Z);
mpz_xor (&tv->u.Z, &a->u.Z, &b->u.Z);
#endif
shift = tarval_ord (b, &b_is_huge);
if ( b_is_huge
|| (shift < 0)
- || ((shift >= mode_l->size*target_bits) && (a->mode != mode_Z))) {
+ || ((shift >= get_mode_size(mode_l)*target_bits) && (a->mode != mode_Z))) {
return NULL;
}
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
tv->u.CHIL = a->u.CHIL << shift;
tv->u.chil = a->u.chil << shift;
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_mul_2exp (&tv->u.Z, &a->u.Z, shift);
+#else
+ assert(0);
+#endif
break;
default: assert (0);
}
}
-/* Return `a>>b' if computable, else NULL. */
+/* Return `a>>b' if computable, else NULL.
+ The interpretation of >> (sign extended or not) is implementaion
+ dependent, i.e. this is neither shr nor shrs!! */
tarval *
tarval_shr (tarval *a, tarval *b)
{
shift = tarval_ord (b, &b_is_huge);
if ( b_is_huge
|| (shift < 0)
- || ((shift >= mode_l->size*target_bits) && (a->mode != mode_Z))) {
+ || ((shift >= get_mode_size(mode_l)*target_bits) && (a->mode != mode_Z))) {
return NULL;
}
tv = (tarval *)obstack_alloc (&tv_obst, sizeof (tarval));
tv->mode = a->mode;
- tv->lab = 0;
- switch (a->mode->code) {
+ switch (get_mode_modecode(a->mode)) {
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
tv->u.CHIL = a->u.CHIL >> shift;
tv->u.chil = a->u.chil >> shift;
break;
case irm_Z:
+#if _TARVAL_GMP_
mpz_init (&tv->u.Z);
mpz_div_2exp (&tv->u.Z, &a->u.Z, shift);
+#else
+ assert(0);
+#endif
break;
default: assert (0);
}
TARVAL_VRFY (tv);
- switch (tv->mode->code) {
+ switch (get_mode_modecode(tv->mode)) {
/* floating */
case irm_f: case irm_d:
return 2;
/* unsigned */
case irm_C:
- return (long)((tv->u.CHIL+1) & tv_val_CHIL (mode_C->max)) - 1;
+ return (long)((tv->u.CHIL+1) & tv_val_CHIL (get_mode_max(mode_C))) - 1;
case irm_H:
- return (long)((tv->u.CHIL+1) & tv_val_CHIL (mode_H->max)) - 1;
+ return (long)((tv->u.CHIL+1) & tv_val_CHIL (get_mode_max(mode_H))) - 1;
case irm_I:
- return (long)((tv->u.CHIL+1) & tv_val_CHIL (mode_I->max)) - 1;
+ return (long)((tv->u.CHIL+1) & tv_val_CHIL (get_mode_max(mode_I))) - 1;
case irm_L:
- return (long)((tv->u.CHIL+1) & tv_val_CHIL (mode_L->max)) - 1;
+ return (long)((tv->u.CHIL+1) & tv_val_CHIL (get_mode_max(mode_L))) - 1;
/* signed */
case irm_c: case irm_h: case irm_i: case irm_l:
return tv->u.chil;
case irm_Z:
+#if _TARVAL_GMP_
if (mpz_cmp_si (&tv->u.Z, 0)) return 0;
else if (mpz_cmp_si (&tv->u.Z, 1)) return 1;
else if (mpz_cmp_si (&tv->u.Z,-1)) return -1;
+#endif
return 2;
/* strange */
case irm_b:
}
+#if _TARVAL_GMP_
bool
tarval_s_fits (tarval *tv, long min, long max) {
return (( mpz_cmp_si (&tv->u.Z, min) >= 0)
return (( mpz_sgn (&tv->u.Z) >= 0)
&& mpz_cmp_si (&tv->u.Z, max) <= 0);
}
-
+#endif
/* Convert `tv' into type `long', set `fail' if not representable.
If `fail' gets set for an unsigned `tv', the correct result can be
{
TARVAL_VRFY (tv);
- switch (tv->mode->code) {
+ switch (get_mode_modecode(tv->mode)) {
/* unsigned */
case irm_C: case irm_H: case irm_I: case irm_L:
- *fail = tv->u.CHIL > tv_val_CHIL (mode_l->max);
+ *fail = tv->u.CHIL > tv_val_CHIL (get_mode_max(mode_l));
return tv->u.CHIL;
/* signed */
case irm_c: case irm_h: case irm_i: case irm_l:
*fail = 0;
return tv->u.chil;
case irm_Z:
- *fail = ( (mpz_cmp_si (&tv->u.Z, tv_val_chil(mode_l->max)) > 0)
- || (mpz_cmp_si (&tv->u.Z, tv_val_chil(mode_l->min)) < 0));
+#if _TARVAL_GMP_
+ *fail = ( (mpz_cmp_si (&tv->u.Z, tv_val_chil(get_mode_max(mode_l))) > 0)
+ || (mpz_cmp_si (&tv->u.Z, tv_val_chil(get_mode_max(mode_l))) < 0));
return mpz_get_si (&tv->u.Z);
+#else
+ *fail = 1;
+ return 0;
+#endif
/* strange */
case irm_b:
*fail = 0;
}
}
-
\f
int
tarval_print (XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
{
tarval *val = XP_GETARG (tarval *, 0);
int printed;
+ char buf[40];
TARVAL_VRFY (val);
- switch (val->mode->code) {
+ switch (get_mode_modecode(val->mode)) {
case irm_T: /* none */
printed = XPSR ("<bad>");
break;
case irm_f: /* float */
- printed = XPF1R ("%g", (double)(val->u.f));
+ sprintf (buf, "%1.9e", (float)(val->u.f));
+ printed = XPF1R ("%s", buf);
break;
case irm_d: /* double */
- printed = XPF1R ("%g", (double)(val->u.d));
+ printed = XPF1R ("%1.30g", (double)(val->u.d));
break;
case irm_c: /* signed char */
if (isprint (val->u.chil)) {
printed = XPF1R ("'%c'", val->u.chil);
} else {
- printed = XPF1R ("'\\%03o'", val->u.chil);
+ printed = XPF1R ("0x%x", (unsigned long)val->u.chil);
}
break;
if (val->u.p.xname) {
printed = XPR (val->u.p.xname);
} else if (val->u.p.ent) {
- printed = XPF1R ("(%I)", val->u.p.ent->name);
+ if (get_entity_peculiarity(val->u.p.ent) == existent)
+ printed = XPF1R ("&(%I)", get_entity_ld_ident(val->u.p.ent));
+ else
+ printed = XPSR ("(NULL)");
} else {
assert (val == tarval_p_void);
printed = XPSR ("(void)");
return printed;
}
-\f
-/* Labeling of tarvals */
-// CS-hac
-/*
-label
-tarval_label (tarval *tv)
-{
- if (!tv->lab) {
- tv->lab = new_label();
- tv->used = 1;
- }
- return tv->lab;
-}
-
-
-void
-tarval_forall_labeled (int (*f) (tarval *, void *), void *data)
-{
- tarval *tv;
-
- for (tv = pset_first (tarvals); tv; tv = pset_next (tarvals)) {
- if (tv->lab && f (tv, data)) {
- pset_break (tarvals);
- return;
- }
- }
-}
-*/
ir_mode *
get_tv_mode (tarval *tv)
{
return tv->mode;
}
+
+
+entity *get_tv_entity(tarval *tv)
+{
+ /*assert(??? && "not a pointer to an entity");*/
+ return tv->u.p.ent;
+}
projects / libfirm / blobdiff