From patchwork Sat Oct 5 07:44:10 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bernd Edlinger X-Patchwork-Id: 1172133 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-510335-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=hotmail.de Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="cfq8P4lP"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 46ldzt74xHz9sNw for ; Sat, 5 Oct 2019 17:44:26 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:content-type:mime-version; q=dns; s= default; b=HN267c8xk8w0VpeWgXmKoLCD2WHmEHf8Z53Rvq/afSE8QBslOYz3H 7hnCtiHxXJjkodVpKG7vZmWXOuOoX7kcEqKD9PPRA5lWYx4iEkRSKcLrxaJ7czqy zSU47LXX0dl9+fEIHO9UkKeHaG5426tbVARGtpi5e8J8YEA0x7WN+M= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:date:message-id:content-type:mime-version; s= default; bh=amGXPr1qVFE2Kr1SZBTus2s0M2g=; b=cfq8P4lPghJMfXymHwGe Wkcg0RuQ6M8J+u8UQHcmaGad8mKBsBBiTca9Vp1ncYctn1X8Urex01ZE6DYqs1Uh ZYU6cySg7L0W+S0JQ6RHKNh+vBLX0OoweRdQYoqoCYKvefT01fafIbH4TWo1Fb3N zLsa6Lq8dIvW3Ohn+u4KPJA= Received: (qmail 62750 invoked by alias); 5 Oct 2019 07:44:17 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 61836 invoked by uid 89); 5 Oct 2019 07:44:17 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.3 required=5.0 tests=AWL, BAYES_00, FREEMAIL_FROM, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.1 spammy= X-HELO: EUR02-AM5-obe.outbound.protection.outlook.com Received: from mail-oln040092067109.outbound.protection.outlook.com (HELO EUR02-AM5-obe.outbound.protection.outlook.com) (40.92.67.109) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Sat, 05 Oct 2019 07:44:13 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=lwTT8+VOT71IfBhcWnzNffvvvf1aSaxUrZWIv54oabo3AbvZ7wNHrYRGUaINctcGnreOcQYRHQ5WgdzL8I3CuEfF/9GRaJ0asMF7gBECkKxGZZYQ21ui+z9OaSPGNvOlLIMqHYbE5Pb7TLIR9MED4oqZcLM1EEEcZsA1SMPbCOB0he609FywRZ/1yibn9+irjIqSPiu0i3B7eQMdPAT7FcGWwfym5gitpfVh6ZrbwQttLFjNV9rW53iVe4vrBGulI4aKMky4miREhcMdaxyWxVc/+IhLKK+k9aY+URIfY6eyFY2lUEbG9MQ5DQVjx6iGIeP4H8hGUP2FD2hszNlJQA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=E67tFuACQSJ9CdCLn+RHWI7r9SSiQINK8u4rZ+mG4ZM=; b=d2tFE3mp60jNw6s9EJ/jfzJxU2bHCjJECW8DOMHrbtlaLbMabzbldR4ozUjtaLN2Mfg5Uiig6TLb+QZI/NS4ehqG5LomVagVADSVTtzpsrNWUvXg/wAx+NMSQNV22uOnO3WyltkYIAMyVWVOqsLxlq5xnrPR/7u9cdE4AVJBTBUKfjfMjO0Dlrd+JfDkNEyWeIQ3OoJJWAwC4ZAXkmBiUAyuvvoI6rgagyYTzM+yVQR5Kkn7F0LrrD2WYdmKotXvFRQY75MoMjPlPdIYk2W+odtP0efr0EYOd7znjRHbd6xb9YNYc8uCwTtVzokSuM3kUoiVafKb635LgDsf3+1coQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=none; dmarc=none; dkim=none; arc=none Received: from VE1EUR02FT047.eop-EUR02.prod.protection.outlook.com (10.152.12.57) by VE1EUR02HT033.eop-EUR02.prod.protection.outlook.com (10.152.13.36) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2327.20; Sat, 5 Oct 2019 07:44:10 +0000 Received: from VI1PR03MB4528.eurprd03.prod.outlook.com (10.152.12.55) by VE1EUR02FT047.mail.protection.outlook.com (10.152.13.237) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2327.20 via Frontend Transport; Sat, 5 Oct 2019 07:44:10 +0000 Received: from VI1PR03MB4528.eurprd03.prod.outlook.com ([fe80::1917:2b45:72b0:548a]) by VI1PR03MB4528.eurprd03.prod.outlook.com ([fe80::1917:2b45:72b0:548a%7]) with mapi id 15.20.2327.023; Sat, 5 Oct 2019 07:44:10 +0000 From: Bernd Edlinger To: "gcc-patches@gcc.gnu.org" Subject: [PATCH, OBVIOUS] Fix -Wshadow=local warnings in gcc/[d-f]*.c Date: Sat, 5 Oct 2019 07:44:10 +0000 Message-ID: x-microsoft-original-message-id: <4bd103c5-b543-135d-831d-af476c3e1d45@hotmail.de> x-ms-exchange-transport-forked: True MIME-Version: 1.0 Hi, this fixes -Wshadow=local warnings in the following files: M gcc/df-problems.c M gcc/df-scan.c M gcc/diagnostic-show-locus.c M gcc/dse.c M gcc/dwarf2cfi.c M gcc/dwarf2out.c M gcc/emit-rtl.c M gcc/expmed.c M gcc/final.c M gcc/fold-const.c M gcc/function.c M gcc/fwprop.c I consider them obvious but will not commit them before monday, to give you all a chance to look at the changes, and request changes, if you like, for instance better variable names or so. Bootstrapped and reg-tested on x86_64-pc-linux-gnu. Thanks Bernd. 2019-10-05 Bernd Edlinger * df-problems.c (df_rd_transfer_function): Remove shadowing local vars. (df_word_lr_local_compute, df_md_local_compute): Rename local var. * df-scan.c (df_insn_rescan): Remove shadowing local var. * diagnostic-show-locus.c (layout::print_leading_fixits): Rename local var. * dse.c (check_mem_read_use, get_call_args): Rename local var. * dwarf2cfi.c (change_cfi_row): Remove shadowing local var. (create_trace_edges): Rename local var. Remove shadowing local var. * dwarf2out.c (build_abbrev_table): Remove shadowing local var. (output_die): Rename local vars. (loc_descriptor): Remove shadowing local var. * emit-rtl.c (widen_memory_access, find_auto_inc): Rename local var. * expmed.c (extract_integral_bit_field, expand_divmod): Remove shadowing local var. (emit_cstore): Rename local var. * final.c (shorten_branches): Remove shadowing local vars. Rename local var. (final_scan_insn_1): Rename local vars. Remove shadowing local var. (mark_symbol_refs_as_used): Rename local var. * fold-const.c (fold_unary_loc, fold_comparison, fold_binary_loc, fold_ternary_loc): Remove shadowing local var. Rename local var. * function.c (instantiate_virtual_regs_in_rtx): Rename local var. * fwprop.c (forward_propagate_and_simplify): Remove shadowing local var. Index: gcc/df-problems.c =================================================================== --- gcc/df-problems.c (revision 276598) +++ gcc/df-problems.c (working copy) @@ -529,11 +529,9 @@ df_rd_transfer_function (int bb_index) basic block, and mask out DEFs of registers that are not live. Computing the mask looks costly, but the benefit of the pruning outweighs the cost. */ - class df_rd_bb_info *bb_info = df_rd_get_bb_info (bb_index); + bb_info = df_rd_get_bb_info (bb_index); bitmap regs_live_out = &df_lr_get_bb_info (bb_index)->out; bitmap live_defs = BITMAP_ALLOC (&df_bitmap_obstack); - unsigned int regno; - bitmap_iterator bi; EXECUTE_IF_SET_IN_BITMAP (regs_live_out, 0, regno, bi) bitmap_set_range (live_defs, @@ -2902,9 +2900,9 @@ df_word_lr_local_compute (bitmap all_blocks ATTRIB if (bb_index == EXIT_BLOCK) { unsigned regno; - bitmap_iterator bi; + bitmap_iterator bi1; EXECUTE_IF_SET_IN_BITMAP (df->exit_block_uses, FIRST_PSEUDO_REGISTER, - regno, bi) + regno, bi1) gcc_unreachable (); } else @@ -4554,7 +4552,7 @@ df_md_local_compute (bitmap all_blocks) bitmap kill = &df_md_get_bb_info (bb_index)->kill; EXECUTE_IF_SET_IN_BITMAP (&frontiers[bb_index], 0, df_bb_index, bi2) { - basic_block bb = BASIC_BLOCK_FOR_FN (cfun, df_bb_index); + bb = BASIC_BLOCK_FOR_FN (cfun, df_bb_index); if (bitmap_bit_p (all_blocks, df_bb_index)) bitmap_ior_and_into (&df_md_get_bb_info (df_bb_index)->init, kill, df_get_live_in (bb)); Index: gcc/df-scan.c =================================================================== --- gcc/df-scan.c (revision 276598) +++ gcc/df-scan.c (working copy) @@ -1083,7 +1083,7 @@ df_insn_rescan (rtx_insn *insn) } else { - struct df_insn_info *insn_info = df_insn_create_insn_record (insn); + insn_info = df_insn_create_insn_record (insn); df_insn_refs_collect (&collection_rec, bb, insn_info); if (dump_file) fprintf (dump_file, "scanning new insn with uid = %d.\n", uid); Index: gcc/diagnostic-show-locus.c =================================================================== --- gcc/diagnostic-show-locus.c (revision 276598) +++ gcc/diagnostic-show-locus.c (working copy) @@ -1625,8 +1625,8 @@ layout::print_leading_fixits (linenum_type row) /* Print all but the trailing newline of the fix-it hint. We have to print the newline separately to avoid getting additional pp prefixes printed. */ - for (size_t i = 0; i < hint->get_length () - 1; i++) - pp_character (m_pp, hint->get_string ()[i]); + for (size_t j = 0; j < hint->get_length () - 1; j++) + pp_character (m_pp, hint->get_string ()[j]); m_colorizer.set_normal_text (); pp_newline (m_pp); } Index: gcc/dse.c =================================================================== --- gcc/dse.c (revision 276598) +++ gcc/dse.c (working copy) @@ -2312,9 +2312,9 @@ check_mem_read_use (rtx *loc, void *data) subrtx_ptr_iterator::array_type array; FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST) { - rtx *loc = *iter; - if (MEM_P (*loc)) - check_mem_read_rtx (loc, (bb_info_t) data); + rtx *loc1 = *iter; + if (MEM_P (*loc1)) + check_mem_read_rtx (loc1, (bb_info_t) data); } } @@ -2344,8 +2344,8 @@ get_call_args (rtx call_insn, tree fn, rtx *args, if (!is_int_mode (TYPE_MODE (TREE_VALUE (arg)), &mode)) return false; - function_arg_info arg (mode, /*named=*/true); - reg = targetm.calls.function_arg (args_so_far, arg); + function_arg_info arg_info (mode, /*named=*/true); + reg = targetm.calls.function_arg (args_so_far, arg_info); if (!reg || !REG_P (reg) || GET_MODE (reg) != mode) return false; @@ -2377,7 +2377,7 @@ get_call_args (rtx call_insn, tree fn, rtx *args, if (tmp) args[idx] = tmp; - targetm.calls.function_arg_advance (args_so_far, arg); + targetm.calls.function_arg_advance (args_so_far, arg_info); } if (arg != void_list_node || idx != nargs) return false; Index: gcc/dwarf2cfi.c =================================================================== --- gcc/dwarf2cfi.c (revision 276598) +++ gcc/dwarf2cfi.c (working copy) @@ -2216,8 +2216,7 @@ change_cfi_row (dw_cfi_row *old_row, dw_cfi_row *n if (!old_row->window_save && new_row->window_save) { - dw_cfi_ref cfi = new_cfi (); - + cfi = new_cfi (); cfi->dw_cfi_opc = DW_CFA_GNU_window_save; add_cfi (cfi); } @@ -2456,8 +2455,8 @@ create_trace_edges (rtx_insn *insn) else if (computed_jump_p (insn)) { rtx_insn *temp; - unsigned int i; - FOR_EACH_VEC_SAFE_ELT (forced_labels, i, temp) + unsigned int k; + FOR_EACH_VEC_SAFE_ELT (forced_labels, k, temp) maybe_record_trace_start (temp, insn); } else if (returnjump_p (insn)) @@ -2494,7 +2493,7 @@ create_trace_edges (rtx_insn *insn) } else if (rtx_sequence *seq = dyn_cast (PATTERN (insn))) { - int i, n = seq->len (); + n = seq->len (); for (i = 0; i < n; ++i) create_trace_edges (seq->insn (i)); return; Index: gcc/dwarf2out.c =================================================================== --- gcc/dwarf2out.c (revision 276598) +++ gcc/dwarf2out.c (working copy) @@ -9098,7 +9098,6 @@ build_abbrev_table (dw_die_ref die, external_ref_h FOR_EACH_VEC_SAFE_ELT (abbrev_die_table, abbrev_id, abbrev) { dw_attr_node *die_a, *abbrev_a; - unsigned ix; bool ok = true; if (abbrev_id == 0) @@ -10804,7 +10803,7 @@ output_die (dw_die_ref die) else { const char *sym = AT_ref (a)->die_id.die_symbol; - int size; + int asize; gcc_assert (sym); /* In DWARF2, DW_FORM_ref_addr is sized by target address @@ -10811,9 +10810,9 @@ output_die (dw_die_ref die) length, whereas in DWARF3 it's always sized as an offset. */ if (dwarf_version == 2) - size = DWARF2_ADDR_SIZE; + asize = DWARF2_ADDR_SIZE; else - size = DWARF_OFFSET_SIZE; + asize = DWARF_OFFSET_SIZE; /* ??? We cannot unconditionally output die_offset if non-zero - others might create references to those DIEs via symbols. @@ -10823,10 +10822,10 @@ output_die (dw_die_ref die) would be the correct thing to do). ??? This is the reason for the with_offset flag. */ if (AT_ref (a)->with_offset) - dw2_asm_output_offset (size, sym, AT_ref (a)->die_offset, + dw2_asm_output_offset (asize, sym, AT_ref (a)->die_offset, debug_info_section, "%s", name); else - dw2_asm_output_offset (size, sym, debug_info_section, "%s", + dw2_asm_output_offset (asize, sym, debug_info_section, "%s", name); } } @@ -10937,10 +10936,10 @@ output_die (dw_die_ref die) case dw_val_class_discr_list: { dw_discr_list_ref list = AT_discr_list (a); - const int size = size_of_discr_list (list); + const int csize = size_of_discr_list (list); /* This is a block, so output its length first. */ - dw2_asm_output_data (constant_size (size), size, + dw2_asm_output_data (constant_size (csize), csize, "%s: block size", name); for (; list != NULL; list = list->dw_discr_next) @@ -16667,7 +16666,6 @@ loc_descriptor (rtx rtl, machine_mode mode, { rtvec par_elems = XVEC (rtl, 0); int num_elem = GET_NUM_ELEM (par_elems); - machine_mode mode; int i, size; /* Create the first one, so we have something to add to. */ Index: gcc/emit-rtl.c =================================================================== --- gcc/emit-rtl.c (revision 276598) +++ gcc/emit-rtl.c (working copy) @@ -2624,7 +2624,7 @@ widen_memory_access (rtx memref, machine_mode mode if (TREE_CODE (attrs.expr) == COMPONENT_REF) { tree field = TREE_OPERAND (attrs.expr, 1); - tree offset = component_ref_field_offset (attrs.expr); + tree offset1 = component_ref_field_offset (attrs.expr); if (! DECL_SIZE_UNIT (field)) { @@ -2640,7 +2640,7 @@ widen_memory_access (rtx memref, machine_mode mode break; poly_uint64 suboffset; - if (!poly_int_tree_p (offset, &suboffset)) + if (!poly_int_tree_p (offset1, &suboffset)) { attrs.expr = NULL_TREE; break; @@ -3813,9 +3813,9 @@ find_auto_inc (const_rtx x, const_rtx reg) subrtx_iterator::array_type array; FOR_EACH_SUBRTX (iter, array, x, NONCONST) { - const_rtx x = *iter; - if (GET_RTX_CLASS (GET_CODE (x)) == RTX_AUTOINC - && rtx_equal_p (reg, XEXP (x, 0))) + const_rtx y = *iter; + if (GET_RTX_CLASS (GET_CODE (y)) == RTX_AUTOINC + && rtx_equal_p (reg, XEXP (y, 0))) return true; } return false; Index: gcc/expmed.c =================================================================== --- gcc/expmed.c (revision 276598) +++ gcc/expmed.c (working copy) @@ -1909,7 +1909,7 @@ extract_integral_bit_field (rtx op0, opt_scalar_in need to be zero'd out. */ if (target_size > nwords * UNITS_PER_WORD) { - unsigned int i, total_words; + unsigned int total_words; total_words = target_size / UNITS_PER_WORD; for (i = nwords; i < total_words; i++) @@ -5105,7 +5105,6 @@ expand_divmod (int rem_flag, enum tree_code code, remainder = gen_reg_rtx (int_mode); if (expand_twoval_binop (udivmod_optab, op0, op1, quotient, remainder, 1) == 0) { - rtx tem; quotient = expand_binop (int_mode, udiv_optab, op0, op1, quotient, 1, OPTAB_LIB_WIDEN); tem = expand_mult (int_mode, quotient, op1, NULL_RTX, 1); @@ -5130,7 +5129,6 @@ expand_divmod (int rem_flag, enum tree_code code, remainder = gen_reg_rtx (int_mode); if (expand_twoval_binop (sdivmod_optab, op0, op1, quotient, remainder, 0) == 0) { - rtx tem; quotient = expand_binop (int_mode, sdiv_optab, op0, op1, quotient, 0, OPTAB_LIB_WIDEN); tem = expand_mult (int_mode, quotient, op1, NULL_RTX, 0); @@ -5479,8 +5477,8 @@ emit_cstore (rtx target, enum insn_code icode, enu gcc_assert (GET_MODE_PRECISION (result_mode) != 1 || STORE_FLAG_VALUE == 1 || STORE_FLAG_VALUE == -1); - bool unsignedp = (STORE_FLAG_VALUE >= 0); - convert_move (target, subtarget, unsignedp); + bool unsigned_cvt = (STORE_FLAG_VALUE >= 0); + convert_move (target, subtarget, unsigned_cvt); op0 = target; result_mode = int_target_mode; Index: gcc/final.c =================================================================== --- gcc/final.c (revision 276598) +++ gcc/final.c (working copy) @@ -893,7 +893,7 @@ shorten_branches (rtx_insn *first) rtx_jump_table_data *table = jump_table_for_label (label); if (!table) { - align_flags alignment = LABEL_ALIGN (label); + alignment = LABEL_ALIGN (label); max_alignment = align_flags::max (max_alignment, alignment); } /* ADDR_VECs only take room if read-only data goes into the text @@ -902,7 +902,7 @@ shorten_branches (rtx_insn *first) || readonly_data_section == text_section) && table) { - align_flags alignment = align_flags (ADDR_VEC_ALIGN (table)); + alignment = align_flags (ADDR_VEC_ALIGN (table)); max_alignment = align_flags::max (max_alignment, alignment); } LABEL_TO_ALIGNMENT (label) = max_alignment; @@ -910,11 +910,11 @@ shorten_branches (rtx_insn *first) } else if (BARRIER_P (insn)) { - rtx_insn *label; + rtx_insn *label1; - for (label = insn; label && ! INSN_P (label); - label = NEXT_INSN (label)) - if (LABEL_P (label)) + for (label1 = insn; label1 && ! INSN_P (label1); + label1 = NEXT_INSN (label1)) + if (LABEL_P (label1)) { align_flags alignment = align_flags (LABEL_ALIGN_AFTER_BARRIER (insn)); @@ -947,8 +947,9 @@ shorten_branches (rtx_insn *first) seq = get_last_insn (); for (; seq; seq = PREV_INSN (seq)) { - int uid = INSN_UID (seq); int log; + + uid = INSN_UID (seq); log = (LABEL_P (seq) ? LABEL_TO_ALIGNMENT (seq).levels[0].log : 0); uid_align[uid] = align_tab[0]; if (log) @@ -980,7 +981,7 @@ shorten_branches (rtx_insn *first) for (insn = first; insn != 0; insn = NEXT_INSN (insn)) { rtx min_lab = NULL_RTX, max_lab = NULL_RTX, pat; - int len, i, min, max, insn_shuid; + int len, min, max, insn_shuid; int min_align; addr_diff_vec_flags flags; @@ -1075,7 +1076,6 @@ shorten_branches (rtx_insn *first) insn_lengths[uid] = asm_insn_count (body) * insn_default_length (insn); else if (rtx_sequence *body_seq = dyn_cast (body)) { - int i; int const_delay_slots; if (DELAY_SLOTS) const_delay_slots = const_num_delay_slots (body_seq->insn (0)); @@ -1200,7 +1200,7 @@ shorten_branches (rtx_insn *first) && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC) { rtx_jump_table_data *table = as_a (insn); - rtx body = PATTERN (insn); + body = PATTERN (insn); int old_length = insn_lengths[uid]; rtx_insn *rel_lab = safe_as_a (XEXP (XEXP (body, 0), 0)); @@ -1317,8 +1317,6 @@ shorten_branches (rtx_insn *first) if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE) { - int i; - body = PATTERN (insn); for (i = 0; i < XVECLEN (body, 0); i++) { @@ -1339,7 +1337,6 @@ shorten_branches (rtx_insn *first) if (NONJUMP_INSN_P (insn) && GET_CODE (PATTERN (insn)) == SEQUENCE) { rtx_sequence *seqn = as_a (PATTERN (insn)); - int i; body = PATTERN (insn); new_length = 0; @@ -2751,13 +2748,13 @@ final_scan_insn_1 (rtx_insn *insn, FILE *file, int for (i = 1; i < seq->len (); i++) { - rtx_insn *insn = seq->insn (i); - rtx_insn *next = NEXT_INSN (insn); + rtx_insn *insn1 = seq->insn (i); + rtx_insn *next1 = NEXT_INSN (insn1); /* We loop in case any instruction in a delay slot gets split. */ do - insn = final_scan_insn (insn, file, 0, 1, seen); - while (insn != next); + insn1 = final_scan_insn (insn1, file, 0, 1, seen); + while (insn1 != next1); } #ifdef DBR_OUTPUT_SEQEND DBR_OUTPUT_SEQEND (file); @@ -2960,7 +2957,7 @@ final_scan_insn_1 (rtx_insn *insn, FILE *file, int if (HAVE_peephole && optimize_p && !flag_no_peephole && !nopeepholes) { - rtx_insn *next = peephole (insn); + next = peephole (insn); /* When peepholing, if there were notes within the peephole, emit them before the peephole. */ if (next != 0 && next != NEXT_INSN (insn)) @@ -4023,9 +4020,9 @@ mark_symbol_refs_as_used (rtx x) subrtx_iterator::array_type array; FOR_EACH_SUBRTX (iter, array, x, ALL) { - const_rtx x = *iter; - if (GET_CODE (x) == SYMBOL_REF) - if (tree t = SYMBOL_REF_DECL (x)) + const_rtx y = *iter; + if (GET_CODE (y) == SYMBOL_REF) + if (tree t = SYMBOL_REF_DECL (y)) assemble_external (t); } } Index: gcc/fold-const.c =================================================================== --- gcc/fold-const.c (revision 276598) +++ gcc/fold-const.c (working copy) @@ -7824,7 +7824,7 @@ fold_unary_loc (location_t loc, enum tree_code cod if (CONSTANT_CLASS_P (arg0)) { - tree tem = const_unop (code, type, arg0); + tem = const_unop (code, type, arg0); if (tem) { if (TREE_TYPE (tem) != type) @@ -8586,11 +8586,11 @@ fold_comparison (location_t loc, enum tree_code co TREE_OPERAND (arg0, 1)); if (poly_int_tree_p (offset0)) { - poly_offset_int tem = wi::sext (wi::to_poly_offset (offset0), - TYPE_PRECISION (sizetype)); - tem <<= LOG2_BITS_PER_UNIT; - tem += bitpos0; - if (tem.to_shwi (&bitpos0)) + poly_offset_int tem0 = wi::sext (wi::to_poly_offset (offset0), + TYPE_PRECISION (sizetype)); + tem0 <<= LOG2_BITS_PER_UNIT; + tem0 += bitpos0; + if (tem0.to_shwi (&bitpos0)) offset0 = NULL_TREE; } } @@ -8629,11 +8629,11 @@ fold_comparison (location_t loc, enum tree_code co TREE_OPERAND (arg1, 1)); if (poly_int_tree_p (offset1)) { - poly_offset_int tem = wi::sext (wi::to_poly_offset (offset1), - TYPE_PRECISION (sizetype)); - tem <<= LOG2_BITS_PER_UNIT; - tem += bitpos1; - if (tem.to_shwi (&bitpos1)) + poly_offset_int tem1 = wi::sext (wi::to_poly_offset (offset1), + TYPE_PRECISION (sizetype)); + tem1 <<= LOG2_BITS_PER_UNIT; + tem1 += bitpos1; + if (tem1.to_shwi (&bitpos1)) offset1 = NULL_TREE; } } @@ -9561,7 +9561,7 @@ fold_binary_loc (location_t loc, enum tree_code co && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1)) && (!FLOAT_TYPE_P (type) || flag_associative_math)) { - tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1); + tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1); if (tem) return tem; } @@ -9986,11 +9986,10 @@ fold_binary_loc (location_t loc, enum tree_code co && TREE_CODE (arg1) == ADDR_EXPR && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF) { - tree tem = fold_addr_of_array_ref_difference (loc, type, - TREE_OPERAND (arg0, 0), - TREE_OPERAND (arg1, 0), - code - == POINTER_DIFF_EXPR); + tem = fold_addr_of_array_ref_difference (loc, type, + TREE_OPERAND (arg0, 0), + TREE_OPERAND (arg1, 0), + code == POINTER_DIFF_EXPR); if (tem) return tem; } @@ -10074,7 +10073,7 @@ fold_binary_loc (location_t loc, enum tree_code co && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (TREE_TYPE (arg1)) && (!FLOAT_TYPE_P (type) || flag_associative_math)) { - tree tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1); + tem = fold_plusminus_mult_expr (loc, code, type, arg0, arg1); if (tem) return tem; } @@ -10676,10 +10675,10 @@ fold_binary_loc (location_t loc, enum tree_code co if (TREE_CODE (arg00) == LSHIFT_EXPR && integer_onep (TREE_OPERAND (arg00, 0))) { - tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00), - arg01, TREE_OPERAND (arg00, 1)); + tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg00), + arg01, TREE_OPERAND (arg00, 1)); tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem, - build_int_cst (TREE_TYPE (arg0), 1)); + build_int_cst (TREE_TYPE (arg0), 1)); return fold_build2_loc (loc, code, type, fold_convert_loc (loc, TREE_TYPE (arg1), tem), arg1); @@ -10687,10 +10686,10 @@ fold_binary_loc (location_t loc, enum tree_code co else if (TREE_CODE (arg01) == LSHIFT_EXPR && integer_onep (TREE_OPERAND (arg01, 0))) { - tree tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01), - arg00, TREE_OPERAND (arg01, 1)); + tem = fold_build2_loc (loc, RSHIFT_EXPR, TREE_TYPE (arg01), + arg00, TREE_OPERAND (arg01, 1)); tem = fold_build2_loc (loc, BIT_AND_EXPR, TREE_TYPE (arg0), tem, - build_int_cst (TREE_TYPE (arg0), 1)); + build_int_cst (TREE_TYPE (arg0), 1)); return fold_build2_loc (loc, code, type, fold_convert_loc (loc, TREE_TYPE (arg1), tem), arg1); @@ -11603,7 +11602,7 @@ fold_ternary_loc (location_t loc, enum tree_code c && integer_zerop (op2) && integer_pow2p (arg1)) { - tree tem = TREE_OPERAND (arg0, 0); + tem = TREE_OPERAND (arg0, 0); STRIP_NOPS (tem); if (TREE_CODE (tem) == RSHIFT_EXPR && tree_fits_uhwi_p (TREE_OPERAND (tem, 1)) @@ -11800,13 +11799,13 @@ fold_ternary_loc (location_t loc, enum tree_code c { unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (op2); unsigned bitsize = TYPE_PRECISION (TREE_TYPE (arg1)); - wide_int tem = (wi::to_wide (arg0) - & wi::shifted_mask (bitpos, bitsize, true, - TYPE_PRECISION (type))); + wide_int tem1 = (wi::to_wide (arg0) + & wi::shifted_mask (bitpos, bitsize, true, + TYPE_PRECISION (type))); wide_int tem2 = wi::lshift (wi::zext (wi::to_wide (arg1, TYPE_PRECISION (type)), bitsize), bitpos); - return wide_int_to_tree (type, wi::bit_or (tem, tem2)); + return wide_int_to_tree (type, wi::bit_or (tem1, tem2)); } else if (TREE_CODE (arg0) == VECTOR_CST && CONSTANT_CLASS_P (arg1) Index: gcc/function.c =================================================================== --- gcc/function.c (revision 276598) +++ gcc/function.c (working copy) @@ -1486,8 +1486,8 @@ instantiate_virtual_regs_in_rtx (rtx *loc) subrtx_ptr_iterator::array_type array; FOR_EACH_SUBRTX_PTR (iter, array, loc, NONCONST) { - rtx *loc = *iter; - if (rtx x = *loc) + rtx *loc1 = *iter; + if (rtx x = *loc1) { rtx new_rtx; poly_int64 offset; @@ -1497,7 +1497,7 @@ instantiate_virtual_regs_in_rtx (rtx *loc) new_rtx = instantiate_new_reg (x, &offset); if (new_rtx) { - *loc = plus_constant (GET_MODE (x), new_rtx, offset); + *loc1 = plus_constant (GET_MODE (x), new_rtx, offset); changed = true; } iter.skip_subrtxes (); @@ -1508,7 +1508,7 @@ instantiate_virtual_regs_in_rtx (rtx *loc) if (new_rtx) { XEXP (x, 0) = new_rtx; - *loc = plus_constant (GET_MODE (x), x, offset, true); + *loc1 = plus_constant (GET_MODE (x), x, offset, true); changed = true; iter.skip_subrtxes (); break; Index: gcc/fwprop.c =================================================================== --- gcc/fwprop.c (revision 276598) +++ gcc/fwprop.c (working copy) @@ -1361,7 +1361,7 @@ forward_propagate_and_simplify (df_ref use, rtx_in { rtx note = find_reg_note (use_insn, REG_EQUAL, NULL_RTX); rtx old_rtx = note ? XEXP (note, 0) : SET_SRC (use_set); - rtx new_rtx = simplify_replace_rtx (old_rtx, src, x); + new_rtx = simplify_replace_rtx (old_rtx, src, x); if (old_rtx != new_rtx) set_unique_reg_note (use_insn, REG_EQUAL, copy_rtx (new_rtx)); }