[4.8] Backport additional diagnostic support

Squashed commit of r198331, r198900, r201467,
and r201574 from trunk.

Change-Id: If0d68971ffac2e7bc48576e2453d799a446f7415

14 files changed, 360 insertions, 255 deletions

diff --git a/gcc-4.8/ChangeLog.backported b/gcc-4.8/ChangeLog.backported
index 4900ff936..0b025f682 100644
--- a/gcc-4.8/ChangeLog.backported
+++ b/gcc-4.8/ChangeLog.backported
@@ -7,6 +7,86 @@ http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=201780
     use fallthru edge from it and give up if there is none.
     Release conds vector when returning early.
 
+http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=201574
+2013-08-07  Eric Botcazou  <ebotcazou@adacore.com>
+
+    * diagnostic.c (diagnostic_classify_diagnostic): Accept zero index and
+    document its semantics.
+    (diagnostic_report_diagnostic): Adjust accordingly.
+    * gnat.dg/warn9.adb: New test.
+
+http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=201467
+2013-08-03  Gabriel Dos Reis  <gdr@integrable-solutions.net>
+
+    * pretty-print.h (pp_underscore): New.
+    (pp_comma): Tidy.
+    * gimple-pretty-print.c (dump_unary_rhs): Use specialized pretty
+    printer functions instead of pp_character.
+    (dump_binary_rhs): Likewise.
+    (dump_ternary_rhs): Likewise.
+    (dump_gimple_call_args): Likewise.
+    (pp_points_to_solution): Likewise.
+    (dump_gimple_call): Likewise.
+    (dump_gimple_switch): Likewise.
+    (dump_gimple_cond): Likewise.
+    (dump_gimple_bind): Likewise.
+    (dump_gimple_try): Likewise.
+    (dump_gimple_omp_for): Likewise.
+    (dump_gimple_omp_continue): Likewise.
+    (dump_gimple_omp_single): Likewise.
+    (dump_gimple_omp_sections): Likewise.
+    (dump_gimple_omp_block): Likewise.
+    (dump_gimple_omp_critical): Likewise.
+    (dump_gimple_transaction): Likewise.
+    (dump_gimple_asm): Likewise.
+    (dump_gimple_phi): Likewise.
+    (dump_gimple_omp_parallel): Likewise.
+    (dump_gimple_omp_task): Likewise.
+    (dump_gimple_omp_atomic_load): Likewise.
+    (dump_gimple_omp_atomic_store): Likewise.
+    (dump_gimple_mem_ops): Likewise.
+    (pp_gimple_stmt_1): Likewise.
+    (pp_cfg_jump): Likewise.
+    (dump_implicit_edges): Likewise.
+    (gimple_dump_bb_for_graph): Likewise.
+    * graph.c (draw_cfg_node): Likewise.
+    * langhooks.c (lhd_print_error_function): Likewise.
+    * sched-vis.c (print_exp): Likewise.
+    (print_value): Likewise.
+    (print_pattern): Likewise.
+    (print_insn): Likewise.
+    (rtl_dump_bb_for_graph): Likewise.
+    * tree-pretty-print.c (dump_function_declaration): Likewise.
+    (dump_array_domain): Likewise.
+    (dump_omp_clause): Likewise.
+    (dump_location): Likewise.
+    (dump_generic_node): Likewise.
+    (print_struct_decl): Likewise.
+    * diagnostic.c (diagnostic_show_locus): Use pp_space.
+    * c-ada-spec.c (print_ada_macros): Use specialized pretty printer
+    functions instead of pp_character.
+    (pp_ada_tree_identifier): Likewise.
+    (dump_ada_double_name): Likewise.
+    (dump_ada_function_declaration): Likewise.
+    (dump_ada_array_domains): Likewise.
+    (dump_template_types): Likewise.
+    (dump_generic_ada_node): Likewise.
+    (print_ada_declaration): Likewise.
+    (print_ada_struct_decl): Likewise.
+    * c-pretty-print.c (pp_c_integer_constant): Likewise.
+    * error.c (dump_aggr_type): Use specialized pretty printer
+    functions instead of pp_character.
+    (dump_type_prefix): Likewise.
+    (dump_simple_decl): Likewise.
+    (type_to_string): Likewise.
+
+http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=198900
+2013-05-14  Jakub Jelinek  <jakub@redhat.com>
+
+    * tree.c (warn_deprecated_use): Print file:line using locus color.
+    * diagnostic.c (diagnostic_report_current_module): Print file:line
+    and file:line:column using locus color.
+
 http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=198332
 2013-04-26  Jakub Jelinek  <jakub@redhat.com>
 
@@ -26,6 +106,16 @@ http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=198332
     the string as locus.
     * langhooks.c (lhd_print_error_function): Adjust caller.
 
+http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=198331
+2013-04-26  Jakub Jelinek  <jakub@redhat.com>
+
+    * diagnostic.h (file_name_as_prefix): Add context argument.
+    * diagnostic.c (file_name_as_prefix): Likewise.  Colorize
+    the string as locus.
+    * langhooks.c (lhd_print_error_function): Adjust caller.
+    * error.c (cp_print_error_function): Adjust file_name_as_prefix
+    caller.
+
 http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=197841
 http://gcc.gnu.org/viewcvs/gcc?view=rev&rev=197842
 2013-04-12  Manuel López-Ibáñez  <manu@gcc.gnu.org>
diff --git a/gcc-4.8/gcc/c-family/c-ada-spec.c b/gcc-4.8/gcc/c-family/c-ada-spec.c
index 21cbfe94f..1d0fcd205 100644
--- a/gcc-4.8/gcc/c-family/c-ada-spec.c
+++ b/gcc-4.8/gcc/c-family/c-ada-spec.c
@@ -418,7 +418,7 @@ print_ada_macros (pretty_printer *pp, cpp_hashnode **macros, int max_ada_macros)
 
 	  pp_string (pp, ";  --  ");
 	  pp_string (pp, sloc.file);
-	  pp_character (pp, ':');
+	  pp_colon (pp);
 	  pp_scalar (pp, "%d", sloc.line);
 	  pp_newline (pp);
 	}
@@ -1253,7 +1253,7 @@ pp_ada_tree_identifier (pretty_printer *buffer, tree node, tree type,
 			{
 			  append_withs (s1, limited_access);
 			  pp_string (buffer, s1);
-			  pp_character (buffer, '.');
+			  pp_dot (buffer);
 			}
 		      free (s1);
 		    }
@@ -1375,7 +1375,7 @@ dump_ada_double_name (pretty_printer *buffer, tree t1, tree t2, const char *s)
       pp_scalar (buffer, "%d", TYPE_UID (TREE_TYPE (t1)));
     }
 
-  pp_character (buffer, '_');
+  pp_underscore (buffer);
 
   if (DECL_NAME (t1))
     pp_ada_tree_identifier (buffer, DECL_NAME (t2), t2, false);
@@ -1489,7 +1489,7 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
   if (num_args > 0)
     {
       pp_space (buffer);
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
     }
 
   if (TREE_CODE (func) == FUNCTION_DECL)
@@ -1550,7 +1550,7 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
 
       if (num < num_args)
 	{
-	  pp_character (buffer, ';');
+	  pp_semicolon (buffer);
 
 	  if (num_args > 2)
 	    newline_and_indent (buffer, spc + INDENT_INCR);
@@ -1566,7 +1566,7 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func,
     }
 
   if (num_args > 0)
-    pp_character (buffer, ')');
+    pp_right_paren (buffer);
   return num_args;
 }
 
@@ -1577,7 +1577,7 @@ static void
 dump_ada_array_domains (pretty_printer *buffer, tree node, int spc)
 {
   int first = 1;
-  pp_character (buffer, '(');
+  pp_left_paren (buffer);
 
   for (; TREE_CODE (node) == ARRAY_TYPE; node = TREE_TYPE (node))
     {
@@ -1606,7 +1606,7 @@ dump_ada_array_domains (pretty_printer *buffer, tree node, int spc)
       else
 	pp_string (buffer, "size_t");
     }
-  pp_character (buffer, ')');
+  pp_right_paren (buffer);
 }
 
 /* Dump in BUFFER file:line information related to NODE.  */
@@ -1706,7 +1706,7 @@ dump_template_types (pretty_printer *buffer, tree types,
   for (i = 0; i < len; i++)
     {
       tree elem = TREE_VEC_ELT (types, i);
-      pp_character (buffer, '_');
+      pp_underscore (buffer);
       if (!dump_generic_ada_node (buffer, elem, 0, cpp_check, spc, false, true))
 	{
 	  pp_string (buffer, "unknown");
@@ -2215,7 +2215,7 @@ dump_generic_ada_node (pretty_printer *buffer, tree node, tree type,
 
 	  if (tree_int_cst_sgn (val) < 0)
 	    {
-	      pp_character (buffer, '-');
+	      pp_minus (buffer);
 	      high = ~high + !low;
 	      low = -low;
 	    }
@@ -2986,7 +2986,7 @@ print_ada_declaration (pretty_printer *buffer, tree t, tree type,
  	  dump_generic_ada_node
 	    (buffer, TYPE_NAME (TREE_TYPE (t)), type, cpp_check,
 	     spc, false, true);
-  	  pp_character (buffer, ')');
+  	  pp_right_paren (buffer);
 
 	  print_ada_methods (buffer, TREE_TYPE (t), cpp_check, spc);
 	}
@@ -3226,7 +3226,7 @@ print_ada_struct_decl (pretty_printer *buffer, tree node, tree type,
   dump_generic_ada_node
     (buffer, TREE_TYPE (type), type, cpp_check, spc, false, true);
   package_prefix = true;
-  pp_character (buffer, ')');
+  pp_right_paren (buffer);
 
   if (is_union)
     {
@@ -3236,7 +3236,7 @@ print_ada_struct_decl (pretty_printer *buffer, tree node, tree type,
 
       dump_generic_ada_node
 	(buffer, TREE_TYPE (type), type, cpp_check, spc, false, true);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
     }
 
   if (bitfield_used)
@@ -3246,7 +3246,7 @@ print_ada_struct_decl (pretty_printer *buffer, tree node, tree type,
       pp_string (buffer, "pragma Pack (");
       dump_generic_ada_node
 	(buffer, TREE_TYPE (type), type, cpp_check, spc, false, true);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       bitfield_used = false;
     }
 
diff --git a/gcc-4.8/gcc/c-family/c-pretty-print.c b/gcc-4.8/gcc/c-family/c-pretty-print.c
index 13dd613d8..acfd165ca 100644
--- a/gcc-4.8/gcc/c-family/c-pretty-print.c
+++ b/gcc-4.8/gcc/c-family/c-pretty-print.c
@@ -920,7 +920,7 @@ pp_c_integer_constant (c_pretty_printer *pp, tree i)
       HOST_WIDE_INT high = TREE_INT_CST_HIGH (i);
       if (tree_int_cst_sgn (i) < 0)
 	{
-	  pp_character (pp, '-');
+	  pp_minus (pp);
 	  high = ~high + !low;
 	  low = -low;
 	}
diff --git a/gcc-4.8/gcc/cp/error.c b/gcc-4.8/gcc/cp/error.c
index a35258748..1344f2bb7 100644
--- a/gcc-4.8/gcc/cp/error.c
+++ b/gcc-4.8/gcc/cp/error.c
@@ -663,7 +663,7 @@ dump_aggr_type (tree t, int flags)
       if (lambda_function (t))
 	dump_parameters (FUNCTION_FIRST_USER_PARMTYPE (lambda_function (t)),
 			 flags);
-      pp_character(cxx_pp, '>');
+      pp_greater (cxx_pp);
     }
   else
     pp_cxx_tree_identifier (cxx_pp, name);
@@ -710,13 +710,13 @@ dump_type_prefix (tree t, int flags)
 				     TYPE_ATTRIBUTES (sub));
 	  }
 	if (TREE_CODE (t) == POINTER_TYPE)
-	  pp_character(cxx_pp, '*');
+	  pp_star (cxx_pp);
 	else if (TREE_CODE (t) == REFERENCE_TYPE)
 	{
 	  if (TYPE_REF_IS_RVALUE (t))
 	    pp_string (cxx_pp, "&&");
 	  else
-	    pp_character (cxx_pp, '&');
+	    pp_ampersand (cxx_pp);
 	}
 	pp_base (cxx_pp)->padding = pp_before;
 	pp_cxx_cv_qualifier_seq (cxx_pp, t);
@@ -2813,7 +2813,7 @@ type_to_string (tree typ, int verbose)
       /* And remember the start of the aka dump.  */
       aka_start = obstack_object_size (ob);
       dump_type (aka, flags);
-      pp_character (cxx_pp, '}');
+      pp_right_brace (cxx_pp);
       p = (char*)obstack_base (ob);
       /* If they are identical, cut off the aka with a NUL.  */
       if (memcmp (p, p+aka_start, len) == 0)
@@ -2936,7 +2936,7 @@ cp_print_error_function (diagnostic_context *context,
       const char *file = LOCATION_FILE (diagnostic->location);
       tree abstract_origin = diagnostic_abstract_origin (diagnostic);
       char *new_prefix = (file && abstract_origin == NULL)
-			 ? file_name_as_prefix (file) : NULL;
+			 ? file_name_as_prefix (context, file) : NULL;
 
       pp_base_set_prefix (context->printer, new_prefix);
 
diff --git a/gcc-4.8/gcc/diagnostic.c b/gcc-4.8/gcc/diagnostic.c
index 46986ca64..0acec5832 100644
--- a/gcc-4.8/gcc/diagnostic.c
+++ b/gcc-4.8/gcc/diagnostic.c
@@ -72,9 +72,12 @@ build_message_string (const char *msg, ...)
 
 /* Same as diagnostic_build_prefix, but only the source FILE is given.  */
 char *
-file_name_as_prefix (const char *f)
+file_name_as_prefix (diagnostic_context *context, const char *f)
 {
-  return build_message_string ("%s: ", f);
+  const char *locus_cs
+    = colorize_start (pp_show_color (context->printer), "locus");
+  const char *locus_ce = colorize_stop (pp_show_color (context->printer));
+  return build_message_string ("%s%s:%s ", locus_cs, f, locus_ce);
 }
 
 
@@ -303,7 +306,7 @@ diagnostic_show_locus (diagnostic_context * context,
   pp_newline (context->printer);
   saved_prefix = pp_get_prefix (context->printer);
   pp_set_prefix (context->printer, NULL);
-  pp_character (context->printer, ' ');
+  pp_space (context->printer);
   while (max_width > 0 && *line != '\0')
     {
       char c = *line == '\t' ? ' ' : *line;
@@ -514,18 +517,18 @@ diagnostic_report_current_module (diagnostic_context *context, location_t where)
 	  map = INCLUDED_FROM (line_table, map);
 	  if (context->show_column)
 	    pp_verbatim (context->printer,
-			 "In file included from %s:%d:%d",
+			 "In file included from %r%s:%d:%d%R", "locus",
 			 LINEMAP_FILE (map),
 			 LAST_SOURCE_LINE (map), LAST_SOURCE_COLUMN (map));
 	  else
 	    pp_verbatim (context->printer,
-			 "In file included from %s:%d",
+			 "In file included from %r%s:%d%R", "locus",
 			 LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
 	  while (! MAIN_FILE_P (map))
 	    {
 	      map = INCLUDED_FROM (line_table, map);
 	      pp_verbatim (context->printer,
-			   ",\n                 from %s:%d",
+			   ",\n                 from %r%s:%d%R", "locus",
 			   LINEMAP_FILE (map), LAST_SOURCE_LINE (map));
 	    }
 	  pp_verbatim (context->printer, ":");
@@ -551,7 +554,8 @@ default_diagnostic_finalizer (diagnostic_context *context ATTRIBUTE_UNUSED,
 
 /* Interface to specify diagnostic kind overrides.  Returns the
    previous setting, or DK_UNSPECIFIED if the parameters are out of
-   range.  */
+   range.  If OPTION_INDEX is zero, the new setting is for all the
+   diagnostics.  */
 diagnostic_t
 diagnostic_classify_diagnostic (diagnostic_context *context,
 				int option_index,
@@ -560,7 +564,7 @@ diagnostic_classify_diagnostic (diagnostic_context *context,
 {
   diagnostic_t old_kind;
 
-  if (option_index <= 0
+  if (option_index < 0
       || option_index >= context->n_opts
       || new_kind >= DK_LAST_DIAGNOSTIC_KIND)
     return DK_UNSPECIFIED;
@@ -692,9 +696,8 @@ diagnostic_report_diagnostic (diagnostic_context *context,
       /* This tests for #pragma diagnostic changes.  */
       if (context->n_classification_history > 0)
 	{
-	  int i;
 	  /* FIXME: Stupid search.  Optimize later. */
-	  for (i = context->n_classification_history - 1; i >= 0; i --)
+	  for (int i = context->n_classification_history - 1; i >= 0; i --)
 	    {
 	      if (linemap_location_before_p
 		  (line_table,
@@ -706,7 +709,9 @@ diagnostic_report_diagnostic (diagnostic_context *context,
 		      i = context->classification_history[i].option;
 		      continue;
 		    }
-		  if (context->classification_history[i].option == diagnostic->option_index)
+		  int option = context->classification_history[i].option;
+		  /* The option 0 is for all the diagnostics.  */
+		  if (option == 0 || option == diagnostic->option_index)
 		    {
 		      diag_class = context->classification_history[i].kind;
 		      if (diag_class != DK_UNSPECIFIED)
diff --git a/gcc-4.8/gcc/diagnostic.h b/gcc-4.8/gcc/diagnostic.h
index f0fae9627..b49ea88c2 100644
--- a/gcc-4.8/gcc/diagnostic.h
+++ b/gcc-4.8/gcc/diagnostic.h
@@ -291,6 +291,6 @@ void diagnostic_set_caret_max_width (diagnostic_context *context, int value);
 
 
 /* Pure text formatting support functions.  */
-extern char *file_name_as_prefix (const char *);
+extern char *file_name_as_prefix (diagnostic_context *, const char *);
 
 #endif /* ! GCC_DIAGNOSTIC_H */
diff --git a/gcc-4.8/gcc/gimple-pretty-print.c b/gcc-4.8/gcc/gimple-pretty-print.c
index 8c24a57d6..c71bef8b0 100644
--- a/gcc-4.8/gcc/gimple-pretty-print.c
+++ b/gcc-4.8/gcc/gimple-pretty-print.c
@@ -266,14 +266,14 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
     case FIX_TRUNC_EXPR:
     case FLOAT_EXPR:
     CASE_CONVERT:
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
       dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false);
       pp_string (buffer, ") ");
       if (op_prio (rhs) < op_code_prio (rhs_code))
 	{
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  dump_generic_node (buffer, rhs, spc, flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       else
 	dump_generic_node (buffer, rhs, spc, flags, false);
@@ -288,7 +288,7 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
     case ABS_EXPR:
       pp_string (buffer, "ABS_EXPR <");
       dump_generic_node (buffer, rhs, spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     default:
@@ -303,23 +303,23 @@ dump_unary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
 	  break;
 	}
       else if (rhs_code == BIT_NOT_EXPR)
-	pp_character (buffer, '~');
+	pp_complement (buffer);
       else if (rhs_code == TRUTH_NOT_EXPR)
-	pp_character (buffer, '!');
+	pp_exclamation (buffer);
       else if (rhs_code == NEGATE_EXPR)
-	pp_character (buffer, '-');
+	pp_minus (buffer);
       else
 	{
-	  pp_character (buffer, '[');
+	  pp_left_bracket (buffer);
 	  pp_string (buffer, tree_code_name [rhs_code]);
 	  pp_string (buffer, "] ");
 	}
 
       if (op_prio (rhs) < op_code_prio (rhs_code))
 	{
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  dump_generic_node (buffer, rhs, spc, flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       else
 	dump_generic_node (buffer, rhs, spc, flags, false);
@@ -356,16 +356,16 @@ dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     default:
       if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code))
 	{
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags,
 			     false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       else
 	dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false);
@@ -374,10 +374,10 @@ dump_binary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       pp_space (buffer);
       if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code))
 	{
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags,
 			     false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       else
 	dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
@@ -404,7 +404,7 @@ dump_ternary_rhs (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     case FMA_EXPR:
@@ -503,7 +503,7 @@ dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
 	{
 	  dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false);
 	  pp_space (buffer);
-	  pp_character (buffer, '=');
+	  pp_equal (buffer);
 
 	  if (gimple_assign_nontemporal_move_p (gs))
 	    pp_string (buffer, "{nt}");
@@ -571,7 +571,7 @@ dump_gimple_call_args (pretty_printer *buffer, gimple gs, int flags)
     {
       if (gimple_call_num_args (gs) > 0)
         {
-          pp_character (buffer, ',');
+          pp_comma (buffer);
           pp_space (buffer);
         }
 
@@ -607,9 +607,9 @@ pp_points_to_solution (pretty_printer *buffer, struct pt_solution *pt)
 	{
 	  pp_string (buffer, "D.");
 	  pp_decimal_int (buffer, i);
-	  pp_character (buffer, ' ');
+	  pp_space (buffer);
 	}
-      pp_character (buffer, '}');
+      pp_right_brace (buffer);
       if (pt->vars_contains_global)
 	pp_string (buffer, " (glob)");
     }
@@ -655,7 +655,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
           pp_string (buffer, ", ");
           dump_gimple_call_args (buffer, gs, flags);
         }
-      pp_character (buffer, '>');
+      pp_greater (buffer);
     }
   else
     {
@@ -675,7 +675,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
 	print_call_name (buffer, fn, flags);
       pp_string (buffer, " (");
       dump_gimple_call_args (buffer, gs, flags);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       if (!(flags & TDF_RHS_ONLY))
 	pp_semicolon (buffer);
     }
@@ -684,7 +684,7 @@ dump_gimple_call (pretty_printer *buffer, gimple gs, int spc, int flags)
     {
       pp_string (buffer, " [static-chain: ");
       dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false);
-      pp_character (buffer, ']');
+      pp_right_bracket (buffer);
     }
 
   if (gimple_call_return_slot_opt_p (gs))
@@ -772,12 +772,12 @@ dump_gimple_switch (pretty_printer *buffer, gimple gs, int spc, int flags)
       tree case_label = gimple_switch_label (gs, i);
       gcc_checking_assert (case_label != NULL_TREE);
       dump_generic_node (buffer, case_label, spc, flags, false);
-      pp_character (buffer, ' ');
+      pp_space (buffer);
       dump_generic_node (buffer, CASE_LABEL (case_label), spc, flags, false);
       if (i < gimple_switch_num_labels (gs) - 1)
         pp_string (buffer, ", ");
     }
-  pp_character (buffer, '>');
+  pp_greater (buffer);
 }
 
 
@@ -803,7 +803,7 @@ dump_gimple_cond (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, gimple_cond_rhs (gs), spc, flags, false);
       if (!(flags & TDF_RHS_ONLY))
 	{
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 
 	  if (gimple_cond_true_label (gs))
 	    {
@@ -837,7 +837,7 @@ dump_gimple_label (pretty_printer *buffer, gimple gs, int spc, int flags)
   else
     {
       dump_generic_node (buffer, label, spc, flags, false);
-      pp_character (buffer, ':');
+      pp_colon (buffer);
     }
   if (DECL_NONLOCAL (label))
     pp_string (buffer, " [non-local]");
@@ -870,7 +870,7 @@ dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
   if (flags & TDF_RAW)
     dump_gimple_fmt (buffer, spc, flags, "%G <", gs);
   else
-    pp_character (buffer, '{');
+    pp_left_brace (buffer);
   if (!(flags & TDF_SLIM))
     {
       tree var;
@@ -887,9 +887,9 @@ dump_gimple_bind (pretty_printer *buffer, gimple gs, int spc, int flags)
   dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags);
   newline_and_indent (buffer, spc);
   if (flags & TDF_RAW)
-    pp_character (buffer, '>');
+    pp_greater (buffer);
   else
-    pp_character (buffer, '}');
+    pp_right_brace (buffer);
 }
 
 
@@ -917,26 +917,26 @@ dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
     {
       pp_string (buffer, "try");
       newline_and_indent (buffer, spc + 2);
-      pp_character (buffer, '{');
+      pp_left_brace (buffer);
       pp_newline (buffer);
 
       dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags);
       newline_and_indent (buffer, spc + 2);
-      pp_character (buffer, '}');
+      pp_right_brace (buffer);
 
       if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH)
 	{
 	  newline_and_indent (buffer, spc);
 	  pp_string (buffer, "catch");
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	}
       else if (gimple_try_kind (gs) == GIMPLE_TRY_FINALLY)
 	{
 	  newline_and_indent (buffer, spc);
 	  pp_string (buffer, "finally");
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	}
       else
 	pp_string (buffer, " <UNKNOWN GIMPLE_TRY> {");
@@ -944,7 +944,7 @@ dump_gimple_try (pretty_printer *buffer, gimple gs, int spc, int flags)
       pp_newline (buffer);
       dump_gimple_seq (buffer, gimple_try_cleanup (gs), spc + 4, flags);
       newline_and_indent (buffer, spc + 2);
-      pp_character (buffer, '}');
+      pp_right_brace (buffer);
     }
 }
 
@@ -1125,10 +1125,10 @@ dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
 	  switch (gimple_omp_for_cond (gs, i))
 	    {
 	    case LT_EXPR:
-	      pp_character (buffer, '<');
+	      pp_less (buffer);
 	      break;
 	    case GT_EXPR:
-	      pp_character (buffer, '>');
+	      pp_greater (buffer);
 	      break;
 	    case LE_EXPR:
 	      pp_string (buffer, "<=");
@@ -1149,17 +1149,17 @@ dump_gimple_omp_for (pretty_printer *buffer, gimple gs, int spc, int flags)
 	  pp_string (buffer, " = ");
 	  dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc,
 			     flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
 
       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
     }
 }
@@ -1180,11 +1180,11 @@ dump_gimple_omp_continue (pretty_printer *buffer, gimple gs, int spc, int flags)
       pp_string (buffer, "#pragma omp continue (");
       dump_generic_node (buffer, gimple_omp_continue_control_def (gs),
 	  		 spc, flags, false);
-      pp_character (buffer, ',');
+      pp_comma (buffer);
       pp_space (buffer);
       dump_generic_node (buffer, gimple_omp_continue_control_use (gs),
 	  		 spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
     }
 }
 
@@ -1207,11 +1207,11 @@ dump_gimple_omp_single (pretty_printer *buffer, gimple gs, int spc, int flags)
       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
     }
 }
@@ -1237,17 +1237,17 @@ dump_gimple_omp_sections (pretty_printer *buffer, gimple gs, int spc,
 	  pp_string (buffer, " <");
 	  dump_generic_node (buffer, gimple_omp_sections_control (gs), spc,
 			     flags, false);
-	  pp_character (buffer, '>');
+	  pp_greater (buffer);
 	}
       dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags);
       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
     }
 }
@@ -1280,11 +1280,11 @@ dump_gimple_omp_block (pretty_printer *buffer, gimple gs, int spc, int flags)
       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
     }
 }
@@ -1306,16 +1306,16 @@ dump_gimple_omp_critical (pretty_printer *buffer, gimple gs, int spc,
 	  pp_string (buffer, " (");
 	  dump_generic_node (buffer, gimple_omp_critical_name (gs), spc,
 			     flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       if (!gimple_seq_empty_p (gimple_omp_body (gs)))
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
     }
 }
@@ -1413,12 +1413,12 @@ dump_gimple_transaction (pretty_printer *buffer, gimple gs, int spc, int flags)
       if (!gimple_seq_empty_p (gimple_transaction_body (gs)))
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, gimple_transaction_body (gs),
 			   spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
     }
 }
@@ -1494,7 +1494,7 @@ dump_gimple_asm (pretty_printer *buffer, gimple gs, int spc, int flags)
 	}
 
       newline_and_indent (buffer, spc);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
     }
   else
     {
@@ -1620,7 +1620,7 @@ dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
 	  expanded_location xloc;
 
 	  xloc = expand_location (gimple_phi_arg_location (phi, i));
-	  pp_character (buffer, '[');
+	  pp_left_bracket (buffer);
 	  if (xloc.file)
 	    {
 	      pp_string (buffer, xloc.file);
@@ -1633,13 +1633,13 @@ dump_gimple_phi (pretty_printer *buffer, gimple phi, int spc, int flags)
 	}
       dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags,
 			 false);
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
       pp_decimal_int (buffer, gimple_phi_arg_edge (phi, i)->src->index);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       if (i < gimple_phi_num_args (phi) - 1)
 	pp_string (buffer, ", ");
     }
-  pp_character (buffer, '>');
+  pp_greater (buffer);
 }
 
 
@@ -1682,11 +1682,11 @@ dump_gimple_omp_parallel (pretty_printer *buffer, gimple gs, int spc,
       if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, body, spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       else if (body)
 	{
@@ -1739,11 +1739,11 @@ dump_gimple_omp_task (pretty_printer *buffer, gimple gs, int spc,
       if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND)
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  pp_newline (buffer);
 	  dump_gimple_seq (buffer, body, spc + 4, flags);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       else if (body)
 	{
@@ -1777,9 +1777,9 @@ dump_gimple_omp_atomic_load (pretty_printer *buffer, gimple gs, int spc,
       dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs),
 	  		 spc, flags, false);
       pp_space (buffer);
-      pp_character (buffer, '=');
+      pp_equal (buffer);
       pp_space (buffer);
-      pp_character (buffer, '*');
+      pp_star (buffer);
       dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs),
 	  		 spc, flags, false);
     }
@@ -1803,10 +1803,10 @@ dump_gimple_omp_atomic_store (pretty_printer *buffer, gimple gs, int spc,
       pp_string (buffer, "#pragma omp atomic_store ");
       if (gimple_omp_atomic_need_value_p (gs))
 	pp_string (buffer, "[needed] ");
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
       dump_generic_node (buffer, gimple_omp_atomic_store_val (gs),
 	  		 spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
     }
 }
 
@@ -1830,14 +1830,14 @@ dump_gimple_mem_ops (pretty_printer *buffer, gimple gs, int spc, int flags)
       dump_generic_node (buffer, vdef, spc + 2, flags, false);
       pp_string (buffer, " = VDEF <");
       dump_generic_node (buffer, vuse, spc + 2, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       newline_and_indent (buffer, spc);
     }
   else if (vuse != NULL_TREE)
     {
       pp_string (buffer, "# VUSE <");
       dump_generic_node (buffer, vuse, spc + 2, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       newline_and_indent (buffer, spc);
     }
 }
@@ -1860,7 +1860,7 @@ pp_gimple_stmt_1 (pretty_printer *buffer, gimple gs, int spc, int flags)
   if ((flags & TDF_LINENO) && gimple_has_location (gs))
     {
       expanded_location xloc = expand_location (gimple_location (gs));
-      pp_character (buffer, '[');
+      pp_left_bracket (buffer);
       if (xloc.file)
 	{
 	  pp_string (buffer, xloc.file);
@@ -2141,12 +2141,12 @@ pp_cfg_jump (pretty_printer *buffer, basic_block bb)
 
   pp_string (buffer, "goto <bb ");
   pp_decimal_int (buffer, bb->index);
-  pp_character (buffer, '>');
+  pp_greater (buffer);
   if (stmt && gimple_code (stmt) == GIMPLE_LABEL)
     {
       pp_string (buffer, " (");
       dump_generic_node (buffer, gimple_label_label (stmt), 0, 0, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       pp_semicolon (buffer);
     }
   else
@@ -2201,7 +2201,7 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent,
 	{
 	  expanded_location goto_xloc;
 	  goto_xloc = expand_location (e->goto_locus);
-	  pp_character (buffer, '[');
+	  pp_left_bracket (buffer);
 	  if (goto_xloc.file)
 	    {
 	      pp_string (buffer, goto_xloc.file);
@@ -2290,7 +2290,7 @@ gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
       if (!virtual_operand_p (gimple_phi_result (phi))
 	  || (dump_flags & TDF_VOPS))
 	{
-	  pp_character (pp, '|');
+	  pp_bar (pp);
 	  pp_write_text_to_stream (pp);
 	  pp_string (pp, "# ");
 	  pp_gimple_stmt_1 (pp, phi, 0, dump_flags);
@@ -2302,7 +2302,7 @@ gimple_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
   for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
     {
       gimple stmt = gsi_stmt (gsi);
-      pp_character (pp, '|');
+      pp_bar (pp);
       pp_write_text_to_stream (pp);
       pp_gimple_stmt_1 (pp, stmt, 0, dump_flags);
       pp_newline (pp);
diff --git a/gcc-4.8/gcc/graph.c b/gcc-4.8/gcc/graph.c
index 51837308b..0cb2ceae4 100644
--- a/gcc-4.8/gcc/graph.c
+++ b/gcc-4.8/gcc/graph.c
@@ -109,10 +109,10 @@ draw_cfg_node (pretty_printer *pp, int funcdef_no, basic_block bb)
     pp_string (pp, "EXIT");
   else
     {
-      pp_character (pp, '{');
+      pp_left_brace (pp);
       pp_write_text_to_stream (pp);
       dump_bb_for_graph (pp, bb);
-      pp_character (pp, '}');
+      pp_right_brace (pp);
     }
 
   pp_string (pp, "\"];\n\n");
diff --git a/gcc-4.8/gcc/langhooks.c b/gcc-4.8/gcc/langhooks.c
index 70af8da4b..fbf545b46 100644
--- a/gcc-4.8/gcc/langhooks.c
+++ b/gcc-4.8/gcc/langhooks.c
@@ -372,7 +372,7 @@ lhd_print_error_function (diagnostic_context *context, const char *file,
       const char *old_prefix = context->printer->prefix;
       tree abstract_origin = diagnostic_abstract_origin (diagnostic);
       char *new_prefix = (file && abstract_origin == NULL)
-			 ? file_name_as_prefix (file) : NULL;
+			 ? file_name_as_prefix (context, file) : NULL;
 
       pp_set_prefix (context->printer, new_prefix);
 
@@ -446,7 +446,7 @@ lhd_print_error_function (diagnostic_context *context, const char *file,
 	      if (fndecl)
 		{
 		  expanded_location s = expand_location (*locus);
-		  pp_character (context->printer, ',');
+		  pp_comma (context->printer);
 		  pp_newline (context->printer);
 		  if (s.file != NULL)
 		    {
@@ -467,7 +467,7 @@ lhd_print_error_function (diagnostic_context *context, const char *file,
 			       identifier_to_locale (lang_hooks.decl_printable_name (fndecl, 2)));
 		}
 	    }
-	  pp_character (context->printer, ':');
+	  pp_colon (context->printer);
 	}
 
       diagnostic_set_last_function (context, diagnostic);
diff --git a/gcc-4.8/gcc/pretty-print.h b/gcc-4.8/gcc/pretty-print.h
index 13bb2dede..f72c23598 100644
--- a/gcc-4.8/gcc/pretty-print.h
+++ b/gcc-4.8/gcc/pretty-print.h
@@ -238,7 +238,7 @@ pp_base_get_prefix (const pretty_printer *pp) { return pp->prefix; }
 #define pp_left_brace(PP)       pp_character (PP, '{')
 #define pp_right_brace(PP)      pp_character (PP, '}')
 #define pp_semicolon(PP)        pp_character (PP, ';')
-#define pp_comma(PP)            pp_string (PP, ", ")
+#define pp_comma(PP)            pp_character (PP, ',')
 #define pp_dot(PP)              pp_character (PP, '.')
 #define pp_colon(PP)            pp_character (PP, ':')
 #define pp_colon_colon(PP)      pp_string (PP, "::")
@@ -260,6 +260,7 @@ pp_base_get_prefix (const pretty_printer *pp) { return pp->prefix; }
 #define pp_quote(PP)            pp_character (PP, '\'')
 #define pp_backquote(PP)        pp_character (PP, '`')
 #define pp_doublequote(PP)      pp_character (PP, '"')
+#define pp_underscore(PP)       pp_character (PP, '_')
 #define pp_newline_and_flush(PP)     \
   do {                               \
     pp_newline (PP);                 \
diff --git a/gcc-4.8/gcc/sched-vis.c b/gcc-4.8/gcc/sched-vis.c
index 98de37e74..d7d8c395f 100644
--- a/gcc-4.8/gcc/sched-vis.c
+++ b/gcc-4.8/gcc/sched-vis.c
@@ -344,11 +344,11 @@ print_exp (pretty_printer *pp, const_rtx x, int verbose)
 	pp_string (pp, "unspec");
 	if (GET_CODE (x) == UNSPEC_VOLATILE)
 	  pp_string (pp, "/v");
-	pp_character (pp, '[');
+	pp_left_bracket (pp);
 	for (i = 0; i < XVECLEN (x, 0); i++)
 	  {
 	    if (i != 0)
-	      pp_character (pp, ',');
+	      pp_comma (pp);
 	    print_pattern (pp, XVECEXP (x, 0, i), verbose);
 	  }
 	pp_string (pp, "] ");
@@ -390,7 +390,7 @@ print_exp (pretty_printer *pp, const_rtx x, int verbose)
   if (fun)
     {
       pp_string (pp, fun);
-      pp_character (pp, '(');
+      pp_left_paren (pp);
     }
 
   for (i = 0; i < 4; i++)
@@ -401,13 +401,13 @@ print_exp (pretty_printer *pp, const_rtx x, int verbose)
       if (op[i])
 	{
 	  if (fun && i != 0)
-	    pp_character (pp, ',');
+	    pp_comma (pp);
 	  print_value (pp, op[i], verbose);
 	}
     }
 
   if (fun)
-    pp_character (pp, ')');
+    pp_right_paren (pp);
 }		/* print_exp */
 
 /* Prints rtxes, I customarily classified as values.  They're constants,
@@ -459,13 +459,13 @@ print_value (pretty_printer *pp, const_rtx x, int verbose)
     case STRICT_LOW_PART:
       pp_printf (pp, "%s(", GET_RTX_NAME (GET_CODE (x)));
       print_value (pp, XEXP (x, 0), verbose);
-      pp_character (pp, ')');
+      pp_right_paren (pp);
       break;
     case REG:
       if (REGNO (x) < FIRST_PSEUDO_REGISTER)
 	{
 	  if (ISDIGIT (reg_names[REGNO (x)][0]))
-	    pp_character (pp, '%');
+	    pp_modulo (pp);
 	  pp_string (pp, reg_names[REGNO (x)]);
 	}
       else
@@ -483,9 +483,9 @@ print_value (pretty_printer *pp, const_rtx x, int verbose)
       pp_string (pp, GET_RTX_NAME (GET_CODE (x)));
       break;
     case MEM:
-      pp_character (pp, '[');
+      pp_left_bracket (pp);
       print_value (pp, XEXP (x, 0), verbose);
-      pp_character (pp, ']');
+      pp_right_bracket (pp);
       break;
     case DEBUG_EXPR:
       pp_printf (pp, "D#%i", DEBUG_TEMP_UID (DEBUG_EXPR_TREE_DECL (x)));
@@ -511,7 +511,7 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
     {
     case SET:
       print_value (pp, SET_DEST (x), verbose);
-      pp_character (pp, '=');
+      pp_equal (pp);
       print_value (pp, SET_SRC (x), verbose);
       break;
     case RETURN:
@@ -532,14 +532,14 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
       print_value (pp, PAT_VAR_LOCATION_LOC (x), verbose);
       break;
     case COND_EXEC:
-      pp_character (pp, '(');
+      pp_left_paren (pp);
       if (GET_CODE (COND_EXEC_TEST (x)) == NE
 	  && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 	print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
       else if (GET_CODE (COND_EXEC_TEST (x)) == EQ
 	       && XEXP (COND_EXEC_TEST (x), 1) == const0_rtx)
 	{
-	  pp_character (pp, '!');
+	  pp_exclamation (pp);
 	  print_value (pp, XEXP (COND_EXEC_TEST (x), 0), verbose);
 	}
       else
@@ -551,13 +551,13 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
       {
 	int i;
 
-	pp_character (pp, '{');
+	pp_left_brace (pp);
 	for (i = 0; i < XVECLEN (x, 0); i++)
 	  {
 	    print_pattern (pp, XVECEXP (x, 0, i), verbose);
-	    pp_character (pp, ';');
+	    pp_semicolon (pp);
 	  }
-	pp_character (pp, '}');
+	pp_right_brace (pp);
       }
       break;
     case SEQUENCE:
@@ -568,9 +568,9 @@ print_pattern (pretty_printer *pp, const_rtx x, int verbose)
 	for (i = 0; i < XVECLEN (x, 0); i++)
 	  {
 	    print_pattern (pp, XVECEXP (x, 0, i), verbose);
-	    pp_character (pp, ';');
+		pp_semicolon (pp);
 	  }
-	pp_character (pp, '}');
+	pp_right_brace (pp);
       }
       break;
     case ASM_INPUT:
@@ -700,9 +700,9 @@ print_insn (pretty_printer *pp, const_rtx x, int verbose)
 
 	  case NOTE_INSN_VAR_LOCATION:
 	  case NOTE_INSN_CALL_ARG_LOCATION:
-	    pp_character (pp, '{');
+	    pp_left_brace (pp);
 	    print_pattern (pp, NOTE_VAR_LOCATION (x), verbose);
-	    pp_character (pp, '}');
+	    pp_right_brace (pp);
 	    break;
 
 	  default:
@@ -813,7 +813,7 @@ rtl_dump_bb_for_graph (pretty_printer *pp, basic_block bb)
     {
       if (! first)
 	{
-	  pp_character (pp, '|');
+	  pp_bar (pp);
 	  pp_write_text_to_stream (pp);
 	}
       first = false;
diff --git a/gcc-4.8/gcc/testsuite/gnat.dg/warn9.adb b/gcc-4.8/gcc/testsuite/gnat.dg/warn9.adb
new file mode 100644
index 000000000..38f9d71e4
--- /dev/null
+++ b/gcc-4.8/gcc/testsuite/gnat.dg/warn9.adb
@@ -0,0 +1,10 @@
+-- { dg-do compile }
+-- { dg-options "-Wuninitialized" }
+
+pragma Warnings (Off);
+
+function Warn9 return Integer is
+  I : Integer;
+begin
+  return I;
+end;
diff --git a/gcc-4.8/gcc/tree-pretty-print.c b/gcc-4.8/gcc/tree-pretty-print.c
index 1613142f3..c6ce73602 100644
--- a/gcc-4.8/gcc/tree-pretty-print.c
+++ b/gcc-4.8/gcc/tree-pretty-print.c
@@ -229,7 +229,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
   tree arg;
 
   pp_space (buffer);
-  pp_character (buffer, '(');
+  pp_left_paren (buffer);
 
   /* Print the argument types.  */
   arg = TYPE_ARG_TYPES (node);
@@ -237,7 +237,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
     {
       if (wrote_arg)
 	{
-	  pp_character (buffer, ',');
+	  pp_comma (buffer);
 	  pp_space (buffer);
 	}
       wrote_arg = true;
@@ -253,7 +253,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
     pp_string (buffer, ", ...");
   /* Avoid printing any arg for unprototyped functions.  */
 
-  pp_character (buffer, ')');
+  pp_right_paren (buffer);
 }
 
 /* Dump the domain associated with an array.  */
@@ -261,7 +261,7 @@ dump_function_declaration (pretty_printer *buffer, tree node,
 static void
 dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
 {
-  pp_character (buffer, '[');
+  pp_left_bracket (buffer);
   if (domain)
     {
       tree min = TYPE_MIN_VALUE (domain);
@@ -275,14 +275,14 @@ dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)
 	{
 	  if (min)
 	    dump_generic_node (buffer, min, spc, flags, false);
-	  pp_character (buffer, ':');
+	  pp_colon (buffer);
 	  if (max)
 	    dump_generic_node (buffer, max, spc, flags, false);
 	}
     }
   else
     pp_string (buffer, "<unknown>");
-  pp_character (buffer, ']');
+  pp_right_bracket (buffer);
 }
 
 
@@ -316,33 +316,33 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
       goto print_remap;
   print_remap:
       pp_string (buffer, name);
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 	  spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_REDUCTION:
       pp_string (buffer, "reduction(");
       pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));
-      pp_character (buffer, ':');
+      pp_colon (buffer);
       dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),
 	  spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_IF:
       pp_string (buffer, "if(");
       dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),
 	  spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_NUM_THREADS:
       pp_string (buffer, "num_threads(");
       dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),
 	  spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_NOWAIT:
@@ -373,7 +373,7 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
 	default:
 	  gcc_unreachable ();
 	}
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_SCHEDULE:
@@ -400,12 +400,12 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
 	}
       if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))
 	{
-	  pp_character (buffer, ',');
+	  pp_comma (buffer);
 	  dump_generic_node (buffer,
 	      OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),
 	      spc, flags, false);
 	}
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_UNTIED:
@@ -417,14 +417,14 @@ dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)
       dump_generic_node (buffer,
 			 OMP_CLAUSE_COLLAPSE_EXPR (clause),
 			 spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_FINAL:
       pp_string (buffer, "final(");
       dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause),
 	  spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case OMP_CLAUSE_MERGEABLE:
@@ -467,7 +467,7 @@ dump_location (pretty_printer *buffer, location_t loc)
 {
   expanded_location xloc = expand_location (loc);
 
-  pp_character (buffer, '[');
+  pp_left_bracket (buffer);
   if (xloc.file)
     {
       pp_string (buffer, xloc.file);
@@ -638,7 +638,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  node = TREE_CHAIN (node);
 	  if (node && TREE_CODE (node) == TREE_LIST)
 	    {
-	      pp_character (buffer, ',');
+	      pp_comma (buffer);
 	      pp_space (buffer);
 	    }
 	}
@@ -658,7 +658,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	      {
 		dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,
 				   false);
-		pp_character (buffer, ',');
+		pp_comma (buffer);
 		pp_space (buffer);
 	      }
 	    dump_generic_node (buffer, TREE_VEC_ELT (node, len - 1), spc,
@@ -717,7 +717,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	    else if (TREE_CODE (node) == VECTOR_TYPE)
 	      {
 		pp_string (buffer, "vector");
-		pp_character (buffer, '(');
+		pp_left_paren (buffer);
 		pp_wide_integer (buffer, TYPE_VECTOR_SUBPARTS (node));
 		pp_string (buffer, ") ");
 		dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
@@ -801,7 +801,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
 	  dump_generic_node (buffer, TREE_TYPE (fnode), spc, flags, false);
 	  pp_space (buffer);
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  pp_string (buffer, str);
 	  if (TYPE_NAME (node) && DECL_NAME (TYPE_NAME (node)))
 	    dump_decl_name (buffer, TYPE_NAME (node), flags);
@@ -810,7 +810,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  else
 	    pp_printf (buffer, "<T%x>", TYPE_UID (node));
 
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	  dump_function_declaration (buffer, fnode, spc, flags);
 	}
       else
@@ -1045,7 +1045,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
 	  if (tree_int_cst_sgn (val) < 0)
 	    {
-	      pp_character (buffer, '-');
+	      pp_minus (buffer);
 	      high = ~high + !low;
 	      low = -low;
 	    }
@@ -1241,10 +1241,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  str = "->";
 	}
       if (op_prio (op0) < op_prio (node))
-	pp_character (buffer, '(');
+	pp_left_paren (buffer);
       dump_generic_node (buffer, op0, spc, flags, false);
       if (op_prio (op0) < op_prio (node))
-	pp_character (buffer, ')');
+	pp_right_paren (buffer);
       pp_string (buffer, str);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       op0 = component_ref_field_offset (node);
@@ -1252,7 +1252,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	{
 	  pp_string (buffer, "{off: ");
 	      dump_generic_node (buffer, op0, spc, flags, false);
-	      pp_character (buffer, '}');
+	      pp_right_brace (buffer);
 	}
       break;
 
@@ -1270,15 +1270,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case ARRAY_RANGE_REF:
       op0 = TREE_OPERAND (node, 0);
       if (op_prio (op0) < op_prio (node))
-	pp_character (buffer, '(');
+	pp_left_paren (buffer);
       dump_generic_node (buffer, op0, spc, flags, false);
       if (op_prio (op0) < op_prio (node))
-	pp_character (buffer, ')');
-      pp_character (buffer, '[');
+	pp_right_paren (buffer);
+      pp_left_bracket (buffer);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       if (TREE_CODE (node) == ARRAY_RANGE_REF)
 	pp_string (buffer, " ...");
-      pp_character (buffer, ']');
+      pp_right_bracket (buffer);
 
       op0 = array_ref_low_bound (node);
       op1 = array_ref_element_size (node);
@@ -1291,7 +1291,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  dump_generic_node (buffer, op0, spc, flags, false);
 	  pp_string (buffer, " sz: ");
 	  dump_generic_node (buffer, op1, spc, flags, false);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       break;
 
@@ -1302,7 +1302,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	bool is_struct_init = false;
 	bool is_array_init = false;
 	double_int curidx = double_int_zero;
-	pp_character (buffer, '{');
+	pp_left_brace (buffer);
 	if (TREE_CLOBBER_P (node))
 	  pp_string (buffer, "CLOBBER");
 	else if (TREE_CODE (TREE_TYPE (node)) == RECORD_TYPE
@@ -1324,15 +1324,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	      {
 		if (is_struct_init)
 		  {
-		    pp_character (buffer, '.');
+		    pp_dot (buffer);
 		    dump_generic_node (buffer, field, spc, flags, false);
-		    pp_character (buffer, '=');
+		    pp_equal (buffer);
 		  }
 		else if (is_array_init
 			 && (TREE_CODE (field) != INTEGER_CST
 			     || tree_to_double_int (field) != curidx))
 		  {
-		    pp_character (buffer, '[');
+		    pp_left_bracket (buffer);
 		    if (TREE_CODE (field) == RANGE_EXPR)
 		      {
 			dump_generic_node (buffer, TREE_OPERAND (field, 0), spc,
@@ -1361,11 +1361,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 		dump_generic_node (buffer, val, spc, flags, false);
 	    if (ix != vec_safe_length (CONSTRUCTOR_ELTS (node)) - 1)
 	      {
-		pp_character (buffer, ',');
+		pp_comma (buffer);
 		pp_space (buffer);
 	      }
 	  }
-	pp_character (buffer, '}');
+	pp_right_brace (buffer);
       }
       break;
 
@@ -1384,7 +1384,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  newline_and_indent (buffer, spc);
 	else
 	  {
-	    pp_character (buffer, ',');
+	    pp_comma (buffer);
 	    pp_space (buffer);
 	  }
 
@@ -1398,7 +1398,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	      newline_and_indent (buffer, spc);
 	    else
 	      {
-	        pp_character (buffer, ',');
+	        pp_comma (buffer);
 	        pp_space (buffer);
 	      }
 	  }
@@ -1434,7 +1434,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags,
 	  		 false);
       pp_space (buffer);
-      pp_character (buffer, '=');
+      pp_equal (buffer);
       pp_space (buffer);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags,
 	  		 false);
@@ -1443,10 +1443,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case TARGET_EXPR:
       pp_string (buffer, "TARGET_EXPR <");
       dump_generic_node (buffer, TARGET_EXPR_SLOT (node), spc, flags, false);
-      pp_character (buffer, ',');
+      pp_comma (buffer);
       pp_space (buffer);
       dump_generic_node (buffer, TARGET_EXPR_INITIAL (node), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     case DECL_EXPR:
@@ -1459,7 +1459,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	{
 	  pp_string (buffer, "if (");
 	  dump_generic_node (buffer, COND_EXPR_COND (node), spc, flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	  /* The lowered cond_exprs should always be printed in full.  */
 	  if (COND_EXPR_THEN (node)
 	      && (IS_EMPTY_STMT (COND_EXPR_THEN (node))
@@ -1484,12 +1484,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	      if (COND_EXPR_THEN (node))
 		{
 		  newline_and_indent (buffer, spc+2);
-		  pp_character (buffer, '{');
+		  pp_left_brace (buffer);
 		  newline_and_indent (buffer, spc+4);
 		  dump_generic_node (buffer, COND_EXPR_THEN (node), spc+4,
 				     flags, true);
 		  newline_and_indent (buffer, spc+2);
-		  pp_character (buffer, '}');
+		  pp_right_brace (buffer);
 		}
 
 	      /* Output COND_EXPR_ELSE.  */
@@ -1499,12 +1499,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 		  newline_and_indent (buffer, spc);
 		  pp_string (buffer, "else");
 		  newline_and_indent (buffer, spc+2);
-		  pp_character (buffer, '{');
+		  pp_left_brace (buffer);
 		  newline_and_indent (buffer, spc+4);
 		  dump_generic_node (buffer, COND_EXPR_ELSE (node), spc+4,
 			             flags, true);
 		  newline_and_indent (buffer, spc+2);
-		  pp_character (buffer, '}');
+		  pp_right_brace (buffer);
 		}
 	    }
 	  is_expr = false;
@@ -1513,18 +1513,18 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	{
 	  dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
 	  pp_space (buffer);
-	  pp_character (buffer, '?');
+	  pp_question (buffer);
 	  pp_space (buffer);
 	  dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
 	  pp_space (buffer);
-	  pp_character (buffer, ':');
+	  pp_colon (buffer);
 	  pp_space (buffer);
 	  dump_generic_node (buffer, TREE_OPERAND (node, 2), spc, flags, false);
 	}
       break;
 
     case BIND_EXPR:
-      pp_character (buffer, '{');
+      pp_left_brace (buffer);
       if (!(flags & TDF_SLIM))
 	{
 	  if (BIND_EXPR_VARS (node))
@@ -1541,7 +1541,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  newline_and_indent (buffer, spc+2);
 	  dump_generic_node (buffer, BIND_EXPR_BODY (node), spc+2, flags, true);
 	  newline_and_indent (buffer, spc);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       is_expr = false;
       break;
@@ -1551,7 +1551,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
       /* Print parameters.  */
       pp_space (buffer);
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
       {
 	tree arg;
 	call_expr_arg_iterator iter;
@@ -1560,7 +1560,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	    dump_generic_node (buffer, arg, spc, flags, false);
 	    if (more_call_expr_args_p (&iter))
 	      {
-		pp_character (buffer, ',');
+		pp_comma (buffer);
 		pp_space (buffer);
 	      }
 	  }
@@ -1569,19 +1569,19 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	{
 	  if (call_expr_nargs (node) > 0)
 	    {
-	      pp_character (buffer, ',');
+	      pp_comma (buffer);
 	      pp_space (buffer);
 	    }
 	  pp_string (buffer, "__builtin_va_arg_pack ()");
 	}
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
 
       op1 = CALL_EXPR_STATIC_CHAIN (node);
       if (op1)
 	{
 	  pp_string (buffer, " [static-chain: ");
 	  dump_generic_node (buffer, op1, spc, flags, false);
-	  pp_character (buffer, ']');
+	  pp_right_bracket (buffer);
 	}
 
       if (CALL_EXPR_RETURN_SLOT_OPT (node))
@@ -1603,7 +1603,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case PLACEHOLDER_EXPR:
       pp_string (buffer, "<PLACEHOLDER_EXPR ");
       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
       /* Binary arithmetic and logic expressions.  */
@@ -1662,9 +1662,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	   keep semantics of the tree representation.  */
 	if (op_prio (op0) <= op_prio (node))
 	  {
-	    pp_character (buffer, '(');
+	    pp_left_paren (buffer);
 	    dump_generic_node (buffer, op0, spc, flags, false);
-	    pp_character (buffer, ')');
+	    pp_right_paren (buffer);
 	  }
 	else
 	  dump_generic_node (buffer, op0, spc, flags, false);
@@ -1677,9 +1677,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	   keep semantics of the tree representation.  */
 	if (op_prio (op1) <= op_prio (node))
 	  {
-	    pp_character (buffer, '(');
+	    pp_left_paren (buffer);
 	    dump_generic_node (buffer, op1, spc, flags, false);
-	    pp_character (buffer, ')');
+	    pp_right_paren (buffer);
 	  }
 	else
 	  dump_generic_node (buffer, op1, spc, flags, false);
@@ -1703,9 +1703,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 
       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
 	{
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       else
 	dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
@@ -1715,9 +1715,9 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case POSTINCREMENT_EXPR:
       if (op_prio (TREE_OPERAND (node, 0)) < op_prio (node))
 	{
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       else
 	dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
@@ -1729,7 +1729,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     case MAX_EXPR:
@@ -1737,13 +1737,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
       pp_string (buffer, ", ");
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     case ABS_EXPR:
       pp_string (buffer, "ABS_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     case RANGE_EXPR:
@@ -1759,15 +1759,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       op0 = TREE_OPERAND (node, 0);
       if (type != TREE_TYPE (op0))
 	{
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
 	  dump_generic_node (buffer, type, spc, flags, false);
 	  pp_string (buffer, ") ");
 	}
       if (op_prio (op0) < op_prio (node))
-	pp_character (buffer, '(');
+	pp_left_paren (buffer);
       dump_generic_node (buffer, op0, spc, flags, false);
       if (op_prio (op0) < op_prio (node))
-	pp_character (buffer, ')');
+	pp_right_paren (buffer);
       break;
 
     case VIEW_CONVERT_EXPR:
@@ -1775,7 +1775,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       dump_generic_node (buffer, TREE_TYPE (node), spc, flags, false);
       pp_string (buffer, ">(");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case PAREN_EXPR:
@@ -1787,13 +1787,13 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case NON_LVALUE_EXPR:
       pp_string (buffer, "NON_LVALUE_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     case SAVE_EXPR:
       pp_string (buffer, "SAVE_EXPR <");
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
-      pp_character (buffer, '>');
+      pp_greater (buffer);
       break;
 
     case COMPLEX_EXPR:
@@ -1886,7 +1886,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	    break;
 	}
       dump_generic_node (buffer, op0, spc, flags, false);
-      pp_character (buffer, ':');
+      pp_colon (buffer);
       if (DECL_NONLOCAL (op0))
 	pp_string (buffer, " [non-local]");
       break;
@@ -1896,11 +1896,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (!(flags & TDF_SLIM))
 	{
 	  newline_and_indent (buffer, spc+2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  newline_and_indent (buffer, spc+4);
 	  dump_generic_node (buffer, LOOP_EXPR_BODY (node), spc+4, flags, true);
 	  newline_and_indent (buffer, spc+2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       is_expr = false;
       break;
@@ -1938,11 +1938,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case SWITCH_EXPR:
       pp_string (buffer, "switch (");
       dump_generic_node (buffer, SWITCH_COND (node), spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       if (!(flags & TDF_SLIM))
 	{
 	  newline_and_indent (buffer, spc+2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  if (SWITCH_BODY (node))
 	    {
 	      newline_and_indent (buffer, spc+4);
@@ -1970,7 +1970,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 		}
 	    }
 	  newline_and_indent (buffer, spc+2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       is_expr = false;
       break;
@@ -1995,15 +1995,15 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       pp_string (buffer, "__asm__");
       if (ASM_VOLATILE_P (node))
 	pp_string (buffer, " __volatile__");
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
       dump_generic_node (buffer, ASM_STRING (node), spc, flags, false);
-      pp_character (buffer, ':');
+      pp_colon (buffer);
       dump_generic_node (buffer, ASM_OUTPUTS (node), spc, flags, false);
-      pp_character (buffer, ':');
+      pp_colon (buffer);
       dump_generic_node (buffer, ASM_INPUTS (node), spc, flags, false);
       if (ASM_CLOBBERS (node))
 	{
-	  pp_character (buffer, ':');
+	  pp_colon (buffer);
 	  dump_generic_node (buffer, ASM_CLOBBERS (node), spc, flags, false);
 	}
       pp_string (buffer, ")");
@@ -2024,18 +2024,17 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	}
       else
 	pp_string (buffer, "default");
-      pp_character (buffer, ':');
+      pp_colon (buffer);
       break;
 
     case OBJ_TYPE_REF:
       pp_string (buffer, "OBJ_TYPE_REF(");
       dump_generic_node (buffer, OBJ_TYPE_REF_EXPR (node), spc, flags, false);
-      pp_character (buffer, ';');
+      pp_semicolon (buffer);
       dump_generic_node (buffer, OBJ_TYPE_REF_OBJECT (node), spc, flags, false);
-      pp_character (buffer, '-');
-      pp_character (buffer, '>');
+      pp_arrow (buffer);
       dump_generic_node (buffer, OBJ_TYPE_REF_TOKEN (node), spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
       break;
 
     case SSA_NAME:
@@ -2162,11 +2161,11 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (!(flags & TDF_SLIM) && OMP_BODY (node))
 	{
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  newline_and_indent (buffer, spc + 4);
 	  dump_generic_node (buffer, OMP_BODY (node), spc + 4, flags, false);
 	  newline_and_indent (buffer, spc + 2);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       is_expr = false;
       break;
@@ -2187,7 +2186,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  if (OMP_FOR_PRE_BODY (node))
 	    {
 	      newline_and_indent (buffer, spc + 2);
-	      pp_character (buffer, '{');
+	      pp_left_brace (buffer);
 	      spc += 4;
 	      newline_and_indent (buffer, spc);
 	      dump_generic_node (buffer, OMP_FOR_PRE_BODY (node),
@@ -2212,19 +2211,19 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
 	  if (OMP_FOR_BODY (node))
 	    {
 	      newline_and_indent (buffer, spc + 2);
-	      pp_character (buffer, '{');
+	      pp_left_brace (buffer);
 	      newline_and_indent (buffer, spc + 4);
 	      dump_generic_node (buffer, OMP_FOR_BODY (node), spc + 4, flags,
 		  false);
 	      newline_and_indent (buffer, spc + 2);
-	      pp_character (buffer, '}');
+	      pp_right_brace (buffer);
 	    }
 	  spc -= 2 * TREE_VEC_LENGTH (OMP_FOR_INIT (node)) - 2;
 	  if (OMP_FOR_PRE_BODY (node))
 	    {
 	      spc -= 4;
 	      newline_and_indent (buffer, spc + 2);
-	      pp_character (buffer, '}');
+	      pp_right_brace (buffer);
 	    }
 	}
       is_expr = false;
@@ -2252,10 +2251,10 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (OMP_CRITICAL_NAME (node))
 	{
 	  pp_space (buffer);
-	  pp_character (buffer, '(');
+	  pp_left_paren (buffer);
           dump_generic_node (buffer, OMP_CRITICAL_NAME (node), spc,
 			     flags, false);
-	  pp_character (buffer, ')');
+	  pp_right_paren (buffer);
 	}
       goto dump_omp_body;
 
@@ -2264,7 +2263,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       newline_and_indent (buffer, spc + 2);
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
       pp_space (buffer);
-      pp_character (buffer, '=');
+      pp_equal (buffer);
       pp_space (buffer);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       break;
@@ -2282,7 +2281,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       newline_and_indent (buffer, spc + 2);
       dump_generic_node (buffer, TREE_OPERAND (node, 0), spc, flags, false);
       pp_space (buffer);
-      pp_character (buffer, '=');
+      pp_equal (buffer);
       pp_space (buffer);
       dump_generic_node (buffer, TREE_OPERAND (node, 1), spc, flags, false);
       break;
@@ -2307,12 +2306,12 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
       if (!(flags & TDF_SLIM) && TRANSACTION_EXPR_BODY (node))
 	{
 	  newline_and_indent (buffer, spc);
-	  pp_character (buffer, '{');
+	  pp_left_brace (buffer);
 	  newline_and_indent (buffer, spc + 2);
 	  dump_generic_node (buffer, TRANSACTION_EXPR_BODY (node),
 			     spc + 2, flags, false);
 	  newline_and_indent (buffer, spc);
-	  pp_character (buffer, '}');
+	  pp_right_brace (buffer);
 	}
       is_expr = false;
       break;
@@ -2341,7 +2340,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
     case VEC_WIDEN_MULT_ODD_EXPR:
     case VEC_WIDEN_LSHIFT_HI_EXPR:
     case VEC_WIDEN_LSHIFT_LO_EXPR:
-      pp_character (buffer, ' ');
+      pp_space (buffer);
       for (str = tree_code_name [code]; *str; str++)
 	pp_character (buffer, TOUPPER (*str));
       pp_string (buffer, " < ");
@@ -2474,9 +2473,9 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
     {
       pp_string (buffer, " __asm__ ");
-      pp_character (buffer, '(');
+      pp_left_paren (buffer);
       dump_generic_node (buffer, DECL_ASSEMBLER_NAME (t), spc, flags, false);
-      pp_character (buffer, ')');
+      pp_right_paren (buffer);
     }
 
   /* The initial value of a function serves to determine whether the function
@@ -2488,7 +2487,7 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
       if (DECL_INITIAL (t))
 	{
 	  pp_space (buffer);
-	  pp_character (buffer, '=');
+	  pp_equal (buffer);
 	  pp_space (buffer);
 	  dump_generic_node (buffer, DECL_INITIAL (t), spc, flags, false);
 	}
@@ -2498,10 +2497,10 @@ print_declaration (pretty_printer *buffer, tree t, int spc, int flags)
     {
       pp_string (buffer, " [value-expr: ");
       dump_generic_node (buffer, DECL_VALUE_EXPR (t), spc, flags, false);
-      pp_character (buffer, ']');
+      pp_right_bracket (buffer);
     }
 
-  pp_character (buffer, ';');
+  pp_semicolon (buffer);
 }
 
 
@@ -2527,7 +2526,7 @@ print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
   /* Print the contents of the structure.  */
   pp_newline (buffer);
   INDENT (spc);
-  pp_character (buffer, '{');
+  pp_left_brace (buffer);
   pp_newline (buffer);
 
   /* Print the fields of the structure.  */
@@ -2552,7 +2551,7 @@ print_struct_decl (pretty_printer *buffer, const_tree node, int spc, int flags)
       }
   }
   INDENT (spc);
-  pp_character (buffer, '}');
+  pp_right_brace (buffer);
 }
 
 /* Return the priority of the operator CODE.
diff --git a/gcc-4.8/gcc/tree.c b/gcc-4.8/gcc/tree.c
index 907566495..9c4ddfe50 100644
--- a/gcc-4.8/gcc/tree.c
+++ b/gcc-4.8/gcc/tree.c
@@ -11554,12 +11554,12 @@ warn_deprecated_use (tree node, tree attr)
       expanded_location xloc = expand_location (DECL_SOURCE_LOCATION (node));
       if (msg)
 	warning (OPT_Wdeprecated_declarations,
-		 "%qD is deprecated (declared at %s:%d): %s",
-		 node, xloc.file, xloc.line, msg);
+		 "%qD is deprecated (declared at %r%s:%d%R): %s",
+		 node, "locus", xloc.file, xloc.line, msg);
       else
 	warning (OPT_Wdeprecated_declarations,
-		 "%qD is deprecated (declared at %s:%d)",
-		 node, xloc.file, xloc.line);
+		 "%qD is deprecated (declared at %r%s:%d%R)",
+		 node, "locus", xloc.file, xloc.line);
     }
   else if (TYPE_P (node))
     {
@@ -11583,23 +11583,23 @@ warn_deprecated_use (tree node, tree attr)
 	    {
 	      if (msg)
 		warning (OPT_Wdeprecated_declarations,
-			 "%qE is deprecated (declared at %s:%d): %s",
-			 what, xloc.file, xloc.line, msg);
+			 "%qE is deprecated (declared at %r%s:%d%R): %s",
+			 what, "locus", xloc.file, xloc.line, msg);
 	      else
 		warning (OPT_Wdeprecated_declarations,
-			 "%qE is deprecated (declared at %s:%d)", what,
-			 xloc.file, xloc.line);
+			 "%qE is deprecated (declared at %r%s:%d%R)",
+			 what, "locus", xloc.file, xloc.line);
 	    }
 	  else
 	    {
 	      if (msg)
 		warning (OPT_Wdeprecated_declarations,
-			 "type is deprecated (declared at %s:%d): %s",
-			 xloc.file, xloc.line, msg);
+			 "type is deprecated (declared at %r%s:%d%R): %s",
+			 "locus", xloc.file, xloc.line, msg);
 	      else
 		warning (OPT_Wdeprecated_declarations,
-			 "type is deprecated (declared at %s:%d)",
-			 xloc.file, xloc.line);
+			 "type is deprecated (declared at %r%s:%d%R)",
+			 "locus", xloc.file, xloc.line);
 	    }
 	}
       else