2014-01-21 Vladimir Makarov <vmakarov@redhat.com>

	PR rtl-optimization/59858
	* lra-constraints.c (SMALL_REGISTER_CLASS_P): Use
	ira_class_hard_regs_num.
	(process_alt_operands): Increase reject for dying matched operand.

2014-01-21  Vladimir Makarov  <vmakarov@redhat.com>

	PR rtl-optimization/59858
	* gcc.target/arm/pr59858.c: New.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@206897 138bc75d-0d04-0410-961f-82ee72b054a4

4 files changed, 197 insertions, 14 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 9efc19abde3..aea384ee69d 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,10 @@
+2014-01-21  Vladimir Makarov  <vmakarov@redhat.com>
+
+	PR rtl-optimization/59858
+	* lra-constraints.c (SMALL_REGISTER_CLASS_P): Use
+	ira_class_hard_regs_num.
+	(process_alt_operands): Increase reject for dying matched operand.
+
 2014-01-21  Jakub Jelinek  <jakub@redhat.com>
 
 	PR target/59003
diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c
index fd4a56a5735..7a2d065b55b 100644
--- a/gcc/lra-constraints.c
+++ b/gcc/lra-constraints.c
@@ -688,9 +688,10 @@ operands_match_p (rtx x, rtx y, int y_hard_regno)
 
 /* True if C is a non-empty register class that has too few registers
    to be safely used as a reload target class.	*/
-#define SMALL_REGISTER_CLASS_P(C)					\
-  (reg_class_size [(C)] == 1						\
-   || (reg_class_size [(C)] >= 1 && targetm.class_likely_spilled_p (C)))
+#define SMALL_REGISTER_CLASS_P(C)		\
+  (ira_class_hard_regs_num [(C)] == 1		\
+   || (ira_class_hard_regs_num [(C)] >= 1	\
+       && targetm.class_likely_spilled_p (C)))
 
 /* If REG is a reload pseudo, try to make its class satisfying CL.  */
 static void
@@ -2113,17 +2114,25 @@ process_alt_operands (int only_alternative)
 		}
 	      /* If the operand is dying, has a matching constraint,
 		 and satisfies constraints of the matched operand
-		 which failed to satisfy the own constraints, we do
-		 not need to generate a reload insn for this
-		 operand.  */
-	      if (!(this_alternative_matches >= 0
-		    && !curr_alt_win[this_alternative_matches]
-		    && REG_P (op)
-		    && find_regno_note (curr_insn, REG_DEAD, REGNO (op))
-		    && (hard_regno[nop] >= 0
-			? in_hard_reg_set_p (this_alternative_set,
-					     mode, hard_regno[nop])
-			: in_class_p (op, this_alternative, NULL))))
+		 which failed to satisfy the own constraints, probably
+		 the reload for this operand will be gone.  */
+	      if (this_alternative_matches >= 0
+		  && !curr_alt_win[this_alternative_matches]
+		  && REG_P (op)
+		  && find_regno_note (curr_insn, REG_DEAD, REGNO (op))
+		  && (hard_regno[nop] >= 0
+		      ? in_hard_reg_set_p (this_alternative_set,
+					   mode, hard_regno[nop])
+		      : in_class_p (op, this_alternative, NULL)))
+		{
+		  if (lra_dump_file != NULL)
+		    fprintf
+		      (lra_dump_file,
+		       "            %d Dying matched operand reload: reject++\n",
+		       nop);
+		  reject++;
+		}
+	      else
 		{
 		  /* Strict_low_part requires to reload the register
 		     not the sub-register.  In this case we should
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
index f7f6f88e26a..deae6511451 100644
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,8 @@
+2014-01-21  Vladimir Makarov  <vmakarov@redhat.com>
+
+	PR rtl-optimization/59858
+	* gcc.target/arm/pr59858.c: New.
+
 2014-01-21  Jakub Jelinek  <jakub@redhat.com>
 
 	PR target/59003
diff --git a/gcc/testsuite/gcc.target/arm/pr59858.c b/gcc/testsuite/gcc.target/arm/pr59858.c
new file mode 100644
index 00000000000..463bd38f715
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pr59858.c
@@ -0,0 +1,162 @@
+/* { dg-do compile } */
+/* { dg-options "-march=armv5te -marm -mthumb-interwork -Wall -Wstrict-prototypes -Wstrict-aliasing -funsigned-char -fno-builtin -fno-asm -msoft-float -std=gnu99 -mlittle-endian -mthumb -fno-stack-protector  -Os -g -feliminate-unused-debug-types -funit-at-a-time -fmerge-all-constants -fstrict-aliasing -fno-tree-loop-optimize -fno-tree-dominator-opts -fno-strength-reduce -fPIC -w" } */
+
+typedef enum {
+ REG_ENOSYS = -1,
+} reg_errcode_t;
+typedef unsigned long int bitset_word_t;
+typedef bitset_word_t bitset_t[(256 / (sizeof (bitset_word_t) * 8))];
+typedef bitset_word_t *re_bitset_ptr_t;
+typedef const bitset_word_t *re_const_bitset_ptr_t;
+typedef struct {
+ int nelem;
+ int *elems;
+} re_node_set;
+typedef enum {
+ CHARACTER = 1,
+} re_token_type_t;
+typedef struct {
+ re_token_type_t type:8;
+ unsigned int word_char:1;
+} re_token_t;
+struct re_string_t {
+ const unsigned char *raw_mbs;
+ int raw_mbs_idx;
+ int cur_idx;
+ unsigned int tip_context;
+ re_const_bitset_ptr_t word_char;
+};
+typedef struct re_string_t re_string_t;
+typedef struct re_dfa_t re_dfa_t;
+struct re_dfastate_t {
+ re_node_set nodes;
+};
+typedef struct re_dfastate_t re_dfastate_t;
+typedef struct {
+ re_dfastate_t **array;
+} state_array_t;
+typedef struct {
+ state_array_t path;
+} re_sub_match_last_t;
+typedef struct {
+ int nlasts;
+ re_sub_match_last_t **lasts;
+} re_sub_match_top_t;
+typedef struct {
+ re_string_t input;
+ const re_dfa_t *dfa;
+ int nsub_tops;
+ re_sub_match_top_t **sub_tops;
+} re_match_context_t;
+struct re_dfa_t {
+ re_token_t *nodes;
+ re_bitset_ptr_t sb_char;
+ int mb_cur_max;
+ bitset_t word_char;
+} bracket_elem_t;
+static reg_errcode_t
+re_string_reconstruct (
+ re_string_t * pstr,
+ int idx,
+ int eflags
+)
+{
+ int offset = idx - pstr->raw_mbs_idx;
+ int c = pstr->raw_mbs[pstr->raw_mbs_idx + offset - 1];
+ pstr->tip_context = ((pstr->word_char[c] & ((bitset_word_t) 1)) ? : (c));
+}
+
+static void match_ctx_clean (
+ re_match_context_t *
+);
+static int check_matching (
+);
+static re_dfastate_t *transit_state (
+);
+static int build_trtable (
+);
+re_search_internal (int eflags
+)
+{
+ reg_errcode_t err;
+ int incr;
+ int
+  match_first,
+  match_last = -1;
+ re_match_context_t mctx;
+ err = re_string_allocate (&mctx.input);
+ for (;; match_first += incr)
+  {
+   err = re_string_reconstruct (&mctx.input, match_first, eflags);
+   err = re_string_reconstruct (&mctx.input, match_first, eflags);
+   match_last = check_matching (&mctx, &match_first);
+   match_ctx_clean (&mctx);
+  }
+}
+
+check_matching (re_match_context_t * mctx, int *p_match_first
+)
+{
+ int cur_str_idx = ((&mctx->input)->cur_idx);
+ re_dfastate_t *cur_state;
+ int next_start_idx = cur_str_idx;
+ cur_state = transit_state (mctx, cur_state);
+ *p_match_first += next_start_idx;
+}
+
+static re_dfastate_t *
+transit_state (
+ re_match_context_t * mctx,
+ re_dfastate_t * state
+)
+{
+ if (!build_trtable (mctx->dfa, state))
+  {
+  }
+}
+
+build_trtable (const re_dfa_t * dfa,
+	             re_dfastate_t * state
+)
+{
+ int i,
+  j;
+ bitset_t accepts;
+ const re_node_set *cur_nodes = &state->nodes;
+ for (i = 0; i < cur_nodes->nelem; ++i)
+  {
+   re_token_t *node = &dfa->nodes[cur_nodes->elems[i]];
+   re_token_type_t type = node->type;
+   {
+    if (dfa->mb_cur_max > 1)
+     bitset_merge (accepts, dfa->sb_char);
+    {
+     bitset_word_t any_set = 0;
+     if (type == CHARACTER && !node->word_char)
+      any_set |= (accepts[j] &= (dfa->word_char[j] | ~dfa->sb_char[j]));
+     else
+      for (j = 0; j < (256 / (sizeof (bitset_word_t) * 8)); ++j)
+       any_set |= (accepts[j] &= dfa->word_char[j]);
+    }
+   }
+  }
+}
+
+static void
+match_ctx_clean (
+ re_match_context_t * mctx
+)
+{
+ int st_idx;
+ for (st_idx = 0; st_idx < mctx->nsub_tops; ++st_idx)
+  {
+   int sl_idx;
+   re_sub_match_top_t *top = mctx->sub_tops[st_idx];
+   for (sl_idx = 0; sl_idx < top->nlasts; ++sl_idx)
+    {
+     re_sub_match_last_t *last = top->lasts[sl_idx];
+     free (last->path.array);
+    }
+  }
+}
+