From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 9D92A388204F for ; Wed, 12 Jun 2024 13:38:05 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 9D92A388204F Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 9D92A388204F Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=170.10.129.124 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1718199492; cv=none; b=hiTDQ66nxbbCuB8sPBFweLVAib2OmNMdl08tqjFTEBiJUTrlX2mlpfxpLfnxc81+FvhuOY8Ajp8j66LqieO0YannU7658MOXhA5Qs32Z9QKPXb+L9makT67nyzFLSfEWP6V9e+OobOvTuzuFejj3GoOZo95zEL1oQxOUgny6VHI= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1718199492; c=relaxed/simple; bh=h0y+jmEHlU6Cimjd9Duz8Y3SUWa730R8tTkz7HvmUr8=; h=DKIM-Signature:From:To:Subject:Date:Message-Id:MIME-Version; b=G4xvuOLROECcN0mPmLaIdY5GXiOqfjxCluSXuiUGZYE65f8zZ68hGXFPO4s7E1bm2exT5SMqiFBL8KtJyXMvyZ1Ff0tkS6YZb3LarBiliq0n/9bTZd9DX/bSMeRFe7bDjz1cpqZyW5fHvKWAVVNJQBfCfoYdve/QclaX3lZlnpE= ARC-Authentication-Results: i=1; server2.sourceware.org DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1718199485; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding; bh=k/zXFDxwnd+e3AXoz/cbaGnsl8ws+gUGbFjaEs5psxg=; b=ObFGPY89hYJEqspTAPEyTF1hr0xoFcmLnqTswcyQGoyVnpZHM2B0sKunzI82UdoBJoCElS tYI95W56ESakeD8vh+XoPJF7Z2usry/R1D+xLTCcnH9H9O3teQAgMxt/ilm3XxEihIJdBi 7BDHjFIYa3WFFQc2a9Jq6t3+9zWOBrM= Received: from mx-prod-mc-01.mail-002.prod.us-west-2.aws.redhat.com (ec2-54-186-198-63.us-west-2.compute.amazonaws.com [54.186.198.63]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-155-l8pkU4ZGO5KBaSS75Va7LQ-1; Wed, 12 Jun 2024 09:38:02 -0400 X-MC-Unique: l8pkU4ZGO5KBaSS75Va7LQ-1 Received: from mx-prod-int-04.mail-002.prod.us-west-2.aws.redhat.com (mx-prod-int-04.mail-002.prod.us-west-2.aws.redhat.com [10.30.177.40]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits) server-digest SHA256) (No client certificate requested) by mx-prod-mc-01.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTPS id 3FAB11956096 for ; Wed, 12 Jun 2024 13:37:56 +0000 (UTC) Received: from t14s.localdomain.com (unknown [10.22.10.12]) by mx-prod-int-04.mail-002.prod.us-west-2.aws.redhat.com (Postfix) with ESMTP id EEE9019560AA; Wed, 12 Jun 2024 13:37:54 +0000 (UTC) From: David Malcolm To: gcc-patches@gcc.gnu.org Cc: David Malcolm Subject: [pushed 1/3] pretty_printer: rename instances named "buffer" to "pp" Date: Wed, 12 Jun 2024 09:37:50 -0400 Message-Id: <20240612133752.558463-1-dmalcolm@redhat.com> MIME-Version: 1.0 X-Scanned-By: MIMEDefang 3.0 on 10.30.177.40 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Transfer-Encoding: 8bit Content-Type: text/plain; charset="US-ASCII"; x-default=true X-Spam-Status: No, score=-10.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H4,RCVD_IN_MSPIKE_WL,RCVD_IN_SBL_CSS,SPF_HELO_NONE,SPF_NONE,TXREP,T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: Various pretty_printer instances are named "buffer", but a pretty_printer *has* a buffer, rather than *is* a buffer. For example, pp_buffer (buffer)->digit_buffer is referring to "buffer"'s buffer's digit_buffer. This mechanical patch renames such variables to "pp", which I find much clearer; the above becomes: pp_buffer (pp)->digit_buffer i.e. "pp's buffer's digit_buffer". No functional change intended. Successfully bootstrapped & regrtested on x86_64-pc-linux-gnu. Successful run of analyzer integration tests on x86_64-pc-linux-gnu. Pushed to trunk as r15-1208-gfc47393acfae81. Signed-off-by: David Malcolm gcc/c-family/ChangeLog: * c-ada-spec.cc: Rename pretty_printer "buffer" to "pp" throughout. gcc/ChangeLog: * gimple-pretty-print.cc: Rename pretty_printer "buffer" to "pp" throughout. * print-tree.cc (print_node): Likewise. * tree-loop-distribution.cc (dot_rdg_1): Likewise. * tree-pretty-print.h (dump_location): Likewise. * value-range.cc (vrange::dump): Likewise. (irange_bitmask::dump): Likewise. Signed-off-by: David Malcolm --- gcc/c-family/c-ada-spec.cc | 876 ++++++++-------- gcc/gimple-pretty-print.cc | 1774 ++++++++++++++++----------------- gcc/print-tree.cc | 8 +- gcc/tree-loop-distribution.cc | 10 +- gcc/tree-pretty-print.h | 2 +- gcc/value-range.cc | 26 +- 6 files changed, 1348 insertions(+), 1348 deletions(-) diff --git a/gcc/c-family/c-ada-spec.cc b/gcc/c-family/c-ada-spec.cc index 0bea923220bb..e0e72493151b 100644 --- a/gcc/c-family/c-ada-spec.cc +++ b/gcc/c-family/c-ada-spec.cc @@ -40,7 +40,7 @@ static void dump_ada_structure (pretty_printer *, tree, tree, bool, int); static char *to_ada_name (const char *, bool *); #define INDENT(SPACE) \ - do { int i; for (i = 0; i True, "); + pp_string (pp, "with Import => True, "); - newline_and_indent (buffer, spc + 5); + newline_and_indent (pp, spc + 5); if (is_stdcall) - pp_string (buffer, "Convention => Stdcall, "); + pp_string (pp, "Convention => Stdcall, "); else if (name[0] == '_' && name[1] == 'Z') - pp_string (buffer, "Convention => CPP, "); + pp_string (pp, "Convention => CPP, "); else - pp_string (buffer, "Convention => C, "); + pp_string (pp, "Convention => C, "); - newline_and_indent (buffer, spc + 5); + newline_and_indent (pp, spc + 5); tree sec = lookup_attribute ("section", DECL_ATTRIBUTES (t)); if (sec) { - pp_string (buffer, "Linker_Section => \""); - pp_string (buffer, TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (sec)))); - pp_string (buffer, "\", "); - newline_and_indent (buffer, spc + 5); + pp_string (pp, "Linker_Section => \""); + pp_string (pp, TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (sec)))); + pp_string (pp, "\", "); + newline_and_indent (pp, spc + 5); } - pp_string (buffer, "External_Name => \""); + pp_string (pp, "External_Name => \""); if (is_stdcall) - pp_string (buffer, IDENTIFIER_POINTER (DECL_NAME (t))); + pp_string (pp, IDENTIFIER_POINTER (DECL_NAME (t))); else - pp_asm_name (buffer, t); + pp_asm_name (pp, t); - pp_string (buffer, "\";"); + pp_string (pp, "\";"); } /* Check whether T and its type have different names, and append "the_" - otherwise in BUFFER. */ + otherwise in PP. */ static void -check_type_name_conflict (pretty_printer *buffer, tree t) +check_type_name_conflict (pretty_printer *pp, tree t) { tree tmp = TREE_TYPE (t); @@ -1626,18 +1626,18 @@ check_type_name_conflict (pretty_printer *buffer, tree t) s = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (tmp))); if (!strcasecmp (IDENTIFIER_POINTER (DECL_NAME (t)), s)) - pp_string (buffer, "the_"); + pp_string (pp, "the_"); } } -/* Dump in BUFFER a function declaration FUNC in Ada syntax. +/* Dump in PP a function declaration FUNC in Ada syntax. IS_METHOD indicates whether FUNC is a C++ method. IS_CONSTRUCTOR whether FUNC is a C++ constructor. IS_DESTRUCTOR whether FUNC is a C++ destructor. SPC is the current indentation level. */ static void -dump_ada_function_declaration (pretty_printer *buffer, tree func, +dump_ada_function_declaration (pretty_printer *pp, tree func, bool is_method, bool is_constructor, bool is_destructor, int spc) { @@ -1670,12 +1670,12 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func, num_args = 1; if (num_args > 2) - newline_and_indent (buffer, spc + 1); + newline_and_indent (pp, spc + 1); if (num_args > 0) { - pp_space (buffer); - pp_left_paren (buffer); + pp_space (pp); + pp_left_paren (pp); } /* For a function, see if we have the corresponding arguments. */ @@ -1707,24 +1707,24 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func, { if (DECL_NAME (arg)) { - check_type_name_conflict (buffer, arg); - pp_ada_tree_identifier (buffer, DECL_NAME (arg), NULL_TREE, + check_type_name_conflict (pp, arg); + pp_ada_tree_identifier (pp, DECL_NAME (arg), NULL_TREE, false); - pp_string (buffer, " : "); + pp_string (pp, " : "); } else { sprintf (buf, "arg%d : ", num); - pp_string (buffer, buf); + pp_string (pp, buf); } - dump_ada_node (buffer, TREE_TYPE (arg), type, spc, false, true); + dump_ada_node (pp, TREE_TYPE (arg), type, spc, false, true); } else { sprintf (buf, "arg%d : ", num); - pp_string (buffer, buf); - dump_ada_node (buffer, TREE_VALUE (arg), type, spc, false, true); + pp_string (pp, buf); + dump_ada_node (pp, TREE_VALUE (arg), type, spc, false, true); } /* If the type is a pointer to a tagged type, we need to differentiate @@ -1738,47 +1738,47 @@ dump_ada_function_declaration (pretty_printer *buffer, tree func, && POINTER_TYPE_P (TREE_TYPE (arg)) && is_tagged_type (TREE_TYPE (TREE_TYPE (arg))) && !(num == 1 && is_method && (DECL_VINDEX (func) || is_constructor))) - pp_string (buffer, "'Class"); + pp_string (pp, "'Class"); arg = TREE_CHAIN (arg); if (num < num_args) { - pp_semicolon (buffer); + pp_semicolon (pp); if (num_args > 2) - newline_and_indent (buffer, spc + INDENT_INCR); + newline_and_indent (pp, spc + INDENT_INCR); else - pp_space (buffer); + pp_space (pp); } } if (have_ellipsis) { - pp_string (buffer, " -- , ..."); - newline_and_indent (buffer, spc + INDENT_INCR); + pp_string (pp, " -- , ..."); + newline_and_indent (pp, spc + INDENT_INCR); } if (num_args > 0) - pp_right_paren (buffer); + pp_right_paren (pp); if (is_constructor || !VOID_TYPE_P (TREE_TYPE (type))) { - pp_string (buffer, " return "); + pp_string (pp, " return "); tree rtype = is_constructor ? DECL_CONTEXT (func) : TREE_TYPE (type); - dump_ada_node (buffer, rtype, rtype, spc, false, true); + dump_ada_node (pp, rtype, rtype, spc, false, true); } } -/* Dump in BUFFER all the domains associated with an array NODE, +/* Dump in PP all the domains associated with an array NODE, in Ada syntax. SPC is the current indentation level. */ static void -dump_ada_array_domains (pretty_printer *buffer, tree node, int spc) +dump_ada_array_domains (pretty_printer *pp, tree node, int spc) { bool first = true; - pp_left_paren (buffer); + pp_left_paren (pp); for (; TREE_CODE (node) == ARRAY_TYPE; node = TREE_TYPE (node)) { @@ -1790,33 +1790,33 @@ dump_ada_array_domains (pretty_printer *buffer, tree node, int spc) tree max = TYPE_MAX_VALUE (domain); if (!first) - pp_string (buffer, ", "); + pp_string (pp, ", "); first = false; if (min) - dump_ada_node (buffer, min, NULL_TREE, spc, false, true); - pp_string (buffer, " .. "); + dump_ada_node (pp, min, NULL_TREE, spc, false, true); + pp_string (pp, " .. "); /* If the upper bound is zero, gcc may generate a NULL_TREE for TYPE_MAX_VALUE rather than an integer_cst. */ if (max) - dump_ada_node (buffer, max, NULL_TREE, spc, false, true); + dump_ada_node (pp, max, NULL_TREE, spc, false, true); else - pp_string (buffer, "0"); + pp_string (pp, "0"); } else { - pp_string (buffer, "size_t"); + pp_string (pp, "size_t"); first = false; } } - pp_right_paren (buffer); + pp_right_paren (pp); } -/* Dump in BUFFER file:line information related to NODE. */ +/* Dump in PP file:line information related to NODE. */ static void -dump_sloc (pretty_printer *buffer, tree node) +dump_sloc (pretty_printer *pp, tree node) { expanded_location xloc; @@ -1829,9 +1829,9 @@ dump_sloc (pretty_printer *buffer, tree node) if (xloc.file) { - pp_string (buffer, xloc.file); - pp_colon (buffer); - pp_decimal_int (buffer, xloc.line); + pp_string (pp, xloc.file); + pp_colon (pp); + pp_decimal_int (pp, xloc.line); } } @@ -1845,68 +1845,68 @@ is_char_array (tree t) && id_equal (DECL_NAME (TYPE_NAME (TREE_TYPE (t))), "char"); } -/* Dump in BUFFER an array type NODE in Ada syntax. SPC is the indentation +/* Dump in PP an array type NODE in Ada syntax. SPC is the indentation level. */ static void -dump_ada_array_type (pretty_printer *buffer, tree node, int spc) +dump_ada_array_type (pretty_printer *pp, tree node, int spc) { const bool char_array = is_char_array (node); /* Special case char arrays. */ if (char_array) - pp_string (buffer, "Interfaces.C.char_array "); + pp_string (pp, "Interfaces.C.char_array "); else - pp_string (buffer, "array "); + pp_string (pp, "array "); /* Print the dimensions. */ - dump_ada_array_domains (buffer, node, spc); + dump_ada_array_domains (pp, node, spc); /* Print the component type. */ if (!char_array) { tree tmp = strip_array_types (node); - pp_string (buffer, " of "); + pp_string (pp, " of "); if (TREE_CODE (tmp) != POINTER_TYPE && !packed_layout) - pp_string (buffer, "aliased "); + pp_string (pp, "aliased "); if (TYPE_NAME (tmp) || (!RECORD_OR_UNION_TYPE_P (tmp) && TREE_CODE (tmp) != ENUMERAL_TYPE)) - dump_ada_node (buffer, tmp, node, spc, false, true); + dump_ada_node (pp, tmp, node, spc, false, true); else - dump_anonymous_type_name (buffer, tmp); + dump_anonymous_type_name (pp, tmp); } } -/* Dump in BUFFER type names associated with a template, each prepended with +/* Dump in PP type names associated with a template, each prepended with '_'. TYPES is the TREE_PURPOSE of a DECL_TEMPLATE_INSTANTIATIONS. SPC is the indentation level. */ static void -dump_template_types (pretty_printer *buffer, tree types, int spc) +dump_template_types (pretty_printer *pp, tree types, int spc) { for (int i = 0; i < TREE_VEC_LENGTH (types); i++) { tree elem = TREE_VEC_ELT (types, i); - pp_underscore (buffer); + pp_underscore (pp); - if (!dump_ada_node (buffer, elem, NULL_TREE, spc, false, true)) + if (!dump_ada_node (pp, elem, NULL_TREE, spc, false, true)) { - pp_string (buffer, "unknown"); - pp_scalar (buffer, HOST_SIZE_T_PRINT_UNSIGNED, + pp_string (pp, "unknown"); + pp_scalar (pp, HOST_SIZE_T_PRINT_UNSIGNED, (fmt_size_t) TREE_HASH (elem)); } } } -/* Dump in BUFFER the contents of all class instantiations associated with +/* Dump in PP the contents of all class instantiations associated with a given template T. SPC is the indentation level. */ static int -dump_ada_template (pretty_printer *buffer, tree t, int spc) +dump_ada_template (pretty_printer *pp, tree t, int spc) { /* DECL_SIZE_UNIT is DECL_TEMPLATE_INSTANTIATIONS in this context. */ tree inst = DECL_SIZE_UNIT (t); @@ -1945,39 +1945,39 @@ dump_ada_template (pretty_printer *buffer, tree t, int spc) num_inst++; INDENT (spc); - pp_string (buffer, "package "); + pp_string (pp, "package "); package_prefix = false; - dump_ada_node (buffer, instance, t, spc, false, true); - dump_template_types (buffer, types, spc); - pp_string (buffer, " is"); + dump_ada_node (pp, instance, t, spc, false, true); + dump_template_types (pp, types, spc); + pp_string (pp, " is"); spc += INDENT_INCR; - newline_and_indent (buffer, spc); + newline_and_indent (pp, spc); TREE_VISITED (get_underlying_decl (instance)) = 1; - pp_string (buffer, "type "); - dump_ada_node (buffer, instance, t, spc, false, true); + pp_string (pp, "type "); + dump_ada_node (pp, instance, t, spc, false, true); package_prefix = true; if (is_tagged_type (instance)) - pp_string (buffer, " is tagged limited "); + pp_string (pp, " is tagged limited "); else - pp_string (buffer, " is limited "); + pp_string (pp, " is limited "); - dump_ada_node (buffer, instance, t, spc, false, false); - pp_newline (buffer); + dump_ada_node (pp, instance, t, spc, false, false); + pp_newline (pp); spc -= INDENT_INCR; - newline_and_indent (buffer, spc); + newline_and_indent (pp, spc); - pp_string (buffer, "end;"); - newline_and_indent (buffer, spc); - pp_string (buffer, "use "); + pp_string (pp, "end;"); + newline_and_indent (pp, spc); + pp_string (pp, "use "); package_prefix = false; - dump_ada_node (buffer, instance, t, spc, false, true); - dump_template_types (buffer, types, spc); + dump_ada_node (pp, instance, t, spc, false, true); + dump_template_types (pp, types, spc); package_prefix = true; - pp_semicolon (buffer); - pp_newline (buffer); - pp_newline (buffer); + pp_semicolon (pp); + pp_newline (pp); + pp_newline (pp); } return num_inst > 0; @@ -2007,41 +2007,41 @@ is_simple_enum (tree node) return true; } -/* Dump in BUFFER the declaration of enumeral NODE of type TYPE in Ada syntax. +/* Dump in PP the declaration of enumeral NODE of type TYPE in Ada syntax. SPC is the indentation level. */ static void -dump_ada_enum_type (pretty_printer *buffer, tree node, tree type, int spc) +dump_ada_enum_type (pretty_printer *pp, tree node, tree type, int spc) { if (is_simple_enum (node)) { bool first = true; spc += INDENT_INCR; - newline_and_indent (buffer, spc - 1); - pp_left_paren (buffer); + newline_and_indent (pp, spc - 1); + pp_left_paren (pp); for (tree value = TYPE_VALUES (node); value; value = TREE_CHAIN (value)) { if (first) first = false; else { - pp_comma (buffer); - newline_and_indent (buffer, spc); + pp_comma (pp); + newline_and_indent (pp, spc); } - pp_ada_tree_identifier (buffer, TREE_PURPOSE (value), node, false); + pp_ada_tree_identifier (pp, TREE_PURPOSE (value), node, false); } - pp_string (buffer, ")"); + pp_string (pp, ")"); spc -= INDENT_INCR; - newline_and_indent (buffer, spc); - pp_string (buffer, "with Convention => C"); + newline_and_indent (pp, spc); + pp_string (pp, "with Convention => C"); } else { if (TYPE_UNSIGNED (node)) - pp_string (buffer, "unsigned"); + pp_string (pp, "unsigned"); else - pp_string (buffer, "int"); + pp_string (pp, "int"); for (tree value = TYPE_VALUES (node); value; value = TREE_CHAIN (value)) { @@ -2050,29 +2050,29 @@ dump_ada_enum_type (pretty_printer *buffer, tree node, tree type, int spc) if (TREE_CODE (int_val) != INTEGER_CST) int_val = DECL_INITIAL (int_val); - pp_semicolon (buffer); - newline_and_indent (buffer, spc); + pp_semicolon (pp); + newline_and_indent (pp, spc); if (TYPE_NAME (node)) - dump_ada_node (buffer, node, NULL_TREE, spc, false, true); + dump_ada_node (pp, node, NULL_TREE, spc, false, true); else if (type) - dump_ada_node (buffer, type, NULL_TREE, spc, false, true); + dump_ada_node (pp, type, NULL_TREE, spc, false, true); else - dump_anonymous_type_name (buffer, node); - pp_underscore (buffer); - pp_ada_tree_identifier (buffer, TREE_PURPOSE (value), node, false); + dump_anonymous_type_name (pp, node); + pp_underscore (pp); + pp_ada_tree_identifier (pp, TREE_PURPOSE (value), node, false); - pp_string (buffer, " : constant "); + pp_string (pp, " : constant "); if (TYPE_NAME (node)) - dump_ada_node (buffer, node, NULL_TREE, spc, false, true); + dump_ada_node (pp, node, NULL_TREE, spc, false, true); else if (type) - dump_ada_node (buffer, type, NULL_TREE, spc, false, true); + dump_ada_node (pp, type, NULL_TREE, spc, false, true); else - dump_anonymous_type_name (buffer, node); + dump_anonymous_type_name (pp, node); - pp_string (buffer, " := "); - dump_ada_node (buffer, int_val, node, spc, false, true); + pp_string (pp, " := "); + dump_ada_node (pp, int_val, node, spc, false, true); } } } @@ -2127,13 +2127,13 @@ is_float128 (tree node) || id_equal (name, "_Float128x"); } -/* Recursively dump in BUFFER Ada declarations corresponding to NODE of type +/* Recursively dump in PP Ada declarations corresponding to NODE of type TYPE. SPC is the indentation level. LIMITED_ACCESS indicates whether NODE can be referenced via a "limited with" clause. NAME_ONLY indicates whether we should only dump the name of NODE, instead of its full declaration. */ static int -dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, +dump_ada_node (pretty_printer *pp, tree node, tree type, int spc, bool limited_access, bool name_only) { if (node == NULL_TREE) @@ -2142,24 +2142,24 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, switch (TREE_CODE (node)) { case ERROR_MARK: - pp_string (buffer, "<<< error >>>"); + pp_string (pp, "<<< error >>>"); return 0; case IDENTIFIER_NODE: - pp_ada_tree_identifier (buffer, node, type, limited_access); + pp_ada_tree_identifier (pp, node, type, limited_access); break; case TREE_LIST: - pp_string (buffer, "--- unexpected node: TREE_LIST"); + pp_string (pp, "--- unexpected node: TREE_LIST"); return 0; case TREE_BINFO: - dump_ada_node (buffer, BINFO_TYPE (node), type, spc, limited_access, + dump_ada_node (pp, BINFO_TYPE (node), type, spc, limited_access, name_only); return 0; case TREE_VEC: - pp_string (buffer, "--- unexpected node: TREE_VEC"); + pp_string (pp, "--- unexpected node: TREE_VEC"); return 0; case NULLPTR_TYPE: @@ -2167,63 +2167,63 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, if (package_prefix) { append_withs ("System", false); - pp_string (buffer, "System.Address"); + pp_string (pp, "System.Address"); } else - pp_string (buffer, "address"); + pp_string (pp, "address"); break; case VECTOR_TYPE: - pp_string (buffer, ""); + pp_string (pp, ""); break; case COMPLEX_TYPE: if (is_float128 (TREE_TYPE (node))) { append_withs ("Interfaces.C.Extensions", false); - pp_string (buffer, "Extensions.CFloat_128"); + pp_string (pp, "Extensions.CFloat_128"); } else if (TREE_TYPE (node) == float_type_node) { append_withs ("Ada.Numerics.Complex_Types", false); - pp_string (buffer, "Ada.Numerics.Complex_Types.Complex"); + pp_string (pp, "Ada.Numerics.Complex_Types.Complex"); } else if (TREE_TYPE (node) == double_type_node) { append_withs ("Ada.Numerics.Long_Complex_Types", false); - pp_string (buffer, "Ada.Numerics.Long_Complex_Types.Complex"); + pp_string (pp, "Ada.Numerics.Long_Complex_Types.Complex"); } else if (TREE_TYPE (node) == long_double_type_node) { append_withs ("Ada.Numerics.Long_Long_Complex_Types", false); - pp_string (buffer, "Ada.Numerics.Long_Long_Complex_Types.Complex"); + pp_string (pp, "Ada.Numerics.Long_Long_Complex_Types.Complex"); } else - pp_string (buffer, ""); + pp_string (pp, ""); break; case ENUMERAL_TYPE: if (name_only) - dump_ada_node (buffer, TYPE_NAME (node), node, spc, false, true); + dump_ada_node (pp, TYPE_NAME (node), node, spc, false, true); else - dump_ada_enum_type (buffer, node, type, spc); + dump_ada_enum_type (pp, node, type, spc); break; case REAL_TYPE: if (is_float32 (node)) { - pp_string (buffer, "Float"); + pp_string (pp, "Float"); break; } else if (is_float64 (node)) { - pp_string (buffer, "Long_Float"); + pp_string (pp, "Long_Float"); break; } else if (is_float128 (node)) { append_withs ("Interfaces.C.Extensions", false); - pp_string (buffer, "Extensions.Float_128"); + pp_string (pp, "Extensions.Float_128"); break; } @@ -2238,13 +2238,13 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, "__int128"))) { if (TREE_CODE (TYPE_NAME (node)) == IDENTIFIER_NODE) - pp_ada_tree_identifier (buffer, TYPE_NAME (node), node, + pp_ada_tree_identifier (pp, TYPE_NAME (node), node, limited_access); else if (TREE_CODE (TYPE_NAME (node)) == TYPE_DECL && DECL_NAME (TYPE_NAME (node))) - dump_ada_decl_name (buffer, TYPE_NAME (node), limited_access); + dump_ada_decl_name (pp, TYPE_NAME (node), limited_access); else - pp_string (buffer, ""); + pp_string (pp, ""); } else if (TREE_CODE (node) == INTEGER_TYPE) { @@ -2252,41 +2252,41 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, bitfield_used = true; if (TYPE_PRECISION (node) == 1) - pp_string (buffer, "Extensions.Unsigned_1"); + pp_string (pp, "Extensions.Unsigned_1"); else { - pp_string (buffer, TYPE_UNSIGNED (node) + pp_string (pp, TYPE_UNSIGNED (node) ? "Extensions.Unsigned_" : "Extensions.Signed_"); - pp_decimal_int (buffer, TYPE_PRECISION (node)); + pp_decimal_int (pp, TYPE_PRECISION (node)); } } else - pp_string (buffer, ""); + pp_string (pp, ""); break; case POINTER_TYPE: case REFERENCE_TYPE: if (name_only && TYPE_NAME (node)) - dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access, + dump_ada_node (pp, TYPE_NAME (node), node, spc, limited_access, true); else if (TREE_CODE (TREE_TYPE (node)) == FUNCTION_TYPE) { if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (node)))) - pp_string (buffer, "access procedure"); + pp_string (pp, "access procedure"); else - pp_string (buffer, "access function"); + pp_string (pp, "access function"); - dump_ada_function_declaration (buffer, node, false, false, false, + dump_ada_function_declaration (pp, node, false, false, false, spc + INDENT_INCR); /* If we are dumping the full type, it means we are part of a type definition and need also a Convention C aspect. */ if (!name_only) { - newline_and_indent (buffer, spc); - pp_string (buffer, "with Convention => C"); + newline_and_indent (pp, spc); + pp_string (pp, "with Convention => C"); } } else @@ -2298,14 +2298,14 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, if (VOID_TYPE_P (ref_type)) { if (!name_only) - pp_string (buffer, "new "); + pp_string (pp, "new "); if (package_prefix) { append_withs ("System", false); - pp_string (buffer, "System.Address"); + pp_string (pp, "System.Address"); } else - pp_string (buffer, "address"); + pp_string (pp, "address"); } else { @@ -2314,15 +2314,15 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, && id_equal (DECL_NAME (TYPE_NAME (ref_type)), "char")) { if (!name_only) - pp_string (buffer, "new "); + pp_string (pp, "new "); if (package_prefix) { - pp_string (buffer, "Interfaces.C.Strings.chars_ptr"); + pp_string (pp, "Interfaces.C.Strings.chars_ptr"); append_withs ("Interfaces.C.Strings", false); } else - pp_string (buffer, "chars_ptr"); + pp_string (pp, "chars_ptr"); } else { @@ -2336,40 +2336,40 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, { append_withs ("System", false); if (!name_only) - pp_string (buffer, "new "); - pp_string (buffer, "System.Address"); + pp_string (pp, "new "); + pp_string (pp, "System.Address"); } else - pp_string (buffer, "address"); + pp_string (pp, "address"); return spc; } if (!package_prefix) { is_access = false; - pp_string (buffer, "access"); + pp_string (pp, "access"); } else if (AGGREGATE_TYPE_P (ref_type)) { if (!type || TREE_CODE (type) != FUNCTION_DECL) { is_access = true; - pp_string (buffer, "access "); + pp_string (pp, "access "); if (quals & TYPE_QUAL_CONST) - pp_string (buffer, "constant "); + pp_string (pp, "constant "); else if (!name_only) - pp_string (buffer, "all "); + pp_string (pp, "all "); } else if (quals & TYPE_QUAL_CONST) { is_access = false; - pp_string (buffer, "in "); + pp_string (pp, "in "); } else { is_access = true; - pp_string (buffer, "access "); + pp_string (pp, "access "); } } else @@ -2377,10 +2377,10 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, /* We want to use regular with clauses for scalar types, as they are not involved in circular declarations. */ is_access = false; - pp_string (buffer, "access "); + pp_string (pp, "access "); if (!name_only) - pp_string (buffer, "all "); + pp_string (pp, "all "); } /* If this is the anonymous original type of a typedef'ed @@ -2421,7 +2421,7 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, break; } - dump_ada_node (buffer, ref_type, ref_type, spc, is_access, + dump_ada_node (pp, ref_type, ref_type, spc, is_access, true); } } @@ -2430,19 +2430,19 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, case ARRAY_TYPE: if (name_only) - dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access, + dump_ada_node (pp, TYPE_NAME (node), node, spc, limited_access, true); else - dump_ada_array_type (buffer, node, spc); + dump_ada_array_type (pp, node, spc); break; case RECORD_TYPE: case UNION_TYPE: if (name_only) - dump_ada_node (buffer, TYPE_NAME (node), node, spc, limited_access, + dump_ada_node (pp, TYPE_NAME (node), node, spc, limited_access, true); else - dump_ada_structure (buffer, node, type, false, spc); + dump_ada_structure (pp, node, type, false, spc); break; case INTEGER_CST: @@ -2452,25 +2452,25 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, if (TREE_TYPE (node) == sizetype) node = fold_convert (ssizetype, node); if (tree_fits_shwi_p (node)) - pp_wide_integer (buffer, tree_to_shwi (node)); + pp_wide_integer (pp, tree_to_shwi (node)); else if (tree_fits_uhwi_p (node)) - pp_unsigned_wide_integer (buffer, tree_to_uhwi (node)); + pp_unsigned_wide_integer (pp, tree_to_uhwi (node)); else { wide_int val = wi::to_wide (node); int i; if (wi::neg_p (val)) { - pp_minus (buffer); + pp_minus (pp); val = -val; } - sprintf (pp_buffer (buffer)->digit_buffer, + sprintf (pp_buffer (pp)->digit_buffer, "16#%" HOST_WIDE_INT_PRINT "x", val.elt (val.get_len () - 1)); for (i = val.get_len () - 2; i >= 0; i--) - sprintf (pp_buffer (buffer)->digit_buffer, + sprintf (pp_buffer (pp)->digit_buffer, HOST_WIDE_INT_PRINT_PADDED_HEX, val.elt (i)); - pp_string (buffer, pp_buffer (buffer)->digit_buffer); + pp_string (pp, pp_buffer (pp)->digit_buffer); } break; @@ -2492,14 +2492,14 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, if (package_prefix) { append_withs ("System", false); - pp_string (buffer, "System.Address"); + pp_string (pp, "System.Address"); } else - pp_string (buffer, "address"); + pp_string (pp, "address"); } } else if (name_only) - dump_ada_decl_name (buffer, node, limited_access); + dump_ada_decl_name (pp, node, limited_access); else { if (is_tagged_type (TREE_TYPE (node))) @@ -2515,23 +2515,23 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, { if (first) { - pp_string (buffer, "limited new "); + pp_string (pp, "limited new "); first = false; } else - pp_string (buffer, " and "); + pp_string (pp, " and "); - dump_ada_decl_name (buffer, TYPE_NAME (TREE_TYPE (fld)), + dump_ada_decl_name (pp, TYPE_NAME (TREE_TYPE (fld)), false); } } - pp_string (buffer, first ? "tagged limited " : " with "); + pp_string (pp, first ? "tagged limited " : " with "); } else if (has_nontrivial_methods (TREE_TYPE (node))) - pp_string (buffer, "limited "); + pp_string (pp, "limited "); - dump_ada_node (buffer, TREE_TYPE (node), type, spc, false, false); + dump_ada_node (pp, TREE_TYPE (node), type, spc, false, false); } break; @@ -2541,7 +2541,7 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, case PARM_DECL: case FIELD_DECL: case NAMESPACE_DECL: - dump_ada_decl_name (buffer, node, false); + dump_ada_decl_name (pp, node, false); break; default: @@ -2552,16 +2552,16 @@ dump_ada_node (pretty_printer *buffer, tree node, tree type, int spc, return 1; } -/* Dump in BUFFER NODE's methods. SPC is the indentation level. Return 1 if +/* Dump in PP NODE's methods. SPC is the indentation level. Return 1 if methods were printed, 0 otherwise. */ static int -dump_ada_methods (pretty_printer *buffer, tree node, int spc) +dump_ada_methods (pretty_printer *pp, tree node, int spc) { if (!has_nontrivial_methods (node)) return 0; - pp_semicolon (buffer); + pp_semicolon (pp); int res = 1; for (tree fld = TYPE_FIELDS (node); fld; fld = DECL_CHAIN (fld)) @@ -2569,21 +2569,21 @@ dump_ada_methods (pretty_printer *buffer, tree node, int spc) { if (res) { - pp_newline (buffer); - pp_newline (buffer); + pp_newline (pp); + pp_newline (pp); } - res = dump_ada_declaration (buffer, fld, node, spc); + res = dump_ada_declaration (pp, fld, node, spc); } return 1; } -/* Dump in BUFFER a forward declaration for TYPE present inside T. +/* Dump in PP a forward declaration for TYPE present inside T. SPC is the indentation level. */ static void -dump_forward_type (pretty_printer *buffer, tree type, tree t, int spc) +dump_forward_type (pretty_printer *pp, tree type, tree t, int spc) { tree decl = get_underlying_decl (type); @@ -2591,14 +2591,14 @@ dump_forward_type (pretty_printer *buffer, tree type, tree t, int spc) if (!decl) { if (TREE_CODE (type) == POINTER_TYPE) - dump_forward_type (buffer, TREE_TYPE (type), t, spc); + dump_forward_type (pp, TREE_TYPE (type), t, spc); else if (TREE_CODE (type) == FUNCTION_TYPE) { function_args_iterator args_iter; tree arg; - dump_forward_type (buffer, TREE_TYPE (type), t, spc); + dump_forward_type (pp, TREE_TYPE (type), t, spc); FOREACH_FUNCTION_ARGS (type, arg, args_iter) - dump_forward_type (buffer, arg, t, spc); + dump_forward_type (pp, arg, t, spc); } return; } @@ -2614,10 +2614,10 @@ dump_forward_type (pretty_printer *buffer, tree type, tree t, int spc) return; /* Generate an incomplete type declaration. */ - pp_string (buffer, "type "); - dump_ada_node (buffer, decl, NULL_TREE, spc, false, true); - pp_semicolon (buffer); - newline_and_indent (buffer, spc); + pp_string (pp, "type "); + dump_ada_node (pp, decl, NULL_TREE, spc, false, true); + pp_semicolon (pp); + newline_and_indent (pp, spc); /* Only one incomplete declaration is legal for a given type. */ TREE_VISITED (decl) = 1; @@ -2630,7 +2630,7 @@ static bitmap dumped_anonymous_types; static void dump_nested_type (pretty_printer *, tree, tree, int); -/* Dump in BUFFER anonymous types nested inside T's definition. PARENT is the +/* Dump in PP anonymous types nested inside T's definition. PARENT is the parent node of T. DUMPED_TYPES is the bitmap of already dumped types. SPC is the indentation level. @@ -2644,7 +2644,7 @@ static void dump_nested_type (pretty_printer *, tree, tree, int); pass on the nested TYPE_DECLs and a second pass on the unnamed types. */ static void -dump_nested_types (pretty_printer *buffer, tree t, int spc) +dump_nested_types (pretty_printer *pp, tree t, int spc) { tree type, field; @@ -2658,18 +2658,18 @@ dump_nested_types (pretty_printer *buffer, tree t, int spc) && DECL_NAME (field) != DECL_NAME (t) && !DECL_ORIGINAL_TYPE (field) && TYPE_NAME (TREE_TYPE (field)) != TYPE_NAME (type)) - dump_nested_type (buffer, field, t, spc); + dump_nested_type (pp, field, t, spc); for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) if (TREE_CODE (field) == FIELD_DECL && !TYPE_NAME (TREE_TYPE (field))) - dump_nested_type (buffer, field, t, spc); + dump_nested_type (pp, field, t, spc); } -/* Dump in BUFFER the anonymous type of FIELD inside T. SPC is the indentation +/* Dump in PP the anonymous type of FIELD inside T. SPC is the indentation level. */ static void -dump_nested_type (pretty_printer *buffer, tree field, tree t, int spc) +dump_nested_type (pretty_printer *pp, tree field, tree t, int spc) { tree field_type = TREE_TYPE (field); tree decl, tmp; @@ -2678,7 +2678,7 @@ dump_nested_type (pretty_printer *buffer, tree field, tree t, int spc) { case POINTER_TYPE: tmp = TREE_TYPE (field_type); - dump_forward_type (buffer, tmp, t, spc); + dump_forward_type (pp, tmp, t, spc); break; case ARRAY_TYPE: @@ -2694,59 +2694,59 @@ dump_nested_type (pretty_printer *buffer, tree field, tree t, int spc) && !TREE_VISITED (decl)) { /* Generate full declaration. */ - dump_nested_type (buffer, decl, t, spc); + dump_nested_type (pp, decl, t, spc); TREE_VISITED (decl) = 1; } else if (!decl && TREE_CODE (tmp) == POINTER_TYPE) - dump_forward_type (buffer, TREE_TYPE (tmp), t, spc); + dump_forward_type (pp, TREE_TYPE (tmp), t, spc); /* Special case char arrays. */ if (is_char_array (field_type)) - pp_string (buffer, "subtype "); + pp_string (pp, "subtype "); else - pp_string (buffer, "type "); + pp_string (pp, "type "); - dump_anonymous_type_name (buffer, field_type); - pp_string (buffer, " is "); - dump_ada_array_type (buffer, field_type, spc); - pp_semicolon (buffer); - newline_and_indent (buffer, spc); + dump_anonymous_type_name (pp, field_type); + pp_string (pp, " is "); + dump_ada_array_type (pp, field_type, spc); + pp_semicolon (pp); + newline_and_indent (pp, spc); break; case ENUMERAL_TYPE: if (is_simple_enum (field_type)) - pp_string (buffer, "type "); + pp_string (pp, "type "); else - pp_string (buffer, "subtype "); + pp_string (pp, "subtype "); if (TYPE_NAME (field_type)) - dump_ada_node (buffer, field_type, NULL_TREE, spc, false, true); + dump_ada_node (pp, field_type, NULL_TREE, spc, false, true); else - dump_anonymous_type_name (buffer, field_type); - pp_string (buffer, " is "); - dump_ada_enum_type (buffer, field_type, NULL_TREE, spc); - pp_semicolon (buffer); - newline_and_indent (buffer, spc); + dump_anonymous_type_name (pp, field_type); + pp_string (pp, " is "); + dump_ada_enum_type (pp, field_type, NULL_TREE, spc); + pp_semicolon (pp); + newline_and_indent (pp, spc); break; case RECORD_TYPE: case UNION_TYPE: - dump_nested_types (buffer, field, spc); + dump_nested_types (pp, field, spc); - pp_string (buffer, "type "); + pp_string (pp, "type "); if (TYPE_NAME (field_type)) - dump_ada_node (buffer, field_type, NULL_TREE, spc, false, true); + dump_ada_node (pp, field_type, NULL_TREE, spc, false, true); else - dump_anonymous_type_name (buffer, field_type); + dump_anonymous_type_name (pp, field_type); if (TREE_CODE (field_type) == UNION_TYPE) - pp_string (buffer, " (discr : unsigned := 0)"); + pp_string (pp, " (discr : unsigned := 0)"); - pp_string (buffer, " is "); - dump_ada_structure (buffer, field_type, t, true, spc); - pp_semicolon (buffer); - newline_and_indent (buffer, spc); + pp_string (pp, " is "); + dump_ada_structure (pp, field_type, t, true, spc); + pp_semicolon (pp); + newline_and_indent (pp, spc); break; default: @@ -2831,39 +2831,39 @@ overloading_index (tree name) return h ? ++h->n : 0; } -/* Dump in BUFFER constructor spec corresponding to T for TYPE. */ +/* Dump in PP constructor spec corresponding to T for TYPE. */ static void -print_constructor (pretty_printer *buffer, tree t, tree type) +print_constructor (pretty_printer *pp, tree t, tree type) { tree decl_name = DECL_NAME (TYPE_NAME (type)); - pp_string (buffer, "New_"); - pp_ada_tree_identifier (buffer, decl_name, t, false); + pp_string (pp, "New_"); + pp_ada_tree_identifier (pp, decl_name, t, false); } -/* Dump in BUFFER destructor spec corresponding to T. */ +/* Dump in PP destructor spec corresponding to T. */ static void -print_destructor (pretty_printer *buffer, tree t, tree type) +print_destructor (pretty_printer *pp, tree t, tree type) { tree decl_name = DECL_NAME (TYPE_NAME (type)); - pp_string (buffer, "Delete_"); + pp_string (pp, "Delete_"); if (startswith (IDENTIFIER_POINTER (DECL_NAME (t)), "__dt_del")) - pp_string (buffer, "And_Free_"); - pp_ada_tree_identifier (buffer, decl_name, t, false); + pp_string (pp, "And_Free_"); + pp_ada_tree_identifier (pp, decl_name, t, false); } -/* Dump in BUFFER assignment operator spec corresponding to T. */ +/* Dump in PP assignment operator spec corresponding to T. */ static void -print_assignment_operator (pretty_printer *buffer, tree t, tree type) +print_assignment_operator (pretty_printer *pp, tree t, tree type) { tree decl_name = DECL_NAME (TYPE_NAME (type)); - pp_string (buffer, "Assign_"); - pp_ada_tree_identifier (buffer, decl_name, t, false); + pp_string (pp, "Assign_"); + pp_ada_tree_identifier (pp, decl_name, t, false); } /* Return the name of type T. */ @@ -2879,12 +2879,12 @@ type_name (tree t) return IDENTIFIER_POINTER (DECL_NAME (n)); } -/* Dump in BUFFER the declaration of object T of type TYPE in Ada syntax. +/* Dump in PP the declaration of object T of type TYPE in Ada syntax. SPC is the indentation level. Return 1 if a declaration was printed, 0 otherwise. */ static int -dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) +dump_ada_declaration (pretty_printer *pp, tree t, tree type, int spc) { bool is_var = false; bool need_indent = false; @@ -2894,7 +2894,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) tree orig = NULL_TREE; if (cpp_check && cpp_check (t, IS_TEMPLATE)) - return dump_ada_template (buffer, t, spc); + return dump_ada_template (pp, t, spc); /* Skip enumeral values: will be handled as part of the type itself. */ if (TREE_CODE (t) == CONST_DECL && TREE_CODE (TREE_TYPE (t)) == ENUMERAL_TYPE) @@ -2921,7 +2921,7 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) if (RECORD_OR_UNION_TYPE_P (orig) && !TREE_VISITED (stub)) { INDENT (spc); - dump_forward_type (buffer, orig, t, 0); + dump_forward_type (pp, orig, t, 0); } TREE_VISITED (t) = 1; @@ -2931,14 +2931,14 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) INDENT (spc); if (RECORD_OR_UNION_TYPE_P (orig) && !TREE_VISITED (stub)) - dump_forward_type (buffer, orig, t, spc); + dump_forward_type (pp, orig, t, spc); - pp_string (buffer, "subtype "); - dump_ada_node (buffer, t, type, spc, false, true); - pp_string (buffer, " is "); - dump_ada_node (buffer, orig, type, spc, false, true); - pp_string (buffer, "; -- "); - dump_sloc (buffer, t); + pp_string (pp, "subtype "); + dump_ada_node (pp, t, type, spc, false, true); + pp_string (pp, " is "); + dump_ada_node (pp, orig, type, spc, false, true); + pp_string (pp, "; -- "); + dump_sloc (pp, t); TREE_VISITED (t) = 1; return 1; @@ -2976,9 +2976,9 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) case UNION_TYPE: if (!COMPLETE_TYPE_P (TREE_TYPE (t))) { - pp_string (buffer, "type "); - dump_ada_node (buffer, t, type, spc, false, true); - pp_string (buffer, " is null record; -- incomplete struct"); + pp_string (pp, "type "); + dump_ada_node (pp, t, type, spc, false, true); + pp_string (pp, " is null record; -- incomplete struct"); TREE_VISITED (t) = 1; return 1; } @@ -2987,63 +2987,63 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) if (TYPE_PACKED (TREE_TYPE (t))) { warning_at (DECL_SOURCE_LOCATION (t), 0, "packed layout"); - pp_string (buffer, "pragma Compile_Time_Warning (True, "); - pp_string (buffer, "\"packed layout may be incorrect\");"); - newline_and_indent (buffer, spc); + pp_string (pp, "pragma Compile_Time_Warning (True, "); + pp_string (pp, "\"packed layout may be incorrect\");"); + newline_and_indent (pp, spc); packed_layout = true; } if (orig && TYPE_NAME (orig)) - pp_string (buffer, "subtype "); + pp_string (pp, "subtype "); else { if (separate_class_package (t)) { is_class = true; - pp_string (buffer, "package Class_"); - dump_ada_node (buffer, t, type, spc, false, true); - pp_string (buffer, " is"); + pp_string (pp, "package Class_"); + dump_ada_node (pp, t, type, spc, false, true); + pp_string (pp, " is"); spc += INDENT_INCR; - newline_and_indent (buffer, spc); + newline_and_indent (pp, spc); } - dump_nested_types (buffer, t, spc); + dump_nested_types (pp, t, spc); - pp_string (buffer, "type "); + pp_string (pp, "type "); } break; case POINTER_TYPE: case REFERENCE_TYPE: - dump_forward_type (buffer, TREE_TYPE (TREE_TYPE (t)), t, spc); + dump_forward_type (pp, TREE_TYPE (TREE_TYPE (t)), t, spc); if (orig && TYPE_NAME (orig)) - pp_string (buffer, "subtype "); + pp_string (pp, "subtype "); else - pp_string (buffer, "type "); + pp_string (pp, "type "); break; case ARRAY_TYPE: if ((orig && TYPE_NAME (orig)) || is_char_array (TREE_TYPE (t))) - pp_string (buffer, "subtype "); + pp_string (pp, "subtype "); else - pp_string (buffer, "type "); + pp_string (pp, "type "); break; case FUNCTION_TYPE: - pp_string (buffer, "-- skipped function type "); - dump_ada_node (buffer, t, type, spc, false, true); + pp_string (pp, "-- skipped function type "); + dump_ada_node (pp, t, type, spc, false, true); return 1; case ENUMERAL_TYPE: if ((orig && TYPE_NAME (orig) && orig != TREE_TYPE (t)) || !is_simple_enum (TREE_TYPE (t))) - pp_string (buffer, "subtype "); + pp_string (pp, "subtype "); else - pp_string (buffer, "type "); + pp_string (pp, "type "); break; default: - pp_string (buffer, "subtype "); + pp_string (pp, "subtype "); } TREE_VISITED (t) = 1; @@ -3065,34 +3065,34 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) INDENT (spc); /* Print variable's name. */ - dump_ada_node (buffer, t, type, spc, false, true); + dump_ada_node (pp, t, type, spc, false, true); if (TREE_CODE (t) == TYPE_DECL) { - pp_string (buffer, " is "); + pp_string (pp, " is "); if (orig && TYPE_NAME (orig)) - dump_ada_node (buffer, TYPE_NAME (orig), type, spc, false, true); + dump_ada_node (pp, TYPE_NAME (orig), type, spc, false, true); else - dump_ada_array_type (buffer, TREE_TYPE (t), spc); + dump_ada_array_type (pp, TREE_TYPE (t), spc); } else { if (spc == INDENT_INCR || TREE_STATIC (t)) is_var = true; - pp_string (buffer, " : "); + pp_string (pp, " : "); if (TREE_CODE (TREE_TYPE (TREE_TYPE (t))) != POINTER_TYPE && !packed_layout) - pp_string (buffer, "aliased "); + pp_string (pp, "aliased "); if (TYPE_NAME (TREE_TYPE (t))) - dump_ada_node (buffer, TREE_TYPE (t), type, spc, false, true); + dump_ada_node (pp, TREE_TYPE (t), type, spc, false, true); else if (type) - dump_anonymous_type_name (buffer, TREE_TYPE (t)); + dump_anonymous_type_name (pp, TREE_TYPE (t)); else - dump_ada_array_type (buffer, TREE_TYPE (t), spc); + dump_ada_array_type (pp, TREE_TYPE (t), spc); } } else if (TREE_CODE (t) == FUNCTION_DECL) @@ -3149,36 +3149,36 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) else if (!DECL_VINDEX (t) && *IDENTIFIER_POINTER (decl_name) == '_') { INDENT (spc); - pp_string (buffer, "-- skipped func "); - pp_string (buffer, IDENTIFIER_POINTER (decl_name)); + pp_string (pp, "-- skipped func "); + pp_string (pp, IDENTIFIER_POINTER (decl_name)); return 1; } INDENT (spc); - dump_forward_type (buffer, TREE_TYPE (t), t, spc); + dump_forward_type (pp, TREE_TYPE (t), t, spc); if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (t))) && !is_constructor) - pp_string (buffer, "procedure "); + pp_string (pp, "procedure "); else - pp_string (buffer, "function "); + pp_string (pp, "function "); if (is_constructor) - print_constructor (buffer, t, type); + print_constructor (pp, t, type); else if (is_destructor) - print_destructor (buffer, t, type); + print_destructor (pp, t, type); else if (is_assignment_operator) - print_assignment_operator (buffer, t, type); + print_assignment_operator (pp, t, type); else { const unsigned int suffix = overloading_index (decl_name); - pp_ada_tree_identifier (buffer, decl_name, t, false); + pp_ada_tree_identifier (pp, decl_name, t, false); if (suffix > 1) - pp_decimal_int (buffer, suffix); + pp_decimal_int (pp, suffix); } dump_ada_function_declaration - (buffer, t, is_method, is_constructor, is_destructor, spc); + (pp, t, is_method, is_constructor, is_destructor, spc); if (is_constructor && RECORD_OR_UNION_TYPE_P (type)) for (tree fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld)) @@ -3189,34 +3189,34 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) } if (is_abstract || is_abstract_class) - pp_string (buffer, " is abstract"); + pp_string (pp, " is abstract"); if (is_abstract || !DECL_ASSEMBLER_NAME (t)) { - pp_semicolon (buffer); - pp_string (buffer, " -- "); - dump_sloc (buffer, t); + pp_semicolon (pp); + pp_string (pp, " -- "); + dump_sloc (pp, t); } else if (is_constructor) { - pp_semicolon (buffer); - pp_string (buffer, " -- "); - dump_sloc (buffer, t); - - newline_and_indent (buffer, spc); - pp_string (buffer, "pragma CPP_Constructor ("); - print_constructor (buffer, t, type); - pp_string (buffer, ", \""); - pp_asm_name (buffer, t); - pp_string (buffer, "\");"); + pp_semicolon (pp); + pp_string (pp, " -- "); + dump_sloc (pp, t); + + newline_and_indent (pp, spc); + pp_string (pp, "pragma CPP_Constructor ("); + print_constructor (pp, t, type); + pp_string (pp, ", \""); + pp_asm_name (pp, t); + pp_string (pp, "\");"); } else { - pp_string (buffer, " -- "); - dump_sloc (buffer, t); + pp_string (pp, " -- "); + dump_sloc (pp, t); - newline_and_indent (buffer, spc); - dump_ada_import (buffer, t, spc); + newline_and_indent (pp, spc); + dump_ada_import (pp, t, spc); } return 1; @@ -3227,12 +3227,12 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) bool is_abstract_record = false; /* Anonymous structs/unions. */ - dump_ada_node (buffer, TREE_TYPE (t), t, spc, false, true); + dump_ada_node (pp, TREE_TYPE (t), t, spc, false, true); if (TREE_CODE (TREE_TYPE (t)) == UNION_TYPE) - pp_string (buffer, " (discr : unsigned := 0)"); + pp_string (pp, " (discr : unsigned := 0)"); - pp_string (buffer, " is "); + pp_string (pp, " is "); /* Check whether we have an Ada interface compatible class. That is only have a vtable non-static data member and no @@ -3269,20 +3269,20 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) TREE_VISITED (t) = 1; if (is_interface) { - pp_string (buffer, "limited interface -- "); - dump_sloc (buffer, t); - newline_and_indent (buffer, spc); - pp_string (buffer, "with Import => True,"); - newline_and_indent (buffer, spc + 5); - pp_string (buffer, "Convention => CPP"); - - dump_ada_methods (buffer, TREE_TYPE (t), spc); + pp_string (pp, "limited interface -- "); + dump_sloc (pp, t); + newline_and_indent (pp, spc); + pp_string (pp, "with Import => True,"); + newline_and_indent (pp, spc + 5); + pp_string (pp, "Convention => CPP"); + + dump_ada_methods (pp, TREE_TYPE (t), spc); } else { if (is_abstract_record) - pp_string (buffer, "abstract "); - dump_ada_node (buffer, t, t, spc, false, false); + pp_string (pp, "abstract "); + dump_ada_node (pp, t, t, spc, false, false); } } else @@ -3292,84 +3292,84 @@ dump_ada_declaration (pretty_printer *buffer, tree t, tree type, int spc) if ((TREE_CODE (t) == FIELD_DECL || VAR_P (t)) && DECL_NAME (t)) - check_type_name_conflict (buffer, t); + check_type_name_conflict (pp, t); /* Print variable/type's name. */ - dump_ada_node (buffer, t, t, spc, false, true); + dump_ada_node (pp, t, t, spc, false, true); if (TREE_CODE (t) == TYPE_DECL) { const bool is_subtype = TYPE_NAME (orig); if (!is_subtype && TREE_CODE (TREE_TYPE (t)) == UNION_TYPE) - pp_string (buffer, " (discr : unsigned := 0)"); + pp_string (pp, " (discr : unsigned := 0)"); - pp_string (buffer, " is "); + pp_string (pp, " is "); - dump_ada_node (buffer, orig, t, spc, false, is_subtype); + dump_ada_node (pp, orig, t, spc, false, is_subtype); } else { if (spc == INDENT_INCR || TREE_STATIC (t)) is_var = true; - pp_string (buffer, " : "); + pp_string (pp, " : "); if (TREE_CODE (TREE_TYPE (t)) != POINTER_TYPE && (TYPE_NAME (TREE_TYPE (t)) || (TREE_CODE (TREE_TYPE (t)) != INTEGER_TYPE && TREE_CODE (TREE_TYPE (t)) != ENUMERAL_TYPE)) && !packed_layout) - pp_string (buffer, "aliased "); + pp_string (pp, "aliased "); if (TREE_READONLY (t) && TREE_CODE (t) != FIELD_DECL) - pp_string (buffer, "constant "); + pp_string (pp, "constant "); if (TYPE_NAME (TREE_TYPE (t)) || (!RECORD_OR_UNION_TYPE_P (TREE_TYPE (t)) && TREE_CODE (TREE_TYPE (t)) != ENUMERAL_TYPE)) - dump_ada_node (buffer, TREE_TYPE (t), t, spc, false, true); + dump_ada_node (pp, TREE_TYPE (t), t, spc, false, true); else if (type) - dump_anonymous_type_name (buffer, TREE_TYPE (t)); + dump_anonymous_type_name (pp, TREE_TYPE (t)); } } if (is_class) { spc -= INDENT_INCR; - newline_and_indent (buffer, spc); - pp_string (buffer, "end;"); - newline_and_indent (buffer, spc); - pp_string (buffer, "use Class_"); - dump_ada_node (buffer, t, type, spc, false, true); - pp_semicolon (buffer); - pp_newline (buffer); + newline_and_indent (pp, spc); + pp_string (pp, "end;"); + newline_and_indent (pp, spc); + pp_string (pp, "use Class_"); + dump_ada_node (pp, t, type, spc, false, true); + pp_semicolon (pp); + pp_newline (pp); /* All needed indentation/newline performed already, so return 0. */ return 0; } else if (is_var) { - pp_string (buffer, " -- "); - dump_sloc (buffer, t); - newline_and_indent (buffer, spc); - dump_ada_import (buffer, t, spc); + pp_string (pp, " -- "); + dump_sloc (pp, t); + newline_and_indent (pp, spc); + dump_ada_import (pp, t, spc); } else { - pp_string (buffer, "; -- "); - dump_sloc (buffer, t); + pp_string (pp, "; -- "); + dump_sloc (pp, t); } return 1; } -/* Dump in BUFFER a structure NODE of type TYPE in Ada syntax. If NESTED is +/* Dump in PP a structure NODE of type TYPE in Ada syntax. If NESTED is true, it's an anonymous nested type. SPC is the indentation level. */ static void -dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested, +dump_ada_structure (pretty_printer *pp, tree node, tree type, bool nested, int spc) { const bool is_union = (TREE_CODE (node) == UNION_TYPE); @@ -3381,16 +3381,16 @@ dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested, bitfield_used = false; /* Print the contents of the structure. */ - pp_string (buffer, "record"); + pp_string (pp, "record"); if (is_union) { - newline_and_indent (buffer, spc + INDENT_INCR); - pp_string (buffer, "case discr is"); + newline_and_indent (pp, spc + INDENT_INCR); + pp_string (pp, "case discr is"); field_spc = spc + INDENT_INCR * 3; } - pp_newline (buffer); + pp_newline (pp); /* Print the non-static fields of the structure. */ for (tree tmp = TYPE_FIELDS (node); tmp; tmp = TREE_CHAIN (tmp)) @@ -3401,24 +3401,24 @@ dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested, if (!is_tagged_type (TREE_TYPE (tmp))) { if (!TYPE_NAME (TREE_TYPE (tmp))) - dump_ada_declaration (buffer, tmp, type, field_spc); + dump_ada_declaration (pp, tmp, type, field_spc); else { INDENT (field_spc); if (field_num == 0) - pp_string (buffer, "parent : aliased "); + pp_string (pp, "parent : aliased "); else { sprintf (buf, "field_%d : aliased ", field_num + 1); - pp_string (buffer, buf); + pp_string (pp, buf); } - dump_ada_decl_name (buffer, TYPE_NAME (TREE_TYPE (tmp)), + dump_ada_decl_name (pp, TYPE_NAME (TREE_TYPE (tmp)), false); - pp_semicolon (buffer); + pp_semicolon (pp); } - pp_newline (buffer); + pp_newline (pp); field_num++; } } @@ -3437,13 +3437,13 @@ dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested, sprintf (buf, "when others =>"); INDENT (spc + INDENT_INCR * 2); - pp_string (buffer, buf); - pp_newline (buffer); + pp_string (pp, buf); + pp_newline (pp); } - if (dump_ada_declaration (buffer, tmp, type, field_spc)) + if (dump_ada_declaration (pp, tmp, type, field_spc)) { - pp_newline (buffer); + pp_newline (pp); field_num++; } } @@ -3453,49 +3453,49 @@ dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested, if (is_union) { INDENT (spc + INDENT_INCR); - pp_string (buffer, "end case;"); - pp_newline (buffer); + pp_string (pp, "end case;"); + pp_newline (pp); } if (field_num == 0) { INDENT (spc + INDENT_INCR); - pp_string (buffer, "null;"); - pp_newline (buffer); + pp_string (pp, "null;"); + pp_newline (pp); } INDENT (spc); - pp_string (buffer, "end record"); + pp_string (pp, "end record"); - newline_and_indent (buffer, spc); + newline_and_indent (pp, spc); /* We disregard the methods for anonymous nested types. */ if (has_nontrivial_methods (node) && !nested) { - pp_string (buffer, "with Import => True,"); - newline_and_indent (buffer, spc + 5); - pp_string (buffer, "Convention => CPP"); + pp_string (pp, "with Import => True,"); + newline_and_indent (pp, spc + 5); + pp_string (pp, "Convention => CPP"); } else - pp_string (buffer, "with Convention => C_Pass_By_Copy"); + pp_string (pp, "with Convention => C_Pass_By_Copy"); if (is_union) { - pp_comma (buffer); - newline_and_indent (buffer, spc + 5); - pp_string (buffer, "Unchecked_Union => True"); + pp_comma (pp); + newline_and_indent (pp, spc + 5); + pp_string (pp, "Unchecked_Union => True"); } if (bitfield_used || packed_layout) { char buf[32]; - pp_comma (buffer); - newline_and_indent (buffer, spc + 5); - pp_string (buffer, "Pack => True"); - pp_comma (buffer); - newline_and_indent (buffer, spc + 5); + pp_comma (pp); + newline_and_indent (pp, spc + 5); + pp_string (pp, "Pack => True"); + pp_comma (pp); + newline_and_indent (pp, spc + 5); sprintf (buf, "Alignment => %d", TYPE_ALIGN (node) / BITS_PER_UNIT); - pp_string (buffer, buf); + pp_string (pp, buf); bitfield_used = false; packed_layout = false; } @@ -3503,7 +3503,7 @@ dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested, if (nested) return; - need_semicolon = !dump_ada_methods (buffer, node, spc); + need_semicolon = !dump_ada_methods (pp, node, spc); /* Print the static fields of the structure, if any. */ for (tree tmp = TYPE_FIELDS (node); tmp; tmp = TREE_CHAIN (tmp)) @@ -3513,11 +3513,11 @@ dump_ada_structure (pretty_printer *buffer, tree node, tree type, bool nested, if (need_semicolon) { need_semicolon = false; - pp_semicolon (buffer); + pp_semicolon (pp); } - pp_newline (buffer); - pp_newline (buffer); - dump_ada_declaration (buffer, tmp, type, spc); + pp_newline (pp); + pp_newline (pp); + dump_ada_declaration (pp, tmp, type, spc); } } } diff --git a/gcc/gimple-pretty-print.cc b/gcc/gimple-pretty-print.cc index a71e1e0efc77..285d76b35406 100644 --- a/gcc/gimple-pretty-print.cc +++ b/gcc/gimple-pretty-print.cc @@ -53,27 +53,27 @@ along with GCC; see the file COPYING3. If not see #endif #define INDENT(SPACE) \ - do { int i; for (i = 0; i < SPACE; i++) pp_space (buffer); } while (0) + do { int i; for (i = 0; i < SPACE; i++) pp_space (pp); } while (0) -#define GIMPLE_NIY do_niy (buffer,gs) +#define GIMPLE_NIY do_niy (pp,gs) -/* Try to print on BUFFER a default message for the unrecognized +/* Try to print on PP a default message for the unrecognized gimple statement GS. */ static void -do_niy (pretty_printer *buffer, const gimple *gs) +do_niy (pretty_printer *pp, const gimple *gs) { - pp_printf (buffer, "<<< Unknown GIMPLE statement: %s >>>\n", + pp_printf (pp, "<<< Unknown GIMPLE statement: %s >>>\n", gimple_code_name[(int) gimple_code (gs)]); } -/* Emit a newline and SPC indentation spaces to BUFFER. */ +/* Emit a newline and SPC indentation spaces to PP. */ static void -newline_and_indent (pretty_printer *buffer, int spc) +newline_and_indent (pretty_printer *pp, int spc) { - pp_newline (buffer); + pp_newline (pp); INDENT (spc); } @@ -139,12 +139,12 @@ dump_probability (profile_probability probability) return ret; } -/* Dump E probability to BUFFER. */ +/* Dump E probability to PP. */ static void -dump_edge_probability (pretty_printer *buffer, edge e) +dump_edge_probability (pretty_printer *pp, edge e) { - pp_scalar (buffer, " %s", dump_probability (e->probability)); + pp_scalar (pp, " %s", dump_probability (e->probability)); } /* Print GIMPLE statement G to FILE using SPC indentation spaces and @@ -153,11 +153,11 @@ dump_edge_probability (pretty_printer *buffer, edge e) void print_gimple_stmt (FILE *file, gimple *g, int spc, dump_flags_t flags) { - pretty_printer buffer; - pp_needs_newline (&buffer) = true; - buffer.buffer->stream = file; - pp_gimple_stmt_1 (&buffer, g, spc, flags); - pp_newline_and_flush (&buffer); + pretty_printer pp; + pp_needs_newline (&pp) = true; + pp.buffer->stream = file; + pp_gimple_stmt_1 (&pp, g, spc, flags); + pp_newline_and_flush (&pp); } DEBUG_FUNCTION void @@ -184,21 +184,21 @@ void print_gimple_expr (FILE *file, gimple *g, int spc, dump_flags_t flags) { flags |= TDF_RHS_ONLY; - pretty_printer buffer; - pp_needs_newline (&buffer) = true; - buffer.buffer->stream = file; - pp_gimple_stmt_1 (&buffer, g, spc, flags); - pp_flush (&buffer); + pretty_printer pp; + pp_needs_newline (&pp) = true; + pp.buffer->stream = file; + pp_gimple_stmt_1 (&pp, g, spc, flags); + pp_flush (&pp); } -/* Print the GIMPLE sequence SEQ on BUFFER using SPC indentation +/* Print the GIMPLE sequence SEQ on PP using SPC indentation spaces and FLAGS as in pp_gimple_stmt_1. - The caller is responsible for calling pp_flush on BUFFER to finalize + The caller is responsible for calling pp_flush on PP to finalize the pretty printer. */ static void -dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, +dump_gimple_seq (pretty_printer *pp, gimple_seq seq, int spc, dump_flags_t flags) { gimple_stmt_iterator i; @@ -207,9 +207,9 @@ dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, { gimple *gs = gsi_stmt (i); INDENT (spc); - pp_gimple_stmt_1 (buffer, gs, spc, flags); + pp_gimple_stmt_1 (pp, gs, spc, flags); if (!gsi_one_before_end_p (i)) - pp_newline (buffer); + pp_newline (pp); } } @@ -220,11 +220,11 @@ dump_gimple_seq (pretty_printer *buffer, gimple_seq seq, int spc, void print_gimple_seq (FILE *file, gimple_seq seq, int spc, dump_flags_t flags) { - pretty_printer buffer; - pp_needs_newline (&buffer) = true; - buffer.buffer->stream = file; - dump_gimple_seq (&buffer, seq, spc, flags); - pp_newline_and_flush (&buffer); + pretty_printer pp; + pp_needs_newline (&pp) = true; + pp.buffer->stream = file; + dump_gimple_seq (&pp, seq, spc, flags); + pp_newline_and_flush (&pp); } @@ -250,7 +250,7 @@ debug_gimple_seq (gimple_seq seq) '-' - decreases indent by 2 then outputs a newline. */ static void -dump_gimple_fmt (pretty_printer *buffer, int spc, dump_flags_t flags, +dump_gimple_fmt (pretty_printer *pp, int spc, dump_flags_t flags, const char *fmt, ...) { va_list args; @@ -270,48 +270,48 @@ dump_gimple_fmt (pretty_printer *buffer, int spc, dump_flags_t flags, case 'G': g = va_arg (args, gimple *); tmp = gimple_code_name[gimple_code (g)]; - pp_string (buffer, tmp); + pp_string (pp, tmp); break; case 'S': seq = va_arg (args, gimple_seq); - pp_newline (buffer); - dump_gimple_seq (buffer, seq, spc + 2, flags); - newline_and_indent (buffer, spc); + pp_newline (pp); + dump_gimple_seq (pp, seq, spc + 2, flags); + newline_and_indent (pp, spc); break; case 'T': t = va_arg (args, tree); if (t == NULL_TREE) - pp_string (buffer, "NULL"); + pp_string (pp, "NULL"); else - dump_generic_node (buffer, t, spc, flags, false); + dump_generic_node (pp, t, spc, flags, false); break; case 'd': - pp_decimal_int (buffer, va_arg (args, int)); + pp_decimal_int (pp, va_arg (args, int)); break; case 's': - pp_string (buffer, va_arg (args, char *)); + pp_string (pp, va_arg (args, char *)); break; case 'n': - newline_and_indent (buffer, spc); + newline_and_indent (pp, spc); break; case 'x': - pp_scalar (buffer, "%x", va_arg (args, int)); + pp_scalar (pp, "%x", va_arg (args, int)); break; case '+': spc += 2; - newline_and_indent (buffer, spc); + newline_and_indent (pp, spc); break; case '-': spc -= 2; - newline_and_indent (buffer, spc); + newline_and_indent (pp, spc); break; default: @@ -319,17 +319,17 @@ dump_gimple_fmt (pretty_printer *buffer, int spc, dump_flags_t flags, } } else - pp_character (buffer, *c); + pp_character (pp, *c); } va_end (args); } /* Helper for dump_gimple_assign. Print the unary RHS of the - assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */ + assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_unary_rhs (pretty_printer *buffer, const gassign *gs, int spc, +dump_unary_rhs (pretty_printer *pp, const gassign *gs, int spc, dump_flags_t flags) { enum tree_code rhs_code = gimple_assign_rhs_code (gs); @@ -339,7 +339,7 @@ dump_unary_rhs (pretty_printer *buffer, const gassign *gs, int spc, switch (rhs_code) { case VIEW_CONVERT_EXPR: - dump_generic_node (buffer, rhs, spc, flags, false); + dump_generic_node (pp, rhs, spc, flags, false); break; case FIXED_CONVERT_EXPR: @@ -347,39 +347,39 @@ dump_unary_rhs (pretty_printer *buffer, const gassign *gs, int spc, case FIX_TRUNC_EXPR: case FLOAT_EXPR: CASE_CONVERT: - pp_left_paren (buffer); - dump_generic_node (buffer, TREE_TYPE (lhs), spc, flags, false); - pp_string (buffer, ") "); + pp_left_paren (pp); + dump_generic_node (pp, TREE_TYPE (lhs), spc, flags, false); + pp_string (pp, ") "); if (op_prio (rhs) < op_code_prio (rhs_code)) { - pp_left_paren (buffer); - dump_generic_node (buffer, rhs, spc, flags, false); - pp_right_paren (buffer); + pp_left_paren (pp); + dump_generic_node (pp, rhs, spc, flags, false); + pp_right_paren (pp); } else - dump_generic_node (buffer, rhs, spc, flags, false); + dump_generic_node (pp, rhs, spc, flags, false); break; case PAREN_EXPR: - pp_string (buffer, "(("); - dump_generic_node (buffer, rhs, spc, flags, false); - pp_string (buffer, "))"); + pp_string (pp, "(("); + dump_generic_node (pp, rhs, spc, flags, false); + pp_string (pp, "))"); break; case ABS_EXPR: case ABSU_EXPR: if (flags & TDF_GIMPLE) { - pp_string (buffer, + pp_string (pp, rhs_code == ABS_EXPR ? "__ABS " : "__ABSU "); - dump_generic_node (buffer, rhs, spc, flags, false); + dump_generic_node (pp, rhs, spc, flags, false); } else { - pp_string (buffer, + pp_string (pp, rhs_code == ABS_EXPR ? "ABS_EXPR <" : "ABSU_EXPR <"); - dump_generic_node (buffer, rhs, spc, flags, false); - pp_greater (buffer); + dump_generic_node (pp, rhs, spc, flags, false); + pp_greater (pp); } break; @@ -391,40 +391,40 @@ dump_unary_rhs (pretty_printer *buffer, const gassign *gs, int spc, || rhs_code == ADDR_EXPR || rhs_code == CONSTRUCTOR) { - dump_generic_node (buffer, rhs, spc, flags, false); + dump_generic_node (pp, rhs, spc, flags, false); break; } else if (rhs_code == BIT_NOT_EXPR) - pp_complement (buffer); + pp_complement (pp); else if (rhs_code == TRUTH_NOT_EXPR) - pp_exclamation (buffer); + pp_exclamation (pp); else if (rhs_code == NEGATE_EXPR) - pp_minus (buffer); + pp_minus (pp); else { - pp_left_bracket (buffer); - pp_string (buffer, get_tree_code_name (rhs_code)); - pp_string (buffer, "] "); + pp_left_bracket (pp); + pp_string (pp, get_tree_code_name (rhs_code)); + pp_string (pp, "] "); } if (op_prio (rhs) < op_code_prio (rhs_code)) { - pp_left_paren (buffer); - dump_generic_node (buffer, rhs, spc, flags, false); - pp_right_paren (buffer); + pp_left_paren (pp); + dump_generic_node (pp, rhs, spc, flags, false); + pp_right_paren (pp); } else - dump_generic_node (buffer, rhs, spc, flags, false); + dump_generic_node (pp, rhs, spc, flags, false); break; } } /* Helper for dump_gimple_assign. Print the binary RHS of the - assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */ + assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_binary_rhs (pretty_printer *buffer, const gassign *gs, int spc, +dump_binary_rhs (pretty_printer *pp, const gassign *gs, int spc, dump_flags_t flags) { const char *p; @@ -435,13 +435,13 @@ dump_binary_rhs (pretty_printer *buffer, const gassign *gs, int spc, case MAX_EXPR: if (flags & TDF_GIMPLE) { - pp_string (buffer, code == MIN_EXPR ? "__MIN (" : "__MAX ("); - dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, + pp_string (pp, code == MIN_EXPR ? "__MIN (" : "__MAX ("); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); - pp_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); - pp_string (buffer, ")"); + pp_string (pp, ")"); break; } else @@ -461,44 +461,44 @@ dump_binary_rhs (pretty_printer *buffer, const gassign *gs, int spc, case VEC_WIDEN_LSHIFT_LO_EXPR: case VEC_SERIES_EXPR: for (p = get_tree_code_name (code); *p; p++) - pp_character (buffer, TOUPPER (*p)); - pp_string (buffer, " <"); - 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_greater (buffer); + pp_character (pp, TOUPPER (*p)); + pp_string (pp, " <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_greater (pp); break; default: if (op_prio (gimple_assign_rhs1 (gs)) <= op_code_prio (code)) { - pp_left_paren (buffer); - dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, + pp_left_paren (pp); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); - pp_right_paren (buffer); + pp_right_paren (pp); } else - dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, flags, false); - pp_space (buffer); - pp_string (buffer, op_symbol_code (gimple_assign_rhs_code (gs), flags)); - pp_space (buffer); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_space (pp); + pp_string (pp, op_symbol_code (gimple_assign_rhs_code (gs), flags)); + pp_space (pp); if (op_prio (gimple_assign_rhs2 (gs)) <= op_code_prio (code)) { - pp_left_paren (buffer); - dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, + pp_left_paren (pp); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); - pp_right_paren (buffer); + pp_right_paren (pp); } else - dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, flags, false); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); } } /* Helper for dump_gimple_assign. Print the ternary RHS of the - assignment GS. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. */ + assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_ternary_rhs (pretty_printer *buffer, const gassign *gs, int spc, +dump_ternary_rhs (pretty_printer *pp, const gassign *gs, int spc, dump_flags_t flags) { const char *p; @@ -508,113 +508,113 @@ dump_ternary_rhs (pretty_printer *buffer, const gassign *gs, int spc, case WIDEN_MULT_PLUS_EXPR: case WIDEN_MULT_MINUS_EXPR: for (p = get_tree_code_name (code); *p; p++) - pp_character (buffer, TOUPPER (*p)); - pp_string (buffer, " <"); - 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_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); - pp_greater (buffer); + pp_character (pp, TOUPPER (*p)); + pp_string (pp, " <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); + pp_greater (pp); break; case DOT_PROD_EXPR: - pp_string (buffer, "DOT_PROD_EXPR <"); - 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_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); - pp_greater (buffer); + pp_string (pp, "DOT_PROD_EXPR <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); + pp_greater (pp); break; case SAD_EXPR: - pp_string (buffer, "SAD_EXPR <"); - 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_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); - pp_greater (buffer); + pp_string (pp, "SAD_EXPR <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); + pp_greater (pp); break; case VEC_PERM_EXPR: if (flags & TDF_GIMPLE) - pp_string (buffer, "__VEC_PERM ("); + pp_string (pp, "__VEC_PERM ("); else - pp_string (buffer, "VEC_PERM_EXPR <"); - 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_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); + pp_string (pp, "VEC_PERM_EXPR <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); if (flags & TDF_GIMPLE) - pp_right_paren (buffer); + pp_right_paren (pp); else - pp_greater (buffer); + pp_greater (pp); break; case REALIGN_LOAD_EXPR: - pp_string (buffer, "REALIGN_LOAD <"); - 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_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); - pp_greater (buffer); + pp_string (pp, "REALIGN_LOAD <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); + pp_greater (pp); break; case COND_EXPR: - 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_string (buffer, " : "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, " ? "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_string (pp, " : "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); break; case VEC_COND_EXPR: - pp_string (buffer, "VEC_COND_EXPR <"); - 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_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, flags, false); - pp_greater (buffer); + pp_string (pp, "VEC_COND_EXPR <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); + pp_greater (pp); break; case BIT_INSERT_EXPR: if (flags & TDF_GIMPLE) { - pp_string (buffer, "__BIT_INSERT ("); - dump_generic_node (buffer, gimple_assign_rhs1 (gs), spc, + pp_string (pp, "__BIT_INSERT ("); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags | TDF_SLIM, false); - pp_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs2 (gs), spc, + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags | TDF_SLIM, false); - pp_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), spc, + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags | TDF_SLIM, false); - pp_right_paren (buffer); + pp_right_paren (pp); } else { - pp_string (buffer, "BIT_INSERT_EXPR <"); - dump_generic_node (buffer, gimple_assign_rhs1 (gs), + pp_string (pp, "BIT_INSERT_EXPR <"); + dump_generic_node (pp, gimple_assign_rhs1 (gs), spc, flags, false); - pp_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs2 (gs), + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs2 (gs), spc, flags, false); - pp_string (buffer, ", "); - dump_generic_node (buffer, gimple_assign_rhs3 (gs), + pp_string (pp, ", "); + dump_generic_node (pp, gimple_assign_rhs3 (gs), spc, flags, false); if (INTEGRAL_TYPE_P (TREE_TYPE (gimple_assign_rhs2 (gs)))) { - pp_string (buffer, " ("); - pp_decimal_int (buffer, TYPE_PRECISION + pp_string (pp, " ("); + pp_decimal_int (pp, TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs2 (gs)))); - pp_string (buffer, " bits)"); + pp_string (pp, " bits)"); } - pp_greater (buffer); + pp_greater (pp); } break; @@ -624,11 +624,11 @@ dump_ternary_rhs (pretty_printer *buffer, const gassign *gs, int spc, } -/* Dump the gimple assignment GS. BUFFER, SPC and FLAGS are as in +/* Dump the gimple assignment GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_gimple_assign (pretty_printer *buffer, const gassign *gs, int spc, +dump_gimple_assign (pretty_printer *pp, const gassign *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) @@ -651,7 +651,7 @@ dump_gimple_assign (pretty_printer *buffer, const gassign *gs, int spc, gcc_unreachable (); } - dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%s, %T, %T, %T, %T>", gs, get_tree_code_name (gimple_assign_rhs_code (gs)), gimple_assign_lhs (gs), arg1, arg2, arg3); } @@ -659,70 +659,70 @@ dump_gimple_assign (pretty_printer *buffer, const gassign *gs, int spc, { if (!(flags & TDF_RHS_ONLY)) { - dump_generic_node (buffer, gimple_assign_lhs (gs), spc, flags, false); - pp_space (buffer); - pp_equal (buffer); + dump_generic_node (pp, gimple_assign_lhs (gs), spc, flags, false); + pp_space (pp); + pp_equal (pp); if (gimple_assign_nontemporal_move_p (gs)) - pp_string (buffer, "{nt}"); + pp_string (pp, "{nt}"); if (gimple_has_volatile_ops (gs)) - pp_string (buffer, "{v}"); + pp_string (pp, "{v}"); - pp_space (buffer); + pp_space (pp); } if (gimple_num_ops (gs) == 2) - dump_unary_rhs (buffer, gs, spc, + dump_unary_rhs (pp, gs, spc, ((flags & TDF_GIMPLE) && gimple_assign_rhs_class (gs) != GIMPLE_SINGLE_RHS) ? (flags | TDF_GIMPLE_VAL) : flags); else if (gimple_num_ops (gs) == 3) - dump_binary_rhs (buffer, gs, spc, + dump_binary_rhs (pp, gs, spc, (flags & TDF_GIMPLE) ? (flags | TDF_GIMPLE_VAL) : flags); else if (gimple_num_ops (gs) == 4) - dump_ternary_rhs (buffer, gs, spc, + dump_ternary_rhs (pp, gs, spc, (flags & TDF_GIMPLE) ? (flags | TDF_GIMPLE_VAL) : flags); else gcc_unreachable (); if (!(flags & TDF_RHS_ONLY)) - pp_semicolon (buffer); + pp_semicolon (pp); } } -/* Dump the return statement GS. BUFFER, SPC and FLAGS are as in +/* Dump the return statement GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_gimple_return (pretty_printer *buffer, const greturn *gs, int spc, +dump_gimple_return (pretty_printer *pp, const greturn *gs, int spc, dump_flags_t flags) { tree t; t = gimple_return_retval (gs); if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, t); + dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, t); else { - pp_string (buffer, "return"); + pp_string (pp, "return"); if (t) { - pp_space (buffer); - dump_generic_node (buffer, t, spc, flags, false); + pp_space (pp); + dump_generic_node (pp, t, spc, flags, false); } - pp_semicolon (buffer); + pp_semicolon (pp); } } -/* Dump the call arguments for a gimple call. BUFFER, FLAGS are as in +/* Dump the call arguments for a gimple call. PP, FLAGS are as in dump_gimple_call. */ static void -dump_gimple_call_args (pretty_printer *buffer, const gcall *gs, +dump_gimple_call_args (pretty_printer *pp, const gcall *gs, dump_flags_t flags) { size_t i = 0; @@ -783,7 +783,7 @@ dump_gimple_call_args (pretty_printer *buffer, const gcall *gs, && (v = tree_to_shwi (arg0)) >= 0 && v < limit) { i++; - pp_string (buffer, enums[v]); + pp_string (pp, enums[v]); } } } @@ -791,52 +791,52 @@ dump_gimple_call_args (pretty_printer *buffer, const gcall *gs, for (; i < gimple_call_num_args (gs); i++) { if (i) - pp_string (buffer, ", "); - dump_generic_node (buffer, gimple_call_arg (gs, i), 0, flags, false); + pp_string (pp, ", "); + dump_generic_node (pp, gimple_call_arg (gs, i), 0, flags, false); } if (gimple_call_va_arg_pack_p (gs)) { if (i) - pp_string (buffer, ", "); + pp_string (pp, ", "); - pp_string (buffer, "__builtin_va_arg_pack ()"); + pp_string (pp, "__builtin_va_arg_pack ()"); } } -/* Dump the points-to solution *PT to BUFFER. */ +/* Dump the points-to solution *PT to PP. */ static void -pp_points_to_solution (pretty_printer *buffer, const pt_solution *pt) +pp_points_to_solution (pretty_printer *pp, const pt_solution *pt) { if (pt->anything) { - pp_string (buffer, "anything "); + pp_string (pp, "anything "); return; } if (pt->nonlocal) - pp_string (buffer, "nonlocal "); + pp_string (pp, "nonlocal "); if (pt->escaped) - pp_string (buffer, "escaped "); + pp_string (pp, "escaped "); if (pt->ipa_escaped) - pp_string (buffer, "unit-escaped "); + pp_string (pp, "unit-escaped "); if (pt->null) - pp_string (buffer, "null "); + pp_string (pp, "null "); if (pt->const_pool) - pp_string (buffer, "const-pool "); + pp_string (pp, "const-pool "); if (pt->vars && !bitmap_empty_p (pt->vars)) { bitmap_iterator bi; unsigned i; - pp_string (buffer, "{ "); + pp_string (pp, "{ "); EXECUTE_IF_SET_IN_BITMAP (pt->vars, 0, i, bi) { - pp_string (buffer, "D."); - pp_decimal_int (buffer, i); - pp_space (buffer); + pp_string (pp, "D."); + pp_decimal_int (pp, i); + pp_space (pp); } - pp_right_brace (buffer); + pp_right_brace (pp); if (pt->vars_contains_nonlocal || pt->vars_contains_escaped || pt->vars_contains_escaped_heap @@ -844,46 +844,46 @@ pp_points_to_solution (pretty_printer *buffer, const pt_solution *pt) || pt->vars_contains_interposable) { const char *comma = ""; - pp_string (buffer, " ("); + pp_string (pp, " ("); if (pt->vars_contains_nonlocal) { - pp_string (buffer, "nonlocal"); + pp_string (pp, "nonlocal"); comma = ", "; } if (pt->vars_contains_escaped) { - pp_string (buffer, comma); - pp_string (buffer, "escaped"); + pp_string (pp, comma); + pp_string (pp, "escaped"); comma = ", "; } if (pt->vars_contains_escaped_heap) { - pp_string (buffer, comma); - pp_string (buffer, "escaped heap"); + pp_string (pp, comma); + pp_string (pp, "escaped heap"); comma = ", "; } if (pt->vars_contains_restrict) { - pp_string (buffer, comma); - pp_string (buffer, "restrict"); + pp_string (pp, comma); + pp_string (pp, "restrict"); comma = ", "; } if (pt->vars_contains_interposable) { - pp_string (buffer, comma); - pp_string (buffer, "interposable"); + pp_string (pp, comma); + pp_string (pp, "interposable"); } - pp_string (buffer, ")"); + pp_string (pp, ")"); } } } -/* Dump the call statement GS. BUFFER, SPC and FLAGS are as in +/* Dump the call statement GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_gimple_call (pretty_printer *buffer, const gcall *gs, int spc, +dump_gimple_call (pretty_printer *pp, const gcall *gs, int spc, dump_flags_t flags) { tree lhs = gimple_call_lhs (gs); @@ -895,72 +895,72 @@ dump_gimple_call (pretty_printer *buffer, const gcall *gs, int spc, pt = gimple_call_use_set (gs); if (!pt_solution_empty_p (pt)) { - pp_string (buffer, "# USE = "); - pp_points_to_solution (buffer, pt); - newline_and_indent (buffer, spc); + pp_string (pp, "# USE = "); + pp_points_to_solution (pp, pt); + newline_and_indent (pp, spc); } pt = gimple_call_clobber_set (gs); if (!pt_solution_empty_p (pt)) { - pp_string (buffer, "# CLB = "); - pp_points_to_solution (buffer, pt); - newline_and_indent (buffer, spc); + pp_string (pp, "# CLB = "); + pp_points_to_solution (pp, pt); + newline_and_indent (pp, spc); } } if (flags & TDF_RAW) { if (gimple_call_internal_p (gs)) - dump_gimple_fmt (buffer, spc, flags, "%G <.%s, %T", gs, + dump_gimple_fmt (pp, spc, flags, "%G <.%s, %T", gs, internal_fn_name (gimple_call_internal_fn (gs)), lhs); else - dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T", gs, fn, lhs); + dump_gimple_fmt (pp, spc, flags, "%G <%T, %T", gs, fn, lhs); if (gimple_call_num_args (gs) > 0) { - pp_string (buffer, ", "); - dump_gimple_call_args (buffer, gs, flags); + pp_string (pp, ", "); + dump_gimple_call_args (pp, gs, flags); } - pp_greater (buffer); + pp_greater (pp); } else { if (lhs && !(flags & TDF_RHS_ONLY)) { - dump_generic_node (buffer, lhs, spc, flags, false); - pp_string (buffer, " ="); + dump_generic_node (pp, lhs, spc, flags, false); + pp_string (pp, " ="); if (gimple_has_volatile_ops (gs)) - pp_string (buffer, "{v}"); + pp_string (pp, "{v}"); - pp_space (buffer); + pp_space (pp); } if (gimple_call_internal_p (gs)) { - pp_dot (buffer); - pp_string (buffer, internal_fn_name (gimple_call_internal_fn (gs))); + pp_dot (pp); + pp_string (pp, internal_fn_name (gimple_call_internal_fn (gs))); } else - print_call_name (buffer, fn, flags); - pp_string (buffer, " ("); - dump_gimple_call_args (buffer, gs, flags); - pp_right_paren (buffer); + print_call_name (pp, fn, flags); + pp_string (pp, " ("); + dump_gimple_call_args (pp, gs, flags); + pp_right_paren (pp); if (!(flags & TDF_RHS_ONLY)) - pp_semicolon (buffer); + pp_semicolon (pp); } if (gimple_call_chain (gs)) { - pp_string (buffer, " [static-chain: "); - dump_generic_node (buffer, gimple_call_chain (gs), spc, flags, false); - pp_right_bracket (buffer); + pp_string (pp, " [static-chain: "); + dump_generic_node (pp, gimple_call_chain (gs), spc, flags, false); + pp_right_bracket (pp); } if (gimple_call_return_slot_opt_p (gs)) - pp_string (buffer, " [return slot optimization]"); + pp_string (pp, " [return slot optimization]"); if (gimple_call_tail_p (gs)) - pp_string (buffer, " [tail call]"); + pp_string (pp, " [tail call]"); if (gimple_call_must_tail_p (gs)) - pp_string (buffer, " [must tail call]"); + pp_string (pp, " [must tail call]"); if (fn == NULL) return; @@ -969,7 +969,7 @@ dump_gimple_call (pretty_printer *buffer, const gcall *gs, int spc, if (TREE_CODE (fn) == ADDR_EXPR) fn = TREE_OPERAND (fn, 0); if (TREE_CODE (fn) == FUNCTION_DECL && decl_is_tm_clone (fn)) - pp_string (buffer, " [tm-clone]"); + pp_string (pp, " [tm-clone]"); if (TREE_CODE (fn) == FUNCTION_DECL && fndecl_built_in_p (fn, BUILT_IN_TM_START) && gimple_call_num_args (gs) > 0) @@ -978,76 +978,76 @@ dump_gimple_call (pretty_printer *buffer, const gcall *gs, int spc, unsigned HOST_WIDE_INT props; gcc_assert (TREE_CODE (t) == INTEGER_CST); - pp_string (buffer, " [ "); + pp_string (pp, " [ "); /* Get the transaction code properties. */ props = TREE_INT_CST_LOW (t); if (props & PR_INSTRUMENTEDCODE) - pp_string (buffer, "instrumentedCode "); + pp_string (pp, "instrumentedCode "); if (props & PR_UNINSTRUMENTEDCODE) - pp_string (buffer, "uninstrumentedCode "); + pp_string (pp, "uninstrumentedCode "); if (props & PR_HASNOXMMUPDATE) - pp_string (buffer, "hasNoXMMUpdate "); + pp_string (pp, "hasNoXMMUpdate "); if (props & PR_HASNOABORT) - pp_string (buffer, "hasNoAbort "); + pp_string (pp, "hasNoAbort "); if (props & PR_HASNOIRREVOCABLE) - pp_string (buffer, "hasNoIrrevocable "); + pp_string (pp, "hasNoIrrevocable "); if (props & PR_DOESGOIRREVOCABLE) - pp_string (buffer, "doesGoIrrevocable "); + pp_string (pp, "doesGoIrrevocable "); if (props & PR_HASNOSIMPLEREADS) - pp_string (buffer, "hasNoSimpleReads "); + pp_string (pp, "hasNoSimpleReads "); if (props & PR_AWBARRIERSOMITTED) - pp_string (buffer, "awBarriersOmitted "); + pp_string (pp, "awBarriersOmitted "); if (props & PR_RARBARRIERSOMITTED) - pp_string (buffer, "RaRBarriersOmitted "); + pp_string (pp, "RaRBarriersOmitted "); if (props & PR_UNDOLOGCODE) - pp_string (buffer, "undoLogCode "); + pp_string (pp, "undoLogCode "); if (props & PR_PREFERUNINSTRUMENTED) - pp_string (buffer, "preferUninstrumented "); + pp_string (pp, "preferUninstrumented "); if (props & PR_EXCEPTIONBLOCK) - pp_string (buffer, "exceptionBlock "); + pp_string (pp, "exceptionBlock "); if (props & PR_HASELSE) - pp_string (buffer, "hasElse "); + pp_string (pp, "hasElse "); if (props & PR_READONLY) - pp_string (buffer, "readOnly "); + pp_string (pp, "readOnly "); - pp_right_bracket (buffer); + pp_right_bracket (pp); } } -/* Dump the switch statement GS. BUFFER, SPC and FLAGS are as in +/* Dump the switch statement GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_gimple_switch (pretty_printer *buffer, const gswitch *gs, int spc, +dump_gimple_switch (pretty_printer *pp, const gswitch *gs, int spc, dump_flags_t flags) { unsigned int i; GIMPLE_CHECK (gs, GIMPLE_SWITCH); if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%T, ", gs, gimple_switch_index (gs)); else { - pp_string (buffer, "switch ("); - dump_generic_node (buffer, gimple_switch_index (gs), spc, flags, true); + pp_string (pp, "switch ("); + dump_generic_node (pp, gimple_switch_index (gs), spc, flags, true); if (flags & TDF_GIMPLE) - pp_string (buffer, ") {"); + pp_string (pp, ") {"); else - pp_string (buffer, ") <"); + pp_string (pp, ") <"); } for (i = 0; i < gimple_switch_num_labels (gs); i++) { 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_space (buffer); + dump_generic_node (pp, case_label, spc, flags, false); + pp_space (pp); tree label = CASE_LABEL (case_label); - dump_generic_node (buffer, label, spc, flags, false); + dump_generic_node (pp, label, spc, flags, false); if (cfun && cfun->cfg) { @@ -1056,48 +1056,48 @@ dump_gimple_switch (pretty_printer *buffer, const gswitch *gs, int spc, { edge label_edge = find_edge (gimple_bb (gs), dest); if (label_edge && !(flags & TDF_GIMPLE)) - dump_edge_probability (buffer, label_edge); + dump_edge_probability (pp, label_edge); } } if (i < gimple_switch_num_labels (gs) - 1) { if (flags & TDF_GIMPLE) - pp_string (buffer, "; "); + pp_string (pp, "; "); else - pp_string (buffer, ", "); + pp_string (pp, ", "); } } if (flags & TDF_GIMPLE) - pp_string (buffer, "; }"); + pp_string (pp, "; }"); else - pp_greater (buffer); + pp_greater (pp); } -/* Dump the gimple conditional GS. BUFFER, SPC and FLAGS are as in +/* Dump the gimple conditional GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_gimple_cond (pretty_printer *buffer, const gcond *gs, int spc, +dump_gimple_cond (pretty_printer *pp, const gcond *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%s, %T, %T, %T, %T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%s, %T, %T, %T, %T>", gs, get_tree_code_name (gimple_cond_code (gs)), gimple_cond_lhs (gs), gimple_cond_rhs (gs), gimple_cond_true_label (gs), gimple_cond_false_label (gs)); else { if (!(flags & TDF_RHS_ONLY)) - pp_string (buffer, "if ("); - dump_generic_node (buffer, gimple_cond_lhs (gs), spc, + pp_string (pp, "if ("); + dump_generic_node (pp, gimple_cond_lhs (gs), spc, flags | ((flags & TDF_GIMPLE) ? TDF_GIMPLE_VAL : TDF_NONE), false); - pp_space (buffer); - pp_string (buffer, op_symbol_code (gimple_cond_code (gs), flags)); - pp_space (buffer); - dump_generic_node (buffer, gimple_cond_rhs (gs), spc, + pp_space (pp); + pp_string (pp, op_symbol_code (gimple_cond_code (gs), flags)); + pp_space (pp); + dump_generic_node (pp, gimple_cond_rhs (gs), spc, flags | ((flags & TDF_GIMPLE) ? TDF_GIMPLE_VAL : TDF_NONE), false); if (!(flags & TDF_RHS_ONLY)) @@ -1119,112 +1119,112 @@ dump_gimple_cond (pretty_printer *buffer, const gcond *gs, int spc, bool has_edge_info = true_edge != NULL && false_edge != NULL; - pp_right_paren (buffer); + pp_right_paren (pp); if (gimple_cond_true_label (gs)) { - pp_string (buffer, " goto "); - dump_generic_node (buffer, gimple_cond_true_label (gs), + pp_string (pp, " goto "); + dump_generic_node (pp, gimple_cond_true_label (gs), spc, flags, false); if (has_edge_info && !(flags & TDF_GIMPLE)) - dump_edge_probability (buffer, true_edge); - pp_semicolon (buffer); + dump_edge_probability (pp, true_edge); + pp_semicolon (pp); } if (gimple_cond_false_label (gs)) { - pp_string (buffer, " else goto "); - dump_generic_node (buffer, gimple_cond_false_label (gs), + pp_string (pp, " else goto "); + dump_generic_node (pp, gimple_cond_false_label (gs), spc, flags, false); if (has_edge_info && !(flags & TDF_GIMPLE)) - dump_edge_probability (buffer, false_edge); + dump_edge_probability (pp, false_edge); - pp_semicolon (buffer); + pp_semicolon (pp); } } } } -/* Dump a GIMPLE_LABEL tuple on the pretty_printer BUFFER, SPC +/* Dump a GIMPLE_LABEL tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfils.h). */ static void -dump_gimple_label (pretty_printer *buffer, const glabel *gs, int spc, +dump_gimple_label (pretty_printer *pp, const glabel *gs, int spc, dump_flags_t flags) { tree label = gimple_label_label (gs); if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label); + dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, label); else { - dump_generic_node (buffer, label, spc, flags, false); - pp_colon (buffer); + dump_generic_node (pp, label, spc, flags, false); + pp_colon (pp); } if (flags & TDF_GIMPLE) return; if (DECL_NONLOCAL (label)) - pp_string (buffer, " [non-local]"); + pp_string (pp, " [non-local]"); if ((flags & TDF_EH) && EH_LANDING_PAD_NR (label)) - pp_printf (buffer, " [LP %d]", EH_LANDING_PAD_NR (label)); + pp_printf (pp, " [LP %d]", EH_LANDING_PAD_NR (label)); } -/* Dump a GIMPLE_GOTO tuple on the pretty_printer BUFFER, SPC +/* Dump a GIMPLE_GOTO tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_goto (pretty_printer *buffer, const ggoto *gs, int spc, +dump_gimple_goto (pretty_printer *pp, const ggoto *gs, int spc, dump_flags_t flags) { tree label = gimple_goto_dest (gs); if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, label); + dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, label); else - dump_gimple_fmt (buffer, spc, flags, "goto %T;", label); + dump_gimple_fmt (pp, spc, flags, "goto %T;", label); } -/* Dump a GIMPLE_BIND tuple on the pretty_printer BUFFER, SPC +/* Dump a GIMPLE_BIND tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_bind (pretty_printer *buffer, const gbind *gs, int spc, +dump_gimple_bind (pretty_printer *pp, const gbind *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <", gs); + dump_gimple_fmt (pp, spc, flags, "%G <", gs); else - pp_left_brace (buffer); + pp_left_brace (pp); if (!(flags & TDF_SLIM)) { tree var; for (var = gimple_bind_vars (gs); var; var = DECL_CHAIN (var)) { - newline_and_indent (buffer, 2); - print_declaration (buffer, var, spc, flags); + newline_and_indent (pp, 2); + print_declaration (pp, var, spc, flags); } if (gimple_bind_vars (gs)) - pp_newline (buffer); + pp_newline (pp); } - pp_newline (buffer); - dump_gimple_seq (buffer, gimple_bind_body (gs), spc + 2, flags); - newline_and_indent (buffer, spc); + pp_newline (pp); + dump_gimple_seq (pp, gimple_bind_body (gs), spc + 2, flags); + newline_and_indent (pp, spc); if (flags & TDF_RAW) - pp_greater (buffer); + pp_greater (pp); else - pp_right_brace (buffer); + pp_right_brace (pp); } -/* Dump a GIMPLE_TRY tuple on the pretty_printer BUFFER, SPC spaces of +/* Dump a GIMPLE_TRY tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_try (pretty_printer *buffer, const gtry *gs, int spc, +dump_gimple_try (pretty_printer *pp, const gtry *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) @@ -1236,95 +1236,95 @@ dump_gimple_try (pretty_printer *buffer, const gtry *gs, int spc, type = "GIMPLE_TRY_FINALLY"; else type = "UNKNOWN GIMPLE_TRY"; - dump_gimple_fmt (buffer, spc, flags, + dump_gimple_fmt (pp, spc, flags, "%G <%s,%+EVAL <%S>%nCLEANUP <%S>%->", gs, type, gimple_try_eval (gs), gimple_try_cleanup (gs)); } else { - pp_string (buffer, "try"); - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); - pp_newline (buffer); + pp_string (pp, "try"); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); - dump_gimple_seq (buffer, gimple_try_eval (gs), spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + dump_gimple_seq (pp, gimple_try_eval (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); gimple_seq seq = gimple_try_cleanup (gs); if (gimple_try_kind (gs) == GIMPLE_TRY_CATCH) { - newline_and_indent (buffer, spc); - pp_string (buffer, "catch"); - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); + newline_and_indent (pp, spc); + pp_string (pp, "catch"); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); } 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_left_brace (buffer); + newline_and_indent (pp, spc); + pp_string (pp, "finally"); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); if (seq && is_a (gimple_seq_first_stmt (seq)) && gimple_seq_nondebug_singleton_p (seq)) { geh_else *stmt = as_a (gimple_seq_first_stmt (seq)); seq = gimple_eh_else_n_body (stmt); - pp_newline (buffer); - dump_gimple_seq (buffer, seq, spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + pp_newline (pp); + dump_gimple_seq (pp, seq, spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); seq = gimple_eh_else_e_body (stmt); - newline_and_indent (buffer, spc); - pp_string (buffer, "else"); - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); + newline_and_indent (pp, spc); + pp_string (pp, "else"); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); } } else - pp_string (buffer, " {"); + pp_string (pp, " {"); - pp_newline (buffer); - dump_gimple_seq (buffer, seq, spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + pp_newline (pp); + dump_gimple_seq (pp, seq, spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } -/* Dump a GIMPLE_CATCH tuple on the pretty_printer BUFFER, SPC spaces of +/* Dump a GIMPLE_CATCH tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_catch (pretty_printer *buffer, const gcatch *gs, int spc, +dump_gimple_catch (pretty_printer *pp, const gcatch *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+CATCH <%S>%->", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%T, %+CATCH <%S>%->", gs, gimple_catch_types (gs), gimple_catch_handler (gs)); else - dump_gimple_fmt (buffer, spc, flags, "catch (%T)%+{%S}", + dump_gimple_fmt (pp, spc, flags, "catch (%T)%+{%S}", gimple_catch_types (gs), gimple_catch_handler (gs)); } -/* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer BUFFER, SPC spaces of +/* Dump a GIMPLE_EH_FILTER tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_eh_filter (pretty_printer *buffer, const geh_filter *gs, int spc, +dump_gimple_eh_filter (pretty_printer *pp, const geh_filter *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%T, %+FAILURE <%S>%->", gs, gimple_eh_filter_types (gs), gimple_eh_filter_failure (gs)); else - dump_gimple_fmt (buffer, spc, flags, "<<>>%+{%+%S%-}", + dump_gimple_fmt (pp, spc, flags, "<<>>%+{%+%S%-}", gimple_eh_filter_types (gs), gimple_eh_filter_failure (gs)); } @@ -1333,113 +1333,113 @@ dump_gimple_eh_filter (pretty_printer *buffer, const geh_filter *gs, int spc, /* Dump a GIMPLE_EH_MUST_NOT_THROW tuple. */ static void -dump_gimple_eh_must_not_throw (pretty_printer *buffer, +dump_gimple_eh_must_not_throw (pretty_printer *pp, const geh_mnt *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, gimple_eh_must_not_throw_fndecl (gs)); else - dump_gimple_fmt (buffer, spc, flags, "<<>>", + dump_gimple_fmt (pp, spc, flags, "<<>>", gimple_eh_must_not_throw_fndecl (gs)); } -/* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer BUFFER, SPC spaces of +/* Dump a GIMPLE_EH_ELSE tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_eh_else (pretty_printer *buffer, const geh_else *gs, int spc, +dump_gimple_eh_else (pretty_printer *pp, const geh_else *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, + dump_gimple_fmt (pp, spc, flags, "%G <%+N_BODY <%S>%nE_BODY <%S>%->", gs, gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs)); else - dump_gimple_fmt (buffer, spc, flags, + dump_gimple_fmt (pp, spc, flags, "<<>>%+{%S}%-<<>>%+{%S}", gimple_eh_else_n_body (gs), gimple_eh_else_e_body (gs)); } -/* Dump a GIMPLE_RESX tuple on the pretty_printer BUFFER, SPC spaces of +/* Dump a GIMPLE_RESX tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_resx (pretty_printer *buffer, const gresx *gs, int spc, +dump_gimple_resx (pretty_printer *pp, const gresx *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%d>", gs, gimple_resx_region (gs)); else - dump_gimple_fmt (buffer, spc, flags, "resx %d", gimple_resx_region (gs)); + dump_gimple_fmt (pp, spc, flags, "resx %d", gimple_resx_region (gs)); } -/* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_EH_DISPATCH tuple on the pretty_printer PP. */ static void -dump_gimple_eh_dispatch (pretty_printer *buffer, const geh_dispatch *gs, +dump_gimple_eh_dispatch (pretty_printer *pp, const geh_dispatch *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%d>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%d>", gs, gimple_eh_dispatch_region (gs)); else - dump_gimple_fmt (buffer, spc, flags, "eh_dispatch %d", + dump_gimple_fmt (pp, spc, flags, "eh_dispatch %d", gimple_eh_dispatch_region (gs)); } -/* Dump a GIMPLE_DEBUG tuple on the pretty_printer BUFFER, SPC spaces +/* Dump a GIMPLE_DEBUG tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_debug (pretty_printer *buffer, const gdebug *gs, int spc, +dump_gimple_debug (pretty_printer *pp, const gdebug *gs, int spc, dump_flags_t flags) { switch (gs->subcode) { case GIMPLE_DEBUG_BIND: if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G BIND <%T, %T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G BIND <%T, %T>", gs, gimple_debug_bind_get_var (gs), gimple_debug_bind_get_value (gs)); else - dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T => %T", + dump_gimple_fmt (pp, spc, flags, "# DEBUG %T => %T", gimple_debug_bind_get_var (gs), gimple_debug_bind_get_value (gs)); break; case GIMPLE_DEBUG_SOURCE_BIND: if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G SRCBIND <%T, %T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G SRCBIND <%T, %T>", gs, gimple_debug_source_bind_get_var (gs), gimple_debug_source_bind_get_value (gs)); else - dump_gimple_fmt (buffer, spc, flags, "# DEBUG %T s=> %T", + dump_gimple_fmt (pp, spc, flags, "# DEBUG %T s=> %T", gimple_debug_source_bind_get_var (gs), gimple_debug_source_bind_get_value (gs)); break; case GIMPLE_DEBUG_BEGIN_STMT: if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G BEGIN_STMT", gs); + dump_gimple_fmt (pp, spc, flags, "%G BEGIN_STMT", gs); else - dump_gimple_fmt (buffer, spc, flags, "# DEBUG BEGIN_STMT"); + dump_gimple_fmt (pp, spc, flags, "# DEBUG BEGIN_STMT"); break; case GIMPLE_DEBUG_INLINE_ENTRY: if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G INLINE_ENTRY %T", gs, + dump_gimple_fmt (pp, spc, flags, "%G INLINE_ENTRY %T", gs, gimple_block (gs) ? block_ultimate_origin (gimple_block (gs)) : NULL_TREE); else - dump_gimple_fmt (buffer, spc, flags, "# DEBUG INLINE_ENTRY %T", + dump_gimple_fmt (pp, spc, flags, "# DEBUG INLINE_ENTRY %T", gimple_block (gs) ? block_ultimate_origin (gimple_block (gs)) : NULL_TREE); @@ -1450,9 +1450,9 @@ dump_gimple_debug (pretty_printer *buffer, const gdebug *gs, int spc, } } -/* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_FOR tuple on the pretty_printer PP. */ static void -dump_gimple_omp_for (pretty_printer *buffer, const gomp_for *gs, int spc, +dump_gimple_omp_for (pretty_printer *pp, const gomp_for *gs, int spc, dump_flags_t flags) { size_t i; @@ -1480,19 +1480,19 @@ dump_gimple_omp_for (pretty_printer *buffer, const gomp_for *gs, int spc, default: gcc_unreachable (); } - dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs, kind, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >,"); + dump_omp_clauses (pp, gimple_omp_for_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >,"); for (i = 0; i < gimple_omp_for_collapse (gs); i++) - dump_gimple_fmt (buffer, spc, flags, + dump_gimple_fmt (pp, spc, flags, "%+%T, %T, %T, %s, %T,%n", gimple_omp_for_index (gs, i), gimple_omp_for_initial (gs, i), gimple_omp_for_final (gs, i), get_tree_code_name (gimple_omp_for_cond (gs, i)), gimple_omp_for_incr (gs, i)); - dump_gimple_fmt (buffer, spc, flags, "PRE_BODY <%S>%->", + dump_gimple_fmt (pp, spc, flags, "PRE_BODY <%S>%->", gimple_omp_for_pre_body (gs)); } else @@ -1500,236 +1500,236 @@ dump_gimple_omp_for (pretty_printer *buffer, const gomp_for *gs, int spc, switch (gimple_omp_for_kind (gs)) { case GF_OMP_FOR_KIND_FOR: - pp_string (buffer, "#pragma omp for"); + pp_string (pp, "#pragma omp for"); break; case GF_OMP_FOR_KIND_DISTRIBUTE: - pp_string (buffer, "#pragma omp distribute"); + pp_string (pp, "#pragma omp distribute"); break; case GF_OMP_FOR_KIND_TASKLOOP: - pp_string (buffer, "#pragma omp taskloop"); + pp_string (pp, "#pragma omp taskloop"); break; case GF_OMP_FOR_KIND_OACC_LOOP: - pp_string (buffer, "#pragma acc loop"); + pp_string (pp, "#pragma acc loop"); break; case GF_OMP_FOR_KIND_SIMD: - pp_string (buffer, "#pragma omp simd"); + pp_string (pp, "#pragma omp simd"); break; default: gcc_unreachable (); } - dump_omp_clauses (buffer, gimple_omp_for_clauses (gs), spc, flags); + dump_omp_clauses (pp, gimple_omp_for_clauses (gs), spc, flags); for (i = 0; i < gimple_omp_for_collapse (gs); i++) { if (i) spc += 2; - newline_and_indent (buffer, spc); - pp_string (buffer, "for ("); - dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, + newline_and_indent (pp, spc); + pp_string (pp, "for ("); + dump_generic_node (pp, gimple_omp_for_index (gs, i), spc, flags, false); - pp_string (buffer, " = "); + pp_string (pp, " = "); tree init = gimple_omp_for_initial (gs, i); if (TREE_CODE (init) != TREE_VEC) - dump_generic_node (buffer, init, spc, flags, false); + dump_generic_node (pp, init, spc, flags, false); else - dump_omp_loop_non_rect_expr (buffer, init, spc, flags); - pp_string (buffer, "; "); + dump_omp_loop_non_rect_expr (pp, init, spc, flags); + pp_string (pp, "; "); - dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, + dump_generic_node (pp, gimple_omp_for_index (gs, i), spc, flags, false); - pp_space (buffer); + pp_space (pp); switch (gimple_omp_for_cond (gs, i)) { case LT_EXPR: - pp_less (buffer); + pp_less (pp); break; case GT_EXPR: - pp_greater (buffer); + pp_greater (pp); break; case LE_EXPR: - pp_less_equal (buffer); + pp_less_equal (pp); break; case GE_EXPR: - pp_greater_equal (buffer); + pp_greater_equal (pp); break; case NE_EXPR: - pp_string (buffer, "!="); + pp_string (pp, "!="); break; default: gcc_unreachable (); } - pp_space (buffer); + pp_space (pp); tree cond = gimple_omp_for_final (gs, i); if (TREE_CODE (cond) != TREE_VEC) - dump_generic_node (buffer, cond, spc, flags, false); + dump_generic_node (pp, cond, spc, flags, false); else - dump_omp_loop_non_rect_expr (buffer, cond, spc, flags); - pp_string (buffer, "; "); + dump_omp_loop_non_rect_expr (pp, cond, spc, flags); + pp_string (pp, "; "); - dump_generic_node (buffer, gimple_omp_for_index (gs, i), spc, + dump_generic_node (pp, gimple_omp_for_index (gs, i), spc, flags, false); - pp_string (buffer, " = "); - dump_generic_node (buffer, gimple_omp_for_incr (gs, i), spc, + pp_string (pp, " = "); + dump_generic_node (pp, gimple_omp_for_incr (gs, i), spc, flags, false); - pp_right_paren (buffer); + pp_right_paren (pp); } if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_CONTINUE tuple on the pretty_printer PP. */ static void -dump_gimple_omp_continue (pretty_printer *buffer, const gomp_continue *gs, +dump_gimple_omp_continue (pretty_printer *pp, const gomp_continue *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%T, %T>", gs, gimple_omp_continue_control_def (gs), gimple_omp_continue_control_use (gs)); } else { - pp_string (buffer, "#pragma omp continue ("); - dump_generic_node (buffer, gimple_omp_continue_control_def (gs), + pp_string (pp, "#pragma omp continue ("); + dump_generic_node (pp, gimple_omp_continue_control_def (gs), spc, flags, false); - pp_comma (buffer); - pp_space (buffer); - dump_generic_node (buffer, gimple_omp_continue_control_use (gs), + pp_comma (pp); + pp_space (pp); + dump_generic_node (pp, gimple_omp_continue_control_use (gs), spc, flags, false); - pp_right_paren (buffer); + pp_right_paren (pp); } } -/* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_SINGLE tuple on the pretty_printer PP. */ static void -dump_gimple_omp_single (pretty_printer *buffer, const gomp_single *gs, +dump_gimple_omp_single (pretty_printer *pp, const gomp_single *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >"); + dump_omp_clauses (pp, gimple_omp_single_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >"); } else { - pp_string (buffer, "#pragma omp single"); - dump_omp_clauses (buffer, gimple_omp_single_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp single"); + dump_omp_clauses (pp, gimple_omp_single_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_TASKGROUP tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_TASKGROUP tuple on the pretty_printer PP. */ static void -dump_gimple_omp_taskgroup (pretty_printer *buffer, const gimple *gs, +dump_gimple_omp_taskgroup (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_taskgroup_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >"); + dump_omp_clauses (pp, gimple_omp_taskgroup_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >"); } else { - pp_string (buffer, "#pragma omp taskgroup"); - dump_omp_clauses (buffer, gimple_omp_taskgroup_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp taskgroup"); + dump_omp_clauses (pp, gimple_omp_taskgroup_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_MASKED tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_MASKED tuple on the pretty_printer PP. */ static void -dump_gimple_omp_masked (pretty_printer *buffer, const gimple *gs, +dump_gimple_omp_masked (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_masked_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >"); + dump_omp_clauses (pp, gimple_omp_masked_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >"); } else { - pp_string (buffer, "#pragma omp masked"); - dump_omp_clauses (buffer, gimple_omp_masked_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp masked"); + dump_omp_clauses (pp, gimple_omp_masked_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_SCOPE tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_SCOPE tuple on the pretty_printer PP. */ static void -dump_gimple_omp_scope (pretty_printer *buffer, const gimple *gs, +dump_gimple_omp_scope (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_scope_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >"); + dump_omp_clauses (pp, gimple_omp_scope_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >"); } else { - pp_string (buffer, "#pragma omp scope"); - dump_omp_clauses (buffer, gimple_omp_scope_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp scope"); + dump_omp_clauses (pp, gimple_omp_scope_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_TARGET tuple on the pretty_printer PP. */ static void -dump_gimple_omp_target (pretty_printer *buffer, const gomp_target *gs, +dump_gimple_omp_target (pretty_printer *pp, const gomp_target *gs, int spc, dump_flags_t flags) { const char *kind; @@ -1791,304 +1791,304 @@ dump_gimple_omp_target (pretty_printer *buffer, const gomp_target *gs, } if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G%s <%+BODY <%S>%nCLAUSES <", gs, kind, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>", + dump_omp_clauses (pp, gimple_omp_target_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >, %T, %T%n>", gimple_omp_target_child_fn (gs), gimple_omp_target_data_arg (gs)); } else { - pp_string (buffer, "#pragma omp target"); - pp_string (buffer, kind); - dump_omp_clauses (buffer, gimple_omp_target_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp target"); + pp_string (pp, kind); + dump_omp_clauses (pp, gimple_omp_target_clauses (gs), spc, flags); if (gimple_omp_target_child_fn (gs)) { - pp_string (buffer, " [child fn: "); - dump_generic_node (buffer, gimple_omp_target_child_fn (gs), + pp_string (pp, " [child fn: "); + dump_generic_node (pp, gimple_omp_target_child_fn (gs), spc, flags, false); - pp_string (buffer, " ("); + pp_string (pp, " ("); if (gimple_omp_target_data_arg (gs)) - dump_generic_node (buffer, gimple_omp_target_data_arg (gs), + dump_generic_node (pp, gimple_omp_target_data_arg (gs), spc, flags, false); else - pp_string (buffer, "???"); - pp_string (buffer, ")]"); + pp_string (pp, "???"); + pp_string (pp, ")]"); } gimple_seq body = gimple_omp_body (gs); if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) { - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); - pp_newline (buffer); - dump_gimple_seq (buffer, body, spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, body, spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } else if (body) { - pp_newline (buffer); - dump_gimple_seq (buffer, body, spc + 2, flags); + pp_newline (pp); + dump_gimple_seq (pp, body, spc + 2, flags); } } } -/* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_TEAMS tuple on the pretty_printer PP. */ static void -dump_gimple_omp_teams (pretty_printer *buffer, const gomp_teams *gs, int spc, +dump_gimple_omp_teams (pretty_printer *pp, const gomp_teams *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >"); + dump_omp_clauses (pp, gimple_omp_teams_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >"); } else { - pp_string (buffer, "#pragma omp teams"); - dump_omp_clauses (buffer, gimple_omp_teams_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp teams"); + dump_omp_clauses (pp, gimple_omp_teams_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - pp_character (buffer, '{'); - pp_newline (buffer); - dump_gimple_seq (buffer, gimple_omp_body (gs), spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_character (buffer, '}'); + newline_and_indent (pp, spc + 2); + pp_character (pp, '{'); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_character (pp, '}'); } } } -/* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_SECTIONS tuple on the pretty_printer PP. */ static void -dump_gimple_omp_sections (pretty_printer *buffer, const gomp_sections *gs, +dump_gimple_omp_sections (pretty_printer *pp, const gomp_sections *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >"); + dump_omp_clauses (pp, gimple_omp_sections_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >"); } else { - pp_string (buffer, "#pragma omp sections"); + pp_string (pp, "#pragma omp sections"); if (gimple_omp_sections_control (gs)) { - pp_string (buffer, " <"); - dump_generic_node (buffer, gimple_omp_sections_control (gs), spc, + pp_string (pp, " <"); + dump_generic_node (pp, gimple_omp_sections_control (gs), spc, flags, false); - pp_greater (buffer); + pp_greater (pp); } - dump_omp_clauses (buffer, gimple_omp_sections_clauses (gs), spc, flags); + dump_omp_clauses (pp, gimple_omp_sections_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } /* Dump a GIMPLE_OMP_{MASTER,ORDERED,SECTION,STRUCTURED_BLOCK} tuple on the - pretty_printer BUFFER. */ + pretty_printer PP. */ static void -dump_gimple_omp_block (pretty_printer *buffer, const gimple *gs, int spc, +dump_gimple_omp_block (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs, gimple_omp_body (gs)); else { switch (gimple_code (gs)) { case GIMPLE_OMP_MASTER: - pp_string (buffer, "#pragma omp master"); + pp_string (pp, "#pragma omp master"); break; case GIMPLE_OMP_SECTION: - pp_string (buffer, "#pragma omp section"); + pp_string (pp, "#pragma omp section"); break; case GIMPLE_OMP_STRUCTURED_BLOCK: - pp_string (buffer, "#pragma omp __structured_block"); + pp_string (pp, "#pragma omp __structured_block"); break; default: gcc_unreachable (); } if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_CRITICAL tuple on the pretty_printer PP. */ static void -dump_gimple_omp_critical (pretty_printer *buffer, const gomp_critical *gs, +dump_gimple_omp_critical (pretty_printer *pp, const gomp_critical *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs, gimple_omp_body (gs)); else { - pp_string (buffer, "#pragma omp critical"); + pp_string (pp, "#pragma omp critical"); if (gimple_omp_critical_name (gs)) { - pp_string (buffer, " ("); - dump_generic_node (buffer, gimple_omp_critical_name (gs), spc, + pp_string (pp, " ("); + dump_generic_node (pp, gimple_omp_critical_name (gs), spc, flags, false); - pp_right_paren (buffer); + pp_right_paren (pp); } - dump_omp_clauses (buffer, gimple_omp_critical_clauses (gs), spc, flags); + dump_omp_clauses (pp, gimple_omp_critical_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_ORDERED tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_ORDERED tuple on the pretty_printer PP. */ static void -dump_gimple_omp_ordered (pretty_printer *buffer, const gomp_ordered *gs, +dump_gimple_omp_ordered (pretty_printer *pp, const gomp_ordered *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs, gimple_omp_body (gs)); else { - pp_string (buffer, "#pragma omp ordered"); - dump_omp_clauses (buffer, gimple_omp_ordered_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp ordered"); + dump_omp_clauses (pp, gimple_omp_ordered_clauses (gs), spc, flags); if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_SCAN tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_SCAN tuple on the pretty_printer PP. */ static void -dump_gimple_omp_scan (pretty_printer *buffer, const gomp_scan *gs, +dump_gimple_omp_scan (pretty_printer *pp, const gomp_scan *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S> >", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S> >", gs, gimple_omp_body (gs)); else { if (gimple_omp_scan_clauses (gs)) { - pp_string (buffer, "#pragma omp scan"); - dump_omp_clauses (buffer, gimple_omp_scan_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp scan"); + dump_omp_clauses (pp, gimple_omp_scan_clauses (gs), spc, flags); } if (!gimple_seq_empty_p (gimple_omp_body (gs))) { - newline_and_indent (buffer, spc + 2); - 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_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_omp_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } } -/* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_OMP_RETURN tuple on the pretty_printer PP. */ static void -dump_gimple_omp_return (pretty_printer *buffer, const gimple *gs, int spc, +dump_gimple_omp_return (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G ", + dump_gimple_fmt (pp, spc, flags, ", lhs=%T>", gimple_omp_return_lhs (gs)); else - dump_gimple_fmt (buffer, spc, flags, ">"); + dump_gimple_fmt (pp, spc, flags, ">"); } else { - pp_string (buffer, "#pragma omp return"); + pp_string (pp, "#pragma omp return"); if (gimple_omp_return_nowait_p (gs)) - pp_string (buffer, "(nowait)"); + pp_string (pp, "(nowait)"); if (gimple_omp_return_lhs (gs)) { - pp_string (buffer, " (set "); - dump_generic_node (buffer, gimple_omp_return_lhs (gs), + pp_string (pp, " (set "); + dump_generic_node (pp, gimple_omp_return_lhs (gs), spc, flags, false); - pp_character (buffer, ')'); + pp_character (pp, ')'); } } } -/* Dump a GIMPLE_ASSUME tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_ASSUME tuple on the pretty_printer PP. */ static void -dump_gimple_assume (pretty_printer *buffer, const gimple *gs, +dump_gimple_assume (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, + dump_gimple_fmt (pp, spc, flags, "%G [GUARD=%T] <%+BODY <%S> >", gs, gimple_assume_guard (gs), gimple_assume_body (gs)); else { - pp_string (buffer, "[[assume ("); - dump_generic_node (buffer, gimple_assume_guard (gs), spc, flags, false); - pp_string (buffer, ")]]"); - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); - pp_newline (buffer); - dump_gimple_seq (buffer, gimple_assume_body (gs), spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + pp_string (pp, "[[assume ("); + dump_generic_node (pp, gimple_assume_guard (gs), spc, flags, false); + pp_string (pp, ")]]"); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_assume_body (gs), spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } } -/* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer BUFFER. */ +/* Dump a GIMPLE_TRANSACTION tuple on the pretty_printer PP. */ static void -dump_gimple_transaction (pretty_printer *buffer, const gtransaction *gs, +dump_gimple_transaction (pretty_printer *pp, const gtransaction *gs, int spc, dump_flags_t flags) { unsigned subcode = gimple_transaction_subcode (gs); if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, + dump_gimple_fmt (pp, spc, flags, "%G [SUBCODE=%x,NORM=%T,UNINST=%T,OVER=%T] " "<%+BODY <%S> >", gs, subcode, gimple_transaction_label_norm (gs), @@ -2099,171 +2099,171 @@ dump_gimple_transaction (pretty_printer *buffer, const gtransaction *gs, else { if (subcode & GTMA_IS_OUTER) - pp_string (buffer, "__transaction_atomic [[outer]]"); + pp_string (pp, "__transaction_atomic [[outer]]"); else if (subcode & GTMA_IS_RELAXED) - pp_string (buffer, "__transaction_relaxed"); + pp_string (pp, "__transaction_relaxed"); else - pp_string (buffer, "__transaction_atomic"); + pp_string (pp, "__transaction_atomic"); subcode &= ~GTMA_DECLARATION_MASK; if (gimple_transaction_body (gs)) { - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); - pp_newline (buffer); - dump_gimple_seq (buffer, gimple_transaction_body (gs), + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, gimple_transaction_body (gs), spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } else { - pp_string (buffer, " //"); + pp_string (pp, " //"); if (gimple_transaction_label_norm (gs)) { - pp_string (buffer, " NORM="); - dump_generic_node (buffer, gimple_transaction_label_norm (gs), + pp_string (pp, " NORM="); + dump_generic_node (pp, gimple_transaction_label_norm (gs), spc, flags, false); } if (gimple_transaction_label_uninst (gs)) { - pp_string (buffer, " UNINST="); - dump_generic_node (buffer, gimple_transaction_label_uninst (gs), + pp_string (pp, " UNINST="); + dump_generic_node (pp, gimple_transaction_label_uninst (gs), spc, flags, false); } if (gimple_transaction_label_over (gs)) { - pp_string (buffer, " OVER="); - dump_generic_node (buffer, gimple_transaction_label_over (gs), + pp_string (pp, " OVER="); + dump_generic_node (pp, gimple_transaction_label_over (gs), spc, flags, false); } if (subcode) { - pp_string (buffer, " SUBCODE=[ "); + pp_string (pp, " SUBCODE=[ "); if (subcode & GTMA_HAVE_ABORT) { - pp_string (buffer, "GTMA_HAVE_ABORT "); + pp_string (pp, "GTMA_HAVE_ABORT "); subcode &= ~GTMA_HAVE_ABORT; } if (subcode & GTMA_HAVE_LOAD) { - pp_string (buffer, "GTMA_HAVE_LOAD "); + pp_string (pp, "GTMA_HAVE_LOAD "); subcode &= ~GTMA_HAVE_LOAD; } if (subcode & GTMA_HAVE_STORE) { - pp_string (buffer, "GTMA_HAVE_STORE "); + pp_string (pp, "GTMA_HAVE_STORE "); subcode &= ~GTMA_HAVE_STORE; } if (subcode & GTMA_MAY_ENTER_IRREVOCABLE) { - pp_string (buffer, "GTMA_MAY_ENTER_IRREVOCABLE "); + pp_string (pp, "GTMA_MAY_ENTER_IRREVOCABLE "); subcode &= ~GTMA_MAY_ENTER_IRREVOCABLE; } if (subcode & GTMA_DOES_GO_IRREVOCABLE) { - pp_string (buffer, "GTMA_DOES_GO_IRREVOCABLE "); + pp_string (pp, "GTMA_DOES_GO_IRREVOCABLE "); subcode &= ~GTMA_DOES_GO_IRREVOCABLE; } if (subcode & GTMA_HAS_NO_INSTRUMENTATION) { - pp_string (buffer, "GTMA_HAS_NO_INSTRUMENTATION "); + pp_string (pp, "GTMA_HAS_NO_INSTRUMENTATION "); subcode &= ~GTMA_HAS_NO_INSTRUMENTATION; } if (subcode) - pp_printf (buffer, "0x%x ", subcode); - pp_right_bracket (buffer); + pp_printf (pp, "0x%x ", subcode); + pp_right_bracket (pp); } } } } -/* Dump a GIMPLE_ASM tuple on the pretty_printer BUFFER, SPC spaces of +/* Dump a GIMPLE_ASM tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc, +dump_gimple_asm (pretty_printer *pp, const gasm *gs, int spc, dump_flags_t flags) { unsigned int i, n, f, fields; if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+STRING <%n%s%n>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+STRING <%n%s%n>", gs, gimple_asm_string (gs)); n = gimple_asm_noutputs (gs); if (n) { - newline_and_indent (buffer, spc + 2); - pp_string (buffer, "OUTPUT: "); + newline_and_indent (pp, spc + 2); + pp_string (pp, "OUTPUT: "); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_output_op (gs, i), + dump_generic_node (pp, gimple_asm_output_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } } n = gimple_asm_ninputs (gs); if (n) { - newline_and_indent (buffer, spc + 2); - pp_string (buffer, "INPUT: "); + newline_and_indent (pp, spc + 2); + pp_string (pp, "INPUT: "); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_input_op (gs, i), + dump_generic_node (pp, gimple_asm_input_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } } n = gimple_asm_nclobbers (gs); if (n) { - newline_and_indent (buffer, spc + 2); - pp_string (buffer, "CLOBBER: "); + newline_and_indent (pp, spc + 2); + pp_string (pp, "CLOBBER: "); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), + dump_generic_node (pp, gimple_asm_clobber_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } } n = gimple_asm_nlabels (gs); if (n) { - newline_and_indent (buffer, spc + 2); - pp_string (buffer, "LABEL: "); + newline_and_indent (pp, spc + 2); + pp_string (pp, "LABEL: "); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_label_op (gs, i), + dump_generic_node (pp, gimple_asm_label_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } } - newline_and_indent (buffer, spc); - pp_greater (buffer); + newline_and_indent (pp, spc); + pp_greater (pp); } else { - pp_string (buffer, "__asm__"); + pp_string (pp, "__asm__"); if (gimple_asm_volatile_p (gs)) - pp_string (buffer, " __volatile__"); + pp_string (pp, " __volatile__"); if (gimple_asm_inline_p (gs)) - pp_string (buffer, " __inline__"); + pp_string (pp, " __inline__"); if (gimple_asm_nlabels (gs)) - pp_string (buffer, " goto"); - pp_string (buffer, "(\""); - pp_string (buffer, gimple_asm_string (gs)); - pp_string (buffer, "\""); + pp_string (pp, " goto"); + pp_string (pp, "(\""); + pp_string (pp, gimple_asm_string (gs)); + pp_string (pp, "\""); if (gimple_asm_nlabels (gs)) fields = 4; @@ -2278,7 +2278,7 @@ dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc, for (f = 0; f < fields; ++f) { - pp_string (buffer, " : "); + pp_string (pp, " : "); switch (f) { @@ -2286,10 +2286,10 @@ dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc, n = gimple_asm_noutputs (gs); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_output_op (gs, i), + dump_generic_node (pp, gimple_asm_output_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } break; @@ -2297,10 +2297,10 @@ dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc, n = gimple_asm_ninputs (gs); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_input_op (gs, i), + dump_generic_node (pp, gimple_asm_input_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } break; @@ -2308,10 +2308,10 @@ dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc, n = gimple_asm_nclobbers (gs); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_clobber_op (gs, i), + dump_generic_node (pp, gimple_asm_clobber_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } break; @@ -2319,10 +2319,10 @@ dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc, n = gimple_asm_nlabels (gs); for (i = 0; i < n; i++) { - dump_generic_node (buffer, gimple_asm_label_op (gs, i), + dump_generic_node (pp, gimple_asm_label_op (gs, i), spc, flags, false); if (i < n - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } break; @@ -2331,15 +2331,15 @@ dump_gimple_asm (pretty_printer *buffer, const gasm *gs, int spc, } } - pp_string (buffer, ");"); + pp_string (pp, ");"); } } -/* Dump ptr_info and range_info for NODE on pretty_printer BUFFER with +/* Dump ptr_info and range_info for NODE on pretty_printer PP with SPC spaces of indent. */ static void -dump_ssaname_info (pretty_printer *buffer, tree node, int spc) +dump_ssaname_info (pretty_printer *pp, tree node, int spc) { if (TREE_CODE (node) != SSA_NAME) return; @@ -2349,13 +2349,13 @@ dump_ssaname_info (pretty_printer *buffer, tree node, int spc) { unsigned int align, misalign; struct ptr_info_def *pi = SSA_NAME_PTR_INFO (node); - pp_string (buffer, "# PT = "); - pp_points_to_solution (buffer, &pi->pt); - newline_and_indent (buffer, spc); + pp_string (pp, "# PT = "); + pp_points_to_solution (pp, &pi->pt); + newline_and_indent (pp, spc); if (get_ptr_info_alignment (pi, &align, &misalign)) { - pp_printf (buffer, "# ALIGN = %u, MISALIGN = %u", align, misalign); - newline_and_indent (buffer, spc); + pp_printf (pp, "# ALIGN = %u, MISALIGN = %u", align, misalign); + newline_and_indent (pp, spc); } } @@ -2364,9 +2364,9 @@ dump_ssaname_info (pretty_printer *buffer, tree node, int spc) { Value_Range r (TREE_TYPE (node)); get_global_range_query ()->range_of_expr (r, node); - pp_string (buffer, "# RANGE "); - pp_vrange (buffer, &r); - newline_and_indent (buffer, spc); + pp_string (pp, "# RANGE "); + pp_vrange (pp, &r); + newline_and_indent (pp, spc); } } @@ -2375,138 +2375,138 @@ dump_ssaname_info (pretty_printer *buffer, tree node, int spc) void dump_ssaname_info_to_file (FILE *file, tree node, int spc) { - pretty_printer buffer; - pp_needs_newline (&buffer) = true; - buffer.buffer->stream = file; - dump_ssaname_info (&buffer, node, spc); - pp_flush (&buffer); + pretty_printer pp; + pp_needs_newline (&pp) = true; + pp.buffer->stream = file; + dump_ssaname_info (&pp, node, spc); + pp_flush (&pp); } -/* Dump a PHI node PHI. BUFFER, SPC and FLAGS are as in pp_gimple_stmt_1. - The caller is responsible for calling pp_flush on BUFFER to finalize +/* Dump a PHI node PHI. PP, SPC and FLAGS are as in pp_gimple_stmt_1. + The caller is responsible for calling pp_flush on PP to finalize pretty printer. If COMMENT is true, print this after #. */ static void -dump_gimple_phi (pretty_printer *buffer, const gphi *phi, int spc, bool comment, +dump_gimple_phi (pretty_printer *pp, const gphi *phi, int spc, bool comment, dump_flags_t flags) { size_t i; tree lhs = gimple_phi_result (phi); if (flags & TDF_ALIAS) - dump_ssaname_info (buffer, lhs, spc); + dump_ssaname_info (pp, lhs, spc); if (comment) - pp_string (buffer, "# "); + pp_string (pp, "# "); if (flags & TDF_RAW) - dump_gimple_fmt (buffer, spc, flags, "%G <%T, ", phi, + dump_gimple_fmt (pp, spc, flags, "%G <%T, ", phi, gimple_phi_result (phi)); else { - dump_generic_node (buffer, lhs, spc, flags, false); + dump_generic_node (pp, lhs, spc, flags, false); if (flags & TDF_GIMPLE) - pp_string (buffer, " = __PHI ("); + pp_string (pp, " = __PHI ("); else - pp_string (buffer, " = PHI <"); + pp_string (pp, " = PHI <"); } for (i = 0; i < gimple_phi_num_args (phi); i++) { if ((flags & TDF_LINENO) && gimple_phi_arg_has_location (phi, i)) - dump_location (buffer, gimple_phi_arg_location (phi, i)); + dump_location (pp, gimple_phi_arg_location (phi, i)); basic_block src = gimple_phi_arg_edge (phi, i)->src; if (flags & TDF_GIMPLE) { - pp_string (buffer, "__BB"); - pp_decimal_int (buffer, src->index); - pp_string (buffer, ": "); + pp_string (pp, "__BB"); + pp_decimal_int (pp, src->index); + pp_string (pp, ": "); } - dump_generic_node (buffer, gimple_phi_arg_def (phi, i), spc, flags, + dump_generic_node (pp, gimple_phi_arg_def (phi, i), spc, flags, false); if (! (flags & TDF_GIMPLE)) { - pp_left_paren (buffer); - pp_decimal_int (buffer, src->index); - pp_right_paren (buffer); + pp_left_paren (pp); + pp_decimal_int (pp, src->index); + pp_right_paren (pp); } if (i < gimple_phi_num_args (phi) - 1) - pp_string (buffer, ", "); + pp_string (pp, ", "); } if (flags & TDF_GIMPLE) - pp_string (buffer, ");"); + pp_string (pp, ");"); else - pp_greater (buffer); + pp_greater (pp); } -/* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer BUFFER, SPC spaces +/* Dump a GIMPLE_OMP_PARALLEL tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_omp_parallel (pretty_printer *buffer, const gomp_parallel *gs, +dump_gimple_omp_parallel (pretty_printer *pp, const gomp_parallel *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >, %T, %T%n>", + dump_omp_clauses (pp, gimple_omp_parallel_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >, %T, %T%n>", gimple_omp_parallel_child_fn (gs), gimple_omp_parallel_data_arg (gs)); } else { gimple_seq body; - pp_string (buffer, "#pragma omp parallel"); - dump_omp_clauses (buffer, gimple_omp_parallel_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp parallel"); + dump_omp_clauses (pp, gimple_omp_parallel_clauses (gs), spc, flags); if (gimple_omp_parallel_child_fn (gs)) { - pp_string (buffer, " [child fn: "); - dump_generic_node (buffer, gimple_omp_parallel_child_fn (gs), + pp_string (pp, " [child fn: "); + dump_generic_node (pp, gimple_omp_parallel_child_fn (gs), spc, flags, false); - pp_string (buffer, " ("); + pp_string (pp, " ("); if (gimple_omp_parallel_data_arg (gs)) - dump_generic_node (buffer, gimple_omp_parallel_data_arg (gs), + dump_generic_node (pp, gimple_omp_parallel_data_arg (gs), spc, flags, false); else - pp_string (buffer, "???"); - pp_string (buffer, ")]"); + pp_string (pp, "???"); + pp_string (pp, ")]"); } body = gimple_omp_body (gs); if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) { - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); - pp_newline (buffer); - dump_gimple_seq (buffer, body, spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, body, spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } else if (body) { - pp_newline (buffer); - dump_gimple_seq (buffer, body, spc + 2, flags); + pp_newline (pp); + dump_gimple_seq (pp, body, spc + 2, flags); } } } -/* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer BUFFER, SPC spaces +/* Dump a GIMPLE_OMP_TASK tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_omp_task (pretty_printer *buffer, const gomp_task *gs, int spc, +dump_gimple_omp_task (pretty_printer *pp, const gomp_task *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%+BODY <%S>%nCLAUSES <", gs, gimple_omp_body (gs)); - dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags); - dump_gimple_fmt (buffer, spc, flags, " >, %T, %T, %T, %T, %T%n>", + dump_omp_clauses (pp, gimple_omp_task_clauses (gs), spc, flags); + dump_gimple_fmt (pp, spc, flags, " >, %T, %T, %T, %T, %T%n>", gimple_omp_task_child_fn (gs), gimple_omp_task_data_arg (gs), gimple_omp_task_copy_fn (gs), @@ -2517,116 +2517,116 @@ dump_gimple_omp_task (pretty_printer *buffer, const gomp_task *gs, int spc, { gimple_seq body; if (gimple_omp_task_taskloop_p (gs)) - pp_string (buffer, "#pragma omp taskloop"); + pp_string (pp, "#pragma omp taskloop"); else if (gimple_omp_task_taskwait_p (gs)) - pp_string (buffer, "#pragma omp taskwait"); + pp_string (pp, "#pragma omp taskwait"); else - pp_string (buffer, "#pragma omp task"); - dump_omp_clauses (buffer, gimple_omp_task_clauses (gs), spc, flags); + pp_string (pp, "#pragma omp task"); + dump_omp_clauses (pp, gimple_omp_task_clauses (gs), spc, flags); if (gimple_omp_task_child_fn (gs)) { - pp_string (buffer, " [child fn: "); - dump_generic_node (buffer, gimple_omp_task_child_fn (gs), + pp_string (pp, " [child fn: "); + dump_generic_node (pp, gimple_omp_task_child_fn (gs), spc, flags, false); - pp_string (buffer, " ("); + pp_string (pp, " ("); if (gimple_omp_task_data_arg (gs)) - dump_generic_node (buffer, gimple_omp_task_data_arg (gs), + dump_generic_node (pp, gimple_omp_task_data_arg (gs), spc, flags, false); else - pp_string (buffer, "???"); - pp_string (buffer, ")]"); + pp_string (pp, "???"); + pp_string (pp, ")]"); } body = gimple_omp_body (gs); if (body && gimple_code (gimple_seq_first_stmt (body)) != GIMPLE_BIND) { - newline_and_indent (buffer, spc + 2); - pp_left_brace (buffer); - pp_newline (buffer); - dump_gimple_seq (buffer, body, spc + 4, flags); - newline_and_indent (buffer, spc + 2); - pp_right_brace (buffer); + newline_and_indent (pp, spc + 2); + pp_left_brace (pp); + pp_newline (pp); + dump_gimple_seq (pp, body, spc + 4, flags); + newline_and_indent (pp, spc + 2); + pp_right_brace (pp); } else if (body) { - pp_newline (buffer); - dump_gimple_seq (buffer, body, spc + 2, flags); + pp_newline (pp); + dump_gimple_seq (pp, body, spc + 2, flags); } } } -/* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer BUFFER, SPC +/* Dump a GIMPLE_OMP_ATOMIC_LOAD tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_omp_atomic_load (pretty_printer *buffer, const gomp_atomic_load *gs, +dump_gimple_omp_atomic_load (pretty_printer *pp, const gomp_atomic_load *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%T, %T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%T, %T>", gs, gimple_omp_atomic_load_lhs (gs), gimple_omp_atomic_load_rhs (gs)); } else { - pp_string (buffer, "#pragma omp atomic_load"); - dump_omp_atomic_memory_order (buffer, + pp_string (pp, "#pragma omp atomic_load"); + dump_omp_atomic_memory_order (pp, gimple_omp_atomic_memory_order (gs)); if (gimple_omp_atomic_need_value_p (gs)) - pp_string (buffer, " [needed]"); + pp_string (pp, " [needed]"); if (gimple_omp_atomic_weak_p (gs)) - pp_string (buffer, " [weak]"); - newline_and_indent (buffer, spc + 2); - dump_generic_node (buffer, gimple_omp_atomic_load_lhs (gs), + pp_string (pp, " [weak]"); + newline_and_indent (pp, spc + 2); + dump_generic_node (pp, gimple_omp_atomic_load_lhs (gs), spc, flags, false); - pp_space (buffer); - pp_equal (buffer); - pp_space (buffer); - pp_star (buffer); - dump_generic_node (buffer, gimple_omp_atomic_load_rhs (gs), + pp_space (pp); + pp_equal (pp); + pp_space (pp); + pp_star (pp); + dump_generic_node (pp, gimple_omp_atomic_load_rhs (gs), spc, flags, false); } } -/* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer BUFFER, SPC +/* Dump a GIMPLE_OMP_ATOMIC_STORE tuple on the pretty_printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). */ static void -dump_gimple_omp_atomic_store (pretty_printer *buffer, +dump_gimple_omp_atomic_store (pretty_printer *pp, const gomp_atomic_store *gs, int spc, dump_flags_t flags) { if (flags & TDF_RAW) { - dump_gimple_fmt (buffer, spc, flags, "%G <%T>", gs, + dump_gimple_fmt (pp, spc, flags, "%G <%T>", gs, gimple_omp_atomic_store_val (gs)); } else { - pp_string (buffer, "#pragma omp atomic_store"); - dump_omp_atomic_memory_order (buffer, + pp_string (pp, "#pragma omp atomic_store"); + dump_omp_atomic_memory_order (pp, gimple_omp_atomic_memory_order (gs)); - pp_space (buffer); + pp_space (pp); if (gimple_omp_atomic_need_value_p (gs)) - pp_string (buffer, "[needed] "); + pp_string (pp, "[needed] "); if (gimple_omp_atomic_weak_p (gs)) - pp_string (buffer, "[weak] "); - pp_left_paren (buffer); - dump_generic_node (buffer, gimple_omp_atomic_store_val (gs), + pp_string (pp, "[weak] "); + pp_left_paren (pp); + dump_generic_node (pp, gimple_omp_atomic_store_val (gs), spc, flags, false); - pp_right_paren (buffer); + pp_right_paren (pp); } } -/* Dump all the memory operands for statement GS. BUFFER, SPC and +/* Dump all the memory operands for statement GS. PP, SPC and FLAGS are as in pp_gimple_stmt_1. */ static void -dump_gimple_mem_ops (pretty_printer *buffer, const gimple *gs, int spc, +dump_gimple_mem_ops (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { tree vdef = gimple_vdef (gs); @@ -2634,246 +2634,246 @@ dump_gimple_mem_ops (pretty_printer *buffer, const gimple *gs, int spc, if (vdef != NULL_TREE) { - pp_string (buffer, "# "); - dump_generic_node (buffer, vdef, spc + 2, flags, false); - pp_string (buffer, " = VDEF <"); - dump_generic_node (buffer, vuse, spc + 2, flags, false); - pp_greater (buffer); - newline_and_indent (buffer, spc); + pp_string (pp, "# "); + dump_generic_node (pp, vdef, spc + 2, flags, false); + pp_string (pp, " = VDEF <"); + dump_generic_node (pp, vuse, spc + 2, flags, false); + pp_greater (pp); + newline_and_indent (pp, spc); } else if (vuse != NULL_TREE) { - pp_string (buffer, "# VUSE <"); - dump_generic_node (buffer, vuse, spc + 2, flags, false); - pp_greater (buffer); - newline_and_indent (buffer, spc); + pp_string (pp, "# VUSE <"); + dump_generic_node (pp, vuse, spc + 2, flags, false); + pp_greater (pp); + newline_and_indent (pp, spc); } } -/* Print the gimple statement GS on the pretty printer BUFFER, SPC +/* Print the gimple statement GS on the pretty printer PP, SPC spaces of indent. FLAGS specifies details to show in the dump (see TDF_* in dumpfile.h). The caller is responsible for calling - pp_flush on BUFFER to finalize the pretty printer. */ + pp_flush on PP to finalize the pretty printer. */ void -pp_gimple_stmt_1 (pretty_printer *buffer, const gimple *gs, int spc, +pp_gimple_stmt_1 (pretty_printer *pp, const gimple *gs, int spc, dump_flags_t flags) { if (!gs) return; if (flags & TDF_STMTADDR) - pp_printf (buffer, "<&%p> ", (const void *) gs); + pp_printf (pp, "<&%p> ", (const void *) gs); if ((flags & TDF_LINENO) && gimple_has_location (gs)) - dump_location (buffer, gimple_location (gs)); + dump_location (pp, gimple_location (gs)); if (flags & TDF_EH) { int lp_nr = lookup_stmt_eh_lp (gs); if (lp_nr > 0) - pp_printf (buffer, "[LP %d] ", lp_nr); + pp_printf (pp, "[LP %d] ", lp_nr); else if (lp_nr < 0) - pp_printf (buffer, "[MNT %d] ", -lp_nr); + pp_printf (pp, "[MNT %d] ", -lp_nr); } if ((flags & (TDF_VOPS|TDF_MEMSYMS)) && gimple_has_mem_ops (gs)) - dump_gimple_mem_ops (buffer, gs, spc, flags); + dump_gimple_mem_ops (pp, gs, spc, flags); if (gimple_has_lhs (gs) && (flags & TDF_ALIAS)) - dump_ssaname_info (buffer, gimple_get_lhs (gs), spc); + dump_ssaname_info (pp, gimple_get_lhs (gs), spc); switch (gimple_code (gs)) { case GIMPLE_ASM: - dump_gimple_asm (buffer, as_a (gs), spc, flags); + dump_gimple_asm (pp, as_a (gs), spc, flags); break; case GIMPLE_ASSIGN: - dump_gimple_assign (buffer, as_a (gs), spc, flags); + dump_gimple_assign (pp, as_a (gs), spc, flags); break; case GIMPLE_BIND: - dump_gimple_bind (buffer, as_a (gs), spc, flags); + dump_gimple_bind (pp, as_a (gs), spc, flags); break; case GIMPLE_CALL: - dump_gimple_call (buffer, as_a (gs), spc, flags); + dump_gimple_call (pp, as_a (gs), spc, flags); break; case GIMPLE_COND: - dump_gimple_cond (buffer, as_a (gs), spc, flags); + dump_gimple_cond (pp, as_a (gs), spc, flags); break; case GIMPLE_LABEL: - dump_gimple_label (buffer, as_a (gs), spc, flags); + dump_gimple_label (pp, as_a (gs), spc, flags); break; case GIMPLE_GOTO: - dump_gimple_goto (buffer, as_a (gs), spc, flags); + dump_gimple_goto (pp, as_a (gs), spc, flags); break; case GIMPLE_NOP: - pp_string (buffer, "GIMPLE_NOP"); + pp_string (pp, "GIMPLE_NOP"); break; case GIMPLE_RETURN: - dump_gimple_return (buffer, as_a (gs), spc, flags); + dump_gimple_return (pp, as_a (gs), spc, flags); break; case GIMPLE_SWITCH: - dump_gimple_switch (buffer, as_a (gs), spc, flags); + dump_gimple_switch (pp, as_a (gs), spc, flags); break; case GIMPLE_TRY: - dump_gimple_try (buffer, as_a (gs), spc, flags); + dump_gimple_try (pp, as_a (gs), spc, flags); break; case GIMPLE_PHI: - dump_gimple_phi (buffer, as_a (gs), spc, false, flags); + dump_gimple_phi (pp, as_a (gs), spc, false, flags); break; case GIMPLE_OMP_PARALLEL: - dump_gimple_omp_parallel (buffer, as_a (gs), spc, + dump_gimple_omp_parallel (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_TASK: - dump_gimple_omp_task (buffer, as_a (gs), spc, flags); + dump_gimple_omp_task (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_ATOMIC_LOAD: - dump_gimple_omp_atomic_load (buffer, as_a (gs), + dump_gimple_omp_atomic_load (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_ATOMIC_STORE: - dump_gimple_omp_atomic_store (buffer, + dump_gimple_omp_atomic_store (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_FOR: - dump_gimple_omp_for (buffer, as_a (gs), spc, flags); + dump_gimple_omp_for (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_CONTINUE: - dump_gimple_omp_continue (buffer, as_a (gs), spc, + dump_gimple_omp_continue (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_SINGLE: - dump_gimple_omp_single (buffer, as_a (gs), spc, + dump_gimple_omp_single (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_TARGET: - dump_gimple_omp_target (buffer, as_a (gs), spc, + dump_gimple_omp_target (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_TEAMS: - dump_gimple_omp_teams (buffer, as_a (gs), spc, + dump_gimple_omp_teams (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_RETURN: - dump_gimple_omp_return (buffer, gs, spc, flags); + dump_gimple_omp_return (pp, gs, spc, flags); break; case GIMPLE_OMP_SECTIONS: - dump_gimple_omp_sections (buffer, as_a (gs), + dump_gimple_omp_sections (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_SECTIONS_SWITCH: - pp_string (buffer, "GIMPLE_SECTIONS_SWITCH"); + pp_string (pp, "GIMPLE_SECTIONS_SWITCH"); break; case GIMPLE_OMP_TASKGROUP: - dump_gimple_omp_taskgroup (buffer, gs, spc, flags); + dump_gimple_omp_taskgroup (pp, gs, spc, flags); break; case GIMPLE_OMP_MASKED: - dump_gimple_omp_masked (buffer, gs, spc, flags); + dump_gimple_omp_masked (pp, gs, spc, flags); break; case GIMPLE_OMP_SCOPE: - dump_gimple_omp_scope (buffer, gs, spc, flags); + dump_gimple_omp_scope (pp, gs, spc, flags); break; case GIMPLE_OMP_MASTER: case GIMPLE_OMP_SECTION: case GIMPLE_OMP_STRUCTURED_BLOCK: - dump_gimple_omp_block (buffer, gs, spc, flags); + dump_gimple_omp_block (pp, gs, spc, flags); break; case GIMPLE_OMP_ORDERED: - dump_gimple_omp_ordered (buffer, as_a (gs), spc, + dump_gimple_omp_ordered (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_SCAN: - dump_gimple_omp_scan (buffer, as_a (gs), spc, + dump_gimple_omp_scan (pp, as_a (gs), spc, flags); break; case GIMPLE_OMP_CRITICAL: - dump_gimple_omp_critical (buffer, as_a (gs), spc, + dump_gimple_omp_critical (pp, as_a (gs), spc, flags); break; case GIMPLE_CATCH: - dump_gimple_catch (buffer, as_a (gs), spc, flags); + dump_gimple_catch (pp, as_a (gs), spc, flags); break; case GIMPLE_EH_FILTER: - dump_gimple_eh_filter (buffer, as_a (gs), spc, + dump_gimple_eh_filter (pp, as_a (gs), spc, flags); break; case GIMPLE_EH_MUST_NOT_THROW: - dump_gimple_eh_must_not_throw (buffer, + dump_gimple_eh_must_not_throw (pp, as_a (gs), spc, flags); break; case GIMPLE_EH_ELSE: - dump_gimple_eh_else (buffer, as_a (gs), spc, flags); + dump_gimple_eh_else (pp, as_a (gs), spc, flags); break; case GIMPLE_RESX: - dump_gimple_resx (buffer, as_a (gs), spc, flags); + dump_gimple_resx (pp, as_a (gs), spc, flags); break; case GIMPLE_EH_DISPATCH: - dump_gimple_eh_dispatch (buffer, as_a (gs), spc, + dump_gimple_eh_dispatch (pp, as_a (gs), spc, flags); break; case GIMPLE_DEBUG: - dump_gimple_debug (buffer, as_a (gs), spc, flags); + dump_gimple_debug (pp, as_a (gs), spc, flags); break; case GIMPLE_PREDICT: - pp_string (buffer, "// predicted "); + pp_string (pp, "// predicted "); if (gimple_predict_outcome (gs)) - pp_string (buffer, "likely by "); + pp_string (pp, "likely by "); else - pp_string (buffer, "unlikely by "); - pp_string (buffer, predictor_name (gimple_predict_predictor (gs))); - pp_string (buffer, " predictor."); + pp_string (pp, "unlikely by "); + pp_string (pp, predictor_name (gimple_predict_predictor (gs))); + pp_string (pp, " predictor."); break; case GIMPLE_ASSUME: - dump_gimple_assume (buffer, gs, spc, flags); + dump_gimple_assume (pp, gs, spc, flags); break; case GIMPLE_TRANSACTION: - dump_gimple_transaction (buffer, as_a (gs), spc, + dump_gimple_transaction (pp, as_a (gs), spc, flags); break; @@ -2929,7 +2929,7 @@ dump_gimple_bb_header (FILE *outf, basic_block bb, int indent, } -/* Dumps end of basic block BB to buffer BUFFER indented by INDENT +/* Dumps end of basic block BB to PP indented by INDENT spaces. */ static void @@ -2943,11 +2943,11 @@ dump_gimple_bb_footer (FILE *outf ATTRIBUTE_UNUSED, } -/* Dump PHI nodes of basic block BB to BUFFER with details described +/* Dump PHI nodes of basic block BB to PP with details described by FLAGS and indented by INDENT spaces. */ static void -dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, +dump_phi_nodes (pretty_printer *pp, basic_block bb, int indent, dump_flags_t flags) { gphi_iterator i; @@ -2958,52 +2958,52 @@ dump_phi_nodes (pretty_printer *buffer, basic_block bb, int indent, if (!virtual_operand_p (gimple_phi_result (phi)) || (flags & TDF_VOPS)) { INDENT (indent); - dump_gimple_phi (buffer, phi, indent, + dump_gimple_phi (pp, phi, indent, (flags & TDF_GIMPLE) ? false : true, flags); - pp_newline (buffer); + pp_newline (pp); } } } /* Dump jump to basic block BB that is represented implicitly in the cfg - to BUFFER. */ + to PP. */ static void -pp_cfg_jump (pretty_printer *buffer, edge e, dump_flags_t flags) +pp_cfg_jump (pretty_printer *pp, edge e, dump_flags_t flags) { if (flags & TDF_GIMPLE) { - pp_string (buffer, "goto __BB"); - pp_decimal_int (buffer, e->dest->index); + pp_string (pp, "goto __BB"); + pp_decimal_int (pp, e->dest->index); if (e->probability.initialized_p ()) { - pp_string (buffer, "("); - pp_string (buffer, + pp_string (pp, "("); + pp_string (pp, profile_quality_as_string (e->probability.quality ())); - pp_string (buffer, "("); - pp_decimal_int (buffer, e->probability.value ()); - pp_string (buffer, "))"); + pp_string (pp, "("); + pp_decimal_int (pp, e->probability.value ()); + pp_string (pp, "))"); } - pp_semicolon (buffer); + pp_semicolon (pp); } else { - pp_string (buffer, "goto dest->index); - pp_greater (buffer); - pp_semicolon (buffer); + pp_string (pp, "goto dest->index); + pp_greater (pp); + pp_semicolon (pp); - dump_edge_probability (buffer, e); + dump_edge_probability (pp, e); } } -/* Dump edges represented implicitly in basic block BB to BUFFER, indented +/* Dump edges represented implicitly in basic block BB to PP, indented by INDENT spaces, with details given by FLAGS. */ static void -dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent, +dump_implicit_edges (pretty_printer *pp, basic_block bb, int indent, dump_flags_t flags) { edge e; @@ -3020,12 +3020,12 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent, extract_true_false_edges_from_block (bb, &true_edge, &false_edge); INDENT (indent + 2); - pp_cfg_jump (buffer, true_edge, flags); - newline_and_indent (buffer, indent); - pp_string (buffer, "else"); - newline_and_indent (buffer, indent + 2); - pp_cfg_jump (buffer, false_edge, flags); - pp_newline (buffer); + pp_cfg_jump (pp, true_edge, flags); + newline_and_indent (pp, indent); + pp_string (pp, "else"); + newline_and_indent (pp, indent + 2); + pp_cfg_jump (pp, false_edge, flags); + pp_newline (pp); return; } @@ -3039,19 +3039,19 @@ dump_implicit_edges (pretty_printer *buffer, basic_block bb, int indent, if ((flags & TDF_LINENO) && e->goto_locus != UNKNOWN_LOCATION) - dump_location (buffer, e->goto_locus); + dump_location (pp, e->goto_locus); - pp_cfg_jump (buffer, e, flags); - pp_newline (buffer); + pp_cfg_jump (pp, e, flags); + pp_newline (pp); } } -/* Dumps basic block BB to buffer BUFFER with details described by FLAGS and +/* Dumps basic block BB to PP with details described by FLAGS and indented by INDENT spaces. */ static void -gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent, +gimple_dump_bb_buff (pretty_printer *pp, basic_block bb, int indent, dump_flags_t flags) { gimple_stmt_iterator gsi; @@ -3061,7 +3061,7 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent, if (label_indent < 0) label_indent = 0; - dump_phi_nodes (buffer, bb, indent, flags); + dump_phi_nodes (pp, bb, indent, flags); for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) { @@ -3072,15 +3072,15 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent, curr_indent = gimple_code (stmt) == GIMPLE_LABEL ? label_indent : indent; INDENT (curr_indent); - pp_gimple_stmt_1 (buffer, stmt, curr_indent, flags); - pp_newline_and_flush (buffer); + pp_gimple_stmt_1 (pp, stmt, curr_indent, flags); + pp_newline_and_flush (pp); gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl)); dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl), - pp_buffer (buffer)->stream, stmt); + pp_buffer (pp)->stream, stmt); } - dump_implicit_edges (buffer, bb, indent, flags); - pp_flush (buffer); + dump_implicit_edges (pp, bb, indent, flags); + pp_flush (pp); } @@ -3093,10 +3093,10 @@ gimple_dump_bb (FILE *file, basic_block bb, int indent, dump_flags_t flags) dump_gimple_bb_header (file, bb, indent, flags); if (bb->index >= NUM_FIXED_BLOCKS) { - pretty_printer buffer; - pp_needs_newline (&buffer) = true; - buffer.buffer->stream = file; - gimple_dump_bb_buff (&buffer, bb, indent, flags); + pretty_printer pp; + pp_needs_newline (&pp) = true; + pp.buffer->stream = file; + gimple_dump_bb_buff (&pp, bb, indent, flags); } dump_gimple_bb_footer (file, bb, indent, flags); } diff --git a/gcc/print-tree.cc b/gcc/print-tree.cc index 7d38ed631d73..4e1acf04d442 100644 --- a/gcc/print-tree.cc +++ b/gcc/print-tree.cc @@ -954,11 +954,11 @@ print_node (FILE *file, const char *prefix, tree node, int indent, indent_to (file, indent + 4); fprintf (file, "def_stmt "); { - pretty_printer buffer; - buffer.buffer->stream = file; - pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4, + pretty_printer pp; + pp.buffer->stream = file; + pp_gimple_stmt_1 (&pp, SSA_NAME_DEF_STMT (node), indent + 4, TDF_NONE); - pp_flush (&buffer); + pp_flush (&pp); } indent_to (file, indent + 4); diff --git a/gcc/tree-loop-distribution.cc b/gcc/tree-loop-distribution.cc index 4d1ed234fcbe..83324086c85b 100644 --- a/gcc/tree-loop-distribution.cc +++ b/gcc/tree-loop-distribution.cc @@ -345,9 +345,9 @@ static void dot_rdg_1 (FILE *file, struct graph *rdg) { int i; - pretty_printer buffer; - pp_needs_newline (&buffer) = false; - buffer.buffer->stream = file; + pretty_printer pp; + pp_needs_newline (&pp) = false; + pp.buffer->stream = file; fprintf (file, "digraph RDG {\n"); @@ -357,8 +357,8 @@ dot_rdg_1 (FILE *file, struct graph *rdg) struct graph_edge *e; fprintf (file, "%d [label=\"[%d] ", i, i); - pp_gimple_stmt_1 (&buffer, RDGV_STMT (v), 0, TDF_SLIM); - pp_flush (&buffer); + pp_gimple_stmt_1 (&pp, RDGV_STMT (v), 0, TDF_SLIM); + pp_flush (&pp); fprintf (file, "\"]\n"); /* Highlight reads from memory. */ diff --git a/gcc/tree-pretty-print.h b/gcc/tree-pretty-print.h index 0da6242629b7..c5089f82cf6a 100644 --- a/gcc/tree-pretty-print.h +++ b/gcc/tree-pretty-print.h @@ -56,6 +56,6 @@ extern void print_call_name (pretty_printer *, tree, dump_flags_t); extern void pp_tree_identifier (pretty_printer *, tree); extern void dump_function_header (FILE *, tree, dump_flags_t); extern void pp_double_int (pretty_printer *pp, double_int d, bool uns); -extern void dump_location (pretty_printer *buffer, location_t loc); +extern void dump_location (pretty_printer *pp, location_t loc); #endif /* ! GCC_TREE_PRETTY_PRINT_H */ diff --git a/gcc/value-range.cc b/gcc/value-range.cc index dbb4f81ae3c4..45400306d647 100644 --- a/gcc/value-range.cc +++ b/gcc/value-range.cc @@ -282,23 +282,23 @@ vrange::operator== (const vrange &src) const void vrange::dump (FILE *file) const { - pretty_printer buffer; - pp_needs_newline (&buffer) = true; - buffer.buffer->stream = file; - vrange_printer vrange_pp (&buffer); + pretty_printer pp; + pp_needs_newline (&pp) = true; + pp.buffer->stream = file; + vrange_printer vrange_pp (&pp); this->accept (vrange_pp); - pp_flush (&buffer); + pp_flush (&pp); } void irange_bitmask::dump (FILE *file) const { char buf[WIDE_INT_PRINT_BUFFER_SIZE], *p; - pretty_printer buffer; + pretty_printer pp; - pp_needs_newline (&buffer) = true; - buffer.buffer->stream = file; - pp_string (&buffer, "MASK "); + pp_needs_newline (&pp) = true; + pp.buffer->stream = file; + pp_string (&pp, "MASK "); unsigned len_mask, len_val; if (print_hex_buf_size (m_mask, &len_mask) | print_hex_buf_size (m_value, &len_val)) @@ -306,11 +306,11 @@ irange_bitmask::dump (FILE *file) const else p = buf; print_hex (m_mask, p); - pp_string (&buffer, p); - pp_string (&buffer, " VALUE "); + pp_string (&pp, p); + pp_string (&pp, " VALUE "); print_hex (m_value, p); - pp_string (&buffer, p); - pp_flush (&buffer); + pp_string (&pp, p); + pp_flush (&pp); } namespace inchash -- 2.26.3