#include "stringpool.h"
#include "attribs.h"
#include "asan.h"
+#include "selftest.h"
#define maybe_fold_build1_loc(FOLD_P, LOC, CODE, TYPE, EXPR) \
((FOLD_P) ? fold_build1_loc (LOC, CODE, TYPE, EXPR) \
}
}
+/* Subroutine of the various convert_to_*_maybe_fold routines.
+
+ If a location wrapper has been folded to a constant (presumably of
+ a different type), re-wrap the new constant with a location wrapper. */
+
+tree
+preserve_any_location_wrapper (tree result, tree orig_expr)
+{
+ if (CONSTANT_CLASS_P (result) && location_wrapper_p (orig_expr))
+ {
+ if (result == TREE_OPERAND (orig_expr, 0))
+ return orig_expr;
+ else
+ return maybe_wrap_with_location (result, EXPR_LOCATION (orig_expr));
+ }
+
+ return result;
+}
+
/* A wrapper around convert_to_pointer_1 that always folds the
expression. */
}
/* A wrapper around convert_to_pointer_1 that only folds the
- expression if DOFOLD, or if it is CONSTANT_CLASS_P. */
+ expression if DOFOLD, or if it is CONSTANT_CLASS_OR_WRAPPER_P. */
tree
convert_to_pointer_maybe_fold (tree type, tree expr, bool dofold)
{
- return convert_to_pointer_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
+ tree result
+ = convert_to_pointer_1 (type, expr,
+ dofold || CONSTANT_CLASS_OR_WRAPPER_P (expr));
+ return preserve_any_location_wrapper (result, expr);
}
/* Convert EXPR to some floating-point type TYPE.
}
/* A wrapper around convert_to_real_1 that only folds the
- expression if DOFOLD, or if it is CONSTANT_CLASS_P. */
+ expression if DOFOLD, or if it is CONSTANT_CLASS_OR_WRAPPER_P. */
tree
convert_to_real_maybe_fold (tree type, tree expr, bool dofold)
{
- return convert_to_real_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
+ tree result
+ = convert_to_real_1 (type, expr,
+ dofold || CONSTANT_CLASS_OR_WRAPPER_P (expr));
+ return preserve_any_location_wrapper (result, expr);
}
/* Try to narrow EX_FORM ARG0 ARG1 in narrowed arg types producing a
{
case POINTER_TYPE:
case REFERENCE_TYPE:
- if (integer_zerop (expr) && !TREE_OVERFLOW (expr))
+ if (integer_zerop (expr)
+ && !TREE_OVERFLOW (tree_strip_any_location_wrapper (expr)))
return build_int_cst (type, 0);
/* Convert to an unsigned integer of the correct width first, and from
/* When parsing long initializers, we might end up with a lot of casts.
Shortcut this. */
- if (TREE_CODE (expr) == INTEGER_CST)
+ if (TREE_CODE (tree_strip_any_location_wrapper (expr)) == INTEGER_CST)
return fold_convert (type, expr);
return build1 (CONVERT_EXPR, type, expr);
}
/* A wrapper around convert_to_complex_1 that only folds the
- expression if DOFOLD, or if it is CONSTANT_CLASS_P. */
+ expression if DOFOLD, or if it is CONSTANT_CLASS_OR_WRAPPER_P. */
tree
convert_to_integer_maybe_fold (tree type, tree expr, bool dofold)
{
- return convert_to_integer_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
+ tree result
+ = convert_to_integer_1 (type, expr,
+ dofold || CONSTANT_CLASS_OR_WRAPPER_P (expr));
+ return preserve_any_location_wrapper (result, expr);
}
/* Convert EXPR to the complex type TYPE in the usual ways. If FOLD_P is
}
/* A wrapper around convert_to_complex_1 that only folds the
- expression if DOFOLD, or if it is CONSTANT_CLASS_P. */
+ expression if DOFOLD, or if it is CONSTANT_CLASS_OR_WRAPPER_P. */
tree
convert_to_complex_maybe_fold (tree type, tree expr, bool dofold)
{
- return convert_to_complex_1 (type, expr, dofold || CONSTANT_CLASS_P (expr));
+ tree result
+ = convert_to_complex_1 (type, expr,
+ dofold || CONSTANT_CLASS_OR_WRAPPER_P (expr));
+ return preserve_any_location_wrapper (result, expr);
}
/* Convert EXPR to the vector type TYPE in the usual ways. */
return error_mark_node;
}
}
+
+#if CHECKING_P
+
+namespace selftest {
+
+/* Selftests for conversions. */
+
+static void
+test_convert_to_integer_maybe_fold (tree orig_type, tree new_type)
+{
+ /* Calling convert_to_integer_maybe_fold on an INTEGER_CST. */
+
+ tree orig_cst = build_int_cst (orig_type, 42);
+
+ /* Verify that convert_to_integer_maybe_fold on a constant returns a new
+ constant of the new type, unless the types are the same, in which
+ case verify it's a no-op. */
+ {
+ tree result = convert_to_integer_maybe_fold (new_type,
+ orig_cst, false);
+ if (orig_type != new_type)
+ {
+ ASSERT_EQ (TREE_TYPE (result), new_type);
+ ASSERT_EQ (TREE_CODE (result), INTEGER_CST);
+ }
+ else
+ ASSERT_EQ (result, orig_cst);
+ }
+
+ /* Calling convert_to_integer_maybe_fold on a location wrapper around
+ an INTEGER_CST.
+
+ Verify that convert_to_integer_maybe_fold on a location wrapper
+ around a constant returns a new location wrapper around an equivalent
+ constant, both of the new type, unless the types are the same,
+ in which case the original wrapper should be returned. */
+ {
+ const location_t loc = BUILTINS_LOCATION;
+ tree wrapped_orig_cst = maybe_wrap_with_location (orig_cst, loc);
+ tree result
+ = convert_to_integer_maybe_fold (new_type, wrapped_orig_cst, false);
+ ASSERT_EQ (TREE_TYPE (result), new_type);
+ ASSERT_EQ (EXPR_LOCATION (result), loc);
+ ASSERT_TRUE (location_wrapper_p (result));
+ ASSERT_EQ (TREE_TYPE (TREE_OPERAND (result, 0)), new_type);
+ ASSERT_EQ (TREE_CODE (TREE_OPERAND (result, 0)), INTEGER_CST);
+
+ if (orig_type == new_type)
+ ASSERT_EQ (result, wrapped_orig_cst);
+ }
+}
+
+/* Verify that convert_to_integer_maybe_fold preserves locations. */
+
+static void
+test_convert_to_integer_maybe_fold ()
+{
+ /* char -> long. */
+ test_convert_to_integer_maybe_fold (char_type_node, long_integer_type_node);
+
+ /* char -> char. */
+ test_convert_to_integer_maybe_fold (char_type_node, char_type_node);
+
+ /* long -> char. */
+ test_convert_to_integer_maybe_fold (char_type_node, long_integer_type_node);
+
+ /* long -> long. */
+ test_convert_to_integer_maybe_fold (long_integer_type_node,
+ long_integer_type_node);
+}
+
+/* Run all of the selftests within this file. */
+
+void
+convert_c_tests ()
+{
+ test_convert_to_integer_maybe_fold ();
+}
+
+} // namespace selftest
+
+#endif /* CHECKING_P */
projects / thirdparty / gcc.git / blobdiff