From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 81946 invoked by alias); 9 May 2017 15:41:27 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 81691 invoked by uid 89); 9 May 2017 15:41:26 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-15.6 required=5.0 tests=BAYES_00,FREEMAIL_FROM,GIT_PATCH_1,GIT_PATCH_2,GIT_PATCH_3,KAM_ASCII_DIVIDERS,RCVD_IN_DNSWL_NONE,RCVD_IN_SORBS_SPAM,SPF_PASS,URIBL_RED autolearn=ham version=3.3.2 spammy=dni, UD:stream, printers X-HELO: mail-yw0-f171.google.com Received: from mail-yw0-f171.google.com (HELO mail-yw0-f171.google.com) (209.85.161.171) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Tue, 09 May 2017 15:41:07 +0000 Received: by mail-yw0-f171.google.com with SMTP id l14so2424911ywk.1 for ; Tue, 09 May 2017 08:41:10 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:sender:to:from:subject:message-id:date :user-agent:mime-version:content-language; bh=YJZVVz/BM62MI3wfsyk55rLC+XN6c3Rzr4xQopckbuo=; b=FQLdCeGjSdzw1Dsgn0lSlfD25UmQmq0dG2eMOx0M1pgVrhzsXgf8+EwIfiHdG/tApL a2YPiiTM7XBD0xBTTVflSBkbT8csk8GLrKoUrxl4VdybAbIWOLwXSFrPFbWhEbVbz7eE Wsl8d8B9DyAx7LSqnsDMjGtpx/bisdH+mb+wtR4amq1CeSWf7oMgVgXSlP6lazFX/fZE gvTttHutv++2uzqInCBVmQomfb7Fd2TSg5A+ZacqJhuBzexuuUStsX9CduiWUMJ3fVOH ccPkoBtRHpVToWmKpwaUt6JdPmVrKmA8F5GNnyC0yCocxC/fFPGnlyDNMvl4zNFXc5f8 OgjQ== X-Gm-Message-State: AODbwcBhj3VxAOBMm6wPsjUH/glZrjYslmrgntxHW7rw4zPf2aHDqOIg zc3lE+NYXfyCej+l X-Received: by 10.129.137.2 with SMTP id z2mr530866ywf.72.1494344469001; Tue, 09 May 2017 08:41:09 -0700 (PDT) Received: from ?IPv6:2620:10d:c0a3:20fb:f6d0:5ac5:64cd:f102? ([2620:10d:c091:200::2:16e0]) by smtp.googlemail.com with ESMTPSA id u3sm169426ywu.10.2017.05.09.08.41.08 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Tue, 09 May 2017 08:41:08 -0700 (PDT) To: GCC Patches From: Nathan Sidwell Subject: [PATCH] Kill -fdump-translation-unit Message-ID: <964bab70-9a78-6812-4697-7c0c0f2dc096@acm.org> Date: Tue, 09 May 2017 15:46:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:52.0) Gecko/20100101 Thunderbird/52.0 MIME-Version: 1.0 Content-Type: multipart/mixed; boundary="------------412E7511DE24C30FAC214E28" X-SW-Source: 2017-05/txt/msg00677.txt.bz2 This is a multi-part message in MIME format. --------------412E7511DE24C30FAC214E28 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Content-length: 433 -fdump-translation-unit is an inscrutably opaque dump. It turned out that most of the uses of the tree-dump header file was to indirectly get at dumpfile.h, and the dump_function entry point it had forwarded to a dumper in tree-cfg.c. The gimple dumper would use its node dumper when asked for a raw dump, but that was about it. We have prettier printers now. This patch nukes the tu dumper. ok? nathan -- Nathan Sidwell --------------412E7511DE24C30FAC214E28 Content-Type: text/x-patch; name="tuecomy.diff" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="tuecomy.diff" Content-length: 56797 2017-05-09 Nathan Sidwell Remove -fdump-translation-unit. gcc/ * Makefile.in (TREE_DUMP_H): Delete. (C_COMMON_OBJS): Remove c-family/c-dump.o. (OBJS): Remove tree-dump.o. (PLUGIN_HEADERS): Remove $(TREE_DUMP_H). * cgraphclones.c: Include dumpfile.h not tree-dump.h. * doc/invoke.texi: Remove -fdump-translation-unit. * dumpfile.h (TDI_tu): Delete. (dump_function): Declare. (dump_node): Delete. * dumpfile.c: Include tree-cfg.h. (dump_files): Remove ".tu" line. (FIRST_AUTO_NUMBERED_DUMP): Decrement. (dump_function): New, from tree-dump.c. * tree-dump.h: Delete. * tree-dump.c: Delete. * gimplify.h: Include splay-tree.h not tree-dump.h. * graphite-poly.c: Don't include tree-dump.h * langhooks-def.h (lhd_tree_dump_dump_tree, lhd_tree_dump_type_quals): Don't declare. (LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN, LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN, LANG_HOOKS_TREE_DUMP_INITIALIZER): Delete. * langhooks.c (lhd_tree_dump_dump_tree, lhd_tree_dump_type_quals): Delete. * langhooks.h (lang_hooks_for_tree_dump): Delete. (lang_hooks): Remove tree_dump field. * print-tree.c: Include dumpfile.h not tree-dump.h. * stor-layout.c: Likewise. * tree-nested.c: Likewise. * tree-cfg.c (dump_function_to_file): Don't dump raw node. gcc/c/ * c-decl.c (c_parse_final_cleanups): Don't dump cleanup nodes. * gimple-parser.c: Don't #include tree-dump.h gcc/c-family/ * c-dump.c: Delete. * c-gimplify.c (c_genericize): Don't raw dump the saved tree. gcc/cp/ * Make-lang.in (CXX_AND_OBJCXX_OBJS): Remove cp/dump.o. * decl2.c (dump_tu): Delete. (c_parse_final_cleanups): Don't dump_tu. * dump.c: Delete. gcc/fortran/ * trans-decl.c: Include dumpfile.h, not tree-dump.h. Index: Makefile.in =================================================================== --- Makefile.in (revision 247784) +++ Makefile.in (working copy) @@ -970,7 +970,6 @@ OPTS_H = $(INPUT_H) $(VEC_H) opts.h $(OB SYMTAB_H = $(srcdir)/../libcpp/include/symtab.h $(OBSTACK_H) CPP_ID_DATA_H = $(CPPLIB_H) $(srcdir)/../libcpp/include/cpp-id-data.h CPP_INTERNAL_H = $(srcdir)/../libcpp/internal.h $(CPP_ID_DATA_H) -TREE_DUMP_H = tree-dump.h $(SPLAY_TREE_H) $(DUMPFILE_H) TREE_PASS_H = tree-pass.h $(TIMEVAR_H) $(DUMPFILE_H) TREE_SSA_H = tree-ssa.h tree-ssa-operands.h \ $(BITMAP_H) sbitmap.h $(BASIC_BLOCK_H) $(GIMPLE_H) \ @@ -1181,7 +1180,7 @@ GCC_OBJS = gcc.o gcc-main.o ggc-none.o c-family-warn = $(STRICT_WARN) # Language-specific object files shared by all C-family front ends. -C_COMMON_OBJS = c-family/c-common.o c-family/c-cppbuiltin.o c-family/c-dump.o \ +C_COMMON_OBJS = c-family/c-common.o c-family/c-cppbuiltin.o \ c-family/c-format.o c-family/c-gimplify.o c-family/c-indentation.o \ c-family/c-lex.o c-family/c-omp.o c-family/c-opts.o c-family/c-pch.o \ c-family/c-ppoutput.o c-family/c-pragma.o c-family/c-pretty-print.o \ @@ -1483,7 +1482,6 @@ OBJS = \ tree-data-ref.o \ tree-dfa.o \ tree-diagnostic.o \ - tree-dump.o \ tree-eh.o \ tree-emutls.o \ tree-if-conv.o \ @@ -3409,7 +3407,7 @@ PLUGIN_HEADERS = $(TREE_H) $(CONFIG_H) $ toplev.h $(DIAGNOSTIC_CORE_H) $(BASIC_BLOCK_H) $(HASH_TABLE_H) \ tree-ssa-alias.h $(INTERNAL_FN_H) gimple-fold.h tree-eh.h gimple-expr.h \ gimple.h is-a.h memmodel.h $(TREE_PASS_H) $(GCC_PLUGIN_H) \ - $(GGC_H) $(TREE_DUMP_H) $(PRETTY_PRINT_H) $(OPTS_H) $(PARAMS_H) \ + $(GGC_H) $(PRETTY_PRINT_H) $(OPTS_H) $(PARAMS_H) \ $(tm_file_list) $(tm_include_list) $(tm_p_file_list) $(tm_p_include_list) \ $(host_xm_file_list) $(host_xm_include_list) $(xm_include_list) \ intl.h $(PLUGIN_VERSION_H) $(DIAGNOSTIC_H) ${C_TREE_H} \ Index: c/c-decl.c =================================================================== --- c/c-decl.c (revision 247784) +++ c/c-decl.c (working copy) @@ -11240,18 +11240,6 @@ c_parse_final_cleanups (void) dump_ada_specs (collect_all_refs, NULL); } - if (ext_block) - { - tree tmp = BLOCK_VARS (ext_block); - int flags; - FILE * stream = dump_begin (TDI_tu, &flags); - if (stream && tmp) - { - dump_node (tmp, flags & ~TDF_SLIM, stream); - dump_end (TDI_tu, stream); - } - } - /* Process all file scopes in this compilation, and the external_scope, through wrapup_global_declarations. */ FOR_EACH_VEC_ELT (*all_translation_units, i, t) Index: c/gimple-parser.c =================================================================== --- c/gimple-parser.c (revision 247784) +++ c/gimple-parser.c (working copy) @@ -53,7 +53,6 @@ along with GCC; see the file COPYING3. #include "tree-ssanames.h" #include "gimple-ssa.h" #include "tree-dfa.h" -#include "tree-dump.h" /* Gimple parsing functions. */ Index: c-family/c-dump.c =================================================================== --- c-family/c-dump.c (revision 247784) +++ c-family/c-dump.c (working copy) @@ -1,50 +0,0 @@ -/* Tree-dumping functionality for C-family languages. - Copyright (C) 2002-2017 Free Software Foundation, Inc. - Written by Mark Mitchell - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify it under -the terms of the GNU General Public License as published by the Free -Software Foundation; either version 3, or (at your option) any later -version. - -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or -FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "c-common.h" -#include "tree-dump.h" - -/* Dump any C-specific tree codes and attributes of common codes. */ - -bool -c_dump_tree (void *dump_info, tree t) -{ - enum tree_code code; - dump_info_p di = (dump_info_p) dump_info; - - /* Figure out what kind of node this is. */ - code = TREE_CODE (t); - - switch (code) - { - case FIELD_DECL: - if (DECL_C_BIT_FIELD (t)) - dump_string (di, "bitfield"); - break; - - default: - break; - } - - return false; -} Index: c-family/c-gimplify.c =================================================================== --- c-family/c-gimplify.c (revision 247784) +++ c-family/c-gimplify.c (working copy) @@ -141,11 +141,7 @@ c_genericize (tree fndecl) fprintf (dump_orig, ";; enabled by -%s\n", dump_flag_name (TDI_original)); fprintf (dump_orig, "\n"); - if (local_dump_flags & TDF_RAW) - dump_node (DECL_SAVED_TREE (fndecl), - TDF_SLIM | local_dump_flags, dump_orig); - else - print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl)); + print_c_tree (dump_orig, DECL_SAVED_TREE (fndecl)); fprintf (dump_orig, "\n"); } Index: cgraphclones.c =================================================================== --- cgraphclones.c (revision 247784) +++ cgraphclones.c (working copy) @@ -78,7 +78,7 @@ along with GCC; see the file COPYING3. #include "tree-eh.h" #include "tree-cfg.h" #include "tree-inline.h" -#include "tree-dump.h" +#include "dumpfile.h" #include "gimple-pretty-print.h" /* Create clone of edge in the node N represented by CALL_EXPR Index: cp/Make-lang.in =================================================================== --- cp/Make-lang.in (revision 247784) +++ cp/Make-lang.in (working copy) @@ -74,7 +74,7 @@ CXX_C_OBJS = attribs.o incpath.o \ CXX_AND_OBJCXX_OBJS = cp/call.o cp/decl.o cp/expr.o cp/pt.o cp/typeck2.o \ cp/class.o cp/decl2.o cp/error.o cp/lex.o cp/parser.o cp/ptree.o cp/rtti.o \ cp/typeck.o cp/cvt.o cp/except.o cp/friend.o cp/init.o cp/method.o \ - cp/search.o cp/semantics.o cp/tree.o cp/repo.o cp/dump.o cp/optimize.o \ + cp/search.o cp/semantics.o cp/tree.o cp/repo.o cp/optimize.o \ cp/mangle.o cp/cp-objcp-common.o cp/name-lookup.o cp/cxx-pretty-print.o \ cp/cp-cilkplus.o \ cp/cp-gimplify.o cp/cp-array-notation.o cp/lambda.o \ Index: cp/decl2.c =================================================================== --- cp/decl2.c (revision 247784) +++ cp/decl2.c (working copy) @@ -4363,22 +4363,6 @@ generate_mangling_aliases () defer_mangling_aliases = false; } -/* The entire file is now complete. If requested, dump everything - to a file. */ - -static void -dump_tu (void) -{ - int flags; - FILE *stream = dump_begin (TDI_tu, &flags); - - if (stream) - { - dump_node (global_namespace, flags & ~TDF_SLIM, stream); - dump_end (TDI_tu, stream); - } -} - static location_t locus_at_end_of_parsing; /* Check the deallocation functions for CODE to see if we want to warn that @@ -4472,7 +4456,6 @@ c_parse_final_cleanups (void) || ! DECL_HARD_REGISTER (node->decl)) DECL_ASSEMBLER_NAME (node->decl); c_common_write_pch (); - dump_tu (); /* Ensure even the callers don't try to finalize the CU. */ flag_syntax_only = 1; return; @@ -4830,10 +4813,6 @@ c_parse_final_cleanups (void) fini_constexpr (); - /* The entire file is now complete. If requested, dump everything - to a file. */ - dump_tu (); - if (flag_detailed_statistics) { dump_tree_statistics (); Index: cp/dump.c =================================================================== --- cp/dump.c (revision 247784) +++ cp/dump.c (working copy) @@ -1,496 +0,0 @@ -/* Tree-dumping functionality for intermediate representation. - Copyright (C) 1999-2017 Free Software Foundation, Inc. - Written by Mark Mitchell - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 3, or (at your option) -any later version. - -GCC is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "cp-tree.h" -#include "tree-dump.h" - -static void dump_access (dump_info_p, tree); - -static void dump_op (dump_info_p, tree); - -/* Dump a representation of the accessibility information associated - with T. */ - -static void -dump_access (dump_info_p di, tree t) -{ - if (TREE_PROTECTED(t)) - dump_string_field (di, "accs", "prot"); - else if (TREE_PRIVATE(t)) - dump_string_field (di, "accs", "priv"); - else - dump_string_field (di, "accs", "pub"); -} - -/* Dump a representation of the specific operator for an overloaded - operator associated with node t. */ - -static void -dump_op (dump_info_p di, tree t) -{ - switch (DECL_OVERLOADED_OPERATOR_P (t)) { - case NEW_EXPR: - dump_string (di, "new"); - break; - case VEC_NEW_EXPR: - dump_string (di, "vecnew"); - break; - case DELETE_EXPR: - dump_string (di, "delete"); - break; - case VEC_DELETE_EXPR: - dump_string (di, "vecdelete"); - break; - case UNARY_PLUS_EXPR: - dump_string (di, "pos"); - break; - case NEGATE_EXPR: - dump_string (di, "neg"); - break; - case ADDR_EXPR: - dump_string (di, "addr"); - break; - case INDIRECT_REF: - dump_string(di, "deref"); - break; - case BIT_NOT_EXPR: - dump_string(di, "not"); - break; - case TRUTH_NOT_EXPR: - dump_string(di, "lnot"); - break; - case PREINCREMENT_EXPR: - dump_string(di, "preinc"); - break; - case PREDECREMENT_EXPR: - dump_string(di, "predec"); - break; - case PLUS_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "plusassign"); - else - dump_string(di, "plus"); - break; - case MINUS_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "minusassign"); - else - dump_string(di, "minus"); - break; - case MULT_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "multassign"); - else - dump_string (di, "mult"); - break; - case TRUNC_DIV_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "divassign"); - else - dump_string (di, "div"); - break; - case TRUNC_MOD_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "modassign"); - else - dump_string (di, "mod"); - break; - case BIT_AND_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "andassign"); - else - dump_string (di, "and"); - break; - case BIT_IOR_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "orassign"); - else - dump_string (di, "or"); - break; - case BIT_XOR_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "xorassign"); - else - dump_string (di, "xor"); - break; - case LSHIFT_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "lshiftassign"); - else - dump_string (di, "lshift"); - break; - case RSHIFT_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "rshiftassign"); - else - dump_string (di, "rshift"); - break; - case EQ_EXPR: - dump_string (di, "eq"); - break; - case NE_EXPR: - dump_string (di, "ne"); - break; - case LT_EXPR: - dump_string (di, "lt"); - break; - case GT_EXPR: - dump_string (di, "gt"); - break; - case LE_EXPR: - dump_string (di, "le"); - break; - case GE_EXPR: - dump_string (di, "ge"); - break; - case TRUTH_ANDIF_EXPR: - dump_string (di, "land"); - break; - case TRUTH_ORIF_EXPR: - dump_string (di, "lor"); - break; - case COMPOUND_EXPR: - dump_string (di, "compound"); - break; - case MEMBER_REF: - dump_string (di, "memref"); - break; - case COMPONENT_REF: - dump_string (di, "ref"); - break; - case ARRAY_REF: - dump_string (di, "subs"); - break; - case POSTINCREMENT_EXPR: - dump_string (di, "postinc"); - break; - case POSTDECREMENT_EXPR: - dump_string (di, "postdec"); - break; - case CALL_EXPR: - dump_string (di, "call"); - break; - case NOP_EXPR: - if (DECL_ASSIGNMENT_OPERATOR_P (t)) - dump_string (di, "assign"); - break; - default: - break; - } -} - -/* Dump information common to statements from STMT. */ - -static void -dump_stmt (dump_info_p di, const_tree t) -{ - if (EXPR_HAS_LOCATION (t)) - dump_int (di, "line", EXPR_LINENO (t)); -} - -bool -cp_dump_tree (void* dump_info, tree t) -{ - enum tree_code code; - dump_info_p di = (dump_info_p) dump_info; - - /* Figure out what kind of node this is. */ - code = TREE_CODE (t); - - if (DECL_P (t)) - { - if (DECL_LANG_SPECIFIC (t) && DECL_LANGUAGE (t) != lang_cplusplus) - dump_string_field (di, "lang", language_to_string (DECL_LANGUAGE (t))); - } - - switch (code) - { - case IDENTIFIER_NODE: - if (IDENTIFIER_OPNAME_P (t)) - { - dump_string_field (di, "note", "operator"); - return true; - } - else if (IDENTIFIER_TYPENAME_P (t)) - { - dump_child ("tynm", TREE_TYPE (t)); - return true; - } - break; - - case OFFSET_TYPE: - dump_string_field (di, "note", "ptrmem"); - dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); - dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); - return true; - - case RECORD_TYPE: - if (TYPE_PTRMEMFUNC_P (t)) - { - dump_string_field (di, "note", "ptrmem"); - dump_child ("ptd", TYPE_PTRMEM_POINTED_TO_TYPE (t)); - dump_child ("cls", TYPE_PTRMEM_CLASS_TYPE (t)); - return true; - } - /* Fall through. */ - - case UNION_TYPE: - /* Is it a type used as a base? */ - if (TYPE_CONTEXT (t) && TREE_CODE (TYPE_CONTEXT (t)) == TREE_CODE (t) - && CLASSTYPE_AS_BASE (TYPE_CONTEXT (t)) == t) - { - dump_child ("bfld", TYPE_CONTEXT (t)); - return true; - } - - if (! MAYBE_CLASS_TYPE_P (t)) - break; - - dump_child ("vfld", TYPE_VFIELD (t)); - if (CLASSTYPE_TEMPLATE_SPECIALIZATION(t)) - dump_string(di, "spec"); - - if (!dump_flag (di, TDF_SLIM, t) && TYPE_BINFO (t)) - { - int i; - tree binfo; - tree base_binfo; - - for (binfo = TYPE_BINFO (t), i = 0; - BINFO_BASE_ITERATE (binfo, i, base_binfo); ++i) - { - dump_child ("base", BINFO_TYPE (base_binfo)); - if (BINFO_VIRTUAL_P (base_binfo)) - dump_string_field (di, "spec", "virt"); - dump_access (di, base_binfo); - } - } - break; - - case FIELD_DECL: - dump_access (di, t); - if (DECL_MUTABLE_P (t)) - dump_string_field (di, "spec", "mutable"); - break; - - case VAR_DECL: - if (TREE_CODE (CP_DECL_CONTEXT (t)) == RECORD_TYPE) - dump_access (di, t); - if (TREE_STATIC (t) && !TREE_PUBLIC (t)) - dump_string_field (di, "link", "static"); - break; - - case FUNCTION_DECL: - if (!DECL_THUNK_P (t)) - { - if (DECL_OVERLOADED_OPERATOR_P (t)) { - dump_string_field (di, "note", "operator"); - dump_op (di, t); - } - if (DECL_FUNCTION_MEMBER_P (t)) - { - dump_string_field (di, "note", "member"); - dump_access (di, t); - } - if (DECL_PURE_VIRTUAL_P (t)) - dump_string_field (di, "spec", "pure"); - if (DECL_VIRTUAL_P (t)) - dump_string_field (di, "spec", "virt"); - if (DECL_CONSTRUCTOR_P (t)) - dump_string_field (di, "note", "constructor"); - if (DECL_DESTRUCTOR_P (t)) - dump_string_field (di, "note", "destructor"); - if (DECL_CONV_FN_P (t)) - dump_string_field (di, "note", "conversion"); - if (DECL_GLOBAL_CTOR_P (t)) - dump_string_field (di, "note", "global init"); - if (DECL_GLOBAL_DTOR_P (t)) - dump_string_field (di, "note", "global fini"); - if (DECL_FRIEND_PSEUDO_TEMPLATE_INSTANTIATION (t)) - dump_string_field (di, "note", "pseudo tmpl"); - } - else - { - tree virt = THUNK_VIRTUAL_OFFSET (t); - - dump_string_field (di, "note", "thunk"); - if (DECL_THIS_THUNK_P (t)) - dump_string_field (di, "note", "this adjusting"); - else - { - dump_string_field (di, "note", "result adjusting"); - if (virt) - virt = BINFO_VPTR_FIELD (virt); - } - dump_int (di, "fixd", THUNK_FIXED_OFFSET (t)); - if (virt) - dump_int (di, "virt", tree_to_shwi (virt)); - dump_child ("fn", DECL_INITIAL (t)); - } - break; - - case NAMESPACE_DECL: - if (DECL_NAMESPACE_ALIAS (t)) - dump_child ("alis", DECL_NAMESPACE_ALIAS (t)); - else if (!dump_flag (di, TDF_SLIM, t)) - dump_child ("dcls", cp_namespace_decls (t)); - break; - - case TEMPLATE_DECL: - dump_child ("rslt", DECL_TEMPLATE_RESULT (t)); - dump_child ("inst", DECL_TEMPLATE_INSTANTIATIONS (t)); - dump_child ("spcs", DECL_TEMPLATE_SPECIALIZATIONS (t)); - dump_child ("prms", DECL_TEMPLATE_PARMS (t)); - break; - - case OVERLOAD: - dump_child ("crnt", OVL_CURRENT (t)); - dump_child ("chan", OVL_CHAIN (t)); - break; - - case TRY_BLOCK: - dump_stmt (di, t); - if (CLEANUP_P (t)) - dump_string_field (di, "note", "cleanup"); - dump_child ("body", TRY_STMTS (t)); - dump_child ("hdlr", TRY_HANDLERS (t)); - break; - - case EH_SPEC_BLOCK: - dump_stmt (di, t); - dump_child ("body", EH_SPEC_STMTS (t)); - dump_child ("raises", EH_SPEC_RAISES (t)); - break; - - case PTRMEM_CST: - dump_child ("clas", PTRMEM_CST_CLASS (t)); - dump_child ("mbr", PTRMEM_CST_MEMBER (t)); - break; - - case THROW_EXPR: - /* These nodes are unary, but do not have code class `1'. */ - dump_child ("op 0", TREE_OPERAND (t, 0)); - break; - - case AGGR_INIT_EXPR: - { - int i = 0; - tree arg; - aggr_init_expr_arg_iterator iter; - dump_int (di, "ctor", AGGR_INIT_VIA_CTOR_P (t)); - dump_child ("fn", AGGR_INIT_EXPR_FN (t)); - FOR_EACH_AGGR_INIT_EXPR_ARG (arg, iter, t) - { - char buffer[32]; - sprintf (buffer, "%u", i); - dump_child (buffer, arg); - i++; - } - dump_child ("decl", AGGR_INIT_EXPR_SLOT (t)); - } - break; - - case HANDLER: - dump_stmt (di, t); - dump_child ("parm", HANDLER_PARMS (t)); - dump_child ("body", HANDLER_BODY (t)); - break; - - case MUST_NOT_THROW_EXPR: - dump_stmt (di, t); - dump_child ("body", TREE_OPERAND (t, 0)); - dump_child ("cond", MUST_NOT_THROW_COND (t)); - break; - - case USING_STMT: - dump_stmt (di, t); - dump_child ("nmsp", USING_STMT_NAMESPACE (t)); - break; - - case CLEANUP_STMT: - dump_stmt (di, t); - dump_child ("decl", CLEANUP_DECL (t)); - dump_child ("expr", CLEANUP_EXPR (t)); - dump_child ("body", CLEANUP_BODY (t)); - break; - - case IF_STMT: - dump_stmt (di, t); - dump_child ("cond", IF_COND (t)); - dump_child ("then", THEN_CLAUSE (t)); - dump_child ("else", ELSE_CLAUSE (t)); - break; - - case BREAK_STMT: - case CONTINUE_STMT: - dump_stmt (di, t); - break; - - case DO_STMT: - dump_stmt (di, t); - dump_child ("body", DO_BODY (t)); - dump_child ("cond", DO_COND (t)); - break; - - case FOR_STMT: - dump_stmt (di, t); - dump_child ("init", FOR_INIT_STMT (t)); - dump_child ("cond", FOR_COND (t)); - dump_child ("expr", FOR_EXPR (t)); - dump_child ("body", FOR_BODY (t)); - break; - - case RANGE_FOR_STMT: - dump_stmt (di, t); - dump_child ("decl", RANGE_FOR_DECL (t)); - dump_child ("expr", RANGE_FOR_EXPR (t)); - dump_child ("body", RANGE_FOR_BODY (t)); - break; - - case SWITCH_STMT: - dump_stmt (di, t); - dump_child ("cond", SWITCH_STMT_COND (t)); - dump_child ("body", SWITCH_STMT_BODY (t)); - break; - - case WHILE_STMT: - dump_stmt (di, t); - dump_child ("cond", WHILE_COND (t)); - dump_child ("body", WHILE_BODY (t)); - break; - - case STMT_EXPR: - dump_child ("stmt", STMT_EXPR_STMT (t)); - break; - - case EXPR_STMT: - dump_stmt (di, t); - dump_child ("expr", EXPR_STMT_EXPR (t)); - break; - - default: - break; - } - - return c_dump_tree (di, t); -} Index: doc/invoke.texi =================================================================== --- doc/invoke.texi (revision 247784) +++ doc/invoke.texi (working copy) @@ -546,7 +546,6 @@ Objective-C and Objective-C++ Dialects}. -fdump-passes @gol -fdump-rtl-@var{pass} -fdump-rtl-@var{pass}=@var{filename} @gol -fdump-statistics @gol --fdump-translation-unit@r{[}-@var{n}@r{]} @gol -fdump-tree-all @gol -fdump-tree-@var{switch} @gol -fdump-tree-@var{switch}-@var{options} @gol @@ -12985,16 +12984,6 @@ whole compilation unit while @samp{-deta the passes generate them. The default with no option is to sum counters for each function compiled. -@item -fdump-translation-unit @r{(C++ only)} -@itemx -fdump-translation-unit-@var{options} @r{(C++ only)} -@opindex fdump-translation-unit -Dump a representation of the tree structure for the entire translation -unit to a file. The file name is made by appending @file{.tu} to the -source file name, and the file is created in the same directory as the -output file. If the @samp{-@var{options}} form is used, @var{options} -controls the details of the dump as described for the -@option{-fdump-tree} options. - @item -fdump-tree-all @itemx -fdump-tree-@var{switch} @itemx -fdump-tree-@var{switch}-@var{options} Index: dumpfile.c =================================================================== --- dumpfile.c (revision 247784) +++ dumpfile.c (working copy) @@ -26,6 +26,7 @@ along with GCC; see the file COPYING3. #include "diagnostic-core.h" #include "dumpfile.h" #include "context.h" +#include "tree-cfg.h" /* If non-NULL, return one past-the-end of the matching SUBPART of the WHOLE string. */ @@ -57,8 +58,6 @@ static struct dump_file_info dump_files[ 0, 0, 0, 0, 0, false, false}, {".ipa-clones", "ipa-clones", NULL, NULL, NULL, NULL, NULL, TDF_IPA, 0, 0, 0, 0, 0, false, false}, - {".tu", "translation-unit", NULL, NULL, NULL, NULL, NULL, TDF_TREE, - 0, 0, 0, 0, 1, false, false}, {".class", "class-hierarchy", NULL, NULL, NULL, NULL, NULL, TDF_TREE, 0, 0, 0, 0, 2, false, false}, {".original", "tree-original", NULL, NULL, NULL, NULL, NULL, TDF_TREE, @@ -67,7 +66,7 @@ static struct dump_file_info dump_files[ 0, 0, 0, 0, 4, false, false}, {".nested", "tree-nested", NULL, NULL, NULL, NULL, NULL, TDF_TREE, 0, 0, 0, 0, 5, false, false}, -#define FIRST_AUTO_NUMBERED_DUMP 6 +#define FIRST_AUTO_NUMBERED_DUMP 5 {NULL, "tree-all", NULL, NULL, NULL, NULL, NULL, TDF_TREE, 0, 0, 0, 0, 0, false, false}, @@ -982,6 +981,22 @@ dump_basic_block (int dump_kind, basic_b dump_bb (alt_dump_file, bb, indent, TDF_DETAILS); } +/* Dump FUNCTION_DECL FN as tree dump PHASE. */ + +void +dump_function (int phase, tree fn) +{ + FILE *stream; + int flags; + + stream = dump_begin (phase, &flags); + if (stream) + { + dump_function_to_file (fn, stream, flags); + dump_end (phase, stream); + } +} + /* Print information from the combine pass on dump_file. */ void Index: dumpfile.h =================================================================== --- dumpfile.h (revision 247784) +++ dumpfile.h (working copy) @@ -30,7 +30,6 @@ enum tree_dump_index TDI_cgraph, /* dump function call graph. */ TDI_inheritance, /* dump type inheritance graph. */ TDI_clones, /* dump IPA cloning decisions. */ - TDI_tu, /* dump the whole translation unit. */ TDI_class, /* dump class hierarchy. */ TDI_original, /* dump each function before optimizing it */ TDI_generic, /* dump each function after genericizing it */ @@ -138,6 +137,7 @@ extern const char *dump_flag_name (int); extern void dump_printf (int, const char *, ...) ATTRIBUTE_PRINTF_2; extern void dump_printf_loc (int, source_location, const char *, ...) ATTRIBUTE_PRINTF_3; +extern void dump_function (int phase, tree fn); extern void dump_basic_block (int, basic_block, int); extern void dump_generic_expr_loc (int, source_location, int, tree); extern void dump_generic_expr (int, int, tree); @@ -146,9 +146,6 @@ extern void dump_gimple_stmt (int, int, extern void print_combine_total_stats (void); extern bool enable_rtl_dump_file (void); -/* In tree-dump.c */ -extern void dump_node (const_tree, int, FILE *); - /* In combine.c */ extern void dump_combine_total_stats (FILE *); /* In cfghooks.c */ Index: fortran/trans-decl.c =================================================================== --- fortran/trans-decl.c (revision 247784) +++ fortran/trans-decl.c (working copy) @@ -35,7 +35,7 @@ along with GCC; see the file COPYING3. #include "stor-layout.h" #include "varasm.h" #include "attribs.h" -#include "tree-dump.h" +#include "dumpfile.h" #include "toplev.h" /* For announce_function. */ #include "debug.h" #include "constructor.h" Index: gimplify.c =================================================================== --- gimplify.c (revision 247784) +++ gimplify.c (working copy) @@ -56,7 +56,7 @@ along with GCC; see the file COPYING3. #include "gimple-low.h" #include "cilk.h" #include "gomp-constants.h" -#include "tree-dump.h" +#include "splay-tree.h" #include "gimple-walk.h" #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name */ #include "builtins.h" Index: graphite-poly.c =================================================================== --- graphite-poly.c (revision 247784) +++ graphite-poly.c (working copy) @@ -39,7 +39,6 @@ along with GCC; see the file COPYING3. #include "tree-data-ref.h" #include "pretty-print.h" #include "gimple-pretty-print.h" -#include "tree-dump.h" #include "graphite.h" /* Print to STDERR the GMP value VAL. */ Index: langhooks-def.h =================================================================== --- langhooks-def.h (revision 247784) +++ langhooks-def.h (working copy) @@ -147,19 +147,8 @@ extern int lhd_type_dwarf_attribute (con /* Hooks for tree gimplification. */ #define LANG_HOOKS_GIMPLIFY_EXPR lhd_gimplify_expr -/* Tree dump hooks. */ -extern bool lhd_tree_dump_dump_tree (void *, tree); -extern int lhd_tree_dump_type_quals (const_tree); extern tree lhd_make_node (enum tree_code); -#define LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN lhd_tree_dump_dump_tree -#define LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN lhd_tree_dump_type_quals - -#define LANG_HOOKS_TREE_DUMP_INITIALIZER { \ - LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN, \ - LANG_HOOKS_TREE_DUMP_TYPE_QUALS_FN \ -} - /* Types hooks. There are no reasonable defaults for most of them, so we create a compile-time error instead. */ extern tree lhd_unit_size_without_reusable_padding (tree); @@ -319,7 +308,6 @@ extern void lhd_end_section (void); LANG_HOOKS_COMMON_ATTRIBUTE_TABLE, \ LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE, \ LANG_HOOKS_TREE_INLINING_INITIALIZER, \ - LANG_HOOKS_TREE_DUMP_INITIALIZER, \ LANG_HOOKS_DECLS, \ LANG_HOOKS_FOR_TYPES_INITIALIZER, \ LANG_HOOKS_LTO, \ Index: langhooks.c =================================================================== --- langhooks.c (revision 247784) +++ langhooks.c (working copy) @@ -236,25 +236,6 @@ lhd_types_compatible_p (tree x, tree y) return TYPE_MAIN_VARIANT (x) == TYPE_MAIN_VARIANT (y); } -/* lang_hooks.tree_dump.dump_tree: Dump language-specific parts of tree - nodes. Returns nonzero if it does not want the usual dumping of the - second argument. */ - -bool -lhd_tree_dump_dump_tree (void *di ATTRIBUTE_UNUSED, tree t ATTRIBUTE_UNUSED) -{ - return false; -} - -/* lang_hooks.tree_dump.type_qual: Determine type qualifiers in a - language-specific way. */ - -int -lhd_tree_dump_type_quals (const_tree t) -{ - return TYPE_QUALS (t); -} - /* lang_hooks.gimplify_expr re-writes *EXPR_P into GIMPLE form. */ int Index: langhooks.h =================================================================== --- langhooks.h (revision 247784) +++ langhooks.h (working copy) @@ -44,18 +44,6 @@ struct lang_hooks_for_tree_inlining bool (*var_mod_type_p) (tree, tree); }; -/* The following hooks are used by tree-dump.c. */ - -struct lang_hooks_for_tree_dump -{ - /* Dump language-specific parts of tree nodes. Returns nonzero if it - does not want the usual dumping of the second argument. */ - bool (*dump_tree) (void *, tree); - - /* Determine type qualifiers in a language-specific way. */ - int (*type_quals) (const_tree); -}; - /* Hooks related to types. */ struct lang_hooks_for_types @@ -447,8 +435,6 @@ struct lang_hooks struct lang_hooks_for_tree_inlining tree_inlining; - struct lang_hooks_for_tree_dump tree_dump; - struct lang_hooks_for_decls decls; struct lang_hooks_for_types types; Index: print-tree.c =================================================================== --- print-tree.c (revision 247784) +++ print-tree.c (working copy) @@ -32,7 +32,7 @@ along with GCC; see the file COPYING3. #include "tree-iterator.h" #include "gimple-pretty-print.h" /* FIXME */ #include "tree-cfg.h" -#include "tree-dump.h" +#include "dumpfile.h" #include "print-tree.h" /* Define the hash table of nodes already seen. Index: stor-layout.c =================================================================== --- stor-layout.c (revision 247784) +++ stor-layout.c (working copy) @@ -38,7 +38,7 @@ along with GCC; see the file COPYING3. #include "print-tree.h" #include "langhooks.h" #include "tree-inline.h" -#include "tree-dump.h" +#include "dumpfile.h" #include "gimplify.h" #include "debug.h" Index: tree-cfg.c =================================================================== --- tree-cfg.c (revision 247784) +++ tree-cfg.c (working copy) @@ -7588,7 +7588,6 @@ dump_function_to_file (tree fndecl, FILE if (flags & TDF_RAW && !gimple_has_body_p (fndecl)) { - dump_node (fndecl, TDF_SLIM | flags, file); current_function_decl = old_current_fndecl; return; } Index: tree-dump.c =================================================================== --- tree-dump.c (revision 247784) +++ tree-dump.c (working copy) @@ -1,772 +0,0 @@ -/* Tree-dumping functionality for intermediate representation. - Copyright (C) 1999-2017 Free Software Foundation, Inc. - Written by Mark Mitchell - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify it under -the terms of the GNU General Public License as published by the Free -Software Foundation; either version 3, or (at your option) any later -version. - -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or -FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tree.h" -#include "tree-pretty-print.h" -#include "tree-dump.h" -#include "langhooks.h" -#include "tree-iterator.h" -#include "tree-cfg.h" - -static unsigned int queue (dump_info_p, const_tree, int); -static void dump_index (dump_info_p, unsigned int); -static void dequeue_and_dump (dump_info_p); -static void dump_new_line (dump_info_p); -static void dump_maybe_newline (dump_info_p); - -/* Add T to the end of the queue of nodes to dump. Returns the index - assigned to T. */ - -static unsigned int -queue (dump_info_p di, const_tree t, int flags) -{ - dump_queue_p dq; - dump_node_info_p dni; - unsigned int index; - - /* Assign the next available index to T. */ - index = ++di->index; - - /* Obtain a new queue node. */ - if (di->free_list) - { - dq = di->free_list; - di->free_list = dq->next; - } - else - dq = XNEW (struct dump_queue); - - /* Create a new entry in the splay-tree. */ - dni = XNEW (struct dump_node_info); - dni->index = index; - dni->binfo_p = ((flags & DUMP_BINFO) != 0); - dq->node = splay_tree_insert (di->nodes, (splay_tree_key) t, - (splay_tree_value) dni); - - /* Add it to the end of the queue. */ - dq->next = 0; - if (!di->queue_end) - di->queue = dq; - else - di->queue_end->next = dq; - di->queue_end = dq; - - /* Return the index. */ - return index; -} - -static void -dump_index (dump_info_p di, unsigned int index) -{ - fprintf (di->stream, "@%-6u ", index); - di->column += 8; -} - -/* If T has not already been output, queue it for subsequent output. - FIELD is a string to print before printing the index. Then, the - index of T is printed. */ - -void -queue_and_dump_index (dump_info_p di, const char *field, const_tree t, int flags) -{ - unsigned int index; - splay_tree_node n; - - /* If there's no node, just return. This makes for fewer checks in - our callers. */ - if (!t) - return; - - /* See if we've already queued or dumped this node. */ - n = splay_tree_lookup (di->nodes, (splay_tree_key) t); - if (n) - index = ((dump_node_info_p) n->value)->index; - else - /* If we haven't, add it to the queue. */ - index = queue (di, t, flags); - - /* Print the index of the node. */ - dump_maybe_newline (di); - fprintf (di->stream, "%-4s: ", field); - di->column += 6; - dump_index (di, index); -} - -/* Dump the type of T. */ - -void -queue_and_dump_type (dump_info_p di, const_tree t) -{ - queue_and_dump_index (di, "type", TREE_TYPE (t), DUMP_NONE); -} - -/* Dump column control */ -#define SOL_COLUMN 25 /* Start of line column. */ -#define EOL_COLUMN 55 /* End of line column. */ -#define COLUMN_ALIGNMENT 15 /* Alignment. */ - -/* Insert a new line in the dump output, and indent to an appropriate - place to start printing more fields. */ - -static void -dump_new_line (dump_info_p di) -{ - fprintf (di->stream, "\n%*s", SOL_COLUMN, ""); - di->column = SOL_COLUMN; -} - -/* If necessary, insert a new line. */ - -static void -dump_maybe_newline (dump_info_p di) -{ - int extra; - - /* See if we need a new line. */ - if (di->column > EOL_COLUMN) - dump_new_line (di); - /* See if we need any padding. */ - else if ((extra = (di->column - SOL_COLUMN) % COLUMN_ALIGNMENT) != 0) - { - fprintf (di->stream, "%*s", COLUMN_ALIGNMENT - extra, ""); - di->column += COLUMN_ALIGNMENT - extra; - } -} - -/* Dump FUNCTION_DECL FN as tree dump PHASE. */ - -void -dump_function (int phase, tree fn) -{ - FILE *stream; - int flags; - - stream = dump_begin (phase, &flags); - if (stream) - { - dump_function_to_file (fn, stream, flags); - dump_end (phase, stream); - } -} - -/* Dump pointer PTR using FIELD to identify it. */ - -void -dump_pointer (dump_info_p di, const char *field, void *ptr) -{ - dump_maybe_newline (di); - fprintf (di->stream, "%-4s: %-8" HOST_WIDE_INT_PRINT "x ", field, - (unsigned HOST_WIDE_INT) (uintptr_t) ptr); - di->column += 15; -} - -/* Dump integer I using FIELD to identify it. */ - -void -dump_int (dump_info_p di, const char *field, int i) -{ - dump_maybe_newline (di); - fprintf (di->stream, "%-4s: %-7d ", field, i); - di->column += 14; -} - -/* Dump the floating point value R, using FIELD to identify it. */ - -static void -dump_real (dump_info_p di, const char *field, const REAL_VALUE_TYPE *r) -{ - char buf[32]; - real_to_decimal (buf, r, sizeof (buf), 0, true); - dump_maybe_newline (di); - fprintf (di->stream, "%-4s: %s ", field, buf); - di->column += strlen (buf) + 7; -} - -/* Dump the fixed-point value F, using FIELD to identify it. */ - -static void -dump_fixed (dump_info_p di, const char *field, const FIXED_VALUE_TYPE *f) -{ - char buf[32]; - fixed_to_decimal (buf, f, sizeof (buf)); - dump_maybe_newline (di); - fprintf (di->stream, "%-4s: %s ", field, buf); - di->column += strlen (buf) + 7; -} - - -/* Dump the string S. */ - -void -dump_string (dump_info_p di, const char *string) -{ - dump_maybe_newline (di); - fprintf (di->stream, "%-13s ", string); - if (strlen (string) > 13) - di->column += strlen (string) + 1; - else - di->column += 14; -} - -/* Dump the string field S. */ - -void -dump_string_field (dump_info_p di, const char *field, const char *string) -{ - dump_maybe_newline (di); - fprintf (di->stream, "%-4s: %-7s ", field, string); - if (strlen (string) > 7) - di->column += 6 + strlen (string) + 1; - else - di->column += 14; -} - -/* Dump the next node in the queue. */ - -static void -dequeue_and_dump (dump_info_p di) -{ - dump_queue_p dq; - splay_tree_node stn; - dump_node_info_p dni; - tree t; - unsigned int index; - enum tree_code code; - enum tree_code_class code_class; - const char* code_name; - - /* Get the next node from the queue. */ - dq = di->queue; - stn = dq->node; - t = (tree) stn->key; - dni = (dump_node_info_p) stn->value; - index = dni->index; - - /* Remove the node from the queue, and put it on the free list. */ - di->queue = dq->next; - if (!di->queue) - di->queue_end = 0; - dq->next = di->free_list; - di->free_list = dq; - - /* Print the node index. */ - dump_index (di, index); - /* And the type of node this is. */ - if (dni->binfo_p) - code_name = "binfo"; - else - code_name = get_tree_code_name (TREE_CODE (t)); - fprintf (di->stream, "%-16s ", code_name); - di->column = 25; - - /* Figure out what kind of node this is. */ - code = TREE_CODE (t); - code_class = TREE_CODE_CLASS (code); - - /* Although BINFOs are TREE_VECs, we dump them specially so as to be - more informative. */ - if (dni->binfo_p) - { - unsigned ix; - tree base; - vec *accesses = BINFO_BASE_ACCESSES (t); - - dump_child ("type", BINFO_TYPE (t)); - - if (BINFO_VIRTUAL_P (t)) - dump_string_field (di, "spec", "virt"); - - dump_int (di, "bases", BINFO_N_BASE_BINFOS (t)); - for (ix = 0; BINFO_BASE_ITERATE (t, ix, base); ix++) - { - tree access = (accesses ? (*accesses)[ix] : access_public_node); - const char *string = NULL; - - if (access == access_public_node) - string = "pub"; - else if (access == access_protected_node) - string = "prot"; - else if (access == access_private_node) - string = "priv"; - else - gcc_unreachable (); - - dump_string_field (di, "accs", string); - queue_and_dump_index (di, "binf", base, DUMP_BINFO); - } - - goto done; - } - - /* We can knock off a bunch of expression nodes in exactly the same - way. */ - if (IS_EXPR_CODE_CLASS (code_class)) - { - /* If we're dumping children, dump them now. */ - queue_and_dump_type (di, t); - - switch (code_class) - { - case tcc_unary: - dump_child ("op 0", TREE_OPERAND (t, 0)); - break; - - case tcc_binary: - case tcc_comparison: - dump_child ("op 0", TREE_OPERAND (t, 0)); - dump_child ("op 1", TREE_OPERAND (t, 1)); - break; - - case tcc_expression: - case tcc_reference: - case tcc_statement: - case tcc_vl_exp: - /* These nodes are handled explicitly below. */ - break; - - default: - gcc_unreachable (); - } - } - else if (DECL_P (t)) - { - expanded_location xloc; - /* All declarations have names. */ - if (DECL_NAME (t)) - dump_child ("name", DECL_NAME (t)); - if (DECL_ASSEMBLER_NAME_SET_P (t) - && DECL_ASSEMBLER_NAME (t) != DECL_NAME (t)) - dump_child ("mngl", DECL_ASSEMBLER_NAME (t)); - if (DECL_ABSTRACT_ORIGIN (t)) - dump_child ("orig", DECL_ABSTRACT_ORIGIN (t)); - /* And types. */ - queue_and_dump_type (di, t); - dump_child ("scpe", DECL_CONTEXT (t)); - /* And a source position. */ - xloc = expand_location (DECL_SOURCE_LOCATION (t)); - if (xloc.file) - { - const char *filename = lbasename (xloc.file); - - dump_maybe_newline (di); - fprintf (di->stream, "srcp: %s:%-6d ", filename, - xloc.line); - di->column += 6 + strlen (filename) + 8; - } - /* And any declaration can be compiler-generated. */ - if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_DECL_COMMON) - && DECL_ARTIFICIAL (t)) - dump_string_field (di, "note", "artificial"); - if (DECL_CHAIN (t) && !dump_flag (di, TDF_SLIM, NULL)) - dump_child ("chain", DECL_CHAIN (t)); - } - else if (code_class == tcc_type) - { - /* All types have qualifiers. */ - int quals = lang_hooks.tree_dump.type_quals (t); - - if (quals != TYPE_UNQUALIFIED) - { - fprintf (di->stream, "qual: %c%c%c ", - (quals & TYPE_QUAL_CONST) ? 'c' : ' ', - (quals & TYPE_QUAL_VOLATILE) ? 'v' : ' ', - (quals & TYPE_QUAL_RESTRICT) ? 'r' : ' '); - di->column += 14; - } - - /* All types have associated declarations. */ - dump_child ("name", TYPE_NAME (t)); - - /* All types have a main variant. */ - if (TYPE_MAIN_VARIANT (t) != t) - dump_child ("unql", TYPE_MAIN_VARIANT (t)); - - /* And sizes. */ - dump_child ("size", TYPE_SIZE (t)); - - /* All types have alignments. */ - dump_int (di, "algn", TYPE_ALIGN (t)); - } - else if (code_class == tcc_constant) - /* All constants can have types. */ - queue_and_dump_type (di, t); - - /* Give the language-specific code a chance to print something. If - it's completely taken care of things, don't bother printing - anything more ourselves. */ - if (lang_hooks.tree_dump.dump_tree (di, t)) - goto done; - - /* Now handle the various kinds of nodes. */ - switch (code) - { - int i; - - case IDENTIFIER_NODE: - dump_string_field (di, "strg", IDENTIFIER_POINTER (t)); - dump_int (di, "lngt", IDENTIFIER_LENGTH (t)); - break; - - case TREE_LIST: - dump_child ("purp", TREE_PURPOSE (t)); - dump_child ("valu", TREE_VALUE (t)); - dump_child ("chan", TREE_CHAIN (t)); - break; - - case STATEMENT_LIST: - { - tree_stmt_iterator it; - for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++) - { - char buffer[32]; - sprintf (buffer, "%u", i); - dump_child (buffer, tsi_stmt (it)); - } - } - break; - - case TREE_VEC: - dump_int (di, "lngt", TREE_VEC_LENGTH (t)); - for (i = 0; i < TREE_VEC_LENGTH (t); ++i) - { - char buffer[32]; - sprintf (buffer, "%u", i); - dump_child (buffer, TREE_VEC_ELT (t, i)); - } - break; - - case INTEGER_TYPE: - case ENUMERAL_TYPE: - dump_int (di, "prec", TYPE_PRECISION (t)); - dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); - dump_child ("min", TYPE_MIN_VALUE (t)); - dump_child ("max", TYPE_MAX_VALUE (t)); - - if (code == ENUMERAL_TYPE) - dump_child ("csts", TYPE_VALUES (t)); - break; - - case REAL_TYPE: - dump_int (di, "prec", TYPE_PRECISION (t)); - break; - - case FIXED_POINT_TYPE: - dump_int (di, "prec", TYPE_PRECISION (t)); - dump_string_field (di, "sign", TYPE_UNSIGNED (t) ? "unsigned": "signed"); - dump_string_field (di, "saturating", - TYPE_SATURATING (t) ? "saturating": "non-saturating"); - break; - - case POINTER_TYPE: - dump_child ("ptd", TREE_TYPE (t)); - break; - - case REFERENCE_TYPE: - dump_child ("refd", TREE_TYPE (t)); - break; - - case METHOD_TYPE: - dump_child ("clas", TYPE_METHOD_BASETYPE (t)); - /* Fall through. */ - - case FUNCTION_TYPE: - dump_child ("retn", TREE_TYPE (t)); - dump_child ("prms", TYPE_ARG_TYPES (t)); - break; - - case ARRAY_TYPE: - dump_child ("elts", TREE_TYPE (t)); - dump_child ("domn", TYPE_DOMAIN (t)); - break; - - case RECORD_TYPE: - case UNION_TYPE: - if (TREE_CODE (t) == RECORD_TYPE) - dump_string_field (di, "tag", "struct"); - else - dump_string_field (di, "tag", "union"); - - dump_child ("flds", TYPE_FIELDS (t)); - dump_child ("fncs", TYPE_METHODS (t)); - queue_and_dump_index (di, "binf", TYPE_BINFO (t), - DUMP_BINFO); - break; - - case CONST_DECL: - dump_child ("cnst", DECL_INITIAL (t)); - break; - - case DEBUG_EXPR_DECL: - dump_int (di, "-uid", DEBUG_TEMP_UID (t)); - /* Fall through. */ - - case VAR_DECL: - case PARM_DECL: - case FIELD_DECL: - case RESULT_DECL: - if (TREE_CODE (t) == PARM_DECL) - dump_child ("argt", DECL_ARG_TYPE (t)); - else - dump_child ("init", DECL_INITIAL (t)); - dump_child ("size", DECL_SIZE (t)); - dump_int (di, "algn", DECL_ALIGN (t)); - - if (TREE_CODE (t) == FIELD_DECL) - { - if (DECL_FIELD_OFFSET (t)) - dump_child ("bpos", bit_position (t)); - } - else if (VAR_P (t) || TREE_CODE (t) == PARM_DECL) - { - dump_int (di, "used", TREE_USED (t)); - if (DECL_REGISTER (t)) - dump_string_field (di, "spec", "register"); - } - break; - - case FUNCTION_DECL: - dump_child ("args", DECL_ARGUMENTS (t)); - if (DECL_EXTERNAL (t)) - dump_string_field (di, "body", "undefined"); - if (TREE_PUBLIC (t)) - dump_string_field (di, "link", "extern"); - else - dump_string_field (di, "link", "static"); - if (DECL_SAVED_TREE (t) && !dump_flag (di, TDF_SLIM, t)) - dump_child ("body", DECL_SAVED_TREE (t)); - break; - - case INTEGER_CST: - fprintf (di->stream, "int: "); - print_decs (t, di->stream); - break; - - case STRING_CST: - fprintf (di->stream, "strg: %-7s ", TREE_STRING_POINTER (t)); - dump_int (di, "lngt", TREE_STRING_LENGTH (t)); - break; - - case REAL_CST: - dump_real (di, "valu", TREE_REAL_CST_PTR (t)); - break; - - case FIXED_CST: - dump_fixed (di, "valu", TREE_FIXED_CST_PTR (t)); - break; - - case TRUTH_NOT_EXPR: - case ADDR_EXPR: - case INDIRECT_REF: - case CLEANUP_POINT_EXPR: - case SAVE_EXPR: - case REALPART_EXPR: - case IMAGPART_EXPR: - /* These nodes are unary, but do not have code class `1'. */ - dump_child ("op 0", TREE_OPERAND (t, 0)); - break; - - case TRUTH_ANDIF_EXPR: - case TRUTH_ORIF_EXPR: - case INIT_EXPR: - case MODIFY_EXPR: - case COMPOUND_EXPR: - case PREDECREMENT_EXPR: - case PREINCREMENT_EXPR: - case POSTDECREMENT_EXPR: - case POSTINCREMENT_EXPR: - /* These nodes are binary, but do not have code class `2'. */ - dump_child ("op 0", TREE_OPERAND (t, 0)); - dump_child ("op 1", TREE_OPERAND (t, 1)); - break; - - case COMPONENT_REF: - case BIT_FIELD_REF: - dump_child ("op 0", TREE_OPERAND (t, 0)); - dump_child ("op 1", TREE_OPERAND (t, 1)); - dump_child ("op 2", TREE_OPERAND (t, 2)); - break; - - case ARRAY_REF: - case ARRAY_RANGE_REF: - dump_child ("op 0", TREE_OPERAND (t, 0)); - dump_child ("op 1", TREE_OPERAND (t, 1)); - dump_child ("op 2", TREE_OPERAND (t, 2)); - dump_child ("op 3", TREE_OPERAND (t, 3)); - break; - - case COND_EXPR: - dump_child ("op 0", TREE_OPERAND (t, 0)); - dump_child ("op 1", TREE_OPERAND (t, 1)); - dump_child ("op 2", TREE_OPERAND (t, 2)); - break; - - case TRY_FINALLY_EXPR: - dump_child ("op 0", TREE_OPERAND (t, 0)); - dump_child ("op 1", TREE_OPERAND (t, 1)); - break; - - case CALL_EXPR: - { - int i = 0; - tree arg; - call_expr_arg_iterator iter; - dump_child ("fn", CALL_EXPR_FN (t)); - FOR_EACH_CALL_EXPR_ARG (arg, iter, t) - { - char buffer[32]; - sprintf (buffer, "%u", i); - dump_child (buffer, arg); - i++; - } - } - break; - - case CONSTRUCTOR: - { - unsigned HOST_WIDE_INT cnt; - tree index, value; - dump_int (di, "lngt", CONSTRUCTOR_NELTS (t)); - FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), cnt, index, value) - { - dump_child ("idx", index); - dump_child ("val", value); - } - } - break; - - case BIND_EXPR: - dump_child ("vars", TREE_OPERAND (t, 0)); - dump_child ("body", TREE_OPERAND (t, 1)); - break; - - case LOOP_EXPR: - dump_child ("body", TREE_OPERAND (t, 0)); - break; - - case EXIT_EXPR: - dump_child ("cond", TREE_OPERAND (t, 0)); - break; - - case RETURN_EXPR: - dump_child ("expr", TREE_OPERAND (t, 0)); - break; - - case TARGET_EXPR: - dump_child ("decl", TREE_OPERAND (t, 0)); - dump_child ("init", TREE_OPERAND (t, 1)); - dump_child ("clnp", TREE_OPERAND (t, 2)); - /* There really are two possible places the initializer can be. - After RTL expansion, the second operand is moved to the - position of the fourth operand, and the second operand - becomes NULL. */ - dump_child ("init", TREE_OPERAND (t, 3)); - break; - - case CASE_LABEL_EXPR: - dump_child ("name", CASE_LABEL (t)); - if (CASE_LOW (t)) - { - dump_child ("low ", CASE_LOW (t)); - if (CASE_HIGH (t)) - dump_child ("high", CASE_HIGH (t)); - } - break; - case LABEL_EXPR: - dump_child ("name", TREE_OPERAND (t,0)); - break; - case GOTO_EXPR: - dump_child ("labl", TREE_OPERAND (t, 0)); - break; - case SWITCH_EXPR: - dump_child ("cond", TREE_OPERAND (t, 0)); - dump_child ("body", TREE_OPERAND (t, 1)); - if (TREE_OPERAND (t, 2)) - { - dump_child ("labl", TREE_OPERAND (t,2)); - } - break; - case OMP_CLAUSE: - { - int i; - fprintf (di->stream, "%s\n", omp_clause_code_name[OMP_CLAUSE_CODE (t)]); - for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++) - dump_child ("op: ", OMP_CLAUSE_OPERAND (t, i)); - } - break; - default: - /* There are no additional fields to print. */ - break; - } - - done: - if (dump_flag (di, TDF_ADDRESS, NULL)) - dump_pointer (di, "addr", (void *)t); - - /* Terminate the line. */ - fprintf (di->stream, "\n"); -} - -/* Return nonzero if FLAG has been specified for the dump, and NODE - is not the root node of the dump. */ - -int dump_flag (dump_info_p di, int flag, const_tree node) -{ - return (di->flags & flag) && (node != di->node); -} - -/* Dump T, and all its children, on STREAM. */ - -void -dump_node (const_tree t, int flags, FILE *stream) -{ - struct dump_info di; - dump_queue_p dq; - dump_queue_p next_dq; - - /* Initialize the dump-information structure. */ - di.stream = stream; - di.index = 0; - di.column = 0; - di.queue = 0; - di.queue_end = 0; - di.free_list = 0; - di.flags = flags; - di.node = t; - di.nodes = splay_tree_new (splay_tree_compare_pointers, 0, - (splay_tree_delete_value_fn) &free); - - /* Queue up the first node. */ - queue (&di, t, DUMP_NONE); - - /* Until the queue is empty, keep dumping nodes. */ - while (di.queue) - dequeue_and_dump (&di); - - /* Now, clean up. */ - for (dq = di.free_list; dq; dq = next_dq) - { - next_dq = dq->next; - free (dq); - } - splay_tree_delete (di.nodes); -} Index: tree-dump.h =================================================================== --- tree-dump.h (revision 247784) +++ tree-dump.h (working copy) @@ -1,93 +0,0 @@ -/* Tree-dumping functionality for intermediate representation. - Copyright (C) 1999-2017 Free Software Foundation, Inc. - Written by Mark Mitchell - -This file is part of GCC. - -GCC is free software; you can redistribute it and/or modify it under -the terms of the GNU General Public License as published by the Free -Software Foundation; either version 3, or (at your option) any later -version. - -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or -FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -for more details. - -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING3. If not see -. */ - -#ifndef GCC_TREE_DUMP_H -#define GCC_TREE_DUMP_H - -#include "splay-tree.h" -#include "dumpfile.h" - -typedef struct dump_info *dump_info_p; - -/* Flags used with queue functions. */ -#define DUMP_NONE 0 -#define DUMP_BINFO 1 - -/* Information about a node to be dumped. */ - -typedef struct dump_node_info -{ - /* The index for the node. */ - unsigned int index; - /* Nonzero if the node is a binfo. */ - unsigned int binfo_p : 1; -} *dump_node_info_p; - -/* A dump_queue is a link in the queue of things to be dumped. */ - -typedef struct dump_queue -{ - /* The queued tree node. */ - splay_tree_node node; - /* The next node in the queue. */ - struct dump_queue *next; -} *dump_queue_p; - -/* A dump_info gives information about how we should perform the dump - and about the current state of the dump. */ - -struct dump_info -{ - /* The stream on which to dump the information. */ - FILE *stream; - /* The original node. */ - const_tree node; - /* User flags. */ - int flags; - /* The next unused node index. */ - unsigned int index; - /* The next column. */ - unsigned int column; - /* The first node in the queue of nodes to be written out. */ - dump_queue_p queue; - /* The last node in the queue. */ - dump_queue_p queue_end; - /* Free queue nodes. */ - dump_queue_p free_list; - /* The tree nodes which we have already written out. The - keys are the addresses of the nodes; the values are the integer - indices we assigned them. */ - splay_tree nodes; -}; - -/* Dump the CHILD and its children. */ -#define dump_child(field, child) \ - queue_and_dump_index (di, field, child, DUMP_NONE) - -extern void dump_pointer (dump_info_p, const char *, void *); -extern void dump_int (dump_info_p, const char *, int); -extern void dump_string (dump_info_p, const char *); -extern void dump_string_field (dump_info_p, const char *, const char *); -extern void queue_and_dump_index (dump_info_p, const char *, const_tree, int); -extern void queue_and_dump_type (dump_info_p, const_tree); -extern void dump_function (int, tree); -extern int dump_flag (dump_info_p, int, const_tree); - -#endif /* ! GCC_TREE_DUMP_H */ Index: tree-nested.c =================================================================== --- tree-nested.c (revision 247784) +++ tree-nested.c (working copy) @@ -31,7 +31,7 @@ #include "cgraph.h" #include "fold-const.h" #include "stor-layout.h" -#include "tree-dump.h" +#include "dumpfile.h" #include "tree-inline.h" #include "gimplify.h" #include "gimple-iterator.h" --------------412E7511DE24C30FAC214E28--