On Thu, Jul 10, 2025, 4:12 AM <claudiu.zissulescu-iancule...@oracle.com>
wrote:

> From: Indu Bhagat <indu.bha...@oracle.com>
>
> 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 'uint64_t' data type to allow
> for more distinct instrumentation modes be added when needed.
>


I have not looked yet but does it make sense to use `unsigned
HOST_WIDE_INT` instead of uint64_t? HWI should be the same as uint64_t but
it is more consistent with the rest of gcc.
Plus since tree_to_uhwi is more consistent there.

Thanks,
Andrew



> gcc/ChangeLog:
>
>         * asan.h (sanitize_flags_p): Use 'uint64_t' 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.
>
> gcc/c-family/ChangeLog:
>
>         * c-attribs.cc (add_no_sanitize_value): Likewise.
>         (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): Likewise.
>
> gcc/cp/ChangeLog:
>
>         * typeck.cc (get_member_function_from_ptrfunc): Likewise.
>
> gcc/d/ChangeLog:
>
>         * d-attribs.cc (d_handle_no_sanitize_attribute): Likewise.
>
> Signed-off-by: Claudiu Zissulescu <
> claudiu.zissulescu-iancule...@oracle.com>
> ---
>  gcc/asan.h                |  5 +++--
>  gcc/c-family/c-attribs.cc | 16 ++++++++--------
>  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        |  8 ++++----
>  gcc/dwarf2asm.cc          |  2 +-
>  gcc/opts.cc               | 25 +++++++++++++------------
>  gcc/opts.h                |  8 ++++----
>  gcc/tree-cfg.cc           |  2 +-
>  11 files changed, 41 insertions(+), 39 deletions(-)
>
> diff --git a/gcc/asan.h b/gcc/asan.h
> index 064d4f24823..d4443de4620 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 (uint64_t flag,
> +                 const_tree fn = current_function_decl)
>  {
> -  unsigned int result_flags = flag_sanitize & flag;
> +  uint64_t 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..ddb173e3ccf 100644
> --- a/gcc/c-family/c-attribs.cc
> +++ b/gcc/c-family/c-attribs.cc
> @@ -1409,23 +1409,23 @@ 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, uint64_t flags)
>  {
>    tree attr = lookup_attribute ("no_sanitize", DECL_ATTRIBUTES (node));
>    if (attr)
>      {
> -      unsigned int old_value = tree_to_uhwi (TREE_VALUE (attr));
> +      uint64_t old_value = tree_to_uhwi (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 +1436,7 @@ static tree
>  handle_no_sanitize_attribute (tree *node, tree name, tree args, int,
>                               bool *no_add_attrs)
>  {
> -  unsigned int flags = 0;
> +  uint64_t flags = 0;
>    *no_add_attrs = true;
>    if (TREE_CODE (*node) != FUNCTION_DECL)
>      {
> @@ -1473,7 +1473,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, (uint64_t) SANITIZE_ADDRESS);
>
>    return NULL_TREE;
>  }
> @@ -1489,7 +1489,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, (uint64_t) SANITIZE_THREAD);
>
>    return NULL_TREE;
>  }
> @@ -1506,7 +1506,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, (uint64_t) SANITIZE_ADDRESS);
>
>    return NULL_TREE;
>  }
> diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h
> index 675708d2680..c7623f52ab0 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, uint64_t 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..3d2550ed729 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;
> +                 uint64_t 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;
> +                 uint64_t 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..9d4b6bf4cc2 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
> +uint64_t 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)
> +uint64_t 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
> +uint64_t 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..37e39b3622f 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;
> +         uint64_t 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..df7a93286b3 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;
> +  uint64_t flags = 0;
>    for (; args; args = TREE_CHAIN (args))
>      {
>        tree id = TREE_VALUE (args);
> @@ -1424,16 +1424,16 @@ 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));
> +      uint64_t old_value = tree_to_uhwi (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..138464b164a 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;
> +  uint64_t 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/opts.cc b/gcc/opts.cc
> index 6ca1ec7e865..d00e05f6321 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,
> +                        uint64_t flags)
>  {
>    for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
>      {
> @@ -1022,10 +1023,10 @@ 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)
> +                                     uint64_t left, uint64_t right)
>  {
> -  unsigned int left_seen = (opts->x_flag_sanitize & left);
> -  unsigned int right_seen = (opts->x_flag_sanitize & right);
> +  uint64_t left_seen = (opts->x_flag_sanitize & left);
> +  uint64_t right_seen = (opts->x_flag_sanitize & right);
>    if (left_seen && right_seen)
>      {
>        const char* left_arg = find_sanitizer_argument (opts, left_seen);
> @@ -2160,9 +2161,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),
>  #undef SANITIZER_OPT
> -  { NULL, 0U, 0UL, false, false }
> +  { NULL, 0ULL, 0UL, false, false }
>  };
>
>  /* -fzero-call-used-regs= suboptions.  */
> @@ -2233,7 +2234,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 +2261,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
> +uint64_t
>  parse_sanitizer_options (const char *p, location_t loc, int scode,
> -                        unsigned int flags, int value, bool complain)
> +                        uint64_t flags, int value, bool complain)
>  {
>    enum opt_code code = (enum opt_code) scode;
>
> @@ -2288,7 +2289,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 +2370,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
> +uint64_t
>  parse_no_sanitize_attribute (char *value)
>  {
> -  unsigned int flags = 0;
> +  uint64_t flags = 0;
>    unsigned int i;
>    char *q = strtok (value, ",");
>
> diff --git a/gcc/opts.h b/gcc/opts.h
> index 382faab9250..c0757e44769 100644
> --- a/gcc/opts.h
> +++ b/gcc/opts.h
> @@ -432,10 +432,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);
> +uint64_t parse_sanitizer_options (const char *, location_t, int,
> +                                 uint64_t, int, bool);
>
> -unsigned int parse_no_sanitize_attribute (char *value);
> +uint64_t 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 +477,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;
> +  uint64_t flag;
>    size_t len;
>    bool can_recover;
>    bool can_trap;
> diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc
> index 9a5479a2d38..9526c3000ca 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);
> +  uint64_t flags = tree_to_uhwi (value);
>    bool first = true;
>    for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
>      {
> --
> 2.50.0
>
>

Reply via email to