From 0a8f7044b7adb657d0883f4bd3bc5b9a56e2ce4f Mon Sep 17 00:00:00 2001 From: David Malcolm Date: Fri, 3 Nov 2017 17:26:10 -0400 Subject: [PATCH 10/25] {[02/14], approved} Support for adding and stripping location_t wrapper nodes Changed in v2.3: * move most of location_wrapper_p's comment inside the function Changed in v2.2: * added tree_strip_any_location_wrapper * removed checking for !CONSTANT_CLASS_P on VIEW_CONVERT_EXPR Changed in v2.1: * updated comments for location_wrapper_p and maybe_wrap_with_location * added selftests This patch provides a mechanism in tree.c for adding a wrapper node for expressing a location_t, for those nodes for which !CAN_HAVE_LOCATION_P. It's called in later patches in the kit via a new method of cp_expr. In this version of the patch, I use NON_LVALUE_EXPR for wrapping constants, and VIEW_CONVERT_EXPR for other nodes. I also turned off wrapper nodes for EXCEPTIONAL_CLASS_P, for the sake of keeping the patch kit more minimal. The patch also adds a STRIP_ANY_LOCATION_WRAPPER macro for stripping such nodes, used later on in the patch kit. gcc/ChangeLog: PR c++/43486 * tree.c (maybe_wrap_with_location): New function. (selftest::test_location_wrappers): New function. (selftest::tree_c_tests): Call it. * tree.h (STRIP_ANY_LOCATION_WRAPPER): New macro. (maybe_wrap_with_location): New decl. (location_wrapper_p): New inline function. (tree_strip_any_location_wrapper): New inline function. gcc/cp/ChangeLog: PR c++/43486 * cp-tree.h (cp_expr::maybe_add_location_wrapper): New method. --- gcc/cp/cp-tree.h | 6 +++++ gcc/tree.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ gcc/tree.h | 51 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 126 insertions(+) diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 708d172..9879e16 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -93,6 +93,12 @@ public: set_location (make_location (m_loc, start, finish)); } + cp_expr& maybe_add_location_wrapper () + { + m_value = maybe_wrap_with_location (m_value, m_loc); + return *this; + } + private: tree m_value; location_t m_loc; diff --git a/gcc/tree.c b/gcc/tree.c index 053670c..2d14916 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -13806,6 +13806,38 @@ set_source_range (tree expr, source_range src_range) return adhoc; } +/* Return EXPR, potentially wrapped with a node expression LOC, + if !CAN_HAVE_LOCATION_P (expr). + + NON_LVALUE_EXPR is used for wrapping constants. + VIEW_CONVERT_EXPR is used for wrapping non-constants. + + Wrapper nodes can be identified using location_wrapper_p. */ + +tree +maybe_wrap_with_location (tree expr, location_t loc) +{ + if (expr == NULL) + return NULL; + if (loc == UNKNOWN_LOCATION) + return expr; + if (CAN_HAVE_LOCATION_P (expr)) + return expr; + /* We should only be adding wrappers for constants and for decls, + or for some exceptional tree nodes (e.g. BASELINK in the C++ FE). */ + gcc_assert (CONSTANT_CLASS_P (expr) + || DECL_P (expr) + || EXCEPTIONAL_CLASS_P (expr)); + + if (EXCEPTIONAL_CLASS_P (expr)) + return expr; + + if (CONSTANT_CLASS_P (expr)) + return build1_loc (loc, NON_LVALUE_EXPR, TREE_TYPE (expr), expr); + else + return build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (expr), expr); +} + /* Return the name of combined function FN, for debugging purposes. */ const char * @@ -14176,6 +14208,42 @@ test_vector_cst_patterns () check_vector_cst_fill (elements, build_vector (vector_type, elements), 4); } +/* Verify location wrappers. */ + +static void +test_location_wrappers () +{ + location_t loc = BUILTINS_LOCATION; + + /* Wrapping a constant. */ + tree int_cst = build_int_cst (integer_type_node, 42); + ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_cst)); + ASSERT_FALSE (location_wrapper_p (int_cst)); + + tree wrapped_int_cst = maybe_wrap_with_location (int_cst, loc); + ASSERT_TRUE (location_wrapper_p (wrapped_int_cst)); + ASSERT_EQ (loc, EXPR_LOCATION (wrapped_int_cst)); + ASSERT_EQ (int_cst, tree_strip_any_location_wrapper (wrapped_int_cst)); + + /* Wrapping a variable. */ + tree int_var = build_decl (UNKNOWN_LOCATION, VAR_DECL, + get_identifier ("some_int_var"), + integer_type_node); + ASSERT_FALSE (CAN_HAVE_LOCATION_P (int_var)); + ASSERT_FALSE (location_wrapper_p (int_var)); + + tree wrapped_int_var = maybe_wrap_with_location (int_var, loc); + ASSERT_TRUE (location_wrapper_p (wrapped_int_var)); + ASSERT_EQ (loc, EXPR_LOCATION (wrapped_int_var)); + ASSERT_EQ (int_var, tree_strip_any_location_wrapper (wrapped_int_var)); + + /* Verify that "reinterpret_cast(some_int_var)" is not a location + wrapper. */ + tree r_cast = build1 (NON_LVALUE_EXPR, integer_type_node, int_var); + ASSERT_FALSE (location_wrapper_p (r_cast)); + ASSERT_EQ (r_cast, tree_strip_any_location_wrapper (r_cast)); +} + /* Run all of the selftests within this file. */ void @@ -14185,6 +14253,7 @@ tree_c_tests () test_identifiers (); test_labels (); test_vector_cst_patterns (); + test_location_wrappers (); } } // namespace selftest diff --git a/gcc/tree.h b/gcc/tree.h index 306ff09..de085ca 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -483,6 +483,12 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, #define STRIP_USELESS_TYPE_CONVERSION(EXP) \ (EXP) = tree_ssa_strip_useless_type_conversions (EXP) +/* Remove any VIEW_CONVERT_EXPR or NON_LVALUE_EXPR that's purely + in use to provide a location_t. */ + +#define STRIP_ANY_LOCATION_WRAPPER(EXP) \ + (EXP) = tree_strip_any_location_wrapper (CONST_CAST_TREE (EXP)) + /* Nonzero if TYPE represents a vector type. */ #define VECTOR_TYPE_P(TYPE) (TREE_CODE (TYPE) == VECTOR_TYPE) @@ -1165,6 +1171,8 @@ get_expr_source_range (tree expr) extern void protected_set_expr_location (tree, location_t); +extern tree maybe_wrap_with_location (tree, location_t); + /* In a TARGET_EXPR node. */ #define TARGET_EXPR_SLOT(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 0) #define TARGET_EXPR_INITIAL(NODE) TREE_OPERAND_CHECK_CODE (NODE, TARGET_EXPR, 1) @@ -3662,6 +3670,49 @@ id_equal (const char *str, const_tree id) return !strcmp (str, IDENTIFIER_POINTER (id)); } +/* Test if EXP is merely a wrapper node, added to express a location_t + on behalf of the node's child (e.g. by maybe_wrap_with_location). */ + +inline bool +location_wrapper_p (const_tree exp) +{ + /* A wrapper node has code NON_LVALUE_EXPR or VIEW_CONVERT_EXPR, and the + same type as its operand. + + NON_LVALUE_EXPR is used for wrapping constants. + VIEW_CONVERT_EXPR is used for wrapping non-constants. + + A subtlety is that we may have to test whether we have the correct + TREE_CODE for the wrapped TREE_CODE. Otherwise, e.g. the C++ expression: + reinterpret_cast(some_int_var) + is a NON_LVALUE_EXPR around a non-constant of the same type, and + could thus be mischaracterized as a location wrapper node. + + Hence we need to check CONSTANT_CLASS_P (TREE_OPERAND (EXP, 0)) + for a NON_LVALUE_EXPR for EXP to be a wrapper. + We don't need to check a VIEW_CONVERT_EXPR that wraps the same type + for !CONSTANT_CLASS_P; such instances of VIEW_CONVERT_EXPR are always + wrappers. */ + if (((TREE_CODE (exp) == NON_LVALUE_EXPR + && CONSTANT_CLASS_P (TREE_OPERAND (exp, 0))) + || TREE_CODE (exp) == VIEW_CONVERT_EXPR) + && (TREE_TYPE (exp) + == TREE_TYPE (TREE_OPERAND (exp, 0)))) + return true; + return false; +} + +/* Implementation of STRIP_ANY_LOCATION_WRAPPER. */ + +inline tree +tree_strip_any_location_wrapper (tree exp) +{ + if (location_wrapper_p (exp)) + return TREE_OPERAND (exp, 0); + else + return exp; +} + #define error_mark_node global_trees[TI_ERROR_MARK] #define intQI_type_node global_trees[TI_INTQI_TYPE] -- 1.8.5.3