From d1e2a107d2046cd27b061d20881d3b49c24c561a Mon Sep 17 00:00:00 2001 From: David McKinney Date: Tue, 11 Sep 2018 19:49:49 +0000 Subject: [PATCH 1/1] More gcc-8 plugin fixes --- scripts/gcc-plugins/checker_plugin.c | 44 ++++++------- scripts/gcc-plugins/constify_plugin.c | 20 +++++- scripts/gcc-plugins/gcc-common.h | 66 +++++++++++++++---- scripts/gcc-plugins/initify_plugin.c | 23 +++++-- scripts/gcc-plugins/latent_entropy_plugin.c | 9 ++- scripts/gcc-plugins/randomize_layout_plugin.c | 42 ++++++++++-- .../gcc-plugins/rap_plugin/rap_fptr_pass.c | 2 +- scripts/gcc-plugins/rap_plugin/rap_plugin.c | 11 +++- scripts/gcc-plugins/rap_plugin/rap_ret_pass.c | 4 +- .../intentional_overflow.c | 45 ++++++++++--- .../remove_unnecessary_dup.c | 8 +-- .../size_overflow_plugin.c | 22 +++++-- .../size_overflow_transform_core.c | 38 +++++++---- scripts/gcc-plugins/stackleak_plugin.c | 15 ++++- scripts/gcc-plugins/structleak_plugin.c | 9 ++- 15 files changed, 273 insertions(+), 85 deletions(-) diff --git a/scripts/gcc-plugins/checker_plugin.c b/scripts/gcc-plugins/checker_plugin.c index c16753c34967..624a376f6f76 100644 --- a/scripts/gcc-plugins/checker_plugin.c +++ b/scripts/gcc-plugins/checker_plugin.c @@ -19,11 +19,11 @@ #include "gcc-common.h" extern void c_register_addr_space (const char *str, addr_space_t as); -extern enum machine_mode default_addr_space_pointer_mode (addr_space_t); -extern enum machine_mode default_addr_space_address_mode (addr_space_t); -extern bool default_addr_space_valid_pointer_mode(enum machine_mode mode, addr_space_t as); -extern bool default_addr_space_legitimate_address_p(enum machine_mode mode, rtx mem, bool strict, addr_space_t as); -extern rtx default_addr_space_legitimize_address(rtx x, rtx oldx, enum machine_mode mode, addr_space_t as); +extern SCALAR_INT_MODE default_addr_space_pointer_mode (addr_space_t); +extern SCALAR_INT_MODE default_addr_space_address_mode (addr_space_t); +extern bool default_addr_space_valid_pointer_mode(SCALAR_INT_MODE mode, addr_space_t as); +extern bool default_addr_space_legitimate_address_p(MACHINE_MODE mode, rtx mem, bool strict, addr_space_t as); +extern rtx default_addr_space_legitimize_address(rtx x, rtx oldx, MACHINE_MODE mode, addr_space_t as); __visible int plugin_is_GPL_compatible; @@ -44,27 +44,27 @@ static struct plugin_info checker_plugin_info = { #define ADDR_SPACE_RCU 0 #define ADDR_SPACE_FORCE_RCU 0 -static enum machine_mode checker_addr_space_pointer_mode(addr_space_t addrspace) +static SCALAR_INT_MODE checker_addr_space_pointer_mode(addr_space_t addrspace) { return default_addr_space_pointer_mode(ADDR_SPACE_GENERIC); } -static enum machine_mode checker_addr_space_address_mode(addr_space_t addrspace) +static SCALAR_INT_MODE checker_addr_space_address_mode(addr_space_t addrspace) { return default_addr_space_address_mode(ADDR_SPACE_GENERIC); } -static bool checker_addr_space_valid_pointer_mode(enum machine_mode mode, addr_space_t as) +static bool checker_addr_space_valid_pointer_mode(SCALAR_INT_MODE mode, addr_space_t as) { return default_addr_space_valid_pointer_mode(mode, as); } -static bool checker_addr_space_legitimate_address_p(enum machine_mode mode, rtx mem, bool strict, addr_space_t as) +static bool checker_addr_space_legitimate_address_p(MACHINE_MODE mode, rtx mem, bool strict, addr_space_t as) { return default_addr_space_legitimate_address_p(mode, mem, strict, ADDR_SPACE_GENERIC); } -static rtx checker_addr_space_legitimize_address(rtx x, rtx oldx, enum machine_mode mode, addr_space_t as) +static rtx checker_addr_space_legitimize_address(rtx x, rtx oldx, MACHINE_MODE mode, addr_space_t as) { return default_addr_space_legitimize_address(x, oldx, mode, as); } @@ -173,21 +173,19 @@ static tree handle_context_attribute(tree *node, tree name, tree args, int flags return NULL_TREE; } -static struct attribute_spec context_attr = { - .name = "context", - .min_length = 2, - .max_length = 3, - .decl_required = true, - .type_required = false, - .function_type_required = false, - .handler = handle_context_attribute, -#if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = true -#endif -}; +static struct attribute_spec context_attr = { }; static void register_attributes(void *event_data, void *data) { + attr.name = "context"; + context_attr.min_length = 2; + context_attr.max_length = 3; + context_attr.decl_required = true; + context_attr.handler = handle_context_attribute; +#if BUILDING_GCC_VERSION >= 4007 + context_attr.affects_type_identity = true; +#endif + register_attribute(&context_attr); } @@ -280,7 +278,7 @@ static basic_block verify_context_before(gimple_stmt_iterator *gsi, tree context cond_bb = e->src; join_bb = e->dest; e->flags = EDGE_FALSE_VALUE; - e->probability = REG_BR_PROB_BASE; + e->probability = probability(REG_BR_PROB_BASE); true_bb = create_empty_bb(EXIT_BLOCK_PTR_FOR_FN(cfun)->prev_bb); make_edge(cond_bb, true_bb, EDGE_TRUE_VALUE); diff --git a/scripts/gcc-plugins/constify_plugin.c b/scripts/gcc-plugins/constify_plugin.c index 42f22097fb16..54680c573b48 100644 --- a/scripts/gcc-plugins/constify_plugin.c +++ b/scripts/gcc-plugins/constify_plugin.c @@ -307,10 +307,17 @@ static struct attribute_spec no_const_attr = { .decl_required = false, .type_required = false, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = true, .handler = handle_no_const_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 + .handler = handle_no_const_attribute, .affects_type_identity = true -#endif +#else + .handler = handle_no_const_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static struct attribute_spec do_const_attr = { @@ -320,10 +327,17 @@ static struct attribute_spec do_const_attr = { .decl_required = false, .type_required = false, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = true, .handler = handle_do_const_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = true -#endif + .handler = handle_do_const_attribute, + .affects_type_identity = true, +#else + .handler = handle_do_const_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static void register_attributes(void *event_data, void *data) diff --git a/scripts/gcc-plugins/gcc-common.h b/scripts/gcc-plugins/gcc-common.h index 8099dd1793ca..00a203f88a43 100644 --- a/scripts/gcc-plugins/gcc-common.h +++ b/scripts/gcc-plugins/gcc-common.h @@ -104,6 +104,10 @@ #include "predict.h" #include "ipa-utils.h" +#if BUILDING_GCC_VERSION >= 8000 +#include "stringpool.h" +#endif + #if BUILDING_GCC_VERSION >= 4009 #include "attribs.h" #include "varasm.h" @@ -430,13 +434,6 @@ static inline struct cgraph_node *cgraph_alias_target(struct cgraph_node *n) } #endif -#if BUILDING_GCC_VERSION >= 4007 && BUILDING_GCC_VERSION <= 4009 -#define cgraph_create_edge(caller, callee, call_stmt, count, freq, nest) \ - cgraph_create_edge((caller), (callee), (call_stmt), (count), (freq)) -#define cgraph_create_edge_including_clones(caller, callee, old_call_stmt, call_stmt, count, freq, nest, reason) \ - cgraph_create_edge_including_clones((caller), (callee), (old_call_stmt), (call_stmt), (count), (freq), (reason)) -#endif - #if BUILDING_GCC_VERSION <= 4008 #define ENTRY_BLOCK_PTR_FOR_FN(FN) ENTRY_BLOCK_PTR_FOR_FUNCTION(FN) #define EXIT_BLOCK_PTR_FOR_FN(FN) EXIT_BLOCK_PTR_FOR_FUNCTION(FN) @@ -785,10 +782,23 @@ static inline const char *get_decl_section_name(const_tree decl) #define varpool_get_node(decl) varpool_node::get(decl) #define dump_varpool_node(file, node) (node)->dump(file) -#define cgraph_create_edge(caller, callee, call_stmt, count, freq, nest) \ - (caller)->create_edge((callee), (call_stmt), (count), (freq)) -#define cgraph_create_edge_including_clones(caller, callee, old_call_stmt, call_stmt, count, freq, nest, reason) \ - (caller)->create_edge_including_clones((callee), (old_call_stmt), (call_stmt), (count), (freq), (reason)) +#if BUILDING_GCC_VERSION >= 8000 +#define cgraph_create_edge(caller, callee, call_stmt, count, freq) \ + (caller)->create_edge((callee), (call_stmt), (count)) + +#define cgraph_create_edge_including_clones(caller, callee, \ + old_call_stmt, call_stmt, count, freq, reason) \ + (caller)->create_edge_including_clones((callee), \ + (old_call_stmt), (call_stmt), (count), (reason)) +#else +#define cgraph_create_edge(caller, callee, call_stmt, count, freq) \ + (caller)->create_edge((callee), (call_stmt), (count), (freq)) + +#define cgraph_create_edge_including_clones(caller, callee, \ + old_call_stmt, call_stmt, count, freq, reason) \ + (caller)->create_edge_including_clones((callee), \ + (old_call_stmt), (call_stmt), (count), (freq), (reason)) +#endif typedef struct cgraph_node *cgraph_node_ptr; typedef struct cgraph_edge *cgraph_edge_p; @@ -1025,4 +1035,38 @@ static inline void debug_gimple_stmt(const_gimple s) get_inner_reference(exp, pbitsize, pbitpos, poffset, pmode, punsignedp, preversep, pvolatilep) #endif +#if BUILDING_GCC_VERSION < 8000 +#define E_HImode HImode +#define E_SImode SImode +#define E_DImode DImode +#define E_TImode TImode +#define E_QImode QImode +#endif + +#if BUILDING_GCC_VERSION < 5000 +#define SCALAR_INT_MODE enum machine_mode +#define MACHINE_MODE enum machine_mode +#elif BUILDING_GCC_VERSION < 8000 +#define SCALAR_INT_MODE machine_mode +#define MACHINE_MODE machine_mode +#else +#define SCALAR_INT_MODE scalar_int_mode +#define MACHINE_MODE machine_mode #endif + +#if BUILDING_GCC_VERSION >= 8000 +#define empty_string "" + +static inline profile_probability probability(int prob) +{ + return profile_probability::from_reg_br_prob_base(prob); +} +#else +static inline int probability(int prob) +{ + return prob; +} +#endif + +#endif + diff --git a/scripts/gcc-plugins/initify_plugin.c b/scripts/gcc-plugins/initify_plugin.c index 1c8d204f9cd3..2185a85d1081 100644 --- a/scripts/gcc-plugins/initify_plugin.c +++ b/scripts/gcc-plugins/initify_plugin.c @@ -359,10 +359,17 @@ static struct attribute_spec nocapture_attr = { .decl_required = true, .type_required = false, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = false, .handler = handle_nocapture_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = false -#endif + .handler = handle_nocapture_attribute, + .affects_type_identity = false, +#else + .handler = handle_nocapture_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static struct attribute_spec unverified_nocapture_attr = { @@ -373,9 +380,17 @@ static struct attribute_spec unverified_nocapture_attr = { .type_required = false, .function_type_required = false, .handler = handle_unverified_nocapture_attribute, +#if BUILDING_GCC_VERSION >= 8000 +#else + .affects_type_identity = false, + .handler = handle_unverified_nocapture_attribute, #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = false -#endif + .handler = handle_unverified_nocapture_attribute, + .affects_type_identity = false, +#else + .handler = handle_unverified_nocapture_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static void register_attributes(void __unused *event_data, void __unused *data) diff --git a/scripts/gcc-plugins/latent_entropy_plugin.c b/scripts/gcc-plugins/latent_entropy_plugin.c index 1de194b63cdd..27f2a8a333b9 100644 --- a/scripts/gcc-plugins/latent_entropy_plugin.c +++ b/scripts/gcc-plugins/latent_entropy_plugin.c @@ -250,10 +250,17 @@ static struct attribute_spec latent_entropy_attr = { .decl_required = true, .type_required = false, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = false, .handler = handle_latent_entropy_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 + .handler = handle_latent_entropy_attribute, .affects_type_identity = false -#endif +#else + .handler = handle_latent_entropy_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static void register_attributes(void *event_data __unused, void *data __unused) diff --git a/scripts/gcc-plugins/randomize_layout_plugin.c b/scripts/gcc-plugins/randomize_layout_plugin.c index bbb2c3612b1d..937b852a6cf8 100644 --- a/scripts/gcc-plugins/randomize_layout_plugin.c +++ b/scripts/gcc-plugins/randomize_layout_plugin.c @@ -568,10 +568,17 @@ static struct attribute_spec randomize_layout_attr = { // need type declaration .type_required = true, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = true, .handler = handle_randomize_layout_attr, +#else #if BUILDING_GCC_VERSION >= 4007 + .handler = handle_randomize_layout_attr, .affects_type_identity = true -#endif +#else + .handler = handle_randomize_layout_attr, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static struct attribute_spec no_randomize_layout_attr = { @@ -583,10 +590,17 @@ static struct attribute_spec no_randomize_layout_attr = { // need type declaration .type_required = true, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = true, .handler = handle_randomize_layout_attr, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = true -#endif + .handler = handle_randomize_layout_attr, + .affects_type_identity = true, +#else + .handler = handle_randomize_layout_attr, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static struct attribute_spec randomize_considered_attr = { @@ -598,10 +612,17 @@ static struct attribute_spec randomize_considered_attr = { // need type declaration .type_required = true, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = false, .handler = handle_randomize_considered_attr, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = false -#endif + .handler = handle_randomize_considered_attr, + .affects_type_identity = false, +#else + .handler = handle_randomize_considered_attr, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static struct attribute_spec randomize_performed_attr = { @@ -613,10 +634,17 @@ static struct attribute_spec randomize_performed_attr = { // need type declaration .type_required = true, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = false, .handler = handle_randomize_performed_attr, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = false -#endif + .handler = handle_randomize_performed_attr, + .affects_type_identity = false, +#else + .handler = handle_randomize_performed_attr, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static void register_attributes(void *event_data, void *data) diff --git a/scripts/gcc-plugins/rap_plugin/rap_fptr_pass.c b/scripts/gcc-plugins/rap_plugin/rap_fptr_pass.c index d7dba8b4caa6..3db7283e6ee9 100644 --- a/scripts/gcc-plugins/rap_plugin/rap_fptr_pass.c +++ b/scripts/gcc-plugins/rap_plugin/rap_fptr_pass.c @@ -137,7 +137,7 @@ static void rap_instrument_fptr(gimple_stmt_iterator *gsi) cond_bb = e->src; join_bb = e->dest; e->flags = EDGE_FALSE_VALUE; - e->probability = REG_BR_PROB_BASE; + e->probability = probability(REG_BR_PROB_BASE); true_bb = create_empty_bb(EXIT_BLOCK_PTR_FOR_FN(cfun)->prev_bb); make_edge(cond_bb, true_bb, EDGE_TRUE_VALUE | EDGE_PRESERVE); diff --git a/scripts/gcc-plugins/rap_plugin/rap_plugin.c b/scripts/gcc-plugins/rap_plugin/rap_plugin.c index 713073ebe0ed..56c05aea8d6f 100644 --- a/scripts/gcc-plugins/rap_plugin/rap_plugin.c +++ b/scripts/gcc-plugins/rap_plugin/rap_plugin.c @@ -581,10 +581,17 @@ static struct attribute_spec rap_hash_attr = { .decl_required = false, .type_required = true, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = true, .handler = handle_rap_hash_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = true -#endif + .handler = handle_rap_hash_attribute, + .affects_type_identity = true, +#else + .handler = handle_rap_hash_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static void register_attributes(void *event_data __unused, void *data __unused) diff --git a/scripts/gcc-plugins/rap_plugin/rap_ret_pass.c b/scripts/gcc-plugins/rap_plugin/rap_ret_pass.c index 3575980c3d8e..e463134a256e 100644 --- a/scripts/gcc-plugins/rap_plugin/rap_ret_pass.c +++ b/scripts/gcc-plugins/rap_plugin/rap_ret_pass.c @@ -109,7 +109,7 @@ static void check_retaddr(gimple_stmt_iterator *gsi, tree new_retaddr) cond_bb = e->src; join_bb = e->dest; e->flags = EDGE_FALSE_VALUE; - e->probability = REG_BR_PROB_BASE; + e->probability = probability(REG_BR_PROB_BASE); true_bb = create_empty_bb(join_bb); make_edge(cond_bb, true_bb, EDGE_TRUE_VALUE | EDGE_PRESERVE); @@ -342,9 +342,11 @@ static unsigned int rap_mark_retloc_execute(void) emit_label_before(label1, insn); LABEL_NUSES(label1)++; +#if BUILDING_GCC_VERSION >= 4007 && BUILDING_GCC_VERSION < 8000 do { insn = NEXT_INSN(insn); } while (GET_CODE(insn) == NOTE && NOTE_KIND(insn) == NOTE_INSN_CALL_ARG_LOCATION); +#endif emit_label_before(label2, insn); LABEL_NUSES(label2)++; } diff --git a/scripts/gcc-plugins/size_overflow_plugin/intentional_overflow.c b/scripts/gcc-plugins/size_overflow_plugin/intentional_overflow.c index 26899bd89cf7..789bb9ed6465 100644 --- a/scripts/gcc-plugins/size_overflow_plugin/intentional_overflow.c +++ b/scripts/gcc-plugins/size_overflow_plugin/intentional_overflow.c @@ -535,16 +535,16 @@ static bool is_lt_signed_type_max(const_tree rhs) return true; switch (TYPE_MODE(type)) { - case QImode: + case E_QImode: new_type = intQI_type_node; break; - case HImode: + case E_HImode: new_type = intHI_type_node; break; - case SImode: + case E_SImode: new_type = intSI_type_node; break; - case DImode: + case E_DImode: new_type = intDI_type_node; break; default: @@ -628,6 +628,33 @@ tree handle_intentional_overflow(interesting_stmts_t expand_from, bool check_ove return create_assign(expand_from->visited, stmt, lhs, AFTER_STMT); } +static bool compare_bitsize_le(machine_mode arg1, machine_mode arg2) +{ +#if BUILDING_GCC_VERSION >= 8000 + return maybe_le(GET_MODE_BITSIZE(arg1), GET_MODE_BITSIZE(arg2)); +#else + return (GET_MODE_BITSIZE(arg1) <= GET_MODE_BITSIZE(arg2)); +#endif +} + +static bool compare_bitsize_ge(machine_mode arg1, machine_mode arg2) +{ +#if BUILDING_GCC_VERSION >= 8000 + return maybe_ne(GET_MODE_BITSIZE(arg1), GET_MODE_BITSIZE(arg2)); +#else + return (GET_MODE_BITSIZE(arg1) != GET_MODE_BITSIZE(arg2)); +#endif +} + +static bool compare_bitsize_ne(machine_mode arg1, machine_mode arg2) +{ +#if BUILDING_GCC_VERSION >= 8000 + return maybe_ne(GET_MODE_BITSIZE(arg1), GET_MODE_BITSIZE(arg2)); +#else + return (GET_MODE_BITSIZE(arg1) != GET_MODE_BITSIZE(arg2)); +#endif +} + static bool is_subtraction_special(struct visited *visited, const gassign *stmt) { gimple rhs1_def_stmt, rhs2_def_stmt; @@ -657,9 +684,9 @@ static bool is_subtraction_special(struct visited *visited, const gassign *stmt) rhs2_def_stmt_rhs1_mode = TYPE_MODE(TREE_TYPE(rhs2_def_stmt_rhs1)); rhs1_def_stmt_lhs_mode = TYPE_MODE(TREE_TYPE(rhs1_def_stmt_lhs)); rhs2_def_stmt_lhs_mode = TYPE_MODE(TREE_TYPE(rhs2_def_stmt_lhs)); - if (GET_MODE_BITSIZE(rhs1_def_stmt_rhs1_mode) <= GET_MODE_BITSIZE(rhs1_def_stmt_lhs_mode)) + if (compare_bitsize_le(rhs1_def_stmt_rhs1_mode, rhs1_def_stmt_lhs_mode)) return false; - if (GET_MODE_BITSIZE(rhs2_def_stmt_rhs1_mode) <= GET_MODE_BITSIZE(rhs2_def_stmt_lhs_mode)) + if (compare_bitsize_le(rhs2_def_stmt_rhs1_mode, rhs2_def_stmt_lhs_mode)) return false; pointer_set_insert(visited->no_cast_check, rhs1_def_stmt); @@ -922,7 +949,7 @@ void unsigned_signed_cast_intentional_overflow(struct visited *visited, gassign if (!(TYPE_UNSIGNED(rhs_type) && !TYPE_UNSIGNED(lhs_type))) return; - if (GET_MODE_BITSIZE(TYPE_MODE(rhs_type)) != GET_MODE_BITSIZE(TYPE_MODE(lhs_type))) + if (compare_bitsize_ne(TYPE_MODE(rhs_type), TYPE_MODE(lhs_type))) return; use_num = uses_num(rhs); if (use_num != 1) @@ -971,7 +998,7 @@ static bool is_short_cast_neg(const_tree rhs) return false; cast_rhs = gimple_assign_rhs1(cast_stmt); - if (GET_MODE_BITSIZE(TYPE_MODE(TREE_TYPE(cast_rhs))) >= GET_MODE_BITSIZE(TYPE_MODE(TREE_TYPE(rhs)))) + if (compare_bitsize_ge(TYPE_MODE(TREE_TYPE(cast_rhs)), TYPE_MODE(TREE_TYPE(rhs)))) return false; neg_cast_stmt = get_def_stmt(cast_rhs); @@ -1013,7 +1040,7 @@ bool neg_short_add_intentional_overflow(gassign *unary_stmt) if (!cast_stmt || !gimple_assign_cast_p(cast_stmt)) return false; cast_rhs = gimple_assign_rhs1(cast_stmt); - if (GET_MODE_BITSIZE(TYPE_MODE(TREE_TYPE(cast_rhs))) <= GET_MODE_BITSIZE(TYPE_MODE(TREE_TYPE(rhs1)))) + if (compare_bitsize_le(TYPE_MODE(TREE_TYPE(cast_rhs)), TYPE_MODE(TREE_TYPE(rhs1)))) return false; // one or two plus expressions diff --git a/scripts/gcc-plugins/size_overflow_plugin/remove_unnecessary_dup.c b/scripts/gcc-plugins/size_overflow_plugin/remove_unnecessary_dup.c index 5c268627352e..3c74ee921093 100644 --- a/scripts/gcc-plugins/size_overflow_plugin/remove_unnecessary_dup.c +++ b/scripts/gcc-plugins/size_overflow_plugin/remove_unnecessary_dup.c @@ -76,16 +76,16 @@ static tree get_proper_unsigned_half_type(const_tree node) type = TREE_TYPE(node); switch (TYPE_MODE(type)) { - case HImode: + case E_HImode: new_type = unsigned_intQI_type_node; break; - case SImode: + case E_SImode: new_type = unsigned_intHI_type_node; break; - case DImode: + case E_DImode: new_type = unsigned_intSI_type_node; break; - case TImode: + case E_TImode: new_type = unsigned_intDI_type_node; break; default: diff --git a/scripts/gcc-plugins/size_overflow_plugin/size_overflow_plugin.c b/scripts/gcc-plugins/size_overflow_plugin/size_overflow_plugin.c index f2571bfd15d5..00fea0e28640 100644 --- a/scripts/gcc-plugins/size_overflow_plugin/size_overflow_plugin.c +++ b/scripts/gcc-plugins/size_overflow_plugin/size_overflow_plugin.c @@ -133,10 +133,17 @@ static struct attribute_spec size_overflow_attr = { .decl_required = true, .type_required = false, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = false, .handler = handle_size_overflow_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = false -#endif + .handler = handle_size_overflow_attribute, + .affects_type_identity = false, +#else + .handler = handle_size_overflow_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static struct attribute_spec intentional_overflow_attr = { @@ -146,10 +153,17 @@ static struct attribute_spec intentional_overflow_attr = { .decl_required = true, .type_required = false, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = false, .handler = handle_intentional_overflow_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 - .affects_type_identity = false -#endif + .handler = handle_intentional_overflow_attribute, + .affects_type_identity = false, +#else + .handler = handle_intentional_overflow_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static void register_attributes(void __unused *event_data, void __unused *data) diff --git a/scripts/gcc-plugins/size_overflow_plugin/size_overflow_transform_core.c b/scripts/gcc-plugins/size_overflow_plugin/size_overflow_transform_core.c index 7b24aea403dc..530df0b53451 100644 --- a/scripts/gcc-plugins/size_overflow_plugin/size_overflow_transform_core.c +++ b/scripts/gcc-plugins/size_overflow_plugin/size_overflow_transform_core.c @@ -37,20 +37,20 @@ tree get_size_overflow_type(struct visited *visited, const_gimple stmt, const_tr return TREE_TYPE(node); switch (TYPE_MODE(type)) { - case QImode: - case HImode: + case E_QImode: + case E_HImode: new_type = size_overflow_type_SI; break; - case SImode: + case E_SImode: new_type = size_overflow_type_DI; break; - case DImode: + case E_DImode: if (LONG_TYPE_SIZE == GET_MODE_BITSIZE(SImode)) new_type = TYPE_UNSIGNED(type) ? unsigned_intDI_type_node : intDI_type_node; else new_type = size_overflow_type_TI; break; - case TImode: + case E_TImode: gcc_assert(!TYPE_UNSIGNED(type)); new_type = size_overflow_type_TI; break; @@ -487,7 +487,7 @@ static void insert_cond_result(interesting_stmts_t expand_from, basic_block bb_t gcc_assert(report_node); frequency = compute_call_stmt_bb_frequency(current_function_decl, bb_true); - edge = cgraph_create_edge(get_cnode(current_function_decl), report_node, func_stmt, bb_true->count, frequency, bb_true->loop_depth); + edge = cgraph_create_edge(get_cnode(current_function_decl), report_node, func_stmt, bb_true->count, frequency); gcc_assert(edge != NULL); } @@ -507,7 +507,7 @@ static void insert_check_size_overflow(interesting_stmts_t expand_from, gimple s cond_bb = e->src; join_bb = e->dest; e->flags = EDGE_FALSE_VALUE; - e->probability = REG_BR_PROB_BASE; + e->probability = probability(REG_BR_PROB_BASE); bb_true = create_empty_bb(cond_bb); make_edge(cond_bb, bb_true, EDGE_TRUE_VALUE); @@ -631,6 +631,24 @@ static bool handle_unsigned_neg_or_bit_not(interesting_stmts_t expand_from, cons return true; } +static bool compare_bitsize_gt(machine_mode arg1, machine_mode arg2) +{ +#if BUILDING_GCC_VERSION >= 8000 + return maybe_gt(GET_MODE_BITSIZE(arg1), GET_MODE_BITSIZE(arg2)); +#else + return (GET_MODE_BITSIZE(arg1) > GET_MODE_BITSIZE(arg2)); +#endif +} + +static bool compare_bitsize_eq(machine_mode arg1, machine_mode arg2) +{ +#if BUILDING_GCC_VERSION >= 8000 + return maybe_eq(GET_MODE_BITSIZE(arg1), GET_MODE_BITSIZE(arg2)); +#else + return (GET_MODE_BITSIZE(arg1) == GET_MODE_BITSIZE(arg2)); +#endif +} + static tree create_cast_overflow_check(interesting_stmts_t expand_from, tree new_rhs1, gassign *stmt) { bool cast_lhs, cast_rhs; @@ -640,8 +658,6 @@ static tree create_cast_overflow_check(interesting_stmts_t expand_from, tree new const_tree rhs_type = TREE_TYPE(rhs); enum machine_mode lhs_mode = TYPE_MODE(lhs_type); enum machine_mode rhs_mode = TYPE_MODE(rhs_type); - unsigned int lhs_size = GET_MODE_BITSIZE(lhs_mode); - unsigned int rhs_size = GET_MODE_BITSIZE(rhs_mode); static bool check_lhs[3][4] = { // ss su us uu @@ -670,10 +686,10 @@ static tree create_cast_overflow_check(interesting_stmts_t expand_from, tree new if (rhs_mode == SImode && !TYPE_UNSIGNED(rhs_type) && (lhs_mode == HImode || lhs_mode == QImode)) return create_assign(expand_from->visited, stmt, lhs, AFTER_STMT); - if (lhs_size > rhs_size) { + if (compare_bitsize_gt(lhs_mode, rhs_mode)) { cast_lhs = check_lhs[0][TYPE_UNSIGNED(rhs_type) + 2 * TYPE_UNSIGNED(lhs_type)]; cast_rhs = check_rhs[0][TYPE_UNSIGNED(rhs_type) + 2 * TYPE_UNSIGNED(lhs_type)]; - } else if (lhs_size == rhs_size) { + } else if (compare_bitsize_eq(lhs_mode, rhs_mode)) { cast_lhs = check_lhs[1][TYPE_UNSIGNED(rhs_type) + 2 * TYPE_UNSIGNED(lhs_type)]; cast_rhs = check_rhs[1][TYPE_UNSIGNED(rhs_type) + 2 * TYPE_UNSIGNED(lhs_type)]; } else { diff --git a/scripts/gcc-plugins/stackleak_plugin.c b/scripts/gcc-plugins/stackleak_plugin.c index f0fdd5e28fdc..3e1710e11121 100644 --- a/scripts/gcc-plugins/stackleak_plugin.c +++ b/scripts/gcc-plugins/stackleak_plugin.c @@ -55,7 +55,7 @@ static void stackleak_check_alloca(gimple_stmt_iterator *gsi) node = cgraph_get_create_node(check_function_decl); gcc_assert(node); frequency = compute_call_stmt_bb_frequency(current_function_decl, bb); - cgraph_create_edge(cgraph_get_node(current_function_decl), node, check_alloca, bb->count, frequency, bb->loop_depth); + cgraph_create_edge(cgraph_get_node(current_function_decl), node, track_stack, bb->count, frequency); } static void stackleak_add_instrumentation(gimple_stmt_iterator *gsi, bool after) @@ -156,6 +156,15 @@ static unsigned int stackleak_tree_instrument_execute(void) return 0; } +static bool large_stack_frame(void) +{ +#if BUILDING_GCC_VERSION >= 8000 + return maybe_ge(get_frame_size(), track_frame_size); +#else + return (get_frame_size() >= track_frame_size); +#endif +} + static unsigned int stackleak_final_execute(void) { rtx_insn *insn, *next; @@ -164,7 +173,7 @@ static unsigned int stackleak_final_execute(void) return 0; // keep calls only if function frame is big enough - if (get_frame_size() >= track_frame_size) + if (large_stack_frame()) return 0; // 1. find pax_track_stack calls @@ -190,7 +199,7 @@ static unsigned int stackleak_final_execute(void) // warning(0, "track_frame_size: %d %ld %d", cfun->calls_alloca, get_frame_size(), track_frame_size); // 2. delete call delete_insn_and_edges(insn); -#if BUILDING_GCC_VERSION >= 4007 +#if BUILDING_GCC_VERSION >= 4007 && BUILDING_GCC_VERSION < 8000 if (GET_CODE(next) == NOTE && NOTE_KIND(next) == NOTE_INSN_CALL_ARG_LOCATION) { insn = next; next = NEXT_INSN(insn); diff --git a/scripts/gcc-plugins/structleak_plugin.c b/scripts/gcc-plugins/structleak_plugin.c index d5609abdeb08..bf0e66142411 100644 --- a/scripts/gcc-plugins/structleak_plugin.c +++ b/scripts/gcc-plugins/structleak_plugin.c @@ -55,10 +55,17 @@ static struct attribute_spec user_attr = { .decl_required = false, .type_required = false, .function_type_required = false, +#if BUILDING_GCC_VERSION >= 8000 + .affects_type_identity = true, .handler = handle_user_attribute, +#else #if BUILDING_GCC_VERSION >= 4007 + .handler = handle_user_attribute, .affects_type_identity = true -#endif +#else + .handler = handle_user_attribute, +#endif /* >= 4007 */ +#endif /* >= 8000 */ }; static void register_attributes(void *event_data __unused, void *data __unused) -- 2.18.0