Index: cp/call.c
===================================================================
--- cp/call.c	(revision 278549)
+++ cp/call.c	(working copy)
@@ -6354,11 +6354,9 @@ build_new_op_1 (const op_location_t &loc, enum tre
 		  && (TYPE_MAIN_VARIANT (arg1_type)
 		      != TYPE_MAIN_VARIANT (arg2_type))
 		  && (complain & tf_warning))
-		{
-		  warning (OPT_Wenum_compare,
-			   "comparison between %q#T and %q#T",
-			   arg1_type, arg2_type);
-		}
+		warning_at (loc, OPT_Wenum_compare,
+			    "comparison between %q#T and %q#T",
+			    arg1_type, arg2_type);
 	      break;
 	    default:
 	      break;
@@ -6416,7 +6414,7 @@ build_new_op_1 (const op_location_t &loc, enum tre
       return cp_build_modify_expr (loc, arg1, code2, arg2, complain);
 
     case INDIRECT_REF:
-      return cp_build_indirect_ref (arg1, RO_UNARY_STAR, complain);
+      return cp_build_indirect_ref (loc, arg1, RO_UNARY_STAR, complain);
 
     case TRUTH_ANDIF_EXPR:
     case TRUTH_ORIF_EXPR:
@@ -6472,8 +6470,9 @@ build_new_op_1 (const op_location_t &loc, enum tre
       return cp_build_array_ref (input_location, arg1, arg2, complain);
 
     case MEMBER_REF:
-      return build_m_component_ref (cp_build_indirect_ref (arg1, RO_ARROW_STAR, 
-                                                           complain), 
+      return build_m_component_ref (cp_build_indirect_ref (loc, arg1,
+							   RO_ARROW_STAR,
+                                                           complain),
                                     arg2, complain);
 
       /* The caller will deal with these.  */
Index: cp/cp-tree.h
===================================================================
--- cp/cp-tree.h	(revision 278549)
+++ cp/cp-tree.h	(working copy)
@@ -7482,9 +7482,11 @@ extern tree build_class_member_access_expr      (c
 extern tree finish_class_member_access_expr     (cp_expr, tree, bool,
 						 tsubst_flags_t);
 extern tree build_x_indirect_ref		(location_t, tree,
-						 ref_operator, tsubst_flags_t);
-extern tree cp_build_indirect_ref		(tree, ref_operator,
-                                                 tsubst_flags_t);
+						 ref_operator,
+						 tsubst_flags_t);
+extern tree cp_build_indirect_ref		(location_t, tree,
+						 ref_operator,
+						 tsubst_flags_t);
 extern tree cp_build_fold_indirect_ref		(tree);
 extern tree build_array_ref			(location_t, tree, tree);
 extern tree cp_build_array_ref			(location_t, tree, tree,
Index: cp/semantics.c
===================================================================
--- cp/semantics.c	(revision 278549)
+++ cp/semantics.c	(working copy)
@@ -7193,7 +7193,8 @@ finish_omp_clauses (tree clauses, enum c_omp_regio
 		remove = true;
 	      else
 		{
-		  t = cp_build_indirect_ref (addr, RO_UNARY_STAR,
+		  t = cp_build_indirect_ref (OMP_CLAUSE_LOCATION (c),
+					     addr, RO_UNARY_STAR,
 					     tf_warning_or_error);
 		  if (t == error_mark_node)
 		    remove = true;
@@ -9328,7 +9329,7 @@ finish_omp_depobj (location_t loc, tree depobj,
       if (addr == error_mark_node)
 	depobj = error_mark_node;
       else
-	depobj = cp_build_indirect_ref (addr, RO_UNARY_STAR,
+	depobj = cp_build_indirect_ref (loc, addr, RO_UNARY_STAR,
 					tf_warning_or_error);
     }
 
Index: cp/typeck.c
===================================================================
--- cp/typeck.c	(revision 278549)
+++ cp/typeck.c	(working copy)
@@ -3278,7 +3278,7 @@ build_x_indirect_ref (location_t loc, tree expr, r
   rval = build_new_op (loc, INDIRECT_REF, LOOKUP_NORMAL, expr,
 		       NULL_TREE, NULL_TREE, &overload, complain);
   if (!rval)
-    rval = cp_build_indirect_ref (expr, errorstring, complain);
+    rval = cp_build_indirect_ref (loc, expr, errorstring, complain);
 
   if (processing_template_decl && rval != error_mark_node)
     {
@@ -3296,7 +3296,7 @@ build_x_indirect_ref (location_t loc, tree expr, r
    constructs.  If DO_FOLD is true, fold away INDIRECT_REF of ADDR_EXPR.  */
 
 static tree
-cp_build_indirect_ref_1 (tree ptr, ref_operator errorstring,
+cp_build_indirect_ref_1 (location_t loc, tree ptr, ref_operator errorstring,
 			 tsubst_flags_t complain, bool do_fold)
 {
   tree pointer, type;
@@ -3345,7 +3345,7 @@ static tree
 	  /* A pointer to incomplete type (other than cv void) can be
 	     dereferenced [expr.unary.op]/1  */
           if (complain & tf_error)
-            error ("%qT is not a pointer-to-object type", type);
+            error_at (loc, "%qT is not a pointer-to-object type", type);
 	  return error_mark_node;
 	}
       else if (do_fold && TREE_CODE (pointer) == ADDR_EXPR
@@ -3376,23 +3376,25 @@ static tree
     switch (errorstring)
       {
          case RO_ARRAY_INDEXING:
-           error ("invalid use of array indexing on pointer to member");
+           error_at (loc,
+		     "invalid use of array indexing on pointer to member");
            break;
          case RO_UNARY_STAR:
-           error ("invalid use of unary %<*%> on pointer to member");
+           error_at (loc, "invalid use of unary %<*%> on pointer to member");
            break;
          case RO_IMPLICIT_CONVERSION:
-           error ("invalid use of implicit conversion on pointer to member");
+           error_at (loc, "invalid use of implicit conversion on pointer "
+		     "to member");
            break;
          case RO_ARROW_STAR:
-           error ("left hand operand of %<->*%> must be a pointer to class, "
-		  "but is a pointer to member of type %qT", type);
+           error_at (loc, "left hand operand of %<->*%> must be a pointer to "
+		     "class, but is a pointer to member of type %qT", type);
            break;
          default:
            gcc_unreachable ();
       }
   else if (pointer != error_mark_node)
-    invalid_indirection_error (input_location, type, errorstring);
+    invalid_indirection_error (loc, type, errorstring);
 
   return error_mark_node;
 }
@@ -3400,10 +3402,10 @@ static tree
 /* Entry point used by c-common, which expects folding.  */
 
 tree
-build_indirect_ref (location_t /*loc*/,
-		    tree ptr, ref_operator errorstring)
+build_indirect_ref (location_t loc, tree ptr, ref_operator errorstring)
 {
-  return cp_build_indirect_ref_1 (ptr, errorstring, tf_warning_or_error, true);
+  return cp_build_indirect_ref_1 (loc, ptr, errorstring,
+				  tf_warning_or_error, true);
 }
 
 /* Entry point used by internal indirection needs that don't correspond to any
@@ -3412,7 +3414,8 @@ tree
 tree
 cp_build_fold_indirect_ref (tree pointer)
 {
-  return cp_build_indirect_ref_1 (pointer, RO_NULL, tf_warning_or_error, true);
+  return cp_build_indirect_ref_1 (input_location, pointer, RO_NULL,
+				  tf_warning_or_error, true);
 }
 
 /* Entry point used by indirection needs that correspond to some syntactic
@@ -3419,10 +3422,10 @@ cp_build_fold_indirect_ref (tree pointer)
    construct.  */
 
 tree
-cp_build_indirect_ref (tree ptr, ref_operator errorstring,
+cp_build_indirect_ref (location_t loc, tree ptr, ref_operator errorstring,
 		       tsubst_flags_t complain)
 {
-  return cp_build_indirect_ref_1 (ptr, errorstring, complain, false);
+  return cp_build_indirect_ref_1 (loc, ptr, errorstring, complain, false);
 }
 
 /* This handles expressions of the form "a[i]", which denotes
@@ -3599,7 +3602,7 @@ cp_build_array_ref (location_t loc, tree array, tr
     ret = cp_build_binary_op (input_location, PLUS_EXPR, ar, ind, complain);
     if (first)
       ret = build2_loc (loc, COMPOUND_EXPR, TREE_TYPE (ret), first, ret);
-    ret = cp_build_indirect_ref (ret, RO_ARRAY_INDEXING, complain);
+    ret = cp_build_indirect_ref (loc, ret, RO_ARRAY_INDEXING, complain);
     protected_set_expr_location (ret, loc);
     if (non_lvalue)
       ret = non_lvalue_loc (loc, ret);
@@ -8280,7 +8283,8 @@ cp_build_modify_expr (location_t loc, tree lhs, en
 	if (VOID_TYPE_P (TREE_TYPE (rhs)))
 	  {
 	    if (complain & tf_error)
-	      error ("void value not ignored as it ought to be");
+	      error_at (cp_expr_loc_or_loc (rhs, loc),
+			"void value not ignored as it ought to be");
 	    return error_mark_node;
 	  }
 
@@ -8493,7 +8497,8 @@ cp_build_modify_expr (location_t loc, tree lhs, en
 	  if (modifycode != INIT_EXPR)
 	    {
 	      if (complain & tf_error)
-		error ("assigning to an array from an initializer list");
+		error_at (loc,
+			  "assigning to an array from an initializer list");
 	      return error_mark_node;
 	    }
 	  if (check_array_initializer (lhs, lhstype, newrhs))
@@ -8520,8 +8525,8 @@ cp_build_modify_expr (location_t loc, tree lhs, en
 				     TYPE_MAIN_VARIANT (TREE_TYPE (newrhs))))
 	{
 	  if (complain & tf_error)
-	    error ("incompatible types in assignment of %qT to %qT",
-		   TREE_TYPE (rhs), lhstype);
+	    error_at (loc, "incompatible types in assignment of %qT to %qT",
+		      TREE_TYPE (rhs), lhstype);
 	  return error_mark_node;
 	}
 
@@ -8534,9 +8539,9 @@ cp_build_modify_expr (location_t loc, tree lhs, en
 	  if (complain & tf_error)
 	    {
 	      if (modifycode == INIT_EXPR)
-		error ("array used as initializer");
+		error_at (loc, "array used as initializer");
 	      else
-		error ("invalid array assignment");
+		error_at (loc, "invalid array assignment");
 	    }
 	  return error_mark_node;
 	}
Index: cp/typeck2.c
===================================================================
--- cp/typeck2.c	(revision 278549)
+++ cp/typeck2.c	(working copy)
@@ -2060,7 +2060,7 @@ build_x_arrow (location_t loc, tree expr, tsubst_f
 	  return expr;
 	}
 
-      return cp_build_indirect_ref (last_rval, RO_ARROW, complain);
+      return cp_build_indirect_ref (loc, last_rval, RO_ARROW, complain);
     }
 
   if (complain & tf_error)
Index: testsuite/g++.dg/cpp0x/initlist26.C
===================================================================
--- testsuite/g++.dg/cpp0x/initlist26.C	(revision 278549)
+++ testsuite/g++.dg/cpp0x/initlist26.C	(working copy)
@@ -6,5 +6,5 @@ void
 foo (int i)
 {
   int a[i];
-  a = { }; // { dg-error "assign" }
+  a = { }; // { dg-error "5:assigning to an array from an initializer list" }
 }
Index: testsuite/g++.dg/cpp0x/initlist28.C
===================================================================
--- testsuite/g++.dg/cpp0x/initlist28.C	(revision 278549)
+++ testsuite/g++.dg/cpp0x/initlist28.C	(working copy)
@@ -4,5 +4,5 @@
 void foo()
 {
   int a[1];
-  throw a = {}; // { dg-error "assign" }
+  throw a = {}; // { dg-error "11:assigning to an array from an initializer list" }
 }
Index: testsuite/g++.dg/cpp0x/initlist29.C
===================================================================
--- testsuite/g++.dg/cpp0x/initlist29.C	(revision 278549)
+++ testsuite/g++.dg/cpp0x/initlist29.C	(working copy)
@@ -5,7 +5,7 @@ class Mesh
 {
 public:
   Mesh(const char*)
-  { typele={0}; }		// { dg-error "" }
+  { typele={0}; }		// { dg-error "11:assigning to an array from an initializer list" }
 
 private:
   int typele[7][2];
Index: testsuite/g++.dg/cpp0x/initlist33.C
===================================================================
--- testsuite/g++.dg/cpp0x/initlist33.C	(revision 278549)
+++ testsuite/g++.dg/cpp0x/initlist33.C	(working copy)
@@ -9,5 +9,5 @@ struct base
 int main()
 {
  base ptr_array[1];
- ptr_array = { base() };	// { dg-error "assign" }
+ ptr_array = { base() };	// { dg-error "12:assigning to an array from an initializer list" }
 }
Index: testsuite/g++.dg/diagnostic/base-operand-non-pointer-1.C
===================================================================
--- testsuite/g++.dg/diagnostic/base-operand-non-pointer-1.C	(nonexistent)
+++ testsuite/g++.dg/diagnostic/base-operand-non-pointer-1.C	(working copy)
@@ -0,0 +1,2 @@
+class C { public: C f(); int get(); };
+int f(C* p) { return p->f()->get(); }  // { dg-error "28:base operand of .->. has non-pointer type .C." }
Index: testsuite/g++.dg/expr/string-2.C
===================================================================
--- testsuite/g++.dg/expr/string-2.C	(revision 278549)
+++ testsuite/g++.dg/expr/string-2.C	(working copy)
@@ -3,7 +3,7 @@
 
 char a[1];
 
-int foo(a = "") // { dg-error "invalid array assignment" }
+int foo(a = "") // { dg-error "11:invalid array assignment" }
 {
   return 0;
 }
Index: testsuite/g++.dg/other/ptrmem5.C
===================================================================
--- testsuite/g++.dg/other/ptrmem5.C	(revision 278549)
+++ testsuite/g++.dg/other/ptrmem5.C	(working copy)
@@ -8,5 +8,5 @@ struct a
 int main()
 {
   int a::*n[8];
-  n = &a::x;                    // { dg-error "int \\(a::\\*\\)" }
+  n = &a::x; // { dg-error "5:incompatible types in assignment of .int \\(a::\\*\\)" }
 }   
Index: testsuite/g++.dg/pr53055.C
===================================================================
--- testsuite/g++.dg/pr53055.C	(revision 278549)
+++ testsuite/g++.dg/pr53055.C	(working copy)
@@ -2,4 +2,4 @@
 // { dg-do compile }
 
 struct A A :: * p ;
-int i = p ->* p ; // { dg-error "" }
+int i = p ->* p ; // { dg-error "11:left hand operand" }
Index: testsuite/g++.dg/warn/Wenum-compare.C
===================================================================
--- testsuite/g++.dg/warn/Wenum-compare.C	(revision 278549)
+++ testsuite/g++.dg/warn/Wenum-compare.C	(working copy)
@@ -6,5 +6,5 @@ enum E2 { b };
 
 int foo (E1 e1, E2 e2)
 {
-  return e1 == e2;  /* { dg-warning "comparison between" } */
+  return e1 == e2;  /* { dg-warning "13:comparison between" } */
 }
Index: testsuite/g++.old-deja/g++.benjamin/14664-1.C
===================================================================
--- testsuite/g++.old-deja/g++.benjamin/14664-1.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.benjamin/14664-1.C	(working copy)
@@ -8,7 +8,7 @@ void bar()
 {
   //-g++: incompatible types in assignment of 'const char[]' to 'char[]'
   //-edg: expression must be a modifiable lvalue
-  foo = "0123456789012345678901234"; // { dg-error "" } // ERROR -
+  foo = "0123456789012345678901234"; // { dg-error "7:invalid array assignment" } // ERROR -
 }
 
 
Index: testsuite/g++.old-deja/g++.benjamin/14664-2.C
===================================================================
--- testsuite/g++.old-deja/g++.benjamin/14664-2.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.benjamin/14664-2.C	(working copy)
@@ -7,7 +7,7 @@ char foo[26];
 
 void bar()
 {
-  foo = "0123456789012345678901234"; // { dg-error "array" }
+  foo = "0123456789012345678901234"; // { dg-error "7:invalid array assignment" }
 }
 
 
Index: testsuite/g++.old-deja/g++.brendan/init12.C
===================================================================
--- testsuite/g++.old-deja/g++.brendan/init12.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.brendan/init12.C	(working copy)
@@ -5,5 +5,5 @@ char * bob();
 int main()
 {
     char a[1][2];
-    a[0] = bob();// { dg-error "" } .*
+    a[0] = bob();// { dg-error "10:incompatible types in assignment" } .*
 }
Index: testsuite/g++.old-deja/g++.bugs/900213_02.C
===================================================================
--- testsuite/g++.old-deja/g++.bugs/900213_02.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.bugs/900213_02.C	(working copy)
@@ -16,7 +16,7 @@ int struct0::*dmp;
 
 void global_function_0 ()
 {
-  i = *dmp;			// { dg-error "invalid use of unary '\\\*' on pointer to member" } causes abort
+  i = *dmp;			// { dg-error "7:invalid use of unary '\\\*' on pointer to member" } causes abort
 }
 
 int main () { return 0; }
Index: testsuite/g++.old-deja/g++.bugs/900215_02.C
===================================================================
--- testsuite/g++.old-deja/g++.bugs/900215_02.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.bugs/900215_02.C	(working copy)
@@ -41,8 +41,8 @@ void struct0::function_member ()
   i = (this->*fmp) ();		// perfectly legal - for both cfront and g++
   i = this->*dmp;		// perfectly legal - for both cfront and g++
 
-  i = (*fmp) ();		// { dg-error "invalid use of unary '\\\*' on pointer to member" } 
-  i = *dmp;			// { dg-error "invalid use of unary '\\\*' on pointer to member" } 
+  i = (*fmp) ();		// { dg-error "8:invalid use of unary '\\\*' on pointer to member" } 
+  i = *dmp;			// { dg-error "7:invalid use of unary '\\\*' on pointer to member" } 
 }
 
 int main () { return 0; }
Index: testsuite/g++.old-deja/g++.bugs/900324_04.C
===================================================================
--- testsuite/g++.old-deja/g++.bugs/900324_04.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.bugs/900324_04.C	(working copy)
@@ -20,7 +20,7 @@ int_array ia2;
 
 void function_0 ()
 {
-  ia1 = ia2;		// { dg-error "" } gnu extension
+  ia1 = ia2;		// { dg-error "7:invalid array assignment" } gnu extension
 }
 
 int main () { return 0; }
Index: testsuite/g++.old-deja/g++.ext/array1.C
===================================================================
--- testsuite/g++.old-deja/g++.ext/array1.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.ext/array1.C	(working copy)
@@ -19,5 +19,5 @@ void
 ccBgaInspection::reinspect (unsigned long diag_flags) 
 {
   ct2d_rigid physTdev;		 
-  _dev2phys = physTdev; // { dg-error "" } 
+  _dev2phys = physTdev; // { dg-error "13:incompatible types in assignment" } 
 }
Index: testsuite/g++.old-deja/g++.jason/rfg17.C
===================================================================
--- testsuite/g++.old-deja/g++.jason/rfg17.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.jason/rfg17.C	(working copy)
@@ -12,5 +12,5 @@ void
 test ()
 {
   b1 = b2;	      /* OK */
-  a1 = a2;	      /* { dg-error "" } array assignment */
+  a1 = a2;	      /* { dg-error "6:invalid array assignment" } array assignment */
 }
Index: testsuite/g++.old-deja/g++.other/badarrow.C
===================================================================
--- testsuite/g++.old-deja/g++.other/badarrow.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.other/badarrow.C	(working copy)
@@ -6,5 +6,5 @@ struct S {
 
 void f()
 {
-  s->i = 3; // { dg-error "" } base operand
+  s->i = 3; // { dg-error "4:base operand of .->. has non-pointer type .S." } base operand
 }
Index: testsuite/g++.old-deja/g++.other/deref1.C
===================================================================
--- testsuite/g++.old-deja/g++.other/deref1.C	(revision 278549)
+++ testsuite/g++.old-deja/g++.other/deref1.C	(working copy)
@@ -7,8 +7,8 @@
 
 void fn (void *vp, volatile void *vvp)
 {
-  *vp;      // { dg-error "" } not a pointer to object
-  *vvp;     // { dg-error "" } not a pointer to object
-  &*vp;     // { dg-error "" } not a pointer to object
-  &*vvp;    // { dg-error "" } not a pointer to object
+  *vp;      // { dg-error "3:.void\\*. is not a pointer-to-object type" } not a pointer to object
+  *vvp;     // { dg-error "3:.volatile void\\*. is not a pointer-to-object type" } not a pointer to object
+  &*vp;     // { dg-error "4:.void\\*. is not a pointer-to-object type" } not a pointer to object
+  &*vvp;    // { dg-error "4:.volatile void\\*. is not a pointer-to-object type" } not a pointer to object
 }
