From nobody Wed Sep 17 16:00:52 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7E896C4332F for ; Mon, 19 Dec 2022 05:55:52 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231181AbiLSFzu (ORCPT ); Mon, 19 Dec 2022 00:55:50 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34150 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230484AbiLSFzo (ORCPT ); Mon, 19 Dec 2022 00:55:44 -0500 Received: from mail-pg1-x530.google.com (mail-pg1-x530.google.com [IPv6:2607:f8b0:4864:20::530]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 562B7B1; Sun, 18 Dec 2022 21:55:42 -0800 (PST) Received: by mail-pg1-x530.google.com with SMTP id 7so432236pga.1; Sun, 18 Dec 2022 21:55:42 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from:from:to :cc:subject:date:message-id:reply-to; bh=xjYjpB0mdpoS0QPDN63hP2X3k7rFnBva/pL54tIDB7M=; b=IGiLREpo03nd1mOJwn3H86s/4jpj9RFtgmO7pVCUcKaXvB/763+/fs+FDv5LiyNYak JZUn0IfJRnGOO3u1Mh/Rl4H7DOpRRIngvl7TbbK/jORt/48Y0/LzE28Y/sY/pXV9yVrg RuEMmRVMtu5hE5SvHVo4OU3jpK2BJyDxpSZpgaY9dR8DnnVgW9DhP22/ags9qGPET5u7 yke+vtf0BGqDCV8nKm8Vp5GKrj2a9bLQ4dqDglmloDj9EMPW0WxSYprcYLB7nkKaTE+8 Ku0/0AvOljFPlzOKagMgPb05EWpn3hSpGbD1ePTRFEpkI4oSsOjOYAz+pQIo6Zj6gScj GVdg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=xjYjpB0mdpoS0QPDN63hP2X3k7rFnBva/pL54tIDB7M=; b=cByIAM34ywGoyAmgZXVtYVzAqPr0VVVYsk3MopdsP6OSrl56Lc3Gnr5P0Kq5A7apx4 sP6GM8bWeoVqaM6WKse+TeZFK+tjcEc4Rzk/gL0KjEQgGpb3mjwhWZrcaiEEAqGa62yC NOgxhcHYQ8xAabaFeGFaXci0E9itrB9qT7gDmajECeoymOv4521+7vkZgFd0d+3kJ0g5 8uB7k8K6yQPDFn0QKyhcGHOduGgAd6EehwWjxv7Ri4NCKDo/PyVT24WZmiTI0AXr6Y3n 9Pw68I4vinNSIl/VrExJg5Bng7XziGWBl1kpI9ujM9Wn6INEZZDhdUsDsaozIN8Q8ycf S0Hw== X-Gm-Message-State: ANoB5pk6chhkllucygJB/VMPsoONiuXG9AHrRMDmzML97BaPsFBAM2Z5 WvQCFXAezL1P+bBTgNo+7yY= X-Google-Smtp-Source: AA0mqf5MfPpYJKDV/7PiN+/CxjwXpTaqxF5QDS6Kr3/6TLtwd6PIw4MV6JDcS8Ii2zotw1Cw5Kdzpg== X-Received: by 2002:a05:6a00:10d5:b0:572:6d6b:2297 with SMTP id d21-20020a056a0010d500b005726d6b2297mr49400591pfu.21.1671429341677; Sun, 18 Dec 2022 21:55:41 -0800 (PST) Received: from localhost ([103.152.220.92]) by smtp.gmail.com with ESMTPSA id 193-20020a6217ca000000b00574cf11aaf3sm5525905pfx.208.2022.12.18.21.55.40 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Sun, 18 Dec 2022 21:55:41 -0800 (PST) From: Dan Li To: gcc-patches@gcc.gnu.org, Richard Sandiford , Masahiro Yamada , Michal Marek , Nick Desaulniers , Catalin Marinas , Will Deacon , Sami Tolvanen , Kees Cook , Nathan Chancellor , Tom Rix , Peter Zijlstra , "Paul E. McKenney" , Mark Rutland , Josh Poimboeuf , Frederic Weisbecker , "Eric W. Biederman" , Dan Li , Marco Elver , Christophe Leroy , Song Liu , Andrew Morton , Uros Bizjak , Kumar Kartikeya Dwivedi , Juergen Gross , Luis Chamberlain , Borislav Petkov , Masami Hiramatsu , Dmitry Torokhov , Aaron Tomlin , Kalesh Singh , Yuntao Wang , Changbin Du Cc: linux-kbuild@vger.kernel.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, llvm@lists.linux.dev, linux-hardening@vger.kernel.org Subject: [RFC/RFT 1/3] [PR102768] flag-types.h (enum sanitize_code): Extend sanitize_code to 64 bits to support more features Date: Sun, 18 Dec 2022 21:54:29 -0800 Message-Id: <20221219055431.22596-2-ashimida.1990@gmail.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20221219055431.22596-1-ashimida.1990@gmail.com> References: <20221219055431.22596-1-ashimida.1990@gmail.com> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" 32-bit sanitize_code can no longer accommodate new options, extending it to 64-bit. Signed-off-by: Dan Li gcc/ChangeLog: PR c/102768 * asan.h (sanitize_flags_p): Promote to uint64_t. * common.opt: Likewise. * dwarf2asm.cc (dw2_output_indirect_constant_1): Likewise. * flag-types.h (enum sanitize_code): Likewise. * opt-suggestions.cc (option_proposer::build_option_suggestions): Likewise. * opts.cc (find_sanitizer_argument): Likewise. (report_conflicting_sanitizer_options): Likewise. (get_closest_sanitizer_option): 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. * 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/asan.h | 4 +-- gcc/c-family/c-attribs.cc | 10 +++--- gcc/c-family/c-common.h | 2 +- gcc/c/c-parser.cc | 4 +-- gcc/common.opt | 4 +-- gcc/cp/typeck.cc | 2 +- gcc/dwarf2asm.cc | 2 +- gcc/flag-types.h | 65 ++++++++++++++++++++------------------- gcc/opt-suggestions.cc | 2 +- gcc/opts.cc | 22 ++++++------- gcc/opts.h | 8 ++--- gcc/tree-cfg.cc | 2 +- 12 files changed, 64 insertions(+), 63 deletions(-) diff --git a/gcc/asan.h b/gcc/asan.h index d4ea49cb240..5b98172549b 100644 --- a/gcc/asan.h +++ b/gcc/asan.h @@ -233,9 +233,9 @@ asan_protect_stack_decl (tree decl) remove all flags mentioned in "no_sanitize" of DECL_ATTRIBUTES. */ =20 static inline bool -sanitize_flags_p (unsigned int flag, const_tree fn =3D current_function_de= cl) +sanitize_flags_p (uint64_t flag, const_tree fn =3D current_function_decl) { - unsigned int result_flags =3D flag_sanitize & flag; + uint64_t result_flags =3D flag_sanitize & flag; if (result_flags =3D=3D 0) return false; =20 diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc index 111a33f405a..a73e2364525 100644 --- a/gcc/c-family/c-attribs.cc +++ b/gcc/c-family/c-attribs.cc @@ -1118,23 +1118,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. = */ =20 void -add_no_sanitize_value (tree node, unsigned int flags) +add_no_sanitize_value (tree node, uint64_t flags) { tree attr =3D lookup_attribute ("no_sanitize", DECL_ATTRIBUTES (node)); if (attr) { - unsigned int old_value =3D tree_to_uhwi (TREE_VALUE (attr)); + uint64_t old_value =3D tree_to_uhwi (TREE_VALUE (attr)); flags |=3D old_value; =20 if (flags =3D=3D old_value) return; =20 - TREE_VALUE (attr) =3D build_int_cst (unsigned_type_node, flags); + TREE_VALUE (attr) =3D build_int_cst (long_long_unsigned_type_node, f= lags); } else DECL_ATTRIBUTES (node) =3D tree_cons (get_identifier ("no_sanitize"), - build_int_cst (unsigned_type_node, flags), + build_int_cst (long_long_unsigned_type_node, flags), DECL_ATTRIBUTES (node)); } =20 @@ -1145,7 +1145,7 @@ static tree handle_no_sanitize_attribute (tree *node, tree name, tree args, int, bool *no_add_attrs) { - unsigned int flags =3D 0; + uint64_t flags =3D 0; *no_add_attrs =3D true; if (TREE_CODE (*node) !=3D FUNCTION_DECL) { diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 52a85bfb783..eb91b9703db 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -1500,7 +1500,7 @@ extern enum flt_eval_method excess_precision_mode_join (enum flt_eval_method, enum flt_eval_method); =20 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); =20 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 f679d53706a..9d55ea55fa6 100644 --- a/gcc/c/c-parser.cc +++ b/gcc/c/c-parser.cc @@ -2217,7 +2217,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool= fndef_ok, start_init (NULL_TREE, asm_name, global_bindings_p (), &richloc); /* A parameter is initialized, which is invalid. Don't attempt to instrument the initializer. */ - int flag_sanitize_save =3D flag_sanitize; + uint64_t flag_sanitize_save =3D flag_sanitize; if (nested && !empty_ok) flag_sanitize =3D 0; init =3D c_parser_expr_no_commas (parser, NULL); @@ -2275,7 +2275,7 @@ c_parser_declaration_or_fndef (c_parser *parser, bool= fndef_ok, start_init (d, asm_name, global_bindings_p (), &richloc); /* A parameter is initialized, which is invalid. Don't attempt to instrument the initializer. */ - int flag_sanitize_save =3D flag_sanitize; + uint64_t flag_sanitize_save =3D flag_sanitize; if (TREE_CODE (d) =3D=3D PARM_DECL) flag_sanitize =3D 0; init =3D c_parser_initializer (parser); diff --git a/gcc/common.opt b/gcc/common.opt index 8a0dafc522d..9613c2f8ba0 100644 --- a/gcc/common.opt +++ b/gcc/common.opt @@ -217,11 +217,11 @@ bool flag_opts_finished =20 ; What the sanitizer should instrument Variable -unsigned int flag_sanitize +uint64_t flag_sanitize =20 ; What sanitizers should recover from errors Variable -unsigned int flag_sanitize_recover =3D (SANITIZE_UNDEFINED | SANITIZE_UNDE= FINED_NONDEFAULT | SANITIZE_KERNEL_ADDRESS | SANITIZE_KERNEL_HWADDRESS) & ~= (SANITIZE_UNREACHABLE | SANITIZE_RETURN) +uint64_t flag_sanitize_recover =3D (SANITIZE_UNDEFINED | SANITIZE_UNDEFINE= D_NONDEFAULT | SANITIZE_KERNEL_ADDRESS | SANITIZE_KERNEL_HWADDRESS) & ~(SAN= ITIZE_UNREACHABLE | SANITIZE_RETURN) =20 ; 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 ceb80d9744f..0afaf58d87d 100644 --- a/gcc/cp/typeck.cc +++ b/gcc/cp/typeck.cc @@ -4023,7 +4023,7 @@ get_member_function_from_ptrfunc (tree *instance_ptrp= tr, tree function, idx =3D 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 =3D cp_build_binary_op (input_location, BIT_AND_EXPR, idx, integer_one_node, diff --git a/gcc/dwarf2asm.cc b/gcc/dwarf2asm.cc index 274f574f25e..b54d1935d57 100644 --- a/gcc/dwarf2asm.cc +++ b/gcc/dwarf2asm.cc @@ -1026,7 +1026,7 @@ dw2_output_indirect_constant_1 (const char *sym, tree= id) sym_ref =3D 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 =3D flag_sanitize; + uint64_t save_flag_sanitize =3D flag_sanitize; flag_sanitize &=3D ~(SANITIZE_ADDRESS | SANITIZE_USER_ADDRESS | SANITIZE_KERNEL_ADDRESS); /* And also temporarily disable -fsection-anchors. These indirect const= ants diff --git a/gcc/flag-types.h b/gcc/flag-types.h index 2c8498169e0..0aa51e282fb 100644 --- a/gcc/flag-types.h +++ b/gcc/flag-types.h @@ -287,42 +287,43 @@ enum auto_init_type { /* Different instrumentation modes. */ enum sanitize_code { /* AddressSanitizer. */ - SANITIZE_ADDRESS =3D 1UL << 0, - SANITIZE_USER_ADDRESS =3D 1UL << 1, - SANITIZE_KERNEL_ADDRESS =3D 1UL << 2, + SANITIZE_ADDRESS =3D 1ULL << 0, + SANITIZE_USER_ADDRESS =3D 1ULL << 1, + SANITIZE_KERNEL_ADDRESS =3D 1ULL << 2, /* ThreadSanitizer. */ - SANITIZE_THREAD =3D 1UL << 3, + SANITIZE_THREAD =3D 1ULL << 3, /* LeakSanitizer. */ - SANITIZE_LEAK =3D 1UL << 4, + SANITIZE_LEAK =3D 1ULL << 4, /* UndefinedBehaviorSanitizer. */ - SANITIZE_SHIFT_BASE =3D 1UL << 5, - SANITIZE_SHIFT_EXPONENT =3D 1UL << 6, - SANITIZE_DIVIDE =3D 1UL << 7, - SANITIZE_UNREACHABLE =3D 1UL << 8, - SANITIZE_VLA =3D 1UL << 9, - SANITIZE_NULL =3D 1UL << 10, - SANITIZE_RETURN =3D 1UL << 11, - SANITIZE_SI_OVERFLOW =3D 1UL << 12, - SANITIZE_BOOL =3D 1UL << 13, - SANITIZE_ENUM =3D 1UL << 14, - SANITIZE_FLOAT_DIVIDE =3D 1UL << 15, - SANITIZE_FLOAT_CAST =3D 1UL << 16, - SANITIZE_BOUNDS =3D 1UL << 17, - SANITIZE_ALIGNMENT =3D 1UL << 18, - SANITIZE_NONNULL_ATTRIBUTE =3D 1UL << 19, - SANITIZE_RETURNS_NONNULL_ATTRIBUTE =3D 1UL << 20, - SANITIZE_OBJECT_SIZE =3D 1UL << 21, - SANITIZE_VPTR =3D 1UL << 22, - SANITIZE_BOUNDS_STRICT =3D 1UL << 23, - SANITIZE_POINTER_OVERFLOW =3D 1UL << 24, - SANITIZE_BUILTIN =3D 1UL << 25, - SANITIZE_POINTER_COMPARE =3D 1UL << 26, - SANITIZE_POINTER_SUBTRACT =3D 1UL << 27, - SANITIZE_HWADDRESS =3D 1UL << 28, - SANITIZE_USER_HWADDRESS =3D 1UL << 29, - SANITIZE_KERNEL_HWADDRESS =3D 1UL << 30, + SANITIZE_SHIFT_BASE =3D 1ULL << 5, + SANITIZE_SHIFT_EXPONENT =3D 1ULL << 6, + SANITIZE_DIVIDE =3D 1ULL << 7, + SANITIZE_UNREACHABLE =3D 1ULL << 8, + SANITIZE_VLA =3D 1ULL << 9, + SANITIZE_NULL =3D 1ULL << 10, + SANITIZE_RETURN =3D 1ULL << 11, + SANITIZE_SI_OVERFLOW =3D 1ULL << 12, + SANITIZE_BOOL =3D 1ULL << 13, + SANITIZE_ENUM =3D 1ULL << 14, + SANITIZE_FLOAT_DIVIDE =3D 1ULL << 15, + SANITIZE_FLOAT_CAST =3D 1ULL << 16, + SANITIZE_BOUNDS =3D 1ULL << 17, + SANITIZE_ALIGNMENT =3D 1ULL << 18, + SANITIZE_NONNULL_ATTRIBUTE =3D 1ULL << 19, + SANITIZE_RETURNS_NONNULL_ATTRIBUTE =3D 1ULL << 20, + SANITIZE_OBJECT_SIZE =3D 1ULL << 21, + SANITIZE_VPTR =3D 1ULL << 22, + SANITIZE_BOUNDS_STRICT =3D 1ULL << 23, + SANITIZE_POINTER_OVERFLOW =3D 1ULL << 24, + SANITIZE_BUILTIN =3D 1ULL << 25, + SANITIZE_POINTER_COMPARE =3D 1ULL << 26, + SANITIZE_POINTER_SUBTRACT =3D 1ULL << 27, + SANITIZE_HWADDRESS =3D 1ULL << 28, + SANITIZE_USER_HWADDRESS =3D 1ULL << 29, + SANITIZE_KERNEL_HWADDRESS =3D 1ULL << 30, /* Shadow Call Stack. */ - SANITIZE_SHADOW_CALL_STACK =3D 1UL << 31, + SANITIZE_SHADOW_CALL_STACK =3D 1ULL << 31, + SANITIZE_MAX =3D 1ULL << 63, SANITIZE_SHIFT =3D SANITIZE_SHIFT_BASE | SANITIZE_SHIFT_EXPONENT, SANITIZE_UNDEFINED =3D SANITIZE_SHIFT | SANITIZE_DIVIDE | SANITIZE_UNREA= CHABLE | SANITIZE_VLA | SANITIZE_NULL | SANITIZE_RETURN diff --git a/gcc/opt-suggestions.cc b/gcc/opt-suggestions.cc index 33f298560a1..c667e23e66f 100644 --- a/gcc/opt-suggestions.cc +++ b/gcc/opt-suggestions.cc @@ -173,7 +173,7 @@ option_proposer::build_option_suggestions (const char *= prefix) /* -fsanitize=3Dall is not valid, only -fno-sanitize=3Dall. So don't register the positive misspelling candidates for it. */ - if (sanitizer_opts[j].flag =3D=3D ~0U && i =3D=3D OPT_fsanitize_) + if (sanitizer_opts[j].flag =3D=3D ~0ULL && i =3D=3D OPT_fsanitize_) { optb =3D *option; optb.opt_text =3D opt_text =3D "-fno-sanitize=3D"; diff --git a/gcc/opts.cc b/gcc/opts.cc index 3a89da2dd03..11c5d70458f 100644 --- a/gcc/opts.cc +++ b/gcc/opts.cc @@ -966,7 +966,7 @@ vec 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 =3D 0; sanitizer_opts[i].name !=3D NULL; ++i) { @@ -1000,10 +1000,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 =3D (opts->x_flag_sanitize & left); - unsigned int right_seen =3D (opts->x_flag_sanitize & right); + uint64_t left_seen =3D (opts->x_flag_sanitize & left); + uint64_t right_seen =3D (opts->x_flag_sanitize & right); if (left_seen && right_seen) { const char* left_arg =3D find_sanitizer_argument (opts, left_seen); @@ -2059,7 +2059,7 @@ const struct sanitizer_opts_s sanitizer_opts[] =3D SANITIZER_OPT (pointer-overflow, SANITIZE_POINTER_OVERFLOW, true), SANITIZER_OPT (builtin, SANITIZE_BUILTIN, true), SANITIZER_OPT (shadow-call-stack, SANITIZE_SHADOW_CALL_STACK, false), - SANITIZER_OPT (all, ~0U, true), + SANITIZER_OPT (all, ~0ULL, true), #undef SANITIZER_OPT { NULL, 0U, 0UL, false } }; @@ -2128,7 +2128,7 @@ get_closest_sanitizer_option (const string_fragment &= arg, { /* -fsanitize=3Dall is not valid, so don't offer it. */ if (code =3D=3D OPT_fsanitize_ - && opts[i].flag =3D=3D ~0U + && opts[i].flag =3D=3D ~0ULL && value) continue; =20 @@ -2148,9 +2148,9 @@ get_closest_sanitizer_option (const string_fragment &= arg, adjust previous FLAGS and return new ones. If COMPLAIN is false, don't issue diagnostics. */ =20 -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 =3D (enum opt_code) scode; =20 @@ -2176,7 +2176,7 @@ parse_sanitizer_options (const char *p, location_t lo= c, int scode, && memcmp (p, sanitizer_opts[i].name, len) =3D=3D 0) { /* Handle both -fsanitize and -fno-sanitize cases. */ - if (value && sanitizer_opts[i].flag =3D=3D ~0U) + if (value && sanitizer_opts[i].flag =3D=3D ~0ULL) { if (code =3D=3D OPT_fsanitize_) { @@ -2241,10 +2241,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. */ =20 -unsigned int +uint64_t parse_no_sanitize_attribute (char *value) { - unsigned int flags =3D 0; + uint64_t flags =3D 0; unsigned int i; char *q =3D strtok (value, ","); =20 diff --git a/gcc/opts.h b/gcc/opts.h index a43ce66cffe..17a02cc7c14 100644 --- a/gcc/opts.h +++ b/gcc/opts.h @@ -425,10 +425,10 @@ extern void control_warning_option (unsigned int opt_= index, int kind, extern char *write_langs (unsigned int mask); extern void print_ignored_options (void); extern void handle_common_deferred_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); =20 -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, @@ -470,7 +470,7 @@ extern bool opt_enum_arg_to_value (size_t opt_index, co= nst char *arg, extern const struct sanitizer_opts_s { const char *const name; - unsigned int flag; + uint64_t flag; size_t len; bool can_recover; } sanitizer_opts[]; diff --git a/gcc/tree-cfg.cc b/gcc/tree-cfg.cc index e321d929fd0..8cc31db9bea 100644 --- a/gcc/tree-cfg.cc +++ b/gcc/tree-cfg.cc @@ -8018,7 +8018,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 =3D tree_to_uhwi (value); + uint64_t flags =3D tree_to_uhwi (value); bool first =3D true; for (int i =3D 0; sanitizer_opts[i].name !=3D NULL; ++i) { --=20 2.17.1