Plug loophole in string store merging

There is a loophole in new string store merging support added recently:
it does not check that the stores are consecutive, which is obviously
required if you want to concatenate them...  Simple fix attached, the
nice thing being that it can fall back to the regular processing if
any hole is detected in the series of stores, thanks to the handling
of STRING_CST by native_encode_expr.

gcc/ChangeLog:
	* gimple-ssa-store-merging.c (struct merged_store_group): Add
	new 'consecutive' field.
	(merged_store_group): Set it to true.
	(do_merge): Set it to false if the store is not consecutive and
	set string_concatenation to false in this case.
	(merge_into): Call do_merge on entry.
	(merge_overlapping): Likewise.

gcc/testsuite/ChangeLog:
	* gnat.dg/opt90a.adb: New test.
	* gnat.dg/opt90b.adb: Likewise.
	* gnat.dg/opt90c.adb: Likewise.
	* gnat.dg/opt90d.adb: Likewise.
	* gnat.dg/opt90e.adb: Likewise.
	* gnat.dg/opt90a_pkg.ads: New helper.
	* gnat.dg/opt90b_pkg.ads: Likewise.
	* gnat.dg/opt90c_pkg.ads: Likewise.
	* gnat.dg/opt90d_pkg.ads: Likewise.
	* gnat.dg/opt90e_pkg.ads: Likewise.

gcc/gimple-ssa-store-merging.c

@@ -1450,6 +1450,7 @@ public:
   bool bit_insertion;
   bool string_concatenation;
   bool only_constants;
+  bool consecutive;
   unsigned int first_nonmergeable_order;
   int lp_nr;
 
@@ -1822,6 +1823,7 @@ merged_store_group::merged_store_group (store_immediate_info *info)
   bit_insertion = info->rhs_code == BIT_INSERT_EXPR;
   string_concatenation = info->rhs_code == STRING_CST;
   only_constants = info->rhs_code == INTEGER_CST;
+  consecutive = true;
   first_nonmergeable_order = ~0U;
   lp_nr = info->lp_nr;
   unsigned HOST_WIDE_INT align_bitpos = 0;
@@ -1957,6 +1959,9 @@ merged_store_group::do_merge (store_immediate_info *info)
       first_stmt = stmt;
     }
 
+  if (info->bitpos != start + width)
+    consecutive = false;
+
   /* We need to use extraction if there is any bit-field.  */
   if (info->rhs_code == BIT_INSERT_EXPR)
     {
@@ -1964,13 +1969,17 @@ merged_store_group::do_merge (store_immediate_info *info)
       gcc_assert (!string_concatenation);
     }
 
-  /* We need to use concatenation if there is any string.  */
+  /* We want to use concatenation if there is any string.  */
   if (info->rhs_code == STRING_CST)
     {
       string_concatenation = true;
       gcc_assert (!bit_insertion);
     }
 
+  /* But we cannot use it if we don't have consecutive stores.  */
+  if (!consecutive)
+    string_concatenation = false;
+
   if (info->rhs_code != INTEGER_CST)
     only_constants = false;
 }
@@ -1982,12 +1991,13 @@ merged_store_group::do_merge (store_immediate_info *info)
 void
 merged_store_group::merge_into (store_immediate_info *info)
 {
+  do_merge (info);
+
   /* Make sure we're inserting in the position we think we're inserting.  */
   gcc_assert (info->bitpos >= start + width
 	      && info->bitregion_start <= bitregion_end);
 
   width = info->bitpos + info->bitsize - start;
-  do_merge (info);
 }
 
 /* Merge a store described by INFO into this merged store.
@@ -1997,11 +2007,11 @@ merged_store_group::merge_into (store_immediate_info *info)
 void
 merged_store_group::merge_overlapping (store_immediate_info *info)
 {
+  do_merge (info);
+
   /* If the store extends the size of the group, extend the width.  */
   if (info->bitpos + info->bitsize > start + width)
     width = info->bitpos + info->bitsize - start;
-
-  do_merge (info);
 }
 
 /* Go through all the recorded stores in this group in program order and

gcc/testsuite/gnat.dg/opt90a.adb

@@ -0,0 +1,16 @@
+-- { dg-do run }
+-- { dg-options "-O2" }
+
+with Ada.Calendar; use Ada.Calendar;
+with Opt90a_Pkg; use Opt90a_Pkg;
+
+procedure Opt90a is
+  B : constant Integer := Year (Clock);
+  V : Data;
+
+begin
+  V := (R => (A => 0, B => B, C => "000000000000"));
+  if V.R.B /= B then
+    raise Program_Error;
+  end if;
+end;

gcc/testsuite/gnat.dg/opt90a_pkg.ads

@@ -0,0 +1,15 @@
+package Opt90a_Pkg is
+
+  type Rec is record
+    A : Short_Short_Integer;
+    B : Integer;
+    C : String (1 .. 12);
+  end record;
+  pragma Pack (Rec);
+  for Rec'Alignment use 1;
+
+  type Data is tagged record
+    R : Rec;
+  end record;
+
+end Opt90a_Pkg;

gcc/testsuite/gnat.dg/opt90b.adb

@@ -0,0 +1,16 @@
+-- { dg-do run }
+-- { dg-options "-O2" }
+
+with Ada.Calendar; use Ada.Calendar;
+with Opt90b_Pkg; use Opt90b_Pkg;
+
+procedure Opt90b is
+  B : constant Integer := Year (Clock);
+  V : Data;
+
+begin
+  V := (R => (A => 0, B => B, C => 0, D => "000000000000"));
+  if V.R.B /= B then
+    raise Program_Error;
+  end if;
+end;

gcc/testsuite/gnat.dg/opt90b_pkg.ads

@@ -0,0 +1,16 @@
+package Opt90b_Pkg is
+
+  type Rec is record
+    A : Short_Short_Integer;
+    B : Integer;
+    C : Short_Integer;
+    D : String (1 .. 12);
+  end record;
+  pragma Pack (Rec);
+  for Rec'Alignment use 1;
+
+  type Data is tagged record
+    R : Rec;
+  end record;
+
+end Opt90b_Pkg;

gcc/testsuite/gnat.dg/opt90c.adb

@@ -0,0 +1,16 @@
+-- { dg-do run }
+-- { dg-options "-O2" }
+
+with Ada.Calendar; use Ada.Calendar;
+with Opt90c_Pkg; use Opt90c_Pkg;
+
+procedure Opt90c is
+  B : constant Integer := Year (Clock);
+  V : Data;
+
+begin
+  V := (R => (A => 0, B => B, C => 0, D => "000000000000"));
+  if V.R.B /= B then
+    raise Program_Error;
+  end if;
+end;

gcc/testsuite/gnat.dg/opt90c_pkg.ads

@@ -0,0 +1,16 @@
+package Opt90c_Pkg is
+
+  type Rec is record
+    D : String (1 .. 12);
+    B : Integer;
+    A : Short_Short_Integer;
+    C : Short_Integer;
+  end record;
+  pragma Pack (Rec);
+  for Rec'Alignment use 1;
+
+  type Data is tagged record
+    R : Rec;
+  end record;
+
+end Opt90c_Pkg;

gcc/testsuite/gnat.dg/opt90d.adb

@@ -0,0 +1,16 @@
+-- { dg-do run }
+-- { dg-options "-O2" }
+
+with Ada.Calendar; use Ada.Calendar;
+with Opt90d_Pkg; use Opt90d_Pkg;
+
+procedure Opt90d is
+  B : constant Integer := Year (Clock);
+  V : Data;
+
+begin
+  V := (R => (A => 0, B => B, C => 0, D => "000000000000"));
+  if V.R.B /= B then
+    raise Program_Error;
+  end if;
+end;

gcc/testsuite/gnat.dg/opt90d_pkg.ads

@@ -0,0 +1,16 @@
+package Opt90d_Pkg is
+
+  type Rec is record
+    D : String (1 .. 12);
+    C : Short_Integer;
+    A : Short_Short_Integer;
+    B : Integer;
+  end record;
+  pragma Pack (Rec);
+  for Rec'Alignment use 1;
+
+  type Data is tagged record
+    R : Rec;
+  end record;
+
+end Opt90d_Pkg;

gcc/testsuite/gnat.dg/opt90e.adb

@@ -0,0 +1,16 @@
+-- { dg-do run }
+-- { dg-options "-O2" }
+
+with Ada.Calendar; use Ada.Calendar;
+with Opt90e_Pkg; use Opt90e_Pkg;
+
+procedure Opt90e is
+  B : constant Integer := Year (Clock);
+  V : Data;
+
+begin
+  V := (R => (A => 0, B => B, C => 0, D => "000000000000"));
+  if V.R.B /= B then
+    raise Program_Error;
+  end if;
+end;

gcc/testsuite/gnat.dg/opt90e_pkg.ads

@@ -0,0 +1,16 @@
+package Opt90e_Pkg is
+
+  type Rec is record
+    D : String (1 .. 12);
+    A : Short_Short_Integer;
+    B : Integer;
+    C : Short_Integer;
+  end record;
+  pragma Pack (Rec);
+  for Rec'Alignment use 1;
+
+  type Data is tagged record
+    R : Rec;
+  end record;
+
+end Opt90e_Pkg;