static tree
fold_const_call_1 (built_in_function fn, tree type, tree arg0, tree arg1,
tree arg2)
{
machine_mode mode = TYPE_MODE (type);
machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
machine_mode arg2_mode = TYPE_MODE (TREE_TYPE (arg2));
if (arg0_mode == arg1_mode
&& arg0_mode == arg2_mode
&& real_cst_p (arg0)
&& real_cst_p (arg1)
&& real_cst_p (arg2))
{
gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
if (mode == arg0_mode)
{
/* real, real, real -> real. */
REAL_VALUE_TYPE result;
if (fold_const_call_ssss (&result, fn, TREE_REAL_CST_PTR (arg0),
TREE_REAL_CST_PTR (arg1),
TREE_REAL_CST_PTR (arg2),
REAL_MODE_FORMAT (mode)))
return build_real (type, result);
}
return NULL_TREE;
}
return NULL_TREE;
}
tree
fold_fma (location_t, tree type, tree arg0, tree arg1, tree arg2)
{
REAL_VALUE_TYPE result;
if (real_cst_p (arg0)
&& real_cst_p (arg1)
&& real_cst_p (arg2)
&& do_mpfr_arg3 (&result, mpfr_fma, TREE_REAL_CST_PTR (arg0),
TREE_REAL_CST_PTR (arg1), TREE_REAL_CST_PTR (arg2),
REAL_MODE_FORMAT (TYPE_MODE (type))))
return build_real (type, result);
return NULL_TREE;
}
static void
unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
{
unsigned i;
REAL_VALUE_TYPE r;
REAL_VALUE_TYPE *rp;
r.cl = (unsigned) bp_unpack_value (bp, 2);
r.decimal = (unsigned) bp_unpack_value (bp, 1);
r.sign = (unsigned) bp_unpack_value (bp, 1);
r.signalling = (unsigned) bp_unpack_value (bp, 1);
r.canonical = (unsigned) bp_unpack_value (bp, 1);
r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
for (i = 0; i < SIGSZ; i++)
r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
rp = ggc_alloc_real_value ();
memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
TREE_REAL_CST_PTR (expr) = rp;
}
static void
unpack_ts_real_cst_value_fields (struct bitpack_d *bp, tree expr)
{
unsigned i;
REAL_VALUE_TYPE r;
REAL_VALUE_TYPE *rp;
/* Clear all bits of the real value type so that we can later do
bitwise comparisons to see if two values are the same. */
memset (&r, 0, sizeof r);
r.cl = (unsigned) bp_unpack_value (bp, 2);
r.decimal = (unsigned) bp_unpack_value (bp, 1);
r.sign = (unsigned) bp_unpack_value (bp, 1);
r.signalling = (unsigned) bp_unpack_value (bp, 1);
r.canonical = (unsigned) bp_unpack_value (bp, 1);
r.uexp = (unsigned) bp_unpack_value (bp, EXP_BITS);
for (i = 0; i < SIGSZ; i++)
r.sig[i] = (unsigned long) bp_unpack_value (bp, HOST_BITS_PER_LONG);
rp = ggc_alloc<real_value> ();
memcpy (rp, &r, sizeof (REAL_VALUE_TYPE));
TREE_REAL_CST_PTR (expr) = rp;
}
void
gfc_conv_tree_to_mpfr (mpfr_ptr f, tree source)
{
mpfr_from_real (f, TREE_REAL_CST_PTR (source), GFC_RND_MODE);
}
static void
dequeue_and_dump (dump_info_p di)
{
dump_queue_p dq;
splay_tree_node stn;
dump_node_info_p dni;
tree t;
unsigned int index;
enum tree_code code;
enum tree_code_class code_class;
const char* code_name;
/* Get the next node from the queue. */
dq = di->queue;
stn = dq->node;
t = (tree) stn->key;
dni = (dump_node_info_p) stn->value;
index = dni->index;
/* Remove the node from the queue, and put it on the free list. */
di->queue = dq->next;
if (!di->queue)
di->queue_end = 0;
dq->next = di->free_list;
di->free_list = dq;
/* Print the node index. */
dump_index (di, index);
/* And the type of node this is. */
if (dni->binfo_p)
code_name = "binfo";
else
code_name = tree_code_name[(int) TREE_CODE (t)];
fprintf (di->stream, "%-16s ", code_name);
di->column = 25;
/* Figure out what kind of node this is. */
code = TREE_CODE (t);
code_class = TREE_CODE_CLASS (code);
/* Although BINFOs are TREE_VECs, we dump them specially so as to be
more informative. */
if (dni->binfo_p)
{
unsigned ix;
tree base;
VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (t);
dump_child ("type", BINFO_TYPE (t));
if (BINFO_VIRTUAL_P (t))
dump_string_field (di, "spec", "virt");
dump_int (di, "bases", BINFO_N_BASE_BINFOS (t));
for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++)
{
tree access = (accesses ? VEC_index (tree, accesses, ix)
: access_public_node);
const char *string = NULL;
if (access == access_public_node)
string = "pub";
else if (access == access_protected_node)
string = "prot";
else if (access == access_private_node)
string = "priv";
else
gcc_unreachable ();
dump_string_field (di, "accs", string);
queue_and_dump_index (di, "binf", base, DUMP_BINFO);
}
goto done;
}
/* We can knock off a bunch of expression nodes in exactly the same
way. */
if (IS_EXPR_CODE_CLASS (code_class))
{
/* If we're dumping children, dump them now. */
queue_and_dump_type (di, t);
switch (code_class)
{
case tcc_unary:
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case tcc_binary:
case tcc_comparison:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case tcc_expression:
case tcc_reference:
case tcc_statement:
case tcc_vl_exp:
/* These nodes are handled explicitly below. */
break;
default:
gcc_unreachable ();
}
}
else if (DECL_P (t))
{
expanded_location xloc;
/* All declarations have names. */
if (DECL_NAME (t))
dump_child ("name", DECL_NAME (t));
if (DECL_ASSEMBLER_NAME_SET_P (t)
&& DECL_ASSEMBLER_NAME (t) != DECL_NAME (t))
dump_child ("mngl", DECL_ASSEMBLER_NAME (t));
if (DECL_ABSTRACT_ORIGIN (t))
dump_child ("orig", DECL_ABSTRACT_ORIGIN (t));
/* And types. */
queue_and_dump_type (di, t);
dump_child ("scpe", DECL_CONTEXT (t));
/* And a source position. */
xloc = expand_location (DECL_SOURCE_LOCATION (t));
if (xloc.file)
{
const char *filename = lbasename (xloc.file);
dump_maybe_newline (di);
fprintf (di->stream, "srcp: %s:%-6d ", filename,
xloc.line);
di->column += 6 + strlen (filename) + 8;
}
/* And any declaration can be compiler-generated. */
if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON)
&& DECL_ARTIFICIAL (t))
dump_string_field (di, "note", "artificial");
if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL))
dump_child ("chain", DECL_CHAIN (t));
}
else if (code_class == tcc_type)
{
/* All types have qualifiers. */
int quals = lang_hooks.tree_dump.type_quals (t);
if (quals != TYPE_UNQUALIFIED)
{
fprintf (di->stream, "qual: %c%c%c ",
(quals & TYPE_QUAL_CONST) ? 'c' : ' ',
(quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ',
(quals & TYPE_QUAL_RESTRICT) ? 'r' : ' ');
di->column += 14;
}
/* All types have associated declarations. */
dump_child ("name", TYPE_NAME (t));
/* All types have a main variant. */
if (TYPE_MAIN_VARIANT (t) != t)
dump_child ("unql", TYPE_MAIN_VARIANT (t));
/* And sizes. */
dump_child ("size", TYPE_SIZE (t));
/* All types have alignments. */
dump_int (di, "algn", TYPE_ALIGN (t));
}
else if (code_class == tcc_constant)
/* All constants can have types. */
queue_and_dump_type (di, t);
/* Give the language-specific code a chance to print something. If
it's completely taken care of things, don't bother printing
anything more ourselves. */
if (lang_hooks.tree_dump.dump_tree (di, t))
goto done;
/* Now handle the various kinds of nodes. */
switch (code)
{
int i;
case IDENTIFIER_NODE:
dump_string_field (di, "strg", IDENTIFIER_POINTER (t));
dump_int (di, "lngt", IDENTIFIER_LENGTH (t));
break;
case TREE_LIST:
dump_child ("purp", TREE_PURPOSE (t));
dump_child ("valu", TREE_VALUE (t));
dump_child ("chan", TREE_CHAIN (t));
break;
case STATEMENT_LIST:
{
tree_stmt_iterator it;
for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, tsi_stmt (it));
}
}
break;
case TREE_VEC:
dump_int (di, "lngt", TREE_VEC_LENGTH (t));
for (i = 0; i < TREE_VEC_LENGTH (t); ++i)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, TREE_VEC_ELT (t, i));
}
break;
case INTEGER_TYPE:
case ENUMERAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_child ("min", TYPE_MIN_VALUE (t));
dump_child ("max", TYPE_MAX_VALUE (t));
if (code == ENUMERAL_TYPE)
dump_child ("csts", TYPE_VALUES (t));
break;
case REAL_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
break;
case FIXED_POINT_TYPE:
dump_int (di, "prec", TYPE_PRECISION (t));
dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed");
dump_string_field (di, "saturating",
TYPE_SATURATING (t) ? "saturating": "non-saturating");
break;
case POINTER_TYPE:
dump_child ("ptd", TREE_TYPE (t));
break;
case REFERENCE_TYPE:
dump_child ("refd", TREE_TYPE (t));
break;
case METHOD_TYPE:
dump_child ("clas", TYPE_METHOD_BASETYPE (t));
/* Fall through. */
case FUNCTION_TYPE:
dump_child ("retn", TREE_TYPE (t));
dump_child ("prms", TYPE_ARG_TYPES (t));
break;
case ARRAY_TYPE:
dump_child ("elts", TREE_TYPE (t));
dump_child ("domn", TYPE_DOMAIN (t));
break;
case RECORD_TYPE:
case UNION_TYPE:
if (TREE_CODE (t) == RECORD_TYPE)
dump_string_field (di, "tag", "struct");
else
dump_string_field (di, "tag", "union");
dump_child ("flds", TYPE_FIELDS (t));
dump_child ("fncs", TYPE_METHODS (t));
queue_and_dump_index (di, "binf", TYPE_BINFO (t),
DUMP_BINFO);
break;
case CONST_DECL:
dump_child ("cnst", DECL_INITIAL (t));
break;
case DEBUG_EXPR_DECL:
dump_int (di, "-uid", DEBUG_TEMP_UID (t));
/* Fall through. */
case VAR_DECL:
case PARM_DECL:
case FIELD_DECL:
case RESULT_DECL:
if (TREE_CODE (t) == PARM_DECL)
dump_child ("argt", DECL_ARG_TYPE (t));
else
dump_child ("init", DECL_INITIAL (t));
dump_child ("size", DECL_SIZE (t));
dump_int (di, "algn", DECL_ALIGN (t));
if (TREE_CODE (t) == FIELD_DECL)
{
if (DECL_FIELD_OFFSET (t))
dump_child ("bpos", bit_position (t));
}
else if (TREE_CODE (t) == VAR_DECL
|| TREE_CODE (t) == PARM_DECL)
{
dump_int (di, "used", TREE_USED (t));
if (DECL_REGISTER (t))
dump_string_field (di, "spec", "register");
}
break;
case FUNCTION_DECL:
dump_child ("args", DECL_ARGUMENTS (t));
if (DECL_EXTERNAL (t))
dump_string_field (di, "body", "undefined");
if (TREE_PUBLIC (t))
dump_string_field (di, "link", "extern");
else
dump_string_field (di, "link", "static");
if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t))
dump_child ("body", DECL_SAVED_TREE (t));
break;
case INTEGER_CST:
if (TREE_INT_CST_HIGH (t))
dump_int (di, "high", TREE_INT_CST_HIGH (t));
dump_int (di, "low", TREE_INT_CST_LOW (t));
break;
case STRING_CST:
fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t));
dump_int (di, "lngt", TREE_STRING_LENGTH (t));
break;
case REAL_CST:
dump_real (di, "valu", TREE_REAL_CST_PTR (t));
break;
case FIXED_CST:
dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t));
break;
case TRUTH_NOT_EXPR:
case ADDR_EXPR:
case INDIRECT_REF:
case CLEANUP_POINT_EXPR:
case SAVE_EXPR:
case REALPART_EXPR:
case IMAGPART_EXPR:
/* These nodes are unary, but do not have code class `1'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
break;
case TRUTH_ANDIF_EXPR:
case TRUTH_ORIF_EXPR:
case INIT_EXPR:
case MODIFY_EXPR:
case COMPOUND_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
case POSTDECREMENT_EXPR:
case POSTINCREMENT_EXPR:
/* These nodes are binary, but do not have code class `2'. */
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case COMPONENT_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case ARRAY_REF:
case ARRAY_RANGE_REF:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
dump_child ("op 3", TREE_OPERAND (t, 3));
break;
case COND_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
dump_child ("op 2", TREE_OPERAND (t, 2));
break;
case TRY_FINALLY_EXPR:
dump_child ("op 0", TREE_OPERAND (t, 0));
dump_child ("op 1", TREE_OPERAND (t, 1));
break;
case CALL_EXPR:
{
int i = 0;
tree arg;
call_expr_arg_iterator iter;
dump_child ("fn", CALL_EXPR_FN (t));
FOR_EACH_CALL_EXPR_ARG (arg, iter, t)
{
char buffer[32];
sprintf (buffer, "%u", i);
dump_child (buffer, arg);
i++;
}
}
break;
case CONSTRUCTOR:
{
unsigned HOST_WIDE_INT cnt;
tree index, value;
dump_int (di, "lngt", VEC_length (constructor_elt,
CONSTRUCTOR_ELTS (t)));
FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value)
{
dump_child ("idx", index);
dump_child ("val", value);
}
}
static tree
fold_const_call_1 (built_in_function fn, tree type, tree arg0, tree arg1)
{
machine_mode mode = TYPE_MODE (type);
machine_mode arg0_mode = TYPE_MODE (TREE_TYPE (arg0));
machine_mode arg1_mode = TYPE_MODE (TREE_TYPE (arg1));
if (arg0_mode == arg1_mode
&& real_cst_p (arg0)
&& real_cst_p (arg1))
{
gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
if (mode == arg0_mode)
{
/* real, real -> real. */
REAL_VALUE_TYPE result;
if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
TREE_REAL_CST_PTR (arg1),
REAL_MODE_FORMAT (mode)))
return build_real (type, result);
}
return NULL_TREE;
}
if (real_cst_p (arg0)
&& integer_cst_p (arg1))
{
gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg0_mode));
if (mode == arg0_mode)
{
/* real, int -> real. */
REAL_VALUE_TYPE result;
if (fold_const_call_sss (&result, fn, TREE_REAL_CST_PTR (arg0),
arg1, REAL_MODE_FORMAT (mode)))
return build_real (type, result);
}
return NULL_TREE;
}
if (integer_cst_p (arg0)
&& real_cst_p (arg1))
{
gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg1_mode));
if (mode == arg1_mode)
{
/* int, real -> real. */
REAL_VALUE_TYPE result;
if (fold_const_call_sss (&result, fn, arg0,
TREE_REAL_CST_PTR (arg1),
REAL_MODE_FORMAT (mode)))
return build_real (type, result);
}
return NULL_TREE;
}
if (arg0_mode == arg1_mode
&& complex_cst_p (arg0)
&& complex_cst_p (arg1))
{
gcc_checking_assert (COMPLEX_MODE_P (arg0_mode));
machine_mode inner_mode = GET_MODE_INNER (arg0_mode);
tree arg0r = TREE_REALPART (arg0);
tree arg0i = TREE_IMAGPART (arg0);
tree arg1r = TREE_REALPART (arg1);
tree arg1i = TREE_IMAGPART (arg1);
if (mode == arg0_mode
&& real_cst_p (arg0r)
&& real_cst_p (arg0i)
&& real_cst_p (arg1r)
&& real_cst_p (arg1i))
{
/* complex real, complex real -> complex real. */
REAL_VALUE_TYPE result_real, result_imag;
if (fold_const_call_ccc (&result_real, &result_imag, fn,
TREE_REAL_CST_PTR (arg0r),
TREE_REAL_CST_PTR (arg0i),
TREE_REAL_CST_PTR (arg1r),
TREE_REAL_CST_PTR (arg1i),
REAL_MODE_FORMAT (inner_mode)))
return build_complex (type,
build_real (TREE_TYPE (type), result_real),
build_real (TREE_TYPE (type), result_imag));
}
return NULL_TREE;
}
return NULL_TREE;
}
static tree
fold_const_call_1 (built_in_function fn, tree type, tree arg)
{
machine_mode mode = TYPE_MODE (type);
machine_mode arg_mode = TYPE_MODE (TREE_TYPE (arg));
if (integer_cst_p (arg))
{
if (SCALAR_INT_MODE_P (mode))
{
wide_int result;
if (fold_const_call_ss (&result, fn, arg, TYPE_PRECISION (type),
TREE_TYPE (arg)))
return wide_int_to_tree (type, result);
}
return NULL_TREE;
}
if (real_cst_p (arg))
{
gcc_checking_assert (SCALAR_FLOAT_MODE_P (arg_mode));
if (mode == arg_mode)
{
/* real -> real. */
REAL_VALUE_TYPE result;
if (fold_const_call_ss (&result, fn, TREE_REAL_CST_PTR (arg),
REAL_MODE_FORMAT (mode)))
return build_real (type, result);
}
else if (COMPLEX_MODE_P (mode)
&& GET_MODE_INNER (mode) == arg_mode)
{
/* real -> complex real. */
REAL_VALUE_TYPE result_real, result_imag;
if (fold_const_call_cs (&result_real, &result_imag, fn,
TREE_REAL_CST_PTR (arg),
REAL_MODE_FORMAT (arg_mode)))
return build_complex (type,
build_real (TREE_TYPE (type), result_real),
build_real (TREE_TYPE (type), result_imag));
}
else if (INTEGRAL_TYPE_P (type))
{
/* real -> int. */
wide_int result;
if (fold_const_call_ss (&result, fn,
TREE_REAL_CST_PTR (arg),
TYPE_PRECISION (type),
REAL_MODE_FORMAT (arg_mode)))
return wide_int_to_tree (type, result);
}
return NULL_TREE;
}
if (complex_cst_p (arg))
{
gcc_checking_assert (COMPLEX_MODE_P (arg_mode));
machine_mode inner_mode = GET_MODE_INNER (arg_mode);
tree argr = TREE_REALPART (arg);
tree argi = TREE_IMAGPART (arg);
if (mode == arg_mode
&& real_cst_p (argr)
&& real_cst_p (argi))
{
/* complex real -> complex real. */
REAL_VALUE_TYPE result_real, result_imag;
if (fold_const_call_cc (&result_real, &result_imag, fn,
TREE_REAL_CST_PTR (argr),
TREE_REAL_CST_PTR (argi),
REAL_MODE_FORMAT (inner_mode)))
return build_complex (type,
build_real (TREE_TYPE (type), result_real),
build_real (TREE_TYPE (type), result_imag));
}
if (mode == inner_mode
&& real_cst_p (argr)
&& real_cst_p (argi))
{
/* complex real -> real. */
REAL_VALUE_TYPE result;
if (fold_const_call_sc (&result, fn,
TREE_REAL_CST_PTR (argr),
TREE_REAL_CST_PTR (argi),
REAL_MODE_FORMAT (inner_mode)))
return build_real (type, result);
}
return NULL_TREE;
}
return NULL_TREE;
}
