[PATCH][mem-ref2] Fixup matrix-reorg

Richard Guenther rguenther@suse.de
Mon Jun 7 12:30:00 GMT 2010


Ugh.  Well - at least all fails are gone now.

matrix.exp-tested on x86_64-unknown-linux-gnu, applied to the branch.

Richard.

2010-06-07  Richard Guenther  <rguenther@suse.de>

	* matrix-reorg.c (may_flatten_matrices_1): Sanitize.
	(ssa_accessed_in_tree): Handle MEM_REF.
	(ssa_accessed_in_assign_rhs): Likewise.
	(update_type_size): Likewise.
	(analyze_accesses_for_call_stmt): Likewise.
	(analyze_accesses_for_assign_stmt): Likewise.
	(transform_access_sites): Likewise.
	(transform_allocation_sites): Likewise.

Index: gcc/matrix-reorg.c
===================================================================
*** gcc/matrix-reorg.c	(revision 160359)
--- gcc/matrix-reorg.c	(working copy)
*************** collect_data_for_malloc_call (gimple stm
*** 218,224 ****
     initial address and index of each dimension.  */
  struct access_site_info
  {
!   /* The statement (INDIRECT_REF or POINTER_PLUS_EXPR).  */
    gimple stmt;
  
    /* In case of POINTER_PLUS_EXPR, what is the offset.  */
--- 218,224 ----
     initial address and index of each dimension.  */
  struct access_site_info
  {
!   /* The statement (MEM_REF or POINTER_PLUS_EXPR).  */
    gimple stmt;
  
    /* In case of POINTER_PLUS_EXPR, what is the offset.  */
*************** struct ssa_acc_in_tree
*** 334,340 ****
    /* The variable whose accesses in the tree we are looking for.  */
    tree ssa_var;
    /* The tree and code inside it the ssa_var is accessed, currently
!      it could be an INDIRECT_REF or CALL_EXPR.  */
    enum tree_code t_code;
    tree t_tree;
    /* The place in the containing tree.  */
--- 334,340 ----
    /* The variable whose accesses in the tree we are looking for.  */
    tree ssa_var;
    /* The tree and code inside it the ssa_var is accessed, currently
!      it could be an MEM_REF or CALL_EXPR.  */
    enum tree_code t_code;
    tree t_tree;
    /* The place in the containing tree.  */
*************** mtt_info_eq (const void *mtt1, const voi
*** 413,445 ****
  static bool
  may_flatten_matrices_1 (gimple stmt)
  {
-   tree t;
- 
    switch (gimple_code (stmt))
      {
      case GIMPLE_ASSIGN:
!       if (!gimple_assign_cast_p (stmt))
  	return true;
! 
!       t = gimple_assign_rhs1 (stmt);
!       while (CONVERT_EXPR_P (t))
  	{
! 	  if (TREE_TYPE (t) && POINTER_TYPE_P (TREE_TYPE (t)))
! 	    {
! 	      tree pointee;
! 
! 	      pointee = TREE_TYPE (t);
! 	      while (POINTER_TYPE_P (pointee))
! 		pointee = TREE_TYPE (pointee);
! 	      if (TREE_CODE (pointee) == VECTOR_TYPE)
! 		{
! 		  if (dump_file)
! 		    fprintf (dump_file,
! 			     "Found vector type, don't flatten matrix\n");
! 		  return false;
! 		}
! 	    }
! 	  t = TREE_OPERAND (t, 0);
  	}
        break;
      case GIMPLE_ASM:
--- 413,430 ----
  static bool
  may_flatten_matrices_1 (gimple stmt)
  {
    switch (gimple_code (stmt))
      {
      case GIMPLE_ASSIGN:
!     case GIMPLE_CALL:
!       if (!gimple_has_lhs (stmt))
  	return true;
!       if (TREE_CODE (TREE_TYPE (gimple_get_lhs (stmt))) == VECTOR_TYPE)
  	{
! 	  if (dump_file)
! 	    fprintf (dump_file,
! 		     "Found vector type, don't flatten matrix\n");
! 	  return false;
  	}
        break;
      case GIMPLE_ASM:
*************** mark_min_matrix_escape_level (struct mat
*** 602,608 ****
  /* Find if the SSA variable is accessed inside the
     tree and record the tree containing it.
     The only relevant uses are the case of SSA_NAME, or SSA inside
!    INDIRECT_REF, PLUS_EXPR, POINTER_PLUS_EXPR, MULT_EXPR.  */
  static void
  ssa_accessed_in_tree (tree t, struct ssa_acc_in_tree *a)
  {
--- 587,593 ----
  /* Find if the SSA variable is accessed inside the
     tree and record the tree containing it.
     The only relevant uses are the case of SSA_NAME, or SSA inside
!    MEM_REF, PLUS_EXPR, POINTER_PLUS_EXPR, MULT_EXPR.  */
  static void
  ssa_accessed_in_tree (tree t, struct ssa_acc_in_tree *a)
  {
*************** ssa_accessed_in_tree (tree t, struct ssa
*** 613,619 ****
        if (t == a->ssa_var)
  	a->var_found = true;
        break;
!     case INDIRECT_REF:
        if (SSA_VAR_P (TREE_OPERAND (t, 0))
  	  && TREE_OPERAND (t, 0) == a->ssa_var)
  	a->var_found = true;
--- 598,604 ----
        if (t == a->ssa_var)
  	a->var_found = true;
        break;
!     case MEM_REF:
        if (SSA_VAR_P (TREE_OPERAND (t, 0))
  	  && TREE_OPERAND (t, 0) == a->ssa_var)
  	a->var_found = true;
*************** ssa_accessed_in_assign_rhs (gimple stmt,
*** 660,666 ****
        tree op1, op2;
  
      case SSA_NAME:
!     case INDIRECT_REF:
      CASE_CONVERT:
      case VIEW_CONVERT_EXPR:
        ssa_accessed_in_tree (gimple_assign_rhs1 (stmt), a);
--- 645,651 ----
        tree op1, op2;
  
      case SSA_NAME:
!     case MEM_REF:
      CASE_CONVERT:
      case VIEW_CONVERT_EXPR:
        ssa_accessed_in_tree (gimple_assign_rhs1 (stmt), a);
*************** get_index_from_offset (tree offset, gimp
*** 984,990 ****
  
  /* update MI->dimension_type_size[CURRENT_INDIRECT_LEVEL] with the size
     of the type related to the SSA_VAR, or the type related to the
!    lhs of STMT, in the case that it is an INDIRECT_REF.  */
  static void
  update_type_size (struct matrix_info *mi, gimple stmt, tree ssa_var,
  		  int current_indirect_level)
--- 969,975 ----
  
  /* update MI->dimension_type_size[CURRENT_INDIRECT_LEVEL] with the size
     of the type related to the SSA_VAR, or the type related to the
!    lhs of STMT, in the case that it is an MEM_REF.  */
  static void
  update_type_size (struct matrix_info *mi, gimple stmt, tree ssa_var,
  		  int current_indirect_level)
*************** update_type_size (struct matrix_info *mi
*** 992,1000 ****
    tree lhs;
    HOST_WIDE_INT type_size;
  
!   /* Update type according to the type of the INDIRECT_REF expr.   */
    if (is_gimple_assign (stmt)
!       && TREE_CODE (gimple_assign_lhs (stmt)) == INDIRECT_REF)
      {
        lhs = gimple_assign_lhs (stmt);
        gcc_assert (POINTER_TYPE_P
--- 977,985 ----
    tree lhs;
    HOST_WIDE_INT type_size;
  
!   /* Update type according to the type of the MEM_REF expr.   */
    if (is_gimple_assign (stmt)
!       && TREE_CODE (gimple_assign_lhs (stmt)) == MEM_REF)
      {
        lhs = gimple_assign_lhs (stmt);
        gcc_assert (POINTER_TYPE_P
*************** analyze_accesses_for_call_stmt (struct m
*** 1073,1079 ****
  	 at this level because in this case we cannot calculate the
  	 address correctly.  */
        if ((lhs_acc.var_found && rhs_acc.var_found
! 	   && lhs_acc.t_code == INDIRECT_REF)
  	  || (!rhs_acc.var_found && !lhs_acc.var_found))
  	{
  	  mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
--- 1058,1064 ----
  	 at this level because in this case we cannot calculate the
  	 address correctly.  */
        if ((lhs_acc.var_found && rhs_acc.var_found
! 	   && lhs_acc.t_code == MEM_REF)
  	  || (!rhs_acc.var_found && !lhs_acc.var_found))
  	{
  	  mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
*************** analyze_accesses_for_call_stmt (struct m
*** 1087,1093 ****
  	{
  	  int l = current_indirect_level + 1;
  
! 	  gcc_assert (lhs_acc.t_code == INDIRECT_REF);
  	  mark_min_matrix_escape_level (mi, l, use_stmt);
  	  return current_indirect_level;
  	}
--- 1072,1078 ----
  	{
  	  int l = current_indirect_level + 1;
  
! 	  gcc_assert (lhs_acc.t_code == MEM_REF);
  	  mark_min_matrix_escape_level (mi, l, use_stmt);
  	  return current_indirect_level;
  	}
*************** analyze_accesses_for_assign_stmt (struct
*** 1213,1219 ****
       at this level because in this case we cannot calculate the
       address correctly.  */
    if ((lhs_acc.var_found && rhs_acc.var_found
!        && lhs_acc.t_code == INDIRECT_REF)
        || (!rhs_acc.var_found && !lhs_acc.var_found))
      {
        mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
--- 1198,1204 ----
       at this level because in this case we cannot calculate the
       address correctly.  */
    if ((lhs_acc.var_found && rhs_acc.var_found
!        && lhs_acc.t_code == MEM_REF)
        || (!rhs_acc.var_found && !lhs_acc.var_found))
      {
        mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
*************** analyze_accesses_for_assign_stmt (struct
*** 1227,1233 ****
      {
        int l = current_indirect_level + 1;
  
!       gcc_assert (lhs_acc.t_code == INDIRECT_REF);
  
        if (!(gimple_assign_copy_p (use_stmt)
  	    || gimple_assign_cast_p (use_stmt))
--- 1212,1218 ----
      {
        int l = current_indirect_level + 1;
  
!       gcc_assert (lhs_acc.t_code == MEM_REF);
  
        if (!(gimple_assign_copy_p (use_stmt)
  	    || gimple_assign_cast_p (use_stmt))
*************** analyze_accesses_for_assign_stmt (struct
*** 1248,1254 ****
       is used.  */
    if (rhs_acc.var_found)
      {
!       if (rhs_acc.t_code != INDIRECT_REF
  	  && rhs_acc.t_code != POINTER_PLUS_EXPR && rhs_acc.t_code != SSA_NAME)
  	{
  	  mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
--- 1233,1239 ----
       is used.  */
    if (rhs_acc.var_found)
      {
!       if (rhs_acc.t_code != MEM_REF
  	  && rhs_acc.t_code != POINTER_PLUS_EXPR && rhs_acc.t_code != SSA_NAME)
  	{
  	  mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
*************** analyze_accesses_for_assign_stmt (struct
*** 1256,1262 ****
  	}
        /* If the access in the RHS has an indirection increase the
           indirection level.  */
!       if (rhs_acc.t_code == INDIRECT_REF)
  	{
  	  if (record_accesses)
  	    record_access_alloc_site_info (mi, use_stmt, NULL_TREE,
--- 1241,1247 ----
  	}
        /* If the access in the RHS has an indirection increase the
           indirection level.  */
!       if (rhs_acc.t_code == MEM_REF)
  	{
  	  if (record_accesses)
  	    record_access_alloc_site_info (mi, use_stmt, NULL_TREE,
*************** analyze_accesses_for_assign_stmt (struct
*** 1309,1315 ****
  	}
        /* If we are storing this level of indirection mark it as
           escaping.  */
!       if (lhs_acc.t_code == INDIRECT_REF || TREE_CODE (lhs) != SSA_NAME)
  	{
  	  int l = current_indirect_level;
  
--- 1294,1300 ----
  	}
        /* If we are storing this level of indirection mark it as
           escaping.  */
!       if (lhs_acc.t_code == MEM_REF || TREE_CODE (lhs) != SSA_NAME)
  	{
  	  int l = current_indirect_level;
  
*************** analyze_matrix_accesses (struct matrix_i
*** 1369,1376 ****
      return;
  
  /* Now go over the uses of the SSA_NAME and check how it is used in
!    each one of them.  We are mainly looking for the pattern INDIRECT_REF,
!    then a POINTER_PLUS_EXPR, then INDIRECT_REF etc.  while in between there could
     be any number of copies and casts.  */
    gcc_assert (TREE_CODE (ssa_var) == SSA_NAME);
  
--- 1354,1361 ----
      return;
  
  /* Now go over the uses of the SSA_NAME and check how it is used in
!    each one of them.  We are mainly looking for the pattern MEM_REF,
!    then a POINTER_PLUS_EXPR, then MEM_REF etc.  while in between there could
     be any number of copies and casts.  */
    gcc_assert (TREE_CODE (ssa_var) == SSA_NAME);
  
*************** transform_access_sites (void **slot, voi
*** 1856,1862 ****
  		    gimple new_stmt;
  
  		    gcc_assert (gimple_assign_rhs_code (acc_info->stmt)
! 				== INDIRECT_REF);
  		    /* Emit convert statement to convert to type of use.  */
  		    tmp = create_tmp_var (TREE_TYPE (lhs), "new");
  		    add_referenced_var (tmp);
--- 1841,1847 ----
  		    gimple new_stmt;
  
  		    gcc_assert (gimple_assign_rhs_code (acc_info->stmt)
! 				== MEM_REF);
  		    /* Emit convert statement to convert to type of use.  */
  		    tmp = create_tmp_var (TREE_TYPE (lhs), "new");
  		    add_referenced_var (tmp);
*************** transform_access_sites (void **slot, voi
*** 1878,1887 ****
  	  continue;
  	}
        code = gimple_assign_rhs_code (acc_info->stmt);
!       if (code == INDIRECT_REF
  	  && acc_info->level < min_escape_l - 1)
  	{
! 	  /* Replace the INDIRECT_REF with NOP (cast) usually we are casting
  	     from "pointer to type" to "type".  */
  	  tree t =
  	    build1 (NOP_EXPR, TREE_TYPE (gimple_assign_rhs1 (acc_info->stmt)),
--- 1863,1872 ----
  	  continue;
  	}
        code = gimple_assign_rhs_code (acc_info->stmt);
!       if (code == MEM_REF
  	  && acc_info->level < min_escape_l - 1)
  	{
! 	  /* Replace the MEM_REF with NOP (cast) usually we are casting
  	     from "pointer to type" to "type".  */
  	  tree t =
  	    build1 (NOP_EXPR, TREE_TYPE (gimple_assign_rhs1 (acc_info->stmt)),
*************** transform_allocation_sites (void **slot,
*** 2216,2232 ****
        gsi = gsi_for_stmt (call_stmt);
        /* Remove the call stmt.  */
        gsi_remove (&gsi, true);
-       /* remove the type cast stmt.  */
-       FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter,
- 			     gimple_call_lhs (call_stmt))
-       {
- 	use_stmt1 = use_stmt;
- 	gsi = gsi_for_stmt (use_stmt);
- 	gsi_remove (&gsi, true);
-       }
        /* Remove the assignment of the allocated area.  */
        FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter,
! 			     gimple_get_lhs (use_stmt1))
        {
  	gsi = gsi_for_stmt (use_stmt);
  	gsi_remove (&gsi, true);
--- 2201,2209 ----
        gsi = gsi_for_stmt (call_stmt);
        /* Remove the call stmt.  */
        gsi_remove (&gsi, true);
        /* Remove the assignment of the allocated area.  */
        FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter,
! 			     gimple_call_lhs (call_stmt))
        {
  	gsi = gsi_for_stmt (use_stmt);
  	gsi_remove (&gsi, true);



More information about the Gcc-patches mailing list