From e07161c7567a71442fc4df99048c219c01d98728 Mon Sep 17 00:00:00 2001
From: David Malcolm <dmalcolm@redhat.com>
Date: Tue, 15 Aug 2017 14:33:32 -0400
Subject: [PATCH 2/6] C++: use an optional vec<location_t> for callsites
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This patch extends various call-handling locations within the C++
frontend so that they can accept a possibly NULL vec<location_t> *,
using the location information if available in various diagnostics.

It updates the C++ frontend's parser for this production:

   postfix-expression:
     postfix-expression ( expression-list [opt] )

within cp_parser_postfix_expression so that it captures an
auto_vec<location_t> for the arguments (via
cp_parser_parenthesized_expression_list), and passes that around
within the parser, so that e.g.

  error: invalid conversion from ‘int’ to ‘const char*’ [-fpermissive]
     return callee_1 (first, second, third);
                                          ^

becomes:

  error: invalid conversion from ‘int’ to ‘const char*’ [-fpermissive]
     return callee_1 (first, second, third);
                             ^~~~~~

The vec<location_t> * are also passed to the arg-checking
code of r251238 ( https://gcc.gnu.org/ml/gcc-patches/2017-08/msg01164.html )
so that -Wformat can underline mismatching arguments for C++.

Doing this for C++ requires handling of the case where the vec<location_t>
from the expression-list needs to be offset by 1 relative to the args due
to the "this" parameter not being part of the expression-list, e.g. in:

  logger->log ("%i %s %i", 100, 101, 102);   [1]
                   ^~           ~~~

hence the patch adds a new "argument_locs" class to be responsible for
this in various places in c-family.

[1] We don't yet underline the "%s" in C++; I plan to fix that as a
separate patch.

gcc/c-family/ChangeLog:
	* c-common.c (argument_locs::get_param_location): New method.
	(check_function_arguments): Convert param "arglocs" from
	vec<location_t> * to argument_locs.
	* c-common.h (class argument_locs): New class.
	(check_function_arguments): Convert final param from
	vec<location_t> * to argument_locs.
	(check_function_format): Likewise.
	* c-format.c (struct format_check_results): Add ctor; convert
	field "arglocs" from vec<location_t> * to argument_locs.
	(check_function_format): Convert param "arglocs" from
	vec<location_t> * to argument_locs.
	(check_format_info): Likewise.  Use a ctor when initializing
	format_ctx.
	(check_format_arg): Convert local "arglocs" from vec<location_t> *
	to argument_locs.
	(class argument_parser): Likewise for field "arglocs".
	(argument_parser::argument_parser): Likewise.
	(check_format_info_main): Likewise for param "arglocs".
	(check_format_types): Likewise.  Replace logic for looking up
	locations within arglocs with a call to
	argument_locs::get_param_location.

gcc/c/ChangeLog:
	* c-typeck.c (build_function_call_vec): Update for conversion
	of final parameter of check_function_arguments.

gcc/cp/ChangeLog:
	* call.c (print_z_candidate): Add optional "arglocs" param and
	pass it to fn_type_unification.
	(print_z_candidates): Add optional "arglocs" param and pass it to
	print_z_candidate.
	(print_error_for_call_failure): Add optional "arglocs" param and
	pass it to print_z_candidates.
	(build_new_function_call): Add "arglocs" param and
	pass it to print_error_for_call_failure and build_over_call.
	(convert_like_real): Convert param "expr" from tree to cp_expr.
	(build_over_call): Add optional "arglocs" param.  Use it if
	available when calling convert_like_with_context, by converting
	"arg" to a cp_expr. Use arglocs when calling
	check_function_arguments, determining the appropriate offset to
	use based on whether there was a "first_arg".
	(build_new_method_call_1): Add "arglocs" param and pass it to
	build_over_call.
	(build_new_method_call): Add "arglocs" param and pass it to
	build_new_method_call_1.
	* cp-tree.h (build_new_function_call): Add optional
	vec<location_t> * param.
	(build_new_method_call): Likewise.
	(fn_type_unification): Likewise.
	(finish_call_expr): Likewise.
	(cp_build_function_call_vec): Likewise.
	* parser.c (cp_parser_postfix_expression): Within handling of
	"postfix-expression ( expression-list [opt] )" production, add
	auto_vec<location_t> and pass it to be built to
	cp_parser_parenthesized_expression_list; pass it for use to
	calls to build_new_method_call and finish_call_expr.
	(cp_parser_parenthesized_expression_list): Add optional "arglocs"
	param.  Convert local "expr" to cp_expr, using it to populate
	"arglocs" if non-NULL.
	* pt.c (unify_type_mismatch): Convert final param from tree to
	cp_expr to fix the location of the "inform".
	(unify_arg_conversion): Likewise.
	(fn_type_unification): Add "arglocs" param and pass it to
	type_unification_real.
	(check_non_deducible_conversion): Convert "arg" from tree to
	cp_expr.
	(type_unification_real): Add optional "arglocs" param.
	Convert local "arg" from tree to cp_expr, reading its location
	from arglocs, or, failing that, from input_location.
	* semantics.c (finish_call_expr): Add optional
	vec<location_t> * param and pass to calls to build_new_method_call
	and build_new_function_call.
	* typeck.c (cp_build_function_call_vec): Add optional
	vec<location_t> * param and pass to call to
	check_function_arguments.

gcc/testsuite/ChangeLog:
	* g++.dg/Wformat-on-method.C: New test case.
	* g++.dg/diagnostic/param-type-mismatch.C: Update expected results
	to reflect underlining of pertinent arguments.
---
 gcc/c-family/c-common.c                            | 27 +++++++-
 gcc/c-family/c-common.h                            | 39 ++++++++++-
 gcc/c-family/c-format.c                            | 53 ++++++++-------
 gcc/c/c-typeck.c                                   |  3 +-
 gcc/cp/call.c                                      | 77 ++++++++++++++--------
 gcc/cp/cp-tree.h                                   | 15 +++--
 gcc/cp/parser.c                                    | 30 ++++++---
 gcc/cp/pt.c                                        | 54 ++++++++++-----
 gcc/cp/semantics.c                                 |  9 +--
 gcc/cp/typeck.c                                    |  6 +-
 gcc/testsuite/g++.dg/Wformat-on-method.C           | 31 +++++++++
 .../g++.dg/diagnostic/param-type-mismatch.C        | 18 ++---
 12 files changed, 261 insertions(+), 101 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/Wformat-on-method.C

diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c
index 156c89d..d238064 100644
--- a/gcc/c-family/c-common.c
+++ b/gcc/c-family/c-common.c
@@ -5534,12 +5534,35 @@ attribute_fallthrough_p (tree attr)
 }
 
 
+/* Lookup the location of the argument with 0-based index PARAM_IDX,
+   gracefully failing if data is unavailable, and handling
+   offsetting the index for the case where the "this"
+   wasn't in the expression-list.  */
+
+location_t
+argument_locs::get_param_location (unsigned int param_idx) const
+{
+  if (m_locs == NULL)
+    return UNKNOWN_LOCATION;
+
+  if (param_idx < m_offset)
+    return UNKNOWN_LOCATION;
+
+  param_idx -= m_offset;
+
+  gcc_assert (param_idx < m_locs->length ());
+
+  return (*m_locs)[param_idx];
+}
+
 /* Check for valid arguments being passed to a function with FNTYPE.
    There are NARGS arguments in the array ARGARRAY.  LOC should be used for
-   diagnostics.  Return true if -Wnonnull warning has been diagnosed.  */
+   diagnostics.  Return true if -Wnonnull warning has been diagnosed.
+   ARGLOCS gives the locations of the arguments
+   (if its "locs" is non-NULL).  */
 bool
 check_function_arguments (location_t loc, const_tree fndecl, const_tree fntype,
-			  int nargs, tree *argarray, vec<location_t> *arglocs)
+			  int nargs, tree *argarray, argument_locs arglocs)
 {
   bool warned_p = false;
 
diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
index 8e36768..7a0a5a0 100644
--- a/gcc/c-family/c-common.h
+++ b/gcc/c-family/c-common.h
@@ -807,8 +807,43 @@ extern const char *fname_as_string (int);
 extern tree fname_decl (location_t, unsigned, tree);
 
 extern int check_user_alignment (const_tree, bool);
+
+/* Information about the locations of arguments at a callsite,
+   based on parsing an expression-list.
+
+   A bundle of a (possibly NULL) vec<location_t> *, together with
+   an offset for determining how this vec corresponds to the
+   arguments at a callsite.
+
+   We either have an offset of 0:
+     | argarray[0] | argarray[1] | argarray[2] | ...
+     | m_locs  [0] | m_locs  [1] | m_locs  [2] | ...
+
+   or an offset of 1:
+     | argarray[0] | argarray[1] | argarray[2] | argarray[3]
+     | "this"      | m_locs  [0] | m_locs  [1] | m_locs[2]
+
+   for the C++ cases where the expression-list didn't contain "this",
+   such as in "ptr->call (expr0, expr1, expr2)".  */
+
+class argument_locs
+{
+ public:
+  argument_locs (const vec<location_t> *locs, unsigned int offset)
+  : m_locs (locs), m_offset (offset)
+  {
+    gcc_assert (offset == 0 || offset == 1);
+  }
+
+  location_t get_param_location (unsigned int param_idx) const;
+
+ private:
+  const vec<location_t> *m_locs;
+  unsigned int m_offset;
+};
+
 extern bool check_function_arguments (location_t loc, const_tree, const_tree,
-				      int, tree *, vec<location_t> *);
+				      int, tree *, argument_locs);
 extern void check_function_arguments_recurse (void (*)
 					      (void *, tree,
 					       unsigned HOST_WIDE_INT),
@@ -816,7 +851,7 @@ extern void check_function_arguments_recurse (void (*)
 					      unsigned HOST_WIDE_INT);
 extern bool check_builtin_function_arguments (location_t, vec<location_t>,
 					      tree, int, tree *);
-extern void check_function_format (tree, int, tree *, vec<location_t> *);
+extern void check_function_format (tree, int, tree *, argument_locs);
 extern bool attribute_fallthrough_p (tree);
 extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
 extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
diff --git a/gcc/c-family/c-format.c b/gcc/c-family/c-format.c
index 0dba979..e992a06 100644
--- a/gcc/c-family/c-format.c
+++ b/gcc/c-family/c-format.c
@@ -986,10 +986,16 @@ struct format_check_results
 
 struct format_check_context
 {
+  format_check_context (format_check_results *res_,
+			function_format_info *info_,
+			tree params_,
+			argument_locs arglocs_)
+  : res (res_), info (info_), params (params_), arglocs (arglocs_) {}
+
   format_check_results *res;
   function_format_info *info;
   tree params;
-  vec<location_t> *arglocs;
+  argument_locs arglocs;
 };
 
 /* Return the format name (as specified in the original table) for the format
@@ -1012,8 +1018,7 @@ format_flags (int format_num)
   gcc_unreachable ();
 }
 
-static void check_format_info (function_format_info *, tree,
-			       vec<location_t> *);
+static void check_format_info (function_format_info *, tree, argument_locs);
 static void check_format_arg (void *, tree, unsigned HOST_WIDE_INT);
 static void check_format_info_main (format_check_results *,
 				    function_format_info *, const char *,
@@ -1021,7 +1026,7 @@ static void check_format_info_main (format_check_results *,
 				    int, tree,
 				    unsigned HOST_WIDE_INT,
 				    object_allocator<format_wanted_type> &,
-				    vec<location_t> *);
+				    argument_locs);
 
 static void init_dollar_format_checking (int, tree);
 static int maybe_read_dollar_number (const char **, int,
@@ -1037,7 +1042,7 @@ static void check_format_types (const substring_loc &fmt_loc,
 				const format_kind_info *fki,
 				int offset_to_type_start,
 				char conversion_char,
-				vec<location_t> *arglocs);
+				argument_locs arglocs);
 static void format_type_warning (const substring_loc &fmt_loc,
 				 source_range *param_range,
 				 format_wanted_type *, tree,
@@ -1081,7 +1086,7 @@ decode_format_type (const char *s)
 
 void
 check_function_format (tree attrs, int nargs, tree *argarray,
-		       vec<location_t> *arglocs)
+		       argument_locs arglocs)
 {
   tree a;
 
@@ -1406,9 +1411,8 @@ get_flag_spec (const format_flag_spec *spec, int flag, const char *predicates)
 
 static void
 check_format_info (function_format_info *info, tree params,
-		   vec<location_t> *arglocs)
+		   argument_locs arglocs)
 {
-  format_check_context format_ctx;
   unsigned HOST_WIDE_INT arg_num;
   tree format_tree;
   format_check_results res;
@@ -1437,10 +1441,7 @@ check_format_info (function_format_info *info, tree params,
   res.number_other = 0;
   res.format_string_loc = input_location;
 
-  format_ctx.res = &res;
-  format_ctx.info = info;
-  format_ctx.params = params;
-  format_ctx.arglocs = arglocs;
+  format_check_context format_ctx (&res, info, params, arglocs);
 
   check_function_arguments_recurse (check_format_arg, &format_ctx,
 				    format_tree, arg_num);
@@ -1525,7 +1526,7 @@ check_format_arg (void *ctx, tree format_tree,
   format_check_results *res = format_ctx->res;
   function_format_info *info = format_ctx->info;
   tree params = format_ctx->params;
-  vec<location_t> *arglocs = format_ctx->arglocs;
+  argument_locs arglocs = format_ctx->arglocs;
 
   int format_length;
   HOST_WIDE_INT offset;
@@ -1777,7 +1778,7 @@ class argument_parser
 		   location_t format_string_loc, flag_chars_t &flag_chars,
 		   int &has_operand_number, tree first_fillin_param,
 		   object_allocator <format_wanted_type> &fwt_pool_,
-		   vec<location_t> *arglocs);
+		   argument_locs arglocs);
 
   bool read_any_dollar ();
 
@@ -1856,7 +1857,7 @@ class argument_parser
  private:
   format_wanted_type *first_wanted_type;
   format_wanted_type *last_wanted_type;
-  vec<location_t> *arglocs;
+  argument_locs arglocs;
 };
 
 /* flag_chars_t's constructor.  */
@@ -2008,7 +2009,7 @@ argument_parser (function_format_info *info_, const char *&format_chars_,
 		 int &has_operand_number_,
 		 tree first_fillin_param_,
 		 object_allocator <format_wanted_type> &fwt_pool_,
-		 vec<location_t> *arglocs_)
+		 argument_locs arglocs_)
 : info (info_),
   fki (&format_types[info->format_type]),
   flag_specs (fki->flag_specs),
@@ -2768,7 +2769,7 @@ check_format_info_main (format_check_results *res,
 			int format_length, tree params,
 			unsigned HOST_WIDE_INT arg_num,
 			object_allocator <format_wanted_type> &fwt_pool,
-			vec<location_t> *arglocs)
+			argument_locs arglocs)
 {
   const char * const orig_format_chars = format_chars;
   const tree first_fillin_param = params;
@@ -3046,7 +3047,7 @@ check_format_types (const substring_loc &fmt_loc,
 		    format_wanted_type *types, const format_kind_info *fki,
 		    int offset_to_type_start,
 		    char conversion_char,
-		    vec<location_t> *arglocs)
+		    argument_locs arglocs)
 {
   for (; types != 0; types = types->next)
     {
@@ -3085,22 +3086,24 @@ check_format_types (const substring_loc &fmt_loc,
       char_type_flag = 0;
 
       source_range param_range;
-      source_range *param_range_ptr;
+      source_range *param_range_ptr = NULL;
       if (EXPR_HAS_LOCATION (cur_param))
 	{
 	  param_range = EXPR_LOCATION_RANGE (cur_param);
 	  param_range_ptr = &param_range;
 	}
-      else if (arglocs)
+      else
 	{
 	  /* arg_num is 1-based.  */
 	  gcc_assert (types->arg_num > 0);
-	  location_t param_loc = (*arglocs)[types->arg_num - 1];
-	  param_range = get_range_from_loc (line_table, param_loc);
-	  param_range_ptr = &param_range;
+	  unsigned int param_idx = types->arg_num - 1;
+	  location_t param_loc = arglocs.get_param_location (param_idx);
+	  if (param_loc != UNKNOWN_LOCATION)
+	    {
+	      param_range = get_range_from_loc (line_table, param_loc);
+	      param_range_ptr = &param_range;
+	    }
 	}
-      else
-	param_range_ptr = NULL;
 
       STRIP_NOPS (cur_param);
 
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index d7ca148..5999a3b 100644
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -3118,7 +3118,8 @@ build_function_call_vec (location_t loc, vec<location_t> arg_loc,
 
   /* Check that the arguments to the function are valid.  */
   bool warned_p = check_function_arguments (loc, fundecl, fntype,
-					    nargs, argarray, &arg_loc);
+					    nargs, argarray,
+					    argument_locs (&arg_loc, 0));
 
   if (name != NULL_TREE
       && !strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10))
diff --git a/gcc/cp/call.c b/gcc/cp/call.c
index 067db59a..afcdd99 100644
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -147,7 +147,8 @@ static int equal_functions (tree, tree);
 static int joust (struct z_candidate *, struct z_candidate *, bool,
 		  tsubst_flags_t);
 static int compare_ics (conversion *, conversion *);
-static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
+static tree build_over_call (struct z_candidate *, int, tsubst_flags_t,
+			     vec<location_t> * = NULL);
 #define convert_like(CONV, EXPR, COMPLAIN)			\
   convert_like_real ((CONV), (EXPR), NULL_TREE, 0,		\
 		     /*issue_conversion_warnings=*/true,	\
@@ -156,14 +157,16 @@ static tree build_over_call (struct z_candidate *, int, tsubst_flags_t);
   convert_like_real ((CONV), (EXPR), (FN), (ARGNO),			\
 		     /*issue_conversion_warnings=*/true,		\
 		     /*c_cast_p=*/false, (COMPLAIN))
-static tree convert_like_real (conversion *, tree, tree, int, bool,
+static tree convert_like_real (conversion *, cp_expr, tree, int, bool,
 			       bool, tsubst_flags_t);
 static void op_error (location_t, enum tree_code, enum tree_code, tree,
 		      tree, tree, bool);
 static struct z_candidate *build_user_type_conversion_1 (tree, tree, int,
 							 tsubst_flags_t);
-static void print_z_candidate (location_t, const char *, struct z_candidate *);
-static void print_z_candidates (location_t, struct z_candidate *);
+static void print_z_candidate (location_t, const char *, struct z_candidate *,
+			       vec<location_t> * = NULL);
+static void print_z_candidates (location_t, struct z_candidate *,
+				vec<location_t> * = NULL);
 static tree build_this (tree);
 static struct z_candidate *splice_viable (struct z_candidate *, bool, bool *);
 static bool any_strictly_viable (struct z_candidate *);
@@ -3442,7 +3445,8 @@ print_arity_information (location_t loc, unsigned int have, unsigned int want)
 
 static void
 print_z_candidate (location_t loc, const char *msgstr,
-		   struct z_candidate *candidate)
+		   struct z_candidate *candidate,
+		   vec<location_t> *arglocs)
 {
   const char *msg = (msgstr == NULL
 		     ? ""
@@ -3531,7 +3535,7 @@ print_z_candidate (location_t loc, const char *msgstr,
 			       r->u.template_unification.return_type,
 			       r->u.template_unification.strict,
 			       r->u.template_unification.flags,
-			       true, false);
+			       true, false, arglocs);
 	  break;
 	case rr_invalid_copy:
 	  inform (cloc,
@@ -3560,7 +3564,8 @@ print_z_candidate (location_t loc, const char *msgstr,
 }
 
 static void
-print_z_candidates (location_t loc, struct z_candidate *candidates)
+print_z_candidates (location_t loc, struct z_candidate *candidates,
+		    vec<location_t> *arglocs)
 {
   struct z_candidate *cand1;
   struct z_candidate **cand2;
@@ -3606,7 +3611,7 @@ print_z_candidates (location_t loc, struct z_candidate *candidates)
     }
 
   for (; candidates; candidates = candidates->next)
-    print_z_candidate (loc, "candidate:", candidates);
+    print_z_candidate (loc, "candidate:", candidates, arglocs);
 }
 
 /* USER_SEQ is a user-defined conversion sequence, beginning with a
@@ -4212,7 +4217,8 @@ perform_overload_resolution (tree fn,
 
 static void
 print_error_for_call_failure (tree fn, vec<tree, va_gc> *args,
-			      struct z_candidate *candidates)
+			      struct z_candidate *candidates,
+			      vec<location_t> *arglocs = NULL)
 {
   tree targs = NULL_TREE;
   if (TREE_CODE (fn) == TEMPLATE_ID_EXPR)
@@ -4232,7 +4238,7 @@ print_error_for_call_failure (tree fn, vec<tree, va_gc> *args,
     error_at (loc, "call of overloaded %<%D(%A)%> is ambiguous",
 	      name, build_tree_list_vec (args));
   if (candidates)
-    print_z_candidates (loc, candidates);
+    print_z_candidates (loc, candidates, arglocs);
 }
 
 /* Return an expression for a call to FN (a namespace-scope function,
@@ -4241,7 +4247,8 @@ print_error_for_call_failure (tree fn, vec<tree, va_gc> *args,
 
 tree
 build_new_function_call (tree fn, vec<tree, va_gc> **args,
-			 tsubst_flags_t complain)
+			 tsubst_flags_t complain,
+			 vec<location_t> *arglocs)
 {
   struct z_candidate *candidates, *cand;
   bool any_viable_p;
@@ -4275,7 +4282,7 @@ build_new_function_call (tree fn, vec<tree, va_gc> **args,
 	    return cp_build_function_call_vec (candidates->fn, args, complain);
 
 	  // Otherwise, emit notes for non-viable candidates.
-	  print_error_for_call_failure (fn, *args, candidates);
+	  print_error_for_call_failure (fn, *args, candidates, arglocs);
 	}
       result = error_mark_node;
     }
@@ -4307,7 +4314,7 @@ build_new_function_call (tree fn, vec<tree, va_gc> **args,
           flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
         }
 
-      result = build_over_call (cand, flags, complain);
+      result = build_over_call (cand, flags, complain, arglocs);
     }
 
   /* Free all the conversions we allocated.  */
@@ -6588,14 +6595,16 @@ maybe_print_user_conv_context (conversion *convs)
    conversions to inaccessible bases are permitted.  */
 
 static tree
-convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
+convert_like_real (conversion *convs, cp_expr expr, tree fn, int argnum,
 		   bool issue_conversion_warnings,
 		   bool c_cast_p, tsubst_flags_t complain)
 {
   tree totype = convs->type;
   diagnostic_t diag_kind;
   int flags;
-  location_t loc = EXPR_LOC_OR_LOC (expr, input_location);
+  location_t loc = expr.get_location ();
+  if (loc == UNKNOWN_LOCATION)
+    loc = input_location;
 
   if (convs->bad_p && !(complain & tf_error))
     return error_mark_node;
@@ -6983,13 +6992,13 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
 		   cannot create a temporary.  */
 		if (lvalue & clk_bitfield)
 		  error_at (loc, "cannot bind bitfield %qE to %qT",
-			    expr, ref_type);
+			    expr.get_value (), ref_type);
 		else if (lvalue & clk_packed)
 		  error_at (loc, "cannot bind packed field %qE to %qT",
-			    expr, ref_type);
+			    expr.get_value (), ref_type);
 		else
 		  error_at (loc, "cannot bind rvalue %qE to %qT",
-			    expr, ref_type);
+			    expr.get_value (), ref_type);
 		return error_mark_node;
 	      }
 	    /* If the source is a packed field, and we must use a copy
@@ -7003,7 +7012,7 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
 		&& type_has_nontrivial_copy_init (type))
 	      {
 		error_at (loc, "cannot bind packed field %qE to %qT",
-			  expr, ref_type);
+			  expr.get_value (), ref_type);
 		return error_mark_node;
 	      }
 	    if (lvalue & clk_bitfield)
@@ -7542,7 +7551,8 @@ unsafe_copy_elision_p (tree target, tree exp)
    bitmask of various LOOKUP_* flags which apply to the call itself.  */
 
 static tree
-build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
+build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain,
+		 vec<location_t> *arglocs)
 {
   tree fn = cand->fn;
   const vec<tree, va_gc> *args = cand->args;
@@ -7687,6 +7697,15 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
     nargs = parmlen;
   argarray = XALLOCAVEC (tree, nargs);
 
+  /* Determine offset to args covered by ARGLOCS within argarray.
+     We either have an offset of 0:
+       | argarray[0] | argarray[1] | argarray[2] | ...
+       | arglocs [0] | arglocs [1] | arglocs [2] | ...
+     or an offset of 1:
+       | argarray[0] | argarray[1] | argarray[2] | ...
+       | first_arg   | arglocs [0] | arglocs [1] | arglocs[2] ...*/
+  int arglocs_offset = first_arg != NULL_TREE ? 1 : 0;
+
   /* The implicit parameters to a constructor are not considered by overload
      resolution, and must be of the proper type.  */
   if (DECL_CONSTRUCTOR_P (fn))
@@ -7805,7 +7824,9 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
        parm = TREE_CHAIN (parm), ++arg_index, ++i)
     {
       tree type = TREE_VALUE (parm);
-      tree arg = (*args)[arg_index];
+      cp_expr arg = (*args)[arg_index];
+      if (arglocs)
+	arg.set_location ((*arglocs)[arg_index]);
       bool conversion_warning = true;
 
       conv = convs[i];
@@ -7949,7 +7970,9 @@ build_over_call (struct z_candidate *cand, int flags, tsubst_flags_t complain)
 	fargs[j] = maybe_constant_value (argarray[j]);
 
       warned_p = check_function_arguments (input_location, fn, TREE_TYPE (fn),
-					   nargs, fargs, NULL);
+					   nargs, fargs,
+					   argument_locs (arglocs,
+							  arglocs_offset));
     }
 
   if (DECL_INHERITED_CTOR (fn))
@@ -8917,7 +8940,8 @@ name_as_c_string (tree name, tree type, bool *free_p)
 static tree
 build_new_method_call_1 (tree instance, tree fns, vec<tree, va_gc> **args,
 		         tree conversion_path, int flags,
-		         tree *fn_p, tsubst_flags_t complain)
+		         tree *fn_p, tsubst_flags_t complain,
+			 vec<location_t> *arglocs)
 {
   struct z_candidate *candidates = 0, *cand;
   tree explicit_targs = NULL_TREE;
@@ -9248,7 +9272,7 @@ build_new_method_call_1 (tree instance, tree fns, vec<tree, va_gc> **args,
 	      if (fn_p)
 		*fn_p = fn;
 	      /* Build the actual CALL_EXPR.  */
-	      call = build_over_call (cand, flags, complain);
+	      call = build_over_call (cand, flags, complain, arglocs);
 	      /* In an expression of the form `a->f()' where `f' turns
 		 out to be a static member function, `a' is
 		 none-the-less evaluated.  */
@@ -9313,12 +9337,13 @@ build_new_method_call_1 (tree instance, tree fns, vec<tree, va_gc> **args,
 tree
 build_new_method_call (tree instance, tree fns, vec<tree, va_gc> **args,
 		       tree conversion_path, int flags,
-		       tree *fn_p, tsubst_flags_t complain)
+		       tree *fn_p, tsubst_flags_t complain,
+		       vec<location_t> *arglocs)
 {
   tree ret;
   bool subtime = timevar_cond_start (TV_OVERLOAD);
   ret = build_new_method_call_1 (instance, fns, args, conversion_path, flags,
-                                 fn_p, complain);
+                                 fn_p, complain, arglocs);
   timevar_cond_stop (TV_OVERLOAD, subtime);
   return ret;
 }
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index 4dd9fc6..b1ec172 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -5862,13 +5862,15 @@ extern tree extract_call_expr			(tree);
 extern tree build_user_type_conversion		(tree, tree, int,
 						 tsubst_flags_t);
 extern tree build_new_function_call		(tree, vec<tree, va_gc> **,
-						 tsubst_flags_t);
+						 tsubst_flags_t,
+						 vec<location_t> * = NULL);
 extern tree build_operator_new_call		(tree, vec<tree, va_gc> **,
 						 tree *, tree *, tree, tree,
 						 tree *, tsubst_flags_t);
 extern tree build_new_method_call		(tree, tree,
 						 vec<tree, va_gc> **, tree,
-						 int, tree *, tsubst_flags_t);
+						 int, tree *, tsubst_flags_t,
+						 vec<location_t> * = NULL);
 extern tree build_special_member_call		(tree, tree,
 						 vec<tree, va_gc> **,
 						 tree, int, tsubst_flags_t);
@@ -6433,7 +6435,8 @@ extern tree instantiate_template		(tree, tree, tsubst_flags_t);
 extern tree fn_type_unification			(tree, tree, tree,
 						 const tree *, unsigned int,
 						 tree, unification_kind_t, int,
-						 bool, bool);
+						 bool, bool,
+						 vec<location_t> * = NULL);
 extern void mark_decl_instantiated		(tree, int);
 extern int more_specialized_fn			(tree, tree, int);
 extern void do_decl_instantiation		(tree, tree);
@@ -6720,7 +6723,8 @@ bool empty_expr_stmt_p				(tree);
 extern cp_expr perform_koenig_lookup		(cp_expr, vec<tree, va_gc> *,
 						 tsubst_flags_t);
 extern tree finish_call_expr			(tree, vec<tree, va_gc> **, bool,
-						 bool, tsubst_flags_t);
+						 bool, tsubst_flags_t,
+						 vec<location_t> * = NULL);
 extern tree lookup_and_finish_template_variable (tree, tree, tsubst_flags_t = tf_warning_or_error);
 extern tree finish_template_variable		(tree, tsubst_flags_t = tf_warning_or_error);
 extern cp_expr finish_increment_expr		(cp_expr, enum tree_code);
@@ -7026,7 +7030,8 @@ extern tree get_member_function_from_ptrfunc	(tree *, tree, tsubst_flags_t);
 extern tree cp_build_function_call_nary         (tree, tsubst_flags_t, ...)
 						ATTRIBUTE_SENTINEL;
 extern tree cp_build_function_call_vec		(tree, vec<tree, va_gc> **,
-						 tsubst_flags_t);
+						 tsubst_flags_t,
+						 vec<location_t> * = NULL);
 extern tree build_x_binary_op			(location_t,
 						 enum tree_code, tree,
 						 enum tree_code, tree,
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c
index b849824..29de054 100644
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -2051,7 +2051,8 @@ static tree cp_parser_postfix_open_square_expression
 static tree cp_parser_postfix_dot_deref_expression
   (cp_parser *, enum cpp_ttype, cp_expr, bool, cp_id_kind *, location_t);
 static vec<tree, va_gc> *cp_parser_parenthesized_expression_list
-  (cp_parser *, int, bool, bool, bool *, location_t * = NULL);
+  (cp_parser *, int, bool, bool, bool *, location_t * = NULL,
+   vec<location_t> * = NULL);
 /* Values for the second parameter of cp_parser_parenthesized_expression_list.  */
 enum { non_attr = 0, normal_attr = 1, id_attr = 2 };
 static void cp_parser_pseudo_destructor_name
@@ -6961,6 +6962,7 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
 	    bool saved_non_integral_constant_expression_p = false;
 	    tsubst_flags_t complain = complain_flags (decltype_p);
 	    vec<tree, va_gc> *args;
+	    auto_vec<location_t> arglocs;
 	    location_t close_paren_loc = UNKNOWN_LOCATION;
 
             is_member_access = false;
@@ -6981,7 +6983,8 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
 		    (parser, non_attr,
 		     /*cast_p=*/false, /*allow_expansion_p=*/true,
 		     /*non_constant_p=*/NULL,
-		     /*close_paren_loc=*/&close_paren_loc));
+		     /*close_paren_loc=*/&close_paren_loc,
+		     &arglocs));
 	    if (is_builtin_constant_p)
 	      {
 		parser->integral_constant_expression_p
@@ -7092,14 +7095,16 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
 			 ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
 			 : LOOKUP_NORMAL),
 			/*fn_p=*/NULL,
-			complain));
+			complain,
+			&arglocs));
 		  }
 		else
 		  postfix_expression
 		    = finish_call_expr (postfix_expression, &args,
 					/*disallow_virtual=*/false,
 					/*koenig_p=*/false,
-					complain);
+					complain,
+					&arglocs);
 	      }
 	    else if (TREE_CODE (postfix_expression) == OFFSET_REF
 		     || TREE_CODE (postfix_expression) == MEMBER_REF
@@ -7114,14 +7119,16 @@ cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p,
 		= finish_call_expr (postfix_expression, &args,
 				    /*disallow_virtual=*/true,
 				    koenig_p,
-				    complain);
+				    complain,
+				    &arglocs);
 	    else
 	      /* All other function calls.  */
 	      postfix_expression
 		= finish_call_expr (postfix_expression, &args,
 				    /*disallow_virtual=*/false,
 				    koenig_p,
-				    complain);
+				    complain,
+				    &arglocs);
 
 	    if (close_paren_loc != UNKNOWN_LOCATION)
 	      {
@@ -7637,7 +7644,8 @@ cp_parser_parenthesized_expression_list (cp_parser* parser,
 					 bool cast_p,
                                          bool allow_expansion_p,
 					 bool *non_constant_p,
-					 location_t *close_paren_loc)
+					 location_t *close_paren_loc,
+					 vec<location_t> *arglocs)
 {
   vec<tree, va_gc> *expression_list;
   bool fold_expr_p = is_attribute_list != non_attr;
@@ -7664,8 +7672,6 @@ cp_parser_parenthesized_expression_list (cp_parser* parser,
   if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN))
     while (true)
       {
-	tree expr;
-
 	/* At the beginning of attribute lists, check to see if the
 	   next token is an identifier.  */
 	if (is_attribute_list == id_attr
@@ -7680,6 +7686,7 @@ cp_parser_parenthesized_expression_list (cp_parser* parser,
 	  }
 	else
 	  {
+	    cp_expr expr;
 	    bool expr_non_constant_p;
 
 	    /* Parse the next assignment-expression.  */
@@ -7723,7 +7730,10 @@ cp_parser_parenthesized_expression_list (cp_parser* parser,
 		expressions to the list, so that we can still tell if
 		the correct form for a parenthesized expression-list
 		is found. That gives better errors.  */
-	    vec_safe_push (expression_list, expr);
+	    vec_safe_push (expression_list, expr.get_value ());
+
+	    if (arglocs)
+	      arglocs->safe_push (expr.get_location ());
 
 	    if (expr == error_mark_node)
 	      goto skip_comma;
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c
index 8d816c7..c642077 100644
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -155,7 +155,8 @@ static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*,
 static int type_unification_real (tree, tree, tree, const tree *,
 				  unsigned int, int, unification_kind_t, int,
 				  vec<deferred_access_check, va_gc> **,
-				  bool);
+				  bool,
+				  vec<location_t> * = NULL);
 static void note_template_header (int);
 static tree convert_nontype_argument_function (tree, tree, tsubst_flags_t);
 static tree convert_nontype_argument (tree, tree, tsubst_flags_t);
@@ -6191,10 +6192,16 @@ unify_cv_qual_mismatch (bool explain_p, tree parm, tree arg)
 }
 
 static int
-unify_type_mismatch (bool explain_p, tree parm, tree arg)
+unify_type_mismatch (bool explain_p, tree parm, cp_expr arg)
 {
   if (explain_p)
-    inform (input_location, "  mismatched types %qT and %qT", parm, arg);
+    {
+      location_t loc = arg.get_location ();
+      if (loc == UNKNOWN_LOCATION)
+	loc = input_location;
+      inform (loc, "  mismatched types %qT and %qT", parm,
+	      arg.get_value ());
+    }
   return unify_invalid (explain_p);
 }
 
@@ -6310,12 +6317,17 @@ unify_too_few_arguments (bool explain_p, int have, int wanted,
 
 static int
 unify_arg_conversion (bool explain_p, tree to_type,
-		      tree from_type, tree arg)
+		      tree from_type, cp_expr arg)
 {
   if (explain_p)
-    inform (EXPR_LOC_OR_LOC (arg, input_location),
-	    "  cannot convert %qE (type %qT) to type %qT",
-	    arg, from_type, to_type);
+    {
+      location_t loc = arg.get_location ();
+      if (loc == UNKNOWN_LOCATION)
+	loc = input_location;
+      inform (loc,
+	      "  cannot convert %qE (type %qT) to type %qT",
+	      arg.get_value (), from_type, to_type);
+    }
   return unify_invalid (explain_p);
 }
 
@@ -18416,7 +18428,8 @@ fn_type_unification (tree fn,
 		     unification_kind_t strict,
 		     int flags,
 		     bool explain_p,
-		     bool decltype_p)
+		     bool decltype_p,
+		     vec<location_t> *arglocs)
 {
   tree parms;
   tree fntype;
@@ -18625,7 +18638,7 @@ fn_type_unification (tree fn,
 
   ok = !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn),
 			       full_targs, parms, args, nargs, /*subr=*/0,
-			       strict, flags, &checks, explain_p);
+			       strict, flags, &checks, explain_p, arglocs);
   if (!explain_p)
     pop_tinst_level ();
   if (!ok)
@@ -18860,7 +18873,7 @@ maybe_adjust_types_for_deduction (unification_kind_t strict,
    unify_one_argument.  */
 
 static int
-check_non_deducible_conversion (tree parm, tree arg, int strict,
+check_non_deducible_conversion (tree parm, cp_expr arg, int strict,
 				int flags, bool explain_p)
 {
   tree type;
@@ -18882,7 +18895,7 @@ check_non_deducible_conversion (tree parm, tree arg, int strict,
   else if (strict != DEDUCE_EXACT)
     {
       if (can_convert_arg (parm, type,
-			   TYPE_P (arg) ? NULL_TREE : arg,
+			   TYPE_P (arg) ? NULL_TREE : arg.get_value (),
 			   flags, explain_p ? tf_warning_or_error : tf_none))
 	return unify_success (explain_p);
     }
@@ -19187,9 +19200,10 @@ type_unification_real (tree tparms,
 		       unification_kind_t strict,
 		       int flags,
 		       vec<deferred_access_check, va_gc> **checks,
-		       bool explain_p)
+		       bool explain_p,
+		       vec<location_t> *arglocs)
 {
-  tree parm, arg;
+  tree parm;
   int i;
   int ntparms = TREE_VEC_LENGTH (tparms);
   int saw_undeduced = 0;
@@ -19235,7 +19249,12 @@ type_unification_real (tree tparms,
 	   parameter pack is a non-deduced context.  */
 	continue;
 
-      arg = args[ia];
+      cp_expr arg = args[ia];
+      if (arglocs)
+	arg.set_location ((*arglocs)[ia]);
+      else
+	if (!CAN_HAVE_LOCATION_P (arg.get_value ()))
+	  arg.set_location (input_location);
       ++ia;
 
       if (unify_one_argument (tparms, full_targs, parm, arg, subr, strict,
@@ -19398,7 +19417,12 @@ type_unification_real (tree tparms,
 		 parameter pack is a non-deduced context.  */
 	      continue;
 
-	    arg = args[ia];
+	    cp_expr arg = args[ia];
+	    if (arglocs)
+	      arg.set_location ((*arglocs)[ia]);
+	    else
+	      if (!CAN_HAVE_LOCATION_P (arg.get_value ()))
+		arg.set_location (input_location);
 	    ++ia;
 
 	    if (uses_template_parms (parm))
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c
index 5401e78..d58eef2 100644
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -2304,7 +2304,8 @@ perform_koenig_lookup (cp_expr fn, vec<tree, va_gc> *args,
 
 tree
 finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
-		  bool koenig_p, tsubst_flags_t complain)
+		  bool koenig_p, tsubst_flags_t complain,
+		  vec<location_t> *arglocs)
 {
   tree result;
   tree orig_fn;
@@ -2388,7 +2389,7 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
                                          ? LOOKUP_NORMAL | LOOKUP_NONVIRTUAL
 					 : LOOKUP_NORMAL),
 					/*fn_p=*/NULL,
-					complain);
+					complain, arglocs);
 	}
     }
 
@@ -2440,7 +2441,7 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
 				       ? LOOKUP_NORMAL|LOOKUP_NONVIRTUAL
 				       : LOOKUP_NORMAL),
 				      /*fn_p=*/NULL,
-				      complain);
+				      complain, arglocs);
     }
   else if (is_overloaded_fn (fn))
     {
@@ -2483,7 +2484,7 @@ finish_call_expr (tree fn, vec<tree, va_gc> **args, bool disallow_virtual,
 	    }
 
 	  /* A call to a namespace-scope function.  */
-	  result = build_new_function_call (fn, args, complain);
+	  result = build_new_function_call (fn, args, complain, arglocs);
 	}
     }
   else if (TREE_CODE (fn) == PSEUDO_DTOR_EXPR)
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c
index 63667f3..3c8ef7a3 100644
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -3577,7 +3577,8 @@ cp_build_function_call_nary (tree function, tsubst_flags_t complain, ...)
 
 tree
 cp_build_function_call_vec (tree function, vec<tree, va_gc> **params,
-			    tsubst_flags_t complain)
+			    tsubst_flags_t complain,
+			    vec<location_t> *arglocs)
 {
   tree fntype, fndecl;
   int is_method;
@@ -3699,7 +3700,8 @@ cp_build_function_call_vec (tree function, vec<tree, va_gc> **params,
   /* Check for errors in format strings and inappropriately
      null parameters.  */
   bool warned_p = check_function_arguments (input_location, fndecl, fntype,
-					    nargs, argarray, NULL);
+					    nargs, argarray,
+					    argument_locs (arglocs, 0));
 
   ret = build_cxx_call (function, nargs, argarray, complain);
 
diff --git a/gcc/testsuite/g++.dg/Wformat-on-method.C b/gcc/testsuite/g++.dg/Wformat-on-method.C
new file mode 100644
index 0000000..4ff22fb
--- /dev/null
+++ b/gcc/testsuite/g++.dg/Wformat-on-method.C
@@ -0,0 +1,31 @@
+/* { dg-options "-Wformat -fdiagnostics-show-caret" } */
+
+struct logger
+{
+  void log (const char *fmt, ...)
+    __attribute__ ((format (gnu_printf, (2), (3))));
+
+  void test ();
+};
+
+/* Test of location-lookup within method call.  */
+
+void test (logger *logger)
+{
+  logger->log ("%i %s %i", 100, 101, 102); /* { dg-warning "format '%s' expects argument of type 'char\\*', but argument 4 has type 'int'" } */
+/* { dg-begin-multiline-output "" }
+   logger->log ("%i %s %i", 100, 101, 102);
+                                 ~~~     ^
+   { dg-end-multiline-output "" } */
+}
+
+/* Test of location-lookup with implicit "this".  */
+
+void logger::test ()
+{
+  log ("%i %s %i", 100, 101, 102); /* { dg-warning "format '%s' expects argument of type 'char\\*', but argument 4 has type 'int'" } */
+/* { dg-begin-multiline-output "" }
+   log ("%i %s %i", 100, 101, 102);
+                         ~~~     ^
+   { dg-end-multiline-output "" } */
+}
diff --git a/gcc/testsuite/g++.dg/diagnostic/param-type-mismatch.C b/gcc/testsuite/g++.dg/diagnostic/param-type-mismatch.C
index b8833ef..f9f5d74 100644
--- a/gcc/testsuite/g++.dg/diagnostic/param-type-mismatch.C
+++ b/gcc/testsuite/g++.dg/diagnostic/param-type-mismatch.C
@@ -17,7 +17,7 @@ int test_1 (int first, int second, float third)
   return callee_1 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return callee_1 (first, second, third);
-                                        ^
+                           ^~~~~~
      { dg-end-multiline-output "" } */
   // { dg-message "initializing argument 2 of 'int callee_1\\(int, const char\\*, float\\)'" "" { target *-*-* } callee_1 }
   /* { dg-begin-multiline-output "" }
@@ -35,7 +35,7 @@ int test_2 (int first, int second, float third)
   return callee_2 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return callee_2 (first, second, third);
-                                        ^
+                           ^~~~~~
      { dg-end-multiline-output "" } */
   // { dg-message "initializing argument 2 of 'int callee_2\\(int, const char\\*, float\\)'" "" { target *-*-* } callee_2 }
   /* { dg-begin-multiline-output "" }
@@ -56,7 +56,7 @@ int test_3 (int first, int second, float third)
   return callee_3 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return callee_3 (first, second, third);
-                                        ^
+                           ^~~~~~
      { dg-end-multiline-output "" } */
   // { dg-message "initializing argument 2 of 'int callee_3\\(int, const char\\*, float\\)'" "" { target *-*-* } callee_3 }
   /* { dg-begin-multiline-output "" }
@@ -74,7 +74,7 @@ int test_4 (int first, int second, float third)
   return s4::member_1 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return s4::member_1 (first, second, third);
-                                            ^
+                               ^~~~~~
      { dg-end-multiline-output "" } */
   /* { dg-begin-multiline-output "" }
  struct s4 { static int member_1 (int one, const char *two, float three); };
@@ -92,7 +92,7 @@ int test_5 (int first, int second, float third)
   return inst.member_1 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return inst.member_1 (first, second, third);
-                                             ^
+                                ^~~~~~
      { dg-end-multiline-output "" } */
   /* { dg-begin-multiline-output "" }
  struct s5 { int member_1 (int one, const char *two, float three); };
@@ -109,7 +109,7 @@ int test_6 (int first, int second, float third, s6 *ptr)
   return ptr->member_1 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return ptr->member_1 (first, second, third);
-                                             ^
+                                ^~~~~~
      { dg-end-multiline-output "" } */
   /* { dg-begin-multiline-output "" }
  struct s6 { int member_1 (int one, const char *two, float three); };
@@ -131,7 +131,7 @@ int test_7 (int first, int second, float third)
      { dg-end-multiline-output "" } */
   /* { dg-begin-multiline-output "" }
    return test_7 <const char *> (first, second, third);
-                                                     ^
+                                        ^~~~~~
      { dg-end-multiline-output "" } */
   /* { dg-begin-multiline-output "" }
  int test_7 (int one, T two, float three);
@@ -149,7 +149,7 @@ int test_8 (int first, int second, float third)
   return s8 <const char *>::member_1 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return s8 <const char *>::member_1 (first, second, third);
-                                                           ^
+                                              ^~~~~~
      { dg-end-multiline-output "" } */
   /* { dg-begin-multiline-output "" }
  struct s8 { static int member_1 (int one, T two, float three); };
@@ -168,7 +168,7 @@ int test_9 (int first, int second, float third)
   return inst.member_1 (first, second, third); // { dg-error "invalid conversion from 'int' to 'const char\\*'" }
   /* { dg-begin-multiline-output "" }
    return inst.member_1 (first, second, third);
-                                             ^
+                                ^~~~~~
      { dg-end-multiline-output "" } */
   /* { dg-begin-multiline-output "" }
  struct s9 { int member_1 (int one, T two, float three); };
-- 
1.8.5.3

