diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index f457d0cf019dce7a49c0ebfdf237cde4eaaef9c2..0e2d2fb2326f0b62f5b4f3b09fe62f2a36dae158 100644
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,5 +1,9 @@
 2010-09-24  Jason Merrill  <jason@redhat.com>
 
+	* decl.c (compute_array_index_type): Remember type dependence of
+	array bound.
+	* pt.c (dependent_type_p_r): Don't recompute it here.
+
 	* error.c (dump_expr) [CASE_CONVERT]: Print conversion between
 	reference and pointer to the same type as "*" or "&".
 
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index 3d1420a23ebe2e527b22197250041ded58e9e3df..6a444822c167503d026565b8c70a74d8de5ea7b6 100644
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -7402,11 +7402,15 @@ compute_array_index_type (tree name, tree size)
       type = TREE_TYPE (size);
     }
 
+  /* A type is dependent if it is...an array type constructed from any
+     dependent type or whose size is specified by a constant expression
+     that is value-dependent.  */
   /* We can only call value_dependent_expression_p on integral constant
      expressions; the parser adds a dummy NOP_EXPR with TREE_SIDE_EFFECTS
      set if this isn't one.  */
   if (processing_template_decl
-      && (TREE_SIDE_EFFECTS (size) || value_dependent_expression_p (size)))
+      && (dependent_type_p (type)
+	  || TREE_SIDE_EFFECTS (size) || value_dependent_expression_p (size)))
     {
       /* We cannot do any checking for a SIZE that isn't known to be
 	 constant. Just build the index type and mark that it requires
@@ -7532,10 +7536,16 @@ compute_array_index_type (tree name, tree size)
     {
       tree t = build_index_type (itype);
       TYPE_CANONICAL (abi_1_itype) = TYPE_CANONICAL (t);
-      return abi_1_itype;
+      itype = abi_1_itype;
     }
   else
-    return build_index_type (itype);
+    itype = build_index_type (itype);
+
+  /* If the index type were dependent, we would have returned early, so
+     remember that it isn't.  */
+  TYPE_DEPENDENT_P (itype) = 0;
+  TYPE_DEPENDENT_P_VALID (itype) = 1;
+  return itype;
 }
 
 /* Returns the scope (if any) in which the entity declared by
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 5a90bdc6eadf7cd119debf046b13a722c180932b..f5e09ee175720148366c2bde8c55f8d639da75cf 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -17479,7 +17479,10 @@ dependent_type_p_r (tree type)
     }
   /* -- an array type constructed from any dependent type or whose
 	size is specified by a constant expression that is
-	value-dependent.  */
+	value-dependent.
+
+        We checked for type- and value-dependence of the bounds in
+        compute_array_index_type, so TYPE_DEPENDENT_P is already set.  */
   if (TREE_CODE (type) == ARRAY_TYPE)
     {
       if (TYPE_DOMAIN (type)
@@ -17487,14 +17490,6 @@ dependent_type_p_r (tree type)
 	return true;
       return dependent_type_p (TREE_TYPE (type));
     }
-  else if (TREE_CODE (type) == INTEGER_TYPE
-	   && !TREE_CONSTANT (TYPE_MAX_VALUE (type)))
-    {
-      /* If this is the TYPE_DOMAIN of an array type, consider it
-	 dependent.  We already checked for value-dependence in
-	 compute_array_index_type.  */
-      return type_dependent_expression_p (TYPE_MAX_VALUE (type));
-    }
 
   /* -- a template-id in which either the template name is a template
      parameter ...  */