#include <assert.h> /* assertions */
#include <stdlib.h> /* atoi() */
#include <string.h> /* nice things for strings */
+#include <strings.h> /* nice things for strings */
-#include <malloc.h>
+#include <stdlib.h>
#include "tv_t.h"
#include "set.h" /* to store tarvals in */
#include "tune.h" /* some constants */
#include "irmode.h" /* defines modes etc */
#include "irmode_t.h"
#include "irnode.h" /* defines boolean return values */
-#include "xprintf.h"
-#include "xp_help.h"
#include "host.h"
#include "strcalc.h"
#include "fltcalc.h"
printf("%s:%d: Invalid tarval (null)", file, line);
assert(0);
}
+#ifdef __GNUC__
+INLINE static void tarval_verify(tarval *tv) __attribute__ ((unused));
+#endif
-static void tarval_verify(tarval *tv)
+INLINE static void tarval_verify(tarval *tv)
{
assert(tv);
assert(tv->mode);
{
switch (get_mode_sort(tv->mode))
{
- case character:
- case int_number:
+ case irms_int_number:
if (sc_comp(tv->value, get_mode_max(tv->mode)->value) == 1) return 1;
if (sc_comp(tv->value, get_mode_min(tv->mode)->value) == -1) return 1;
break;
- case float_number:
+ case irms_float_number:
+ /*
+ * TODO: check NaNs
+ */
if (fc_comp(tv->value, get_mode_max(tv->mode)->value) == 1) return 1;
if (fc_comp(tv->value, get_mode_min(tv->mode)->value) == -1) return 1;
break;
return 0;
}
-/****************************************************************************
+/*
* public variables declared in tv.h
- ****************************************************************************/
+ */
tarval *tarval_bad;
tarval *tarval_undefined;
tarval *tarval_b_false;
tarval *tarval_b_true;
tarval *tarval_P_void;
-/****************************************************************************
+/*
* public functions declared in tv.h
- ****************************************************************************/
+ */
+
/*
* Constructors =============================================================
*/
switch (get_mode_sort(mode))
{
- case auxiliary:
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
assert(0);
break;
- case internal_boolean:
+ case irms_internal_boolean:
/* match tTrRuUeE/fFaAlLsSeE */
if (strcasecmp(str, "true")) return tarval_b_true;
else if (strcasecmp(str, "false")) return tarval_b_true;
else
return atoi(str) ? tarval_b_true : tarval_b_false;
- case float_number:
+ case irms_float_number:
fc_val_from_str(str, len);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
sc_val_from_str(str, len);
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
- case reference:
+ case irms_reference:
return get_tarval(str, len, mode);
}
}
#endif
+/*
+ * helper function, create a tarval from long
+ */
tarval *new_tarval_from_long(long l, ir_mode *mode)
{
ANNOUNCE();
- assert(mode && !(get_mode_sort(mode) == auxiliary));
+ assert(mode && !((get_mode_sort(mode) == irms_memory)||(get_mode_sort(mode)==irms_control_flow)||(get_mode_sort(mode)==irms_auxiliary)));
switch(get_mode_sort(mode))
{
- case internal_boolean:
+ case irms_internal_boolean:
/* XXX C-Semantics ! */
return l ? tarval_b_true : tarval_b_false ;
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
sc_val_from_long(l);
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
- case float_number:
+ case irms_float_number:
return new_tarval_from_double((long double)l, mode);
- case reference:
+ case irms_reference:
return l ? tarval_bad : get_tarval(NULL, 0, mode); /* null pointer or tarval_bad */
default:
return NULL;
}
+/* returns non-zero if can be converted to long */
int tarval_is_long(tarval *tv)
{
ANNOUNCE();
- return ((get_mode_sort(tv->mode) == int_number) || (get_mode_sort(tv->mode) == character));
+ if (get_mode_sort(tv->mode) != irms_int_number) return 0;
+
+ if (get_mode_size_bits(tv->mode) > sizeof(long)<<3)
+ {
+ /* the value might be too big to fit in a long */
+ sc_max_from_bits(sizeof(long)<<3, 0);
+ if (sc_comp(sc_get_buffer(), tv->value) == -1)
+ {
+ /* really doesn't fit */
+ return 0;
+ }
+ }
+ return 1;
}
/* this might overflow the machine's long, so use only with small values */
long tarval_to_long(tarval* tv)
{
ANNOUNCE();
- assert(tv && get_mode_sort(tv->mode) == int_number);
+ assert(tarval_is_long(tv) && "tarval too big to fit in long");
- return sc_val_to_long(tv->value); /* might overflow */
+ return sc_val_to_long(tv->value);
}
tarval *new_tarval_from_double(long double d, ir_mode *mode)
{
ANNOUNCE();
- assert(mode && (get_mode_sort(mode) == float_number));
+ assert(mode && (get_mode_sort(mode) == irms_float_number));
fc_val_from_float(d);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
}
+/* returns non-zero if can be converted to double */
int tarval_is_double(tarval *tv)
{
ANNOUNCE();
assert(tv);
- return (get_mode_sort(tv->mode) == float_number);
+ return (get_mode_sort(tv->mode) == irms_float_number);
}
long double tarval_to_double(tarval *tv)
{
ANNOUNCE();
assert(ent);
- assert(mode && (get_mode_sort(mode) == reference));
+ assert(mode && (get_mode_sort(mode) == irms_reference));
return get_tarval((void *)ent, 0, mode);
}
ANNOUNCE();
assert(tv);
/* tv->value == NULL means dereferencing a null pointer */
- return ((get_mode_sort(tv->mode) == reference) && (tv->value != NULL) && (tv->length == 0));
+ return ((get_mode_sort(tv->mode) == irms_reference) && (tv->value != NULL) && (tv->length == 0)
+ && (tv != tarval_P_void));
}
entity *tarval_to_entity(tarval *tv)
switch(get_mode_sort(mode))
{
- case reference:
- case auxiliary:
+ case irms_reference:
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
assert(0);
break;
- case internal_boolean:
+ case irms_internal_boolean:
return tarval_b_true;
- case float_number:
+ case irms_float_number:
fc_get_max(get_mode_size_bits(mode));
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
sc_max_from_bits(get_mode_size_bits(mode), mode_is_signed(mode));
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
}
switch(get_mode_sort(mode))
{
- case reference:
- case auxiliary:
+ case irms_reference:
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
assert(0);
break;
- case internal_boolean:
+ case irms_internal_boolean:
return tarval_b_false;
- case float_number:
+ case irms_float_number:
fc_get_min(get_mode_size_bits(mode));
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
sc_min_from_bits(get_mode_size_bits(mode), mode_is_signed(mode));
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), mode);
}
switch(get_mode_sort(mode))
{
- case auxiliary:
- case internal_boolean:
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
+ case irms_internal_boolean:
assert(0);
break;
- case float_number:
+ case irms_float_number:
return new_tarval_from_double(0.0, mode);
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
return new_tarval_from_long(0l, mode);
- case reference:
+ case irms_reference:
return tarval_P_void;
}
return tarval_bad;
switch(get_mode_sort(mode))
{
- case auxiliary:
- case internal_boolean:
- case reference:
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
+ case irms_internal_boolean:
+ case irms_reference:
assert(0);
break;
- case float_number:
+ case irms_float_number:
return new_tarval_from_double(1.0, mode);
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
return new_tarval_from_long(1l, mode);
break;
}
ANNOUNCE();
assert(mode);
- if (get_mode_sort(mode) == float_number) {
+ if (get_mode_sort(mode) == irms_float_number) {
fc_get_nan();
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
}
ANNOUNCE();
assert(mode);
- if (get_mode_sort(mode) == float_number) {
+ if (get_mode_sort(mode) == irms_float_number) {
fc_get_inf();
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), mode);
}
switch (get_mode_sort(a->mode))
{
- case int_number:
+ case irms_int_number:
if (!mode_is_signed(a->mode)) return 0;
else
return sc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0;
- case float_number:
+ case irms_float_number:
return fc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0;
default:
}
}
+/*
+ * test if null, 1 means 'yes'
+ */
+int tarval_is_null(tarval *a)
+{
+ ir_mode *m = get_tarval_mode(a);
+
+ return a == get_tarval_null(m);
+}
+
/*
* comparison
*/
/* Here the two tarvals are unequal and of the same mode */
switch (get_mode_sort(a->mode))
{
- case auxiliary:
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
return False;
- case float_number:
+ case irms_float_number:
return (fc_comp(a->value, b->value)==1)?(Gt):(Lt);
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
return (sc_comp(a->value, b->value)==1)?(Gt):(Lt);
- case internal_boolean:
+ case irms_internal_boolean:
return (a == tarval_b_true)?(Gt):(Lt);
- case reference:
+ case irms_reference:
return Uo;
}
return False;
*/
tarval *tarval_convert_to(tarval *src, ir_mode *m)
{
- ANNOUNCE();
tarval tv;
+ ANNOUNCE();
assert(src);
assert(m);
switch (get_mode_sort(src->mode))
{
- case auxiliary:
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
break;
- case float_number:
+ case irms_float_number:
+ switch (get_mode_sort(m)) {
+ case irms_float_number:
+ tv.mode = m;
+ tv.length = src->length;
+ tv.value = src->value;
+ if (overflows(&tv)) {
+ return tarval_bad;
+ }
+
+ return INSERT_TARVAL(&tv);
+
+ default:
+ break;
+ }
break;
- case int_number:
- switch (get_mode_sort(m))
- {
- case int_number:
- case character:
- tv.mode = m;
+ case irms_int_number:
+ switch (get_mode_sort(m)) {
+ case irms_int_number:
+ case irms_character:
+ tv.mode = m;
tv.length = src->length;
- tv.value = src->value;
+ tv.value = src->value;
if (overflows(&tv))
- {
return tarval_bad;
- }
+
return INSERT_TARVAL(&tv);
- case internal_boolean:
+ case irms_internal_boolean:
/* XXX C semantics */
if (src == get_mode_null(src->mode)) return tarval_b_false;
else return tarval_b_true;
}
break;
- case internal_boolean:
+ case irms_internal_boolean:
switch (get_mode_sort(m))
{
- case int_number:
+ case irms_int_number:
if (src == tarval_b_true) return get_mode_one(m);
else return get_mode_null(m);
}
break;
- case character:
+ case irms_character:
break;
- case reference:
+ case irms_reference:
break;
}
switch (get_mode_sort(a->mode))
{
- case int_number:
+ case irms_int_number:
sc_neg(a->value);
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
- case float_number:
+ case irms_float_number:
fc_neg(a->value);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), a->mode);
ANNOUNCE();
assert(a);
assert(b);
- assert((a->mode == b->mode) || (get_mode_sort(a->mode) == character && mode_is_int(b->mode)));
+ assert((a->mode == b->mode) || (get_mode_sort(a->mode) == irms_character && mode_is_int(b->mode)));
switch (get_mode_sort(a->mode))
{
- case character:
- case int_number:
+ case irms_character:
+ case irms_int_number:
/* modes of a,b are equal, so result has mode of a as this might be the character */
sc_add(a->value, b->value);
/* FIXME: Check for overflow */
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
- case float_number:
+ case irms_float_number:
/* FIXME: Overflow/Underflow/transition to inf when mode < 80bit */
fc_add(a->value, b->value);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), a->mode);
ANNOUNCE();
assert(a);
assert(b);
- assert((a->mode == b->mode) || (get_mode_sort(a->mode) == character && mode_is_int(b->mode)));
+ assert((a->mode == b->mode) || (get_mode_sort(a->mode) == irms_character && mode_is_int(b->mode)));
switch (get_mode_sort(a->mode))
{
- case character:
- case int_number:
+ case irms_character:
+ case irms_int_number:
/* modes of a,b are equal, so result has mode of a as this might be the character */
sc_sub(a->value, b->value);
/* FIXME: check for overflow */
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
- case float_number:
+ case irms_float_number:
/* FIXME: Overflow/Underflow/transition to inf when mode < 80bit */
fc_add(a->value, b->value);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), a->mode);
switch (get_mode_sort(a->mode))
{
- case int_number:
+ case irms_int_number:
/* modes of a,b are equal */
sc_mul(a->value, b->value);
/* FIXME: check for overflow */
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
- case float_number:
+ case irms_float_number:
/* FIXME: Overflow/Underflow/transition to inf when mode < 80bit */
fc_add(a->value, b->value);
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), a->mode);
switch (get_mode_sort(a->mode))
{
- case int_number:
+ case irms_int_number:
if (sc_comp(a->value, get_mode_null(a->mode)->value) == -1)
{
sc_neg(a->value);
}
return a;
- case float_number:
+ case irms_float_number:
break;
default:
ANNOUNCE();
assert(a);
assert(b);
- assert((a->mode == b->mode) && mode_is_int(a->mode));
+ assert(a->mode == b->mode);
+
+ /* GL: needed for easy optimization. */
+ if (a->mode == mode_b) return (a == tarval_b_false) ? a : b;
+
+ assert(mode_is_int(a->mode));
sc_and(a->value, b->value);
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
ANNOUNCE();
assert(a);
assert(b);
- assert((a->mode == b->mode) && mode_is_int(a->mode));
+ assert(a->mode == b->mode);
+
+ /* GL: needed for easy optimization. */
+ if (a->mode == mode_b) return (a == tarval_b_true) ? a : b;
+
+
+ assert(mode_is_int(a->mode));
sc_or(a->value, b->value);
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
return get_tarval(sc_get_buffer(), sc_get_buffer_length(), a->mode);
}
+
/*
* Output of tarvals
*/
-int tarval_print(XP_PAR1, const xprintf_info *info ATTRIBUTE((unused)), XP_PARN)
+int tarval_snprintf(char *buf, size_t len, tarval *tv)
{
static const tarval_mode_info default_info = { TVO_NATIVE, NULL, NULL };
- tarval *tv;
const char *str;
- char buf[100];
+ char tv_buf[100];
const tarval_mode_info *mode_info;
const char *prefix, *suffix;
ANNOUNCE();
- tv = XP_GETARG(tarval *, 0);
mode_info = tv->mode->tv_priv;
if (! mode_info)
mode_info = &default_info;
switch (get_mode_sort(tv->mode))
{
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
switch (mode_info->mode_output) {
case TVO_DECIMAL:
str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_HEX);
break;
}
- return XPF3R("%s%s%s", prefix, str, suffix);
+ return snprintf(buf, len, "%s%s%s", prefix, str, suffix);
- case float_number:
- return XPF3R("%s%s%s", prefix, fc_print_dec(tv->value, buf, sizeof(buf)), suffix);
+ case irms_float_number:
+ return snprintf(buf, len, "%s%s%s", prefix, fc_print_dec(tv->value, tv_buf, sizeof(tv_buf)), suffix);
- case reference:
+ case irms_reference:
+ if (tv==tarval_P_void) return snprintf(buf, len, "NULL");
if (tv->value != NULL)
- if (tarval_is_entity(tv))
+ if (tarval_is_entity(tv)) {
if (get_entity_peculiarity((entity *)tv->value) == existent)
- return XPF1R("&(%I)", get_entity_ld_ident((entity *)tv->value));
- else
- return XPSR("NULL");
- else
- return XPMR((char*)tv->value, tv->length);
+ return snprintf(buf, len, "%s%s%s", prefix, get_entity_ld_name((entity *)tv->value), suffix);
+ else {
+ if (mode_info->mode_output == TVO_NATIVE)
+ return snprintf(buf, len, "NULL");
+ else
+ return snprintf(buf, len, "0");
+ }
+ }
+ else {
+ if (size > tv->length) {
+ memcpy(buf, tv->value, tv->length);
+ buf[tv->length] = '\0';
+ }
+ else {
+ /* truncated */
+ memcpy(buf, tv->value, size-1);
+ buf[size-1] = '\0';
+ }
+ return tv->length;
+ }
else
- return XPSR("void");
+ return snprintf(buf, len, "void");
- case internal_boolean:
+ case irms_internal_boolean:
switch (mode_info->mode_output) {
case TVO_DECIMAL:
case TVO_OCTAL:
case TVO_HEX:
case TVO_BINARY:
- return XPF3R("%s%c%s", prefix, (tv == tarval_b_true) ? '1' : '0', suffix);
+ return snprintf(buf, len, "%s%c%s", prefix, (tv == tarval_b_true) ? '1' : '0', suffix);
case TVO_NATIVE:
default:
- return XPF3R("%s%s%s", prefix, (tv == tarval_b_true) ? "true" : "false", suffix);
+ return snprintf(buf, len, "%s%s%s", prefix, (tv == tarval_b_true) ? "true" : "false", suffix);
}
- case auxiliary:
- return XPSR("<BAD>");
+ case irms_control_flow:
+ case irms_memory:
+ case irms_auxiliary:
+ return snprintf(buf, len, "<BAD>");
}
return 0;
}
-int tarval_xprintf(printf_func print_func, void * out , tarval *tv)
-{
- const char *str;
- char buf[100];
-
- switch (get_mode_sort(tv->mode))
- {
- case int_number:
- case character:
- str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_HEX);
-
- return print_func(out,"0x%s", str);
-
- case float_number:
- return print_func(out,"%s", fc_print_dec(tv->value, buf, sizeof(buf)));
-
- case reference:
- if (tv->value != NULL)
- if (tarval_is_entity(tv))
- if (get_entity_peculiarity((entity *)tv->value) == existent)
- return print_func(out,"&(%s)", id_to_str(get_entity_ld_ident((entity *)tv->value)));
- else
- return print_func(out,"NULL",0);
- else
- return print_func(out,(char*)tv->value, tv->length);
- else
- return print_func(out,"void",0);
-
- case internal_boolean:
- if (tv == tarval_b_true) return print_func(out,"true",0);
- else return print_func(out,"false",0);
-
- case auxiliary:
- return print_func(out,"<BAD>",0);
- }
- return 0;
+/**
+ * Output of tarvals to stdio.
+ */
+int tarval_printf(tarval *tv) {
+ char buf[1024];
+ int res;
+
+ res = tarval_snprintf(buf, sizeof(buf), tv);
+ assert(res < sizeof(buf) && "buffer to small for tarval_snprintf");
+ printf(buf);
+ return res;
}
+
char *tarval_bitpattern(tarval *tv)
{
return NULL;
unsigned char tarval_sub_bits(tarval *tv, unsigned byte_ofs)
{
switch (get_mode_sort(tv->mode)) {
- case int_number:
- case character:
+ case irms_int_number:
+ case irms_character:
return sc_sub_bits(tv->value, tv->length, byte_ofs);
- case float_number:
+ case irms_float_number:
return fc_sub_bits(tv->value, get_mode_size_bits(tv->mode), byte_ofs);
default:
return 0;
}
+/*
+ * Returns the output options of one mode.
+ *
+ * This functions returns the modinfo of a given mode.
+ */
+const tarval_mode_info *tarval_get_mode_output_option(ir_mode *mode)
+{
+ assert(mode);
+
+ return mode->tv_priv;
+}
+
+
/* Identifying some tarvals ??? */
/* Implemented in old tv.c as such:
* return 0 for additive neutral,
if (tv == get_mode_null(tv->mode)) return 0;
else if (tv == get_mode_one(tv->mode)) return 1;
- else if ((get_mode_sort(tv->mode) == int_number)
+ else if ((get_mode_sort(tv->mode) == irms_int_number)
&& (tv == new_tarval_from_long(-1, tv->mode))) return -1;
return 2;
/* init with default precision */
init_strcalc(0);
/* init_fltcalc(0); not yet*/
+ tarval_bad = (tarval*)malloc(sizeof(tarval));
+ tarval_undefined = (tarval*)malloc(sizeof(tarval));
+ tarval_b_true = (tarval*)malloc(sizeof(tarval));
+ tarval_b_false = (tarval*)malloc(sizeof(tarval));
+ tarval_P_void = (tarval*)malloc(sizeof(tarval));
}
/**
NULL,
};
+/**
+ * default mode_info for output as reference
+ */
+static const tarval_mode_info reference_output = {
+ TVO_NATIVE,
+ "&(",
+ ")",
+};
+
+
/*
* Initialization of the tarval module: called after init_mode()
*/
{
ANNOUNCE();
- tarval_bad = (tarval*)malloc(sizeof(tarval));
- tarval_bad->mode = NULL;
-
- tarval_undefined = (tarval*)malloc(sizeof(tarval));
- tarval_undefined->mode = NULL;
-
- tarval_b_true = (tarval*)malloc(sizeof(tarval));
- tarval_b_true->mode = mode_b;
-
- tarval_b_false = (tarval*)malloc(sizeof(tarval));
- tarval_b_false->mode = mode_b;
-
- tarval_P_void = (tarval*)malloc(sizeof(tarval));
- tarval_P_void->mode = mode_P;
+ tarval_bad->mode = mode_BAD;
+ tarval_undefined->mode = mode_ANY;
+ tarval_b_true->mode = mode_b;
+ tarval_b_false->mode = mode_b;
+ tarval_P_void->mode = mode_P;
/*
* assign output modes that are compatible with the
tarval_set_mode_output_option(mode_Iu, &hex_output);
tarval_set_mode_output_option(mode_Ls, &hex_output);
tarval_set_mode_output_option(mode_Lu, &hex_output);
+ tarval_set_mode_output_option(mode_P, &reference_output);
}
/****************************************************************************