/* Tree inlining hooks and declarations.
- Copyright 2001, 2003, 2004, 2005, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ Copyright (C) 2001-2016 Free Software Foundation, Inc.
Contributed by Alexandre Oliva <aoliva@redhat.com>
This file is part of GCC.
#ifndef GCC_TREE_INLINE_H
#define GCC_TREE_INLINE_H
-#include "pointer-set.h"
+struct cgraph_edge;
/* Indicate the desired behavior wrt call graph edges. We can either
duplicate the edge (inlining, cloning), move the edge (versioning,
CB_CGE_MOVE_CLONES
};
+typedef int_hash <unsigned short, 0> dependence_hash;
+
/* Data required for function body duplication. */
-typedef struct copy_body_data
+struct copy_body_data
{
/* FUNCTION_DECL for function being inlined, or in general the
source function providing the original trees. */
/* The VAR_DECL for the return value. */
tree retvar;
+ /* The VAR_DECL for the return bounds. */
+ tree retbnd;
+
+ /* Assign statements that need bounds copy. */
+ vec<gimple *> assign_stmts;
+
/* The map from local declarations in the inlined function to
equivalents in the function into which it is being inlined. */
- struct pointer_map_t *decl_map;
+ hash_map<tree, tree> *decl_map;
/* Create a new decl to replace DECL in the destination function. */
tree (*copy_decl) (tree, struct copy_body_data *);
/* GIMPLE_CALL if va arg parameter packs should be expanded or NULL
is not. */
- gimple gimple_call;
+ gimple *call_stmt;
- /* Exception region the inlined call lie in. */
- int eh_region;
+ /* Exception landing pad the inlined call lies in. */
+ int eh_lp_nr;
- /* Take region number in the function being copied, add this value and
- get eh region number of the duplicate in the function we inline into. */
- int eh_region_offset;
+ /* Maps region and landing pad structures from the function being copied
+ to duplicates created within the function we inline into. */
+ hash_map<void *, void *> *eh_map;
/* We use the same mechanism do all sorts of different things. Rather
than enumerating the different cases, we categorize the behavior
by manipulating the CFG rather than a statement. */
bool transform_return_to_modify;
+ /* True if the parameters of the source function are transformed.
+ Only true for inlining. */
+ bool transform_parameter;
+
/* True if this statement will need to be regimplified. */
bool regimplify;
+ /* True if trees should not be unshared. */
+ bool do_not_unshare;
+
/* > 0 if we are remapping a type currently. */
int remapping_type_depth;
void (*transform_lang_insert_block) (tree);
/* Statements that might be possibly folded. */
- struct pointer_set_t *statements_to_fold;
+ hash_set<gimple *> *statements_to_fold;
/* Entry basic block to currently copied body. */
- struct basic_block_def *entry_bb;
-} copy_body_data;
+ basic_block entry_bb;
+
+ /* For partial function versioning, bitmap of bbs to be copied,
+ otherwise NULL. */
+ bitmap blocks_to_copy;
+
+ /* Debug statements that need processing. */
+ vec<gdebug *> debug_stmts;
+
+ /* A map from local declarations in the inlined function to
+ equivalents in the function into which it is being inlined, where
+ the originals have been mapped to a value rather than to a
+ variable. */
+ hash_map<tree, tree> *debug_map;
+
+ /* Cilk keywords currently need to replace some variables that
+ ordinary nested functions do not. */
+ bool remap_var_for_cilk;
+
+ /* A map from the inlined functions dependence info cliques to
+ equivalents in the function into which it is being inlined. */
+ hash_map<dependence_hash, unsigned short> *dependence_map;
+};
/* Weights of constructions for estimate_num_insns. */
-typedef struct eni_weights_d
+struct eni_weights
{
/* Cost per call. */
unsigned call_cost;
+ /* Cost per indirect call. */
+ unsigned indirect_call_cost;
+
/* Cost per call to a target specific builtin */
unsigned target_builtin_call_cost;
/* Cost for omp construct. */
unsigned omp_cost;
- /* True when time of statemnt should be estimated. Thus i.e
- cost of switch statement is logarithmic rather than linear in number
+ /* Cost for tm transaction. */
+ unsigned tm_cost;
+
+ /* Cost of return. */
+ unsigned return_cost;
+
+ /* True when time of statement should be estimated. Thus, the
+ cost of a switch statement is logarithmic rather than linear in number
of cases. */
bool time_based;
-} eni_weights;
+};
/* Weights that estimate_num_insns uses for heuristics in inlining. */
extern eni_weights eni_time_weights;
/* Function prototypes. */
-
+void init_inline_once (void);
extern tree copy_tree_body_r (tree *, int *, void *);
extern void insert_decl_map (copy_body_data *, tree, tree);
-
unsigned int optimize_inline_calls (tree);
+tree maybe_inline_call_in_expr (tree);
bool tree_inlinable_function_p (tree);
tree copy_tree_r (tree *, int *, void *);
tree copy_decl_no_change (tree decl, copy_body_data *id);
-void save_body (tree, tree *, tree *);
-int estimate_move_cost (tree type);
-int estimate_num_insns (gimple, eni_weights *);
+int estimate_move_cost (tree type, bool);
+int estimate_num_insns (gimple *, eni_weights *);
int estimate_num_insns_fn (tree, eni_weights *);
-int count_insns_seq (gimple_seq, eni_weights *);
+int estimate_num_insns_seq (gimple_seq, eni_weights *);
bool tree_versionable_function_p (tree);
-bool tree_can_inline_p (tree, tree);
-
-extern gimple_seq remap_gimple_seq (gimple_seq, copy_body_data *);
extern tree remap_decl (tree decl, copy_body_data *id);
extern tree remap_type (tree type, copy_body_data *id);
extern gimple_seq copy_gimple_seq_and_replace_locals (gimple_seq seq);
+extern bool debug_find_tree (tree, tree);
+extern tree copy_fn (tree, tree&, tree&);
+extern const char *copy_forbidden (struct function *fun, tree fndecl);
-extern HOST_WIDE_INT estimated_stack_frame_size (void);
+/* This is in tree-inline.c since the routine uses
+ data structures from the inliner. */
+extern tree build_duplicate_type (tree);
#endif /* GCC_TREE_INLINE_H */
projects / gcc.git / blobdiff