[4.8] Backport additional diagnostic support

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

Change-Id: If0d68971ffac2e7bc48576e2453d799a446f7415

1 files changed, 109 insertions, 110 deletions

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.