gcc/ipa-icf-gimple.h

   1 /* Interprocedural semantic function equality pass
   2    Copyright (C) 2014 Free Software Foundation, Inc.
   3
   4    Contributed by Jan Hubicka <hubicka@ucw.cz> and Martin Liska <mliska@suse.cz>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 /* Gimple identical code folding (class func_checker) is an infastructure
  23    capable of comparing two given functions. The class compares every
  24    gimple statement and uses many dictionaries to map source and target
  25    SSA_NAMEs, declarations and other components.
  26
  27    To use the infrastructure, create an instanse of func_checker and call
  28    a comparsion function based on type of gimple statement.  */
  29
  30 /* Prints string STRING to a FILE with a given number of SPACE_COUNT.  */
  31 #define FPUTS_SPACES(file, space_count, string) \
  32   fprintf (file, "%*s" string, space_count, " ");
  33
  34 /* fprintf function wrapper that transforms given FORMAT to follow given
  35    number for SPACE_COUNT and call fprintf for a FILE.  */
  36 #define FPRINTF_SPACES(file, space_count, format, ...) \
  37   fprintf (file, "%*s" format, space_count, " ", ##__VA_ARGS__);
  38
  39 /* Prints a MESSAGE to dump_file if exists. FUNC is name of function and
  40    LINE is location in the source file.  */
  41
  42 static inline void
  43 dump_message_1 (const char *message, const char *func, unsigned int line)
  44 {
  45   if (dump_file && (dump_flags & TDF_DETAILS))
  46     fprintf (dump_file, "  debug message: %s (%s:%u)\n", message, func, line);
  47 }
  48
  49 /* Prints a MESSAGE to dump_file if exists.  */
  50 #define dump_message(message) dump_message_1 (message, __func__, __LINE__)
  51
  52 /* Logs a MESSAGE to dump_file if exists and returns false. FUNC is name
  53    of function and LINE is location in the source file.  */
  54
  55 static inline bool
  56 return_false_with_message_1 (const char *message, const char *func,
  57                              unsigned int line)
  58 {
  59   if (dump_file && (dump_flags & TDF_DETAILS))
  60     fprintf (dump_file, "  false returned: '%s' (%s:%u)\n", message, func, line);
  61   return false;
  62 }
  63
  64 /* Logs a MESSAGE to dump_file if exists and returns false.  */
  65 #define return_false_with_msg(message) \
  66   return_false_with_message_1 (message, __func__, __LINE__)
  67
  68 /* Return false and log that false value is returned.  */
  69 #define return_false() return_false_with_msg ("")
  70
  71 /* Logs return value if RESULT is false. FUNC is name of function and LINE
  72    is location in the source file.  */
  73
  74 static inline bool
  75 return_with_result (bool result, const char *func, unsigned int line)
  76 {
  77   if (!result && dump_file && (dump_flags & TDF_DETAILS))
  78     fprintf (dump_file, "  false returned (%s:%u)\n", func, line);
  79
  80   return result;
  81 }
  82
  83 /* Logs return value if RESULT is false.  */
  84 #define return_with_debug(result) return_with_result (result, __func__, __LINE__)
  85
  86 /* Verbose logging function logging statements S1 and S2 of a CODE.
  87    FUNC is name of function and LINE is location in the source file.  */
  88
  89 static inline bool
  90 return_different_stmts_1 (gimple s1, gimple s2, const char *code,
  91                           const char *func, unsigned int line)
  92 {
  93   if (dump_file && (dump_flags & TDF_DETAILS))
  94     {
  95       fprintf (dump_file, "  different statement for code: %s (%s:%u):\n",
  96                code, func, line);
  97
  98       print_gimple_stmt (dump_file, s1, 3, TDF_DETAILS);
  99       print_gimple_stmt (dump_file, s2, 3, TDF_DETAILS);
 100     }
 101
 102   return false;
 103 }
 104
 105 /* Verbose logging function logging statements S1 and S2 of a CODE.  */
 106 #define return_different_stmts(s1, s2, code) \
 107   return_different_stmts_1 (s1, s2, code, __func__, __LINE__)
 108
 109 namespace ipa_icf_gimple {
 110
 111 /* Basic block struct for semantic equality pass.  */
 112 class sem_bb
 113 {
 114 public:
 115   sem_bb (basic_block bb_, unsigned nondbg_stmt_count_, unsigned edge_count_):
 116     bb (bb_), nondbg_stmt_count (nondbg_stmt_count_), edge_count (edge_count_) {}
 117
 118   /* Basic block the structure belongs to.  */
 119   basic_block bb;
 120
 121   /* Number of non-debug statements in the basic block.  */
 122   unsigned nondbg_stmt_count;
 123
 124   /* Number of edges connected to the block.  */
 125   unsigned edge_count;
 126 };
 127
 128 /* A class aggregating all connections and semantic equivalents
 129    for a given pair of semantic function candidates.  */
 130 class func_checker
 131 {
 132 public:
 133   /* Initialize internal structures for a given SOURCE_FUNC_DECL and
 134      TARGET_FUNC_DECL. Strict polymorphic comparison is processed if
 135      an option COMPARE_POLYMORPHIC is true. For special cases, one can
 136      set IGNORE_LABELS to skip label comparison.
 137      Similarly, IGNORE_SOURCE_DECLS and IGNORE_TARGET_DECLS are sets
 138      of declarations that can be skipped.  */
 139   func_checker (tree source_func_decl, tree target_func_decl,
 140                 bool compare_polymorphic,
 141                 bool ignore_labels = false,
 142                 hash_set<symtab_node *> *ignored_source_nodes = NULL,
 143                 hash_set<symtab_node *> *ignored_target_nodes = NULL);
 144
 145   /* Memory release routine.  */
 146   ~func_checker();
 147
 148   /* Function visits all gimple labels and creates corresponding
 149      mapping between basic blocks and labels.  */
 150   void parse_labels (sem_bb *bb);
 151
 152   /* Basic block equivalence comparison function that returns true if
 153      basic blocks BB1 and BB2 correspond.  */
 154   bool compare_bb (sem_bb *bb1, sem_bb *bb2);
 155
 156   /* Verifies that trees T1 and T2 are equivalent from perspective of ICF.  */
 157   bool compare_ssa_name (tree t1, tree t2);
 158
 159   /* Verification function for edges E1 and E2.  */
 160   bool compare_edge (edge e1, edge e2);
 161
 162   /* Verifies for given GIMPLEs S1 and S2 that
 163      call statements are semantically equivalent.  */
 164   bool compare_gimple_call (gimple s1, gimple s2);
 165
 166   /* Verifies for given GIMPLEs S1 and S2 that
 167      assignment statements are semantically equivalent.  */
 168   bool compare_gimple_assign (gimple s1, gimple s2);
 169
 170   /* Verifies for given GIMPLEs S1 and S2 that
 171      condition statements are semantically equivalent.  */
 172   bool compare_gimple_cond (gimple s1, gimple s2);
 173
 174   /* Verifies for given GIMPLEs S1 and S2 that
 175      label statements are semantically equivalent.  */
 176   bool compare_gimple_label (gimple s1, gimple s2);
 177
 178   /* Verifies for given GIMPLEs S1 and S2 that
 179      switch statements are semantically equivalent.  */
 180   bool compare_gimple_switch (gimple s1, gimple s2);
 181
 182   /* Verifies for given GIMPLEs S1 and S2 that
 183      return statements are semantically equivalent.  */
 184   bool compare_gimple_return (gimple s1, gimple s2);
 185
 186   /* Verifies for given GIMPLEs S1 and S2 that
 187      goto statements are semantically equivalent.  */
 188   bool compare_gimple_goto (gimple s1, gimple s2);
 189
 190   /* Verifies for given GIMPLEs S1 and S2 that
 191      resx statements are semantically equivalent.  */
 192   bool compare_gimple_resx (gimple s1, gimple s2);
 193
 194   /* Verifies for given GIMPLEs S1 and S2 that ASM statements are equivalent.
 195      For the beginning, the pass only supports equality for
 196      '__asm__ __volatile__ ("", "", "", "memory")'.  */
 197   bool compare_gimple_asm (gimple s1, gimple s2);
 198
 199   /* Verification function for declaration trees T1 and T2.  */
 200   bool compare_decl (tree t1, tree t2);
 201
 202   /* Verifies that tree labels T1 and T2 correspond.  */
 203   bool compare_tree_ssa_label (tree t1, tree t2);
 204
 205   /* Function responsible for comparison of handled components T1 and T2.
 206      If these components, from functions FUNC1 and FUNC2, are equal, true
 207      is returned.  */
 208   bool compare_operand (tree t1, tree t2);
 209
 210   /* Compares two tree list operands T1 and T2 and returns true if these
 211      two trees are semantically equivalent.  */
 212   bool compare_tree_list_operand (tree t1, tree t2);
 213
 214   /* Verifies that trees T1 and T2, representing function declarations
 215      are equivalent from perspective of ICF.  */
 216   bool compare_function_decl (tree t1, tree t2);
 217
 218   /* Verifies that trees T1 and T2 do correspond.  */
 219   bool compare_variable_decl (tree t1, tree t2);
 220
 221   /* Return true if types are compatible from perspective of ICF.
 222      FIRST_ARGUMENT indicates if the comparison is called for
 223      first parameter of a function.  */
 224   static bool compatible_types_p (tree t1, tree t2,
 225                                   bool compare_polymorphic = true,
 226                                   bool first_argument = false);
 227
 228
 229 private:
 230   /* Vector mapping source SSA names to target ones.  */
 231   vec <int> m_source_ssa_names;
 232
 233   /* Vector mapping target SSA names to source ones.  */
 234   vec <int> m_target_ssa_names;
 235
 236   /* Source TREE function declaration.  */
 237   tree m_source_func_decl;
 238
 239   /* Target TREE function declaration.  */
 240   tree m_target_func_decl;
 241
 242   /* Source symbol nodes that should be skipped by
 243      declaration comparison.  */
 244   hash_set<symtab_node *> *m_ignored_source_nodes;
 245
 246   /* Target symbol nodes that should be skipped by
 247      declaration comparison.  */
 248   hash_set<symtab_node *> *m_ignored_target_nodes;
 249
 250   /* Source to target edge map.  */
 251   hash_map <edge, edge> m_edge_map;
 252
 253   /* Source to target declaration map.  */
 254   hash_map <tree, tree> m_decl_map;
 255
 256   /* Label to basic block index mapping.  */
 257   hash_map <tree, int> m_label_bb_map;
 258
 259   /* Flag if polymorphic comparison should be executed.  */
 260   bool m_compare_polymorphic;
 261
 262   /* Flag if ignore labels in comparison.  */
 263   bool m_ignore_labels;
 264 };
 265
 266 } // ipa_icf_gimple namespace