Subversion Repositories openrisc

/* Pretty formatting of GENERIC trees in C syntax.

   Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,

   2011  Free Software Foundation, Inc.

   Adapted from c-pretty-print.c by Diego Novillo <dnovillo@redhat.com>

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

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "output.h"

#include "tree-pretty-print.h"

#include "hashtab.h"

#include "tree-flow.h"

#include "langhooks.h"

#include "tree-iterator.h"

#include "tree-chrec.h"

#include "tree-pass.h"

#include "value-prof.h"

#include "predict.h"

/* Local functions, macros and variables.  */

static const char *op_symbol (const_tree);

static void pretty_print_string (pretty_printer *, const char*);

static void newline_and_indent (pretty_printer *, int);

static void maybe_init_pretty_print (FILE *);

static void print_struct_decl (pretty_printer *, const_tree, int, int);

static void do_niy (pretty_printer *, const_tree);

#define INDENT(SPACE) do { \

  int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)

#define NIY do_niy(buffer,node)

static pretty_printer buffer;

static int initialized = 0;

/* Try to print something for an unknown tree code.  */

static void

do_niy (pretty_printer *buffer, const_tree node)

{

  int i, len;

  pp_string (buffer, "<<< Unknown tree: ");

  pp_string (buffer, tree_code_name[(int) TREE_CODE (node)]);

  if (EXPR_P (node))

    {

      len = TREE_OPERAND_LENGTH (node);

      for (i = 0; i < len; ++i)

        {

          newline_and_indent (buffer, 2);

          dump_generic_node (buffer, TREE_OPERAND (node, i), 2, 0, false);

        }

    }

  pp_string (buffer, " >>>");

}

/* Debugging function to print out a generic expression.  */

DEBUG_FUNCTION void

debug_generic_expr (tree t)

{

  print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS);

  fprintf (stderr, "\n");

}

/* Debugging function to print out a generic statement.  */

DEBUG_FUNCTION void

debug_generic_stmt (tree t)

{

  print_generic_stmt (stderr, t, TDF_VOPS|TDF_MEMSYMS);

  fprintf (stderr, "\n");

}

/* Debugging function to print out a chain of trees .  */

DEBUG_FUNCTION void

debug_tree_chain (tree t)

{

  struct pointer_set_t *seen = pointer_set_create ();

  while (t)

    {

      print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);

      fprintf (stderr, " ");

      t = TREE_CHAIN (t);

      if (pointer_set_insert (seen, t))

        {

          fprintf (stderr, "... [cycled back to ");

          print_generic_expr (stderr, t, TDF_VOPS|TDF_MEMSYMS|TDF_UID);

          fprintf (stderr, "]");

          break;

        }

    }

  fprintf (stderr, "\n");

  pointer_set_destroy (seen);

}

/* Prints declaration DECL to the FILE with details specified by FLAGS.  */

void

print_generic_decl (FILE *file, tree decl, int flags)

{

  maybe_init_pretty_print (file);

  print_declaration (&buffer, decl, 2, flags);

  pp_write_text_to_stream (&buffer);

}

/* Print tree T, and its successors, on file FILE.  FLAGS specifies details

   to show in the dump.  See TDF_* in tree-pass.h.  */

void

print_generic_stmt (FILE *file, tree t, int flags)

{

  maybe_init_pretty_print (file);

  dump_generic_node (&buffer, t, 0, flags, true);

  pp_flush (&buffer);

}

/* Print tree T, and its successors, on file FILE.  FLAGS specifies details

   to show in the dump.  See TDF_* in tree-pass.h.  The output is indented by

   INDENT spaces.  */

void

print_generic_stmt_indented (FILE *file, tree t, int flags, int indent)

{

  int i;

  maybe_init_pretty_print (file);

  for (i = 0; i < indent; i++)

    pp_space (&buffer);

  dump_generic_node (&buffer, t, indent, flags, true);

  pp_flush (&buffer);

}

/* Print a single expression T on file FILE.  FLAGS specifies details to show

   in the dump.  See TDF_* in tree-pass.h.  */

void

print_generic_expr (FILE *file, tree t, int flags)

{

  maybe_init_pretty_print (file);

  dump_generic_node (&buffer, t, 0, flags, false);

}

/* Dump the name of a _DECL node and its DECL_UID if TDF_UID is set

   in FLAGS.  */

static void

dump_decl_name (pretty_printer *buffer, tree node, int flags)

{

  if (DECL_NAME (node))

    {

      if ((flags & TDF_ASMNAME) && DECL_ASSEMBLER_NAME_SET_P (node))

        pp_tree_identifier (buffer, DECL_ASSEMBLER_NAME (node));

      else

        pp_tree_identifier (buffer, DECL_NAME (node));

    }

  if ((flags & TDF_UID) || DECL_NAME (node) == NULL_TREE)

    {

      if (TREE_CODE (node) == LABEL_DECL && LABEL_DECL_UID (node) != -1)

        pp_printf (buffer, "L.%d", (int) LABEL_DECL_UID (node));

      else if (TREE_CODE (node) == DEBUG_EXPR_DECL)

        {

          if (flags & TDF_NOUID)

            pp_string (buffer, "D#xxxx");

          else

            pp_printf (buffer, "D#%i", DEBUG_TEMP_UID (node));

        }

      else

        {

          char c = TREE_CODE (node) == CONST_DECL ? 'C' : 'D';

          if (flags & TDF_NOUID)

            pp_printf (buffer, "%c.xxxx", c);

          else

            pp_printf (buffer, "%c.%u", c, DECL_UID (node));

        }

    }

  if ((flags & TDF_ALIAS) && DECL_PT_UID (node) != DECL_UID (node))

    {

      if (flags & TDF_NOUID)

        pp_printf (buffer, "ptD.xxxx");

      else

        pp_printf (buffer, "ptD.%u", DECL_PT_UID (node));

    }

}

/* Like the above, but used for pretty printing function calls.  */

static void

dump_function_name (pretty_printer *buffer, tree node, int flags)

{

  if (TREE_CODE (node) == NOP_EXPR)

    node = TREE_OPERAND (node, 0);

  if (DECL_NAME (node) && (flags & TDF_ASMNAME) == 0)

    pp_string (buffer, lang_hooks.decl_printable_name (node, 1));

  else

    dump_decl_name (buffer, node, flags);

}

/* Dump a function declaration.  NODE is the FUNCTION_TYPE.  BUFFER, SPC and

   FLAGS are as in dump_generic_node.  */

static void

dump_function_declaration (pretty_printer *buffer, tree node,

                           int spc, int flags)

{

  bool wrote_arg = false;

  tree arg;

  pp_space (buffer);

  pp_character (buffer, '(');

  /* Print the argument types.  */

  arg = TYPE_ARG_TYPES (node);

  while (arg && arg != void_list_node && arg != error_mark_node)

    {

      if (wrote_arg)

        {

          pp_character (buffer, ',');

          pp_space (buffer);

        }

      wrote_arg = true;

      dump_generic_node (buffer, TREE_VALUE (arg), spc, flags, false);

      arg = TREE_CHAIN (arg);

    }

  /* Drop the trailing void_type_node if we had any previous argument.  */

  if (arg == void_list_node && !wrote_arg)

    pp_string (buffer, "void");

  /* Properly dump vararg function types.  */

  else if (!arg && wrote_arg)

    pp_string (buffer, ", ...");

  /* Avoid printing any arg for unprototyped functions.  */

  pp_character (buffer, ')');

}

/* Dump the domain associated with an array.  */

static void

dump_array_domain (pretty_printer *buffer, tree domain, int spc, int flags)

{

  pp_character (buffer, '[');

  if (domain)

    {

      tree min = TYPE_MIN_VALUE (domain);

      tree max = TYPE_MAX_VALUE (domain);

      if (min && max

          && integer_zerop (min)

          && host_integerp (max, 0))

        pp_wide_integer (buffer, TREE_INT_CST_LOW (max) + 1);

      else

        {

          if (min)

            dump_generic_node (buffer, min, spc, flags, false);

          pp_character (buffer, ':');

          if (max)

            dump_generic_node (buffer, max, spc, flags, false);

        }

    }

  else

    pp_string (buffer, "<unknown>");

  pp_character (buffer, ']');

}

/* Dump OpenMP clause CLAUSE.  BUFFER, CLAUSE, SPC and FLAGS are as in

   dump_generic_node.  */

static void

dump_omp_clause (pretty_printer *buffer, tree clause, int spc, int flags)

{

  const char *name;

  switch (OMP_CLAUSE_CODE (clause))

    {

    case OMP_CLAUSE_PRIVATE:

      name = "private";

      goto print_remap;

    case OMP_CLAUSE_SHARED:

      name = "shared";

      goto print_remap;

    case OMP_CLAUSE_FIRSTPRIVATE:

      name = "firstprivate";

      goto print_remap;

    case OMP_CLAUSE_LASTPRIVATE:

      name = "lastprivate";

      goto print_remap;

    case OMP_CLAUSE_COPYIN:

      name = "copyin";

      goto print_remap;

    case OMP_CLAUSE_COPYPRIVATE:

      name = "copyprivate";

      goto print_remap;

  print_remap:

      pp_string (buffer, name);

      pp_character (buffer, '(');

      dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),

          spc, flags, false);

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_REDUCTION:

      pp_string (buffer, "reduction(");

      pp_string (buffer, op_symbol_code (OMP_CLAUSE_REDUCTION_CODE (clause)));

      pp_character (buffer, ':');

      dump_generic_node (buffer, OMP_CLAUSE_DECL (clause),

          spc, flags, false);

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_IF:

      pp_string (buffer, "if(");

      dump_generic_node (buffer, OMP_CLAUSE_IF_EXPR (clause),

          spc, flags, false);

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_NUM_THREADS:

      pp_string (buffer, "num_threads(");

      dump_generic_node (buffer, OMP_CLAUSE_NUM_THREADS_EXPR (clause),

          spc, flags, false);

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_NOWAIT:

      pp_string (buffer, "nowait");

      break;

    case OMP_CLAUSE_ORDERED:

      pp_string (buffer, "ordered");

      break;

    case OMP_CLAUSE_DEFAULT:

      pp_string (buffer, "default(");

      switch (OMP_CLAUSE_DEFAULT_KIND (clause))

        {

        case OMP_CLAUSE_DEFAULT_UNSPECIFIED:

          break;

        case OMP_CLAUSE_DEFAULT_SHARED:

          pp_string (buffer, "shared");

          break;

        case OMP_CLAUSE_DEFAULT_NONE:

          pp_string (buffer, "none");

          break;

        case OMP_CLAUSE_DEFAULT_PRIVATE:

          pp_string (buffer, "private");

          break;

        case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:

          pp_string (buffer, "firstprivate");

          break;

        default:

          gcc_unreachable ();

        }

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_SCHEDULE:

      pp_string (buffer, "schedule(");

      switch (OMP_CLAUSE_SCHEDULE_KIND (clause))

        {

      case OMP_CLAUSE_SCHEDULE_STATIC:

        pp_string (buffer, "static");

        break;

      case OMP_CLAUSE_SCHEDULE_DYNAMIC:

        pp_string (buffer, "dynamic");

        break;

      case OMP_CLAUSE_SCHEDULE_GUIDED:

        pp_string (buffer, "guided");

        break;

      case OMP_CLAUSE_SCHEDULE_RUNTIME:

        pp_string (buffer, "runtime");

        break;

      case OMP_CLAUSE_SCHEDULE_AUTO:

        pp_string (buffer, "auto");

        break;

      default:

        gcc_unreachable ();

        }

      if (OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause))

        {

          pp_character (buffer, ',');

          dump_generic_node (buffer,

              OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (clause),

              spc, flags, false);

        }

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_UNTIED:

      pp_string (buffer, "untied");

      break;

    case OMP_CLAUSE_COLLAPSE:

      pp_string (buffer, "collapse(");

      dump_generic_node (buffer,

                         OMP_CLAUSE_COLLAPSE_EXPR (clause),

                         spc, flags, false);

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_FINAL:

      pp_string (buffer, "final(");

      dump_generic_node (buffer, OMP_CLAUSE_FINAL_EXPR (clause),

          spc, flags, false);

      pp_character (buffer, ')');

      break;

    case OMP_CLAUSE_MERGEABLE:

      pp_string (buffer, "mergeable");

      break;

    default:

      /* Should never happen.  */

      dump_generic_node (buffer, clause, spc, flags, false);

      break;

    }

}

/* Dump the list of OpenMP clauses.  BUFFER, SPC and FLAGS are as in

   dump_generic_node.  */

void

dump_omp_clauses (pretty_printer *buffer, tree clause, int spc, int flags)

{

  if (clause == NULL)

    return;

  pp_space (buffer);

  while (1)

    {

      dump_omp_clause (buffer, clause, spc, flags);

      clause = OMP_CLAUSE_CHAIN (clause);

      if (clause == NULL)

        return;

      pp_space (buffer);

    }

}

/* Dump location LOC to BUFFER.  */

static void

dump_location (pretty_printer *buffer, location_t loc)

{

  expanded_location xloc = expand_location (loc);

  pp_character (buffer, '[');

  if (xloc.file)

    {

      pp_string (buffer, xloc.file);

      pp_string (buffer, " : ");

    }

  pp_decimal_int (buffer, xloc.line);

  pp_string (buffer, "] ");

}

/* Dump lexical block BLOCK.  BUFFER, SPC and FLAGS are as in

   dump_generic_node.  */

static void

dump_block_node (pretty_printer *buffer, tree block, int spc, int flags)

{

  tree t;

  pp_printf (buffer, "BLOCK #%d ", BLOCK_NUMBER (block));

  if (flags & TDF_ADDRESS)

    pp_printf (buffer, "[%p] ", (void *) block);

  if (BLOCK_ABSTRACT (block))

    pp_string (buffer, "[abstract] ");

  if (TREE_ASM_WRITTEN (block))

    pp_string (buffer, "[written] ");

  if (flags & TDF_SLIM)

    return;

  if (BLOCK_SOURCE_LOCATION (block))

    dump_location (buffer, BLOCK_SOURCE_LOCATION (block));

  newline_and_indent (buffer, spc + 2);

  if (BLOCK_SUPERCONTEXT (block))

    {

      pp_string (buffer, "SUPERCONTEXT: ");

      dump_generic_node (buffer, BLOCK_SUPERCONTEXT (block), 0,

                         flags | TDF_SLIM, false);

      newline_and_indent (buffer, spc + 2);

    }

  if (BLOCK_SUBBLOCKS (block))

    {

      pp_string (buffer, "SUBBLOCKS: ");

      for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))

        {

          dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);

          pp_string (buffer, " ");

        }

      newline_and_indent (buffer, spc + 2);

    }

  if (BLOCK_CHAIN (block))

    {

      pp_string (buffer, "SIBLINGS: ");

      for (t = BLOCK_CHAIN (block); t; t = BLOCK_CHAIN (t))

        {

          dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);

          pp_string (buffer, " ");

        }

      newline_and_indent (buffer, spc + 2);

    }

  if (BLOCK_VARS (block))

    {

      pp_string (buffer, "VARS: ");

      for (t = BLOCK_VARS (block); t; t = TREE_CHAIN (t))

        {

          dump_generic_node (buffer, t, 0, flags, false);

          pp_string (buffer, " ");

        }

      newline_and_indent (buffer, spc + 2);

    }

  if (VEC_length (tree, BLOCK_NONLOCALIZED_VARS (block)) > 0)

    {

      unsigned i;

      VEC(tree,gc) *nlv = BLOCK_NONLOCALIZED_VARS (block);

      pp_string (buffer, "NONLOCALIZED_VARS: ");

      FOR_EACH_VEC_ELT (tree, nlv, i, t)

        {

          dump_generic_node (buffer, t, 0, flags, false);

          pp_string (buffer, " ");

        }

      newline_and_indent (buffer, spc + 2);

    }

  if (BLOCK_ABSTRACT_ORIGIN (block))

    {

      pp_string (buffer, "ABSTRACT_ORIGIN: ");

      dump_generic_node (buffer, BLOCK_ABSTRACT_ORIGIN (block), 0,

                         flags | TDF_SLIM, false);

      newline_and_indent (buffer, spc + 2);

    }

  if (BLOCK_FRAGMENT_ORIGIN (block))

    {

      pp_string (buffer, "FRAGMENT_ORIGIN: ");

      dump_generic_node (buffer, BLOCK_FRAGMENT_ORIGIN (block), 0,

                         flags | TDF_SLIM, false);

      newline_and_indent (buffer, spc + 2);

    }

  if (BLOCK_FRAGMENT_CHAIN (block))

    {

      pp_string (buffer, "FRAGMENT_CHAIN: ");

      for (t = BLOCK_FRAGMENT_CHAIN (block); t; t = BLOCK_FRAGMENT_CHAIN (t))

        {

          dump_generic_node (buffer, t, 0, flags | TDF_SLIM, false);

          pp_string (buffer, " ");

        }

      newline_and_indent (buffer, spc + 2);

    }

}

/* Dump the node NODE on the pretty_printer BUFFER, SPC spaces of

   indent.  FLAGS specifies details to show in the dump (see TDF_* in

   tree-pass.h).  If IS_STMT is true, the object printed is considered

   to be a statement and it is terminated by ';' if appropriate.  */

int

dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,

                   bool is_stmt)

{

  tree type;

  tree op0, op1;

  const char *str;

  bool is_expr;

  if (node == NULL_TREE)

    return spc;

  is_expr = EXPR_P (node);

  if (is_stmt && (flags & TDF_STMTADDR))

    pp_printf (buffer, "<&%p> ", (void *)node);

  if ((flags & TDF_LINENO) && EXPR_HAS_LOCATION (node))

    dump_location (buffer, EXPR_LOCATION (node));

  switch (TREE_CODE (node))

    {

    case ERROR_MARK:

      pp_string (buffer, "<<< error >>>");

      break;

    case IDENTIFIER_NODE:

      pp_tree_identifier (buffer, node);

      break;

    case TREE_LIST:

      while (node && node != error_mark_node)

        {

          if (TREE_PURPOSE (node))

            {

              dump_generic_node (buffer, TREE_PURPOSE (node), spc, flags, false);

              pp_space (buffer);

            }

          dump_generic_node (buffer, TREE_VALUE (node), spc, flags, false);

          node = TREE_CHAIN (node);

          if (node && TREE_CODE (node) == TREE_LIST)

            {

              pp_character (buffer, ',');

              pp_space (buffer);

            }

        }

      break;

    case TREE_BINFO:

      dump_generic_node (buffer, BINFO_TYPE (node), spc, flags, false);

      break;

    case TREE_VEC:

      {

        size_t i;

        if (TREE_VEC_LENGTH (node) > 0)

          {

            size_t len = TREE_VEC_LENGTH (node);

            for (i = 0; i < len - 1; i++)

              {

                dump_generic_node (buffer, TREE_VEC_ELT (node, i), spc, flags,

                                   false);

                pp_character (buffer, ',');

                pp_space (buffer);