From 2117b9bb988c489ff1a2233e066abc7cf9b136c1 Mon Sep 17 00:00:00 2001 From: Eric Botcazou Date: Mon, 25 May 2015 20:59:27 +0000 Subject: [PATCH] decl.c (gnat_to_gnu_entity): Minor tweak. * gcc-interface/decl.c (gnat_to_gnu_entity): Minor tweak. * gcc-interface/trans.c (finalize_nrv_unc_r): Use CONSTRUCTOR_ELT. * gcc-interface/utils.c (convert): Likewise and simplify. (remove_conversions): Likewise. * gcc-interface/utils2.c (compare_fat_pointers): Likewise. (build_unary_op): Likewise and simplify. From-SVN: r223653 --- gcc/ada/ChangeLog | 9 +++++++++ gcc/ada/gcc-interface/decl.c | 4 ++-- gcc/ada/gcc-interface/trans.c | 15 ++++++++------- gcc/ada/gcc-interface/utils.c | 8 +++----- gcc/ada/gcc-interface/utils2.c | 30 ++++++++++++++---------------- 5 files changed, 36 insertions(+), 30 deletions(-) diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index eb0a3baa9f5..41af09ac57a 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,12 @@ +2015-05-25 Eric Botcazou + + * gcc-interface/decl.c (gnat_to_gnu_entity): Minor tweak. + * gcc-interface/trans.c (finalize_nrv_unc_r): Use CONSTRUCTOR_ELT. + * gcc-interface/utils.c (convert): Likewise and simplify. + (remove_conversions): Likewise. + * gcc-interface/utils2.c (compare_fat_pointers): Likewise. + (build_unary_op): Likewise and simplify. + 2015-05-25 Eric Botcazou * gcc-interface/gigi.h (build_atomic_load): Adjust prototype. diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index 27f906d6891..501b0761c7d 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -1335,8 +1335,8 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition) = TREE_TYPE (DECL_CHAIN (TYPE_FIELDS (gnu_alloc_type))); if (TREE_CODE (gnu_expr) == CONSTRUCTOR - && 1 == vec_safe_length (CONSTRUCTOR_ELTS (gnu_expr))) - gnu_expr = 0; + && vec_safe_length (CONSTRUCTOR_ELTS (gnu_expr)) == 1) + gnu_expr = NULL_TREE; else gnu_expr = build_component_ref diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c index 3c957a68a1d..cb8662c0a87 100644 --- a/gcc/ada/gcc-interface/trans.c +++ b/gcc/ada/gcc-interface/trans.c @@ -3309,12 +3309,12 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) if (TREE_CODE (ret_val) == COMPOUND_EXPR && TREE_CODE (TREE_OPERAND (ret_val, 0)) == INIT_EXPR) { + tree rhs = TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1); + if (TYPE_IS_FAT_POINTER_P (TREE_TYPE (ret_val))) - ret_val - = (*CONSTRUCTOR_ELTS (TREE_OPERAND (TREE_OPERAND (ret_val, 0), - 1)))[1].value; + ret_val = CONSTRUCTOR_ELT (rhs, 1)->value; else - ret_val = TREE_OPERAND (TREE_OPERAND (ret_val, 0), 1); + ret_val = rhs; } /* Strip useless conversions around the return value. */ @@ -3365,20 +3365,21 @@ finalize_nrv_unc_r (tree *tp, int *walk_subtrees, void *data) if (TYPE_IS_FAT_POINTER_P (TREE_TYPE (alloc))) { + tree cst = TREE_OPERAND (alloc, 1); + /* The new initial value is a COMPOUND_EXPR with the allocation in the first arm and the value of P_ARRAY in the second arm. */ DECL_INITIAL (new_var) = build2 (COMPOUND_EXPR, TREE_TYPE (new_var), TREE_OPERAND (alloc, 0), - (*CONSTRUCTOR_ELTS (TREE_OPERAND (alloc, 1)))[0].value); + CONSTRUCTOR_ELT (cst, 0)->value); /* Build a modified CONSTRUCTOR that references NEW_VAR. */ p_array = TYPE_FIELDS (TREE_TYPE (alloc)); CONSTRUCTOR_APPEND_ELT (v, p_array, fold_convert (TREE_TYPE (p_array), new_var)); CONSTRUCTOR_APPEND_ELT (v, DECL_CHAIN (p_array), - (*CONSTRUCTOR_ELTS ( - TREE_OPERAND (alloc, 1)))[1].value); + CONSTRUCTOR_ELT (cst, 1)->value); new_ret = build_constructor (TREE_TYPE (alloc), v); } else diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c index 184c7d53e9e..3cefe112834 100644 --- a/gcc/ada/gcc-interface/utils.c +++ b/gcc/ada/gcc-interface/utils.c @@ -4067,10 +4067,8 @@ convert (tree type, tree expr) /* If we have just converted to this padded type, just get the inner expression. */ - if (TREE_CODE (expr) == CONSTRUCTOR - && !vec_safe_is_empty (CONSTRUCTOR_ELTS (expr)) - && (*CONSTRUCTOR_ELTS (expr))[0].index == TYPE_FIELDS (etype)) - unpadded = (*CONSTRUCTOR_ELTS (expr))[0].value; + if (TREE_CODE (expr) == CONSTRUCTOR) + unpadded = CONSTRUCTOR_ELT (expr, 0)->value; /* Otherwise, build an explicit component reference. */ else @@ -4632,7 +4630,7 @@ remove_conversions (tree exp, bool true_address) && TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE && TYPE_JUSTIFIED_MODULAR_P (TREE_TYPE (exp))) return - remove_conversions ((*CONSTRUCTOR_ELTS (exp))[0].value, true); + remove_conversions (CONSTRUCTOR_ELT (exp, 0)->value, true); break; case COMPONENT_REF: diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c index aa92382e99e..42587d9a802 100644 --- a/gcc/ada/gcc-interface/utils2.c +++ b/gcc/ada/gcc-interface/utils2.c @@ -461,7 +461,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) /* The constant folder doesn't fold fat pointer types so we do it here. */ if (TREE_CODE (p1) == CONSTRUCTOR) - p1_array = (*CONSTRUCTOR_ELTS (p1))[0].value; + p1_array = CONSTRUCTOR_ELT (p1, 0)->value; else p1_array = build_component_ref (p1, NULL_TREE, TYPE_FIELDS (TREE_TYPE (p1)), true); @@ -472,7 +472,7 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) null_pointer_node)); if (TREE_CODE (p2) == CONSTRUCTOR) - p2_array = (*CONSTRUCTOR_ELTS (p2))[0].value; + p2_array = CONSTRUCTOR_ELT (p2, 0)->value; else p2_array = build_component_ref (p2, NULL_TREE, TYPE_FIELDS (TREE_TYPE (p2)), true); @@ -493,14 +493,14 @@ compare_fat_pointers (location_t loc, tree result_type, tree p1, tree p2) = fold_build2_loc (loc, EQ_EXPR, result_type, p1_array, p2_array); if (TREE_CODE (p1) == CONSTRUCTOR) - p1_bounds = (*CONSTRUCTOR_ELTS (p1))[1].value; + p1_bounds = CONSTRUCTOR_ELT (p1, 1)->value; else p1_bounds = build_component_ref (p1, NULL_TREE, DECL_CHAIN (TYPE_FIELDS (TREE_TYPE (p1))), true); if (TREE_CODE (p2) == CONSTRUCTOR) - p2_bounds = (*CONSTRUCTOR_ELTS (p2))[1].value; + p2_bounds = CONSTRUCTOR_ELT (p2, 1)->value; else p2_bounds = build_component_ref (p2, NULL_TREE, @@ -1445,15 +1445,13 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) offset = size_binop (PLUS_EXPR, offset, size_int (bitpos / BITS_PER_UNIT)); - /* Take the address of INNER, convert the offset to void *, and - add then. It will later be converted to the desired result - type, if any. */ - inner = build_unary_op (ADDR_EXPR, NULL_TREE, inner); - inner = convert (ptr_void_type_node, inner); - result = build_binary_op (POINTER_PLUS_EXPR, ptr_void_type_node, + /* Take the address of INNER, convert it to a pointer to our type + and add the offset. */ + inner = build_unary_op (ADDR_EXPR, + build_pointer_type (TREE_TYPE (operand)), + inner); + result = build_binary_op (POINTER_PLUS_EXPR, TREE_TYPE (inner), inner, offset); - result = convert (build_pointer_type (TREE_TYPE (operand)), - result); break; } goto common; @@ -1464,12 +1462,12 @@ build_unary_op (enum tree_code op_code, tree result_type, tree operand) a pointer to our type. */ if (TYPE_IS_PADDING_P (type)) { - result = (*CONSTRUCTOR_ELTS (operand))[0].value; - result = convert (build_pointer_type (TREE_TYPE (operand)), - build_unary_op (ADDR_EXPR, NULL_TREE, result)); + result + = build_unary_op (ADDR_EXPR, + build_pointer_type (TREE_TYPE (operand)), + CONSTRUCTOR_ELT (operand, 0)->value); break; } - goto common; case NOP_EXPR: -- 2.30.2