#include "tv_t.h"
#include "set.h" /* to store tarvals in */
-//#include "tune.h" /* some constants */
+/* #include "tune.h" */ /* some constants */
#include "entity_t.h" /* needed to store pointers to entities */
-#include "irmode.h" /* defines modes etc */
#include "irmode_t.h"
#include "irnode.h" /* defines boolean return values (pnc_number)*/
#include "host.h"
/** Size of hash tables. Should correspond to average number of distinct constant
target values */
-#define N_CONSTANTS 2048
+#define N_CONSTANTS 2048
/* XXX hack until theres's a proper interface */
#define BAD 1
else if (strcasecmp(str, "false")) return tarval_b_true;
else
/* XXX This is C semantics */
- return atoi(str) ? tarval_b_true : tarval_b_false;
+ return atoi(str) ? tarval_b_true : tarval_b_false;
case irms_float_number:
switch(get_mode_size_bits(mode)) {
}
/* this might overflow the machine's long, so use only with small values */
-long tarval_to_long(tarval* tv)
+long get_tarval_long(tarval* tv)
{
ANNOUNCE();
assert(tarval_is_long(tv) && "tarval too big to fit in long");
return (get_mode_sort(tv->mode) == irms_float_number);
}
-long double tarval_to_double(tarval *tv)
+long double get_tarval_double(tarval *tv)
{
ANNOUNCE();
assert(tarval_is_double(tv));
return fc_val_to_float(tv->value);
}
-/* The tarval represents the address of the entity. As the address must
- be constant the entity must have as owner the global type. */
-tarval *new_tarval_from_entity (entity *ent, ir_mode *mode)
-{
- ANNOUNCE();
- assert(ent);
- assert(mode && (get_mode_sort(mode) == irms_reference));
-
- return get_tarval((void *)ent, 0, mode);
-}
-int tarval_is_entity(tarval *tv)
-{
- ANNOUNCE();
- assert(tv);
- /* tv->value == NULL means dereferencing a null pointer */
- return ((get_mode_sort(tv->mode) == irms_reference) && (tv->value != NULL) && (tv->length == 0)
- && (tv != tarval_P_void));
-}
-
-entity *tarval_to_entity(tarval *tv)
-{
- ANNOUNCE();
- assert(tv);
-
- if (tarval_is_entity(tv))
- return (entity *)tv->value;
- else {
- assert(0 && "tarval did not represent an entity");
- return NULL;
- }
-}
-
-void free_tarval_entity(entity *ent) {
- /* There can be a tarval referencing this entity. Even if the
- tarval is not used by the code any more, it can still reference
- the entity as tarvals live indepently of the entity referenced.
- Further the tarval is hashed into a set. If a hash function
- evaluation happens to collide with this tarval, we will vrfy that
- it contains a proper entity and we will crash if the entity is
- freed.
-
- Unluckily, tarvals can neither be changed nor deleted, and to find
- one, all existing reference modes have to be tried -> a facility
- to retrieve all modes of a kind is needed. */
- ANNOUNCE();
-}
/*
* Access routines for tarval fields ========================================
ANNOUNCE();
assert(mode);
- if (get_mode_vector_elems(mode) > 1) {
+ if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
ANNOUNCE();
assert(mode);
- if (get_mode_vector_elems(mode) > 1) {
+ if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
ANNOUNCE();
assert(mode);
- if (get_mode_vector_elems(mode) > 1) {
+ if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
ANNOUNCE();
assert(mode);
- if (get_mode_vector_elems(mode) > 1) {
+ if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
ANNOUNCE();
assert(mode);
- if (get_mode_vector_elems(mode) > 1) {
+ if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
ANNOUNCE();
assert(mode);
- if (get_mode_vector_elems(mode) > 1) {
+ if (get_mode_n_vector_elems(mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
ANNOUNCE();
assert(a);
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
assert(0 && "tarval_is_negative is not allowed for vector modes");
return 0;
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;
+ return sc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0;
case irms_float_number:
return fc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0;
if (a == b) return Eq;
if (a->mode != b->mode) return False;
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
assert(0 && "cmp not implemented for vector modes");
}
if (src->mode == m) return src;
- if (get_mode_vector_elems(src->mode) > 1) {
+ if (get_mode_n_vector_elems(src->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
/* cast float to something */
case irms_float_number:
switch (get_mode_sort(m)) {
- case irms_float_number:
+ case irms_float_number:
switch (get_mode_size_bits(m))
{
case 32:
break;
}
return get_tarval(fc_get_buffer(), fc_get_buffer_length(), m);
- break;
+ break;
case irms_int_number:
switch (GET_FLOAT_TO_INT_MODE())
* an intermediate representation is needed here first. */
/* return get_tarval(); */
return tarval_bad;
- break;
+ break;
default:
/* the rest can't be converted */
assert(mode_is_num(a->mode)); /* negation only for numerical values */
assert(mode_is_signed(a->mode)); /* negation is difficult without negative numbers, isn't it */
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert((a->mode == b->mode) || (get_mode_sort(a->mode) == irms_character && mode_is_int(b->mode)));
- if (get_mode_vector_elems(a->mode) > 1 || get_mode_vector_elems(b->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(b->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert((a->mode == b->mode) || (get_mode_sort(a->mode) == irms_character && mode_is_int(b->mode)));
- if (get_mode_vector_elems(a->mode) > 1 || get_mode_vector_elems(b->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(b->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert((a->mode == b->mode) && mode_is_num(a->mode));
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert((a->mode == b->mode) && mode_is_float(a->mode));
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert((a->mode == b->mode) && mode_is_int(a->mode));
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert((a->mode == b->mode) && mode_is_int(a->mode));
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(a);
assert(mode_is_num(a->mode));
- if (get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert(mode_is_int(a->mode) && mode_is_int(b->mode));
- if (get_mode_vector_elems(a->mode) > 1 || get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert(mode_is_int(a->mode) && mode_is_int(b->mode));
- if (get_mode_vector_elems(a->mode) > 1 || get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert(mode_is_int(a->mode) && mode_is_int(b->mode));
- if (get_mode_vector_elems(a->mode) > 1 || get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
assert(b);
assert(mode_is_int(a->mode) && mode_is_int(b->mode));
- if (get_mode_vector_elems(a->mode) > 1 || get_mode_vector_elems(a->mode) > 1) {
+ if (get_mode_n_vector_elems(a->mode) > 1 || get_mode_n_vector_elems(a->mode) > 1) {
/* vector arithmetic not implemented yet */
return tarval_bad;
}
case TVO_DECIMAL:
str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_DEC);
- break;
+ break;
case TVO_OCTAL:
str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_OCT);
- break;
+ break;
case TVO_HEX:
case TVO_NATIVE:
default:
str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_HEX);
- break;
+ break;
}
return snprintf(buf, len, "%s%s%s", prefix, str, suffix);
break;
case irms_reference:
- if (tv==tarval_P_void) return snprintf(buf, len, "NULL");
- if (tv->value != NULL)
- if (tarval_is_entity(tv)) {
- if (get_entity_peculiarity((entity *)tv->value) != peculiarity_description)
- 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) {
+ if (tv == tarval_P_void) return snprintf(buf, len, "NULL");
+ if (tv->value != NULL){
+ if (len > tv->length) {
memcpy(buf, tv->value, tv->length);
buf[tv->length] = '\0';
}
else {
/* truncated */
- memcpy(buf, tv->value, size-1);
- buf[size-1] = '\0';
+ memcpy(buf, tv->value, len-1);
+ buf[len-1] = '\0';
}
- return tv->length;
- }
+ return tv->length;
+ }
else
- return snprintf(buf, len, "void");
+ return snprintf(buf, len, "void");
case irms_internal_boolean:
switch (mode_info->mode_output) {
}
-char *tarval_bitpattern(tarval *tv)
+char *get_tarval_bitpattern(tarval *tv)
{
return NULL;
}
/*
* access to the bitpattern
*/
-unsigned char tarval_sub_bits(tarval *tv, unsigned byte_ofs)
+unsigned char get_tarval_sub_bits(tarval *tv, unsigned byte_ofs)
{
switch (get_mode_sort(tv->mode)) {
case irms_int_number:
*
* Returns zero on success.
*/
-int tarval_set_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinfo)
+int set_tarval_mode_output_option(ir_mode *mode, const tarval_mode_info *modeinfo)
{
assert(mode);
*
* This functions returns the modinfo of a given mode.
*/
-const tarval_mode_info *tarval_get_mode_output_option(ir_mode *mode)
+const tarval_mode_info *get_tarval_mode_output_option(ir_mode *mode)
{
assert(mode);
* - TV_CLASSIFY_ALL_ONE for bitwise-and neutral
* - TV_CLASSIFY_OTHER else
*/
-tarval_classification_t tarval_classify(tarval *tv)
+tarval_classification_t classify_tarval(tarval *tv)
{
ANNOUNCE();
if (!tv || tv == tarval_bad) return TV_CLASSIFY_OTHER;
* assign output modes that are compatible with the
* old implementation: Hex output
*/
- tarval_set_mode_output_option(mode_U, &hex_output);
- tarval_set_mode_output_option(mode_C, &hex_output);
- tarval_set_mode_output_option(mode_Bs, &hex_output);
- tarval_set_mode_output_option(mode_Bu, &hex_output);
- tarval_set_mode_output_option(mode_Hs, &hex_output);
- tarval_set_mode_output_option(mode_Hu, &hex_output);
- tarval_set_mode_output_option(mode_Is, &hex_output);
- 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);
+ set_tarval_mode_output_option(mode_U, &hex_output);
+ set_tarval_mode_output_option(mode_C, &hex_output);
+ set_tarval_mode_output_option(mode_Bs, &hex_output);
+ set_tarval_mode_output_option(mode_Bu, &hex_output);
+ set_tarval_mode_output_option(mode_Hs, &hex_output);
+ set_tarval_mode_output_option(mode_Hu, &hex_output);
+ set_tarval_mode_output_option(mode_Is, &hex_output);
+ set_tarval_mode_output_option(mode_Iu, &hex_output);
+ set_tarval_mode_output_option(mode_Ls, &hex_output);
+ set_tarval_mode_output_option(mode_Lu, &hex_output);
+ set_tarval_mode_output_option(mode_P, &reference_output);
}
/* free all memory occupied by tarval. */