[RFC, tentative patch] Adjust cost for conversion expression

[Pitchumani Sivanupandi]

GCC inlines small functions if the code size after expansion is not 
excedded.
For test case (inline.c, avr-gcc -Os -S inline.c) code size become higher if
'func2' is inlined. It happens because the CONVERT_EXPR/ NOP_EXPR are 
considered
as zero cost expression.
Few conversions will cost additional instructions. For targets like AVR
it will cost considerably as it's register size is just one byte.

Attached the tentative patch that changes the CONVERT_EXPR/ NOP_EXPR cost
to 1 if the LHS is bigger than RHS and target's word_mode.

Is this Ok?

Would it be reasonable if cost evaluated as below instead of constant 1?
  if (LHS PRECISION > RHS PRECISION)
    cost = LHS_PRECISION / word_mode - 1
  else
    cost = 0

Built GCC for native with bootstrap enabled. No issues.

Regards,
Pitchumani

typedef unsigned int uint16_t __attribute__((__mode__(__HI__)));
typedef unsigned int uint32_t __attribute__ ((__mode__ (__SI__)));
char c = 12;
volatile long l = 1;
volatile uint32_t (*p)();

static uint16_t bar ()
{
  return c;
}

static uint32_t foo ()
{
  return ((uint32_t)bar() << 16 | bar());
}

__attribute__((noinline))
void func2 (uint32_t(*ptr)())
{
  p = ptr();
  l = foo();
}

void main ()
{
  func2(foo);
}

diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c
index 6899d2a..dbb305d 100644
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -3867,19 +3867,28 @@ estimate_move_cost (tree type, bool ARG_UNUSED (speed_p))
 
 static int
 estimate_operator_cost (enum tree_code code, eni_weights *weights,
-			tree op1 ATTRIBUTE_UNUSED, tree op2)
+			tree op1, tree op2)
 {
+  unsigned int lhs_prec, rhs_prec;
   switch (code)
     {
     /* These are "free" conversions, or their presumed cost
        is folded into other operations.  */
     case RANGE_EXPR:
-    CASE_CONVERT:
     case COMPLEX_EXPR:
     case PAREN_EXPR:
     case VIEW_CONVERT_EXPR:
       return 0;
-
+    CASE_CONVERT:
+    {
+      if (op1 && op2) {
+        lhs_prec = element_precision (TREE_TYPE (op1));
+        rhs_prec = element_precision (TREE_TYPE (op2));
+        if ((lhs_prec > rhs_prec) && (lhs_prec > word_mode))
+          return 1;
+      }
+      return 0;
+    }
     /* Assign cost of 1 to usual operations.
        ??? We may consider mapping RTL costs to this.  */
     case COND_EXPR:
@@ -4026,6 +4035,7 @@ estimate_num_insns (gimple *stmt, eni_weights *weights)
 {
   unsigned cost, i;
   enum gimple_code code = gimple_code (stmt);
+  enum tree_code rhs_code;
   tree lhs;
   tree rhs;
 
@@ -4064,9 +4074,17 @@ estimate_num_insns (gimple *stmt, eni_weights *weights)
       if (gimple_assign_load_p (stmt))
 	cost += estimate_move_cost (TREE_TYPE (rhs), weights->time_based);
 
-      cost += estimate_operator_cost (gimple_assign_rhs_code (stmt), weights,
+      rhs_code = gimple_assign_rhs_code (stmt);
+      if ((rhs_code == NOP_EXPR) || (rhs_code == CONVERT_EXPR))
+      {
+        cost += estimate_operator_cost (rhs_code, weights,
+                     gimple_assign_lhs (stmt),
+                     gimple_assign_rhs1 (stmt));
+      }
+      else
+        cost += estimate_operator_cost (rhs_code, weights,
       				      gimple_assign_rhs1 (stmt),
-				      get_gimple_rhs_class (gimple_assign_rhs_code (stmt))
+				      get_gimple_rhs_class (rhs_code)
 				      == GIMPLE_BINARY_RHS
 				      ? gimple_assign_rhs2 (stmt) : NULL);
       break;