void xml_short_constant(tree cst, FILE *out)
{
size_t i;
const char *p;
char buf[100];
REAL_VALUE_TYPE rt;
switch (TREE_CODE(cst))
{
case REAL_CST:
rt = TREE_REAL_CST(cst);
if (REAL_VALUE_ISINF(rt))
fprintf(out, "<float-literal special='%sInfinity' />",
REAL_VALUE_NEGATIVE(rt) ? "-" : "+");
else if (REAL_VALUE_ISNAN(rt))
fprintf(out, "<float-literal special='NaN' />");
else
{
real_to_decimal(buf, &rt, sizeof(buf), 0, 1);
fprintf(out, "<float-literal value='%s' />", buf);
}
break;
case INTEGER_CST:
fprintf(out, "<integer-literal value='%lld' />", double_int_to_ll(TREE_INT_CST(cst)));
break;
case STRING_CST:
fprintf(out, "<string-literal>");
p = TREE_STRING_POINTER(cst);
for (i = 0; i < TREE_STRING_LENGTH(cst); i++)
{
if (p[i] == '\\')
fputc('\\', out), fputc('\\', out);
else if (p[i] == '&')
fputs("&", out);
else if (p[i] == '<')
fputs("<", out);
else if (p[i] == '>')
fputs(">", out);
else if (ISPRINT(p[i]))
fputc(p[i], out);
else
fprintf(out, "\\x%02x", p[i] & 0xFF);
}
fprintf(out, "</string-literal>");
break;
default:
fprintf(stderr, "failing: unhandled cst tree type %s\n",
tree_code_name[TREE_CODE(cst)]);
abort();
}
}
static int
some_nonzerop (tree t)
{
int zerop = false;
if (TREE_CODE (t) == REAL_CST)
zerop = REAL_VALUES_IDENTICAL (TREE_REAL_CST (t), dconst0);
else if (TREE_CODE (t) == INTEGER_CST)
zerop = integer_zerop (t);
return !zerop;
}
static void
pack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
{
unsigned i;
REAL_VALUE_TYPE r;
r = TREE_REAL_CST (expr);
bp_pack_value (bp, r.cl, 2);
bp_pack_value (bp, r.decimal, 1);
bp_pack_value (bp, r.sign, 1);
bp_pack_value (bp, r.signalling, 1);
bp_pack_value (bp, r.canonical, 1);
bp_pack_value (bp, r.uexp, EXP_BITS);
for (i = 0; i < SIGSZ; i++)
bp_pack_value (bp, r.sig[i], HOST_BITS_PER_LONG);
}
static int
some_nonzerop (tree t)
{
int zerop = false;
/* Operations with real or imaginary part of a complex number zero
cannot be treated the same as operations with a real or imaginary
operand if we care about the signs of zeros in the result. */
if (TREE_CODE (t) == REAL_CST && !flag_signed_zeros)
zerop = REAL_VALUES_IDENTICAL (TREE_REAL_CST (t), dconst0);
else if (TREE_CODE (t) == FIXED_CST)
zerop = fixed_zerop (t);
else if (TREE_CODE (t) == INTEGER_CST)
zerop = integer_zerop (t);
return !zerop;
}
static void
pp_c_floating_constant (c_pretty_printer *pp, tree r)
{
real_to_decimal (pp_buffer (pp)->digit_buffer, &TREE_REAL_CST (r),
sizeof (pp_buffer (pp)->digit_buffer), 0, 1);
pp_string (pp, pp_buffer(pp)->digit_buffer);
if (TREE_TYPE (r) == float_type_node)
pp_character (pp, 'f');
else if (TREE_TYPE (r) == long_double_type_node)
pp_character (pp, 'l');
else if (TREE_TYPE (r) == dfloat128_type_node)
pp_string (pp, "dl");
else if (TREE_TYPE (r) == dfloat64_type_node)
pp_string (pp, "dd");
else if (TREE_TYPE (r) == dfloat32_type_node)
pp_string (pp, "df");
}
static void
gen_conditions_for_pow_cst_base (tree base, tree expn,
vec<gimple> conds,
unsigned *nconds)
{
inp_domain exp_domain;
/* Validate the range of the base constant to make
sure it is consistent with check_pow. */
REAL_VALUE_TYPE mv;
REAL_VALUE_TYPE bcv = TREE_REAL_CST (base);
gcc_assert (!REAL_VALUES_EQUAL (bcv, dconst1)
&& !REAL_VALUES_LESS (bcv, dconst1));
real_from_integer (&mv, TYPE_MODE (TREE_TYPE (base)), 256, UNSIGNED);
gcc_assert (!REAL_VALUES_LESS (mv, bcv));
exp_domain = get_domain (0, false, false,
127, true, false);
gen_conditions_for_domain (expn, exp_domain,
conds, nconds);
}
/*
* Return a new REAL_CST node whose type
* is TYPE and value is D.
*/
tree
build_real (tree type, REAL_VALUE_TYPE d)
{
tree v;
/*
* Check for valid float value for this type
* on this target machine; if not, can print
* error message and store a valid value in D.
*/
#ifdef CHECK_FLOAT_VALUE
CHECK_FLOAT_VALUE (TYPE_MODE (type), d);
#endif
v = make_node (REAL_CST);
TREE_TYPE (v) = type;
TREE_REAL_CST (v) = d;
return v;
} /* end build_real */
/*
* This function can't be implemented if we can't
* do arithmetic on the float representation.
*/
tree
build_real_from_int_cst (tree type, tree i)
{
tree v;
REAL_VALUE_TYPE d;
v = make_node (REAL_CST);
TREE_TYPE (v) = type;
d = real_value_from_int_cst (i);
/*
* Check for valid float value for this type
* on this target machine; if not, can print
* error message and store a valid value in D.
*/
#ifdef CHECK_FLOAT_VALUE
CHECK_FLOAT_VALUE (TYPE_MODE (type), d);
#endif
TREE_REAL_CST (v) = d;
return (v);
} /* end build_real_from_int_cst */
void
print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
{
enum tree_code_class tclass;
if (node == 0)
return;
tclass = TREE_CODE_CLASS (TREE_CODE (node));
/* Always print the slot this node is in, and its code, address and
name if any. */
if (indent > 0)
fprintf (file, " ");
fprintf (file, "%s <%s", prefix, get_tree_code_name (TREE_CODE (node)));
dump_addr (file, " ", node);
if (tclass == tcc_declaration)
{
if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
else if (TREE_CODE (node) == LABEL_DECL
&& LABEL_DECL_UID (node) != -1)
{
if (dump_flags & TDF_NOUID)
fprintf (file, " L.xxxx");
else
fprintf (file, " L.%d", (int) LABEL_DECL_UID (node));
}
else
{
if (dump_flags & TDF_NOUID)
fprintf (file, " %c.xxxx",
TREE_CODE (node) == CONST_DECL ? 'C' : 'D');
else
fprintf (file, " %c.%u",
TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
DECL_UID (node));
}
}
else if (tclass == tcc_type)
{
if (TYPE_NAME (node))
{
if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (TYPE_NAME (node)));
else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (node)))
fprintf (file, " %s",
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (node))));
}
if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (node)))
fprintf (file, " address-space-%d", TYPE_ADDR_SPACE (node));
}
if (TREE_CODE (node) == IDENTIFIER_NODE)
fprintf (file, " %s", IDENTIFIER_POINTER (node));
/* We might as well always print the value of an integer or real. */
if (TREE_CODE (node) == INTEGER_CST)
{
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
fprintf (file, " ");
print_dec (node, file, TYPE_SIGN (TREE_TYPE (node)));
}
if (TREE_CODE (node) == REAL_CST)
{
REAL_VALUE_TYPE d;
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
d = TREE_REAL_CST (node);
if (REAL_VALUE_ISINF (d))
fprintf (file, REAL_VALUE_NEGATIVE (d) ? " -Inf" : " Inf");
else if (REAL_VALUE_ISNAN (d))
fprintf (file, " Nan");
else
{
char string[60];
real_to_decimal (string, &d, sizeof (string), 0, 1);
fprintf (file, " %s", string);
}
}
if (TREE_CODE (node) == FIXED_CST)
{
FIXED_VALUE_TYPE f;
char string[60];
if (TREE_OVERFLOW (node))
fprintf (file, " overflow");
f = TREE_FIXED_CST (node);
fixed_to_decimal (string, &f, sizeof (string));
fprintf (file, " %s", string);
}
fprintf (file, ">");
}
static bool
check_pow (gimple pow_call)
{
tree base, expn;
enum tree_code bc, ec;
if (gimple_call_num_args (pow_call) != 2)
return false;
base = gimple_call_arg (pow_call, 0);
expn = gimple_call_arg (pow_call, 1);
if (!check_target_format (expn))
return false;
bc = TREE_CODE (base);
ec = TREE_CODE (expn);
/* Folding candidates are not interesting.
Can actually assert that it is already folded. */
if (ec == REAL_CST && bc == REAL_CST)
return false;
if (bc == REAL_CST)
{
/* Only handle a fixed range of constant. */
REAL_VALUE_TYPE mv;
REAL_VALUE_TYPE bcv = TREE_REAL_CST (base);
if (REAL_VALUES_EQUAL (bcv, dconst1))
return false;
if (REAL_VALUES_LESS (bcv, dconst1))
return false;
real_from_integer (&mv, TYPE_MODE (TREE_TYPE (base)), 256, 0, 1);
if (REAL_VALUES_LESS (mv, bcv))
return false;
return true;
}
else if (bc == SSA_NAME)
{
tree base_val0, base_var, type;
gimple base_def;
int bit_sz;
/* Only handles cases where base value is converted
from integer values. */
base_def = SSA_NAME_DEF_STMT (base);
if (gimple_code (base_def) != GIMPLE_ASSIGN)
return false;
if (gimple_assign_rhs_code (base_def) != FLOAT_EXPR)
return false;
base_val0 = gimple_assign_rhs1 (base_def);
base_var = SSA_NAME_VAR (base_val0);
if (!DECL_P (base_var))
return false;
type = TREE_TYPE (base_var);
if (TREE_CODE (type) != INTEGER_TYPE)
return false;
bit_sz = TYPE_PRECISION (type);
/* If the type of the base is too wide,
the resulting shrink wrapping condition
will be too conservative. */
if (bit_sz > MAX_BASE_INT_BIT_SIZE)
return false;
return true;
}
else
return false;
}
static gimple
vect_recog_pow_pattern (gimple last_stmt, tree *type_in, tree *type_out)
{
tree fn, base, exp = NULL;
gimple stmt;
tree var;
if (!is_gimple_call (last_stmt) || gimple_call_lhs (last_stmt) == NULL)
return NULL;
fn = gimple_call_fndecl (last_stmt);
if (fn == NULL_TREE || DECL_BUILT_IN_CLASS (fn) != BUILT_IN_NORMAL)
return NULL;
switch (DECL_FUNCTION_CODE (fn))
{
case BUILT_IN_POWIF:
case BUILT_IN_POWI:
case BUILT_IN_POWF:
case BUILT_IN_POW:
base = gimple_call_arg (last_stmt, 0);
exp = gimple_call_arg (last_stmt, 1);
if (TREE_CODE (exp) != REAL_CST
&& TREE_CODE (exp) != INTEGER_CST)
return NULL;
break;
default:
return NULL;
}
/* We now have a pow or powi builtin function call with a constant
exponent. */
*type_out = NULL_TREE;
/* Catch squaring. */
if ((host_integerp (exp, 0)
&& tree_low_cst (exp, 0) == 2)
|| (TREE_CODE (exp) == REAL_CST
&& REAL_VALUES_EQUAL (TREE_REAL_CST (exp), dconst2)))
{
*type_in = TREE_TYPE (base);
var = vect_recog_temp_ssa_var (TREE_TYPE (base), NULL);
stmt = gimple_build_assign_with_ops (MULT_EXPR, var, base, base);
SSA_NAME_DEF_STMT (var) = stmt;
return stmt;
}
/* Catch square root. */
if (TREE_CODE (exp) == REAL_CST
&& REAL_VALUES_EQUAL (TREE_REAL_CST (exp), dconsthalf))
{
tree newfn = mathfn_built_in (TREE_TYPE (base), BUILT_IN_SQRT);
*type_in = get_vectype_for_scalar_type (TREE_TYPE (base));
if (*type_in)
{
gimple stmt = gimple_build_call (newfn, 1, base);
if (vectorizable_function (stmt, *type_in, *type_in)
!= NULL_TREE)
{
var = vect_recog_temp_ssa_var (TREE_TYPE (base), stmt);
gimple_call_set_lhs (stmt, var);
return stmt;
}
}
}
return NULL;
}
