From: Eric Botcazou Date: Wed, 6 Feb 2019 23:28:34 +0000 (+0000) Subject: backport: decl.c (annotate_value): Tidy up. X-Git-Tag: releases/gcc-7.5.0~607 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=71174464215e2fa550a6699117c9aad437fd3eb3;p=thirdparty%2Fgcc.git backport: decl.c (annotate_value): Tidy up. Backport from mainline 2017-09-05 Eric Botcazou * gcc-interface/decl.c (annotate_value): Tidy up. : Set TCODE instead of recursing. : Set TCODE instead of calling Create_Node manually. : Fold conversions into inner operations. : Adjust. : Do not fall through. From-SVN: r268598 --- diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index e5adc7f53e0e..a0b7692fa41d 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,15 @@ +2019-02-06 Eric Botcazou + + Backport from mainline + 2017-09-05 Eric Botcazou + + * gcc-interface/decl.c (annotate_value): Tidy up. + : Set TCODE instead of recursing. + : Set TCODE instead of calling Create_Node manually. + : Fold conversions into inner operations. + : Adjust. + : Do not fall through. + 2019-01-27 Eric Botcazou * gcc-interface/decl.c (array_type_has_nonaliased_component): Return diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c index acd7fc5ddc88..ebc441ccc94b 100644 --- a/gcc/ada/gcc-interface/decl.c +++ b/gcc/ada/gcc-interface/decl.c @@ -8048,9 +8048,8 @@ static Uint annotate_value (tree gnu_size) { TCode tcode; - Node_Ref_Or_Val ops[3], ret, pre_op1 = No_Uint; + Node_Ref_Or_Val ops[3] = { No_Uint, No_Uint, No_Uint }; struct tree_int_map in; - int i; /* See if we've already saved the value for this node. */ if (EXPR_P (gnu_size)) @@ -8067,9 +8066,7 @@ annotate_value (tree gnu_size) in.base.from = NULL_TREE; /* If we do not return inside this switch, TCODE will be set to the - code to use for a Create_Node operand and LEN (set above) will be - the number of recursive calls for us to make. */ - + code to be used in a call to Create_Node. */ switch (TREE_CODE (gnu_size)) { case INTEGER_CST: @@ -8079,37 +8076,46 @@ annotate_value (tree gnu_size) if (tree_int_cst_sign_bit (gnu_size)) { tree t = wide_int_to_tree (sizetype, wi::neg (gnu_size)); - return annotate_value (build1 (NEGATE_EXPR, sizetype, t)); + tcode = Negate_Expr; + ops[0] = UI_From_gnu (t); } - - return TREE_OVERFLOW (gnu_size) ? No_Uint : UI_From_gnu (gnu_size); + else + return TREE_OVERFLOW (gnu_size) ? No_Uint : UI_From_gnu (gnu_size); + break; case COMPONENT_REF: /* The only case we handle here is a simple discriminant reference. */ if (DECL_DISCRIMINANT_NUMBER (TREE_OPERAND (gnu_size, 1))) { - tree n = DECL_DISCRIMINANT_NUMBER (TREE_OPERAND (gnu_size, 1)); + tree ref = gnu_size; + gnu_size = TREE_OPERAND (ref, 1); /* Climb up the chain of successive extensions, if any. */ - while (TREE_CODE (TREE_OPERAND (gnu_size, 0)) == COMPONENT_REF - && DECL_NAME (TREE_OPERAND (TREE_OPERAND (gnu_size, 0), 1)) + while (TREE_CODE (TREE_OPERAND (ref, 0)) == COMPONENT_REF + && DECL_NAME (TREE_OPERAND (TREE_OPERAND (ref, 0), 1)) == parent_name_id) - gnu_size = TREE_OPERAND (gnu_size, 0); + ref = TREE_OPERAND (ref, 0); - if (TREE_CODE (TREE_OPERAND (gnu_size, 0)) == PLACEHOLDER_EXPR) - return - Create_Node (Discrim_Val, annotate_value (n), No_Uint, No_Uint); + if (TREE_CODE (TREE_OPERAND (ref, 0)) == PLACEHOLDER_EXPR) + { + /* Fall through to common processing as a FIELD_DECL. */ + tcode = Discrim_Val; + ops[0] = UI_From_gnu (DECL_DISCRIMINANT_NUMBER (gnu_size)); + } + else + return No_Uint; } + else + return No_Uint; + break; - return No_Uint; - - CASE_CONVERT: case NON_LVALUE_EXPR: + CASE_CONVERT: + case NON_LVALUE_EXPR: return annotate_value (TREE_OPERAND (gnu_size, 0)); /* Now just list the operations we handle. */ case COND_EXPR: tcode = Cond_Expr; break; case MINUS_EXPR: tcode = Minus_Expr; break; - case MULT_EXPR: tcode = Mult_Expr; break; case TRUNC_DIV_EXPR: tcode = Trunc_Div_Expr; break; case CEIL_DIV_EXPR: tcode = Ceil_Div_Expr; break; case FLOOR_DIV_EXPR: tcode = Floor_Div_Expr; break; @@ -8140,11 +8146,39 @@ annotate_value (tree gnu_size) && tree_int_cst_sign_bit (TREE_OPERAND (gnu_size, 1))) { tcode = Minus_Expr; + ops[0] = annotate_value (TREE_OPERAND (gnu_size, 0)); wide_int op1 = wi::neg (TREE_OPERAND (gnu_size, 1)); - pre_op1 = annotate_value (wide_int_to_tree (sizetype, op1)); + ops[1] = annotate_value (wide_int_to_tree (sizetype, op1)); + break; + } + + /* ... fall through ... */ + + case MULT_EXPR: + tcode = (TREE_CODE (gnu_size) == MULT_EXPR ? Mult_Expr : Plus_Expr); + /* Fold conversions from bytes to bits into inner operations. */ + if (TREE_CODE (TREE_OPERAND (gnu_size, 1)) == INTEGER_CST + && CONVERT_EXPR_P (TREE_OPERAND (gnu_size, 0))) + { + tree inner_op = TREE_OPERAND (TREE_OPERAND (gnu_size, 0), 0); + if (TREE_CODE (inner_op) == TREE_CODE (gnu_size) + && TREE_CODE (TREE_OPERAND (inner_op, 1)) == INTEGER_CST) + { + ops[0] = annotate_value (TREE_OPERAND (inner_op, 0)); + tree inner_op_op1 = TREE_OPERAND (inner_op, 1); + tree gnu_size_op1 = TREE_OPERAND (gnu_size, 1); + wide_int op1; + if (TREE_CODE (gnu_size) == MULT_EXPR) + op1 = wi::mul (inner_op_op1, gnu_size_op1); + else + { + op1 = wi::add (inner_op_op1, gnu_size_op1); + if (wi::zext (op1, TYPE_PRECISION (sizetype)) == 0) + return ops[0]; + } + ops[1] = annotate_value (wide_int_to_tree (sizetype, op1)); + } } - else - tcode = Plus_Expr; break; case BIT_AND_EXPR: @@ -8155,7 +8189,7 @@ annotate_value (tree gnu_size) { wide_int op1 = wi::sext (TREE_OPERAND (gnu_size, 1), TYPE_PRECISION (sizetype)); - pre_op1 = annotate_value (wide_int_to_tree (sizetype, op1)); + ops[1] = annotate_value (wide_int_to_tree (sizetype, op1)); } break; @@ -8166,34 +8200,26 @@ annotate_value (tree gnu_size) if (List_Representation_Info == 3 || type_annotate_only) { tree t = maybe_inline_call_in_expr (gnu_size); - if (t) - return annotate_value (t); + return t ? annotate_value (t) : No_Uint; } else return Uint_Minus_1; - /* Fall through... */ - default: return No_Uint; } /* Now get each of the operands that's relevant for this code. If any cannot be expressed as a repinfo node, say we can't. */ - for (i = 0; i < 3; i++) - ops[i] = No_Uint; - - for (i = 0; i < TREE_CODE_LENGTH (TREE_CODE (gnu_size)); i++) - { - if (i == 1 && pre_op1 != No_Uint) - ops[i] = pre_op1; - else + for (int i = 0; i < TREE_CODE_LENGTH (TREE_CODE (gnu_size)); i++) + if (ops[i] == No_Uint) + { ops[i] = annotate_value (TREE_OPERAND (gnu_size, i)); - if (ops[i] == No_Uint) - return No_Uint; - } + if (ops[i] == No_Uint) + return No_Uint; + } - ret = Create_Node (tcode, ops[0], ops[1], ops[2]); + Node_Ref_Or_Val ret = Create_Node (tcode, ops[0], ops[1], ops[2]); /* Save the result in the cache. */ if (in.base.from) @@ -8206,7 +8232,7 @@ annotate_value (tree gnu_size) h = annotate_value_cache->find_slot (&in, INSERT); gcc_assert (!*h); *h = ggc_alloc (); - (*h)->base.from = gnu_size; + (*h)->base.from = in.base.from; (*h)->to = ret; }