diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c
index 17ff6bb582c..6f8caa331a6 100644
--- a/gcc/tree-ssa-alias.c
+++ b/gcc/tree-ssa-alias.c
@@ -120,6 +120,8 @@ static struct {
   unsigned HOST_WIDE_INT modref_use_no_alias;
   unsigned HOST_WIDE_INT modref_clobber_may_alias;
   unsigned HOST_WIDE_INT modref_clobber_no_alias;
+  unsigned HOST_WIDE_INT modref_kill_no;
+  unsigned HOST_WIDE_INT modref_kill_yes;
   unsigned HOST_WIDE_INT modref_tests;
   unsigned HOST_WIDE_INT modref_baseptr_tests;
 } alias_stats;
@@ -169,6 +171,12 @@ dump_alias_stats (FILE *s)
 	   + alias_stats.aliasing_component_refs_p_may_alias);
   dump_alias_stats_in_alias_c (s);
   fprintf (s, "\nModref stats:\n");
+  fprintf (s, "  modref kill: "
+	   HOST_WIDE_INT_PRINT_DEC" kills, "
+	   HOST_WIDE_INT_PRINT_DEC" queries\n",
+	   alias_stats.modref_kill_yes,
+	   alias_stats.modref_kill_yes
+	   + alias_stats.modref_kill_no);
   fprintf (s, "  modref use: "
 	   HOST_WIDE_INT_PRINT_DEC" disambiguations, "
 	   HOST_WIDE_INT_PRINT_DEC" queries\n",
@@ -3373,6 +3381,107 @@ stmt_kills_ref_p (gimple *stmt, ao_ref *ref)
   if (is_gimple_call (stmt))
     {
       tree callee = gimple_call_fndecl (stmt);
+      struct cgraph_node *node;
+      modref_summary *summary;
+
+      /* Try to disambiguate using modref summary.  Modref records a vector
+	 of stores with known offsets relative to function parameters that must
+	 happen every execution of function.  Find if we have a matching
+	 store and verify that function can not use the value.  */
+      if (callee != NULL_TREE
+	  && (node = cgraph_node::get (callee)) != NULL
+	  && node->binds_to_current_def_p ()
+	  && (summary = get_modref_function_summary (node)) != NULL
+	  && summary->kills.length ())
+	{
+	  tree base = ao_ref_base (ref);
+	  for (unsigned int i = 0; i < summary->kills.length (); i++)
+	    {
+	      modref_access_node &a = summary->kills[i];
+	      tree op;
+	      poly_offset_int off1_adj = 0, off2_adj = 0;
+	      poly_int64 off1, off2;
+	      tree base_ptr = NULL;
+	      tree base_decl = NULL;
+
+	      if (a.parm_index >= 0)
+		op = gimple_call_arg (stmt, a.parm_index);
+	      else if (a.parm_index == MODREF_STATIC_CHAIN_PARM)
+		op = gimple_call_chain (stmt);
+	      else
+		gcc_unreachable ();
+
+	      off2_adj += a.parm_offset * BITS_PER_UNIT;
+	      if (!(off2_adj + a.offset).to_shwi (&off2))
+		continue;
+	      if (TREE_CODE (base) == MEM_REF)
+		{
+		  off1_adj = mem_ref_offset (base) << LOG2_BITS_PER_UNIT;
+		  if (TREE_CODE (TREE_OPERAND (base, 0)) == ADDR_EXPR)
+		    base_decl = TREE_OPERAND (TREE_OPERAND (base, 0), 0);
+		  else
+		    base_ptr = TREE_OPERAND (base, 0);
+		}
+	      /* Give up on TMRs for now.  */
+	      else if (TREE_CODE (base) == TARGET_MEM_REF)
+		break;
+	      else
+		base_decl = base;
+
+	      gcc_checking_assert (!base_decl || DECL_P (base_decl));
+	      gcc_checking_assert (!base_ptr
+				   || TREE_CODE (base_ptr) == SSA_NAME);
+
+	      /* OP is a pointer and we have access range from its
+		 dereference.  */
+	      if (TREE_CODE (op) == ADDR_EXPR)
+		{
+		  poly_int64 size, offset, max_size;
+		  bool reverse;
+		  tree op_base = get_ref_base_and_extent
+			  (TREE_OPERAND (op, 0), &offset, &size,
+			   &max_size, &reverse);
+		  if (!known_size_p (size) || !known_eq (size, max_size))
+		    continue;
+		  off2_adj += offset;
+		  /* &str->foo are not passed as gimple operands directly,
+		     would need to look up the def stmt.  */
+		  gcc_checking_assert (TREE_CODE (op_base) != MEM_REF);
+		  if (!base_decl
+		      || compare_base_decls (op_base, base_decl) != 1)
+		    continue;
+		}
+	      else if (!base_ptr || !operand_equal_p (base_ptr, op))
+		continue;
+
+	      if (!(off1_adj + ref->offset).to_shwi (&off1))
+		continue;
+	      if (!(off2_adj + a.offset).to_shwi (&off2))
+		continue;
+
+	      if (known_subrange_p (off1, ref->max_size, off2, a.size)
+		  && dbg_cnt (ipa_mod_ref))
+		{
+		  /* For store to be killed it needs to not be used earlier.  */
+		  if (ref_maybe_used_by_call_p_1 (as_a <gcall *> (stmt), ref,
+						  true))
+		    break;
+		  if (dump_file && (dump_flags & TDF_DETAILS))
+		    {
+		      fprintf (dump_file,
+			       "ipa-modref: call stmt ");
+		      print_gimple_stmt (dump_file, stmt, 0);
+		      fprintf (dump_file,
+			       "ipa-modref: call to %s kills ",
+			       node->dump_name ());
+		      print_generic_expr (dump_file, ref->base);
+		    }
+		  ++alias_stats.modref_kill_yes;
+		  return true;
+		}
+	    }
+	  ++alias_stats.modref_kill_no;
+	}
       if (callee != NULL_TREE
 	  && gimple_call_builtin_p (stmt, BUILT_IN_NORMAL))
 	switch (DECL_FUNCTION_CODE (callee))
diff --git a/gcc/ipa-modref-tree.h b/gcc/ipa-modref-tree.h
index 3e213b23d79..dc3b910801d 100644
--- a/gcc/ipa-modref-tree.h
+++ b/gcc/ipa-modref-tree.h
@@ -287,6 +287,55 @@ struct GTY(()) modref_access_node
 	      size, max_size, record_adjustments);
       return true;
     }
+  /* Merge in access A if it is possible to do without losing
+     precision.  Return true if successful.
+     Unlike merge assume that both accesses are always executed
+     and merge size the same was as max_size.  */
+  bool merge_for_kills (const modref_access_node &a)
+    {
+      poly_int64 offset1 = 0;
+      poly_int64 aoffset1 = 0;
+      poly_int64 new_parm_offset = 0;
+
+      /* We assume that containment was tested earlier.  */
+      gcc_checking_assert (!contains (a) && !a.contains (*this));
+      /* For kills we allways need to know parameter.  */
+      gcc_checking_assert (parm_index != MODREF_UNKNOWN_PARM
+			   && a.parm_index != MODREF_UNKNOWN_PARM);
+      if (parm_index != a.parm_index)
+	return false;
+      /* Unknown offsets are useless.  */
+      gcc_checking_assert (parm_offset_known && a.parm_offset_known);
+      if (!combined_offsets (a, &new_parm_offset, &offset1, &aoffset1))
+	return false;
+      /* Ranges must be known and sizes matching max sizes.  */
+      gcc_checking_assert (range_info_useful_p ()
+			  && a.range_info_useful_p ()
+			  && known_size_p (size) && known_eq (size, max_size)
+			  && known_size_p (a.size)
+			  && known_eq (a.size, a.max_size));
+      if (known_le (offset1, aoffset1))
+	{
+	  if (!known_size_p (max_size)
+	      || known_ge (offset1 + max_size, aoffset1))
+	    {
+	      update_for_kills (new_parm_offset, offset1, max_size,
+				aoffset1, a.max_size);
+	      return true;
+	    }
+	}
+      else if (known_le (aoffset1, offset1))
+	{
+	  if (!known_size_p (a.max_size)
+	      || known_ge (aoffset1 + a.max_size, offset1))
+	    {
+	      update_for_kills (new_parm_offset, offset1, max_size,
+				aoffset1, a.max_size);
+	      return true;
+	    }
+	}
+      return false;
+    }
   /* Return true if A1 and B1 can be merged with lower informatoin
      less than A2 and B2.
      Assume that no containment or lossless merging is possible.  */
@@ -430,6 +479,33 @@ private:
       update (parm_offset1, offset1,
 	      new_size, new_max_size, record_adjustments);
     }
+  /* Merge two ranges both starting at parm_offset1 and update THIS
+     with result.  */
+  void update_for_kills (poly_int64 parm_offset1,
+			 poly_int64 offset1,
+			 poly_int64 max_size1,
+			 poly_int64 offset2,
+			 poly_int64 max_size2)
+    {
+      if (known_le (offset1, offset2))
+	;
+      else if (known_le (offset2, offset1))
+	{
+	  std::swap (offset1, offset2);
+	  std::swap (max_size1, max_size2);
+	}
+      else
+	gcc_unreachable ();
+
+      poly_int64 new_max_size = max_size2 + offset2 - offset1;
+      if (known_le (new_max_size, max_size1))
+	new_max_size = max_size1;
+
+      parm_offset = parm_offset1;
+      offset = offset1;
+      max_size = new_max_size;
+      size = new_max_size;
+    }
   /* Given access nodes THIS and A, return true if they
      can be done with common parm_offsets.  In this case
      return parm offset in new_parm_offset, new_offset
diff --git a/gcc/ipa-modref.c b/gcc/ipa-modref.c
index f8b7b900527..d9859daa18e 100644
--- a/gcc/ipa-modref.c
+++ b/gcc/ipa-modref.c
@@ -334,6 +334,8 @@ modref_summary::useful_p (int ecf_flags, bool check_flags)
     return false;
   if (loads && !loads->every_base)
     return true;
+  else
+    kills.release ();
   if (ecf_flags & ECF_PURE)
     return false;
   return stores && !stores->every_base;
@@ -370,6 +372,7 @@ struct GTY(()) modref_summary_lto
      more verbose and thus more likely to hit the limits.  */
   modref_records_lto *loads;
   modref_records_lto *stores;
+  auto_vec<modref_access_node> GTY((skip)) kills;
   auto_vec<eaf_flags_t> GTY((skip)) arg_flags;
   eaf_flags_t retslot_flags;
   eaf_flags_t static_chain_flags;
@@ -617,6 +620,12 @@ modref_summary::dump (FILE *out)
       fprintf (out, "  stores:\n");
       dump_records (stores, out);
     }
+  if (kills.length ())
+    {
+      fprintf (out, "  kills:\n");
+      for (unsigned int i = 0; i < kills.length (); i++)
+	dump_access (&kills[i], out);
+    }
   if (writes_errno)
     fprintf (out, "  Writes errno\n");
   if (side_effects)
@@ -750,13 +759,12 @@ get_access (ao_ref *ref)
 /* Record access into the modref_records data structure.  */
 
 static void
-record_access (modref_records *tt, ao_ref *ref)
+record_access (modref_records *tt, ao_ref *ref, modref_access_node &a)
 {
   alias_set_type base_set = !flag_strict_aliasing ? 0
 			    : ao_ref_base_alias_set (ref);
   alias_set_type ref_set = !flag_strict_aliasing ? 0
 			    : (ao_ref_alias_set (ref));
-  modref_access_node a = get_access (ref);
   if (dump_file)
     {
        fprintf (dump_file, "   - Recording base_set=%i ref_set=%i ",
@@ -769,7 +777,7 @@ record_access (modref_records *tt, ao_ref *ref)
 /* IPA version of record_access_tree.  */
 
 static void
-record_access_lto (modref_records_lto *tt, ao_ref *ref)
+record_access_lto (modref_records_lto *tt, ao_ref *ref, modref_access_node &a)
 {
   /* get_alias_set sometimes use different type to compute the alias set
      than TREE_TYPE (base).  Do same adjustments.  */
@@ -816,7 +824,6 @@ record_access_lto (modref_records_lto *tt, ao_ref *ref)
 		       || variably_modified_type_p (ref_type, NULL_TREE)))
 	ref_type = NULL_TREE;
     }
-  modref_access_node a = get_access (ref);
   if (dump_file)
     {
       fprintf (dump_file, "   - Recording base type:");
@@ -910,6 +917,82 @@ parm_map_for_arg (tree op)
   return parm_map;
 }
 
+/* Insert new kill A into KILLS.  */
+
+static void
+add_kill (vec<modref_access_node> &kills, modref_access_node &a)
+{
+  size_t index;
+  modref_access_node *a2;
+  bool merge = false;
+
+  /* See if we have corresponding etry already or we can merge with
+     neighbouring entry.  */
+  FOR_EACH_VEC_ELT (kills, index, a2)
+    {
+      if (a2->contains (a))
+	return;
+      if (a.contains (*a2))
+	{
+	  *a2 = a;
+	  merge = true;
+	  break;
+	}
+      if (a2->merge_for_kills (a))
+	{
+	  merge = true;
+	  break;
+	}
+    }
+  /* If entry was not found, insert it.  */
+  if (!merge)
+    {
+      if ((int)kills.length () >= param_modref_max_accesses)
+	{
+	  if (dump_file)
+	    fprintf (dump_file,
+		     "--param param=modref-max-accesses limit reached:");
+	  return;
+	}
+      kills.safe_push (a);
+      return;
+    }
+  /* Extenidng range in an entry may make it possible to merge it with
+     other entries.  */
+    {
+      size_t i;
+
+      for (i = 0; i < kills.length ();)
+	if (i != index)
+	  {
+	    bool found = false, restart = false;
+	    modref_access_node *a = &kills[i];
+	    modref_access_node *n = &kills[index];
+
+	    if (n->contains (*a))
+	      found = true;
+	    if (!found && n->merge_for_kills (*a))
+	      found = restart = true;
+	    gcc_checking_assert (found || !a->merge_for_kills (*n));
+	    if (found)
+	      {
+		kills.unordered_remove (i);
+		if (index == kills.length ())
+		  {
+		    index = i;
+		    i++;
+		  }
+		if (restart)
+		  i = 0;
+	      }
+	    else
+	      i++;
+	  }
+	else
+	  i++;
+    }
+}
+
 /* Merge side effects of call STMT to function with CALLEE_SUMMARY
    int CUR_SUMMARY.  Return true if something changed.
    If IGNORE_STORES is true, do not merge stores.
@@ -920,7 +1003,7 @@ bool
 merge_call_side_effects (modref_summary *cur_summary,
 			 gimple *stmt, modref_summary *callee_summary,
 			 bool ignore_stores, cgraph_node *callee_node,
-			 bool record_adjustments)
+			 bool record_adjustments, bool always_executed)
 {
   auto_vec <modref_parm_map, 32> parm_map;
   modref_parm_map chain_map;
@@ -988,6 +1071,29 @@ merge_call_side_effects (modref_summary *cur_summary,
 	  changed = true;
 	}
     }
+  if (always_executed)
+    {
+      size_t i;
+      modref_access_node *a2;
+      FOR_EACH_VEC_ELT (callee_summary->kills, i, a2)
+	{
+	  modref_access_node n = *a2;
+	  if (n.parm_index >= (int)parm_map.length ())
+	    continue;
+	  modref_parm_map &m
+		  = n.parm_index == MODREF_STATIC_CHAIN_PARM
+		    ? chain_map
+		    : parm_map[n.parm_index];
+	  if (m.parm_index == MODREF_LOCAL_MEMORY_PARM
+	      || m.parm_index == MODREF_UNKNOWN_PARM
+	      || m.parm_index == MODREF_RETSLOT_PARM
+	      || !m.parm_offset_known)
+	    continue;
+	  n.parm_index = m.parm_index;
+	  n.parm_offset += m.parm_offset;
+	  add_kill (cur_summary->kills, n);
+	}
+    }
   if (!cur_summary->side_effects
       && callee_summary->side_effects)
     {
@@ -1198,7 +1304,8 @@ process_fnspec (modref_summary *cur_summary,
 
 static bool
 analyze_call (modref_summary *cur_summary, modref_summary_lto *cur_summary_lto,
-	      gcall *stmt, vec <gimple *> *recursive_calls)
+	      gcall *stmt, vec <gimple *> *recursive_calls,
+	      bool always_executed)
 {
   /* Check flags on the function call.  In certain cases, analysis can be
      simplified.  */
@@ -1284,7 +1391,7 @@ analyze_call (modref_summary *cur_summary, modref_summary_lto *cur_summary_lto,
     }
 
   merge_call_side_effects (cur_summary, stmt, callee_summary, ignore_stores,
-			   callee_node, false);
+			   callee_node, false, always_executed);
 
   return true;
 }
@@ -1295,6 +1402,7 @@ struct summary_ptrs
 {
   struct modref_summary *nolto;
   struct modref_summary_lto *lto;
+  bool always_executed;
 };
 
 /* Helper for analyze_stmt.  */
@@ -1329,11 +1437,12 @@ analyze_load (gimple *, tree, tree op, void *data)
 
   ao_ref r;
   ao_ref_init (&r, op);
+  modref_access_node a = get_access (&r);
 
   if (summary)
-    record_access (summary->loads, &r);
+    record_access (summary->loads, &r, a);
   if (summary_lto)
-    record_access_lto (summary_lto->loads, &r);
+    record_access_lto (summary_lto->loads, &r, a);
   return false;
 }
 
@@ -1369,11 +1478,24 @@ analyze_store (gimple *, tree, tree op, void *data)
 
   ao_ref r;
   ao_ref_init (&r, op);
+  modref_access_node a = get_access (&r);
 
   if (summary)
-    record_access (summary->stores, &r);
+    record_access (summary->stores, &r, a);
   if (summary_lto)
-    record_access_lto (summary_lto->stores, &r);
+    record_access_lto (summary_lto->stores, &r, a);
+  if (summary
+      && ((summary_ptrs *)data)->always_executed
+      && a.parm_offset_known == true
+      && a.parm_index != MODREF_UNKNOWN_PARM
+      && a.parm_index != MODREF_RETSLOT_PARM
+      && known_size_p (r.size)
+      && known_eq (r.max_size, r.size))
+    {
+      if (dump_file)
+	fprintf (dump_file, "   - Recording kill\n");
+      add_kill (summary->kills, a);
+    }
   return false;
 }
 
@@ -1382,16 +1504,36 @@ analyze_store (gimple *, tree, tree op, void *data)
 
 static bool
 analyze_stmt (modref_summary *summary, modref_summary_lto *summary_lto,
-	      gimple *stmt, bool ipa, vec <gimple *> *recursive_calls)
+	      gimple *stmt, bool ipa, vec <gimple *> *recursive_calls,
+	      bool always_executed)
 {
   /* In general we can not ignore clobbers because they are barriers for code
      motion, however after inlining it is safe to do because local optimization
      passes do not consider clobbers from other functions.
      Similar logic is in ipa-pure-const.c.  */
   if ((ipa || cfun->after_inlining) && gimple_clobber_p (stmt))
-    return true;
+    {
+      if (summary
+	  && always_executed && record_access_p (gimple_assign_lhs (stmt)))
+	{
+	  ao_ref r;
+	  ao_ref_init (&r, gimple_assign_lhs (stmt));
+	  modref_access_node a = get_access (&r);
+	  if (a.parm_offset_known == true
+	      && a.parm_index != MODREF_UNKNOWN_PARM
+	      && a.parm_index != MODREF_RETSLOT_PARM
+	      && known_size_p (r.size)
+	      && known_eq (r.max_size, r.size))
+	    {
+	      if (dump_file)
+		fprintf (dump_file, "   - Recording kill\n");
+	      add_kill (summary->kills, a);
+	    }
+	}
+      return true;
+    }
 
-  struct summary_ptrs sums = {summary, summary_lto};
+  struct summary_ptrs sums = {summary, summary_lto, always_executed};
 
   /* Analyze all loads and stores in STMT.  */
   walk_stmt_load_store_ops (stmt, &sums,
@@ -1420,7 +1562,8 @@ analyze_stmt (modref_summary *summary, modref_summary_lto *summary_lto,
    case GIMPLE_CALL:
      if (!ipa || gimple_call_internal_p (stmt))
        return analyze_call (summary, summary_lto,
-			    as_a <gcall *> (stmt), recursive_calls);
+			    as_a <gcall *> (stmt), recursive_calls,
+			    always_executed);
      else
       {
 	attr_fnspec fnspec = gimple_call_fnspec (as_a <gcall *>(stmt));
@@ -2729,11 +2872,15 @@ analyze_function (function *f, bool ipa)
   FOR_EACH_BB_FN (bb, f)
     {
       gimple_stmt_iterator si;
+      bool always_executed
+	      = bb == single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun))->dest;
+
       for (si = gsi_start_nondebug_after_labels_bb (bb);
 	   !gsi_end_p (si); gsi_next_nondebug (&si))
 	{
 	  if (!analyze_stmt (summary, summary_lto,
-			     gsi_stmt (si), ipa, &recursive_calls)
+			     gsi_stmt (si), ipa, &recursive_calls,
+			     always_executed)
 	      || ((!summary || !summary->useful_p (ecf_flags, false))
 		  && (!summary_lto
 		      || !summary_lto->useful_p (ecf_flags, false))))
@@ -2742,6 +2889,9 @@ analyze_function (function *f, bool ipa)
 	      collapse_stores (summary, summary_lto);
 	      break;
 	    }
+	  if (always_executed
+	      && stmt_can_throw_external (cfun, gsi_stmt (si)))
+	    always_executed = false;
 	}
     }
 
@@ -2761,7 +2911,7 @@ analyze_function (function *f, bool ipa)
 			   ignore_stores_p (current_function_decl,
 					    gimple_call_flags
 						 (recursive_calls[i])),
-			   fnode, !first);
+			   fnode, !first, false);
 	      if (!summary->useful_p (ecf_flags, false))
 		{
 		  remove_summary (lto, nolto, ipa);
@@ -2993,6 +3143,8 @@ modref_summaries::duplicate (cgraph_node *, cgraph_node *dst,
 			 src_data->loads->max_refs,
 			 src_data->loads->max_accesses);
   dst_data->loads->copy_from (src_data->loads);
+  dst_data->kills.reserve_exact (src_data->kills.length ());
+  dst_data->kills.splice (src_data->kills);
   dst_data->writes_errno = src_data->writes_errno;
   dst_data->side_effects = src_data->side_effects;
   if (src_data->arg_flags.length ())
@@ -3640,6 +3792,8 @@ update_signature (struct cgraph_node *node)
     {
       r->loads->remap_params (&map);
       r->stores->remap_params (&map);
+      /* TODO: One we do IPA kills analysis, update the table here.  */
+      r->kills.release ();
       if (r->arg_flags.length ())
 	remap_arg_flags (r->arg_flags, info);
     }
@@ -3647,6 +3801,8 @@ update_signature (struct cgraph_node *node)
     {
       r_lto->loads->remap_params (&map);
       r_lto->stores->remap_params (&map);
+      /* TODO: One we do IPA kills analysis, update the table here.  */
+      r_lto->kills.release ();
       if (r_lto->arg_flags.length ())
 	remap_arg_flags (r_lto->arg_flags, info);
     }
diff --git a/gcc/ipa-modref.h b/gcc/ipa-modref.h
index 49c99f263a7..b77c1aa7400 100644
--- a/gcc/ipa-modref.h
+++ b/gcc/ipa-modref.h
@@ -30,6 +30,7 @@ struct GTY(()) modref_summary
   /* Load and stores in function (transitively closed to all callees)  */
   modref_records *loads;
   modref_records *stores;
+  auto_vec<modref_access_node> GTY((skip)) kills;
   auto_vec<eaf_flags_t> GTY((skip)) arg_flags;
   eaf_flags_t retslot_flags;
   eaf_flags_t static_chain_flags;
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/modref-dse-2.c b/gcc/testsuite/gcc.dg/tree-ssa/modref-dse-2.c
new file mode 100644
index 00000000000..2a23a9e8ccb
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/modref-dse-2.c
@@ -0,0 +1,22 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-dse1"  } */
+__attribute__ ((noinline))
+void write (int *a)
+{
+	*a=1;
+	a[1]=2;
+}
+int test ()
+{
+	int a;
+	a=2;
+	write (&a);
+	return a;
+}
+int test2 (int *a)
+{
+	*a=2;
+	write (a);
+	return *a;
+}
+/* { dg-final { scan-tree-dump-times "Deleted dead store" 2 "dse1"} } */
