gcc/ipa-param-manipulation.h

   1 /* Manipulation of formal and actual parameters of functions and function
   2    calls.
   3    Copyright (C) 2017-2024 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 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
  23 This file defines classes and other data structures that are used to manipulate
  24 the prototype of a function, especially to create, remove or split its formal
  25 parameters, but also to remove its return value, and also its call statements
  26 correspondingly.
  27
  28 The most basic one is a vector of structures ipa_adjusted_param.  It is simply
  29 a description how the new parameters should look like after the transformation
  30 in what way they relate to the previous ones (if in any).  Such relation to an
  31 old parameter can be an outright copy or an IPA-SRA replacement. If an old
  32 parameter is not listed or otherwise mentioned, it is removed as unused or at
  33 least unnecessary.  Note that this most basic structure does not work for
  34 modifying calls of functions with variable number of arguments.
  35
  36 Class ipa_param_adjustments is only a little more than a thin encapsulation of
  37 a vector of ipa_param_adjustments.  Along with this vector it contains an index
  38 of the first potential vararg argument and a boolean flag whether the return
  39 value should be removed or not.  Moreover, the class contains method
  40 modify_call which can transform a call statement so that it correctly calls a
  41 modified function.  These two data structures were designed to have a small
  42 memory footprint because they are allocated for each clone of a call graph node
  43 that has its prototype changed and live until the end of IPA clone
  44 materialization and call redirection phase.
  45
  46 On the other hand, class ipa_param_body_adjustments can afford to allocate more
  47 data because its life span is much smaller, it is allocated and destroyed in
  48 the course of materialization of each single clone that needs it or only when a
  49 particular pass needs to change a function it is operating on.  This class has
  50 various methods required to change function declaration and the body of the
  51 function according to instructions given either by class ipa_param_adjustments
  52 or only a vector of ipa_adjusted_params.
  53
  54 When these classes are used in the context of call graph clone materialization
  55 and subsequent call statement redirection - which is the point at which we
  56 modify arguments in call statements - they need to cooperate with each other in
  57 order to handle what we refer to as pass-through (IPA-SRA) splits.  These are
  58 situations when a formal parameter of one function is split into several
  59 smaller ones and some of them are then passed on in a call to another function
  60 because the formal parameter of this callee has also been split.
  61
  62 Consider a simple example:
  63
  64 struct S {int a, b, c;};
  65 struct Z {int x; S s;};
  66
  67 foo (S s)
  68 {
  69   use (s.b);
  70 }
  71
  72 bar (Z z)
  73 {
  74   use (z.s.a);
  75   foo (z.s);
  76 }
  77
  78 baz ()
  79 {
  80   bar (*global);
  81 }
  82
  83 Both bar and foo would have their parameter split.  Foo would receive one
  84 replacement representing s.b.  Function bar would see its parameter split into
  85 one replacement representing z.s.a and another representing z.s.b which would
  86 be passed on to foo.  It would be a so called pass-through split IPA-SRA
  87 replacement, one which is passed in a call as an actual argument to another
  88 IPA-SRA replacement in another function.
  89
  90 Note that the call chain the example can be arbitrarily long and recursive and
  91 that any function in it can be cloned by another IPA pass and any number of
  92 adjacent functions in the call chain can be inlined into each other.  Call
  93 redirection takes place only after bodies of the function have been modified by
  94 all of the above.
  95
  96 Call redirection has to be able to find the right decl or SSA_NAME that
  97 corresponds to the transitive split in the caller.  The SSA names are assigned
  98 right after clone materialization/ modification and cannot be "added" to call
  99 arguments at any later point.  Moreover, if the caller has been inlined the
 100 SSA_NAMEs in question no longer belong to PARM_DECLs but to VAR_DECLs,
 101 indistinguishable from any others.
 102
 103 Therefore, when clone materialization finds a call statement which it knows is
 104 a part of a transitive split, it will simply add as arguments all new "split"
 105 replacements (that have grater or equal offset than the original call
 106 argument):
 107
 108   foo (repl_for_a, repl_for_b, <rest of original arguments>);
 109
 110 It will also store into ipa_edge_modification_info (which is internal to
 111 ipa-param-modification.c) information about which replacement is which and
 112 where original arguments are.  Call redirection will then invoke
 113 ipa_param_adjustments::modify_call which will access this information and
 114 eliminate all replacements which the callee does not expect (repl_for_a in our
 115 example above).  In between these two steps, however, a call statement might
 116 have extraneous arguments.  */
 117
 118 #ifndef IPA_PARAM_MANIPULATION_H
 119 #define IPA_PARAM_MANIPULATION_H
 120
 121 /* Indices into ipa_param_prefixes to identify a human-readable prefix for newly
 122    synthesized parameters.  Keep in sync with the array.  */
 123 enum ipa_param_name_prefix_indices
 124   {
 125    IPA_PARAM_PREFIX_SYNTH,
 126    IPA_PARAM_PREFIX_ISRA,
 127    IPA_PARAM_PREFIX_SIMD,
 128    IPA_PARAM_PREFIX_MASK,
 129    IPA_PARAM_PREFIX_COUNT
 130 };
 131
 132 /* We do not support manipulating functions with more than
 133    1<<IPA_PARAM_MAX_INDEX_BITS parameters.  */
 134 #define IPA_PARAM_MAX_INDEX_BITS 16
 135
 136 /* Operation to be performed for the parameter in ipa_parm_adjustment
 137    below.  */
 138
 139 enum ipa_parm_op
 140 {
 141   /* Do not use or you will trigger an assert.  */
 142   IPA_PARAM_OP_UNDEFINED,
 143
 144   /* This new parameter is an unmodified parameter at index base_index. */
 145   IPA_PARAM_OP_COPY,
 146
 147   /* This describes a brand new parameter.  If it somehow relates to any
 148      original parameters, the user needs to manage the transition itself.  */
 149   IPA_PARAM_OP_NEW,
 150
 151     /* Split parameter as indicated by fields base_index, offset and type.  */
 152   IPA_PARAM_OP_SPLIT
 153 };
 154
 155 /* Structure that describes one parameter of a function after transformation.
 156    Omitted parameters will be removed.  */
 157
 158 struct GTY(()) ipa_adjusted_param
 159 {
 160   /* Type of the new parameter.  Required for all operations except
 161      IPA_PARM_OP_COPY when the original type will be preserved.  */
 162   tree type;
 163
 164   /* Alias reference type to be used in MEM_REFs when adjusting caller
 165      arguments.  Required for IPA_PARM_OP_SPLIT operation.  */
 166   tree alias_ptr_type;
 167
 168   /* Offset into the original parameter (for the cases when the new parameter
 169      is a component of an original one).  Required for IPA_PARM_OP_SPLIT
 170      operation.  */
 171   unsigned unit_offset;
 172
 173   /* Zero based index of the original parameter this one is based on.  Required
 174      for IPA_PARAM_OP_COPY and IPA_PARAM_OP_SPLIT, users of IPA_PARAM_OP_NEW
 175      only need to specify it if they use replacement lookup provided by
 176      ipa_param_body_adjustments.  */
 177   unsigned base_index : IPA_PARAM_MAX_INDEX_BITS;
 178
 179   /* Zero based index of the parameter this one is based on in the previous
 180      clone.  If there is no previous clone, it must be equal to base_index.  */
 181   unsigned prev_clone_index : IPA_PARAM_MAX_INDEX_BITS;
 182
 183   /* Specify the operation, if any, to be performed on the parameter.  */
 184   enum ipa_parm_op op : 2;
 185
 186   /* If set, this structure describes a parameter copied over from a previous
 187      IPA clone, any transformations are thus not to be re-done.  */
 188   unsigned prev_clone_adjustment : 1;
 189
 190   /* Index into ipa_param_prefixes specifying a prefix to be used with
 191      DECL_NAMEs of newly synthesized parameters.  */
 192   unsigned param_prefix_index : 2;
 193
 194   /* Storage order of the original parameter (for the cases when the new
 195      parameter is a component of an original one).  */
 196   unsigned reverse : 1;
 197
 198   /* A bit free for the user.  */
 199   unsigned user_flag : 1;
 200 };
 201
 202 void ipa_dump_adjusted_parameters (FILE *f,
 203                                    vec<ipa_adjusted_param, va_gc> *adj_params);
 204
 205 /* Class used to record planned modifications to parameters of a function and
 206    also to perform necessary modifications at the caller side at the gimple
 207    level.  Used to describe all cgraph node clones that have their parameters
 208    changed, therefore the class should only have a small memory footprint.  */
 209
 210 class GTY(()) ipa_param_adjustments
 211 {
 212 public:
 213   /* Constructor from NEW_PARAMS showing how new parameters should look like
 214       plus copying any pre-existing actual arguments starting from argument
 215       with index ALWAYS_COPY_START (if non-negative, negative means do not copy
 216       anything beyond what is described in NEW_PARAMS), and SKIP_RETURN, which
 217       indicates that the function should return void after transformation.  */
 218
 219   ipa_param_adjustments (vec<ipa_adjusted_param, va_gc> *new_params,
 220                          int always_copy_start, bool skip_return)
 221     : m_adj_params (new_params), m_always_copy_start (always_copy_start),
 222     m_skip_return (skip_return)
 223     {}
 224
 225   /* Modify a call statement arguments (and possibly remove the return value)
 226      as described in the data fields of this class.  */
 227   gcall *modify_call (cgraph_edge *cs, bool update_references,
 228                       hash_set <tree> *killed_ssas);
 229   /* Return if the first parameter is left intact.  */
 230   bool first_param_intact_p ();
 231   /* Build a function type corresponding to the modified call.  */
 232   tree build_new_function_type (tree old_type, bool type_is_original_p);
 233   /* Build a declaration corresponding to the target of the modified call.  */
 234   tree adjust_decl (tree orig_decl);
 235   /* Fill a vector marking which parameters are intact by the described
 236      modifications. */
 237   void get_surviving_params (vec<bool> *surviving_params);
 238   /* Fill a vector with new indices of surviving original parameters.  */
 239   void get_updated_indices (vec<int> *new_indices);
 240   /* Return the original index for the given new parameter index.  Return a
 241      negative number if not available.  */
 242   int get_original_index (int newidx);
 243
 244   void dump (FILE *f);
 245   void debug ();
 246
 247   /* How the known part of arguments should look like.  */
 248   vec<ipa_adjusted_param, va_gc> *m_adj_params;
 249
 250   /* If non-negative, copy any arguments starting at this offset without any
 251      modifications so that functions with variable number of arguments can be
 252      modified. This number should be equal to the number of original forma
 253      parameters.  */
 254   int m_always_copy_start;
 255   /* If true, make the function not return any value.  */
 256   bool m_skip_return;
 257
 258   static bool type_attribute_allowed_p (tree);
 259 private:
 260   ipa_param_adjustments () {}
 261
 262   void init (vec<tree> *cur_params);
 263   int get_max_base_index ();
 264   bool method2func_p (tree orig_type);
 265 };
 266
 267 /* Structure used to map expressions accessing split or replaced parameters to
 268    new PARM_DECLs.  */
 269
 270 struct ipa_param_body_replacement
 271 {
 272   /* The old decl of the original parameter.   */
 273   tree base;
 274   /* The new decl it should be replaced with.  */
 275   tree repl;
 276   /* Users of ipa_param_body_adjustments that modify standalone functions
 277      outside of IPA clone materialization can use the following field for their
 278      internal purposes.  */
 279   tree dummy;
 280   /* The offset within BASE that REPL represents.  */
 281   unsigned unit_offset;
 282 };
 283
 284 struct ipa_replace_map;
 285
 286 /* Class used when actually performing adjustments to formal parameters of a
 287    function to map accesses that need to be replaced to replacements.  The
 288    class attempts to work in two very different sets of circumstances: as a
 289    part of tree-inine.c's tree_function_versioning machinery to clone functions
 290    (when M_ID is not NULL) and in s standalone fashion, modifying an existing
 291    function in place (when M_ID is NULL).  While a lot of stuff handled in a
 292    unified way in both modes, there are many aspects of the processs that
 293    requires distinct paths.  */
 294
 295 class ipa_param_body_adjustments
 296 {
 297 public:
 298   /* Constructor to use from within tree-inline.  */
 299   ipa_param_body_adjustments (ipa_param_adjustments *adjustments,
 300                               tree fndecl, tree old_fndecl,
 301                               struct copy_body_data *id, tree *vars,
 302                               vec<ipa_replace_map *, va_gc> *tree_map);
 303   /* Constructor to use for modifying a function outside of tree-inline from an
 304      instance of ipa_param_adjustments.  */
 305   ipa_param_body_adjustments (ipa_param_adjustments *adjustments,
 306                               tree fndecl);
 307   /* Constructor to use for modifying a function outside of tree-inline from a
 308      simple vector of desired parameter modification.  */
 309   ipa_param_body_adjustments (vec<ipa_adjusted_param, va_gc> *adj_params,
 310                               tree fndecl);
 311
 312   /* The do-it-all function for modifying a function outside of
 313      tree-inline.  */
 314   bool perform_cfun_body_modifications ();
 315
 316   /* Change the PARM_DECLs.  */
 317   void modify_formal_parameters ();
 318   /* Register a REPLACEMENT for accesses to BASE at UNIT_OFFSET.  */
 319   void register_replacement (tree base, unsigned unit_offset, tree replacement);
 320   /* Register a replacement decl for the transformation done in APM.  */
 321   void register_replacement (ipa_adjusted_param *apm, tree replacement);
 322   /* Sort m_replacements and set m_sorted_replacements_p to true.  Users that
 323      call register_replacement themselves must call the method before any
 324      lookup and thus also any statement or expression modification.  */
 325   void sort_replacements ();
 326   /* Lookup a replacement for a given offset within a given parameter.  */
 327   tree lookup_replacement (tree base, unsigned unit_offset);
 328   /* Lookup a replacement for an expression, if there is one.  */
 329   ipa_param_body_replacement *get_expr_replacement (tree expr,
 330                                                     bool ignore_default_def);
 331   /* Lookup the new base for surviving names previously belonging to a
 332      parameter. */
 333   tree get_replacement_ssa_base (tree old_decl);
 334   /* Modify a statement.  */
 335   bool modify_gimple_stmt (gimple **stmt, gimple_seq *extra_stmts,
 336                            gimple *orig_stmt);
 337   /* Return the new chain of parameters.  */
 338   tree get_new_param_chain ();
 339   /* Replace all occurances of SSAs in m_dead_ssa_debug_equiv in t with what
 340      they are mapped to.  */
 341   void remap_with_debug_expressions (tree *t);
 342
 343   /* If there are any initialization statements that need to be emitted into
 344      the basic block BB right at ther start of the new function, do so.  */
 345   void append_init_stmts (basic_block bb);
 346
 347   /* Pointers to data structures defining how the function should be
 348      modified.  */
 349   vec<ipa_adjusted_param, va_gc> *m_adj_params;
 350   ipa_param_adjustments *m_adjustments;
 351
 352   /* Vector of old parameter declarations that must have their debug bind
 353      statements re-mapped and debug decls created.  */
 354
 355   auto_vec<tree, 16> m_reset_debug_decls;
 356
 357   /* Sets of statements and SSA_NAMEs that only manipulate data from parameters
 358      removed because they are not necessary.  */
 359   hash_set<gimple *> m_dead_stmts;
 360   hash_set<tree> m_dead_ssas;
 361
 362   /* Mapping from DCEd SSAs to what their potential debug_binds should be.  */
 363   hash_map<tree, tree> m_dead_ssa_debug_equiv;
 364   /* Mapping from DCEd statements to debug expressions that will be placed on
 365      the RHS of debug statement that will replace this one.  */
 366   hash_map<gimple *, tree> m_dead_stmt_debug_equiv;
 367
 368 private:
 369   void common_initialization (tree old_fndecl, tree *vars,
 370                               vec<ipa_replace_map *, va_gc> *tree_map);
 371   tree carry_over_param (tree t);
 372   unsigned get_base_index (ipa_adjusted_param *apm);
 373   ipa_param_body_replacement *lookup_replacement_1 (tree base,
 374                                                     unsigned unit_offset);
 375   ipa_param_body_replacement *lookup_first_base_replacement (tree base);
 376   tree replace_removed_params_ssa_names (tree old_name, gimple *stmt);
 377   bool modify_expression (tree *expr_p, bool convert, gimple_seq * = nullptr);
 378   bool modify_assignment (gimple *stmt, gimple_seq *extra_stmts);
 379   bool modify_call_stmt (gcall **stmt_p, gimple *orig_stmt);
 380   bool modify_cfun_body ();
 381   void reset_debug_stmts ();
 382   tree get_ddef_if_exists_and_is_used (tree decl);
 383   void mark_dead_statements (tree dead_param, vec<tree> *debugstack);
 384   void mark_clobbers_dead (tree dead_param);
 385   bool prepare_debug_expressions (tree dead_ssa);
 386
 387   /* Declaration of the function that is being transformed.  */
 388
 389   tree m_fndecl;
 390
 391   /* If non-NULL, the tree-inline master data structure guiding materialization
 392      of the current clone.  */
 393   struct copy_body_data *m_id;
 394
 395   /* Vector of old parameter declarations (before changing them).  */
 396
 397   auto_vec<tree, 16> m_oparms;
 398
 399   /* Vector of parameter declarations the function will have after
 400      transformation.  */
 401
 402   auto_vec<tree, 16> m_new_decls;
 403
 404   /* If the function type has non-NULL TYPE_ARG_TYPES, this is the vector of
 405      these types after transformation, otherwise an empty one.  */
 406
 407   auto_vec<tree, 16> m_new_types;
 408
 409   /* Vector of structures telling how to replace old parameters in the
 410      function body.  TODO: Even though there usually be only few, but should we
 411      use a hash?  */
 412
 413   auto_vec<ipa_param_body_replacement, 16> m_replacements;
 414
 415   /* List of initialization assignments to be put at the beginning of the
 416      cloned function to deal with split aggregates which however have known
 417      constant value and so their PARM_DECL disappears.  */
 418
 419   auto_vec<gimple *, 8> m_split_agg_csts_inits;
 420
 421   /* Vector for remapping SSA_BASES from old parameter declarations that are
 422      being removed as a part of the transformation.  Before a new VAR_DECL is
 423      created, it holds the old PARM_DECL, once the variable is built it is
 424      stored here.  */
 425
 426   auto_vec<tree> m_removed_decls;
 427
 428   /* Hash to quickly lookup the item in m_removed_decls given the old decl.  */
 429
 430   hash_map<tree, unsigned> m_removed_map;
 431
 432   /* True iff the transformed function is a class method that is about to loose
 433      its this pointer and must be converted to a normal function.  */
 434
 435   bool m_method2func;
 436
 437   /* True if m_replacements have ben sorted since the last insertion.  */
 438
 439   bool m_sorted_replacements_p;
 440 };
 441
 442 void push_function_arg_decls (vec<tree> *args, tree fndecl);
 443 void push_function_arg_types (vec<tree> *types, tree fntype);
 444 void ipa_verify_edge_has_no_modifications (cgraph_edge *cs);
 445 void ipa_edge_modifications_finalize ();
 446 void ipa_release_ssas_in_hash (hash_set <tree> *killed_ssas);
 447
 448 #endif  /* IPA_PARAM_MANIPULATION_H */