From patchwork Wed Jun 30 15:39:27 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Martin Sebor X-Patchwork-Id: 1498968 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=iDL5B2nB; dkim-atps=neutral Received: from sourceware.org (ip-8-43-85-97.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4GFQYm6ssnz9sVb for ; Thu, 1 Jul 2021 01:41:31 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 77B6E385E82B for ; Wed, 30 Jun 2021 15:41:29 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 77B6E385E82B DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1625067689; bh=ydU1DmlBatTxj7y8Mq5eP/MLpkBrI0FKGJYl6myhHMw=; h=Subject:To:References:Date:In-Reply-To:List-Id:List-Unsubscribe: List-Archive:List-Post:List-Help:List-Subscribe:From:Reply-To:Cc: From; b=iDL5B2nBylK9mfvXgTSPXsT1dsf3qoB/GWJFtWuCecnwweGG33pwXM5eY26GB6FMi w0iG1dC+l2iKd3Wj9ERwvetSwcchJgaWIQBhERw5Eqne2CpCMckPSKhztrKZobsHs4 fPYky1Edy6GB2meAi0fkAlM3e0JahLilVDqDfRX4= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-ot1-x334.google.com (mail-ot1-x334.google.com [IPv6:2607:f8b0:4864:20::334]) by sourceware.org (Postfix) with ESMTPS id 4A880395B057 for ; Wed, 30 Jun 2021 15:39:30 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 4A880395B057 Received: by mail-ot1-x334.google.com with SMTP id t24-20020a9d7f980000b029046f4a1a5ec4so3158459otp.1 for ; Wed, 30 Jun 2021 08:39:30 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:subject:from:to:references:cc:message-id:date :user-agent:mime-version:in-reply-to:content-language; bh=ydU1DmlBatTxj7y8Mq5eP/MLpkBrI0FKGJYl6myhHMw=; b=noCjqs2cM74qgNM3E7LV4iebzTrh6+9ZBZgVSwf/3glDXa1KCO9HJ5fZPjjNLsiSPC gcNwlY+pedugh/V/Yp7zQvF4TbIXSKIqUwL4GzWIU8Avyu3cx3brrATaatlk1iBPoQ6b hSl2i1Ua57heV5KJ3bX4gt+SSZUqbvciDk701butg89a2Xnb0MtXdarnwYwIeXzdgs9A rosz2kupRmBl8UOaFyypvyQPk5vXIyMD6P+X9QcXo1koWtuRHidhTQEKyRqq7xvPRhIz y5HPfgWncpTm0jKnIJSSTHD2Nw5N/zQ5hfxDhxG1q3a6PpeJqZpCgQgpQCdZRZDOwJGe 5vbg== X-Gm-Message-State: AOAM532MEwNy+/QhBrZP+IliEiiWoIZvlO05DjlBXwB23FQ5HdsrNNlf KlZZRhoUkOPXWRoxo6xjcYk= X-Google-Smtp-Source: ABdhPJy7fk/H2eAQ94fRiTFsJaAE2usqYKc91uHSvM1NI7Yed9UqOGn3ONYuyP/qiK+jTKpwCKtT2Q== X-Received: by 2002:a05:6830:545:: with SMTP id l5mr9215373otb.270.1625067569720; Wed, 30 Jun 2021 08:39:29 -0700 (PDT) Received: from [192.168.0.41] (97-118-116-139.hlrn.qwest.net. [97.118.116.139]) by smtp.gmail.com with ESMTPSA id r25sm1729958ots.72.2021.06.30.08.39.28 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Wed, 30 Jun 2021 08:39:28 -0700 (PDT) Subject: [PING][PATCH 2/4] remove %G and %K from calls in front end and middle end (PR 98512) To: gcc-patches References: <2e49b6c6-a403-a207-c41e-58f78df96b84@gmail.com> <945093c7-de5e-0350-6030-e4e79ea41161@gmail.com> <5aff247f-dfcb-cecf-e07e-b5fca877f911@gmail.com> <36e75bb4-2c3c-5b3a-9fe1-9cdb046666a3@gmail.com> Message-ID: <12ed261b-d35e-4c07-949a-67e085cec750@gmail.com> Date: Wed, 30 Jun 2021 09:39:27 -0600 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Thunderbird/68.2.2 MIME-Version: 1.0 In-Reply-To: <36e75bb4-2c3c-5b3a-9fe1-9cdb046666a3@gmail.com> Content-Language: en-US X-Spam-Status: No, score=-11.0 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, FREEMAIL_FROM, GIT_PATCH_0, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Martin Sebor via Gcc-patches From: Martin Sebor Reply-To: Martin Sebor Cc: Jeff Law Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" Ping. Attached is the same patch rebased on top the latest trunk. As discussed in the review of Aldy's recent changes to the backwards threader, he has run into the same bug the patch fixes. Getting this patch set reviewed and approved would be helpful in keeping him from having to work around the bug. https://gcc.gnu.org/pipermail/gcc/2021-June/236608.html On 6/10/21 5:27 PM, Martin Sebor wrote: > This diff removes the uses of %G and %K from all warning_at() calls > throughout GCC front end and middle end.  The inlining context is > included in diagnostic output whenever it's present. Improve warning suppression for inlined functions. Resolves: PR middle-end/98871 - Cannot silence -Wmaybe-uninitialized at declaration site PR middle-end/98512 - #pragma GCC diagnostic ignored ineffective in conjunction with alias attribute gcc/ChangeLog: * builtins.c (warn_string_no_nul): Remove %G. (maybe_warn_for_bound): Same. (warn_for_access): Same. (check_access): Same. (check_strncat_sizes): Same. (expand_builtin_strncat): Same. (expand_builtin_strncmp): Same. (expand_builtin): Same. (expand_builtin_object_size): Same. (warn_dealloc_offset): Same. (maybe_emit_free_warning): Same. * calls.c (maybe_warn_alloc_args_overflow): Same. (maybe_warn_nonstring_arg): Same. (maybe_warn_rdwr_sizes): Same. * expr.c (expand_expr_real_1): Remove %K. * gimple-fold.c (gimple_fold_builtin_strncpy): Remove %G. (gimple_fold_builtin_strncat): Same. * gimple-ssa-sprintf.c (format_directive): Same. (handle_printf_call): Same. * gimple-ssa-warn-alloca.c (pass_walloca::execute): Same. * gimple-ssa-warn-restrict.c (maybe_diag_overlap): Same. (maybe_diag_access_bounds): Same. Call gimple_location. (check_bounds_or_overlap): Same. * trans-mem.c (ipa_tm_scan_irr_block): Remove %K. Simplify. * tree-ssa-ccp.c (pass_post_ipa_warn::execute): Remove %G. * tree-ssa-strlen.c (maybe_warn_overflow): Same. (maybe_diag_stxncpy_trunc): Same. (handle_builtin_stxncpy_strncat): Same. (maybe_warn_pointless_strcmp): Same. * tree-ssa-uninit.c (maybe_warn_operand): Same. gcc/testsuite/ChangeLog: * gcc.dg/Wfree-nonheap-object-4.c: Tighten up. * gcc.dg/Wobjsize-1.c: Prune expected output. * gcc.dg/Warray-bounds-71.c: New test. * gcc.dg/Warray-bounds-71.h: New test. * gcc.dg/Warray-bounds-72.c: New test. * gcc.dg/Warray-bounds-73.c: New test. * gcc.dg/Warray-bounds-74.c: New test. * gcc.dg/Warray-bounds-75.c: New test. * gcc.dg/Wfree-nonheap-object-5.c: New test. * gcc.dg/pragma-diag-10.c: New test. * gcc.dg/pragma-diag-9.c: New test. * gcc.dg/uninit-suppress_3.c: New test. diff --git a/gcc/builtins.c b/gcc/builtins.c index e5e39386a93..e59fa322729 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -1126,30 +1126,30 @@ warn_string_no_nul (location_t loc, tree expr, const char *fname, { if (wi::ltu_p (maxsiz, bndrng[0])) warned = warning_at (loc, opt, - "%K%qD specified bound %s exceeds " + "%qD specified bound %s exceeds " "maximum object size %E", - expr, func, bndstr, maxobjsize); + func, bndstr, maxobjsize); else { bool maybe = wi::to_wide (size) == bndrng[0]; warned = warning_at (loc, opt, exact - ? G_("%K%qD specified bound %s exceeds " + ? G_("%qD specified bound %s exceeds " "the size %E of unterminated array") : (maybe - ? G_("%K%qD specified bound %s may " + ? G_("%qD specified bound %s may " "exceed the size of at most %E " "of unterminated array") - : G_("%K%qD specified bound %s exceeds " + : G_("%qD specified bound %s exceeds " "the size of at most %E " "of unterminated array")), - expr, func, bndstr, size); + func, bndstr, size); } } else warned = warning_at (loc, opt, - "%K%qD argument missing terminating nul", - expr, func); + "%qD argument missing terminating nul", + func); } else { @@ -3969,35 +3969,34 @@ maybe_warn_for_bound (opt_code opt, location_t loc, tree exp, tree func, warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified bound %E may " + ? G_("%qD specified bound %E may " "exceed maximum object size %E") - : G_("%K%qD specified bound %E " + : G_("%qD specified bound %E " "exceeds maximum object size %E")), - exp, func, bndrng[0], maxobjsize) + func, bndrng[0], maxobjsize) : warning_at (loc, opt, (maybe - ? G_("%Kspecified bound %E may " + ? G_("specified bound %E may " "exceed maximum object size %E") - : G_("%Kspecified bound %E " + : G_("specified bound %E " "exceeds maximum object size %E")), - exp, bndrng[0], maxobjsize)); + bndrng[0], maxobjsize)); else warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified bound [%E, %E] may " + ? G_("%qD specified bound [%E, %E] may " "exceed maximum object size %E") - : G_("%K%qD specified bound [%E, %E] " + : G_("%qD specified bound [%E, %E] " "exceeds maximum object size %E")), - exp, func, - bndrng[0], bndrng[1], maxobjsize) + func, bndrng[0], bndrng[1], maxobjsize) : warning_at (loc, opt, (maybe - ? G_("%Kspecified bound [%E, %E] may " + ? G_("specified bound [%E, %E] may " "exceed maximum object size %E") - : G_("%Kspecified bound [%E, %E] " + : G_("specified bound [%E, %E] " "exceeds maximum object size %E")), - exp, bndrng[0], bndrng[1], maxobjsize)); + bndrng[0], bndrng[1], maxobjsize)); } else if (!size || tree_int_cst_le (bndrng[0], size)) return false; @@ -4005,34 +4004,34 @@ maybe_warn_for_bound (opt_code opt, location_t loc, tree exp, tree func, warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified bound %E may exceed " + ? G_("%qD specified bound %E may exceed " "source size %E") - : G_("%K%qD specified bound %E exceeds " + : G_("%qD specified bound %E exceeds " "source size %E")), - exp, func, bndrng[0], size) + func, bndrng[0], size) : warning_at (loc, opt, (maybe - ? G_("%Kspecified bound %E may exceed " + ? G_("specified bound %E may exceed " "source size %E") - : G_("%Kspecified bound %E exceeds " + : G_("specified bound %E exceeds " "source size %E")), - exp, bndrng[0], size)); + bndrng[0], size)); else warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified bound [%E, %E] may " + ? G_("%qD specified bound [%E, %E] may " "exceed source size %E") - : G_("%K%qD specified bound [%E, %E] exceeds " + : G_("%qD specified bound [%E, %E] exceeds " "source size %E")), - exp, func, bndrng[0], bndrng[1], size) + func, bndrng[0], bndrng[1], size) : warning_at (loc, opt, (maybe - ? G_("%Kspecified bound [%E, %E] may exceed " + ? G_("specified bound [%E, %E] may exceed " "source size %E") - : G_("%Kspecified bound [%E, %E] exceeds " + : G_("specified bound [%E, %E] exceeds " "source size %E")), - exp, bndrng[0], bndrng[1], size)); + bndrng[0], bndrng[1], size)); if (warned) { if (pad && pad->src.ref) @@ -4057,35 +4056,34 @@ maybe_warn_for_bound (opt_code opt, location_t loc, tree exp, tree func, warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified size %E may " + ? G_("%qD specified size %E may " "exceed maximum object size %E") - : G_("%K%qD specified size %E " + : G_("%qD specified size %E " "exceeds maximum object size %E")), - exp, func, bndrng[0], maxobjsize) + func, bndrng[0], maxobjsize) : warning_at (loc, opt, (maybe - ? G_("%Kspecified size %E may exceed " + ? G_("specified size %E may exceed " "maximum object size %E") - : G_("%Kspecified size %E exceeds " + : G_("specified size %E exceeds " "maximum object size %E")), - exp, bndrng[0], maxobjsize)); + bndrng[0], maxobjsize)); else warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified size between %E and %E " + ? G_("%qD specified size between %E and %E " "may exceed maximum object size %E") - : G_("%K%qD specified size between %E and %E " + : G_("%qD specified size between %E and %E " "exceeds maximum object size %E")), - exp, func, - bndrng[0], bndrng[1], maxobjsize) + func, bndrng[0], bndrng[1], maxobjsize) : warning_at (loc, opt, (maybe - ? G_("%Kspecified size between %E and %E " + ? G_("specified size between %E and %E " "may exceed maximum object size %E") - : G_("%Kspecified size between %E and %E " + : G_("specified size between %E and %E " "exceeds maximum object size %E")), - exp, bndrng[0], bndrng[1], maxobjsize)); + bndrng[0], bndrng[1], maxobjsize)); } else if (!size || tree_int_cst_le (bndrng[0], size)) return false; @@ -4093,34 +4091,34 @@ maybe_warn_for_bound (opt_code opt, location_t loc, tree exp, tree func, warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified bound %E may exceed " + ? G_("%qD specified bound %E may exceed " "destination size %E") - : G_("%K%qD specified bound %E exceeds " + : G_("%qD specified bound %E exceeds " "destination size %E")), - exp, func, bndrng[0], size) + func, bndrng[0], size) : warning_at (loc, opt, (maybe - ? G_("%Kspecified bound %E may exceed " + ? G_("specified bound %E may exceed " "destination size %E") - : G_("%Kspecified bound %E exceeds " + : G_("specified bound %E exceeds " "destination size %E")), - exp, bndrng[0], size)); + bndrng[0], size)); else warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD specified bound [%E, %E] may exceed " + ? G_("%qD specified bound [%E, %E] may exceed " "destination size %E") - : G_("%K%qD specified bound [%E, %E] exceeds " + : G_("%qD specified bound [%E, %E] exceeds " "destination size %E")), - exp, func, bndrng[0], bndrng[1], size) + func, bndrng[0], bndrng[1], size) : warning_at (loc, opt, (maybe - ? G_("%Kspecified bound [%E, %E] exceeds " + ? G_("specified bound [%E, %E] exceeds " "destination size %E") - : G_("%Kspecified bound [%E, %E] exceeds " + : G_("specified bound [%E, %E] exceeds " "destination size %E")), - exp, bndrng[0], bndrng[1], size)); + bndrng[0], bndrng[1], size)); if (warned) { @@ -4158,65 +4156,63 @@ warn_for_access (location_t loc, tree func, tree exp, int opt, tree range[2], warned = (func ? warning_n (loc, opt, tree_to_uhwi (range[0]), (maybe - ? G_("%K%qD may access %E byte in a region " + ? G_("%qD may access %E byte in a region " "of size %E") - : G_("%K%qD accessing %E byte in a region " + : G_("%qD accessing %E byte in a region " "of size %E")), (maybe - ? G_ ("%K%qD may access %E bytes in a region " + ? G_ ("%qD may access %E bytes in a region " "of size %E") - : G_ ("%K%qD accessing %E bytes in a region " + : G_ ("%qD accessing %E bytes in a region " "of size %E")), - exp, func, range[0], size) + func, range[0], size) : warning_n (loc, opt, tree_to_uhwi (range[0]), (maybe - ? G_("%Kmay access %E byte in a region " + ? G_("may access %E byte in a region " "of size %E") - : G_("%Kaccessing %E byte in a region " + : G_("accessing %E byte in a region " "of size %E")), (maybe - ? G_("%Kmay access %E bytes in a region " + ? G_("may access %E bytes in a region " "of size %E") - : G_("%Kaccessing %E bytes in a region " + : G_("accessing %E bytes in a region " "of size %E")), - exp, range[0], size)); + range[0], size)); else if (tree_int_cst_sign_bit (range[1])) { /* Avoid printing the upper bound if it's invalid. */ warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD may access %E or more bytes " + ? G_("%qD may access %E or more bytes " "in a region of size %E") - : G_("%K%qD accessing %E or more bytes " + : G_("%qD accessing %E or more bytes " "in a region of size %E")), - exp, func, range[0], size) + func, range[0], size) : warning_at (loc, opt, (maybe - ? G_("%Kmay access %E or more bytes " + ? G_("may access %E or more bytes " "in a region of size %E") - : G_("%Kaccessing %E or more bytes " + : G_("accessing %E or more bytes " "in a region of size %E")), - exp, range[0], size)); + range[0], size)); } else warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD may access between %E and %E " + ? G_("%qD may access between %E and %E " "bytes in a region of size %E") - : G_("%K%qD accessing between %E and %E " + : G_("%qD accessing between %E and %E " "bytes in a region of size %E")), - exp, func, range[0], range[1], - size) + func, range[0], range[1], size) : warning_at (loc, opt, (maybe - ? G_("%Kmay access between %E and %E bytes " + ? G_("may access between %E and %E bytes " "in a region of size %E") - : G_("%Kaccessing between %E and %E bytes " + : G_("accessing between %E and %E bytes " "in a region of size %E")), - exp, range[0], range[1], - size)); + range[0], range[1], size)); return warned; } @@ -4226,69 +4222,67 @@ warn_for_access (location_t loc, tree func, tree exp, int opt, tree range[2], warned = (func ? warning_n (loc, opt, tree_to_uhwi (range[0]), (maybe - ? G_("%K%qD may write %E byte into a region " + ? G_("%qD may write %E byte into a region " "of size %E") - : G_("%K%qD writing %E byte into a region " + : G_("%qD writing %E byte into a region " "of size %E overflows the destination")), (maybe - ? G_("%K%qD may write %E bytes into a region " + ? G_("%qD may write %E bytes into a region " "of size %E") - : G_("%K%qD writing %E bytes into a region " + : G_("%qD writing %E bytes into a region " "of size %E overflows the destination")), - exp, func, range[0], size) + func, range[0], size) : warning_n (loc, opt, tree_to_uhwi (range[0]), (maybe - ? G_("%Kmay write %E byte into a region " + ? G_("may write %E byte into a region " "of size %E") - : G_("%Kwriting %E byte into a region " + : G_("writing %E byte into a region " "of size %E overflows the destination")), (maybe - ? G_("%Kmay write %E bytes into a region " + ? G_("may write %E bytes into a region " "of size %E") - : G_("%Kwriting %E bytes into a region " + : G_("writing %E bytes into a region " "of size %E overflows the destination")), - exp, range[0], size)); + range[0], size)); else if (tree_int_cst_sign_bit (range[1])) { /* Avoid printing the upper bound if it's invalid. */ warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD may write %E or more bytes " + ? G_("%qD may write %E or more bytes " "into a region of size %E") - : G_("%K%qD writing %E or more bytes " + : G_("%qD writing %E or more bytes " "into a region of size %E overflows " "the destination")), - exp, func, range[0], size) + func, range[0], size) : warning_at (loc, opt, (maybe - ? G_("%Kmay write %E or more bytes into " + ? G_("may write %E or more bytes into " "a region of size %E") - : G_("%Kwriting %E or more bytes into " + : G_("writing %E or more bytes into " "a region of size %E overflows " "the destination")), - exp, range[0], size)); + range[0], size)); } else warned = (func ? warning_at (loc, opt, (maybe - ? G_("%K%qD may write between %E and %E bytes " + ? G_("%qD may write between %E and %E bytes " "into a region of size %E") - : G_("%K%qD writing between %E and %E bytes " + : G_("%qD writing between %E and %E bytes " "into a region of size %E overflows " "the destination")), - exp, func, range[0], range[1], - size) + func, range[0], range[1], size) : warning_at (loc, opt, (maybe - ? G_("%Kmay write between %E and %E bytes " + ? G_("may write between %E and %E bytes " "into a region of size %E") - : G_("%Kwriting between %E and %E bytes " + : G_("writing between %E and %E bytes " "into a region of size %E overflows " "the destination")), - exp, range[0], range[1], - size)); + range[0], range[1], size)); return warned; } @@ -4299,64 +4293,64 @@ warn_for_access (location_t loc, tree func, tree exp, int opt, tree range[2], ? warning_n (loc, OPT_Wstringop_overread, tree_to_uhwi (range[0]), (maybe - ? G_("%K%qD may read %E byte from a region " + ? G_("%qD may read %E byte from a region " "of size %E") - : G_("%K%qD reading %E byte from a region " + : G_("%qD reading %E byte from a region " "of size %E")), (maybe - ? G_("%K%qD may read %E bytes from a region " + ? G_("%qD may read %E bytes from a region " "of size %E") - : G_("%K%qD reading %E bytes from a region " + : G_("%qD reading %E bytes from a region " "of size %E")), - exp, func, range[0], size) + func, range[0], size) : warning_n (loc, OPT_Wstringop_overread, tree_to_uhwi (range[0]), (maybe - ? G_("%Kmay read %E byte from a region " + ? G_("may read %E byte from a region " "of size %E") - : G_("%Kreading %E byte from a region " + : G_("reading %E byte from a region " "of size %E")), (maybe - ? G_("%Kmay read %E bytes from a region " + ? G_("may read %E bytes from a region " "of size %E") - : G_("%Kreading %E bytes from a region " + : G_("reading %E bytes from a region " "of size %E")), - exp, range[0], size)); + range[0], size)); else if (tree_int_cst_sign_bit (range[1])) { /* Avoid printing the upper bound if it's invalid. */ warned = (func ? warning_at (loc, OPT_Wstringop_overread, (maybe - ? G_("%K%qD may read %E or more bytes " + ? G_("%qD may read %E or more bytes " "from a region of size %E") - : G_("%K%qD reading %E or more bytes " + : G_("%qD reading %E or more bytes " "from a region of size %E")), - exp, func, range[0], size) + func, range[0], size) : warning_at (loc, OPT_Wstringop_overread, (maybe - ? G_("%Kmay read %E or more bytes " + ? G_("may read %E or more bytes " "from a region of size %E") - : G_("%Kreading %E or more bytes " + : G_("reading %E or more bytes " "from a region of size %E")), - exp, range[0], size)); + range[0], size)); } else warned = (func ? warning_at (loc, OPT_Wstringop_overread, (maybe - ? G_("%K%qD may read between %E and %E bytes " + ? G_("%qD may read between %E and %E bytes " "from a region of size %E") - : G_("%K%qD reading between %E and %E bytes " + : G_("%qD reading between %E and %E bytes " "from a region of size %E")), - exp, func, range[0], range[1], size) + func, range[0], range[1], size) : warning_at (loc, opt, (maybe - ? G_("%Kmay read between %E and %E bytes " + ? G_("may read between %E and %E bytes " "from a region of size %E") - : G_("%Kreading between %E and %E bytes " + : G_("reading between %E and %E bytes " "from a region of size %E")), - exp, range[0], range[1], size)); + range[0], range[1], size)); if (warned) suppress_warning (exp, OPT_Wstringop_overread); @@ -4369,37 +4363,37 @@ warn_for_access (location_t loc, tree func, tree exp, int opt, tree range[2], warned = (func ? warning_n (loc, OPT_Wstringop_overread, tree_to_uhwi (range[0]), - "%K%qD expecting %E byte in a region of size %E", - "%K%qD expecting %E bytes in a region of size %E", - exp, func, range[0], size) + "%qD expecting %E byte in a region of size %E", + "%qD expecting %E bytes in a region of size %E", + func, range[0], size) : warning_n (loc, OPT_Wstringop_overread, tree_to_uhwi (range[0]), - "%Kexpecting %E byte in a region of size %E", - "%Kexpecting %E bytes in a region of size %E", - exp, range[0], size)); + "expecting %E byte in a region of size %E", + "expecting %E bytes in a region of size %E", + range[0], size)); else if (tree_int_cst_sign_bit (range[1])) { /* Avoid printing the upper bound if it's invalid. */ warned = (func ? warning_at (loc, OPT_Wstringop_overread, - "%K%qD expecting %E or more bytes in a region " + "%qD expecting %E or more bytes in a region " "of size %E", - exp, func, range[0], size) + func, range[0], size) : warning_at (loc, OPT_Wstringop_overread, - "%Kexpecting %E or more bytes in a region " + "expecting %E or more bytes in a region " "of size %E", - exp, range[0], size)); + range[0], size)); } else warned = (func ? warning_at (loc, OPT_Wstringop_overread, - "%K%qD expecting between %E and %E bytes in " + "%qD expecting between %E and %E bytes in " "a region of size %E", - exp, func, range[0], range[1], size) + func, range[0], range[1], size) : warning_at (loc, OPT_Wstringop_overread, - "%Kexpecting between %E and %E bytes in " + "expecting between %E and %E bytes in " "a region of size %E", - exp, range[0], range[1], size)); + range[0], range[1], size)); if (warned) suppress_warning (exp, OPT_Wstringop_overread); @@ -4759,7 +4753,7 @@ check_access (tree exp, tree dstwrite, && TREE_CODE (range[0]) == INTEGER_CST && tree_int_cst_lt (maxobjsize, range[0])) { - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); maybe_warn_for_bound (OPT_Wstringop_overflow_, loc, exp, func, range, NULL_TREE, pad); return false; @@ -4787,7 +4781,7 @@ check_access (tree exp, tree dstwrite, && warning_suppressed_p (pad->dst.ref, opt))) return false; - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); bool warned = false; if (dstwrite == slen && at_least_one) { @@ -4796,15 +4790,15 @@ check_access (tree exp, tree dstwrite, at least one byte past the end of the destination. */ warned = (func ? warning_at (loc, opt, - "%K%qD writing %E or more bytes into " + "%qD writing %E or more bytes into " "a region of size %E overflows " "the destination", exp, func, range[0], dstsize) : warning_at (loc, opt, - "%Kwriting %E or more bytes into " + "writing %E or more bytes into " "a region of size %E overflows " "the destination", - exp, range[0], dstsize)); + range[0], dstsize)); } else { @@ -4840,7 +4834,7 @@ check_access (tree exp, tree dstwrite, PAD is nonnull and BNDRNG is valid. */ get_size_range (maxread, range, pad ? pad->src.bndrng : NULL); - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); tree size = dstsize; if (pad && pad->mode == access_read_only) size = wide_int_to_tree (sizetype, pad->src.sizrng[1]); @@ -4901,7 +4895,7 @@ check_access (tree exp, tree dstwrite, && warning_suppressed_p (pad->src.ref, opt))) return false; - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); const bool read = mode == access_read_only || mode == access_read_write; const bool maybe = pad && pad->dst.parmarray; @@ -6481,10 +6475,10 @@ check_strncat_sizes (tree exp, tree objsize) if (tree_fits_uhwi_p (maxread) && tree_fits_uhwi_p (objsize) && tree_int_cst_equal (objsize, maxread)) { - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); warning_at (loc, OPT_Wstringop_overflow_, - "%K%qD specified bound %E equals destination size", - exp, get_callee_fndecl (exp), maxread); + "%qD specified bound %E equals destination size", + get_callee_fndecl (exp), maxread); return false; } @@ -6554,10 +6548,10 @@ expand_builtin_strncat (tree exp, rtx) if (tree_fits_uhwi_p (maxread) && tree_fits_uhwi_p (destsize) && tree_int_cst_equal (destsize, maxread)) { - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); warning_at (loc, OPT_Wstringop_overflow_, - "%K%qD specified bound %E equals destination size", - exp, get_callee_fndecl (exp), maxread); + "%qD specified bound %E equals destination size", + get_callee_fndecl (exp), maxread); return NULL_RTX; } @@ -7330,7 +7324,7 @@ expand_builtin_strncmp (tree exp, ATTRIBUTE_UNUSED rtx target, || !check_nul_terminated_array (exp, arg2, arg3)) return NULL_RTX; - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); tree len1 = c_strlen (arg1, 1); tree len2 = c_strlen (arg2, 1); @@ -10006,13 +10000,13 @@ expand_builtin (tree exp, rtx target, rtx subtarget, machine_mode mode, case BUILT_IN_VA_ARG_PACK: /* All valid uses of __builtin_va_arg_pack () are removed during inlining. */ - error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp); + error ("invalid use of %<__builtin_va_arg_pack ()%>"); return const0_rtx; case BUILT_IN_VA_ARG_PACK_LEN: /* All valid uses of __builtin_va_arg_pack_len () are removed during inlining. */ - error ("%Kinvalid use of %<__builtin_va_arg_pack_len ()%>", exp); + error ("invalid use of %<__builtin_va_arg_pack_len ()%>"); return const0_rtx; /* Return the address of the first anonymous stack arg. */ @@ -12961,8 +12955,8 @@ expand_builtin_object_size (tree exp) if (!validate_arglist (exp, POINTER_TYPE, INTEGER_TYPE, VOID_TYPE)) { - error ("%Kfirst argument of %qD must be a pointer, second integer constant", - exp, fndecl); + error ("first argument of %qD must be a pointer, second integer constant", + fndecl); expand_builtin_trap (); return const0_rtx; } @@ -12974,8 +12968,8 @@ expand_builtin_object_size (tree exp) || tree_int_cst_sgn (ost) < 0 || compare_tree_int (ost, 3) > 0) { - error ("%Klast argument of %qD is not integer constant between 0 and 3", - exp, fndecl); + error ("last argument of %qD is not integer constant between 0 and 3", + fndecl); expand_builtin_trap (); return const0_rtx; } @@ -13787,8 +13781,8 @@ warn_dealloc_offset (location_t loc, tree exp, const access_ref &aref) } if (!warning_at (loc, OPT_Wfree_nonheap_object, - "%K%qD called on pointer %qE with nonzero offset%s", - exp, dealloc_decl, aref.ref, offstr)) + "%qD called on pointer %qE with nonzero offset%s", + dealloc_decl, aref.ref, offstr)) return false; if (DECL_P (aref.ref)) @@ -13843,15 +13837,15 @@ maybe_emit_free_warning (tree exp) return; tree dealloc_decl = get_callee_fndecl (exp); - location_t loc = tree_inlined_location (exp); + location_t loc = EXPR_LOCATION (exp); if (DECL_P (ref) || EXPR_P (ref)) { /* Diagnose freeing a declared object. */ if (aref.ref_declared () && warning_at (loc, OPT_Wfree_nonheap_object, - "%K%qD called on unallocated object %qD", - exp, dealloc_decl, ref)) + "%qD called on unallocated object %qD", + dealloc_decl, ref)) { loc = (DECL_P (ref) ? DECL_SOURCE_LOCATION (ref) @@ -13870,8 +13864,8 @@ maybe_emit_free_warning (tree exp) else if (CONSTANT_CLASS_P (ref)) { if (warning_at (loc, OPT_Wfree_nonheap_object, - "%K%qD called on a pointer to an unallocated " - "object %qE", exp, dealloc_decl, ref)) + "%qD called on a pointer to an unallocated " + "object %qE", dealloc_decl, ref)) { if (TREE_CODE (ptr) == SSA_NAME) { @@ -13909,18 +13903,18 @@ maybe_emit_free_warning (tree exp) ? OPT_Wmismatched_new_delete : OPT_Wmismatched_dealloc); warned = warning_at (loc, opt, - "%K%qD called on pointer returned " + "%qD called on pointer returned " "from a mismatched allocation " - "function", exp, dealloc_decl); + "function", dealloc_decl); } } else if (gimple_call_builtin_p (def_stmt, BUILT_IN_ALLOCA) || gimple_call_builtin_p (def_stmt, BUILT_IN_ALLOCA_WITH_ALIGN)) warned = warning_at (loc, OPT_Wfree_nonheap_object, - "%K%qD called on pointer to " + "%qD called on pointer to " "an unallocated object", - exp, dealloc_decl); + dealloc_decl); else if (warn_dealloc_offset (loc, exp, aref)) return; diff --git a/gcc/calls.c b/gcc/calls.c index f8a4b79e7f8..d2413a280cf 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -1435,8 +1435,8 @@ maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2]) if (tree_int_cst_lt (args[i], integer_zero_node)) { warned = warning_at (loc, OPT_Walloc_size_larger_than_, - "%Kargument %i value %qE is negative", - exp, idx[i] + 1, args[i]); + "argument %i value %qE is negative", + idx[i] + 1, args[i]); } else if (integer_zerop (args[i])) { @@ -1452,8 +1452,8 @@ maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2]) : !lookup_attribute ("returns_nonnull", TYPE_ATTRIBUTES (fntype))) warned = warning_at (loc, OPT_Walloc_zero, - "%Kargument %i value is zero", - exp, idx[i] + 1); + "argument %i value is zero", + idx[i] + 1); } else if (tree_int_cst_lt (maxobjsize, args[i])) { @@ -1470,9 +1470,9 @@ maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2]) continue; warned = warning_at (loc, OPT_Walloc_size_larger_than_, - "%Kargument %i value %qE exceeds " + "argument %i value %qE exceeds " "maximum object size %E", - exp, idx[i] + 1, args[i], maxobjsize); + idx[i] + 1, args[i], maxobjsize); } } else if (TREE_CODE (args[i]) == SSA_NAME @@ -1484,16 +1484,16 @@ maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2]) && tree_int_cst_le (argrange[i][1], integer_zero_node)) { warned = warning_at (loc, OPT_Walloc_size_larger_than_, - "%Kargument %i range [%E, %E] is negative", - exp, idx[i] + 1, + "argument %i range [%E, %E] is negative", + idx[i] + 1, argrange[i][0], argrange[i][1]); } else if (tree_int_cst_lt (maxobjsize, argrange[i][0])) { warned = warning_at (loc, OPT_Walloc_size_larger_than_, - "%Kargument %i range [%E, %E] exceeds " + "argument %i range [%E, %E] exceeds " "maximum object size %E", - exp, idx[i] + 1, + idx[i] + 1, argrange[i][0], argrange[i][1], maxobjsize); } @@ -1521,15 +1521,15 @@ maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2]) if (vflow) warned = warning_at (loc, OPT_Walloc_size_larger_than_, - "%Kproduct %<%E * %E%> of arguments %i and %i " + "product %<%E * %E%> of arguments %i and %i " "exceeds %", - exp, argrange[0][0], argrange[1][0], + argrange[0][0], argrange[1][0], idx[0] + 1, idx[1] + 1); else if (wi::ltu_p (wi::to_wide (maxobjsize, szprec), prod)) warned = warning_at (loc, OPT_Walloc_size_larger_than_, - "%Kproduct %<%E * %E%> of arguments %i and %i " + "product %<%E * %E%> of arguments %i and %i " "exceeds maximum object size %E", - exp, argrange[0][0], argrange[1][0], + argrange[0][0], argrange[1][0], idx[0] + 1, idx[1] + 1, maxobjsize); @@ -1729,14 +1729,14 @@ maybe_warn_nonstring_arg (tree fndecl, tree exp) bool warned = false; if (tree_int_cst_equal (bndrng[0], bndrng[1])) warned = warning_at (loc, OPT_Wstringop_overread, - "%K%qD specified bound %E " + "%qD specified bound %E " "exceeds maximum object size %E", - exp, fndecl, bndrng[0], maxobjsize); + fndecl, bndrng[0], maxobjsize); else warned = warning_at (loc, OPT_Wstringop_overread, - "%K%qD specified bound [%E, %E] " + "%qD specified bound [%E, %E] " "exceeds maximum object size %E", - exp, fndecl, bndrng[0], bndrng[1], + fndecl, bndrng[0], bndrng[1], maxobjsize); if (warned) suppress_warning (exp, OPT_Wstringop_overread); @@ -2068,16 +2068,16 @@ maybe_warn_rdwr_sizes (rdwr_map *rwm, tree fndecl, tree fntype, tree exp) = access.second.array_as_string (ptrtype); if (warning_at (loc, OPT_Wstringop_overflow_, - "%Kbound argument %i value %s is " + "bound argument %i value %s is " "negative for a variable length array " "argument %i of type %s", - exp, sizidx + 1, sizstr, + sizidx + 1, sizstr, ptridx + 1, argtypestr.c_str ())) arg_warned = OPT_Wstringop_overflow_; } else if (warning_at (loc, OPT_Wstringop_overflow_, - "%Kargument %i value %s is negative", - exp, sizidx + 1, sizstr)) + "argument %i value %s is negative", + sizidx + 1, sizstr)) arg_warned = OPT_Wstringop_overflow_; if (arg_warned != no_warning) @@ -2124,20 +2124,19 @@ maybe_warn_rdwr_sizes (rdwr_map *rwm, tree fndecl, tree fntype, tree exp) = access.second.array_as_string (ptrtype); if (warning_at (loc, OPT_Wnonnull, - "%Kargument %i of variable length " + "argument %i of variable length " "array %s is null but " "the corresponding bound argument " "%i value is %s", - exp, sizidx + 1, argtypestr.c_str (), + sizidx + 1, argtypestr.c_str (), ptridx + 1, sizstr)) arg_warned = OPT_Wnonnull; } else if (warning_at (loc, OPT_Wnonnull, - "%Kargument %i is null but " + "argument %i is null but " "the corresponding size argument " "%i value is %s", - exp, ptridx + 1, sizidx + 1, - sizstr)) + ptridx + 1, sizidx + 1, sizstr)) arg_warned = OPT_Wnonnull; } else if (access_size && access.second.static_p) @@ -2145,10 +2144,9 @@ maybe_warn_rdwr_sizes (rdwr_map *rwm, tree fndecl, tree fntype, tree exp) /* Warn about null pointers for [static N] array arguments but do not warn for ordinary (i.e., nonstatic) arrays. */ if (warning_at (loc, OPT_Wnonnull, - "%Kargument %i to %<%T[static %E]%> " + "argument %i to %<%T[static %E]%> " "is null where non-null expected", - exp, ptridx + 1, argtype, - access_size)) + ptridx + 1, argtype, access_size)) arg_warned = OPT_Wnonnull; } diff --git a/gcc/expr.c b/gcc/expr.c index 025033c9ecf..b9fe1cf91d7 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -11401,7 +11401,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, /* All valid uses of __builtin_va_arg_pack () are removed during inlining. */ if (CALL_EXPR_VA_ARG_PACK (exp)) - error ("%Kinvalid use of %<__builtin_va_arg_pack ()%>", exp); + error ("invalid use of %<__builtin_va_arg_pack ()%>"); { tree fndecl = get_callee_fndecl (exp), attr; @@ -11413,7 +11413,7 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, DECL_ATTRIBUTES (fndecl))) != NULL) { const char *ident = lang_hooks.decl_printable_name (fndecl, 1); - error ("%Kcall to %qs declared with attribute error: %s", exp, + error ("call to %qs declared with attribute error: %s", identifier_to_locale (ident), TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)))); } @@ -11425,10 +11425,10 @@ expand_expr_real_1 (tree exp, rtx target, machine_mode tmode, DECL_ATTRIBUTES (fndecl))) != NULL) { const char *ident = lang_hooks.decl_printable_name (fndecl, 1); - warning_at (tree_nonartificial_location (exp), + warning_at (EXPR_LOCATION (exp), OPT_Wattribute_warning, - "%Kcall to %qs declared with attribute warning: %s", - exp, identifier_to_locale (ident), + "call to %qs declared with attribute warning: %s", + identifier_to_locale (ident), TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr)))); } diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 68031538145..1401092aa9b 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -2115,13 +2115,13 @@ gimple_fold_builtin_strncpy (gimple_stmt_iterator *gsi, tree slen = get_maxval_strlen (src, SRK_STRLEN); if (slen && !integer_zerop (slen)) warning_at (loc, OPT_Wstringop_truncation, - "%G%qD destination unchanged after copying no bytes " + "%qD destination unchanged after copying no bytes " "from a string of length %E", - stmt, fndecl, slen); + fndecl, slen); else warning_at (loc, OPT_Wstringop_truncation, - "%G%qD destination unchanged after copying no bytes", - stmt, fndecl); + "%qD destination unchanged after copying no bytes", + fndecl); } replace_call_with_value (gsi, dest); @@ -2498,11 +2498,11 @@ gimple_fold_builtin_strncat (gimple_stmt_iterator *gsi) location_t loc = gimple_location (stmt); nowarn = warning_at (loc, OPT_Wstringop_overflow_, cmpdst == 0 - ? G_("%G%qD specified bound %E equals " + ? G_("%qD specified bound %E equals " "destination size") - : G_("%G%qD specified bound %E exceeds " + : G_("%qD specified bound %E exceeds " "destination size %wu"), - stmt, fndecl, len, dstsize); + fndecl, len, dstsize); if (nowarn) suppress_warning (stmt, OPT_Wstringop_overflow_); } @@ -2518,8 +2518,8 @@ gimple_fold_builtin_strncat (gimple_stmt_iterator *gsi) of the destination is unknown (it's not an uncommon mistake to specify as the bound to strncpy the length of the source). */ if (warning_at (loc, OPT_Wstringop_overflow_, - "%G%qD specified bound %E equals source length", - stmt, fndecl, len)) + "%qD specified bound %E equals source length", + fndecl, len)) suppress_warning (stmt, OPT_Wstringop_overflow_); } diff --git a/gcc/gimple-ssa-sprintf.c b/gcc/gimple-ssa-sprintf.c index 41e3be6f9f4..f38fb03f068 100644 --- a/gcc/gimple-ssa-sprintf.c +++ b/gcc/gimple-ssa-sprintf.c @@ -3115,9 +3115,8 @@ format_directive (const call_info &info, if (fmtres.nullp) { fmtwarn (dirloc, argloc, NULL, info.warnopt (), - "%G%<%.*s%> directive argument is null", - info.callstmt, dirlen, - target_to_host (hostdir, sizeof hostdir, dir.beg)); + "%<%.*s%> directive argument is null", + dirlen, target_to_host (hostdir, sizeof hostdir, dir.beg)); /* Don't bother processing the rest of the format string. */ res->warned = true; @@ -4620,8 +4619,7 @@ handle_printf_call (gimple_stmt_iterator *gsi, pointer_query &ptr_qry) is not constant. */ location_t loc = gimple_location (info.callstmt); warning_at (EXPR_LOC_OR_LOC (dstptr, loc), - info.warnopt (), "%Gnull destination pointer", - info.callstmt); + info.warnopt (), "null destination pointer"); return false; } @@ -4650,8 +4648,7 @@ handle_printf_call (gimple_stmt_iterator *gsi, pointer_query &ptr_qry) { location_t loc = gimple_location (info.callstmt); warning_at (EXPR_LOC_OR_LOC (info.format, loc), - info.warnopt (), "%Gnull format string", - info.callstmt); + info.warnopt (), "null format string"); return false; } diff --git a/gcc/gimple-ssa-warn-alloca.c b/gcc/gimple-ssa-warn-alloca.c index 72480f1d8cb..4fc7125d378 100644 --- a/gcc/gimple-ssa-warn-alloca.c +++ b/gcc/gimple-ssa-warn-alloca.c @@ -283,7 +283,7 @@ pass_walloca::execute (function *fun) } else if (warn_alloca) { - warning_at (loc, OPT_Walloca, "%Guse of %", stmt); + warning_at (loc, OPT_Walloca, "use of %"); continue; } else if (warn_alloca_limit < 0) @@ -322,11 +322,10 @@ pass_walloca::execute (function *fun) auto_diagnostic_group d; if (warning_at (loc, wcode, (is_vla - ? G_("%Gargument to variable-length " + ? G_("argument to variable-length " "array may be too large") - : G_("%Gargument to % may be too " - "large")), - stmt) + : G_("argument to % may be too " + "large"))) && t.limit != 0) { print_decu (t.limit, buff); @@ -342,10 +341,9 @@ pass_walloca::execute (function *fun) auto_diagnostic_group d; if (warning_at (loc, wcode, (is_vla - ? G_("%Gargument to variable-length" + ? G_("argument to variable-length" " array is too large") - : G_("%Gargument to % is too large")), - stmt) + : G_("argument to % is too large"))) && t.limit != 0) { print_decu (t.limit, buff); @@ -361,22 +359,20 @@ pass_walloca::execute (function *fun) warning_at (loc, wcode, (is_vla - ? G_("%Gunbounded use of variable-length array") - : G_("%Gunbounded use of %")), - stmt); + ? G_("unbounded use of variable-length array") + : G_("unbounded use of %"))); break; case ALLOCA_IN_LOOP: gcc_assert (!is_vla); warning_at (loc, wcode, - "%Guse of % within a loop", stmt); + "use of % within a loop"); break; case ALLOCA_ARG_IS_ZERO: warning_at (loc, wcode, (is_vla - ? G_("%Gargument to variable-length array " + ? G_("argument to variable-length array " "is zero") - : G_("%Gargument to % is zero")), - stmt); + : G_("argument to % is zero"))); break; default: gcc_unreachable (); diff --git a/gcc/gimple-ssa-warn-restrict.c b/gcc/gimple-ssa-warn-restrict.c index 02771e4cd60..efb8db98393 100644 --- a/gcc/gimple-ssa-warn-restrict.c +++ b/gcc/gimple-ssa-warn-restrict.c @@ -1494,36 +1494,36 @@ maybe_diag_overlap (location_t loc, gimple *call, builtin_access &acs) warning_at (loc, OPT_Wrestrict, sizrange[0] == 1 ? (ovlsiz[0] == 1 - ? G_("%G%qD accessing %wu byte at offsets %s " + ? G_("%qD accessing %wu byte at offsets %s " "and %s overlaps %wu byte at offset %s") - : G_("%G%qD accessing %wu byte at offsets %s " + : G_("%qD accessing %wu byte at offsets %s " "and %s overlaps %wu bytes at offset " "%s")) : (ovlsiz[0] == 1 - ? G_("%G%qD accessing %wu bytes at offsets %s " + ? G_("%qD accessing %wu bytes at offsets %s " "and %s overlaps %wu byte at offset %s") - : G_("%G%qD accessing %wu bytes at offsets %s " + : G_("%qD accessing %wu bytes at offsets %s " "and %s overlaps %wu bytes at offset " "%s")), - call, func, sizrange[0], + func, sizrange[0], offstr[0], offstr[1], ovlsiz[0], offstr[2]); else if (ovlsiz[1] >= 0 && ovlsiz[1] < maxobjsize.to_shwi ()) warning_n (loc, OPT_Wrestrict, sizrange[0], - "%G%qD accessing %wu byte at offsets %s " + "%qD accessing %wu byte at offsets %s " "and %s overlaps between %wu and %wu bytes " "at offset %s", - "%G%qD accessing %wu bytes at offsets %s " + "%qD accessing %wu bytes at offsets %s " "and %s overlaps between %wu and %wu bytes " "at offset %s", - call, func, sizrange[0], offstr[0], offstr[1], + func, sizrange[0], offstr[0], offstr[1], ovlsiz[0], ovlsiz[1], offstr[2]); else warning_n (loc, OPT_Wrestrict, sizrange[0], - "%G%qD accessing %wu byte at offsets %s and " + "%qD accessing %wu byte at offsets %s and " "%s overlaps %wu or more bytes at offset %s", - "%G%qD accessing %wu bytes at offsets %s and " + "%qD accessing %wu bytes at offsets %s and " "%s overlaps %wu or more bytes at offset %s", - call, func, sizrange[0], + func, sizrange[0], offstr[0], offstr[1], ovlsiz[0], offstr[2]); return true; } @@ -1532,28 +1532,28 @@ maybe_diag_overlap (location_t loc, gimple *call, builtin_access &acs) { if (ovlsiz[0] == ovlsiz[1]) warning_n (loc, OPT_Wrestrict, ovlsiz[0], - "%G%qD accessing between %wu and %wu bytes " + "%qD accessing between %wu and %wu bytes " "at offsets %s and %s overlaps %wu byte at " "offset %s", - "%G%qD accessing between %wu and %wu bytes " + "%qD accessing between %wu and %wu bytes " "at offsets %s and %s overlaps %wu bytes " "at offset %s", - call, func, sizrange[0], sizrange[1], + func, sizrange[0], sizrange[1], offstr[0], offstr[1], ovlsiz[0], offstr[2]); else if (ovlsiz[1] >= 0 && ovlsiz[1] < maxobjsize.to_shwi ()) warning_at (loc, OPT_Wrestrict, - "%G%qD accessing between %wu and %wu bytes at " + "%qD accessing between %wu and %wu bytes at " "offsets %s and %s overlaps between %wu and %wu " "bytes at offset %s", - call, func, sizrange[0], sizrange[1], + func, sizrange[0], sizrange[1], offstr[0], offstr[1], ovlsiz[0], ovlsiz[1], offstr[2]); else warning_at (loc, OPT_Wrestrict, - "%G%qD accessing between %wu and %wu bytes at " + "%qD accessing between %wu and %wu bytes at " "offsets %s and %s overlaps %wu or more bytes " "at offset %s", - call, func, sizrange[0], sizrange[1], + func, sizrange[0], sizrange[1], offstr[0], offstr[1], ovlsiz[0], offstr[2]); return true; } @@ -1563,24 +1563,24 @@ maybe_diag_overlap (location_t loc, gimple *call, builtin_access &acs) if (ovlsiz[0] == ovlsiz[1]) warning_n (loc, OPT_Wrestrict, ovlsiz[0], - "%G%qD accessing %wu or more bytes at offsets " + "%qD accessing %wu or more bytes at offsets " "%s and %s overlaps %wu byte at offset %s", - "%G%qD accessing %wu or more bytes at offsets " + "%qD accessing %wu or more bytes at offsets " "%s and %s overlaps %wu bytes at offset %s", - call, func, sizrange[0], offstr[0], offstr[1], + func, sizrange[0], offstr[0], offstr[1], ovlsiz[0], offstr[2]); else if (ovlsiz[1] >= 0 && ovlsiz[1] < maxobjsize.to_shwi ()) warning_at (loc, OPT_Wrestrict, - "%G%qD accessing %wu or more bytes at offsets %s " + "%qD accessing %wu or more bytes at offsets %s " "and %s overlaps between %wu and %wu bytes " "at offset %s", - call, func, sizrange[0], offstr[0], offstr[1], + func, sizrange[0], offstr[0], offstr[1], ovlsiz[0], ovlsiz[1], offstr[2]); else warning_at (loc, OPT_Wrestrict, - "%G%qD accessing %wu or more bytes at offsets %s " + "%qD accessing %wu or more bytes at offsets %s " "and %s overlaps %wu or more bytes at offset %s", - call, func, sizrange[0], offstr[0], offstr[1], + func, sizrange[0], offstr[0], offstr[1], ovlsiz[0], offstr[2]); return true; } @@ -1606,36 +1606,36 @@ maybe_diag_overlap (location_t loc, gimple *call, builtin_access &acs) { if (open_range) warning_n (loc, OPT_Wrestrict, sizrange[1], - "%G%qD accessing %wu byte may overlap " + "%qD accessing %wu byte may overlap " "%wu byte", - "%G%qD accessing %wu bytes may overlap " + "%qD accessing %wu bytes may overlap " "%wu byte", - call, func, sizrange[1], ovlsiz[1]); + func, sizrange[1], ovlsiz[1]); else warning_n (loc, OPT_Wrestrict, sizrange[1], - "%G%qD accessing %wu byte at offsets %s " + "%qD accessing %wu byte at offsets %s " "and %s may overlap %wu byte at offset %s", - "%G%qD accessing %wu bytes at offsets %s " + "%qD accessing %wu bytes at offsets %s " "and %s may overlap %wu byte at offset %s", - call, func, sizrange[1], offstr[0], offstr[1], + func, sizrange[1], offstr[0], offstr[1], ovlsiz[1], offstr[2]); return true; } if (open_range) warning_n (loc, OPT_Wrestrict, sizrange[1], - "%G%qD accessing %wu byte may overlap " + "%qD accessing %wu byte may overlap " "up to %wu bytes", - "%G%qD accessing %wu bytes may overlap " + "%qD accessing %wu bytes may overlap " "up to %wu bytes", - call, func, sizrange[1], ovlsiz[1]); + func, sizrange[1], ovlsiz[1]); else warning_n (loc, OPT_Wrestrict, sizrange[1], - "%G%qD accessing %wu byte at offsets %s and " + "%qD accessing %wu byte at offsets %s and " "%s may overlap up to %wu bytes at offset %s", - "%G%qD accessing %wu bytes at offsets %s and " + "%qD accessing %wu bytes at offsets %s and " "%s may overlap up to %wu bytes at offset %s", - call, func, sizrange[1], offstr[0], offstr[1], + func, sizrange[1], offstr[0], offstr[1], ovlsiz[1], offstr[2]); return true; } @@ -1644,30 +1644,30 @@ maybe_diag_overlap (location_t loc, gimple *call, builtin_access &acs) { if (open_range) warning_n (loc, OPT_Wrestrict, ovlsiz[1], - "%G%qD accessing between %wu and %wu bytes " + "%qD accessing between %wu and %wu bytes " "may overlap %wu byte", - "%G%qD accessing between %wu and %wu bytes " + "%qD accessing between %wu and %wu bytes " "may overlap up to %wu bytes", - call, func, sizrange[0], sizrange[1], ovlsiz[1]); + func, sizrange[0], sizrange[1], ovlsiz[1]); else warning_n (loc, OPT_Wrestrict, ovlsiz[1], - "%G%qD accessing between %wu and %wu bytes " + "%qD accessing between %wu and %wu bytes " "at offsets %s and %s may overlap %wu byte " "at offset %s", - "%G%qD accessing between %wu and %wu bytes " + "%qD accessing between %wu and %wu bytes " "at offsets %s and %s may overlap up to %wu " "bytes at offset %s", - call, func, sizrange[0], sizrange[1], + func, sizrange[0], sizrange[1], offstr[0], offstr[1], ovlsiz[1], offstr[2]); return true; } warning_n (loc, OPT_Wrestrict, ovlsiz[1], - "%G%qD accessing %wu or more bytes at offsets %s " + "%qD accessing %wu or more bytes at offsets %s " "and %s may overlap %wu byte at offset %s", - "%G%qD accessing %wu or more bytes at offsets %s " + "%qD accessing %wu or more bytes at offsets %s " "and %s may overlap up to %wu bytes at offset %s", - call, func, sizrange[0], offstr[0], offstr[1], + func, sizrange[0], offstr[0], offstr[1], ovlsiz[1], offstr[2]); return true; @@ -1689,7 +1689,7 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, const builtin_memref &ref, offset_int wroff, bool do_warn) { - location_t loc = gimple_or_expr_nonartificial_location (call, ref.ptr); + location_t loc = gimple_location (call); const offset_int maxobjsize = ref.maxobjsize; /* Check for excessive size first and regardless of warning options @@ -1709,15 +1709,15 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, { if (ref.sizrange[0] == ref.sizrange[1]) warned = warning_at (loc, opt, - "%G%qD specified bound %wu " + "%qD specified bound %wu " "exceeds maximum object size %wu", - call, func, ref.sizrange[0].to_uhwi (), + func, ref.sizrange[0].to_uhwi (), maxobjsize.to_uhwi ()); else warned = warning_at (loc, opt, - "%G%qD specified bound between %wu and %wu " + "%qD specified bound between %wu and %wu " "exceeds maximum object size %wu", - call, func, ref.sizrange[0].to_uhwi (), + func, ref.sizrange[0].to_uhwi (), ref.sizrange[1].to_uhwi (), maxobjsize.to_uhwi ()); return warned ? opt : no_warning; @@ -1776,9 +1776,9 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, { auto_diagnostic_group d; if (warning_at (loc, opt, - "%G%qD pointer overflow between offset %s " + "%qD pointer overflow between offset %s " "and size %s accessing array %qD with type %qT", - call, func, rangestr[0], rangestr[1], ref.base, type)) + func, rangestr[0], rangestr[1], ref.base, type)) { inform (DECL_SOURCE_LOCATION (ref.base), "array %qD declared here", ref.base); @@ -1786,15 +1786,15 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, } else warned = warning_at (loc, opt, - "%G%qD pointer overflow between offset %s " + "%qD pointer overflow between offset %s " "and size %s", - call, func, rangestr[0], rangestr[1]); + func, rangestr[0], rangestr[1]); } else warned = warning_at (loc, opt, - "%G%qD pointer overflow between offset %s " + "%qD pointer overflow between offset %s " "and size %s", - call, func, rangestr[0], rangestr[1]); + func, rangestr[0], rangestr[1]); } else if (oobref == ref.base) { @@ -1809,20 +1809,20 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, if ((ref.basesize < maxobjsize && warning_at (loc, opt, form - ? G_("%G%qD forming offset %s is out of " + ? G_("%qD forming offset %s is out of " "the bounds [0, %wu] of object %qD with " "type %qT") - : G_("%G%qD offset %s is out of the bounds " + : G_("%qD offset %s is out of the bounds " "[0, %wu] of object %qD with type %qT"), - call, func, rangestr[0], ref.basesize.to_uhwi (), + func, rangestr[0], ref.basesize.to_uhwi (), ref.base, TREE_TYPE (ref.base))) || warning_at (loc, opt, form - ? G_("%G%qD forming offset %s is out of " + ? G_("%qD forming offset %s is out of " "the bounds of object %qD with type %qT") - : G_("%G%qD offset %s is out of the bounds " + : G_("%qD offset %s is out of the bounds " "of object %qD with type %qT"), - call, func, rangestr[0], + func, rangestr[0], ref.base, TREE_TYPE (ref.base))) { inform (DECL_SOURCE_LOCATION (ref.base), @@ -1833,17 +1833,17 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, else if (ref.basesize < maxobjsize) warned = warning_at (loc, opt, form - ? G_("%G%qD forming offset %s is out " + ? G_("%qD forming offset %s is out " "of the bounds [0, %wu]") - : G_("%G%qD offset %s is out " + : G_("%qD offset %s is out " "of the bounds [0, %wu]"), - call, func, rangestr[0], ref.basesize.to_uhwi ()); + func, rangestr[0], ref.basesize.to_uhwi ()); else warned = warning_at (loc, opt, form - ? G_("%G%qD forming offset %s is out of bounds") - : G_("%G%qD offset %s is out of bounds"), - call, func, rangestr[0]); + ? G_("%qD forming offset %s is out of bounds") + : G_("%qD offset %s is out of bounds"), + func, rangestr[0]); } else if (TREE_CODE (ref.ref) == MEM_REF) { @@ -1854,9 +1854,9 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, type = TYPE_MAIN_VARIANT (type); if (warning_at (loc, opt, - "%G%qD offset %s from the object at %qE is out " + "%qD offset %s from the object at %qE is out " "of the bounds of %qT", - call, func, rangestr[0], ref.base, type)) + func, rangestr[0], ref.base, type)) { if (TREE_CODE (ref.ref) == COMPONENT_REF) refop = TREE_OPERAND (ref.ref, 1); @@ -1872,10 +1872,10 @@ maybe_diag_access_bounds (gimple *call, tree func, int strict, tree type = TYPE_MAIN_VARIANT (TREE_TYPE (ref.ref)); if (warning_at (loc, opt, - "%G%qD offset %s from the object at %qE is out " + "%qD offset %s from the object at %qE is out " "of the bounds of referenced subobject %qD with " "type %qT at offset %wi", - call, func, rangestr[0], ref.base, + func, rangestr[0], ref.base, TREE_OPERAND (ref.ref, 1), type, ref.refoff.to_shwi ())) { @@ -2065,7 +2065,7 @@ check_bounds_or_overlap (range_query *query, } } - location_t loc = gimple_or_expr_nonartificial_location (call, dst); + location_t loc = gimple_location (call); if (operand_equal_p (dst, src, 0)) { /* Issue -Wrestrict unless the pointers are null (those do @@ -2075,8 +2075,8 @@ check_bounds_or_overlap (range_query *query, if (!integer_zerop (dst) && !warning_suppressed_p (call, OPT_Wrestrict)) { warning_at (loc, OPT_Wrestrict, - "%G%qD source argument is the same as destination", - call, func); + "%qD source argument is the same as destination", + func); suppress_warning (call, OPT_Wrestrict); return OPT_Wrestrict; } diff --git a/gcc/testsuite/gcc.dg/Wfree-nonheap-object-4.c b/gcc/testsuite/gcc.dg/Wfree-nonheap-object-4.c index a7d921248c4..fdef9e6b3ea 100644 --- a/gcc/testsuite/gcc.dg/Wfree-nonheap-object-4.c +++ b/gcc/testsuite/gcc.dg/Wfree-nonheap-object-4.c @@ -26,7 +26,7 @@ void g2 (struct A *p) { g1 (p); } #define NOIPA __attribute__ ((noipa)) -extern int array[]; +extern int array[]; // { dg-message "declared here" "note on line 29" } /* Verify the warning is issued even for calls in a system header inlined into a function outside the header. */ @@ -39,7 +39,7 @@ NOIPA void warn_g0 (struct A *p) g0 (p); } -// { dg-message "inlined from 'warn_g0'" "" { target *-*-* } 0 } +// { dg-message "inlined from 'warn_g0'" "note on line 42" { target *-*-* } 0 } /* Also verify the warning can be suppressed. */ @@ -65,8 +65,8 @@ NOIPA void warn_g1 (struct A *p) g1 (p); } -// { dg-message "inlined from 'g1'" "" { target *-*-* } 0 } -// { dg-message "inlined from 'warn_g1'" "" { target *-*-* } 0 } +// { dg-message "inlined from 'g1'" "note on line 68" { target *-*-* } 0 } +// { dg-message "inlined from 'warn_g1'" "note on line 69" { target *-*-* } 0 } NOIPA void nowarn_g1 (struct A *p) @@ -90,8 +90,8 @@ NOIPA void warn_g2 (struct A *p) g2 (p); } -// { dg-message "inlined from 'g2'" "" { target *-*-* } 0 } -// { dg-message "inlined from 'warn_g2'" "" { target *-*-* } 0 } +// { dg-message "inlined from 'g2'" "note on line 93" { target *-*-* } 0 } +// { dg-message "inlined from 'warn_g2'" "note on line 94" { target *-*-* } 0 } NOIPA void nowarn_g2 (struct A *p) diff --git a/gcc/testsuite/gcc.dg/Wobjsize-1.c b/gcc/testsuite/gcc.dg/Wobjsize-1.c index e80c8add3bb..2bd2f93897b 100644 --- a/gcc/testsuite/gcc.dg/Wobjsize-1.c +++ b/gcc/testsuite/gcc.dg/Wobjsize-1.c @@ -4,13 +4,17 @@ #include "Wobjsize-1.h" char buf[6]; -/* { dg-warning "writing" "" { target *-*-* } .-1 } */ int main(int argc, char **argv) { - strcpy (buf,"hello "); + strcpy (buf,"hello "); /* { dg-warning "\\\[-Wstringop-overflow" } */ return 0; } -/* { dg-message "file included" "included" { target *-*-* } 0 } */ -/* { dg-message "inlined from" "inlined" { target *-*-* } 0 } */ +/* { dg-message "file included" "included" { target *-*-* } 0 } + { dg-message "inlined from" "inlined" { target *-*-* } 0 } + + The test might emit two warnings, one for the strcpy call and + another for the inlined call to __builtin___strcpy_chk() called + from strcpy(). + { dg-prune-output "writing 7 bytes into a region of size 6" } */ diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index e74bd1f5ec0..c270d039b15 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -4413,12 +4413,8 @@ ipa_tm_scan_irr_block (basic_block bb) is to wrap it in a __tm_waiver block. This is not yet implemented, so we can't check for it. */ if (is_tm_safe (current_function_decl)) - { - tree t = build1 (NOP_EXPR, void_type_node, size_zero_node); - SET_EXPR_LOCATION (t, gimple_location (stmt)); - error ("%K% not allowed in % function", - t); - } + error_at (gimple_location (stmt), + "% not allowed in % function"); return true; default: diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index 42585412325..9ce6214d7e2 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -3563,7 +3563,7 @@ pass_post_ipa_warn::execute (function *fun) if (argno == 0) { if (warning_at (loc, OPT_Wnonnull, - "%G%qs pointer is null", stmt, "this") + "%qs pointer is null", "this") && fndecl) inform (DECL_SOURCE_LOCATION (fndecl), "in a call to non-static member function %qD", @@ -3572,8 +3572,8 @@ pass_post_ipa_warn::execute (function *fun) } if (!warning_at (loc, OPT_Wnonnull, - "%Gargument %u null where non-null " - "expected", stmt, argno)) + "argument %u null where non-null " + "expected", argno)) continue; tree fndecl = gimple_call_fndecl (stmt); diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c index 13ea107da17..94257df1067 100644 --- a/gcc/tree-ssa-strlen.c +++ b/gcc/tree-ssa-strlen.c @@ -2022,13 +2022,12 @@ maybe_warn_overflow (gimple *stmt, tree len, pointer_query &ptr_qry, warned = (writefn ? warning_at (loc, OPT_Wstringop_overflow_, - "%G%qD writing one too many bytes into a region " + "%qD writing one too many bytes into a region " "of a size that depends on %", - stmt, writefn) + writefn) : warning_at (loc, OPT_Wstringop_overflow_, - "%Gwriting one too many bytes into a region " - "of a size that depends on %", - stmt)); + "writing one too many bytes into a region " + "of a size that depends on %")); } else if (lenrng[0] == lenrng[1]) { @@ -2036,65 +2035,65 @@ maybe_warn_overflow (gimple *stmt, tree len, pointer_query &ptr_qry, warned = (writefn ? warning_n (loc, OPT_Wstringop_overflow_, lenrng[0].to_uhwi (), - "%G%qD writing %wu byte into a region " + "%qD writing %wu byte into a region " "of size %wu", - "%G%qD writing %wu bytes into a region " + "%qD writing %wu bytes into a region " "of size %wu", - stmt, writefn, lenrng[0].to_uhwi (), + writefn, lenrng[0].to_uhwi (), spcrng[0].to_uhwi ()) : warning_n (loc, OPT_Wstringop_overflow_, lenrng[0].to_uhwi (), - "%Gwriting %wu byte into a region " + "writing %wu byte into a region " "of size %wu", - "%Gwriting %wu bytes into a region " + "writing %wu bytes into a region " "of size %wu", - stmt, lenrng[0].to_uhwi (), + lenrng[0].to_uhwi (), spcrng[0].to_uhwi ())); else warned = (writefn ? warning_n (loc, OPT_Wstringop_overflow_, lenrng[0].to_uhwi (), - "%G%qD writing %wu byte into a region " + "%qD writing %wu byte into a region " "of size between %wu and %wu", - "%G%qD writing %wu bytes into a region " + "%qD writing %wu bytes into a region " "of size between %wu and %wu", - stmt, writefn, lenrng[0].to_uhwi (), + writefn, lenrng[0].to_uhwi (), spcrng[0].to_uhwi (), spcrng[1].to_uhwi ()) : warning_n (loc, OPT_Wstringop_overflow_, lenrng[0].to_uhwi (), - "%Gwriting %wu byte into a region " + "writing %wu byte into a region " "of size between %wu and %wu", - "%Gwriting %wu bytes into a region " + "writing %wu bytes into a region " "of size between %wu and %wu", - stmt, lenrng[0].to_uhwi (), + lenrng[0].to_uhwi (), spcrng[0].to_uhwi (), spcrng[1].to_uhwi ())); } else if (spcrng[0] == spcrng[1]) warned = (writefn ? warning_at (loc, OPT_Wstringop_overflow_, - "%G%qD writing between %wu and %wu bytes " + "%qD writing between %wu and %wu bytes " "into a region of size %wu", - stmt, writefn, lenrng[0].to_uhwi (), + writefn, lenrng[0].to_uhwi (), lenrng[1].to_uhwi (), spcrng[0].to_uhwi ()) : warning_at (loc, OPT_Wstringop_overflow_, - "%Gwriting between %wu and %wu bytes " + "writing between %wu and %wu bytes " "into a region of size %wu", - stmt, lenrng[0].to_uhwi (), + lenrng[0].to_uhwi (), lenrng[1].to_uhwi (), spcrng[0].to_uhwi ())); else warned = (writefn ? warning_at (loc, OPT_Wstringop_overflow_, - "%G%qD writing between %wu and %wu bytes " + "%qD writing between %wu and %wu bytes " "into a region of size between %wu and %wu", - stmt, writefn, lenrng[0].to_uhwi (), + writefn, lenrng[0].to_uhwi (), lenrng[1].to_uhwi (), spcrng[0].to_uhwi (), spcrng[1].to_uhwi ()) : warning_at (loc, OPT_Wstringop_overflow_, - "%Gwriting between %wu and %wu bytes " + "writing between %wu and %wu bytes " "into a region of size between %wu and %wu", - stmt, lenrng[0].to_uhwi (), + lenrng[0].to_uhwi (), lenrng[1].to_uhwi (), spcrng[0].to_uhwi (), spcrng[1].to_uhwi ())); @@ -2985,13 +2984,13 @@ maybe_diag_stxncpy_trunc (gimple_stmt_iterator gsi, tree src, tree cnt, if (lenrange[0] == cntrange[1] && cntrange[0] == cntrange[1]) return warning_n (callloc, OPT_Wstringop_truncation, cntrange[0].to_uhwi (), - "%G%qD output truncated before terminating " + "%qD output truncated before terminating " "nul copying %E byte from a string of the " "same length", - "%G%qD output truncated before terminating nul " + "%qD output truncated before terminating nul " "copying %E bytes from a string of the same " "length", - stmt, func, cnt); + func, cnt); else if (!cat_dstlen_bounded) { if (wi::geu_p (lenrange[0], cntrange[1])) @@ -3001,16 +3000,16 @@ maybe_diag_stxncpy_trunc (gimple_stmt_iterator gsi, tree src, tree cnt, if (cntrange[0] == cntrange[1]) return warning_n (callloc, OPT_Wstringop_truncation, cntrange[0].to_uhwi (), - "%G%qD output truncated copying %E byte " + "%qD output truncated copying %E byte " "from a string of length %wu", - "%G%qD output truncated copying %E bytes " + "%qD output truncated copying %E bytes " "from a string of length %wu", - stmt, func, cnt, lenrange[0].to_uhwi ()); + func, cnt, lenrange[0].to_uhwi ()); return warning_at (callloc, OPT_Wstringop_truncation, - "%G%qD output truncated copying between %wu " + "%qD output truncated copying between %wu " "and %wu bytes from a string of length %wu", - stmt, func, cntrange[0].to_uhwi (), + func, cntrange[0].to_uhwi (), cntrange[1].to_uhwi (), lenrange[0].to_uhwi ()); } else if (wi::geu_p (lenrange[1], cntrange[1])) @@ -3020,16 +3019,16 @@ maybe_diag_stxncpy_trunc (gimple_stmt_iterator gsi, tree src, tree cnt, if (cntrange[0] == cntrange[1]) return warning_n (callloc, OPT_Wstringop_truncation, cntrange[0].to_uhwi (), - "%G%qD output may be truncated copying %E " + "%qD output may be truncated copying %E " "byte from a string of length %wu", - "%G%qD output may be truncated copying %E " + "%qD output may be truncated copying %E " "bytes from a string of length %wu", - stmt, func, cnt, lenrange[1].to_uhwi ()); + func, cnt, lenrange[1].to_uhwi ()); return warning_at (callloc, OPT_Wstringop_truncation, - "%G%qD output may be truncated copying between " + "%qD output may be truncated copying between " "%wu and %wu bytes from a string of length %wu", - stmt, func, cntrange[0].to_uhwi (), + func, cntrange[0].to_uhwi (), cntrange[1].to_uhwi (), lenrange[1].to_uhwi ()); } } @@ -3043,9 +3042,9 @@ maybe_diag_stxncpy_trunc (gimple_stmt_iterator gsi, tree src, tree cnt, the lower bound of the specified count but shorter than the upper bound the copy may (but need not) be truncated. */ return warning_at (callloc, OPT_Wstringop_truncation, - "%G%qD output may be truncated copying between " + "%qD output may be truncated copying between " "%wu and %wu bytes from a string of length %wu", - stmt, func, cntrange[0].to_uhwi (), + func, cntrange[0].to_uhwi (), cntrange[1].to_uhwi (), lenrange[0].to_uhwi ()); } } @@ -3072,8 +3071,8 @@ maybe_diag_stxncpy_trunc (gimple_stmt_iterator gsi, tree src, tree cnt, if (cntrange[0] == cntrange[1]) return warning_at (callloc, OPT_Wstringop_truncation, - "%G%qD specified bound %E equals destination size", - stmt, func, cnt); + "%qD specified bound %E equals destination size", + func, cnt); } return false; @@ -3197,9 +3196,9 @@ handle_builtin_stxncpy_strncat (bool append_p, gimple_stmt_iterator *gsi) && sisrc == silen && is_strlen_related_p (src, len) && warning_at (callloc, OPT_Wstringop_truncation, - "%G%qD output truncated before terminating nul " + "%qD output truncated before terminating nul " "copying as many bytes from a string as its length", - stmt, func)) + func)) warned = true; else if ((append_p || !dstsize || len == dstlenp1) && silen && is_strlen_related_p (src, silen->ptr)) @@ -3210,9 +3209,9 @@ handle_builtin_stxncpy_strncat (bool append_p, gimple_stmt_iterator *gsi) opt_code opt = (append_p || dstsize ? OPT_Wstringop_overflow_ : OPT_Wstringop_truncation); warned = warning_at (callloc, opt, - "%G%qD specified bound depends on the length " + "%qD specified bound depends on the length " "of the source argument", - stmt, func); + func); } if (warned) { @@ -4141,24 +4140,24 @@ maybe_warn_pointless_strcmp (gimple *stmt, HOST_WIDE_INT bound, if (siz <= minlen && bound == -1) warned = warning_at (stmt_loc, OPT_Wstring_compare, (at_least - ? G_("%G%qD of a string of length %wu or more and " + ? G_("%qD of a string of length %wu or more and " "an array of size %wu evaluates to nonzero") - : G_("%G%qD of a string of length %wu and an array " + : G_("%qD of a string of length %wu and an array " "of size %wu evaluates to nonzero")), - stmt, callee, minlen, siz); + callee, minlen, siz); else if (!at_least && siz <= HOST_WIDE_INT_MAX) { if (len[0] != HOST_WIDE_INT_MAX && len[1] != HOST_WIDE_INT_MAX) warned = warning_at (stmt_loc, OPT_Wstring_compare, - "%G%qD of strings of length %wu and %wu " + "%qD of strings of length %wu and %wu " "and bound of %wu evaluates to nonzero", - stmt, callee, len[0], len[1], bound); + callee, len[0], len[1], bound); else warned = warning_at (stmt_loc, OPT_Wstring_compare, - "%G%qD of a string of length %wu, an array " + "%qD of a string of length %wu, an array " "of size %wu and bound of %wu evaluates to " "nonzero", - stmt, callee, minlen, siz, bound); + callee, minlen, siz, bound); } if (!warned) diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c index 99442d7f975..24ac031a693 100644 --- a/gcc/tree-ssa-uninit.c +++ b/gcc/tree-ssa-uninit.c @@ -444,7 +444,7 @@ maybe_warn_operand (ao_ref &ref, gimple *stmt, tree lhs, tree rhs, if (wlims.always_executed) { if (warning_at (location, OPT_Wuninitialized, - "%G%qE is used uninitialized", stmt, rhs)) + "%qE is used uninitialized", rhs)) { /* ??? This is only effective for decls as in gcc.dg/uninit-B-O0.c. Avoid doing this for maybe-uninit @@ -457,7 +457,7 @@ maybe_warn_operand (ao_ref &ref, gimple *stmt, tree lhs, tree rhs, } else if (wlims.wmaybe_uninit) warned = warning_at (location, OPT_Wmaybe_uninitialized, - "%G%qE may be used uninitialized", stmt, rhs); + "%qE may be used uninitialized", rhs); return warned ? base : NULL_TREE; }