pp_decimal_int (buffer, TYPE_PRECISION (node));
pp_string (buffer, ">");
}
+ else if (TREE_CODE (node) == VOID_TYPE)
+ pp_string (buffer, "void");
else
pp_string (buffer, "<unnamed type>");
}
case MEM_REF:
{
if (integer_zerop (TREE_OPERAND (node, 1))
+ /* Dump the types of INTEGER_CSTs explicitly, for we can't
+ infer them and MEM_ATTR caching will share MEM_REFs
+ with differently-typed op0s. */
+ && TREE_CODE (TREE_OPERAND (node, 0)) != INTEGER_CST
/* Same pointer types, but ignoring POINTER_TYPE vs.
REFERENCE_TYPE. */
&& (TREE_TYPE (TREE_TYPE (TREE_OPERAND (node, 0)))
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (node, 1))))
&& (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 0)))
== TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (node, 1))))
- && (TYPE_QUALS (TREE_TYPE (TREE_OPERAND (node, 0)))
- == TYPE_QUALS (TREE_TYPE (TREE_OPERAND (node, 1))))
/* Same value types ignoring qualifiers. */
&& (TYPE_MAIN_VARIANT (TREE_TYPE (node))
== TYPE_MAIN_VARIANT
}
else
{
+ tree ptype;
+
pp_string (buffer, "MEM[");
pp_string (buffer, "(");
- dump_generic_node (buffer, TREE_TYPE (TREE_OPERAND (node, 1)),
+ ptype = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (node, 1)));
+ dump_generic_node (buffer, ptype,
spc, flags | TDF_SLIM, false);
pp_string (buffer, ")");
dump_generic_node (buffer, TREE_OPERAND (node, 0),
pp_string (buffer, "MEM[");
- tmp = TMR_SYMBOL (node);
- if (tmp)
+ if (TREE_CODE (TMR_BASE (node)) == ADDR_EXPR)
{
pp_string (buffer, sep);
sep = ", ";
pp_string (buffer, "symbol: ");
- dump_generic_node (buffer, tmp, spc, flags, false);
+ dump_generic_node (buffer, TREE_OPERAND (TMR_BASE (node), 0),
+ spc, flags, false);
}
- tmp = TMR_BASE (node);
+ else
+ {
+ pp_string (buffer, sep);
+ sep = ", ";
+ pp_string (buffer, "base: ");
+ dump_generic_node (buffer, TMR_BASE (node), spc, flags, false);
+ }
+ tmp = TMR_INDEX2 (node);
if (tmp)
{
pp_string (buffer, sep);
|| (TREE_CODE (op0) == MEM_REF
&& TREE_CODE (TREE_OPERAND (op0, 0)) != ADDR_EXPR
&& integer_zerop (TREE_OPERAND (op0, 1))
+ /* Dump the types of INTEGER_CSTs explicitly, for we
+ can't infer them and MEM_ATTR caching will share
+ MEM_REFs with differently-typed op0s. */
+ && TREE_CODE (TREE_OPERAND (op0, 0)) != INTEGER_CST
/* Same pointer types, but ignoring POINTER_TYPE vs.
REFERENCE_TYPE. */
&& (TREE_TYPE (TREE_TYPE (TREE_OPERAND (op0, 0)))
== TYPE_MODE (TREE_TYPE (TREE_OPERAND (op0, 1))))
&& (TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 0)))
== TYPE_REF_CAN_ALIAS_ALL (TREE_TYPE (TREE_OPERAND (op0, 1))))
- && (TYPE_QUALS (TREE_TYPE (TREE_OPERAND (op0, 0)))
- == TYPE_QUALS (TREE_TYPE (TREE_OPERAND (op0, 1))))
/* Same value types ignoring qualifiers. */
&& (TYPE_MAIN_VARIANT (TREE_TYPE (op0))
== TYPE_MAIN_VARIANT
case ADDR_EXPR:
case PREDECREMENT_EXPR:
case PREINCREMENT_EXPR:
- case MISALIGNED_INDIRECT_REF:
case INDIRECT_REF:
if (TREE_CODE (node) == ADDR_EXPR
&& (TREE_CODE (TREE_OPERAND (node, 0)) == STRING_CST
}
else
dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-
- if (TREE_CODE (node) == MISALIGNED_INDIRECT_REF)
- {
- pp_string (buffer, "{misalignment: ");
- dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
- pp_character (buffer, '}');
- }
break;
case POSTDECREMENT_EXPR:
pp_string (buffer, " > ");
break;
+ case FMA_EXPR:
+ pp_string (buffer, " FMA_EXPR < ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
+ pp_string (buffer, ", ");
+ dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
+ pp_string (buffer, " > ");
+ break;
+
case OMP_PARALLEL:
pp_string (buffer, "#pragma omp parallel");
dump_omp_clauses (buffer, OMP_PARALLEL_CLAUSES (node), spc, flags);
case CEIL_MOD_EXPR:
case FLOOR_MOD_EXPR:
case ROUND_MOD_EXPR:
+ case FMA_EXPR:
return 13;
case TRUTH_NOT_EXPR:
case PREINCREMENT_EXPR:
case PREDECREMENT_EXPR:
case NEGATE_EXPR:
- case MISALIGNED_INDIRECT_REF:
case INDIRECT_REF:
case ADDR_EXPR:
case FLOAT_EXPR:
case INDIRECT_REF:
return "*";
- case MISALIGNED_INDIRECT_REF:
- return "M*";
-
case TRUNC_DIV_EXPR:
case RDIV_EXPR:
return "/";