diff --git a/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-104.c b/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-104.c
index f0f12ef82b7..425c32dd93c 100644
--- a/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-104.c
+++ b/gcc/testsuite/gcc.dg/tree-ssa/ssa-fre-104.c
@@ -21,4 +21,4 @@ int main() {
   *c = &d;
 }
 
-/* { dg-final { scan-tree-dump-not "foo" "fre1" } } */
+/* { dg-final { scan-tree-dump-not "foo" "fre1" { xfail *-*-* } } } */
diff --git a/gcc/tree-ssa-sccvn.cc b/gcc/tree-ssa-sccvn.cc
index 21123644a5a..0b7fb0663c7 100644
--- a/gcc/tree-ssa-sccvn.cc
+++ b/gcc/tree-ssa-sccvn.cc
@@ -912,8 +912,6 @@ copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
 {
   /* For non-calls, store the information that makes up the address.  */
   tree orig = ref;
-  unsigned start = result->length ();
-  bool seen_variable_array_ref = false;
   while (ref)
     {
       vn_reference_op_s temp;
@@ -1000,12 +998,6 @@ copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
 	    tree eltype = TREE_TYPE (TREE_TYPE (TREE_OPERAND (ref, 0)));
 	    /* Record index as operand.  */
 	    temp.op0 = TREE_OPERAND (ref, 1);
-	    /* When the index is not constant we have to apply the same
-	       logic as get_ref_base_and_extent which eventually uses
-	       global ranges to refine the overall ref extent.  Record
-	       we've seen such a case, fixup below.  */
-	    if (TREE_CODE (temp.op0) == SSA_NAME)
-	      seen_variable_array_ref = true;
 	    /* Always record lower bounds and element size.  */
 	    temp.op1 = array_ref_low_bound (ref);
 	    /* But record element size in units of the type alignment.  */
@@ -1098,132 +1090,6 @@ copy_reference_ops_from_ref (tree ref, vec<vn_reference_op_s> *result)
       else
 	ref = NULL_TREE;
     }
-  poly_int64 offset, size, max_size;
-  tree base;
-  bool rev;
-  if (seen_variable_array_ref
-      && handled_component_p (orig)
-      && (base = get_ref_base_and_extent (orig,
-					  &offset, &size, &max_size, &rev))
-      && known_size_p (max_size)
-      && known_eq (size, max_size))
-    {
-      poly_int64 orig_offset = offset;
-      poly_int64 tem;
-      if (TREE_CODE (base) == MEM_REF
-	  && mem_ref_offset (base).to_shwi (&tem))
-	offset += tem * BITS_PER_UNIT;
-      HOST_WIDE_INT coffset = offset.to_constant ();
-      /* When get_ref_base_and_extent computes an offset constrained to
-	 a constant position we have to fixup variable array indexes in
-	 the ref to avoid the situation where based on context we'd have
-	 to value-number the same vn_reference ops differently.  Make
-	 the vn_reference ops differ by adjusting those indexes to
-	 appropriate constants.  */
-      poly_int64 off = 0;
-      bool oob_index = false;
-      for (unsigned i = result->length (); i > start; --i)
-	{
-	  auto &op = (*result)[i-1];
-	  if (flag_checking
-	      && op.opcode == ARRAY_REF
-	      && TREE_CODE (op.op0) == INTEGER_CST)
-	    {
-	      /* The verifier below chokes on inconsistencies of handling
-		 out-of-bound accesses so disable it in that case.  */
-	      tree atype = (*result)[i].type;
-	      if (TREE_CODE (atype) == ARRAY_TYPE)
-		if (tree dom = TYPE_DOMAIN (atype))
-		  if ((TYPE_MIN_VALUE (dom)
-		       && TREE_CODE (TYPE_MIN_VALUE (dom)) == INTEGER_CST
-		       && (wi::to_widest (op.op0)
-			   < wi::to_widest (TYPE_MIN_VALUE (dom))))
-		      || (TYPE_MAX_VALUE (dom)
-			  && TREE_CODE (TYPE_MAX_VALUE (dom)) == INTEGER_CST
-			  && (wi::to_widest (op.op0)
-			      > wi::to_widest (TYPE_MAX_VALUE (dom)))))
-		    oob_index = true;
-	    }
-	  if ((op.opcode == ARRAY_REF
-	       || op.opcode == ARRAY_RANGE_REF)
-	      && TREE_CODE (op.op0) == SSA_NAME)
-	    {
-	      /* There's a single constant index that get's 'off' closer
-		 to 'offset'.  */
-	      unsigned HOST_WIDE_INT elsz
-		= tree_to_uhwi (op.op2) * vn_ref_op_align_unit (&op);
-	      unsigned HOST_WIDE_INT idx
-		= (coffset - off.to_constant ()) / BITS_PER_UNIT / elsz;
-	      if (idx == 0)
-		op.op0 = op.op1;
-	      else
-		op.op0 = wide_int_to_tree (TREE_TYPE (op.op0),
-					   wi::to_poly_wide (op.op1) + idx);
-	      op.off = idx * elsz;
-	      off += op.off * BITS_PER_UNIT;
-	    }
-	  else
-	    {
-	      if (op.opcode == ERROR_MARK)
-		/* two-ops codes have the offset in the first op.  */
-		;
-	      else if (op.opcode == ADDR_EXPR
-		       || op.opcode == SSA_NAME
-		       || op.opcode == CONSTRUCTOR
-		       || TREE_CODE_CLASS (op.opcode) == tcc_declaration
-		       || TREE_CODE_CLASS (op.opcode) == tcc_constant)
-		/* end-of ref.  */
-		gcc_assert (i == result->length ());
-	      else if (op.opcode == COMPONENT_REF)
-		{
-		  /* op.off is tracked in bytes, re-do it manually
-		     because of bitfields.  */
-		  tree field = op.op0;
-		  /* We do not have a complete COMPONENT_REF tree here so we
-		     cannot use component_ref_field_offset.  Do the interesting
-		     parts manually.  */
-		  tree this_offset = DECL_FIELD_OFFSET (field);
-		  if (op.op1 || !poly_int_tree_p (this_offset))
-		    gcc_unreachable ();
-		  else
-		    {
-		      poly_offset_int woffset
-			= (wi::to_poly_offset (this_offset)
-			   << LOG2_BITS_PER_UNIT);
-		      woffset += wi::to_offset (DECL_FIELD_BIT_OFFSET (field));
-		      off += woffset.force_shwi ();
-		    }
-		}
-	      else
-		{
-		  gcc_assert (known_ne (op.off, -1)
-			      /* The constant offset can be -1.  */
-			      || op.opcode == MEM_REF
-			      /* Out-of-bound indices can compute to
-				 a known -1 offset.  */
-			      || ((op.opcode == ARRAY_REF
-				   || op.opcode == ARRAY_RANGE_REF)
-				  && poly_int_tree_p (op.op0)
-				  && poly_int_tree_p (op.op1)
-				  && TREE_CODE (op.op2) == INTEGER_CST));
-		  off += op.off * BITS_PER_UNIT;
-		}
-	    }
-	}
-      if (flag_checking && !oob_index)
-	{
-	  ao_ref r;
-	  if (start != 0)
-	    ;
-	  else if (ao_ref_init_from_vn_reference (&r, 0, 0, TREE_TYPE (orig),
-						  *result))
-	    gcc_assert (known_eq (r.offset, orig_offset)
-			&& known_eq (r.size, size)
-			&& known_eq (r.max_size, max_size));
-	  else
-	    gcc_unreachable ();
-	}
-    }
 }
 
 /* Build a alias-oracle reference abstraction in *REF from the vn_reference
