[PATCH][AArch64][9/14] Implement TARGET_CAN_INLINE_P

[PATCH][AArch64][9/14] Implement TARGET_CAN_INLINE_P

[Kyrill Tkachov]

[-- Attachment #1: Type: text/plain, Size: 1509 bytes --]

Hi all,

This patch implements the target-specific inlining rules.
The basic philosophy is that we want to definitely reject inlining if the callee's architecture
is not a subset, feature-wise, of the caller's.

Beyond that, we want to allow inlining if the callee is always_inline.
If it's not, we reject inlining if the TargetSave options don't match up
in a way that's described in the comments in the patch.

Generally, we try to allow as much inlining as possible for the benefit of LTO.
However, if the architectural features of the callee are not a subset of the features
of the caller, then we must reject inlining. For example, inlining a function with 'simd'
into a function without 'simd' is not allowed.

Also, inlining a non-strict-align function into a strict-align function is not allowed.
These two restrictions apply even when the callee is tagged with always_inline because they
can affect the correctness of the program.

Beyond that, we reject inlining only if the user has explicitly specified attributes/options for
both the caller and the callee and they don't match up.

An exception to that are the tuning CPUs. We want to allow inlining even when the tuning CPUs don't match.

Bootstrapped and tested on aarch64.

Ok for trunk?

Thanks,
Kyrill

2015-07-16  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>

     * config/aarch64/aarch64.c (aarch64_reject_inlining): New function.
     (aarch64_can_inline_p): Likewise.
     (TARGET_CAN_INLINE_P): Define.

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: aarch64-attrs-9.patch --]
[-- Type: text/x-patch; name=aarch64-attrs-9.patch, Size: 5053 bytes --]

commit 55e576c7ca01679551404dac9f6302443c2a6bae
Author: Kyrylo Tkachov <kyrylo.tkachov@arm.com>
Date:   Thu May 14 12:00:07 2015 +0100

    [AArch64][9/N] Implement TARGET_CAN_INLINE_P

diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index 0a6ed70..34cd986 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -8486,6 +8486,113 @@ aarch64_option_valid_attribute_p (tree fndecl, tree, tree args, int)
   return ret;
 }
 
+/* Helper for aarch64_can_inline_p.  In the case where CALLER and CALLEE are
+   tri-bool options (yes, no, don't care) and the default value is
+   DEF, determine whether to reject inlining.  */
+
+static bool
+aarch64_reject_inlining (int caller, int callee, int dont_care, int def)
+{
+  /* If both caller and callee care about the value then reject inlining
+     if they don't match up.  */
+  if (caller != dont_care && callee != dont_care && caller != callee)
+    return true;
+
+  /* If caller doesn't care then make sure that the default agrees
+     with the callee.  */
+  if (caller == dont_care && callee != dont_care && callee != def)
+    return true;
+
+  return false;
+}
+
+/* Implement TARGET_CAN_INLINE_P.  Decide whether it is valid
+   to inline CALLE into CALLER based on target-specific info.
+   Make sure that the caller and callee have compatible architectural
+   features.  Then go through the other possible target attributes
+   and.  Try not to reject always_inline callees unless they are
+   incompatible architecturally.  */
+
+static bool
+aarch64_can_inline_p (tree caller, tree callee)
+{
+  bool ret = false;
+  tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
+  tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
+
+  /* If callee has no option attributes, then it is ok to inline.  */
+  if (!callee_tree)
+    ret = true;
+  else
+    {
+      struct cl_target_option *caller_opts
+	= TREE_TARGET_OPTION (caller_tree ? caller_tree
+					   : target_option_default_node);
+      struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
+
+
+      /* Callee's ISA flags should be a subset of the caller's.  */
+      if ((caller_opts->x_aarch64_isa_flags & callee_opts->x_aarch64_isa_flags)
+	  == callee_opts->x_aarch64_isa_flags)
+	ret = true;
+
+     /* Allow non-strict aligned functions inlining into strict
+        aligned ones.  */
+      if ((TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)
+	   != TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags))
+	  && !(!TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags)
+	       && TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)))
+	ret = false;
+
+      bool always_inline = lookup_attribute ("always_inline",
+					       DECL_ATTRIBUTES (callee));
+
+      /* If the architectural features match up and the callee is always_inline
+	  then the other attributes don't matter.  */
+      if (always_inline)
+	return ret;
+
+      if (caller_opts->x_aarch64_cmodel_var
+	  != callee_opts->x_aarch64_cmodel_var)
+	ret = false;
+
+      if (caller_opts->x_aarch64_tls_dialect
+	  != callee_opts->x_aarch64_tls_dialect)
+	ret = false;
+
+
+      /* Honour explicit requests to workaround errata.  */
+      if (aarch64_reject_inlining (caller_opts->x_aarch64_fix_a53_err835769,
+				    callee_opts->x_aarch64_fix_a53_err835769,
+				    2, TARGET_FIX_ERR_A53_835769_DEFAULT))
+	ret = false;
+
+      /* If the user explicitly specified -momit-leaf-frame-pointer for the
+         caller and calle and they don't match up, reject inlining.  */
+      if (aarch64_reject_inlining (caller_opts->x_flag_omit_leaf_frame_pointer,
+				   callee_opts->x_flag_omit_leaf_frame_pointer,
+				   2, 1))
+	ret = false;
+
+      /* If the callee has specific tuning overrides, respect them.  */
+      if (callee_opts->x_aarch64_override_tune_string != NULL
+	  && caller_opts->x_aarch64_override_tune_string == NULL)
+	ret = false;
+
+      /* If the user specified tuning override strings for the
+         caller and callee and they don't match up, reject inlining.
+         We just do a string compare here, we don't analyze the meaning
+         of the string, as it would be too costly for little gain.  */
+      if (callee_opts->x_aarch64_override_tune_string
+	  && caller_opts->x_aarch64_override_tune_string
+	  && (strcmp (callee_opts->x_aarch64_override_tune_string,
+		      caller_opts->x_aarch64_override_tune_string) != 0))
+	ret = false;
+    }
+
+  return ret;
+}
+
 /* Return true if SYMBOL_REF X binds locally.  */
 
 static bool
@@ -12963,6 +13070,9 @@ aarch64_unspec_may_trap_p (const_rtx x, unsigned flags)
 #undef TARGET_OPTION_VALID_ATTRIBUTE_P
 #define TARGET_OPTION_VALID_ATTRIBUTE_P aarch64_option_valid_attribute_p
 
+#undef TARGET_CAN_INLINE_P
+#define TARGET_CAN_INLINE_P aarch64_can_inline_p
+
 #undef TARGET_PASS_BY_REFERENCE
 #define TARGET_PASS_BY_REFERENCE aarch64_pass_by_reference
 

Re: [PATCH][AArch64][9/14] Implement TARGET_CAN_INLINE_P

[James Greenhalgh]

On Thu, Jul 16, 2015 at 04:21:02PM +0100, Kyrill Tkachov wrote:
> Hi all,
> 
> This patch implements the target-specific inlining rules.
> The basic philosophy is that we want to definitely reject inlining if the callee's architecture
> is not a subset, feature-wise, of the caller's.
> 
> Beyond that, we want to allow inlining if the callee is always_inline.
> If it's not, we reject inlining if the TargetSave options don't match up
> in a way that's described in the comments in the patch.
> 
> Generally, we try to allow as much inlining as possible for the benefit of LTO.
> However, if the architectural features of the callee are not a subset of the features
> of the caller, then we must reject inlining. For example, inlining a function with 'simd'
> into a function without 'simd' is not allowed.
> 
> Also, inlining a non-strict-align function into a strict-align function is not allowed.
> These two restrictions apply even when the callee is tagged with always_inline because they
> can affect the correctness of the program.
> 
> Beyond that, we reject inlining only if the user has explicitly specified attributes/options for
> both the caller and the callee and they don't match up.
> 
> An exception to that are the tuning CPUs. We want to allow inlining even when the tuning CPUs don't match.
> 
> Bootstrapped and tested on aarch64.
> 
> Ok for trunk?

Comments below.

> diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
> index 0a6ed70..34cd986 100644
> --- a/gcc/config/aarch64/aarch64.c
> +++ b/gcc/config/aarch64/aarch64.c
> @@ -8486,6 +8486,113 @@ aarch64_option_valid_attribute_p (tree fndecl, tree, tree args, int)
>    return ret;
>  }
>  
> +/* Helper for aarch64_can_inline_p.  In the case where CALLER and CALLEE are
> +   tri-bool options (yes, no, don't care) and the default value is
> +   DEF, determine whether to reject inlining.  */
> +
> +static bool
> +aarch64_reject_inlining (int caller, int callee, int dont_care, int def)
> +{
> +  /* If both caller and callee care about the value then reject inlining
> +     if they don't match up.  */
> +  if (caller != dont_care && callee != dont_care && caller != callee)
> +    return true;
> +
> +  /* If caller doesn't care then make sure that the default agrees
> +     with the callee.  */
> +  if (caller == dont_care && callee != dont_care && callee != def)
> +    return true;

I don't like boolean functions which return the negative of how they
will be used, so how about flipping the sense of this function to be
positive and cleaning up the logical cases to be more explicit:

  static bool
  aarch64_tribool_values_ok_for_inlining_p (int caller, int callee,
					    int dont_care, int def)
  {
    /* If the callee doesn't care, always allow inlining.  */
    if (callee == dont_care)
      return true;

    /* If the caller doesn't care, always allow inlining.  */
    if (caller == dont_care)
      return true;

    /* Otherwise, allow inlining if either the callee and caller values
       agree, or if the callee is using the default value.
    return (callee == caller || callee == def)
  }

> +/* Implement TARGET_CAN_INLINE_P.  Decide whether it is valid
> +   to inline CALLE into CALLER based on target-specific info.

s/CALLE/CALLEE/

> +   Make sure that the caller and callee have compatible architectural
> +   features.  Then go through the other possible target attributes
> +   and.  Try not to reject always_inline callees unless they are

Typo: and... what?

> +   incompatible architecturally.  */
> +
> +static bool
> +aarch64_can_inline_p (tree caller, tree callee)
> +{
> +  bool ret = false;
> +  tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
> +  tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
> +
> +  /* If callee has no option attributes, then it is ok to inline.  */
> +  if (!callee_tree)
> +    ret = true;

Just return true, drop the else and clean up the control flow, particularly
as the rest of the code below is going to fall through to each condition
in turn.

> +  else
> +    {
> +      struct cl_target_option *caller_opts
> +	= TREE_TARGET_OPTION (caller_tree ? caller_tree
> +					   : target_option_default_node);
> +      struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
> +
> +
> +      /* Callee's ISA flags should be a subset of the caller's.  */
> +      if ((caller_opts->x_aarch64_isa_flags & callee_opts->x_aarch64_isa_flags)
> +	  == callee_opts->x_aarch64_isa_flags)
> +	ret = true;

This is the only place that ret can become true. Why not switch the sense
of the comparison (!= callee_opts...) and simply return false here.

Then each of the cases below can just return false as they go and the
fallthrough case can return true.

That seems much more readable to me!

Thanks,
James


> +
> +     /* Allow non-strict aligned functions inlining into strict
> +        aligned ones.  */
> +      if ((TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)
> +	   != TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags))
> +	  && !(!TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags)
> +	       && TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)))
> +	ret = false;
> +
> +      bool always_inline = lookup_attribute ("always_inline",
> +					       DECL_ATTRIBUTES (callee));
> +
> +      /* If the architectural features match up and the callee is always_inline
> +	  then the other attributes don't matter.  */
> +      if (always_inline)
> +	return ret;
> +
> +      if (caller_opts->x_aarch64_cmodel_var
> +	  != callee_opts->x_aarch64_cmodel_var)
> +	ret = false;
> +
> +      if (caller_opts->x_aarch64_tls_dialect
> +	  != callee_opts->x_aarch64_tls_dialect)
> +	ret = false;
> +
> +
> +      /* Honour explicit requests to workaround errata.  */
> +      if (aarch64_reject_inlining (caller_opts->x_aarch64_fix_a53_err835769,
> +				    callee_opts->x_aarch64_fix_a53_err835769,
> +				    2, TARGET_FIX_ERR_A53_835769_DEFAULT))
> +	ret = false;
> +
> +      /* If the user explicitly specified -momit-leaf-frame-pointer for the
> +         caller and calle and they don't match up, reject inlining.  */
> +      if (aarch64_reject_inlining (caller_opts->x_flag_omit_leaf_frame_pointer,
> +				   callee_opts->x_flag_omit_leaf_frame_pointer,
> +				   2, 1))
> +	ret = false;
> +
> +      /* If the callee has specific tuning overrides, respect them.  */
> +      if (callee_opts->x_aarch64_override_tune_string != NULL
> +	  && caller_opts->x_aarch64_override_tune_string == NULL)
> +	ret = false;
> +
> +      /* If the user specified tuning override strings for the
> +         caller and callee and they don't match up, reject inlining.
> +         We just do a string compare here, we don't analyze the meaning
> +         of the string, as it would be too costly for little gain.  */
> +      if (callee_opts->x_aarch64_override_tune_string
> +	  && caller_opts->x_aarch64_override_tune_string
> +	  && (strcmp (callee_opts->x_aarch64_override_tune_string,
> +		      caller_opts->x_aarch64_override_tune_string) != 0))
> +	ret = false;
> +    }
> +
> +  return ret;
> +}
> +
>  /* Return true if SYMBOL_REF X binds locally.  */
>  
>  static bool
> @@ -12963,6 +13070,9 @@ aarch64_unspec_may_trap_p (const_rtx x, unsigned flags)
>  #undef TARGET_OPTION_VALID_ATTRIBUTE_P
>  #define TARGET_OPTION_VALID_ATTRIBUTE_P aarch64_option_valid_attribute_p
>  
> +#undef TARGET_CAN_INLINE_P
> +#define TARGET_CAN_INLINE_P aarch64_can_inline_p
> +
>  #undef TARGET_PASS_BY_REFERENCE
>  #define TARGET_PASS_BY_REFERENCE aarch64_pass_by_reference
>  

Re: [PATCH][AArch64][9/14] Implement TARGET_CAN_INLINE_P

[Kyrill Tkachov]

[-- Attachment #1: Type: text/plain, Size: 8404 bytes --]


On 21/07/15 17:07, James Greenhalgh wrote:
> On Thu, Jul 16, 2015 at 04:21:02PM +0100, Kyrill Tkachov wrote:
>> Hi all,
>>
>> This patch implements the target-specific inlining rules.
>> The basic philosophy is that we want to definitely reject inlining if the callee's architecture
>> is not a subset, feature-wise, of the caller's.
>>
>> Beyond that, we want to allow inlining if the callee is always_inline.
>> If it's not, we reject inlining if the TargetSave options don't match up
>> in a way that's described in the comments in the patch.
>>
>> Generally, we try to allow as much inlining as possible for the benefit of LTO.
>> However, if the architectural features of the callee are not a subset of the features
>> of the caller, then we must reject inlining. For example, inlining a function with 'simd'
>> into a function without 'simd' is not allowed.
>>
>> Also, inlining a non-strict-align function into a strict-align function is not allowed.
>> These two restrictions apply even when the callee is tagged with always_inline because they
>> can affect the correctness of the program.
>>
>> Beyond that, we reject inlining only if the user has explicitly specified attributes/options for
>> both the caller and the callee and they don't match up.
>>
>> An exception to that are the tuning CPUs. We want to allow inlining even when the tuning CPUs don't match.
>>
>> Bootstrapped and tested on aarch64.
>>
>> Ok for trunk?
> Comments below.
>
>> diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
>> index 0a6ed70..34cd986 100644
>> --- a/gcc/config/aarch64/aarch64.c
>> +++ b/gcc/config/aarch64/aarch64.c
>> @@ -8486,6 +8486,113 @@ aarch64_option_valid_attribute_p (tree fndecl, tree, tree args, int)
>>     return ret;
>>   }
>>   
>> +/* Helper for aarch64_can_inline_p.  In the case where CALLER and CALLEE are
>> +   tri-bool options (yes, no, don't care) and the default value is
>> +   DEF, determine whether to reject inlining.  */
>> +
>> +static bool
>> +aarch64_reject_inlining (int caller, int callee, int dont_care, int def)
>> +{
>> +  /* If both caller and callee care about the value then reject inlining
>> +     if they don't match up.  */
>> +  if (caller != dont_care && callee != dont_care && caller != callee)
>> +    return true;
>> +
>> +  /* If caller doesn't care then make sure that the default agrees
>> +     with the callee.  */
>> +  if (caller == dont_care && callee != dont_care && callee != def)
>> +    return true;
> I don't like boolean functions which return the negative of how they
> will be used, so how about flipping the sense of this function to be
> positive and cleaning up the logical cases to be more explicit:
>
>    static bool
>    aarch64_tribool_values_ok_for_inlining_p (int caller, int callee,
> 					    int dont_care, int def)
>    {
>      /* If the callee doesn't care, always allow inlining.  */
>      if (callee == dont_care)
>        return true;
>
>      /* If the caller doesn't care, always allow inlining.  */
>      if (caller == dont_care)
>        return true;
>
>      /* Otherwise, allow inlining if either the callee and caller values
>         agree, or if the callee is using the default value.
>      return (callee == caller || callee == def)
>    }
>
>> +/* Implement TARGET_CAN_INLINE_P.  Decide whether it is valid
>> +   to inline CALLE into CALLER based on target-specific info.
> s/CALLE/CALLEE/
>
>> +   Make sure that the caller and callee have compatible architectural
>> +   features.  Then go through the other possible target attributes
>> +   and.  Try not to reject always_inline callees unless they are
> Typo: and... what?
>
>> +   incompatible architecturally.  */
>> +
>> +static bool
>> +aarch64_can_inline_p (tree caller, tree callee)
>> +{
>> +  bool ret = false;
>> +  tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
>> +  tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
>> +
>> +  /* If callee has no option attributes, then it is ok to inline.  */
>> +  if (!callee_tree)
>> +    ret = true;
> Just return true, drop the else and clean up the control flow, particularly
> as the rest of the code below is going to fall through to each condition
> in turn.
>
>> +  else
>> +    {
>> +      struct cl_target_option *caller_opts
>> +	= TREE_TARGET_OPTION (caller_tree ? caller_tree
>> +					   : target_option_default_node);
>> +      struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
>> +
>> +
>> +      /* Callee's ISA flags should be a subset of the caller's.  */
>> +      if ((caller_opts->x_aarch64_isa_flags & callee_opts->x_aarch64_isa_flags)
>> +	  == callee_opts->x_aarch64_isa_flags)
>> +	ret = true;
> This is the only place that ret can become true. Why not switch the sense
> of the comparison (!= callee_opts...) and simply return false here.
>
> Then each of the cases below can just return false as they go and the
> fallthrough case can return true.
>
> That seems much more readable to me!

Thanks, I've implemented the suggestions.
Re-bootstrapped and tested on aarch64.
How's this?

Thanks,
Kyrill

2015-07-23  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>

     * config/aarch64/aarch64.c (aarch64_tribools_ok_for_inlining_p):
     New function.
     (aarch64_can_inline_p): Likewise.
     (TARGET_CAN_INLINE_P): Define.


>
> Thanks,
> James
>
>
>> +
>> +     /* Allow non-strict aligned functions inlining into strict
>> +        aligned ones.  */
>> +      if ((TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)
>> +	   != TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags))
>> +	  && !(!TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags)
>> +	       && TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)))
>> +	ret = false;
>> +
>> +      bool always_inline = lookup_attribute ("always_inline",
>> +					       DECL_ATTRIBUTES (callee));
>> +
>> +      /* If the architectural features match up and the callee is always_inline
>> +	  then the other attributes don't matter.  */
>> +      if (always_inline)
>> +	return ret;
>> +
>> +      if (caller_opts->x_aarch64_cmodel_var
>> +	  != callee_opts->x_aarch64_cmodel_var)
>> +	ret = false;
>> +
>> +      if (caller_opts->x_aarch64_tls_dialect
>> +	  != callee_opts->x_aarch64_tls_dialect)
>> +	ret = false;
>> +
>> +
>> +      /* Honour explicit requests to workaround errata.  */
>> +      if (aarch64_reject_inlining (caller_opts->x_aarch64_fix_a53_err835769,
>> +				    callee_opts->x_aarch64_fix_a53_err835769,
>> +				    2, TARGET_FIX_ERR_A53_835769_DEFAULT))
>> +	ret = false;
>> +
>> +      /* If the user explicitly specified -momit-leaf-frame-pointer for the
>> +         caller and calle and they don't match up, reject inlining.  */
>> +      if (aarch64_reject_inlining (caller_opts->x_flag_omit_leaf_frame_pointer,
>> +				   callee_opts->x_flag_omit_leaf_frame_pointer,
>> +				   2, 1))
>> +	ret = false;
>> +
>> +      /* If the callee has specific tuning overrides, respect them.  */
>> +      if (callee_opts->x_aarch64_override_tune_string != NULL
>> +	  && caller_opts->x_aarch64_override_tune_string == NULL)
>> +	ret = false;
>> +
>> +      /* If the user specified tuning override strings for the
>> +         caller and callee and they don't match up, reject inlining.
>> +         We just do a string compare here, we don't analyze the meaning
>> +         of the string, as it would be too costly for little gain.  */
>> +      if (callee_opts->x_aarch64_override_tune_string
>> +	  && caller_opts->x_aarch64_override_tune_string
>> +	  && (strcmp (callee_opts->x_aarch64_override_tune_string,
>> +		      caller_opts->x_aarch64_override_tune_string) != 0))
>> +	ret = false;
>> +    }
>> +
>> +  return ret;
>> +}
>> +
>>   /* Return true if SYMBOL_REF X binds locally.  */
>>   
>>   static bool
>> @@ -12963,6 +13070,9 @@ aarch64_unspec_may_trap_p (const_rtx x, unsigned flags)
>>   #undef TARGET_OPTION_VALID_ATTRIBUTE_P
>>   #define TARGET_OPTION_VALID_ATTRIBUTE_P aarch64_option_valid_attribute_p
>>   
>> +#undef TARGET_CAN_INLINE_P
>> +#define TARGET_CAN_INLINE_P aarch64_can_inline_p
>> +
>>   #undef TARGET_PASS_BY_REFERENCE
>>   #define TARGET_PASS_BY_REFERENCE aarch64_pass_by_reference
>>   


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: aarch64-attrs-9.patch --]
[-- Type: text/x-patch; name=aarch64-attrs-9.patch, Size: 5021 bytes --]

commit cc49230c0ed153759e6f617c6251d48f9a1814b2
Author: Kyrylo Tkachov <kyrylo.tkachov@arm.com>
Date:   Thu May 14 12:00:07 2015 +0100

    [AArch64][9/N] Implement TARGET_CAN_INLINE_P

diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index ba82ca9..ff584fe 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -8486,6 +8486,113 @@ aarch64_option_valid_attribute_p (tree fndecl, tree, tree args, int)
   return ret;
 }
 
+/* Helper for aarch64_can_inline_p.  In the case where CALLER and CALLEE are
+   tri-bool options (yes, no, don't care) and the default value is
+   DEF, determine whether to reject inlining.  */
+
+static bool
+aarch64_tribools_ok_for_inlining_p (int caller, int callee,
+				     int dont_care, int def)
+{
+  /* If the callee doesn't care, always allow inlining.  */
+  if (callee == dont_care)
+    return true;
+
+  /* If the caller doesn't care, always allow inlining.  */
+  if (caller == dont_care)
+    return true;
+
+  /* Otherwise, allow inlining if either the callee and caller values
+     agree, or if the callee is using the default value.  */
+  return (callee == caller || callee == def);
+}
+
+/* Implement TARGET_CAN_INLINE_P.  Decide whether it is valid
+   to inline CALLEE into CALLER based on target-specific info.
+   Make sure that the caller and callee have compatible architectural
+   features.  Then go through the other possible target attributes
+   and see if they can block inlining.  Try not to reject always_inline
+   callees unless they are incompatible architecturally.  */
+
+static bool
+aarch64_can_inline_p (tree caller, tree callee)
+{
+  tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
+  tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
+
+  /* If callee has no option attributes, then it is ok to inline.  */
+  if (!callee_tree)
+    return true;
+
+  struct cl_target_option *caller_opts
+	= TREE_TARGET_OPTION (caller_tree ? caller_tree
+					   : target_option_default_node);
+
+  struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
+
+
+  /* Callee's ISA flags should be a subset of the caller's.  */
+  if ((caller_opts->x_aarch64_isa_flags & callee_opts->x_aarch64_isa_flags)
+       != callee_opts->x_aarch64_isa_flags)
+    return false;
+
+  /* Allow non-strict aligned functions inlining into strict
+     aligned ones.  */
+  if ((TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)
+       != TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags))
+      && !(!TARGET_STRICT_ALIGN_P (callee_opts->x_target_flags)
+	   && TARGET_STRICT_ALIGN_P (caller_opts->x_target_flags)))
+    return false;
+
+  bool always_inline = lookup_attribute ("always_inline",
+					  DECL_ATTRIBUTES (callee));
+
+  /* If the architectural features match up and the callee is always_inline
+     then the other attributes don't matter.  */
+  if (always_inline)
+    return true;
+
+  if (caller_opts->x_aarch64_cmodel_var
+      != callee_opts->x_aarch64_cmodel_var)
+    return false;
+
+  if (caller_opts->x_aarch64_tls_dialect
+      != callee_opts->x_aarch64_tls_dialect)
+    return false;
+
+  /* Honour explicit requests to workaround errata.  */
+  if (!aarch64_tribools_ok_for_inlining_p (
+	  caller_opts->x_aarch64_fix_a53_err835769,
+	  callee_opts->x_aarch64_fix_a53_err835769,
+	  2, TARGET_FIX_ERR_A53_835769_DEFAULT))
+    return false;
+
+  /* If the user explicitly specified -momit-leaf-frame-pointer for the
+     caller and calle and they don't match up, reject inlining.  */
+  if (!aarch64_tribools_ok_for_inlining_p (
+	  caller_opts->x_flag_omit_leaf_frame_pointer,
+	  callee_opts->x_flag_omit_leaf_frame_pointer,
+	  2, 1))
+    return false;
+
+  /* If the callee has specific tuning overrides, respect them.  */
+  if (callee_opts->x_aarch64_override_tune_string != NULL
+      && caller_opts->x_aarch64_override_tune_string == NULL)
+    return false;
+
+  /* If the user specified tuning override strings for the
+     caller and callee and they don't match up, reject inlining.
+     We just do a string compare here, we don't analyze the meaning
+     of the string, as it would be too costly for little gain.  */
+  if (callee_opts->x_aarch64_override_tune_string
+      && caller_opts->x_aarch64_override_tune_string
+      && (strcmp (callee_opts->x_aarch64_override_tune_string,
+		  caller_opts->x_aarch64_override_tune_string) != 0))
+    return false;
+
+  return true;
+}
+
 /* Return true if SYMBOL_REF X binds locally.  */
 
 static bool
@@ -12850,6 +12957,9 @@ aarch64_unspec_may_trap_p (const_rtx x, unsigned flags)
 #undef TARGET_CAN_ELIMINATE
 #define TARGET_CAN_ELIMINATE aarch64_can_eliminate
 
+#undef TARGET_CAN_INLINE_P
+#define TARGET_CAN_INLINE_P aarch64_can_inline_p
+
 #undef TARGET_CANNOT_FORCE_CONST_MEM
 #define TARGET_CANNOT_FORCE_CONST_MEM aarch64_cannot_force_const_mem
 

Re: [PATCH][AArch64][9/14] Implement TARGET_CAN_INLINE_P

[James Greenhalgh]

On Thu, Jul 23, 2015 at 11:17:20AM +0100, Kyrill Tkachov wrote:
> Thanks, I've implemented the suggestions.
> Re-bootstrapped and tested on aarch64.
> How's this?

This is good. OK for trunk.

Thanks,
James