346 lines
13 KiB
C
346 lines
13 KiB
C
#ifndef SIZE_OVERFLOW_H
|
|
#define SIZE_OVERFLOW_H
|
|
|
|
#define CREATE_NEW_VAR NULL_TREE
|
|
#define MAX_PARAM 31
|
|
#define CANNOT_FIND_ARG 32
|
|
#define NONE_ARGNUM 32
|
|
|
|
#define BEFORE_STMT true
|
|
#define AFTER_STMT false
|
|
|
|
#define TURN_OFF_ASM_STR "# size_overflow MARK_TURN_OFF "
|
|
#define YES_ASM_STR "# size_overflow MARK_YES "
|
|
#define END_INTENTIONAL_ASM_STR "# size_overflow MARK_END_INTENTIONAL "
|
|
#define SO_ASM_STR "# size_overflow "
|
|
#define OK_ASM_STR "# size_overflow MARK_NO"
|
|
|
|
#define FUNCTION_PTR_P(node) \
|
|
(TREE_CODE(TREE_TYPE(node)) == POINTER_TYPE && (TREE_CODE(TREE_TYPE(TREE_TYPE(node))) == FUNCTION_TYPE || TREE_CODE(TREE_TYPE(TREE_TYPE(node))) == METHOD_TYPE))
|
|
|
|
#define CODES_LIMIT 32
|
|
|
|
#define GLOBAL_NIFN_LEN 65536
|
|
#define NO_HASH 65537
|
|
|
|
#define SIZE_OVERFLOW true
|
|
#define DISABLE_SIZE_OVERFLOW false
|
|
|
|
#include "gcc-common.h"
|
|
|
|
#include <string.h>
|
|
#include <limits.h>
|
|
|
|
enum intentional_mark {
|
|
MARK_NO, MARK_YES, MARK_END_INTENTIONAL, MARK_TURN_OFF
|
|
};
|
|
|
|
enum intentional_overflow_type {
|
|
NO_INTENTIONAL_OVERFLOW, RHS1_INTENTIONAL_OVERFLOW, RHS2_INTENTIONAL_OVERFLOW
|
|
};
|
|
|
|
enum size_overflow_mark {
|
|
NO_SO_MARK, YES_SO_MARK, ASM_STMT_SO_MARK
|
|
};
|
|
|
|
struct decl_hash {
|
|
size_t tree_codes_len;
|
|
unsigned char tree_codes[CODES_LIMIT];
|
|
const_tree decl;
|
|
const char *context;
|
|
unsigned int hash;
|
|
const char *fn_name;
|
|
};
|
|
|
|
struct next_interesting_function;
|
|
typedef struct next_interesting_function * next_interesting_function_t;
|
|
|
|
struct interesting_stmts;
|
|
typedef struct interesting_stmts * interesting_stmts_t;
|
|
|
|
enum based_decl {
|
|
SO_FUNCTION, SO_VAR, SO_FIELD, SO_FUNCTION_POINTER, SO_AUX, SO_DISABLE, SO_NONE
|
|
};
|
|
|
|
// Store data associated with the next_interesting_function_t entry
|
|
struct fn_raw_data
|
|
{
|
|
const char *decl_str;
|
|
tree decl;
|
|
const char *context;
|
|
unsigned int hash;
|
|
unsigned int num;
|
|
enum size_overflow_mark marked;
|
|
enum based_decl based_decl;
|
|
const char *orig_decl_str;
|
|
unsigned int orig_num;
|
|
};
|
|
|
|
#if BUILDING_GCC_VERSION <= 4007
|
|
DEF_VEC_P(next_interesting_function_t);
|
|
DEF_VEC_ALLOC_P(next_interesting_function_t, heap);
|
|
#endif
|
|
|
|
#if BUILDING_GCC_VERSION >= 5000
|
|
typedef struct hash_set<const_gimple> gimple_set;
|
|
|
|
static inline bool pointer_set_insert(gimple_set *visited, const_gimple stmt)
|
|
{
|
|
return visited->add(stmt);
|
|
}
|
|
|
|
static inline bool pointer_set_contains(gimple_set *visited, const_gimple stmt)
|
|
{
|
|
return visited->contains(stmt);
|
|
}
|
|
|
|
static inline gimple_set* pointer_set_create(void)
|
|
{
|
|
return new hash_set<const_gimple>;
|
|
}
|
|
|
|
static inline void pointer_set_destroy(gimple_set *visited)
|
|
{
|
|
delete visited;
|
|
}
|
|
|
|
typedef struct hash_set<next_interesting_function_t> next_interesting_function_set;
|
|
|
|
static inline bool pointer_set_insert(next_interesting_function_set *visited, next_interesting_function_t node)
|
|
{
|
|
return visited->add(node);
|
|
}
|
|
|
|
static inline bool pointer_set_contains(next_interesting_function_set *visited, next_interesting_function_t node)
|
|
{
|
|
return visited->contains(node);
|
|
}
|
|
|
|
static inline next_interesting_function_set *next_interesting_function_pointer_set_create(void)
|
|
{
|
|
return new hash_set<next_interesting_function_t>;
|
|
}
|
|
|
|
static inline void pointer_set_destroy(next_interesting_function_set *visited)
|
|
{
|
|
delete visited;
|
|
}
|
|
#else
|
|
typedef struct pointer_set_t gimple_set;
|
|
typedef struct pointer_set_t next_interesting_function_set;
|
|
|
|
static inline next_interesting_function_set *next_interesting_function_pointer_set_create(void)
|
|
{
|
|
return pointer_set_create();
|
|
}
|
|
#endif
|
|
|
|
struct visited {
|
|
gimple_set *stmts;
|
|
gimple_set *my_stmts;
|
|
gimple_set *skip_expr_casts;
|
|
gimple_set *no_cast_check;
|
|
};
|
|
|
|
/*
|
|
* * children: callers with data flow into the integer parameter of decl
|
|
* * decl_name: name of the function or the field
|
|
* * context: the containing type name for a function pointer (or "fielddecl" if the type has no name), otherwise either "vardecl" or "fndecl"
|
|
* * hash: hash num of the function
|
|
* * num: parameter number (1-31) or return value (0)
|
|
* * marked: determines whether to duplicate stmts and/or look for missing hashtable entries
|
|
* * orig_next_node: pointer to the originally cloned function
|
|
*/
|
|
|
|
struct next_interesting_function {
|
|
next_interesting_function_t next;
|
|
#if BUILDING_GCC_VERSION <= 4007
|
|
VEC(next_interesting_function_t, heap) *children;
|
|
#else
|
|
vec<next_interesting_function_t, va_heap, vl_embed> *children;
|
|
#endif
|
|
const char *decl_name;
|
|
const char *context;
|
|
enum based_decl based_decl;
|
|
unsigned int hash;
|
|
unsigned int num;
|
|
enum size_overflow_mark marked;
|
|
next_interesting_function_t orig_next_node;
|
|
};
|
|
|
|
// size_overflow_plugin.c
|
|
extern tree report_size_overflow_decl;
|
|
extern tree size_overflow_type_HI;
|
|
extern tree size_overflow_type_SI;
|
|
extern tree size_overflow_type_DI;
|
|
extern tree size_overflow_type_TI;
|
|
// command line options
|
|
extern bool check_fields, check_fns, check_fnptrs, check_vars;
|
|
|
|
|
|
// size_overflow_plugin_hash.c
|
|
struct size_overflow_hash {
|
|
const struct size_overflow_hash * const next;
|
|
const char * const name;
|
|
const char * const context;
|
|
const unsigned int param;
|
|
};
|
|
|
|
extern const char *get_orig_decl_name(const_tree decl);
|
|
extern bool is_size_overflow_asm(const_gimple stmt);
|
|
extern void print_missing_function(next_interesting_function_t node);
|
|
extern const struct size_overflow_hash *get_size_overflow_hash_entry(struct fn_raw_data *raw_data);
|
|
extern const struct size_overflow_hash *get_size_overflow_hash_entry_tree(struct fn_raw_data *raw_data, bool hash_table);
|
|
extern unsigned int find_arg_number_tree(const_tree arg, const_tree func);
|
|
extern unsigned int get_decl_hash(const_tree decl, const char *decl_name);
|
|
extern const char *get_based_decl_str(enum based_decl based_decl);
|
|
extern void initialize_raw_data(struct fn_raw_data *raw_data);
|
|
|
|
|
|
// intentional_overflow.c
|
|
extern enum intentional_mark get_intentional_attr_type(const_tree node);
|
|
extern tree get_size_overflow_asm_input(const gasm *stmt);
|
|
extern enum intentional_mark check_intentional_size_overflow_asm_and_attribute(const_tree var);
|
|
extern bool is_size_overflow_insert_check_asm(const gasm *stmt);
|
|
extern enum intentional_mark check_intentional_attribute(const_gimple stmt, unsigned int argnum);
|
|
extern enum intentional_mark get_so_asm_type(const_gimple stmt);
|
|
extern const_tree get_attribute(const char* attr_name, const_tree decl);
|
|
extern bool is_a_cast_and_const_overflow(const_tree no_const_rhs);
|
|
extern bool is_const_plus_unsigned_signed_truncation(const_tree lhs);
|
|
extern bool is_a_constant_overflow(const gassign *stmt, const_tree rhs);
|
|
extern tree handle_intentional_overflow(interesting_stmts_t expand_from, bool check_overflow, gassign *stmt, tree change_rhs, tree new_rhs2);
|
|
extern tree handle_integer_truncation(interesting_stmts_t expand_from, const_tree lhs);
|
|
extern bool is_a_neg_overflow(const gassign *stmt, const_tree rhs);
|
|
extern enum intentional_overflow_type add_mul_intentional_overflow(const gassign *stmt);
|
|
extern void unsigned_signed_cast_intentional_overflow(struct visited *visited, gassign *stmt);
|
|
extern bool neg_short_add_intentional_overflow(gassign *stmt);
|
|
extern bool is_bitfield_unnamed_cast(const_tree decl, gassign *assign);
|
|
extern bool uconst_neg_intentional_overflow(const gassign *stmt);
|
|
extern bool short_or_neg_const_ushort(gassign *stmt);
|
|
|
|
|
|
// insert_size_overflow_asm.c
|
|
#if BUILDING_GCC_VERSION >= 4009
|
|
extern opt_pass *make_insert_size_overflow_asm_pass(void);
|
|
#else
|
|
extern struct opt_pass *make_insert_size_overflow_asm_pass(void);
|
|
#endif
|
|
extern bool search_interesting_args(tree fndecl, bool *argnums);
|
|
|
|
|
|
// size_overflow_misc.c
|
|
extern bool is_vararg(const_tree fn, unsigned int num);
|
|
extern tree get_ref_field(const_tree ref);
|
|
extern unsigned int get_correct_argnum_fndecl(const_tree fndecl, const_tree correct_argnum_of_fndecl, unsigned int num);
|
|
extern const char *get_type_name_from_field(const_tree field_decl);
|
|
extern void set_dominance_info(void);
|
|
extern void unset_dominance_info(void);
|
|
extern tree get_interesting_orig_fndecl_from_stmt(const gcall *stmt);
|
|
extern tree get_orig_fndecl(const_tree clone_fndecl);
|
|
extern unsigned int get_correct_argnum(const_tree decl, const_tree correct_argnum_of_decl, unsigned int argnum);
|
|
extern bool is_valid_cgraph_node(struct cgraph_node *node);
|
|
extern void set_current_function_decl(tree fndecl);
|
|
extern void unset_current_function_decl(void);
|
|
extern gimple get_def_stmt(const_tree node);
|
|
extern tree create_new_var(tree type);
|
|
extern gimple build_cast_stmt(struct visited *visited, tree dst_type, tree rhs, tree lhs, gimple_stmt_iterator *gsi, bool before, bool force);
|
|
extern bool skip_types(const_tree var);
|
|
extern tree cast_a_tree(tree type, tree var);
|
|
extern bool is_size_overflow_type(const_tree var);
|
|
extern bool made_by_compiler(const_tree decl);
|
|
extern gimple get_fnptr_def_stmt(const_tree fn_ptr);
|
|
extern tree get_lhs(const_gimple stmt);
|
|
|
|
|
|
// size_overflow_transform.c
|
|
struct interesting_stmts {
|
|
struct interesting_stmts *next;
|
|
next_interesting_function_t next_node;
|
|
gimple first_stmt;
|
|
tree orig_node;
|
|
unsigned int num;
|
|
struct visited *visited;
|
|
};
|
|
|
|
extern unsigned int size_overflow_function_transform(struct cgraph_node *node);
|
|
extern tree handle_fnptr_assign(const_gimple stmt);
|
|
|
|
|
|
// size_overflow_transform_core.c
|
|
extern tree cast_to_new_size_overflow_type(struct visited *visited, gimple stmt, tree rhs, tree size_overflow_type, bool before);
|
|
extern tree get_size_overflow_type(struct visited *visited, const_gimple stmt, const_tree node);
|
|
extern tree expand(interesting_stmts_t expand_from, tree lhs);
|
|
extern void check_size_overflow(interesting_stmts_t expand_from, gimple stmt, tree size_overflow_type, tree cast_rhs, tree rhs, bool before);
|
|
extern tree dup_assign(struct visited *visited, gassign *oldstmt, const_tree node, tree rhs1, tree rhs2, tree __unused rhs3);
|
|
extern tree create_assign(struct visited *visited, gimple oldstmt, tree rhs1, bool before);
|
|
|
|
|
|
// remove_unnecessary_dup.c
|
|
extern struct opt_pass *make_remove_unnecessary_dup_pass(void);
|
|
extern void insert_cast_expr(struct visited *visited, gassign *stmt, enum intentional_overflow_type type);
|
|
extern bool skip_expr_on_double_type(const gassign *stmt);
|
|
extern void create_up_and_down_cast(struct visited *visited, gassign *use_stmt, tree orig_type, tree rhs);
|
|
|
|
|
|
// size_overflow_ipa.c
|
|
struct walk_use_def_data {
|
|
next_interesting_function_t parent;
|
|
next_interesting_function_t next_cnodes_head;
|
|
gimple_set *visited;
|
|
};
|
|
|
|
extern const char* get_decl_context(const_tree decl);
|
|
extern void add_to_global_next_interesting_function(next_interesting_function_t new_entry);
|
|
extern bool has_next_interesting_function_vec(next_interesting_function_t target, next_interesting_function_t next_node);
|
|
extern void push_child(next_interesting_function_t parent, next_interesting_function_t child);
|
|
extern struct cgraph_node *get_cnode(const_tree fndecl);
|
|
extern next_interesting_function_t global_next_interesting_function[GLOBAL_NIFN_LEN];
|
|
extern next_interesting_function_t get_global_next_interesting_function_entry(struct fn_raw_data *raw_data);
|
|
extern next_interesting_function_t get_global_next_interesting_function_entry_with_hash(struct fn_raw_data *raw_data);
|
|
extern void size_overflow_register_hooks(void);
|
|
#if BUILDING_GCC_VERSION >= 4009
|
|
extern opt_pass *make_size_overflow_pass(void);
|
|
#else
|
|
extern struct opt_pass *make_size_overflow_pass(void);
|
|
#endif
|
|
extern void size_overflow_node_removal_hook(struct cgraph_node *node, void *data);
|
|
extern next_interesting_function_t get_and_create_next_node_from_global_next_nodes(struct fn_raw_data *raw_data, next_interesting_function_t orig_next_node);
|
|
extern next_interesting_function_t create_new_next_interesting_decl(struct fn_raw_data *raw_data, next_interesting_function_t orig_next_node);
|
|
extern next_interesting_function_t create_new_next_interesting_entry(struct fn_raw_data *raw_data, next_interesting_function_t orig_next_node);
|
|
|
|
|
|
// size_overflow_lto.c
|
|
extern void size_overflow_read_summary(void);
|
|
extern void size_overflow_read_optimization_summary(void);
|
|
#if BUILDING_GCC_VERSION >= 4008
|
|
extern void size_overflow_write_summary(void);
|
|
extern void size_overflow_write_optimization_summary(void);
|
|
#elif BUILDING_GCC_VERSION >= 4006
|
|
extern void size_overflow_write_summary(cgraph_node_set set, varpool_node_set vset);
|
|
extern void size_overflow_write_optimization_summary(cgraph_node_set set, varpool_node_set vset);
|
|
#else
|
|
extern void size_overflow_write_summary(cgraph_node_set set);
|
|
extern void size_overflow_write_optimization_summary(cgraph_node_set set);
|
|
#endif
|
|
|
|
// size_overflow_fnptrs.c
|
|
extern void handle_function_ptr_ret(struct walk_use_def_data *use_def_data, const_tree fn_ptr);
|
|
extern void check_local_variables(next_interesting_function_t next_node);
|
|
extern void check_global_variables(next_interesting_function_t cur_global);
|
|
extern next_interesting_function_t get_and_create_next_node_from_global_next_nodes_fnptr(const_tree fn_ptr, struct fn_raw_data *raw_data);
|
|
|
|
|
|
// size_overflow_debug.c
|
|
extern void __unused print_intentional_mark(enum intentional_mark mark);
|
|
extern unsigned int __unused size_overflow_dump_function(FILE *file, struct cgraph_node *node);
|
|
extern void __unused print_next_interesting_functions_chain(next_interesting_function_t head, bool only_this);
|
|
extern void __unused print_global_next_interesting_functions(void);
|
|
extern void __unused print_children_chain_list(next_interesting_function_t next_node);
|
|
extern void __unused print_all_next_node_children_chain_list(next_interesting_function_t next_node);
|
|
extern const char * __unused print_so_mark_name(enum size_overflow_mark mark);
|
|
extern const char * __unused print_intentional_mark_name(enum intentional_mark mark);
|
|
extern void __unused print_next_interesting_function(next_interesting_function_t node);
|
|
extern void __unused print_raw_data(struct fn_raw_data *data);
|
|
|
|
#endif
|