Line data    Source code

       1             : /* Prints out trees in human readable form.
       2             :    Copyright (C) 1992-2023 Free Software Foundation, Inc.
       3             :    Hacked by Michael Tiemann (tiemann@cygnus.com)
       4             : 
       5             : This file is part of GCC.
       6             : 
       7             : GCC is free software; you can redistribute it and/or modify
       8             : it under the terms of the GNU General Public License as published by
       9             : the Free Software Foundation; either version 3, or (at your option)
      10             : any later version.
      11             : 
      12             : GCC is distributed in the hope that it will be useful,
      13             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      15             : GNU General Public License for more details.
      16             : 
      17             : You should have received a copy of the GNU General Public License
      18             : along with GCC; see the file COPYING3.  If not see
      19             : <http://www.gnu.org/licenses/>.  */
      20             : 
      21             : 
      22             : #include "config.h"
      23             : #include "system.h"
      24             : #include "coretypes.h"
      25             : #include "cp-tree.h"
      26             : #include "print-tree.h"
      27             : 
      28             : void
      29           0 : cxx_print_decl (FILE *file, tree node, int indent)
      30             : {
      31           0 :   if (TREE_CODE (node) == FIELD_DECL)
      32             :     {
      33           0 :       if (DECL_MUTABLE_P (node))
      34             :         {
      35           0 :           indent_to (file, indent + 3);
      36           0 :           fprintf (file, " mutable ");
      37             :         }
      38           0 :       return;
      39             :     }
      40             : 
      41           0 :   if (!CODE_CONTAINS_STRUCT (TREE_CODE (node), TS_DECL_COMMON)
      42           0 :       || !DECL_LANG_SPECIFIC (node))
      43             :     return;
      44             : 
      45           0 :   if (TREE_CODE (node) == FUNCTION_DECL)
      46             :     {
      47           0 :       int flags = TFF_DECL_SPECIFIERS|TFF_RETURN_TYPE
      48             :         |TFF_FUNCTION_DEFAULT_ARGUMENTS|TFF_EXCEPTION_SPECIFICATION ;
      49           0 :       indent_to (file, indent + 3);
      50           0 :       fprintf (file, " full-name \"%s\"", decl_as_string (node, flags));
      51             :     }
      52           0 :   else if (TREE_CODE (node) == TEMPLATE_DECL)
      53             :     {
      54           0 :       print_node (file, "result", DECL_TEMPLATE_RESULT (node), indent + 4);
      55           0 :       print_node (file, "parms", DECL_TEMPLATE_PARMS (node), indent + 4);
      56           0 :       indent_to (file, indent + 3);
      57           0 :       fprintf (file, " full-name \"%s\"",
      58             :                decl_as_string (node, TFF_TEMPLATE_HEADER));
      59             :     }
      60             : 
      61           0 :   bool need_indent = true;
      62             : 
      63           0 :   tree ntnode = STRIP_TEMPLATE (node);
      64           0 :   if (TREE_CODE (ntnode) == FUNCTION_DECL
      65             :       || TREE_CODE (ntnode) == VAR_DECL
      66             :       || TREE_CODE (ntnode) == TYPE_DECL
      67             :       || TREE_CODE (ntnode) == CONCEPT_DECL
      68             :       || TREE_CODE (ntnode) == NAMESPACE_DECL)
      69             :     {
      70           0 :       unsigned m = 0;
      71           0 :       if (DECL_LANG_SPECIFIC (ntnode) && DECL_MODULE_IMPORT_P (ntnode))
      72           0 :         m = get_importing_module (ntnode, true);
      73             : 
      74           0 :       if (const char *name = m == ~0u ? "" : module_name (m, true))
      75             :         {
      76           0 :           if (need_indent)
      77           0 :             indent_to (file, indent + 3);
      78           0 :           fprintf (file, " module %d:%s", m, name);
      79           0 :           need_indent = false;
      80             :         }
      81             : 
      82           0 :       if (DECL_LANG_SPECIFIC (ntnode))
      83             :         {
      84           0 :           if (DECL_MODULE_PURVIEW_P (ntnode))
      85             :             {
      86           0 :               if (need_indent)
      87           0 :                 indent_to (file, indent + 3);
      88           0 :               fprintf (file, " purview");
      89           0 :               need_indent = false;
      90             :             }
      91           0 :           if (DECL_MODULE_ATTACH_P (ntnode))
      92             :             {
      93           0 :               if (need_indent)
      94           0 :                 indent_to (file, indent + 3);
      95           0 :               fprintf (file, " attached");
      96           0 :               need_indent = false;
      97             :             }
      98             :         }
      99             :     }
     100             : 
     101           0 :   if (DECL_MODULE_EXPORT_P (node))
     102             :     {
     103           0 :       if (need_indent)
     104           0 :         indent_to (file, indent + 3);
     105           0 :       fprintf (file, " exported");
     106           0 :       need_indent = false;
     107             :     }
     108             : 
     109           0 :   if (DECL_EXTERNAL (node) && DECL_NOT_REALLY_EXTERN (node))
     110             :     {
     111           0 :       if (need_indent)
     112           0 :         indent_to (file, indent + 3);
     113           0 :       fprintf (file, " not-really-extern");
     114           0 :       need_indent = false;
     115             :     }
     116             : 
     117           0 :   if (TREE_CODE (node) == FUNCTION_DECL
     118           0 :       && DECL_PENDING_INLINE_INFO (node))
     119             :     {
     120           0 :       if (need_indent)
     121           0 :         indent_to (file, indent + 3);
     122           0 :       fprintf (file, " pending-inline-info %p",
     123           0 :                (void *) DECL_PENDING_INLINE_INFO (node));
     124           0 :       need_indent = false;
     125             :     }
     126             :   
     127           0 :   if (VAR_OR_FUNCTION_DECL_P (node)
     128           0 :       && DECL_TEMPLATE_INFO (node))
     129           0 :     print_node (file, "template-info", DECL_TEMPLATE_INFO (node),
     130             :                 indent + 4);
     131             : }
     132             : 
     133             : void
     134           0 : cxx_print_type (FILE *file, tree node, int indent)
     135             : {
     136           0 :   switch (TREE_CODE (node))
     137             :     {
     138           0 :     case BOUND_TEMPLATE_TEMPLATE_PARM:
     139           0 :       print_node (file, "args", TYPE_TI_ARGS (node), indent + 4);
     140           0 :       gcc_fallthrough ();
     141             : 
     142           0 :     case TEMPLATE_TYPE_PARM:
     143           0 :     case TEMPLATE_TEMPLATE_PARM:
     144           0 :       indent_to (file, indent + 3);
     145           0 :       fprintf (file, "index %d level %d orig_level %d",
     146           0 :                TEMPLATE_TYPE_IDX (node), TEMPLATE_TYPE_LEVEL (node),
     147           0 :                TEMPLATE_TYPE_ORIG_LEVEL (node));
     148           0 :       return;
     149             : 
     150           0 :     case FUNCTION_TYPE:
     151           0 :     case METHOD_TYPE:
     152           0 :       if (TYPE_RAISES_EXCEPTIONS (node))
     153           0 :         print_node (file, "throws", TYPE_RAISES_EXCEPTIONS (node), indent + 4);
     154             :       return;
     155             : 
     156           0 :     case RECORD_TYPE:
     157           0 :     case UNION_TYPE:
     158           0 :       break;
     159             : 
     160           0 :     case DECLTYPE_TYPE:
     161           0 :       print_node (file, "expr", DECLTYPE_TYPE_EXPR (node), indent + 4);
     162           0 :       return;
     163             : 
     164           0 :     case DEPENDENT_OPERATOR_TYPE:
     165           0 :       print_node (file, "saved_lookups",
     166           0 :                   DEPENDENT_OPERATOR_TYPE_SAVED_LOOKUPS (node),
     167             :                   indent + 4);
     168           0 :       return;
     169             : 
     170           0 :     case TYPENAME_TYPE:
     171           0 :       print_node (file, "fullname", TYPENAME_TYPE_FULLNAME (node),
     172             :                   indent + 4);
     173           0 :       return;
     174             : 
     175           0 :     case TYPEOF_TYPE:
     176           0 :       print_node (file, "expr", TYPEOF_TYPE_EXPR (node), indent + 4);
     177           0 :       return;
     178             : 
     179           0 :     case BASES:
     180           0 :       if (BASES_DIRECT (node))
     181           0 :         fputs (" direct", file);
     182           0 :       print_node (file, "type", BASES_TYPE (node), indent + 4);
     183           0 :       return;
     184             : 
     185           0 :     case TYPE_PACK_EXPANSION:
     186           0 :       print_node (file, "pattern", PACK_EXPANSION_PATTERN (node), indent + 4);
     187           0 :       print_node (file, "args", PACK_EXPANSION_EXTRA_ARGS (node), indent + 4);
     188           0 :       return;
     189             : 
     190             :     default:
     191             :       return;
     192             :     }
     193             : 
     194           0 :   if (TYPE_PTRMEMFUNC_P (node))
     195           0 :     print_node (file, "ptrmemfunc fn type", TYPE_PTRMEMFUNC_FN_TYPE (node),
     196             :                 indent + 4);
     197             : 
     198           0 :   if (! CLASS_TYPE_P (node))
     199             :     return;
     200             : 
     201           0 :   indent_to (file, indent + 4);
     202           0 :   fprintf (file, "full-name \"%s\"",
     203             :            type_as_string (node, TFF_CLASS_KEY_OR_ENUM));
     204             : 
     205           0 :   indent_to (file, indent + 3);
     206             : 
     207           0 :   if (TYPE_NEEDS_CONSTRUCTING (node))
     208           0 :     fputs ( " needs-constructor", file);
     209           0 :   if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (node))
     210           0 :     fputs (" needs-destructor", file);
     211           0 :   if (TYPE_HAS_DEFAULT_CONSTRUCTOR (node))
     212           0 :     fputs (" X()", file);
     213           0 :   if (TYPE_HAS_CONVERSION (node))
     214           0 :     fputs (" has-type-conversion", file);
     215           0 :   if (TYPE_HAS_COPY_CTOR (node))
     216             :     {
     217           0 :       if (TYPE_HAS_CONST_COPY_CTOR (node))
     218           0 :         fputs (" X(constX&)", file);
     219             :       else
     220           0 :         fputs (" X(X&)", file);
     221             :     }
     222           0 :   if (TYPE_HAS_NEW_OPERATOR (node))
     223           0 :     fputs (" new", file);
     224           0 :   if (TYPE_HAS_ARRAY_NEW_OPERATOR (node))
     225           0 :     fputs (" new[]", file);
     226           0 :   if (TYPE_GETS_DELETE (node) & 1)
     227           0 :     fputs (" delete", file);
     228           0 :   if (TYPE_GETS_DELETE (node) & 2)
     229           0 :     fputs (" delete[]", file);
     230           0 :   if (TYPE_HAS_COPY_ASSIGN (node))
     231           0 :     fputs (" this=(X&)", file);
     232             : 
     233           0 :   if (TREE_CODE (node) == RECORD_TYPE)
     234             :     {
     235           0 :       if (TYPE_BINFO (node))
     236           0 :         fprintf (file, " n_parents=%d",
     237           0 :                  BINFO_N_BASE_BINFOS (TYPE_BINFO (node)));
     238             :       else
     239           0 :         fprintf (file, " no-binfo");
     240             : 
     241           0 :       fprintf (file, " use_template=%d", CLASSTYPE_USE_TEMPLATE (node));
     242           0 :       if (CLASSTYPE_INTERFACE_ONLY (node))
     243           0 :         fprintf (file, " interface-only");
     244           0 :       if (CLASSTYPE_INTERFACE_UNKNOWN (node))
     245           0 :         fprintf (file, " interface-unknown");
     246             :     }
     247             : }
     248             : 
     249             : void
     250           0 : cxx_print_identifier (FILE *file, tree node, int indent)
     251             : {
     252           0 :   if (indent == 0)
     253           0 :     fprintf (file, " ");
     254             :   else
     255           0 :     indent_to (file, indent + 4);
     256           0 :   fprintf (file, "%s local bindings <%p>", get_identifier_kind_name (node),
     257           0 :            (void *) IDENTIFIER_BINDING (node));
     258           0 : }
     259             : 
     260             : void
     261           0 : cxx_print_lambda_node (FILE *file, tree node, int indent)
     262             : {
     263           0 :   if (LAMBDA_EXPR_MUTABLE_P (node))
     264           0 :     fprintf (file, " /mutable");
     265           0 :   fprintf (file, " default_capture_mode=[");
     266           0 :   switch (LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (node))
     267             :     {
     268           0 :     case CPLD_NONE:
     269           0 :       fprintf (file, "NONE");
     270           0 :       break;
     271           0 :     case CPLD_COPY:
     272           0 :       fprintf (file, "COPY");
     273           0 :       break;
     274           0 :     case CPLD_REFERENCE:
     275           0 :       fprintf (file, "CPLD_REFERENCE");
     276           0 :       break;
     277           0 :     default:
     278           0 :       fprintf (file, "??");
     279           0 :       break;
     280             :     }
     281           0 :   fprintf (file, "] ");
     282           0 :   print_node (file, "capture_list", LAMBDA_EXPR_CAPTURE_LIST (node), indent + 4);
     283           0 :   print_node (file, "this_capture", LAMBDA_EXPR_THIS_CAPTURE (node), indent + 4);
     284           0 : }
     285             : 
     286             : void
     287           0 : cxx_print_xnode (FILE *file, tree node, int indent)
     288             : {
     289           0 :   switch (TREE_CODE (node))
     290             :     {
     291           0 :     case BASELINK:
     292           0 :       print_node (file, "functions", BASELINK_FUNCTIONS (node), indent + 4);
     293           0 :       print_node (file, "binfo", BASELINK_BINFO (node), indent + 4);
     294           0 :       print_node (file, "access_binfo", BASELINK_ACCESS_BINFO (node),
     295             :                   indent + 4);
     296           0 :       print_node (file, "optype", BASELINK_OPTYPE (node), indent + 4);
     297           0 :       break;
     298           0 :     case OVERLOAD:
     299           0 :       print_node (file, "function", OVL_FUNCTION (node), indent + 4);
     300           0 :       print_node (file, "next", OVL_CHAIN (node), indent + 4);
     301           0 :       break;
     302           0 :     case BINDING_VECTOR:
     303           0 :       {
     304           0 :         unsigned len = BINDING_VECTOR_NUM_CLUSTERS (node);
     305           0 :         print_node (file, "name", BINDING_VECTOR_NAME (node), indent + 4);
     306           0 :         fprintf (file, " clusters %u, alloc %u", len,
     307           0 :                  BINDING_VECTOR_ALLOC_CLUSTERS (node));
     308           0 :         for (unsigned ix = 0; ix != len; ix++)
     309             :           {
     310           0 :             binding_cluster *cluster = &BINDING_VECTOR_CLUSTER (node, ix);
     311             :             char pfx[32];
     312           0 :             for (unsigned jx = 0; jx != BINDING_VECTOR_SLOTS_PER_CLUSTER; jx++)
     313           0 :               if (cluster->indices[jx].span)
     314             :                 {
     315           0 :                   int len = sprintf (pfx, "module:%u",
     316           0 :                                      cluster->indices[jx].base);
     317           0 :                   if (cluster->indices[jx].span > 1)
     318           0 :                     len += sprintf (&pfx[len], "(+%u)",
     319             :                                     cluster->indices[jx].span);
     320           0 :                   len += sprintf (&pfx[len], " cluster:%u/%u", ix, jx);
     321           0 :                   binding_slot &slot = cluster->slots[jx];
     322           0 :                   if (slot.is_lazy ())
     323             :                     {
     324           0 :                       indent_to (file, indent + 4);
     325           0 :                       unsigned lazy = slot.get_lazy ();
     326           0 :                       fprintf (file, "%s snum:%u", pfx, lazy);
     327             :                     }
     328           0 :                   else if (slot)
     329           0 :                     print_node (file, pfx, slot, indent + 4);
     330             :                   else
     331             :                     {
     332           0 :                       indent_to (file, indent + 4);
     333           0 :                       fprintf (file, "%s NULL", pfx);
     334             :                     }
     335             :                 }
     336             :           }
     337             :       }
     338             :       break;
     339           0 :     case TEMPLATE_PARM_INDEX:
     340           0 :       print_node (file, "decl", TEMPLATE_PARM_DECL (node), indent+4);
     341           0 :       indent_to (file, indent + 3);
     342           0 :       fprintf (file, "index %d level %d orig_level %d",
     343           0 :                TEMPLATE_PARM_IDX (node), TEMPLATE_PARM_LEVEL (node),
     344           0 :                TEMPLATE_PARM_ORIG_LEVEL (node));
     345           0 :       break;
     346           0 :     case TEMPLATE_INFO:
     347           0 :       print_node (file, "template", TI_TEMPLATE (node), indent+4);
     348           0 :       print_node (file, "args", TI_ARGS (node), indent+4);
     349           0 :       if (TI_TEMPLATE (node)
     350           0 :           && PRIMARY_TEMPLATE_P (TI_TEMPLATE (node)))
     351           0 :         print_node (file, "partial", TI_PARTIAL_INFO (node), indent+4);
     352           0 :       if (TI_PENDING_TEMPLATE_FLAG (node))
     353             :         {
     354           0 :           indent_to (file, indent + 3);
     355           0 :           fprintf (file, "pending_template");
     356             :         }
     357             :       break;
     358           0 :     case CONSTRAINT_INFO:
     359           0 :       {
     360           0 :         tree_constraint_info *cinfo = (tree_constraint_info *)node;
     361           0 :         if (cinfo->template_reqs)
     362           0 :           print_node (file, "template_reqs", cinfo->template_reqs, indent+4);
     363           0 :         if (cinfo->declarator_reqs)
     364           0 :           print_node (file, "declarator_reqs", cinfo->declarator_reqs,
     365             :                       indent+4);
     366           0 :         print_node (file, "associated_constr",
     367             :                           cinfo->associated_constr, indent+4);
     368           0 :         break;
     369             :       }
     370           0 :     case ARGUMENT_PACK_SELECT:
     371           0 :       print_node (file, "pack", ARGUMENT_PACK_SELECT_FROM_PACK (node),
     372             :                   indent+4);
     373           0 :       indent_to (file, indent + 3);
     374           0 :       fprintf (file, "index %d", ARGUMENT_PACK_SELECT_INDEX (node));
     375           0 :       break;
     376           0 :     case DEFERRED_NOEXCEPT:
     377           0 :       print_node (file, "pattern", DEFERRED_NOEXCEPT_PATTERN (node), indent+4);
     378           0 :       print_node (file, "args", DEFERRED_NOEXCEPT_ARGS (node), indent+4);
     379           0 :       break;
     380           0 :     case TRAIT_EXPR:
     381           0 :       indent_to (file, indent+4);
     382           0 :       fprintf (file, "kind %d", TRAIT_EXPR_KIND (node));
     383           0 :       print_node (file, "type 1", TRAIT_EXPR_TYPE1 (node), indent+4);
     384           0 :       if (TRAIT_EXPR_TYPE2 (node))
     385           0 :         print_node (file, "type 2", TRAIT_EXPR_TYPE2 (node), indent+4);
     386             :       break;
     387           0 :     case LAMBDA_EXPR:
     388           0 :       cxx_print_lambda_node (file, node, indent);
     389           0 :       break;
     390           0 :     case STATIC_ASSERT:
     391           0 :       if (location_t loc = STATIC_ASSERT_SOURCE_LOCATION (node))
     392             :         {
     393           0 :           expanded_location xloc = expand_location (loc);
     394           0 :           indent_to (file, indent+4);
     395           0 :           fprintf (file, "%s:%d:%d", xloc.file, xloc.line, xloc.column);
     396             :         }
     397           0 :       print_node (file, "condition", STATIC_ASSERT_CONDITION (node), indent+4);
     398           0 :       if (tree message = STATIC_ASSERT_MESSAGE (node))
     399           0 :         print_node (file, "message", message, indent+4);
     400             :       break;
     401           0 :     case PTRMEM_CST:
     402           0 :       print_node (file, "member", PTRMEM_CST_MEMBER (node), indent+4);
     403           0 :       break;
     404             :     default:
     405             :       break;
     406             :     }
     407           0 : }
     408             : 
     409             : /* Print the node NODE on standard error, for debugging.  */
     410             : 
     411             : DEBUG_FUNCTION void
     412           0 : debug_tree (cp_expr node)
     413             : {
     414           0 :   debug_tree (node.get_value());
     415           0 : }
     416             : 
     417             : DEBUG_FUNCTION void
     418           0 : debug_overload (tree node)
     419             : {
     420           0 :   FILE *file = stdout;
     421             : 
     422           0 :   for (lkp_iterator iter (node); iter; ++iter)
     423             :     {
     424           0 :       tree decl = *iter;
     425           0 :       auto xloc = expand_location (DECL_SOURCE_LOCATION (decl));
     426           0 :       auto fullname = decl_as_string (decl, 0);
     427           0 :       bool using_p = iter.using_p ();
     428           0 :       bool hidden_p = iter.hidden_p ();
     429             : 
     430           0 :       fprintf (file, "%p:%c%c %s:%d:%d \"%s\"\n", (void *)decl,
     431             :                hidden_p ? 'H' : '-',
     432             :                using_p ? 'U' : '-',
     433             :                xloc.file, xloc.line, xloc.column, fullname);
     434             :     }
     435           0 : }