[email protected] writes:
> From: Indu Bhagat <[email protected]>
>
> Currently, the data type of sanitizer flags is unsigned int, with
> SANITIZE_SHADOW_CALL_STACK (1UL << 31) being highest individual
> enumerator for enum sanitize_code. Use 'sanitize_code_type' data type
> to allow for more distinct instrumentation modes be added when needed.
>
> gcc/ChangeLog:
>
> * flag-types.h (sanitize_code_type): Define.
> * asan.h (sanitize_flags_p): Use 'sanitize_code_type' instead of
> 'unsigned int'.
> * common.opt: Likewise.
> * dwarf2asm.cc (dw2_output_indirect_constant_1): Likewise.
> * opts.cc (find_sanitizer_argument): Likewise.
> (report_conflicting_sanitizer_options): Likewise.
> (parse_sanitizer_options): Likewise.
> (parse_no_sanitize_attribute): Likewise.
> * opts.h (parse_sanitizer_options): Likewise.
> (parse_no_sanitize_attribute): Likewise.
> * tree-cfg.cc (print_no_sanitize_attr_value): Likewise.
> * tree.cc (tree_fits_sanitize_code_type_p): Define.
> (tree_to_sanitize_code_type): Likewise.
> * tree.h (tree_fits_sanitize_code_type_p): Declare.
> (tree_to_sanitize_code_type): Likewise.
>
> gcc/c-family/ChangeLog:
>
> * c-attribs.cc (add_no_sanitize_value): Use 'sanitize_code_type'
> instead of 'unsigned int'.
> (handle_no_sanitize_attribute): Likewise.
> (handle_no_sanitize_address_attribute): Likewise.
> (handle_no_sanitize_thread_attribute): Likewise.
> (handle_no_address_safety_analysis_attribute): Likewise.
> * c-common.h (add_no_sanitize_value): Likewise.
>
> gcc/c/ChangeLog:
>
> * c-parser.cc (c_parser_declaration_or_fndef): Use
> 'sanitize_code_type' instead of 'unsigned int'.
>
> gcc/cp/ChangeLog:
>
> * typeck.cc (get_member_function_from_ptrfunc): Use
> 'sanitize_code_type' instead of 'unsigned int'.
>
> gcc/d/ChangeLog:
>
> * d-attribs.cc (d_handle_no_sanitize_attribute): Use
> 'sanitize_code_type' instead of 'unsigned int'.
>
> Signed-off-by: Claudiu Zissulescu <[email protected]>
> ---
> gcc/asan.h | 5 +++--
> gcc/c-family/c-attribs.cc | 17 +++++++++--------
> gcc/c-family/c-common.h | 2 +-
> gcc/c/c-parser.cc | 4 ++--
> gcc/common.opt | 6 +++---
> gcc/cp/typeck.cc | 2 +-
> gcc/d/d-attribs.cc | 9 +++++----
> gcc/dwarf2asm.cc | 2 +-
> gcc/flag-types.h | 3 +++
> gcc/opts.cc | 26 ++++++++++++++------------
> gcc/opts.h | 9 +++++----
> gcc/tree-cfg.cc | 2 +-
> gcc/tree.cc | 23 +++++++++++++++++++++++
> gcc/tree.h | 4 ++++
> 14 files changed, 75 insertions(+), 39 deletions(-)
>
> diff --git a/gcc/asan.h b/gcc/asan.h
> index 064d4f24823..a24562f67a2 100644
> --- a/gcc/asan.h
> +++ b/gcc/asan.h
> @@ -242,9 +242,10 @@ asan_protect_stack_decl (tree decl)
> remove all flags mentioned in "no_sanitize" of DECL_ATTRIBUTES. */
>
> inline bool
> -sanitize_flags_p (unsigned int flag, const_tree fn = current_function_decl)
> +sanitize_flags_p (sanitize_code_type flag,
> + const_tree fn = current_function_decl)
> {
> - unsigned int result_flags = flag_sanitize & flag;
> + sanitize_code_type result_flags = flag_sanitize & flag;
> if (result_flags == 0)
> return false;
>
> diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc
> index ea04ed7f0d4..f8ba1b1fcd2 100644
> --- a/gcc/c-family/c-attribs.cc
> +++ b/gcc/c-family/c-attribs.cc
> @@ -1409,23 +1409,24 @@ handle_cold_attribute (tree *node, tree name, tree
> ARG_UNUSED (args),
> /* Add FLAGS for a function NODE to no_sanitize_flags in DECL_ATTRIBUTES. */
>
> void
> -add_no_sanitize_value (tree node, unsigned int flags)
> +add_no_sanitize_value (tree node, sanitize_code_type flags)
> {
> tree attr = lookup_attribute ("no_sanitize", DECL_ATTRIBUTES (node));
> if (attr)
> {
> - unsigned int old_value = tree_to_uhwi (TREE_VALUE (attr));
> + sanitize_code_type old_value =
> + tree_to_sanitize_code_type (TREE_VALUE (attr));
> flags |= old_value;
>
> if (flags == old_value)
> return;
>
> - TREE_VALUE (attr) = build_int_cst (unsigned_type_node, flags);
> + TREE_VALUE (attr) = build_int_cst (uint64_type_node, flags);
> }
> else
> DECL_ATTRIBUTES (node)
> = tree_cons (get_identifier ("no_sanitize"),
> - build_int_cst (unsigned_type_node, flags),
> + build_int_cst (uint64_type_node, flags),
> DECL_ATTRIBUTES (node));
> }
>
> @@ -1436,7 +1437,7 @@ static tree
> handle_no_sanitize_attribute (tree *node, tree name, tree args, int,
> bool *no_add_attrs)
> {
> - unsigned int flags = 0;
> + sanitize_code_type flags = 0;
> *no_add_attrs = true;
> if (TREE_CODE (*node) != FUNCTION_DECL)
> {
> @@ -1473,7 +1474,7 @@ handle_no_sanitize_address_attribute (tree *node, tree
> name, tree, int,
> if (TREE_CODE (*node) != FUNCTION_DECL)
> warning (OPT_Wattributes, "%qE attribute ignored", name);
> else
> - add_no_sanitize_value (*node, SANITIZE_ADDRESS);
> + add_no_sanitize_value (*node, (sanitize_code_type) SANITIZE_ADDRESS);
>
> return NULL_TREE;
> }
> @@ -1489,7 +1490,7 @@ handle_no_sanitize_thread_attribute (tree *node, tree
> name, tree, int,
> if (TREE_CODE (*node) != FUNCTION_DECL)
> warning (OPT_Wattributes, "%qE attribute ignored", name);
> else
> - add_no_sanitize_value (*node, SANITIZE_THREAD);
> + add_no_sanitize_value (*node, (sanitize_code_type) SANITIZE_THREAD);
>
> return NULL_TREE;
> }
> @@ -1506,7 +1507,7 @@ handle_no_address_safety_analysis_attribute (tree
> *node, tree name, tree, int,
> if (TREE_CODE (*node) != FUNCTION_DECL)
> warning (OPT_Wattributes, "%qE attribute ignored", name);
> else
> - add_no_sanitize_value (*node, SANITIZE_ADDRESS);
> + add_no_sanitize_value (*node, (sanitize_code_type) SANITIZE_ADDRESS);
>
> return NULL_TREE;
> }
> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> index 675708d2680..a6d70a42bed 100644
> --- a/gcc/c-family/c-common.h
> +++ b/gcc/c-family/c-common.h
> @@ -1713,7 +1713,7 @@ extern enum flt_eval_method
> excess_precision_mode_join (enum flt_eval_method, enum flt_eval_method);
>
> extern int c_flt_eval_method (bool ts18661_p);
> -extern void add_no_sanitize_value (tree node, unsigned int flags);
> +extern void add_no_sanitize_value (tree node, sanitize_code_type flags);
>
> extern void maybe_add_include_fixit (rich_location *, const char *, bool);
> extern void maybe_suggest_missing_token_insertion (rich_location *richloc,
> diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc
> index 0c3e3e2889c..6d01614c6f3 100644
> --- a/gcc/c/c-parser.cc
> +++ b/gcc/c/c-parser.cc
> @@ -2822,7 +2822,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool
> fndef_ok,
> specs->constexpr_p, &richloc);
> /* A parameter is initialized, which is invalid. Don't
> attempt to instrument the initializer. */
> - int flag_sanitize_save = flag_sanitize;
> + sanitize_code_type flag_sanitize_save = flag_sanitize;
> if (nested && !empty_ok)
> flag_sanitize = 0;
> init = c_parser_expr_no_commas (parser, NULL);
> @@ -2911,7 +2911,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool
> fndef_ok,
> specs->constexpr_p, &richloc);
> /* A parameter is initialized, which is invalid. Don't
> attempt to instrument the initializer. */
> - int flag_sanitize_save = flag_sanitize;
> + sanitize_code_type flag_sanitize_save = flag_sanitize;
> if (TREE_CODE (d) == PARM_DECL)
> flag_sanitize = 0;
> init = c_parser_initializer (parser, d);
> diff --git a/gcc/common.opt b/gcc/common.opt
> index 3d65656e658..5277fdfb178 100644
> --- a/gcc/common.opt
> +++ b/gcc/common.opt
> @@ -205,15 +205,15 @@ bool flag_opts_finished
>
> ; What the sanitizer should instrument
> Variable
> -unsigned int flag_sanitize
> +sanitize_code_type flag_sanitize
>
> ; What sanitizers should recover from errors
> Variable
> -unsigned int flag_sanitize_recover = (SANITIZE_UNDEFINED |
> SANITIZE_UNDEFINED_NONDEFAULT | SANITIZE_KERNEL_ADDRESS |
> SANITIZE_KERNEL_HWADDRESS) & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN)
> +sanitize_code_type flag_sanitize_recover = (SANITIZE_UNDEFINED |
> SANITIZE_UNDEFINED_NONDEFAULT | SANITIZE_KERNEL_ADDRESS |
> SANITIZE_KERNEL_HWADDRESS) & ~(SANITIZE_UNREACHABLE | SANITIZE_RETURN)
>
> ; What sanitizers should use __builtin_trap () instead of runtime diagnostics
> Variable
> -unsigned int flag_sanitize_trap
> +sanitize_code_type flag_sanitize_trap
>
> ; Flag whether a prefix has been added to dump_base_name
> Variable
> diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
> index 0bf5ae4e4e2..dae38ff9ca7 100644
> --- a/gcc/cp/typeck.cc
> +++ b/gcc/cp/typeck.cc
> @@ -4286,7 +4286,7 @@ get_member_function_from_ptrfunc (tree
> *instance_ptrptr, tree function,
> idx = build1 (NOP_EXPR, vtable_index_type, e3);
> switch (TARGET_PTRMEMFUNC_VBIT_LOCATION)
> {
> - int flag_sanitize_save;
> + sanitize_code_type flag_sanitize_save;
> case ptrmemfunc_vbit_in_pfn:
> e1 = cp_build_binary_op (input_location,
> BIT_AND_EXPR, idx, integer_one_node,
> diff --git a/gcc/d/d-attribs.cc b/gcc/d/d-attribs.cc
> index 77315dc5d58..53aea5e2e90 100644
> --- a/gcc/d/d-attribs.cc
> +++ b/gcc/d/d-attribs.cc
> @@ -1406,7 +1406,7 @@ d_handle_no_sanitize_attribute (tree *node, tree name,
> tree args, int,
> return NULL_TREE;
> }
>
> - unsigned int flags = 0;
> + sanitize_code_type flags = 0;
> for (; args; args = TREE_CHAIN (args))
> {
> tree id = TREE_VALUE (args);
> @@ -1424,16 +1424,17 @@ d_handle_no_sanitize_attribute (tree *node, tree
> name, tree args, int,
> merge existing flags if no_sanitize was previously handled. */
> if (tree attr = lookup_attribute ("no_sanitize", DECL_ATTRIBUTES (*node)))
> {
> - unsigned int old_value = tree_to_uhwi (TREE_VALUE (attr));
> + sanitize_code_type old_value =
> + tree_to_sanitize_code_type (TREE_VALUE (attr));
> flags |= old_value;
>
> if (flags != old_value)
> - TREE_VALUE (attr) = build_int_cst (d_uint_type, flags);
> + TREE_VALUE (attr) = build_int_cst (d_ulong_type, flags);
> }
> else
> {
> DECL_ATTRIBUTES (*node) = tree_cons (get_identifier ("no_sanitize"),
> - build_int_cst (d_uint_type, flags),
> + build_int_cst (d_ulong_type, flags),
> DECL_ATTRIBUTES (*node));
> }
>
> diff --git a/gcc/dwarf2asm.cc b/gcc/dwarf2asm.cc
> index ec5c684da47..bf7fef32b8d 100644
> --- a/gcc/dwarf2asm.cc
> +++ b/gcc/dwarf2asm.cc
> @@ -1041,7 +1041,7 @@ dw2_output_indirect_constant_1 (const char *sym, tree
> id)
> sym_ref = gen_rtx_SYMBOL_REF (Pmode, sym);
> /* Disable ASan for decl because redzones cause ABI breakage between GCC
> and
> libstdc++ for `.LDFCM*' variables. See PR 78651 for details. */
> - unsigned int save_flag_sanitize = flag_sanitize;
> + sanitize_code_type save_flag_sanitize = flag_sanitize;
> flag_sanitize &= ~(SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS
> | SANITIZE_KERNEL_ADDRESS);
> /* And also temporarily disable -fsection-anchors. These indirect
> constants
> diff --git a/gcc/flag-types.h b/gcc/flag-types.h
> index 9a3cc4a2e16..bf681c3e815 100644
> --- a/gcc/flag-types.h
> +++ b/gcc/flag-types.h
> @@ -350,6 +350,9 @@ enum sanitize_code {
> | SANITIZE_BOUNDS_STRICT
> };
>
> +/* Sanitizer flag type. */
> +typedef uint64_t sanitize_code_type;
> +
> /* Different settings for zeroing subset of registers. */
> namespace zero_regs_flags {
> const unsigned int UNSET = 0;
> diff --git a/gcc/opts.cc b/gcc/opts.cc
> index 6ca1ec7e865..4d311938ce8 100644
> --- a/gcc/opts.cc
> +++ b/gcc/opts.cc
> @@ -988,7 +988,8 @@ vec<const char *> help_option_arguments;
> /* Return the string name describing a sanitizer argument which has been
> provided on the command line and has set this particular flag. */
> const char *
> -find_sanitizer_argument (struct gcc_options *opts, unsigned int flags)
> +find_sanitizer_argument (struct gcc_options *opts,
> + sanitize_code_type flags)
> {
> for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
> {
> @@ -1022,10 +1023,11 @@ find_sanitizer_argument (struct gcc_options *opts,
> unsigned int flags)
> set these flags. */
> static void
> report_conflicting_sanitizer_options (struct gcc_options *opts, location_t
> loc,
> - unsigned int left, unsigned int right)
> + sanitize_code_type left,
> + sanitize_code_type right)
> {
> - unsigned int left_seen = (opts->x_flag_sanitize & left);
> - unsigned int right_seen = (opts->x_flag_sanitize & right);
> + sanitize_code_type left_seen = (opts->x_flag_sanitize & left);
> + sanitize_code_type right_seen = (opts->x_flag_sanitize & right);
> if (left_seen && right_seen)
> {
> const char* left_arg = find_sanitizer_argument (opts, left_seen);
> @@ -2160,9 +2162,9 @@ const struct sanitizer_opts_s sanitizer_opts[] =
> SANITIZER_OPT (pointer-overflow, SANITIZE_POINTER_OVERFLOW, true, true),
> SANITIZER_OPT (builtin, SANITIZE_BUILTIN, true, true),
> SANITIZER_OPT (shadow-call-stack, SANITIZE_SHADOW_CALL_STACK, false,
> false),
> - SANITIZER_OPT (all, ~0U, true, true),
> + SANITIZER_OPT (all, ~0ULL, true, true),
Let's maintain the abstraction by using ~sanitize_code_type (0) instead
of ~0ULL and...
> #undef SANITIZER_OPT
> - { NULL, 0U, 0UL, false, false }
> + { NULL, 0ULL, 0UL, false, false }
sanitize_code_type (0) (or just 0) instead of 0ULL. Same for the other
uses of the same constants.
OK with that change, thanks.
Richard
> };
>
> /* -fzero-call-used-regs= suboptions. */
> @@ -2233,7 +2235,7 @@ get_closest_sanitizer_option (const string_fragment
> &arg,
> {
> /* -fsanitize=all is not valid, so don't offer it. */
> if (code == OPT_fsanitize_
> - && opts[i].flag == ~0U
> + && opts[i].flag == ~0ULL
> && value)
> continue;
>
> @@ -2260,9 +2262,9 @@ get_closest_sanitizer_option (const string_fragment
> &arg,
> adjust previous FLAGS and return new ones. If COMPLAIN is false,
> don't issue diagnostics. */
>
> -unsigned int
> +sanitize_code_type
> parse_sanitizer_options (const char *p, location_t loc, int scode,
> - unsigned int flags, int value, bool complain)
> + sanitize_code_type flags, int value, bool complain)
> {
> enum opt_code code = (enum opt_code) scode;
>
> @@ -2288,7 +2290,7 @@ parse_sanitizer_options (const char *p, location_t loc,
> int scode,
> && memcmp (p, sanitizer_opts[i].name, len) == 0)
> {
> /* Handle both -fsanitize and -fno-sanitize cases. */
> - if (value && sanitizer_opts[i].flag == ~0U)
> + if (value && sanitizer_opts[i].flag == ~0ULL)
> {
> if (code == OPT_fsanitize_)
> {
> @@ -2369,10 +2371,10 @@ parse_sanitizer_options (const char *p, location_t
> loc, int scode,
> /* Parse string values of no_sanitize attribute passed in VALUE.
> Values are separated with comma. */
>
> -unsigned int
> +sanitize_code_type
> parse_no_sanitize_attribute (char *value)
> {
> - unsigned int flags = 0;
> + sanitize_code_type flags = 0;
> unsigned int i;
> char *q = strtok (value, ",");
>
> diff --git a/gcc/opts.h b/gcc/opts.h
> index 382faab9250..66b8949d3e6 100644
> --- a/gcc/opts.h
> +++ b/gcc/opts.h
> @@ -22,6 +22,7 @@ along with GCC; see the file COPYING3. If not see
>
> #include "rich-location.h"
> #include "obstack.h"
> +#include "flag-types.h"
>
> /* Specifies how a switch's VAR_VALUE relates to its FLAG_VAR. */
> enum cl_var_type {
> @@ -432,10 +433,10 @@ extern char *write_langs (unsigned int mask);
> extern void print_ignored_options (void);
> extern void handle_common_deferred_options (void);
> extern void handle_deferred_dump_options (void);
> -unsigned int parse_sanitizer_options (const char *, location_t, int,
> - unsigned int, int, bool);
> +sanitize_code_type parse_sanitizer_options (const char *, location_t, int,
> + sanitize_code_type, int, bool);
>
> -unsigned int parse_no_sanitize_attribute (char *value);
> +sanitize_code_type parse_no_sanitize_attribute (char *value);
> extern bool common_handle_option (struct gcc_options *opts,
> struct gcc_options *opts_set,
> const struct cl_decoded_option *decoded,
> @@ -477,7 +478,7 @@ extern bool opt_enum_arg_to_value (size_t opt_index,
> const char *arg,
> extern const struct sanitizer_opts_s
> {
> const char *const name;
> - unsigned int flag;
> + sanitize_code_type flag;
> size_t len;
> bool can_recover;
> bool can_trap;
> diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc
> index 9a5479a2d38..c1b4980a37e 100644
> --- a/gcc/tree-cfg.cc
> +++ b/gcc/tree-cfg.cc
> @@ -8305,7 +8305,7 @@ dump_default_def (FILE *file, tree def, int spc,
> dump_flags_t flags)
> static void
> print_no_sanitize_attr_value (FILE *file, tree value)
> {
> - unsigned int flags = tree_to_uhwi (value);
> + sanitize_code_type flags = tree_to_sanitize_code_type (value);
> bool first = true;
> for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
> {
> diff --git a/gcc/tree.cc b/gcc/tree.cc
> index 6a055c8c2d0..ae6b8f60a5e 100644
> --- a/gcc/tree.cc
> +++ b/gcc/tree.cc
> @@ -6637,6 +6637,18 @@ tree_fits_poly_uint64_p (const_tree t)
> && wi::fits_uhwi_p (wi::to_widest (t)));
> }
>
> +/* Return true if T is an INTEGER_CST whose numerical value (extended
> according
> + to TYPE_UNSIGNED) fits in a sanitize_code_type (uint64_t). */
> +
> +bool
> +tree_fits_sanitize_code_type_p (const_tree t)
> +{
> + if (t == NULL_TREE)
> + return false;
> + return (TREE_CODE (t) == INTEGER_CST
> + && wi::fits_uhwi_p (wi::to_widest (t)));
> +}
> +
> /* T is an INTEGER_CST whose numerical value (extended according to
> TYPE_UNSIGNED) fits in a signed HOST_WIDE_INT. Return that
> HOST_WIDE_INT. */
> @@ -6659,6 +6671,17 @@ tree_to_uhwi (const_tree t)
> return TREE_INT_CST_LOW (t);
> }
>
> +/* T is an INTEGER_CST whose numerical value (extended according to
> + TYPE_UNSIGNED) fits in a sanitize_code_type. Return that
> + sanitize_code_type. */
> +
> +sanitize_code_type
> +tree_to_sanitize_code_type (const_tree t)
> +{
> + gcc_assert (tree_fits_sanitize_code_type_p (t));
> + return TREE_INT_CST_LOW (t);
> +}
> +
> /* Return the most significant (sign) bit of T. */
>
> int
> diff --git a/gcc/tree.h b/gcc/tree.h
> index e87fa0f81bc..7171c8f9739 100644
> --- a/gcc/tree.h
> +++ b/gcc/tree.h
> @@ -5023,6 +5023,8 @@ extern bool tree_fits_shwi_p (const_tree)
> ATTRIBUTE_PURE;
> extern bool tree_fits_poly_int64_p (const_tree) ATTRIBUTE_PURE;
> extern bool tree_fits_uhwi_p (const_tree) ATTRIBUTE_PURE;
> extern bool tree_fits_poly_uint64_p (const_tree) ATTRIBUTE_PURE;
> +extern bool tree_fits_sanitize_code_type_p (const_tree) ATTRIBUTE_PURE;
> +
>
> extern HOST_WIDE_INT tree_to_shwi (const_tree)
> ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
> @@ -5032,6 +5034,8 @@ extern unsigned HOST_WIDE_INT tree_to_uhwi (const_tree)
> ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
> extern poly_uint64 tree_to_poly_uint64 (const_tree)
> ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
> +extern sanitize_code_type tree_to_sanitize_code_type (const_tree)
> + ATTRIBUTE_NONNULL (1) ATTRIBUTE_PURE;
> #if !defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 4003)
> extern inline __attribute__ ((__gnu_inline__)) HOST_WIDE_INT
> tree_to_shwi (const_tree t)
