On Fri, Aug 1, 2014 at 6:03 PM, Kugan <kugan.vivekanandara...@linaro.org> wrote: >>>> if (rhs_uns) >>>> return wi::ge_p (min, 0); // if min >= 0 then range contains positive >>>> values >>>> else >>>> return wi::le_p (max, wi::max_value (TYPE_PRECISION (TREE_TYPE >>>> (ssa)), SIGNED); // if max <= signed-max-of-type then range doesn't >>>> need sign-extension >>> >>> I think we will have to check that ssa has necessary sign/zero extension >>> when assigned to lhs_type. If PROMOTE_MODE tells us that ssa's type will >>> be interpreted differently, the value range of ssa also will have >>> corresponding range. In this cases, shouldn’t we have to check for >>> upper and lower limit for both min and max? >> >> Hmm? That's exactly what the check is testing... we know that >> min <= max thus if min >= 0 then max >= 0. >> >> zero_extension will never do anything on [0, INF] >> >> If max < MAX-SIGNED then sign-extension will not do anything. Ok, >> sign-extension will do sth for negative values still. So rather >> >> if (rhs_uns) >> return wi::geu_p (min, 0); >> else >> return wi::ges_p (min, 0) && wi::les_p (max, wi::max_value >> (TYPE_PRECISION (TREE_TYPE (ssa)), SIGNED)); >> >> ? > > Thanks for the explanation. I agree. Don’t we have to however check this > on lhs_uns as this function is checking if ssa is promoted for lhs_sign > and lhs_mode? > > Here is an attempt based on this. I ran regression testing with > arm-none-linux-gnueabi on qemu-arm without any new regressions. > > Sine I am not comparing value ranges to see if it can be represented in > lhs_sigh, I can now skip the PROMOTED_MODE check.
Now I'm lost. You call this function from two contexts: diff --git a/gcc/calls.c b/gcc/calls.c index a3e6faa..eac512f 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -1484,7 +1484,10 @@ precompute_arguments (int num_actuals, struct arg_data *args) args[i].initial_value = gen_lowpart_SUBREG (mode, args[i].value); SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1; - SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp); + if (is_promoted_for_type (args[i].tree_value, mode, !args[i].unsignedp)) + SUBREG_PROMOTED_SET (args[i].initial_value, SRP_SIGNED_AND_UNSIGNED); + else + SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp); and @@ -9527,7 +9587,10 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode, temp = gen_lowpart_SUBREG (mode, decl_rtl); SUBREG_PROMOTED_VAR_P (temp) = 1; - SUBREG_PROMOTED_SET (temp, unsignedp); + if (is_promoted_for_type (ssa_name, mode, !unsignedp)) + SUBREG_PROMOTED_SET (temp, SRP_SIGNED_AND_UNSIGNED); + else + SUBREG_PROMOTED_SET (temp, unsignedp); return temp; } what's the semantic of setting SRP_SIGNED_AND_UNSIGNED on the subreg? That is, for the created (subreg:lhs_mode (reg:<PROMOTE_MODE of ssa> N))? it seems that we need to verify that 'ssa', when promoted, does not have bits set above the target modes MSB when we know it is zero-extended (according to PROMOTE_MODE)? Or has all bits set to one and is sign-extended (according to PROMOTE_MODE)? Now it seems that the promotion is according to promote_{function,decl}_mode in expand_expr_real_1 and according to promote_mode in calls.c. The function comment above promoted_for_type_p needs to be more elaborate on what invariant it checks. As you pass in the subreg mode but you need to verify the larger mode is properly extended. > I am still using wide_int::from (instead of wi::max_value) to get the > limit as I have to match the precision with min, max precision. > otherwise wide_int comparisons will not work. Is there a better way for > this? I don't understand. wi::max_value takes a precision argument. > > /* Return TRUE if value in SSA is already zero/sign extended for lhs type > (type here is the combination of LHS_MODE and LHS_UNS) using value range > information stored. Return FALSE otherwise. */ > bool > promoted_for_type_p (tree ssa, enum machine_mode lhs_mode, bool lhs_uns) > { > wide_int min, max, limit; > tree lhs_type; > bool rhs_uns; > signop rhs_signop; > > if (ssa == NULL_TREE > || TREE_CODE (ssa) != SSA_NAME > || !INTEGRAL_TYPE_P (TREE_TYPE (ssa))) > return false; > > /* Return FALSE if value_range is not recorded for SSA. */ > if (get_range_info (ssa, &min, &max) != VR_RANGE) > return false; > > rhs_uns = TYPE_UNSIGNED (TREE_TYPE (ssa)); > rhs_signop = rhs_uns ? UNSIGNED : SIGNED; > lhs_type = lang_hooks.types.type_for_mode (lhs_mode, lhs_uns); > limit = wide_int::from (TYPE_MAX_VALUE (lhs_type), > TYPE_PRECISION (TREE_TYPE (ssa)), SIGNED); > > if (lhs_uns) > /* If min >= 0 then range contains positive values and doesnt need > zero-extension. */ > return wi::ge_p (min, 0, rhs_signop); > else > /* If min >= 0 and max <= signed-max-of-type then range doesn't need > sign-extension. */ > return wi::ge_p (min, 0, rhs_signop) && wi::le_p (max, limit, > rhs_signop); > } > > Thanks, > Kugan