diff options
| author | rsandifo <rsandifo@138bc75d-0d04-0410-961f-82ee72b054a4> | 2013-09-28 08:42:34 +0000 |
|---|---|---|
| committer | rsandifo <rsandifo@138bc75d-0d04-0410-961f-82ee72b054a4> | 2013-09-28 08:42:34 +0000 |
| commit | 9af5ce0cdcae10ebe09a9b1d081bccfaa9b1248c (patch) | |
| tree | d508fc7773e01b720c3929468a0618058edbf8f9 | |
| parent | 3f71db404b5e3a91a324663f76d92c0300c24fe0 (diff) | |
| download | gcc-9af5ce0cdcae10ebe09a9b1d081bccfaa9b1248c.tar.gz | |
gcc/
* alloc-pool.c, asan.c, auto-inc-dec.c, basic-block.h, bb-reorder.c,
bitmap.c, bitmap.h, bt-load.c, builtins.c, calls.c, cfgcleanup.c,
cfgexpand.c, cfghooks.c, cfgloop.c, cfgloopmanip.c, cfgrtl.c, cgraph.c,
cgraph.h, cgraphbuild.c, cgraphclones.c, cgraphunit.c, collect2.c,
combine-stack-adj.c, combine.c, compare-elim.c, context.c, context.h,
cprop.c, cse.c, cselib.c, dbxout.c, dce.c, defaults.h, df-core.c,
df-problems.c, df-scan.c, df.h, diagnostic.c, double-int.c, dse.c,
dumpfile.c, dwarf2asm.c, dwarf2cfi.c, dwarf2out.c, emit-rtl.c,
errors.c, except.c, expmed.c, expr.c, file-find.c, final.c,
fixed-value.c, fold-const.c, function.c, fwprop.c, gcc-ar.c, gcc.c,
gcov-io.c, gcov-io.h, gcov.c, gcse.c, genattr-common.c, genattr.c,
genattrtab.c, genautomata.c, genconfig.c, genemit.c, genextract.c,
genflags.c, gengenrtl.c, gengtype-state.c, gengtype.c, genmodes.c,
genopinit.c, genoutput.c, genpeep.c, genpreds.c, genrecog.c,
gensupport.c, ggc-common.c, ggc-page.c, gimple-fold.c, gimple-low.c,
gimple-pretty-print.c, gimple-ssa-strength-reduction.c, gimple.c,
gimple.h, godump.c, graphite-clast-to-gimple.c,
graphite-optimize-isl.c, graphite-poly.h, graphite-sese-to-poly.c,
graphite.c, haifa-sched.c, hash-table.c, hash-table.h, hwint.c,
hwint.h, ifcvt.c, incpath.c, init-regs.c, input.h, intl.c, intl.h,
ipa-cp.c, ipa-devirt.c, ipa-inline-analysis.c, ipa-inline.c,
ipa-profile.c, ipa-pure-const.c, ipa-reference.c, ipa-split.c,
ipa-utils.c, ipa.c, ira-build.c, ira.c, jump.c, loop-doloop.c,
loop-init.c, loop-invariant.c, loop-iv.c, lower-subreg.c, lto-cgraph.c,
lto-streamer-in.c, lto-streamer-out.c, lto-wrapper.c, mcf.c,
mode-switching.c, modulo-sched.c, omp-low.c, optabs.c, opts.c,
pass_manager.h, passes.c, plugin.c, postreload-gcse.c, postreload.c,
predict.c, prefix.c, pretty-print.c, print-rtl.c, print-tree.c,
profile.c, read-md.c, real.c, real.h, recog.c, ree.c, reg-stack.c,
regcprop.c, reginfo.c, regmove.c, regrename.c, regs.h, regstat.c,
reload1.c, reorg.c, rtl.c, rtl.h, rtlanal.c, sbitmap.c, sched-rgn.c,
sdbout.c, sel-sched-ir.c, sel-sched.c, sparseset.c, stack-ptr-mod.c,
statistics.c, stmt.c, stor-layout.c, store-motion.c, streamer-hooks.h,
system.h, target-hooks-macros.h, targhooks.c, targhooks.h, toplev.c,
tracer.c, trans-mem.c, tree-browser.c, tree-call-cdce.c, tree-cfg.c,
tree-cfgcleanup.c, tree-complex.c, tree-data-ref.c, tree-data-ref.h,
tree-eh.c, tree-emutls.c, tree-flow.h, tree-if-conv.c, tree-into-ssa.c,
tree-iterator.c, tree-loop-distribution.c, tree-mudflap.c,
tree-nested.c, tree-nomudflap.c, tree-nrv.c, tree-object-size.c,
tree-optimize.c, tree-pass.h, tree-pretty-print.c, tree-profile.c,
tree-scalar-evolution.c, tree-sra.c, tree-ssa-ccp.c,
tree-ssa-coalesce.c, tree-ssa-copy.c, tree-ssa-copyrename.c,
tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-dse.c, tree-ssa-forwprop.c,
tree-ssa-ifcombine.c, tree-ssa-live.c, tree-ssa-loop-ch.c,
tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-loop-prefetch.c,
tree-ssa-loop.c, tree-ssa-math-opts.c, tree-ssa-operands.c,
tree-ssa-phiopt.c, tree-ssa-phiprop.c, tree-ssa-pre.c,
tree-ssa-reassoc.c, tree-ssa-sink.c, tree-ssa-strlen.c,
tree-ssa-structalias.c, tree-ssa-threadedge.c, tree-ssa-threadupdate.c,
tree-ssa-uncprop.c, tree-ssa-uninit.c, tree-ssa.c, tree-ssanames.c,
tree-stdarg.c, tree-switch-conversion.c, tree-tailcall.c,
tree-vect-data-refs.c, tree-vect-generic.c, tree-vect-loop-manip.c,
tree-vect-stmts.c, tree-vectorizer.c, tree-vectorizer.h, tree-vrp.c,
tree.c, tree.h, tsan.c, tsystem.h, value-prof.c, var-tracking.c,
varasm.c, vec.h, vmsdbgout.c, vtable-verify.c, web.c: Add missing
whitespace before "(".
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@203004 138bc75d-0d04-0410-961f-82ee72b054a4
256 files changed, 1612 insertions, 1529 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 125ac612388..1e9839a8eb0 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,62 @@ +2013-09-28 Richard Sandiford <rdsandiford@googlemail.com> + + * alloc-pool.c, asan.c, auto-inc-dec.c, basic-block.h, bb-reorder.c, + bitmap.c, bitmap.h, bt-load.c, builtins.c, calls.c, cfgcleanup.c, + cfgexpand.c, cfghooks.c, cfgloop.c, cfgloopmanip.c, cfgrtl.c, cgraph.c, + cgraph.h, cgraphbuild.c, cgraphclones.c, cgraphunit.c, collect2.c, + combine-stack-adj.c, combine.c, compare-elim.c, context.c, context.h, + cprop.c, cse.c, cselib.c, dbxout.c, dce.c, defaults.h, df-core.c, + df-problems.c, df-scan.c, df.h, diagnostic.c, double-int.c, dse.c, + dumpfile.c, dwarf2asm.c, dwarf2cfi.c, dwarf2out.c, emit-rtl.c, + errors.c, except.c, expmed.c, expr.c, file-find.c, final.c, + fixed-value.c, fold-const.c, function.c, fwprop.c, gcc-ar.c, gcc.c, + gcov-io.c, gcov-io.h, gcov.c, gcse.c, genattr-common.c, genattr.c, + genattrtab.c, genautomata.c, genconfig.c, genemit.c, genextract.c, + genflags.c, gengenrtl.c, gengtype-state.c, gengtype.c, genmodes.c, + genopinit.c, genoutput.c, genpeep.c, genpreds.c, genrecog.c, + gensupport.c, ggc-common.c, ggc-page.c, gimple-fold.c, gimple-low.c, + gimple-pretty-print.c, gimple-ssa-strength-reduction.c, gimple.c, + gimple.h, godump.c, graphite-clast-to-gimple.c, + graphite-optimize-isl.c, graphite-poly.h, graphite-sese-to-poly.c, + graphite.c, haifa-sched.c, hash-table.c, hash-table.h, hwint.c, + hwint.h, ifcvt.c, incpath.c, init-regs.c, input.h, intl.c, intl.h, + ipa-cp.c, ipa-devirt.c, ipa-inline-analysis.c, ipa-inline.c, + ipa-profile.c, ipa-pure-const.c, ipa-reference.c, ipa-split.c, + ipa-utils.c, ipa.c, ira-build.c, ira.c, jump.c, loop-doloop.c, + loop-init.c, loop-invariant.c, loop-iv.c, lower-subreg.c, lto-cgraph.c, + lto-streamer-in.c, lto-streamer-out.c, lto-wrapper.c, mcf.c, + mode-switching.c, modulo-sched.c, omp-low.c, optabs.c, opts.c, + pass_manager.h, passes.c, plugin.c, postreload-gcse.c, postreload.c, + predict.c, prefix.c, pretty-print.c, print-rtl.c, print-tree.c, + profile.c, read-md.c, real.c, real.h, recog.c, ree.c, reg-stack.c, + regcprop.c, reginfo.c, regmove.c, regrename.c, regs.h, regstat.c, + reload1.c, reorg.c, rtl.c, rtl.h, rtlanal.c, sbitmap.c, sched-rgn.c, + sdbout.c, sel-sched-ir.c, sel-sched.c, sparseset.c, stack-ptr-mod.c, + statistics.c, stmt.c, stor-layout.c, store-motion.c, streamer-hooks.h, + system.h, target-hooks-macros.h, targhooks.c, targhooks.h, toplev.c, + tracer.c, trans-mem.c, tree-browser.c, tree-call-cdce.c, tree-cfg.c, + tree-cfgcleanup.c, tree-complex.c, tree-data-ref.c, tree-data-ref.h, + tree-eh.c, tree-emutls.c, tree-flow.h, tree-if-conv.c, tree-into-ssa.c, + tree-iterator.c, tree-loop-distribution.c, tree-mudflap.c, + tree-nested.c, tree-nomudflap.c, tree-nrv.c, tree-object-size.c, + tree-optimize.c, tree-pass.h, tree-pretty-print.c, tree-profile.c, + tree-scalar-evolution.c, tree-sra.c, tree-ssa-ccp.c, + tree-ssa-coalesce.c, tree-ssa-copy.c, tree-ssa-copyrename.c, + tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-dse.c, tree-ssa-forwprop.c, + tree-ssa-ifcombine.c, tree-ssa-live.c, tree-ssa-loop-ch.c, + tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-loop-prefetch.c, + tree-ssa-loop.c, tree-ssa-math-opts.c, tree-ssa-operands.c, + tree-ssa-phiopt.c, tree-ssa-phiprop.c, tree-ssa-pre.c, + tree-ssa-reassoc.c, tree-ssa-sink.c, tree-ssa-strlen.c, + tree-ssa-structalias.c, tree-ssa-threadedge.c, tree-ssa-threadupdate.c, + tree-ssa-uncprop.c, tree-ssa-uninit.c, tree-ssa.c, tree-ssanames.c, + tree-stdarg.c, tree-switch-conversion.c, tree-tailcall.c, + tree-vect-data-refs.c, tree-vect-generic.c, tree-vect-loop-manip.c, + tree-vect-stmts.c, tree-vectorizer.c, tree-vectorizer.h, tree-vrp.c, + tree.c, tree.h, tsan.c, tsystem.h, value-prof.c, var-tracking.c, + varasm.c, vec.h, vmsdbgout.c, vtable-verify.c, web.c: Add missing + whitespace before "(". + 2013-09-28 Sandra Loosemore <sandra@codesourcery.com> * expr.h (extract_bit_field): Remove packedp parameter. diff --git a/gcc/alloc-pool.c b/gcc/alloc-pool.c index 65907544565..64535685de0 100644 --- a/gcc/alloc-pool.c +++ b/gcc/alloc-pool.c @@ -316,7 +316,7 @@ pool_alloc (alloc_pool pool) /* Pull the first free element from the free list, and return it. */ header = pool->returned_free_list; - VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (header, sizeof(*header))); + VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (header, sizeof (*header))); pool->returned_free_list = header->next; pool->elts_free--; diff --git a/gcc/asan.c b/gcc/asan.c index 2e1fb0e4082..688c2310e81 100644 --- a/gcc/asan.c +++ b/gcc/asan.c @@ -2268,8 +2268,8 @@ const pass_data pass_data_asan = class pass_asan : public gimple_opt_pass { public: - pass_asan(gcc::context *ctxt) - : gimple_opt_pass(pass_data_asan, ctxt) + pass_asan (gcc::context *ctxt) + : gimple_opt_pass (pass_data_asan, ctxt) {} /* opt_pass methods: */ @@ -2314,8 +2314,8 @@ const pass_data pass_data_asan_O0 = class pass_asan_O0 : public gimple_opt_pass { public: - pass_asan_O0(gcc::context *ctxt) - : gimple_opt_pass(pass_data_asan_O0, ctxt) + pass_asan_O0 (gcc::context *ctxt) + : gimple_opt_pass (pass_data_asan_O0, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/auto-inc-dec.c b/gcc/auto-inc-dec.c index 0d92b1d79b5..6006b70c085 100644 --- a/gcc/auto-inc-dec.c +++ b/gcc/auto-inc-dec.c @@ -1452,9 +1452,9 @@ merge_in_block (int max_reg, basic_block bb) { /* In this case, we must clear these vectors since the trick of testing if the stale insn in the block will not work. */ - memset (reg_next_use, 0, max_reg * sizeof(rtx)); - memset (reg_next_inc_use, 0, max_reg * sizeof(rtx)); - memset (reg_next_def, 0, max_reg * sizeof(rtx)); + memset (reg_next_use, 0, max_reg * sizeof (rtx)); + memset (reg_next_inc_use, 0, max_reg * sizeof (rtx)); + memset (reg_next_def, 0, max_reg * sizeof (rtx)); df_recompute_luids (bb); merge_in_block (max_reg, bb); } @@ -1526,8 +1526,8 @@ const pass_data pass_data_inc_dec = class pass_inc_dec : public rtl_opt_pass { public: - pass_inc_dec(gcc::context *ctxt) - : rtl_opt_pass(pass_data_inc_dec, ctxt) + pass_inc_dec (gcc::context *ctxt) + : rtl_opt_pass (pass_data_inc_dec, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/basic-block.h b/gcc/basic-block.h index ad04d4de83e..b68cb453d36 100644 --- a/gcc/basic-block.h +++ b/gcc/basic-block.h @@ -214,8 +214,8 @@ struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_d struct rtl_bb_info, so that inlining the former into basic_block_def is the better choice. */ typedef int __assert_gimple_bb_smaller_rtl_bb - [(int)sizeof(struct rtl_bb_info) - - (int)sizeof (struct gimple_bb_info)]; + [(int) sizeof (struct rtl_bb_info) + - (int) sizeof (struct gimple_bb_info)]; #define BB_FREQ_MAX 10000 @@ -324,9 +324,9 @@ struct GTY(()) control_flow_graph { #define profile_status_for_function(FN) ((FN)->cfg->x_profile_status) #define BASIC_BLOCK_FOR_FUNCTION(FN,N) \ - ((*basic_block_info_for_function(FN))[(N)]) + ((*basic_block_info_for_function (FN))[(N)]) #define SET_BASIC_BLOCK_FOR_FUNCTION(FN,N,BB) \ - ((*basic_block_info_for_function(FN))[(N)] = (BB)) + ((*basic_block_info_for_function (FN))[(N)] = (BB)) /* Defines for textual backward source compatibility. */ #define ENTRY_BLOCK_PTR (cfun->cfg->x_entry_block_ptr) @@ -353,7 +353,7 @@ struct GTY(()) control_flow_graph { #define FOR_EACH_BB_REVERSE_FN(BB, FN) \ FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb) -#define FOR_EACH_BB_REVERSE(BB) FOR_EACH_BB_REVERSE_FN(BB, cfun) +#define FOR_EACH_BB_REVERSE(BB) FOR_EACH_BB_REVERSE_FN (BB, cfun) /* For iterating over insns in basic block. */ #define FOR_BB_INSNS(BB, INSN) \ @@ -951,7 +951,7 @@ extern void default_rtl_profile (void); /* In profile.c. */ typedef struct gcov_working_set_info gcov_working_set_t; -extern gcov_working_set_t *find_working_set(unsigned pct_times_10); +extern gcov_working_set_t *find_working_set (unsigned pct_times_10); /* Check tha probability is sane. */ diff --git a/gcc/bb-reorder.c b/gcc/bb-reorder.c index 6b034aba5c9..b89f9855e77 100644 --- a/gcc/bb-reorder.c +++ b/gcc/bb-reorder.c @@ -2329,8 +2329,8 @@ const pass_data pass_data_reorder_blocks = class pass_reorder_blocks : public rtl_opt_pass { public: - pass_reorder_blocks(gcc::context *ctxt) - : rtl_opt_pass(pass_data_reorder_blocks, ctxt) + pass_reorder_blocks (gcc::context *ctxt) + : rtl_opt_pass (pass_data_reorder_blocks, ctxt) {} /* opt_pass methods: */ @@ -2495,8 +2495,8 @@ const pass_data pass_data_duplicate_computed_gotos = class pass_duplicate_computed_gotos : public rtl_opt_pass { public: - pass_duplicate_computed_gotos(gcc::context *ctxt) - : rtl_opt_pass(pass_data_duplicate_computed_gotos, ctxt) + pass_duplicate_computed_gotos (gcc::context *ctxt) + : rtl_opt_pass (pass_data_duplicate_computed_gotos, ctxt) {} /* opt_pass methods: */ @@ -2719,8 +2719,8 @@ const pass_data pass_data_partition_blocks = class pass_partition_blocks : public rtl_opt_pass { public: - pass_partition_blocks(gcc::context *ctxt) - : rtl_opt_pass(pass_data_partition_blocks, ctxt) + pass_partition_blocks (gcc::context *ctxt) + : rtl_opt_pass (pass_data_partition_blocks, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/bitmap.c b/gcc/bitmap.c index 2c5d228fdd1..ecaca42d00e 100644 --- a/gcc/bitmap.c +++ b/gcc/bitmap.c @@ -811,7 +811,7 @@ bitmap_first_set_bit (const_bitmap a) bit_no += ix * BITMAP_WORD_BITS; #if GCC_VERSION >= 3004 - gcc_assert (sizeof(long) == sizeof (word)); + gcc_assert (sizeof (long) == sizeof (word)); bit_no += __builtin_ctzl (word); #else /* Binary search for the first set bit. */ @@ -863,7 +863,7 @@ bitmap_last_set_bit (const_bitmap a) found_bit: bit_no += ix * BITMAP_WORD_BITS; #if GCC_VERSION >= 3004 - gcc_assert (sizeof(long) == sizeof (word)); + gcc_assert (sizeof (long) == sizeof (word)); bit_no += BITMAP_WORD_BITS - __builtin_clzl (word) - 1; #else /* Hopefully this is a twos-complement host... */ diff --git a/gcc/bitmap.h b/gcc/bitmap.h index ada414d8836..b3cb5da98e9 100644 --- a/gcc/bitmap.h +++ b/gcc/bitmap.h @@ -300,7 +300,7 @@ extern unsigned bitmap_first_set_bit (const_bitmap); extern unsigned bitmap_last_set_bit (const_bitmap); /* Compute bitmap hash (for purposes of hashing etc.) */ -extern hashval_t bitmap_hash(const_bitmap); +extern hashval_t bitmap_hash (const_bitmap); /* Allocate a bitmap from a bit obstack. */ #define BITMAP_ALLOC(OBSTACK) bitmap_obstack_alloc (OBSTACK) diff --git a/gcc/bt-load.c b/gcc/bt-load.c index b53435680ec..5384d01d525 100644 --- a/gcc/bt-load.c +++ b/gcc/bt-load.c @@ -605,7 +605,7 @@ compute_defs_uses_and_gen (fibheap_t all_btr_defs, btr_def *def_array, } if (dump_file) - dump_btrs_live(i); + dump_btrs_live (i); } } @@ -691,13 +691,13 @@ link_btr_uses (btr_def *def_array, btr_user *use_array, sbitmap *bb_out, for this one. */ bitmap_and_compl (reaching_defs, reaching_defs, btr_defset[def->btr - first_btr]); - bitmap_set_bit(reaching_defs, insn_uid); + bitmap_set_bit (reaching_defs, insn_uid); } if (user != NULL) { /* Find all the reaching defs for this use. */ - sbitmap reaching_defs_of_reg = sbitmap_alloc(max_uid); + sbitmap reaching_defs_of_reg = sbitmap_alloc (max_uid); unsigned int uid = 0; sbitmap_iterator sbi; @@ -1363,7 +1363,7 @@ migrate_btr_def (btr_def def, int min_cost) if (btr != -1) { move_btr_def (attempt, btr, def, live_range, &btrs_live_in_range); - bitmap_copy(live_range, def->live_range); + bitmap_copy (live_range, def->live_range); btr_used_near_def = 0; def_moved = 1; def_basic_block_freq = basic_block_freq (def->bb); @@ -1406,11 +1406,11 @@ migrate_btr_defs (enum reg_class btr_class, int allow_callee_save) for (i = NUM_FIXED_BLOCKS; i < last_basic_block; i++) { basic_block bb = BASIC_BLOCK (i); - fprintf(dump_file, - "Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC - " loop-depth = %d idom = %d\n", - i, (HOST_WIDEST_INT) bb->count, bb_loop_depth (bb), - get_immediate_dominator (CDI_DOMINATORS, bb)->index); + fprintf (dump_file, + "Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC + " loop-depth = %d idom = %d\n", + i, (HOST_WIDEST_INT) bb->count, bb_loop_depth (bb), + get_immediate_dominator (CDI_DOMINATORS, bb)->index); } } @@ -1524,8 +1524,8 @@ const pass_data pass_data_branch_target_load_optimize1 = class pass_branch_target_load_optimize1 : public rtl_opt_pass { public: - pass_branch_target_load_optimize1(gcc::context *ctxt) - : rtl_opt_pass(pass_data_branch_target_load_optimize1, ctxt) + pass_branch_target_load_optimize1 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_branch_target_load_optimize1, ctxt) {} /* opt_pass methods: */ @@ -1593,8 +1593,8 @@ const pass_data pass_data_branch_target_load_optimize2 = class pass_branch_target_load_optimize2 : public rtl_opt_pass { public: - pass_branch_target_load_optimize2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_branch_target_load_optimize2, ctxt) + pass_branch_target_load_optimize2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_branch_target_load_optimize2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/builtins.c b/gcc/builtins.c index d19ca68baba..3b16d592db4 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -1703,7 +1703,7 @@ expand_builtin_apply (rtx function, rtx arguments, rtx argsize) else #endif emit_stack_restore (SAVE_BLOCK, old_stack_level); - fixup_args_size_notes (call_insn, get_last_insn(), 0); + fixup_args_size_notes (call_insn, get_last_insn (), 0); OK_DEFER_POP; @@ -4172,7 +4172,7 @@ std_canonical_va_list_type (tree type) if (INDIRECT_REF_P (type)) type = TREE_TYPE (type); - else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type))) + else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE (type))) type = TREE_TYPE (type); wtype = va_list_type_node; htype = type; @@ -5342,7 +5342,7 @@ get_memmodel (tree exp) return MEMMODEL_SEQ_CST; } - if ((INTVAL(op) & MEMMODEL_MASK) >= MEMMODEL_LAST) + if ((INTVAL (op) & MEMMODEL_MASK) >= MEMMODEL_LAST) { warning (OPT_Winvalid_memory_model, "invalid memory model argument to builtin"); @@ -5546,7 +5546,7 @@ expand_builtin_atomic_fetch_op (enum machine_mode mode, tree exp, rtx target, STRIP_NOPS (addr); gcc_assert (TREE_OPERAND (addr, 0) == fndecl); - TREE_OPERAND (addr, 0) = builtin_decl_explicit(ext_call); + TREE_OPERAND (addr, 0) = builtin_decl_explicit (ext_call); /* Expand the call here so we can emit trailing code. */ ret = expand_call (exp, target, ignore); @@ -9644,8 +9644,8 @@ static tree fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type) { if (validate_arg (arg0, REAL_TYPE) - && validate_arg(arg1, REAL_TYPE) - && validate_arg(arg2, REAL_TYPE)) + && validate_arg (arg1, REAL_TYPE) + && validate_arg (arg2, REAL_TYPE)) { tree tem = fold_fma (loc, type, arg0, arg1, arg2); if (tem) @@ -10387,13 +10387,13 @@ fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore) break; CASE_FLT_FN (BUILT_IN_CCOS): - return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false); + return fold_builtin_ccos (loc, arg0, type, fndecl, /*hyper=*/ false); CASE_FLT_FN (BUILT_IN_CCOSH): - return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true); + return fold_builtin_ccos (loc, arg0, type, fndecl, /*hyper=*/ true); CASE_FLT_FN (BUILT_IN_CPROJ): - return fold_builtin_cproj(loc, arg0, type); + return fold_builtin_cproj (loc, arg0, type); CASE_FLT_FN (BUILT_IN_CSIN): if (validate_arg (arg0, COMPLEX_TYPE) @@ -10768,26 +10768,26 @@ fold_builtin_2 (location_t loc, tree fndecl, tree arg0, tree arg1, bool ignore) CASE_FLT_FN (BUILT_IN_DREM): CASE_FLT_FN (BUILT_IN_REMAINDER): if (validate_arg (arg0, REAL_TYPE) - && validate_arg(arg1, REAL_TYPE)) + && validate_arg (arg1, REAL_TYPE)) return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder); break; CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */ CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */ if (validate_arg (arg0, REAL_TYPE) - && validate_arg(arg1, POINTER_TYPE)) + && validate_arg (arg1, POINTER_TYPE)) return do_mpfr_lgamma_r (arg0, arg1, type); break; CASE_FLT_FN (BUILT_IN_ATAN2): if (validate_arg (arg0, REAL_TYPE) - && validate_arg(arg1, REAL_TYPE)) + && validate_arg (arg1, REAL_TYPE)) return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2); break; CASE_FLT_FN (BUILT_IN_FDIM): if (validate_arg (arg0, REAL_TYPE) - && validate_arg(arg1, REAL_TYPE)) + && validate_arg (arg1, REAL_TYPE)) return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim); break; @@ -10969,8 +10969,8 @@ fold_builtin_3 (location_t loc, tree fndecl, CASE_FLT_FN (BUILT_IN_REMQUO): if (validate_arg (arg0, REAL_TYPE) - && validate_arg(arg1, REAL_TYPE) - && validate_arg(arg2, POINTER_TYPE)) + && validate_arg (arg1, REAL_TYPE) + && validate_arg (arg2, POINTER_TYPE)) return do_mpfr_remquo (arg0, arg1, arg2); break; @@ -13943,7 +13943,7 @@ do_mpfr_bessel_n (tree arg1, tree arg2, tree type, && host_integerp (arg1, 0) && TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)) { - const HOST_WIDE_INT n = tree_low_cst(arg1, 0); + const HOST_WIDE_INT n = tree_low_cst (arg1, 0); const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2); if (n == (long)n @@ -14071,7 +14071,7 @@ do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type) negative integer. */ if (real_isfinite (ra) && ra->cl != rvc_zero - && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type)))) + && !(real_isneg (ra) && real_isinteger (ra, TYPE_MODE (type)))) { const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); const int prec = fmt->p; @@ -14140,8 +14140,8 @@ do_mpc_arg1 (tree arg, tree type, int (*func)(mpc_ptr, mpc_srcptr, mpc_rnd_t)) mpc_t m; mpc_init2 (m, prec); - mpfr_from_real (mpc_realref(m), re, rnd); - mpfr_from_real (mpc_imagref(m), im, rnd); + mpfr_from_real (mpc_realref (m), re, rnd); + mpfr_from_real (mpc_imagref (m), im, rnd); mpfr_clear_flags (); inexact = func (m, m, crnd); result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0); @@ -14196,10 +14196,10 @@ do_mpc_arg2 (tree arg0, tree arg1, tree type, int do_nonfinite, mpc_init2 (m0, prec); mpc_init2 (m1, prec); - mpfr_from_real (mpc_realref(m0), re0, rnd); - mpfr_from_real (mpc_imagref(m0), im0, rnd); - mpfr_from_real (mpc_realref(m1), re1, rnd); - mpfr_from_real (mpc_imagref(m1), im1, rnd); + mpfr_from_real (mpc_realref (m0), re0, rnd); + mpfr_from_real (mpc_imagref (m0), im0, rnd); + mpfr_from_real (mpc_realref (m1), re1, rnd); + mpfr_from_real (mpc_imagref (m1), im1, rnd); mpfr_clear_flags (); inexact = func (m0, m0, m1, crnd); result = do_mpc_ckconv (m0, type, inexact, do_nonfinite); diff --git a/gcc/calls.c b/gcc/calls.c index 3c083e6d53e..f489f4baf75 100644 --- a/gcc/calls.c +++ b/gcc/calls.c @@ -1732,7 +1732,8 @@ internal_arg_pointer_based_exp_scan (void) if (val != NULL_RTX) { if (idx >= internal_arg_pointer_exp_state.cache.length ()) - internal_arg_pointer_exp_state.cache.safe_grow_cleared(idx + 1); + internal_arg_pointer_exp_state.cache + .safe_grow_cleared (idx + 1); internal_arg_pointer_exp_state.cache[idx] = val; } } diff --git a/gcc/cfgcleanup.c b/gcc/cfgcleanup.c index e88fe2ed500..53a99755010 100644 --- a/gcc/cfgcleanup.c +++ b/gcc/cfgcleanup.c @@ -3089,8 +3089,8 @@ const pass_data pass_data_jump = class pass_jump : public rtl_opt_pass { public: - pass_jump(gcc::context *ctxt) - : rtl_opt_pass(pass_data_jump, ctxt) + pass_jump (gcc::context *ctxt) + : rtl_opt_pass (pass_data_jump, ctxt) {} /* opt_pass methods: */ @@ -3133,8 +3133,8 @@ const pass_data pass_data_jump2 = class pass_jump2 : public rtl_opt_pass { public: - pass_jump2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_jump2, ctxt) + pass_jump2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_jump2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/cfgexpand.c b/gcc/cfgexpand.c index f76e5f20b0e..afb02a0801b 100644 --- a/gcc/cfgexpand.c +++ b/gcc/cfgexpand.c @@ -569,7 +569,7 @@ add_partitioned_vars_to_ptset (struct pt_solution *pt, || pt->vars == NULL /* The pointed-to vars bitmap is shared, it is enough to visit it once. */ - || pointer_set_insert(visited, pt->vars)) + || pointer_set_insert (visited, pt->vars)) return; bitmap_clear (temp); @@ -1184,7 +1184,7 @@ expand_one_var (tree var, bool toplevel, bool really_expand) { /* stack_alignment_estimated shouldn't change after stack realign decision made */ - gcc_assert(!crtl->stack_realign_processed); + gcc_assert (!crtl->stack_realign_processed); crtl->stack_alignment_estimated = align; } @@ -1723,7 +1723,7 @@ expand_used_vars (void) case SPCT_FLAG_DEFAULT: if (cfun->calls_alloca || has_protected_decls) - create_stack_guard(); + create_stack_guard (); break; default: @@ -1770,7 +1770,7 @@ expand_used_vars (void) var_end_seq = asan_emit_stack_protection (virtual_stack_vars_rtx, data.asan_vec.address (), - data.asan_decl_vec. address(), + data.asan_decl_vec. address (), data.asan_vec.length ()); } @@ -4934,8 +4934,8 @@ const pass_data pass_data_expand = class pass_expand : public rtl_opt_pass { public: - pass_expand(gcc::context *ctxt) - : rtl_opt_pass(pass_data_expand, ctxt) + pass_expand (gcc::context *ctxt) + : rtl_opt_pass (pass_data_expand, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/cfghooks.c b/gcc/cfghooks.c index a4248354d97..c12a62fca50 100644 --- a/gcc/cfghooks.c +++ b/gcc/cfghooks.c @@ -1443,6 +1443,6 @@ account_profile_record (struct profile_record *record, int after_pass) || bb == EXIT_BLOCK_PTR_FOR_FUNCTION (cfun)) continue; gcc_assert (cfg_hooks->account_profile_record); - cfg_hooks->account_profile_record(bb, after_pass, record); + cfg_hooks->account_profile_record (bb, after_pass, record); } } diff --git a/gcc/cfgloop.c b/gcc/cfgloop.c index 928edd46228..f39b1944ab6 100644 --- a/gcc/cfgloop.c +++ b/gcc/cfgloop.c @@ -433,7 +433,7 @@ flow_loops_find (struct loops *loops) /* Gather all loop headers in reverse completion order and allocate loop structures for loops that are not already present. */ - larray.create (loops->larray->length()); + larray.create (loops->larray->length ()); for (b = 0; b < n_basic_blocks - NUM_FIXED_BLOCKS; b++) { basic_block header = BASIC_BLOCK (rc_order[b]); @@ -509,7 +509,7 @@ flow_loops_find (struct loops *loops) } } - larray.release(); + larray.release (); return loops; } diff --git a/gcc/cfgloopmanip.c b/gcc/cfgloopmanip.c index ed8a2075f7a..b4840dcf014 100644 --- a/gcc/cfgloopmanip.c +++ b/gcc/cfgloopmanip.c @@ -950,7 +950,7 @@ unloop (struct loop *loop, bool *irred_invalidated, remove_bb_from_loops (body[i]); add_bb_to_loop (body[i], loop_outer (loop)); } - free(body); + free (body); while (loop->inner) { diff --git a/gcc/cfgrtl.c b/gcc/cfgrtl.c index c82e480ee30..85738a43f36 100644 --- a/gcc/cfgrtl.c +++ b/gcc/cfgrtl.c @@ -479,8 +479,8 @@ const pass_data pass_data_free_cfg = class pass_free_cfg : public rtl_opt_pass { public: - pass_free_cfg(gcc::context *ctxt) - : rtl_opt_pass(pass_data_free_cfg, ctxt) + pass_free_cfg (gcc::context *ctxt) + : rtl_opt_pass (pass_data_free_cfg, ctxt) {} /* opt_pass methods: */ @@ -1441,7 +1441,7 @@ void emit_barrier_after_bb (basic_block bb) { rtx barrier = emit_barrier_after (BB_END (bb)); - gcc_assert (current_ir_type() == IR_RTL_CFGRTL + gcc_assert (current_ir_type () == IR_RTL_CFGRTL || current_ir_type () == IR_RTL_CFGLAYOUT); if (current_ir_type () == IR_RTL_CFGLAYOUT) BB_FOOTER (bb) = unlink_insn_chain (barrier, barrier); @@ -2346,7 +2346,7 @@ verify_hot_cold_block_grouping (void) again (in compgoto). Ensure we don't call this before going back into linearized RTL when any layout fixes would have been committed. */ if (!crtl->bb_reorder_complete - || current_ir_type() != IR_RTL_CFGRTL) + || current_ir_type () != IR_RTL_CFGRTL) return err; FOR_EACH_BB (bb) @@ -3484,8 +3484,8 @@ const pass_data pass_data_into_cfg_layout_mode = class pass_into_cfg_layout_mode : public rtl_opt_pass { public: - pass_into_cfg_layout_mode(gcc::context *ctxt) - : rtl_opt_pass(pass_data_into_cfg_layout_mode, ctxt) + pass_into_cfg_layout_mode (gcc::context *ctxt) + : rtl_opt_pass (pass_data_into_cfg_layout_mode, ctxt) {} /* opt_pass methods: */ @@ -3521,8 +3521,8 @@ const pass_data pass_data_outof_cfg_layout_mode = class pass_outof_cfg_layout_mode : public rtl_opt_pass { public: - pass_outof_cfg_layout_mode(gcc::context *ctxt) - : rtl_opt_pass(pass_data_outof_cfg_layout_mode, ctxt) + pass_outof_cfg_layout_mode (gcc::context *ctxt) + : rtl_opt_pass (pass_data_outof_cfg_layout_mode, ctxt) {} /* opt_pass methods: */ @@ -4887,7 +4887,7 @@ rtl_lv_add_condition_to_bb (basic_block first_head , end_sequence (); /* Add the new cond , in the new head. */ - emit_insn_after(seq, BB_END(cond_bb)); + emit_insn_after (seq, BB_END (cond_bb)); } diff --git a/gcc/cgraph.c b/gcc/cgraph.c index e84ce948d90..124ee0adf85 100644 --- a/gcc/cgraph.c +++ b/gcc/cgraph.c @@ -1635,7 +1635,7 @@ release_function_body (tree decl) } if (cfun->value_histograms) free_histograms (); - pop_cfun(); + pop_cfun (); gimple_set_body (decl, NULL); /* Struct function hangs a lot of data that would leak if we didn't removed all pointers to it. */ @@ -1762,7 +1762,7 @@ cgraph_remove_node (struct cgraph_node *node) /* Clear out the node to NULL all pointers and add the node to the free list. */ - memset (node, 0, sizeof(*node)); + memset (node, 0, sizeof (*node)); node->symbol.type = SYMTAB_FUNCTION; node->uid = uid; SET_NEXT_FREE_NODE (node, free_nodes); @@ -1947,13 +1947,13 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node) fprintf (f, "(%.2f per call) ", edge->frequency / (double)CGRAPH_FREQ_BASE); if (edge->speculative) - fprintf(f, "(speculative) "); + fprintf (f, "(speculative) "); if (!edge->inline_failed) - fprintf(f, "(inlined) "); + fprintf (f, "(inlined) "); if (edge->indirect_inlining_edge) - fprintf(f, "(indirect_inlining) "); + fprintf (f, "(indirect_inlining) "); if (edge->can_throw_external) - fprintf(f, "(can throw external) "); + fprintf (f, "(can throw external) "); } fprintf (f, "\n Calls: "); @@ -1962,11 +1962,11 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node) fprintf (f, "%s/%i ", cgraph_node_asm_name (edge->callee), edge->callee->symbol.order); if (edge->speculative) - fprintf(f, "(speculative) "); + fprintf (f, "(speculative) "); if (!edge->inline_failed) - fprintf(f, "(inlined) "); + fprintf (f, "(inlined) "); if (edge->indirect_inlining_edge) - fprintf(f, "(indirect_inlining) "); + fprintf (f, "(indirect_inlining) "); if (edge->count) fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ", (HOST_WIDEST_INT)edge->count); @@ -1974,7 +1974,7 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node) fprintf (f, "(%.2f per call) ", edge->frequency / (double)CGRAPH_FREQ_BASE); if (edge->can_throw_external) - fprintf(f, "(can throw external) "); + fprintf (f, "(can throw external) "); } fprintf (f, "\n"); diff --git a/gcc/cgraph.h b/gcc/cgraph.h index 50e8743bbf7..afdeaba4c3d 100644 --- a/gcc/cgraph.h +++ b/gcc/cgraph.h @@ -901,21 +901,21 @@ cgraph_node_asm_name (struct cgraph_node *node) /* Return asm name of varpool node. */ static inline const char * -varpool_node_asm_name(struct varpool_node *node) +varpool_node_asm_name (struct varpool_node *node) { return symtab_node_asm_name ((symtab_node)node); } /* Return name of cgraph node. */ static inline const char * -cgraph_node_name(struct cgraph_node *node) +cgraph_node_name (struct cgraph_node *node) { return symtab_node_name ((symtab_node)node); } /* Return name of varpool node. */ static inline const char * -varpool_node_name(struct varpool_node *node) +varpool_node_name (struct varpool_node *node) { return symtab_node_name ((symtab_node)node); } diff --git a/gcc/cgraphbuild.c b/gcc/cgraphbuild.c index 98fd12cbb13..4cf562ecdd5 100644 --- a/gcc/cgraphbuild.c +++ b/gcc/cgraphbuild.c @@ -393,8 +393,8 @@ const pass_data pass_data_build_cgraph_edges = class pass_build_cgraph_edges : public gimple_opt_pass { public: - pass_build_cgraph_edges(gcc::context *ctxt) - : gimple_opt_pass(pass_data_build_cgraph_edges, ctxt) + pass_build_cgraph_edges (gcc::context *ctxt) + : gimple_opt_pass (pass_data_build_cgraph_edges, ctxt) {} /* opt_pass methods: */ @@ -525,8 +525,8 @@ const pass_data pass_data_rebuild_cgraph_edges = class pass_rebuild_cgraph_edges : public gimple_opt_pass { public: - pass_rebuild_cgraph_edges(gcc::context *ctxt) - : gimple_opt_pass(pass_data_rebuild_cgraph_edges, ctxt) + pass_rebuild_cgraph_edges (gcc::context *ctxt) + : gimple_opt_pass (pass_data_rebuild_cgraph_edges, ctxt) {} /* opt_pass methods: */ @@ -573,8 +573,8 @@ const pass_data pass_data_remove_cgraph_callee_edges = class pass_remove_cgraph_callee_edges : public gimple_opt_pass { public: - pass_remove_cgraph_callee_edges(gcc::context *ctxt) - : gimple_opt_pass(pass_data_remove_cgraph_callee_edges, ctxt) + pass_remove_cgraph_callee_edges (gcc::context *ctxt) + : gimple_opt_pass (pass_data_remove_cgraph_callee_edges, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/cgraphclones.c b/gcc/cgraphclones.c index e1aa120dce4..cad10a7dcb0 100644 --- a/gcc/cgraphclones.c +++ b/gcc/cgraphclones.c @@ -750,8 +750,8 @@ cgraph_function_versioning (struct cgraph_node *old_version_node, SET_DECL_RTL (new_decl, NULL); /* When the old decl was a con-/destructor make sure the clone isn't. */ - DECL_STATIC_CONSTRUCTOR(new_decl) = 0; - DECL_STATIC_DESTRUCTOR(new_decl) = 0; + DECL_STATIC_CONSTRUCTOR (new_decl) = 0; + DECL_STATIC_DESTRUCTOR (new_decl) = 0; /* Create the new version's call-graph node. and update the edges of the new node. */ diff --git a/gcc/cgraphunit.c b/gcc/cgraphunit.c index 1644ca9eea9..e01918cfbd4 100644 --- a/gcc/cgraphunit.c +++ b/gcc/cgraphunit.c @@ -850,7 +850,7 @@ walk_polymorphic_call_targets (pointer_set_t *reachable_call_targets, dump_possible_polymorphic_call_targets (cgraph_dump_file, edge); - for (i = 0; i < targets.length(); i++) + for (i = 0; i < targets.length (); i++) { /* Do not bother to mark virtual methods in anonymous namespace; either we will find use of virtual table defining it, or it is @@ -872,7 +872,7 @@ walk_polymorphic_call_targets (pointer_set_t *reachable_call_targets, make the edge direct. */ if (final) { - if (targets.length() <= 1) + if (targets.length () <= 1) { cgraph_node *target; if (targets.length () == 1) diff --git a/gcc/collect2.c b/gcc/collect2.c index 43b9defafd8..84cf6b476e4 100644 --- a/gcc/collect2.c +++ b/gcc/collect2.c @@ -602,7 +602,7 @@ is_ctor_dtor (const char *s) { if (ch == p->name[0] && (!p->two_underscores || ((s - orig_s) >= 2)) - && strncmp(s, p->name, p->len) == 0) + && strncmp (s, p->name, p->len) == 0) { return p->ret; } @@ -777,7 +777,7 @@ maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst, plus number of partitions. */ for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++) ; - out_lto_ld_argv = XCNEWVEC(char *, num_files + lto_ld_argv_size + 1); + out_lto_ld_argv = XCNEWVEC (char *, num_files + lto_ld_argv_size + 1); out_lto_ld_argv_size = 0; /* After running the LTO back end, we will relink, substituting @@ -1644,9 +1644,9 @@ main (int argc, char **argv) "%d destructors found\n", destructors.number), destructors.number); - notice_translated (ngettext("%d frame table found\n", - "%d frame tables found\n", - frame_tables.number), + notice_translated (ngettext ("%d frame table found\n", + "%d frame tables found\n", + frame_tables.number), frame_tables.number); } @@ -1698,7 +1698,7 @@ main (int argc, char **argv) sort_ids (&constructors); sort_ids (&destructors); - maybe_unlink(output_file); + maybe_unlink (output_file); outf = fopen (c_file, "w"); if (outf == (FILE *) 0) fatal_error ("fopen %s: %m", c_file); @@ -1812,8 +1812,8 @@ collect_wait (const char *prog, struct pex_obj *pex) { int sig = WTERMSIG (status); error ("%s terminated with signal %d [%s]%s", - prog, sig, strsignal(sig), - WCOREDUMP(status) ? ", core dumped" : ""); + prog, sig, strsignal (sig), + WCOREDUMP (status) ? ", core dumped" : ""); exit (FATAL_EXIT_CODE); } @@ -2255,8 +2255,8 @@ write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED) if (shared_obj) { - COLLECT_SHARED_INIT_FUNC(stream, initname); - COLLECT_SHARED_FINI_FUNC(stream, fininame); + COLLECT_SHARED_INIT_FUNC (stream, initname); + COLLECT_SHARED_FINI_FUNC (stream, fininame); } } @@ -2727,16 +2727,16 @@ scan_libraries (const char *prog_name) #if defined (EXTENDED_COFF) -# define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax) +# define GCC_SYMBOLS(X) (SYMHEADER (X).isymMax + SYMHEADER (X).iextMax) # define GCC_SYMENT SYMR # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal) # define GCC_SYMINC(X) (1) -# define GCC_SYMZERO(X) (SYMHEADER(X).isymMax) -# define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0) +# define GCC_SYMZERO(X) (SYMHEADER (X).isymMax) +# define GCC_CHECK_HDR(X) (PSYMTAB (X) != 0) #else -# define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms) +# define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms) # define GCC_SYMENT SYMENT # if defined (C_WEAKEXT) # define GCC_OK_SYMBOL(X) \ @@ -2994,7 +2994,7 @@ scan_prog_file (const char *prog_name, scanpass which_pass, while (ldclose (ldptr) == FAILURE); #else /* Otherwise we simply close ldptr. */ - (void) ldclose(ldptr); + (void) ldclose (ldptr); #endif } #endif /* OBJECT_FORMAT_COFF */ @@ -3014,7 +3014,7 @@ resolve_lib_name (const char *name) if (libpaths[i]->max_len > l) l = libpaths[i]->max_len; - lib_buf = XNEWVEC (char, l + strlen(name) + 10); + lib_buf = XNEWVEC (char, l + strlen (name) + 10); for (i = 0; libpaths[i]; i++) { @@ -3025,7 +3025,7 @@ resolve_lib_name (const char *name) may contain directories both with trailing DIR_SEPARATOR and without it. */ const char *p = ""; - if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1])) + if (!IS_DIR_SEPARATOR (list->prefix[strlen (list->prefix)-1])) p = "/"; for (j = 0; j < 2; j++) { diff --git a/gcc/combine-stack-adj.c b/gcc/combine-stack-adj.c index be47665ebc0..5ca131f346a 100644 --- a/gcc/combine-stack-adj.c +++ b/gcc/combine-stack-adj.c @@ -663,8 +663,8 @@ const pass_data pass_data_stack_adjustments = class pass_stack_adjustments : public rtl_opt_pass { public: - pass_stack_adjustments(gcc::context *ctxt) - : rtl_opt_pass(pass_data_stack_adjustments, ctxt) + pass_stack_adjustments (gcc::context *ctxt) + : rtl_opt_pass (pass_data_stack_adjustments, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/combine.c b/gcc/combine.c index 248a6eeeaa9..fcf60cd08aa 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -735,7 +735,7 @@ do_SUBST (rtx *into, rtx newval) buf->next = undobuf.undos, undobuf.undos = buf; } -#define SUBST(INTO, NEWVAL) do_SUBST(&(INTO), (NEWVAL)) +#define SUBST(INTO, NEWVAL) do_SUBST (&(INTO), (NEWVAL)) /* Similar to SUBST, but NEWVAL is an int expression. Note that substitution for the value of a HOST_WIDE_INT value (including CONST_INT) is @@ -763,7 +763,7 @@ do_SUBST_INT (int *into, int newval) buf->next = undobuf.undos, undobuf.undos = buf; } -#define SUBST_INT(INTO, NEWVAL) do_SUBST_INT(&(INTO), (NEWVAL)) +#define SUBST_INT(INTO, NEWVAL) do_SUBST_INT (&(INTO), (NEWVAL)) /* Similar to SUBST, but just substitute the mode. This is used when changing the mode of a pseudo-register, so that any other @@ -792,7 +792,7 @@ do_SUBST_MODE (rtx *into, enum machine_mode newval) buf->next = undobuf.undos, undobuf.undos = buf; } -#define SUBST_MODE(INTO, NEWVAL) do_SUBST_MODE(&(INTO), (NEWVAL)) +#define SUBST_MODE(INTO, NEWVAL) do_SUBST_MODE (&(INTO), (NEWVAL)) #ifndef HAVE_cc0 /* Similar to SUBST, but NEWVAL is a LOG_LINKS expression. */ @@ -1197,8 +1197,8 @@ combine_instructions (rtx f, unsigned int nregs) INSN_COST (insn) = insn_rtx_cost (PATTERN (insn), optimize_this_for_speed_p); if (dump_file) - fprintf(dump_file, "insn_cost %d: %d\n", - INSN_UID (insn), INSN_COST (insn)); + fprintf (dump_file, "insn_cost %d: %d\n", + INSN_UID (insn), INSN_COST (insn)); } } @@ -2328,7 +2328,7 @@ can_change_dest_mode (rtx x, int added_sets, enum machine_mode mode) { unsigned int regno; - if (!REG_P(x)) + if (!REG_P (x)) return false; regno = REGNO (x); @@ -4279,7 +4279,7 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, df_insn_rescan (undobuf.other_insn); } - if (i0 && !(NOTE_P(i0) && (NOTE_KIND (i0) == NOTE_INSN_DELETED))) + if (i0 && !(NOTE_P (i0) && (NOTE_KIND (i0) == NOTE_INSN_DELETED))) { if (dump_file) { @@ -4289,7 +4289,7 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, df_insn_rescan (i0); } - if (i1 && !(NOTE_P(i1) && (NOTE_KIND (i1) == NOTE_INSN_DELETED))) + if (i1 && !(NOTE_P (i1) && (NOTE_KIND (i1) == NOTE_INSN_DELETED))) { if (dump_file) { @@ -4299,7 +4299,7 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, df_insn_rescan (i1); } - if (i2 && !(NOTE_P(i2) && (NOTE_KIND (i2) == NOTE_INSN_DELETED))) + if (i2 && !(NOTE_P (i2) && (NOTE_KIND (i2) == NOTE_INSN_DELETED))) { if (dump_file) { @@ -4309,7 +4309,7 @@ try_combine (rtx i3, rtx i2, rtx i1, rtx i0, int *new_direct_jump_p, df_insn_rescan (i2); } - if (i3 && !(NOTE_P(i3) && (NOTE_KIND (i3) == NOTE_INSN_DELETED))) + if (i3 && !(NOTE_P (i3) && (NOTE_KIND (i3) == NOTE_INSN_DELETED))) { if (dump_file) { @@ -11015,7 +11015,7 @@ simplify_comparison (enum rtx_code code, rtx *pop0, rtx *pop1) this shift are known to be zero for both inputs and if the type of comparison is compatible with the shift. */ if (GET_CODE (op0) == GET_CODE (op1) - && HWI_COMPUTABLE_MODE_P (GET_MODE(op0)) + && HWI_COMPUTABLE_MODE_P (GET_MODE (op0)) && ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ)) || ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT) && (code != GT && code != LT && code != GE && code != LE)) @@ -13875,8 +13875,8 @@ const pass_data pass_data_combine = class pass_combine : public rtl_opt_pass { public: - pass_combine(gcc::context *ctxt) - : rtl_opt_pass(pass_data_combine, ctxt) + pass_combine (gcc::context *ctxt) + : rtl_opt_pass (pass_data_combine, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/compare-elim.c b/gcc/compare-elim.c index 19cf524b1f9..847c89128b4 100644 --- a/gcc/compare-elim.c +++ b/gcc/compare-elim.c @@ -247,7 +247,7 @@ class find_comparison_dom_walker : public dom_walker { public: find_comparison_dom_walker (cdi_direction direction) - : dom_walker(direction) {} + : dom_walker (direction) {} virtual void before_dom_children (basic_block); }; @@ -673,8 +673,8 @@ const pass_data pass_data_compare_elim_after_reload = class pass_compare_elim_after_reload : public rtl_opt_pass { public: - pass_compare_elim_after_reload(gcc::context *ctxt) - : rtl_opt_pass(pass_data_compare_elim_after_reload, ctxt) + pass_compare_elim_after_reload (gcc::context *ctxt) + : rtl_opt_pass (pass_data_compare_elim_after_reload, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/context.c b/gcc/context.c index b5152419a97..6bd25f01852 100644 --- a/gcc/context.c +++ b/gcc/context.c @@ -27,7 +27,7 @@ along with GCC; see the file COPYING3. If not see /* The singleton holder of global state: */ gcc::context *g; -gcc::context::context() +gcc::context::context () { passes_ = new gcc::pass_manager (this); } diff --git a/gcc/context.h b/gcc/context.h index 66260cd279a..ed6a24a8f5c 100644 --- a/gcc/context.h +++ b/gcc/context.h @@ -30,7 +30,7 @@ class pass_manager; class context { public: - context(); + context (); /* Pass-management. */ diff --git a/gcc/cprop.c b/gcc/cprop.c index 3518fd839ce..9d6cb46654b 100644 --- a/gcc/cprop.c +++ b/gcc/cprop.c @@ -246,7 +246,8 @@ insert_set_in_table (rtx dest, rtx src, rtx insn, struct hash_table_d *table, /* Record bitmap_index of the implicit set in implicit_set_indexes. */ if (implicit) - implicit_set_indexes[BLOCK_FOR_INSN(insn)->index] = cur_expr->bitmap_index; + implicit_set_indexes[BLOCK_FOR_INSN (insn)->index] + = cur_expr->bitmap_index; } /* Determine whether the rtx X should be treated as a constant for CPROP. @@ -1402,9 +1403,9 @@ find_implicit_sets (void) implicit_sets[dest->index] = new_rtx; if (dump_file) { - fprintf(dump_file, "Implicit set of reg %d in ", - REGNO (XEXP (cond, 0))); - fprintf(dump_file, "basic block %d\n", dest->index); + fprintf (dump_file, "Implicit set of reg %d in ", + REGNO (XEXP (cond, 0))); + fprintf (dump_file, "basic block %d\n", dest->index); } count++; } @@ -1934,8 +1935,8 @@ const pass_data pass_data_rtl_cprop = class pass_rtl_cprop : public rtl_opt_pass { public: - pass_rtl_cprop(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_cprop, ctxt) + pass_rtl_cprop (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_cprop, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/cse.c b/gcc/cse.c index 37349705129..43fa1e8191f 100644 --- a/gcc/cse.c +++ b/gcc/cse.c @@ -468,7 +468,7 @@ struct table_elt a cost of 2. Aside from these special cases, call `rtx_cost'. */ #define CHEAP_REGNO(N) \ - (REGNO_PTR_FRAME_P(N) \ + (REGNO_PTR_FRAME_P (N) \ || (HARD_REGISTER_NUM_P (N) \ && FIXED_REGNO_P (N) && REGNO_REG_CLASS (N) != NO_REGS)) @@ -4839,7 +4839,7 @@ cse_insn (rtx insn) /* Set what we are trying to extend and the operation it might have been extended with. */ - memset (memory_extend_rtx, 0, sizeof(*memory_extend_rtx)); + memset (memory_extend_rtx, 0, sizeof (*memory_extend_rtx)); PUT_CODE (memory_extend_rtx, LOAD_EXTEND_OP (mode)); XEXP (memory_extend_rtx, 0) = src; @@ -7479,8 +7479,8 @@ const pass_data pass_data_cse = class pass_cse : public rtl_opt_pass { public: - pass_cse(gcc::context *ctxt) - : rtl_opt_pass(pass_data_cse, ctxt) + pass_cse (gcc::context *ctxt) + : rtl_opt_pass (pass_data_cse, ctxt) {} /* opt_pass methods: */ @@ -7559,8 +7559,8 @@ const pass_data pass_data_cse2 = class pass_cse2 : public rtl_opt_pass { public: - pass_cse2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_cse2, ctxt) + pass_cse2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_cse2, ctxt) {} /* opt_pass methods: */ @@ -7637,8 +7637,8 @@ const pass_data pass_data_cse_after_global_opts = class pass_cse_after_global_opts : public rtl_opt_pass { public: - pass_cse_after_global_opts(gcc::context *ctxt) - : rtl_opt_pass(pass_data_cse_after_global_opts, ctxt) + pass_cse_after_global_opts (gcc::context *ctxt) + : rtl_opt_pass (pass_data_cse_after_global_opts, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/cselib.c b/gcc/cselib.c index c3431af1246..e201f5e7c49 100644 --- a/gcc/cselib.c +++ b/gcc/cselib.c @@ -259,10 +259,10 @@ void (*cselib_record_sets_hook) (rtx insn, struct cselib_set *sets, int n_sets); #define PRESERVED_VALUE_P(RTX) \ - (RTL_FLAG_CHECK1("PRESERVED_VALUE_P", (RTX), VALUE)->unchanging) + (RTL_FLAG_CHECK1 ("PRESERVED_VALUE_P", (RTX), VALUE)->unchanging) #define SP_BASED_VALUE_P(RTX) \ - (RTL_FLAG_CHECK1("SP_BASED_VALUE_P", (RTX), VALUE)->jump) + (RTL_FLAG_CHECK1 ("SP_BASED_VALUE_P", (RTX), VALUE)->jump) diff --git a/gcc/dbxout.c b/gcc/dbxout.c index 1cc5d524205..9b5e23f6d71 100644 --- a/gcc/dbxout.c +++ b/gcc/dbxout.c @@ -636,7 +636,7 @@ dbxout_begin_complex_stabs_noforcetext (void) #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr) /* Add STR, a normal C string, to the string being built. */ -#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str)) +#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str)) /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */ #define stabstr_I(id) obstack_grow (&stabstr_ob, \ @@ -2434,7 +2434,7 @@ dbxout_class_name_qualifiers (tree decl) tree context = decl_type_context (decl); if (context != NULL_TREE - && TREE_CODE(context) == RECORD_TYPE + && TREE_CODE (context) == RECORD_TYPE && TYPE_NAME (context) != 0 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE || (DECL_NAME (TYPE_NAME (context)) != 0))) @@ -3302,8 +3302,8 @@ dbxout_common_check (tree decl, int *value) for thread-local symbols. Can be handled via same mechanism as used in dwarf2out.c. */ if (TREE_CODE (decl) != VAR_DECL - || !TREE_STATIC(decl) - || !DECL_HAS_VALUE_EXPR_P(decl) + || !TREE_STATIC (decl) + || !DECL_HAS_VALUE_EXPR_P (decl) || DECL_THREAD_LOCAL_P (decl) || !is_fortran ()) return NULL; @@ -3337,21 +3337,21 @@ dbxout_common_check (tree decl, int *value) if (CONST_INT_P (XEXP (sym_addr, 0))) { name = - targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 1), 0)); + targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 1), 0)); *value = INTVAL (XEXP (sym_addr, 0)); cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1)); } else { name = - targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 0), 0)); + targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 0), 0)); *value = INTVAL (XEXP (sym_addr, 1)); cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0)); } break; case SYMBOL_REF: - name = targetm.strip_name_encoding(XSTR (sym_addr, 0)); + name = targetm.strip_name_encoding (XSTR (sym_addr, 0)); *value = 0; cdecl = SYMBOL_REF_DECL (sym_addr); break; @@ -3364,7 +3364,7 @@ dbxout_common_check (tree decl, int *value) /* Check area common symbol is offset into. If this is not public, then it is not a symbol in a common block. It must be a .lcomm symbol, not a .comm symbol. */ - if (cdecl == NULL || !TREE_PUBLIC(cdecl)) + if (cdecl == NULL || !TREE_PUBLIC (cdecl)) name = NULL; } else diff --git a/gcc/dce.c b/gcc/dce.c index fa22316b5cc..5c11cbeef0d 100644 --- a/gcc/dce.c +++ b/gcc/dce.c @@ -806,8 +806,8 @@ const pass_data pass_data_ud_rtl_dce = class pass_ud_rtl_dce : public rtl_opt_pass { public: - pass_ud_rtl_dce(gcc::context *ctxt) - : rtl_opt_pass(pass_data_ud_rtl_dce, ctxt) + pass_ud_rtl_dce (gcc::context *ctxt) + : rtl_opt_pass (pass_data_ud_rtl_dce, ctxt) {} /* opt_pass methods: */ @@ -1239,8 +1239,8 @@ const pass_data pass_data_fast_rtl_dce = class pass_fast_rtl_dce : public rtl_opt_pass { public: - pass_fast_rtl_dce(gcc::context *ctxt) - : rtl_opt_pass(pass_data_fast_rtl_dce, ctxt) + pass_fast_rtl_dce (gcc::context *ctxt) + : rtl_opt_pass (pass_data_fast_rtl_dce, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/defaults.h b/gcc/defaults.h index 3fa105d113d..37e8a08ac5a 100644 --- a/gcc/defaults.h +++ b/gcc/defaults.h @@ -76,7 +76,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see int c = p[i]; \ if (c == '\"' || c == '\\') \ putc ('\\', asm_out_file); \ - if (ISPRINT(c)) \ + if (ISPRINT (c)) \ putc (c, asm_out_file); \ else \ { \ @@ -86,7 +86,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see The VAX assembler fails to stop reading the escape \ after three digits, so this is the only way we \ can get it to parse the data properly. */ \ - if (i < thissize - 1 && ISDIGIT(p[i + 1])) \ + if (i < thissize - 1 && ISDIGIT (p[i + 1])) \ fprintf (asm_out_file, "\"\n\t.ascii \""); \ } \ } \ @@ -351,7 +351,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see /* If we have named sections, and we're using crtstuff to run ctors, use them for registering eh frame information. */ #if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \ - && !defined(EH_FRAME_IN_DATA_SECTION) + && !defined (EH_FRAME_IN_DATA_SECTION) #ifndef EH_FRAME_SECTION_NAME #define EH_FRAME_SECTION_NAME ".eh_frame" #endif @@ -1278,7 +1278,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see SET_RATIO or more simple move-instruction sequences, we will do a movmem or libcall instead. */ #ifndef SET_RATIO -#define SET_RATIO(speed) MOVE_RATIO(speed) +#define SET_RATIO(speed) MOVE_RATIO (speed) #endif /* Supply a default definition for FUNCTION_ARG_PADDING: diff --git a/gcc/df-core.c b/gcc/df-core.c index 95df1c1b056..deea7551053 100644 --- a/gcc/df-core.c +++ b/gcc/df-core.c @@ -549,7 +549,7 @@ df_set_blocks (bitmap blocks) { basic_block bb; bitmap_initialize (&blocks_to_reset, &df_bitmap_obstack); - FOR_ALL_BB(bb) + FOR_ALL_BB (bb) { bitmap_set_bit (&blocks_to_reset, bb->index); } @@ -766,8 +766,8 @@ const pass_data pass_data_df_initialize_opt = class pass_df_initialize_opt : public rtl_opt_pass { public: - pass_df_initialize_opt(gcc::context *ctxt) - : rtl_opt_pass(pass_data_df_initialize_opt, ctxt) + pass_df_initialize_opt (gcc::context *ctxt) + : rtl_opt_pass (pass_data_df_initialize_opt, ctxt) {} /* opt_pass methods: */ @@ -812,8 +812,8 @@ const pass_data pass_data_df_initialize_no_opt = class pass_df_initialize_no_opt : public rtl_opt_pass { public: - pass_df_initialize_no_opt(gcc::context *ctxt) - : rtl_opt_pass(pass_data_df_initialize_no_opt, ctxt) + pass_df_initialize_no_opt (gcc::context *ctxt) + : rtl_opt_pass (pass_data_df_initialize_no_opt, ctxt) {} /* opt_pass methods: */ @@ -878,8 +878,8 @@ const pass_data pass_data_df_finish = class pass_df_finish : public rtl_opt_pass { public: - pass_df_finish(gcc::context *ctxt) - : rtl_opt_pass(pass_data_df_finish, ctxt) + pass_df_finish (gcc::context *ctxt) + : rtl_opt_pass (pass_data_df_finish, ctxt) {} /* opt_pass methods: */ @@ -2078,7 +2078,7 @@ df_dump_start (FILE *file) { df_dump_problem_function fun = dflow->problem->dump_start_fun; if (fun) - fun(file); + fun (file); } } } diff --git a/gcc/df-problems.c b/gcc/df-problems.c index e647b5ad0a0..59fc2f64444 100644 --- a/gcc/df-problems.c +++ b/gcc/df-problems.c @@ -326,7 +326,7 @@ df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info, if (n_defs > DF_SPARSE_THRESHOLD) { bitmap_set_bit (&bb_info->sparse_kill, regno); - bitmap_clear_range(&bb_info->gen, begin, n_defs); + bitmap_clear_range (&bb_info->gen, begin, n_defs); } else { @@ -594,7 +594,7 @@ df_rd_start_dump (FILE *file) { struct df_rd_problem_data *problem_data = (struct df_rd_problem_data *) df_rd->problem_data; - unsigned int m = DF_REG_SIZE(df); + unsigned int m = DF_REG_SIZE (df); unsigned int regno; if (!df_rd->block_info) @@ -622,7 +622,7 @@ df_rd_dump_defs_set (bitmap defs_set, const char *prefix, FILE *file) { bitmap_head tmp; unsigned int regno; - unsigned int m = DF_REG_SIZE(df); + unsigned int m = DF_REG_SIZE (df); bool first_reg = true; fprintf (file, "%s\t(%d) ", prefix, (int) bitmap_count_bits (defs_set)); diff --git a/gcc/df-scan.c b/gcc/df-scan.c index 3a8e9ca7ec4..f2e8ab27136 100644 --- a/gcc/df-scan.c +++ b/gcc/df-scan.c @@ -191,9 +191,9 @@ df_scan_free_internal (void) /* The vectors that hold the refs are not pool allocated because they come in many sizes. This makes them impossible to delete all at once. */ - for (i = 0; i < DF_INSN_SIZE(); i++) + for (i = 0; i < DF_INSN_SIZE (); i++) { - struct df_insn_info *insn_info = DF_INSN_UID_GET(i); + struct df_insn_info *insn_info = DF_INSN_UID_GET (i); /* Skip the insns that have no insn_info or have been deleted. */ if (insn_info) @@ -233,7 +233,7 @@ df_scan_free_internal (void) free (df->eq_use_regs); df->eq_use_regs = NULL; df->regs_size = 0; - DF_REG_SIZE(df) = 0; + DF_REG_SIZE (df) = 0; free (df->insns); df->insns = NULL; @@ -2188,7 +2188,7 @@ df_notes_rescan (rtx insn) df_grow_bb_info (df_scan); df_grow_reg_info (); - insn_info = DF_INSN_UID_SAFE_GET (INSN_UID(insn)); + insn_info = DF_INSN_UID_SAFE_GET (INSN_UID (insn)); /* The client has deferred rescanning. */ if (df->changeable_flags & DF_DEFER_INSN_RESCAN) @@ -4558,11 +4558,11 @@ df_scan_verify (void) for (i = 0; i < DF_REG_SIZE (df); i++) { gcc_assert (df_reg_chain_mark (DF_REG_DEF_CHAIN (i), i, true, false) - == DF_REG_DEF_COUNT(i)); + == DF_REG_DEF_COUNT (i)); gcc_assert (df_reg_chain_mark (DF_REG_USE_CHAIN (i), i, false, false) - == DF_REG_USE_COUNT(i)); + == DF_REG_USE_COUNT (i)); gcc_assert (df_reg_chain_mark (DF_REG_EQ_USE_CHAIN (i), i, false, true) - == DF_REG_EQ_USE_COUNT(i)); + == DF_REG_EQ_USE_COUNT (i)); } /* (2) There are various bitmaps whose value may change over the @@ -607,29 +607,29 @@ struct df_d bool redo_entry_and_exit; }; -#define DF_SCAN_BB_INFO(BB) (df_scan_get_bb_info((BB)->index)) -#define DF_RD_BB_INFO(BB) (df_rd_get_bb_info((BB)->index)) -#define DF_LR_BB_INFO(BB) (df_lr_get_bb_info((BB)->index)) -#define DF_LIVE_BB_INFO(BB) (df_live_get_bb_info((BB)->index)) -#define DF_WORD_LR_BB_INFO(BB) (df_word_lr_get_bb_info((BB)->index)) -#define DF_MD_BB_INFO(BB) (df_md_get_bb_info((BB)->index)) +#define DF_SCAN_BB_INFO(BB) (df_scan_get_bb_info ((BB)->index)) +#define DF_RD_BB_INFO(BB) (df_rd_get_bb_info ((BB)->index)) +#define DF_LR_BB_INFO(BB) (df_lr_get_bb_info ((BB)->index)) +#define DF_LIVE_BB_INFO(BB) (df_live_get_bb_info ((BB)->index)) +#define DF_WORD_LR_BB_INFO(BB) (df_word_lr_get_bb_info ((BB)->index)) +#define DF_MD_BB_INFO(BB) (df_md_get_bb_info ((BB)->index)) /* Most transformations that wish to use live register analysis will use these macros. This info is the and of the lr and live sets. */ -#define DF_LIVE_IN(BB) (&DF_LIVE_BB_INFO(BB)->in) -#define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO(BB)->out) +#define DF_LIVE_IN(BB) (&DF_LIVE_BB_INFO (BB)->in) +#define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO (BB)->out) /* These macros are used by passes that are not tolerant of uninitialized variables. This intolerance should eventually be fixed. */ -#define DF_LR_IN(BB) (&DF_LR_BB_INFO(BB)->in) -#define DF_LR_OUT(BB) (&DF_LR_BB_INFO(BB)->out) +#define DF_LR_IN(BB) (&DF_LR_BB_INFO (BB)->in) +#define DF_LR_OUT(BB) (&DF_LR_BB_INFO (BB)->out) /* These macros are used by passes that are not tolerant of uninitialized variables. This intolerance should eventually be fixed. */ -#define DF_WORD_LR_IN(BB) (&DF_WORD_LR_BB_INFO(BB)->in) -#define DF_WORD_LR_OUT(BB) (&DF_WORD_LR_BB_INFO(BB)->out) +#define DF_WORD_LR_IN(BB) (&DF_WORD_LR_BB_INFO (BB)->in) +#define DF_WORD_LR_OUT(BB) (&DF_WORD_LR_BB_INFO (BB)->out) /* Macros to access the elements within the ref structure. */ @@ -640,10 +640,11 @@ struct df_d #define DF_REF_REAL_LOC(REF) (GET_CODE (*((REF)->regular_ref.loc)) == SUBREG \ ? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc)) #define DF_REF_REG(REF) ((REF)->base.reg) -#define DF_REF_LOC(REF) (DF_REF_CLASS(REF) == DF_REF_REGULAR ? \ +#define DF_REF_LOC(REF) (DF_REF_CLASS (REF) == DF_REF_REGULAR ? \ (REF)->regular_ref.loc : NULL) -#define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL(REF) ? \ - (REF)->artificial_ref.bb : BLOCK_FOR_INSN (DF_REF_INSN(REF))) +#define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL (REF) \ + ? (REF)->artificial_ref.bb \ + : BLOCK_FOR_INSN (DF_REF_INSN (REF))) #define DF_REF_BBNO(REF) (DF_REF_BB (REF)->index) #define DF_REF_INSN_INFO(REF) ((REF)->base.insn_info) #define DF_REF_INSN(REF) ((REF)->base.insn_info->insn) @@ -660,7 +661,7 @@ struct df_d /* If DF_REF_IS_ARTIFICIAL () is true, this is not a real definition/use, but an artificial one created to model always live registers, eh uses, etc. */ -#define DF_REF_IS_ARTIFICIAL(REF) (DF_REF_CLASS(REF) == DF_REF_ARTIFICIAL) +#define DF_REF_IS_ARTIFICIAL(REF) (DF_REF_CLASS (REF) == DF_REF_ARTIFICIAL) #define DF_REF_REG_MARK(REF) (DF_REF_FLAGS_SET ((REF),DF_REF_REG_MARKER)) #define DF_REF_REG_UNMARK(REF) (DF_REF_FLAGS_CLEAR ((REF),DF_REF_REG_MARKER)) #define DF_REF_IS_REG_MARKED(REF) (DF_REF_FLAGS_IS_SET ((REF),DF_REF_REG_MARKER)) @@ -722,35 +723,35 @@ struct df_d /* Macros to access the elements within the reg_info structure table. */ #define DF_REGNO_FIRST_DEF(REGNUM) \ -(DF_REG_DEF_GET(REGNUM) ? DF_REG_DEF_GET(REGNUM) : 0) +(DF_REG_DEF_GET(REGNUM) ? DF_REG_DEF_GET (REGNUM) : 0) #define DF_REGNO_LAST_USE(REGNUM) \ -(DF_REG_USE_GET(REGNUM) ? DF_REG_USE_GET(REGNUM) : 0) +(DF_REG_USE_GET(REGNUM) ? DF_REG_USE_GET (REGNUM) : 0) /* Macros to access the elements within the insn_info structure table. */ #define DF_INSN_SIZE() ((df)->insns_size) -#define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID(INSN))]) +#define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID (INSN))]) #define DF_INSN_INFO_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL)) #define DF_INSN_INFO_LUID(II) ((II)->luid) #define DF_INSN_INFO_DEFS(II) ((II)->defs) #define DF_INSN_INFO_USES(II) ((II)->uses) #define DF_INSN_INFO_EQ_USES(II) ((II)->eq_uses) -#define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET(INSN))) -#define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET(INSN))) -#define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET(INSN))) -#define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET(INSN))) +#define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET (INSN))) +#define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET (INSN))) +#define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET (INSN))) +#define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET (INSN))) #define DF_INSN_UID_GET(UID) (df->insns[(UID)]) #define DF_INSN_UID_SET(UID,VAL) (df->insns[(UID)]=(VAL)) -#define DF_INSN_UID_SAFE_GET(UID) (((unsigned)(UID) < DF_INSN_SIZE()) \ +#define DF_INSN_UID_SAFE_GET(UID) (((unsigned)(UID) < DF_INSN_SIZE ()) \ ? DF_INSN_UID_GET (UID) \ : NULL) -#define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET(INSN)->luid) -#define DF_INSN_UID_DEFS(INSN) (DF_INSN_UID_GET(INSN)->defs) -#define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET(INSN)->uses) -#define DF_INSN_UID_EQ_USES(INSN) (DF_INSN_UID_GET(INSN)->eq_uses) -#define DF_INSN_UID_MWS(INSN) (DF_INSN_UID_GET(INSN)->mw_hardregs) +#define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET (INSN)->luid) +#define DF_INSN_UID_DEFS(INSN) (DF_INSN_UID_GET (INSN)->defs) +#define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET (INSN)->uses) +#define DF_INSN_UID_EQ_USES(INSN) (DF_INSN_UID_GET (INSN)->eq_uses) +#define DF_INSN_UID_MWS(INSN) (DF_INSN_UID_GET (INSN)->mw_hardregs) /* An obstack for bitmap not related to specific dataflow problems. This obstack should e.g. be used for bitmaps with a short life time diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c index 295bbb6e045..36094a19c9a 100644 --- a/gcc/diagnostic.c +++ b/gcc/diagnostic.c @@ -267,7 +267,7 @@ adjust_line (const char *line, int max_width, int *column_p) int line_width = strlen (line); int column = *column_p; - right_margin = MIN(line_width - column, right_margin); + right_margin = MIN (line_width - column, right_margin); right_margin = max_width - right_margin; if (line_width >= max_width && column > right_margin) { @@ -354,7 +354,7 @@ bt_callback (void *data, uintptr_t pc, const char *filename, int lineno, /* Skip functions in diagnostic.c. */ if (*pcount == 0 && filename != NULL - && strcmp (lbasename(filename), "diagnostic.c") == 0) + && strcmp (lbasename (filename), "diagnostic.c") == 0) return 0; /* Print up to 20 functions. We could make this a --param, but @@ -881,7 +881,7 @@ diagnostic_append_note (diagnostic_context *context, pp_destroy_prefix (context->printer); pp_set_prefix (context->printer, saved_prefix); diagnostic_show_locus (context, &diagnostic); - va_end(ap); + va_end (ap); } bool diff --git a/gcc/double-int.c b/gcc/double-int.c index 7eaad659279..32dc514a3dd 100644 --- a/gcc/double-int.c +++ b/gcc/double-int.c @@ -1555,11 +1555,11 @@ mpz_get_double_int (const_tree type, mpz_t val, bool wrap) for representing the value. The code to calculate count is extracted from the GMP manual, section "Integer Import and Export": http://gmplib.org/manual/Integer-Import-and-Export.html */ - numb = 8*sizeof(HOST_WIDE_INT); + numb = 8 * sizeof (HOST_WIDE_INT); count = (mpz_sizeinbase (val, 2) + numb-1) / numb; if (count < 2) count = 2; - vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof(HOST_WIDE_INT)); + vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof (HOST_WIDE_INT)); vp[0] = 0; vp[1] = 0; diff --git a/gcc/dse.c b/gcc/dse.c index d0e99db3dbd..1d04a252583 100644 --- a/gcc/dse.c +++ b/gcc/dse.c @@ -2916,8 +2916,8 @@ dse_step2_nospill (void) if (group == clear_alias_group) continue; - memset (group->offset_map_n, 0, sizeof(int) * group->offset_map_size_n); - memset (group->offset_map_p, 0, sizeof(int) * group->offset_map_size_p); + memset (group->offset_map_n, 0, sizeof (int) * group->offset_map_size_n); + memset (group->offset_map_p, 0, sizeof (int) * group->offset_map_size_p); bitmap_clear (group->group_kill); EXECUTE_IF_SET_IN_BITMAP (group->store2_n, 0, j, bi) @@ -3749,8 +3749,8 @@ const pass_data pass_data_rtl_dse1 = class pass_rtl_dse1 : public rtl_opt_pass { public: - pass_rtl_dse1(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_dse1, ctxt) + pass_rtl_dse1 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_dse1, ctxt) {} /* opt_pass methods: */ @@ -3787,8 +3787,8 @@ const pass_data pass_data_rtl_dse2 = class pass_rtl_dse2 : public rtl_opt_pass { public: - pass_rtl_dse2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_dse2, ctxt) + pass_rtl_dse2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_dse2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/dumpfile.c b/gcc/dumpfile.c index dc87ab35e8c..435d22dc8eb 100644 --- a/gcc/dumpfile.c +++ b/gcc/dumpfile.c @@ -240,10 +240,10 @@ dump_open_alternate_stream (struct dump_file_info *dfi) if (dfi->alt_stream) return dfi->alt_stream; - stream = strcmp("stderr", dfi->alt_filename) == 0 + stream = strcmp ("stderr", dfi->alt_filename) == 0 ? stderr - : strcmp("stdout", dfi->alt_filename) == 0 - ? stdout + : strcmp ("stdout", dfi->alt_filename) == 0 + ? stdout : fopen (dfi->alt_filename, dfi->alt_state < 0 ? "w" : "a"); if (!stream) @@ -404,10 +404,10 @@ dump_start (int phase, int *flag_ptr) name = get_dump_file_name (phase); if (name) { - stream = strcmp("stderr", name) == 0 + stream = strcmp ("stderr", name) == 0 ? stderr - : strcmp("stdout", name) == 0 - ? stdout + : strcmp ("stdout", name) == 0 + ? stdout : fopen (name, dfi->pstate < 0 ? "w" : "a"); if (!stream) error ("could not open dump file %qs: %m", name); @@ -451,12 +451,12 @@ dump_finish (int phase) return; dfi = get_dump_file_info (phase); if (dfi->pstream && (!dfi->pfilename - || (strcmp("stderr", dfi->pfilename) != 0 - && strcmp("stdout", dfi->pfilename) != 0))) + || (strcmp ("stderr", dfi->pfilename) != 0 + && strcmp ("stdout", dfi->pfilename) != 0))) fclose (dfi->pstream); - if (dfi->alt_stream && strcmp("stderr", dfi->alt_filename) != 0 - && strcmp("stdout", dfi->alt_filename) != 0) + if (dfi->alt_stream && strcmp ("stderr", dfi->alt_filename) != 0 + && strcmp ("stdout", dfi->alt_filename) != 0) fclose (dfi->alt_stream); dfi->alt_stream = NULL; @@ -488,10 +488,10 @@ dump_begin (int phase, int *flag_ptr) return NULL; dfi = get_dump_file_info (phase); - stream = strcmp("stderr", name) == 0 + stream = strcmp ("stderr", name) == 0 ? stderr - : strcmp("stdout", name) == 0 - ? stdout + : strcmp ("stdout", name) == 0 + ? stdout : fopen (name, dfi->pstate < 0 ? "w" : "a"); if (!stream) diff --git a/gcc/dwarf2asm.c b/gcc/dwarf2asm.c index 37dc8959bdc..69907f9fbf2 100644 --- a/gcc/dwarf2asm.c +++ b/gcc/dwarf2asm.c @@ -315,7 +315,7 @@ dw2_asm_output_nstring (const char *str, size_t orig_len, int c = str[i]; if (c == '\"' || c == '\\') fputc ('\\', asm_out_file); - if (ISPRINT(c)) + if (ISPRINT (c)) fputc (c, asm_out_file); else fprintf (asm_out_file, "\\%o", c); diff --git a/gcc/dwarf2cfi.c b/gcc/dwarf2cfi.c index 12256bcec39..5a096adcd0f 100644 --- a/gcc/dwarf2cfi.c +++ b/gcc/dwarf2cfi.c @@ -2841,14 +2841,14 @@ create_cie_data (void) dw_stack_pointer_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM); dw_frame_pointer_regnum = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM); - memset (&cie_trace, 0, sizeof(cie_trace)); + memset (&cie_trace, 0, sizeof (cie_trace)); cur_trace = &cie_trace; add_cfi_vec = &cie_cfi_vec; cie_cfi_row = cur_row = new_cfi_row (); /* On entry, the Canonical Frame Address is at SP. */ - memset(&loc, 0, sizeof (loc)); + memset (&loc, 0, sizeof (loc)); loc.reg = dw_stack_pointer_regnum; loc.offset = INCOMING_FRAME_SP_OFFSET; def_cfa_1 (&loc); @@ -3268,7 +3268,7 @@ dump_cfi_row (FILE *f, dw_cfi_row *row) if (!cfi) { dw_cfa_location dummy; - memset(&dummy, 0, sizeof(dummy)); + memset (&dummy, 0, sizeof (dummy)); dummy.reg = INVALID_REGNUM; cfi = def_cfa_0 (&dummy, &row->cfa); } @@ -3391,8 +3391,8 @@ const pass_data pass_data_dwarf2_frame = class pass_dwarf2_frame : public rtl_opt_pass { public: - pass_dwarf2_frame(gcc::context *ctxt) - : rtl_opt_pass(pass_data_dwarf2_frame, ctxt) + pass_dwarf2_frame (gcc::context *ctxt) + : rtl_opt_pass (pass_data_dwarf2_frame, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index 95049e4d184..8d865d38d0e 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -4245,7 +4245,7 @@ index_addr_table_entry (void **h, void *v) if (node->refcount == 0) return 1; - gcc_assert(node->index == NO_INDEX_ASSIGNED); + gcc_assert (node->index == NO_INDEX_ASSIGNED); node->index = *index; *index += 1; @@ -6163,7 +6163,7 @@ generate_type_signature (dw_die_ref die, comdat_type_node *type_node) context, if any. This is stored in the type unit DIE for link-time ODR (one-definition rule) checking. */ - if (is_cxx() && name != NULL) + if (is_cxx () && name != NULL) { md5_init_ctx (&ctx); @@ -6249,7 +6249,7 @@ same_dw_val_p (const dw_val_node *v1, const dw_val_node *v2, int *mark) case dw_val_class_flag: return v1->v.val_flag == v2->v.val_flag; case dw_val_class_str: - return !strcmp(v1->v.val_str->str, v2->v.val_str->str); + return !strcmp (v1->v.val_str->str, v2->v.val_str->str); case dw_val_class_addr: r1 = v1->v.val_addr; @@ -6788,7 +6788,7 @@ contains_subprogram_definition (dw_die_ref die) if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die)) return 1; - FOR_EACH_CHILD (die, c, if (contains_subprogram_definition(c)) return 1); + FOR_EACH_CHILD (die, c, if (contains_subprogram_definition (c)) return 1); return 0; } @@ -6860,7 +6860,7 @@ clone_tree (dw_die_ref die) dw_die_ref c; dw_die_ref clone = clone_die (die); - FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree(c))); + FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree (c))); return clone; } @@ -7052,7 +7052,7 @@ copy_declaration_context (dw_die_ref unit, dw_die_ref die) add_dwarf_attr (die, a); } - FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree(c))); + FOR_EACH_CHILD (decl, c, add_child_die (die, clone_tree (c))); } if (decl->die_parent != NULL @@ -19109,7 +19109,7 @@ gen_compile_unit_die (const char *filename) else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0) ; else if (strncmp (common_lang, "GNU C", 5) == 0 - && strncmp(TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0) + && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0) /* Mixing C and C++ is ok, use C++ in that case. */ common_lang = "GNU C++"; else @@ -21996,7 +21996,7 @@ index_string (void **h, void *v) find_string_form (node); if (node->form == DW_FORM_GNU_str_index && node->refcount > 0) { - gcc_assert(node->index == NO_INDEX_ASSIGNED); + gcc_assert (node->index == NO_INDEX_ASSIGNED); node->index = *index; *index += 1; } diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c index 888076cf4d7..85714f5d8a5 100644 --- a/gcc/emit-rtl.c +++ b/gcc/emit-rtl.c @@ -4090,7 +4090,7 @@ reorder_insns_nobb (rtx from, rtx to, rtx after) NEXT_INSN (to) = NEXT_INSN (after); PREV_INSN (from) = after; NEXT_INSN (after) = from; - if (after == get_last_insn()) + if (after == get_last_insn ()) set_last_insn (to); } @@ -4300,7 +4300,7 @@ emit_insn_after_1 (rtx first, rtx after, basic_block bb) if (after_after) PREV_INSN (after_after) = last; - if (after == get_last_insn()) + if (after == get_last_insn ()) set_last_insn (last); return last; @@ -4700,7 +4700,7 @@ emit_debug_insn_before (rtx pattern, rtx before) rtx emit_insn (rtx x) { - rtx last = get_last_insn(); + rtx last = get_last_insn (); rtx insn; if (x == NULL_RTX) @@ -4747,7 +4747,7 @@ emit_insn (rtx x) rtx emit_debug_insn (rtx x) { - rtx last = get_last_insn(); + rtx last = get_last_insn (); rtx insn; if (x == NULL_RTX) @@ -5804,9 +5804,9 @@ init_emit_once (void) mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) { - FCONST0(mode).data.high = 0; - FCONST0(mode).data.low = 0; - FCONST0(mode).mode = mode; + FCONST0 (mode).data.high = 0; + FCONST0 (mode).data.low = 0; + FCONST0 (mode).mode = mode; const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( FCONST0 (mode), mode); } @@ -5815,9 +5815,9 @@ init_emit_once (void) mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) { - FCONST0(mode).data.high = 0; - FCONST0(mode).data.low = 0; - FCONST0(mode).mode = mode; + FCONST0 (mode).data.high = 0; + FCONST0 (mode).data.low = 0; + FCONST0 (mode).mode = mode; const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( FCONST0 (mode), mode); } @@ -5826,17 +5826,17 @@ init_emit_once (void) mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) { - FCONST0(mode).data.high = 0; - FCONST0(mode).data.low = 0; - FCONST0(mode).mode = mode; + FCONST0 (mode).data.high = 0; + FCONST0 (mode).data.low = 0; + FCONST0 (mode).mode = mode; const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( FCONST0 (mode), mode); /* We store the value 1. */ - FCONST1(mode).data.high = 0; - FCONST1(mode).data.low = 0; - FCONST1(mode).mode = mode; - FCONST1(mode).data + FCONST1 (mode).data.high = 0; + FCONST1 (mode).data.low = 0; + FCONST1 (mode).mode = mode; + FCONST1 (mode).data = double_int_one.lshift (GET_MODE_FBIT (mode), HOST_BITS_PER_DOUBLE_INT, SIGNED_FIXED_POINT_MODE_P (mode)); @@ -5848,17 +5848,17 @@ init_emit_once (void) mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode)) { - FCONST0(mode).data.high = 0; - FCONST0(mode).data.low = 0; - FCONST0(mode).mode = mode; + FCONST0 (mode).data.high = 0; + FCONST0 (mode).data.low = 0; + FCONST0 (mode).mode = mode; const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( FCONST0 (mode), mode); /* We store the value 1. */ - FCONST1(mode).data.high = 0; - FCONST1(mode).data.low = 0; - FCONST1(mode).mode = mode; - FCONST1(mode).data + FCONST1 (mode).data.high = 0; + FCONST1 (mode).data.low = 0; + FCONST1 (mode).mode = mode; + FCONST1 (mode).data = double_int_one.lshift (GET_MODE_FBIT (mode), HOST_BITS_PER_DOUBLE_INT, SIGNED_FIXED_POINT_MODE_P (mode)); diff --git a/gcc/errors.c b/gcc/errors.c index cac7dcb9c09..5e0bc720e6f 100644 --- a/gcc/errors.c +++ b/gcc/errors.c @@ -48,7 +48,7 @@ warning (const char *format, ...) fprintf (stderr, "%s: warning: ", progname); vfprintf (stderr, format, ap); va_end (ap); - fputc('\n', stderr); + fputc ('\n', stderr); } @@ -63,7 +63,7 @@ error (const char *format, ...) fprintf (stderr, "%s: ", progname); vfprintf (stderr, format, ap); va_end (ap); - fputc('\n', stderr); + fputc ('\n', stderr); have_error = 1; } @@ -80,7 +80,7 @@ fatal (const char *format, ...) fprintf (stderr, "%s: ", progname); vfprintf (stderr, format, ap); va_end (ap); - fputc('\n', stderr); + fputc ('\n', stderr); exit (FATAL_EXIT_CODE); } diff --git a/gcc/except.c b/gcc/except.c index b161f9e2b69..fb47fbb06cb 100644 --- a/gcc/except.c +++ b/gcc/except.c @@ -641,7 +641,7 @@ eh_region_outermost (struct function *ifun, eh_region region_a, gcc_assert (ifun->eh->region_array); gcc_assert (ifun->eh->region_tree); - b_outer = sbitmap_alloc (ifun->eh->region_array->length()); + b_outer = sbitmap_alloc (ifun->eh->region_array->length ()); bitmap_clear (b_outer); do @@ -2021,8 +2021,8 @@ const pass_data pass_data_set_nothrow_function_flags = class pass_set_nothrow_function_flags : public rtl_opt_pass { public: - pass_set_nothrow_function_flags(gcc::context *ctxt) - : rtl_opt_pass(pass_data_set_nothrow_function_flags, ctxt) + pass_set_nothrow_function_flags (gcc::context *ctxt) + : rtl_opt_pass (pass_data_set_nothrow_function_flags, ctxt) {} /* opt_pass methods: */ @@ -2652,8 +2652,8 @@ const pass_data pass_data_convert_to_eh_region_ranges = class pass_convert_to_eh_region_ranges : public rtl_opt_pass { public: - pass_convert_to_eh_region_ranges(gcc::context *ctxt) - : rtl_opt_pass(pass_data_convert_to_eh_region_ranges, ctxt) + pass_convert_to_eh_region_ranges (gcc::context *ctxt) + : rtl_opt_pass (pass_data_convert_to_eh_region_ranges, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/expmed.c b/gcc/expmed.c index e83d064addc..92c293879d5 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -2806,7 +2806,7 @@ choose_mult_variant (enum machine_mode mode, HOST_WIDE_INT val, `unsigned int' */ if (HOST_BITS_PER_INT >= GET_MODE_UNIT_BITSIZE (mode)) { - op_cost = neg_cost(speed, mode); + op_cost = neg_cost (speed, mode); if (MULT_COST_LESS (&alg->cost, mult_cost)) { limit.cost = alg->cost.cost - op_cost; @@ -3124,7 +3124,7 @@ expand_mult (enum machine_mode mode, rtx op0, rtx op1, rtx target, calculation of the synth_mult. */ coeff = -(unsigned HOST_WIDE_INT) coeff; max_cost = (set_src_cost (gen_rtx_MULT (mode, fake_reg, op1), speed) - - neg_cost(speed, mode)); + - neg_cost (speed, mode)); if (max_cost <= 0) goto skip_synth; @@ -3877,7 +3877,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode, { if (rem_flag) return const0_rtx; - return expand_unop (mode, flag_trapv && GET_MODE_CLASS(mode) == MODE_INT + return expand_unop (mode, flag_trapv && GET_MODE_CLASS (mode) == MODE_INT ? negv_optab : neg_optab, op0, target, 0); } diff --git a/gcc/expr.c b/gcc/expr.c index bb5f8a88855..01cd9e66bdf 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -1738,7 +1738,7 @@ emit_group_load_1 (rtx *tmps, rtx dst, rtx orig_src, tree type, int ssize) } else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode && XVECLEN (dst, 0) > 1) - tmps[i] = simplify_gen_subreg (mode, src, GET_MODE(dst), bytepos); + tmps[i] = simplify_gen_subreg (mode, src, GET_MODE (dst), bytepos); else if (CONSTANT_P (src)) { HOST_WIDE_INT len = (HOST_WIDE_INT) bytelen; @@ -3247,10 +3247,10 @@ emit_move_complex (enum machine_mode mode, rtx x, rtx y) && optab_handler (mov_optab, GET_MODE_INNER (mode)) != CODE_FOR_nothing && !(REG_P (x) && HARD_REGISTER_P (x) - && hard_regno_nregs[REGNO(x)][mode] == 1) + && hard_regno_nregs[REGNO (x)][mode] == 1) && !(REG_P (y) && HARD_REGISTER_P (y) - && hard_regno_nregs[REGNO(y)][mode] == 1)) + && hard_regno_nregs[REGNO (y)][mode] == 1)) try_int = false; /* Not possible if the values are inherently not adjacent. */ else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT) @@ -7560,7 +7560,7 @@ expand_expr_addr_expr_1 (tree exp, rtx target, enum machine_mode tmode, if (TREE_ADDRESSABLE (exp) && ! MEM_P (result) - && ! targetm.calls.allocate_stack_slots_for_args()) + && ! targetm.calls.allocate_stack_slots_for_args ()) { error ("local frame unavailable (naked function?)"); return result; diff --git a/gcc/file-find.c b/gcc/file-find.c index bc6b4349ef5..3952349e989 100644 --- a/gcc/file-find.c +++ b/gcc/file-find.c @@ -25,7 +25,7 @@ along with GCC; see the file COPYING3. If not see static bool debug = false; void -find_file_set_debug(bool debug_state) +find_file_set_debug (bool debug_state) { debug = debug_state; } diff --git a/gcc/final.c b/gcc/final.c index c25f7566567..641ebe48eee 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -704,7 +704,7 @@ compute_alignments (void) freq_threshold = freq_max / PARAM_VALUE (PARAM_ALIGN_THRESHOLD); if (dump_file) - fprintf(dump_file, "freq_max: %i\n",freq_max); + fprintf (dump_file, "freq_max: %i\n",freq_max); FOR_EACH_BB (bb) { rtx label = BB_HEAD (bb); @@ -716,9 +716,10 @@ compute_alignments (void) || optimize_bb_for_size_p (bb)) { if (dump_file) - fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n", - bb->index, bb->frequency, bb->loop_father->num, - bb_loop_depth (bb)); + fprintf (dump_file, + "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n", + bb->index, bb->frequency, bb->loop_father->num, + bb_loop_depth (bb)); continue; } max_log = LABEL_ALIGN (label); @@ -733,10 +734,11 @@ compute_alignments (void) } if (dump_file) { - fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i fall %4i branch %4i", - bb->index, bb->frequency, bb->loop_father->num, - bb_loop_depth (bb), - fallthru_frequency, branch_frequency); + fprintf (dump_file, "BB %4i freq %4i loop %2i loop_depth" + " %2i fall %4i branch %4i", + bb->index, bb->frequency, bb->loop_father->num, + bb_loop_depth (bb), + fallthru_frequency, branch_frequency); if (!bb->loop_father->inner && bb->loop_father->num) fprintf (dump_file, " inner_loop"); if (bb->loop_father->header == bb) @@ -762,7 +764,7 @@ compute_alignments (void) { log = JUMP_ALIGN (label); if (dump_file) - fprintf(dump_file, " jump alignment added.\n"); + fprintf (dump_file, " jump alignment added.\n"); if (max_log < log) { max_log = log; @@ -779,7 +781,7 @@ compute_alignments (void) { log = LOOP_ALIGN (label); if (dump_file) - fprintf(dump_file, " internal loop alignment added.\n"); + fprintf (dump_file, " internal loop alignment added.\n"); if (max_log < log) { max_log = log; @@ -862,8 +864,8 @@ const pass_data pass_data_compute_alignments = class pass_compute_alignments : public rtl_opt_pass { public: - pass_compute_alignments(gcc::context *ctxt) - : rtl_opt_pass(pass_data_compute_alignments, ctxt) + pass_compute_alignments (gcc::context *ctxt) + : rtl_opt_pass (pass_data_compute_alignments, ctxt) {} /* opt_pass methods: */ @@ -1123,7 +1125,7 @@ shorten_branches (rtx first) INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid]; if (NOTE_P (insn) || BARRIER_P (insn) - || LABEL_P (insn) || DEBUG_INSN_P(insn)) + || LABEL_P (insn) || DEBUG_INSN_P (insn)) continue; if (INSN_DELETED_P (insn)) continue; @@ -4489,8 +4491,8 @@ const pass_data pass_data_final = class pass_final : public rtl_opt_pass { public: - pass_final(gcc::context *ctxt) - : rtl_opt_pass(pass_data_final, ctxt) + pass_final (gcc::context *ctxt) + : rtl_opt_pass (pass_data_final, ctxt) {} /* opt_pass methods: */ @@ -4535,8 +4537,8 @@ const pass_data pass_data_shorten_branches = class pass_shorten_branches : public rtl_opt_pass { public: - pass_shorten_branches(gcc::context *ctxt) - : rtl_opt_pass(pass_data_shorten_branches, ctxt) + pass_shorten_branches (gcc::context *ctxt) + : rtl_opt_pass (pass_data_shorten_branches, ctxt) {} /* opt_pass methods: */ @@ -4699,8 +4701,8 @@ const pass_data pass_data_clean_state = class pass_clean_state : public rtl_opt_pass { public: - pass_clean_state(gcc::context *ctxt) - : rtl_opt_pass(pass_data_clean_state, ctxt) + pass_clean_state (gcc::context *ctxt) + : rtl_opt_pass (pass_data_clean_state, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/fixed-value.c b/gcc/fixed-value.c index 8ba78769c79..91ec5880119 100644 --- a/gcc/fixed-value.c +++ b/gcc/fixed-value.c @@ -97,7 +97,7 @@ fixed_from_double_int (double_int payload, enum machine_mode mode) else if (UNSIGNED_SCALAR_FIXED_POINT_MODE_P (mode)) value.data = payload.zext (GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode)); else - gcc_unreachable(); + gcc_unreachable (); value.mode = mode; diff --git a/gcc/fold-const.c b/gcc/fold-const.c index d435b540e00..72a43e04a44 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -11711,8 +11711,8 @@ fold_binary_loc (location_t loc, if (TREE_CODE (arg1) == INTEGER_CST) { double_int cst1 = tree_to_double_int (arg1); - double_int ncst1 = (-cst1).ext(TYPE_PRECISION (TREE_TYPE (arg1)), - TYPE_UNSIGNED (TREE_TYPE (arg1))); + double_int ncst1 = (-cst1).ext (TYPE_PRECISION (TREE_TYPE (arg1)), + TYPE_UNSIGNED (TREE_TYPE (arg1))); if ((cst1 & ncst1) == ncst1 && multiple_of_p (type, arg0, double_int_to_tree (TREE_TYPE (arg1), ncst1))) diff --git a/gcc/function.c b/gcc/function.c index c7d259c73ff..eb8aca91aaa 100644 --- a/gcc/function.c +++ b/gcc/function.c @@ -1970,8 +1970,8 @@ const pass_data pass_data_instantiate_virtual_regs = class pass_instantiate_virtual_regs : public rtl_opt_pass { public: - pass_instantiate_virtual_regs(gcc::context *ctxt) - : rtl_opt_pass(pass_data_instantiate_virtual_regs, ctxt) + pass_instantiate_virtual_regs (gcc::context *ctxt) + : rtl_opt_pass (pass_data_instantiate_virtual_regs, ctxt) {} /* opt_pass methods: */ @@ -2078,7 +2078,7 @@ aggregate_value_p (const_tree exp, const_tree fntype) bool use_register_for_decl (const_tree decl) { - if (!targetm.calls.allocate_stack_slots_for_args()) + if (!targetm.calls.allocate_stack_slots_for_args ()) return true; /* Honor volatile. */ @@ -7022,8 +7022,8 @@ const pass_data pass_data_leaf_regs = class pass_leaf_regs : public rtl_opt_pass { public: - pass_leaf_regs(gcc::context *ctxt) - : rtl_opt_pass(pass_data_leaf_regs, ctxt) + pass_leaf_regs (gcc::context *ctxt) + : rtl_opt_pass (pass_data_leaf_regs, ctxt) {} /* opt_pass methods: */ @@ -7079,8 +7079,8 @@ const pass_data pass_data_thread_prologue_and_epilogue = class pass_thread_prologue_and_epilogue : public rtl_opt_pass { public: - pass_thread_prologue_and_epilogue(gcc::context *ctxt) - : rtl_opt_pass(pass_data_thread_prologue_and_epilogue, ctxt) + pass_thread_prologue_and_epilogue (gcc::context *ctxt) + : rtl_opt_pass (pass_data_thread_prologue_and_epilogue, ctxt) {} /* opt_pass methods: */ @@ -7298,8 +7298,8 @@ const pass_data pass_data_match_asm_constraints = class pass_match_asm_constraints : public rtl_opt_pass { public: - pass_match_asm_constraints(gcc::context *ctxt) - : rtl_opt_pass(pass_data_match_asm_constraints, ctxt) + pass_match_asm_constraints (gcc::context *ctxt) + : rtl_opt_pass (pass_data_match_asm_constraints, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/fwprop.c b/gcc/fwprop.c index 137011d3324..d08710c9614 100644 --- a/gcc/fwprop.c +++ b/gcc/fwprop.c @@ -1504,8 +1504,8 @@ const pass_data pass_data_rtl_fwprop = class pass_rtl_fwprop : public rtl_opt_pass { public: - pass_rtl_fwprop(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_fwprop, ctxt) + pass_rtl_fwprop (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_fwprop, ctxt) {} /* opt_pass methods: */ @@ -1570,8 +1570,8 @@ const pass_data pass_data_rtl_fwprop_addr = class pass_rtl_fwprop_addr : public rtl_opt_pass { public: - pass_rtl_fwprop_addr(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_fwprop_addr, ctxt) + pass_rtl_fwprop_addr (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_fwprop_addr, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/gcc-ar.c b/gcc/gcc-ar.c index ef425c1cb30..d7e05e3f35c 100644 --- a/gcc/gcc-ar.c +++ b/gcc/gcc-ar.c @@ -123,7 +123,7 @@ setup_prefixes (const char *exec_path) } int -main(int ac, char **av) +main (int ac, char **av) { const char *exe_name; char *plugin; @@ -166,7 +166,7 @@ main(int ac, char **av) nargv[1] = "--plugin"; nargv[2] = plugin; if (is_ar && av[1] && av[1][0] != '-') - av[1] = concat("-", av[1], NULL); + av[1] = concat ("-", av[1], NULL); for (k = 1; k < ac; k++) nargv[2 + k] = av[k]; nargv[2 + k] = NULL; @@ -176,18 +176,18 @@ main(int ac, char **av) err_msg = pex_one (PEX_LAST|PEX_SEARCH, exe_name, CONST_CAST2 (char * const *, const char **, nargv), - concat("gcc-", exe_name, NULL), + concat ("gcc-", exe_name, NULL), NULL,NULL, &status, &err); if (err_msg) - fprintf(stderr, "Error running %s: %s\n", exe_name, err_msg); + fprintf (stderr, "Error running %s: %s\n", exe_name, err_msg); else if (status) { if (WIFSIGNALED (status)) { int sig = WTERMSIG (status); fprintf (stderr, "%s terminated with signal %d [%s]%s\n", - exe_name, sig, strsignal(sig), - WCOREDUMP(status) ? ", core dumped" : ""); + exe_name, sig, strsignal (sig), + WCOREDUMP (status) ? ", core dumped" : ""); } else if (WIFEXITED (status)) exit_code = WEXITSTATUS (status); diff --git a/gcc/gcc.c b/gcc/gcc.c index d48c4db118b..2bbc9426cf9 100644 --- a/gcc/gcc.c +++ b/gcc/gcc.c @@ -1556,7 +1556,7 @@ init_spec (void) /* Prepend "--traditional-format" to whatever asm_spec we had before. */ { static const char tf[] = "--traditional-format "; - obstack_grow (&obstack, tf, sizeof(tf) - 1); + obstack_grow (&obstack, tf, sizeof (tf) - 1); obstack_grow0 (&obstack, asm_spec, strlen (asm_spec)); asm_spec = XOBFINISH (&obstack, const char *); } @@ -1566,19 +1566,19 @@ init_spec (void) defined LINKER_HASH_STYLE # ifdef LINK_BUILDID_SPEC /* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */ - obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1); + obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1); # endif # ifdef LINK_EH_SPEC /* Prepend LINK_EH_SPEC to whatever link_spec we had before. */ - obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1); + obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1); # endif # ifdef LINKER_HASH_STYLE /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had before. */ { static const char hash_style[] = "--hash-style="; - obstack_grow (&obstack, hash_style, sizeof(hash_style) - 1); - obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof(LINKER_HASH_STYLE) - 1); + obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1); + obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1); obstack_1grow (&obstack, ' '); } # endif @@ -1644,7 +1644,7 @@ set_spec (const char *name, const char *spec, bool user_p) /* Free the old spec. */ if (old_spec && sl->alloc_p) - free (CONST_CAST(char *, old_spec)); + free (CONST_CAST (char *, old_spec)); sl->user_p = user_p; sl->alloc_p = true; @@ -2490,7 +2490,7 @@ find_a_file (const struct path_prefix *pprefix, const char *name, int mode, #endif #ifdef DEFAULT_LINKER - if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0) + if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0) return xstrdup (DEFAULT_LINKER); #endif @@ -5741,11 +5741,11 @@ handle_braces (const char *p) a_is_negated = false; a_is_spectype = false; - SKIP_WHITE(); + SKIP_WHITE (); if (*p == '!') p++, a_is_negated = true; - SKIP_WHITE(); + SKIP_WHITE (); if (*p == '%' && p[1] == ':') { atom = NULL; @@ -5760,7 +5760,7 @@ handle_braces (const char *p) p++, a_is_spectype = true; atom = p; - while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '=' + while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '=' || *p == ',' || *p == '.' || *p == '@') p++; end_atom = p; @@ -5769,7 +5769,7 @@ handle_braces (const char *p) p++, a_is_starred = 1; } - SKIP_WHITE(); + SKIP_WHITE (); switch (*p) { case '&': case '}': @@ -6074,13 +6074,13 @@ give_switch (int switchnum, int omit_first_word) while (length-- && !IS_DIR_SEPARATOR (arg[length])) if (arg[length] == '.') { - (CONST_CAST(char *, arg))[length] = 0; + (CONST_CAST (char *, arg))[length] = 0; dot = 1; break; } do_spec_1 (arg, 1, NULL); if (dot) - (CONST_CAST(char *, arg))[length] = '.'; + (CONST_CAST (char *, arg))[length] = '.'; do_spec_1 (suffix_subst, 1, NULL); } else @@ -8395,7 +8395,7 @@ get_random_number (void) } #endif - return ret ^ getpid(); + return ret ^ getpid (); } /* %:compare-debug-dump-opt spec function. Save the last argument, @@ -8607,7 +8607,7 @@ replace_extension_spec_func (int argc, const char **argv) name = xstrdup (argv[0]); - for (i = strlen(name) - 1; i >= 0; i--) + for (i = strlen (name) - 1; i >= 0; i--) if (IS_DIR_SEPARATOR (name[i])) break; diff --git a/gcc/gcov-io.c b/gcc/gcov-io.c index 441aad92833..5a21c1f0691 100644 --- a/gcc/gcov-io.c +++ b/gcc/gcov-io.c @@ -386,7 +386,7 @@ gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary) h_cnt++; } } - gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH(h_cnt)); + gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH (h_cnt)); gcov_write_unsigned (summary->checksum); for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++) { @@ -559,7 +559,7 @@ gcov_read_summary (struct gcov_summary *summary) while (!cur_bitvector) { h_ix = bv_ix * 32; - gcc_assert(bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE); + gcc_assert (bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE); cur_bitvector = histo_bitvector[bv_ix++]; } while (!(cur_bitvector & 0x1)) @@ -567,7 +567,7 @@ gcov_read_summary (struct gcov_summary *summary) h_ix++; cur_bitvector >>= 1; } - gcc_assert(h_ix < GCOV_HISTOGRAM_SIZE); + gcc_assert (h_ix < GCOV_HISTOGRAM_SIZE); csum->histogram[h_ix].num_counters = gcov_read_unsigned (); csum->histogram[h_ix].min_value = gcov_read_counter (); @@ -709,7 +709,7 @@ static void gcov_histogram_merge (gcov_bucket_type *tgt_histo, gcov_bucket_type tmp_histo[GCOV_HISTOGRAM_SIZE]; int src_done = 0; - memset(tmp_histo, 0, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE); + memset (tmp_histo, 0, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE); /* Assume that the counters are in the same relative order in both histograms. Walk the histograms from largest to smallest entry, @@ -797,7 +797,7 @@ static void gcov_histogram_merge (gcov_bucket_type *tgt_histo, /* The merged counters get placed in the new merged histogram at the entry for the merged min_value. */ - tmp_i = gcov_histo_index(merge_min); + tmp_i = gcov_histo_index (merge_min); gcc_assert (tmp_i < GCOV_HISTOGRAM_SIZE); tmp_histo[tmp_i].num_counters += merge_num; tmp_histo[tmp_i].cum_value += merge_cum; @@ -829,12 +829,13 @@ static void gcov_histogram_merge (gcov_bucket_type *tgt_histo, } /* At this point, tmp_i should be the smallest non-zero entry in the tmp_histo. */ - gcc_assert(tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE - && tmp_histo[tmp_i].num_counters > 0); + gcc_assert (tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE + && tmp_histo[tmp_i].num_counters > 0); tmp_histo[tmp_i].cum_value += src_cum; /* Finally, copy the merged histogram into tgt_histo. */ - memcpy(tgt_histo, tmp_histo, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE); + memcpy (tgt_histo, tmp_histo, + sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE); } #endif /* !IN_GCOV */ diff --git a/gcc/gcov-io.h b/gcc/gcov-io.h index db1a6bf4c30..ea8d9a7b769 100644 --- a/gcc/gcov-io.h +++ b/gcc/gcov-io.h @@ -382,7 +382,7 @@ typedef unsigned HOST_WIDEST_INT gcov_type_unsigned; /* Return nonzero if SUB is an immediate subtag of TAG. */ #define GCOV_TAG_IS_SUBTAG(TAG,SUB) \ (GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (SUB) \ - && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK(TAG))) + && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK (TAG))) /* Return nonzero if SUB is at a sublevel to TAG. */ #define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \ diff --git a/gcc/gcov.c b/gcc/gcov.c index 6aa48fd26c2..9458812d86b 100644 --- a/gcc/gcov.c +++ b/gcc/gcov.c @@ -398,7 +398,7 @@ static void executed_summary (unsigned, unsigned); static void function_summary (const coverage_t *, const char *); static const char *format_gcov (gcov_type, gcov_type, int); static void accumulate_line_counts (source_t *); -static void output_gcov_file(const char *, source_t *); +static void output_gcov_file (const char *, source_t *); static int output_branch_count (FILE *, int, const arc_t *); static void output_lines (FILE *, const source_t *); static char *make_gcov_file_name (const char *, const char *); @@ -448,8 +448,8 @@ main (int argc, char **argv) for (; argno != argc; argno++) { if (flag_display_progress) - printf("Processing file %d out of %d\n", - argno - first_arg + 1, argc - first_arg); + printf ("Processing file %d out of %d\n", + argno - first_arg + 1, argc - first_arg); process_file (argv[argno]); } @@ -621,7 +621,7 @@ get_gcov_intermediate_filename (const char *file_name) /* Find the 'basename'. */ cptr = lbasename (file_name); - result = XNEWVEC(char, strlen (cptr) + strlen (gcov) + 1); + result = XNEWVEC (char, strlen (cptr) + strlen (gcov) + 1); sprintf (result, "%s%s", cptr, gcov); return result; @@ -699,7 +699,7 @@ output_intermediate_file (FILE *gcov_file, source_t *src) branch_type = (arc->count > 0) ? "taken" : "nottaken"; else branch_type = "notexec"; - fprintf(gcov_file, "branch:%d,%s\n", line_num, branch_type); + fprintf (gcov_file, "branch:%d,%s\n", line_num, branch_type); } } } @@ -782,7 +782,7 @@ process_file (const char *file_name) } static void -output_gcov_file(const char *file_name, source_t *src) +output_gcov_file (const char *file_name, source_t *src) { char *gcov_file_name = make_gcov_file_name (file_name, src->coverage.name); diff --git a/gcc/gcse.c b/gcc/gcse.c index 422d6f060eb..bb9ba15ea8b 100644 --- a/gcc/gcse.c +++ b/gcc/gcse.c @@ -4169,8 +4169,8 @@ const pass_data pass_data_rtl_pre = class pass_rtl_pre : public rtl_opt_pass { public: - pass_rtl_pre(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_pre, ctxt) + pass_rtl_pre (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_pre, ctxt) {} /* opt_pass methods: */ @@ -4208,8 +4208,8 @@ const pass_data pass_data_rtl_hoist = class pass_rtl_hoist : public rtl_opt_pass { public: - pass_rtl_hoist(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_hoist, ctxt) + pass_rtl_hoist (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_hoist, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/genattr-common.c b/gcc/genattr-common.c index 69bfcae48c7..b0848cff7ec 100644 --- a/gcc/genattr-common.c +++ b/gcc/genattr-common.c @@ -33,7 +33,7 @@ static void write_upcase (const char *str) { for (; *str; str++) - putchar (TOUPPER(*str)); + putchar (TOUPPER (*str)); } static void diff --git a/gcc/genattr.c b/gcc/genattr.c index e16cad9c79a..0b92243a86d 100644 --- a/gcc/genattr.c +++ b/gcc/genattr.c @@ -361,10 +361,10 @@ main (int argc, char **argv) /* Output flag masks for use by reorg. Flags are used to hold branch direction for use by eligible_for_... */ - printf("\n#define ATTR_FLAG_forward\t0x1\n"); - printf("#define ATTR_FLAG_backward\t0x2\n"); + printf ("\n#define ATTR_FLAG_forward\t0x1\n"); + printf ("#define ATTR_FLAG_backward\t0x2\n"); - puts("\n#endif /* GCC_INSN_ATTR_H */"); + puts ("\n#endif /* GCC_INSN_ATTR_H */"); if (ferror (stdout) || fflush (stdout) || fclose (stdout)) return FATAL_EXIT_CODE; diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c index 8fcbb1610e6..973cade3fc2 100644 --- a/gcc/genattrtab.c +++ b/gcc/genattrtab.c @@ -90,9 +90,9 @@ along with GCC; see the file COPYING3. If not see `return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique (see attr_rtx). */ -#define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging)) -#define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct)) -#define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val)) +#define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), unchanging)) +#define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), in_struct)) +#define ATTR_PERMANENT_P(RTX) (RTX_FLAG ((RTX), return_val)) #if 0 #define strcmp_check(S1, S2) ((S1) == (S2) \ @@ -2815,7 +2815,7 @@ simplify_test_exp (rtx exp, int insn_code, int insn_index) x = evaluate_eq_attr (exp, attr, av->value, insn_code, insn_index); x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index); - if (attr_rtx_cost(x) < 7) + if (attr_rtx_cost (x) < 7) return x; } } @@ -4403,7 +4403,7 @@ write_upcase (FILE *outf, const char *str) while (*str) { /* The argument of TOUPPER should not have side effects. */ - fputc (TOUPPER(*str), outf); + fputc (TOUPPER (*str), outf); str++; } } @@ -5285,7 +5285,7 @@ main (int argc, char **argv) { FILE *outf; -#define IS_ATTR_GROUP(X) (!strncmp(attr->name,X,strlen(X))) +#define IS_ATTR_GROUP(X) (!strncmp (attr->name, X, strlen (X))) if (IS_ATTR_GROUP ("*internal_dfa_insn_code")) outf = dfa_file; else if (IS_ATTR_GROUP ("*insn_default_latency")) diff --git a/gcc/genautomata.c b/gcc/genautomata.c index add4624ba17..a0bf0767aa9 100644 --- a/gcc/genautomata.c +++ b/gcc/genautomata.c @@ -5533,7 +5533,7 @@ static reserv_sets_t form_reservs_matter (automaton_t automaton) { int cycle, unit; - reserv_sets_t reservs_matter = alloc_empty_reserv_sets(); + reserv_sets_t reservs_matter = alloc_empty_reserv_sets (); for (cycle = 0; cycle < max_cycles_num; cycle++) for (unit = 0; unit < description->units_num; unit++) @@ -7558,7 +7558,7 @@ output_trans_table (automaton_t automaton) { size_t i; arc_t arc; - vla_hwint_t transition_vect = vla_hwint_t(); + vla_hwint_t transition_vect = vla_hwint_t (); undefined_vect_el_value = automaton->achieved_states_num; automaton->trans_table = create_state_ainsn_table (automaton); @@ -7742,7 +7742,7 @@ output_dead_lock_vect (automaton_t automaton) { size_t i; arc_t arc; - vla_hwint_t dead_lock_vect = vla_hwint_t(); + vla_hwint_t dead_lock_vect = vla_hwint_t (); /* Create vect of pointers to states ordered by num of transitions from the state (state with the maximum num is the @@ -7787,7 +7787,7 @@ output_dead_lock_vect (automaton_t automaton) static void output_reserved_units_table (automaton_t automaton) { - vla_hwint_t reserved_units_table = vla_hwint_t(); + vla_hwint_t reserved_units_table = vla_hwint_t (); int state_byte_size; int reserved_units_size; size_t n; diff --git a/gcc/genconfig.c b/gcc/genconfig.c index 81edc7466ab..498dd72e375 100644 --- a/gcc/genconfig.c +++ b/gcc/genconfig.c @@ -355,7 +355,7 @@ main (int argc, char **argv) printf ("#define MAX_INSNS_PER_PEEP2 %d\n", max_insns_per_peep2); } - puts("\n#endif /* GCC_INSN_CONFIG_H */"); + puts ("\n#endif /* GCC_INSN_CONFIG_H */"); if (ferror (stdout) || fflush (stdout) || fclose (stdout)) return FATAL_EXIT_CODE; diff --git a/gcc/genemit.c b/gcc/genemit.c index 692ef526abf..d4bb301320d 100644 --- a/gcc/genemit.c +++ b/gcc/genemit.c @@ -68,7 +68,7 @@ print_code (RTX_CODE code) { const char *p1; for (p1 = GET_RTX_NAME (code); *p1; p1++) - putchar (TOUPPER(*p1)); + putchar (TOUPPER (*p1)); } static void diff --git a/gcc/genextract.c b/gcc/genextract.c index 6d2d3d2d0bb..35fc91e8806 100644 --- a/gcc/genextract.c +++ b/gcc/genextract.c @@ -165,9 +165,9 @@ gen_insn (rtx insn, int insn_code_number) p->duplocs = p->oplocs + op_count; p->dupnums = (int *)(p->duplocs + dup_count); - memcpy(p->oplocs, acc.oplocs.address(), op_count*sizeof(locstr)); - memcpy(p->duplocs, acc.duplocs.address(), dup_count*sizeof(locstr)); - memcpy(p->dupnums, acc.dupnums.address(), dup_count*sizeof(int)); + memcpy (p->oplocs, acc.oplocs.address (), op_count * sizeof (locstr)); + memcpy (p->duplocs, acc.duplocs.address (), dup_count * sizeof (locstr)); + memcpy (p->dupnums, acc.dupnums.address (), dup_count * sizeof (int)); done: acc.oplocs.release (); @@ -334,7 +334,7 @@ print_path (const char *path) { if (ISLOWER (path[i])) printf (", 0, %d)", path[i] - 'a'); - else if (ISDIGIT(path[i])) + else if (ISDIGIT (path[i])) printf (", %d)", path[i] - '0'); else gcc_unreachable (); diff --git a/gcc/genflags.c b/gcc/genflags.c index df329b5a806..80d8315e41b 100644 --- a/gcc/genflags.c +++ b/gcc/genflags.c @@ -109,7 +109,7 @@ gen_macro (const char *name, int real, int expect) for (i = 0; name[i]; i++) putchar (TOUPPER (name[i])); - putchar('('); + putchar ('('); for (i = 0; i < expect - 1; i++) printf ("%c, ", i + 'A'); printf ("%c) gen_%s (", i + 'A', name); @@ -290,7 +290,7 @@ main (int argc, char **argv) for (insn_ptr = insns; *insn_ptr; insn_ptr++) gen_proto (*insn_ptr); - puts("\n#endif /* GCC_INSN_FLAGS_H */"); + puts ("\n#endif /* GCC_INSN_FLAGS_H */"); if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout)) return FATAL_EXIT_CODE; diff --git a/gcc/gengenrtl.c b/gcc/gengenrtl.c index 5b5a3ca0308..4a35683c896 100644 --- a/gcc/gengenrtl.c +++ b/gcc/gengenrtl.c @@ -37,7 +37,7 @@ static const struct rtx_definition defs[] = { #include "rtl.def" /* rtl expressions are documented here */ }; -#define NUM_RTX_CODE ARRAY_SIZE(defs) +#define NUM_RTX_CODE ARRAY_SIZE (defs) static const char *formats[NUM_RTX_CODE]; diff --git a/gcc/gengtype-state.c b/gcc/gengtype-state.c index ba7948a1ff0..a019aaf353e 100644 --- a/gcc/gengtype-state.c +++ b/gcc/gengtype-state.c @@ -142,7 +142,7 @@ static long state_bol = 0; /* offset of beginning of line */ class s_expr_writer { public: - s_expr_writer(); + s_expr_writer (); void write_new_line (); void write_any_indent (int leading_spaces); @@ -159,7 +159,7 @@ private: class state_writer : public s_expr_writer { public: - state_writer(); + state_writer (); private: void write_state_fileloc (struct fileloc *floc); @@ -205,7 +205,7 @@ private: /* class s_expr_writer's trivial constructor. */ -s_expr_writer::s_expr_writer() +s_expr_writer::s_expr_writer () : indent_amount_(0), had_recent_newline_(0) { @@ -269,9 +269,9 @@ s_expr_writer::end_s_expr (void) /* class state_writer's trivial constructor. */ -state_writer::state_writer() - : s_expr_writer(), - state_written_type_count(0) +state_writer::state_writer () + : s_expr_writer (), + state_written_type_count (0) { } @@ -309,7 +309,7 @@ fatal_reading_state (struct state_token_st* tok, const char*msg) else \ fatal ("%s:%d: Invalid state file; " Fmt, \ state_path, state_line, __VA_ARGS__); \ - } while(0) + } while (0) /* Find or allocate an identifier in our name hash table. */ diff --git a/gcc/gengtype.c b/gcc/gengtype.c index ce60c788012..b9bef4df76c 100644 --- a/gcc/gengtype.c +++ b/gcc/gengtype.c @@ -617,7 +617,7 @@ type_for_name (const char *s) extern GTY(()) gcc::some_type *some_ptr; where the autogenerated functions will refer to simply "some_type", where they can be resolved into their namespace. */ - if (0 == strncmp(s, "gcc::", 5)) + if (0 == strncmp (s, "gcc::", 5)) s += 5; for (p = typedefs; p != NULL; p = p->next) @@ -953,7 +953,7 @@ create_field_at (pair_p next, type_p type, const char *name, options_p opt, /* Create a fake field with the given type and name. NEXT is the next field in the chain. */ #define create_field(next,type,name) \ - create_field_all(next,type,name, 0, this_file, __LINE__) + create_field_all (next,type,name, 0, this_file, __LINE__) /* Like create_field, but the field is only valid when condition COND is true. */ @@ -2131,7 +2131,7 @@ matching_file_name_substitute (const char *filnam, regmatch_t pmatch[10], else { /* This can happen only when files_rules is buggy! */ - gcc_unreachable(); + gcc_unreachable (); } /* Always skip the character after the dollar. */ pt++; @@ -2544,7 +2544,7 @@ output_mangled_typename (outf_p of, const_type_p t) oprintf (of, "%lu%s", (unsigned long) strlen (id_for_tag), id_for_tag); if (id_for_tag != t->u.s.tag) - free (CONST_CAST(char *, id_for_tag)); + free (CONST_CAST (char *, id_for_tag)); } break; case TYPE_PARAM_STRUCT: @@ -3329,7 +3329,7 @@ write_marker_function_name (outf_p of, type_p s, const char *prefix) const char *id_for_tag = filter_type_name (s->u.s.tag); oprintf (of, "gt_%sx_%s", prefix, id_for_tag); if (id_for_tag != s->u.s.tag) - free (CONST_CAST(char *, id_for_tag)); + free (CONST_CAST (char *, id_for_tag)); } else if (s->kind == TYPE_PARAM_STRUCT) { @@ -3663,7 +3663,7 @@ write_types (outf_p output_header, type_p structures, type_p param_structs, "#define gt_%sx_%s gt_%sx_%s\n", wtd->prefix, s->u.s.tag, wtd->prefix, t_id_for_tag); if (t_id_for_tag != t->u.s.tag) - free (CONST_CAST(char *, t_id_for_tag)); + free (CONST_CAST (char *, t_id_for_tag)); } else error_at_line (&s->u.s.line, @@ -3679,7 +3679,7 @@ write_types (outf_p output_header, type_p structures, type_p param_structs, wtd->prefix, s_id_for_tag); if (s_id_for_tag != s->u.s.tag) - free (CONST_CAST(char *, s_id_for_tag)); + free (CONST_CAST (char *, s_id_for_tag)); if (s->u.s.line.file == NULL) { @@ -4373,7 +4373,7 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, else oprintf (f, " NULL"); if (id_for_tag != tp->u.s.tag) - free (CONST_CAST(char *, id_for_tag)); + free (CONST_CAST (char *, id_for_tag)); } else if (!has_length && tp->kind == TYPE_PARAM_STRUCT) { @@ -4789,7 +4789,7 @@ write_typed_alloc_def (outf_p f, oprintf (f, ", n"); oprintf (f, " MEM_STAT_INFO)))\n"); if (type_name_as_id != type_name) - free (CONST_CAST(char *, type_name_as_id)); + free (CONST_CAST (char *, type_name_as_id)); } /* Writes a typed allocator definition into output F for a struct or @@ -4856,7 +4856,7 @@ write_typed_alloc_defns (outf_p f, relevant to plugin input files. */ if (nb_plugin_files > 0) { - struct fileloc* filoc = type_fileloc(s); + struct fileloc* filoc = type_fileloc (s); if (!filoc || !filoc->file->inpisplugin) continue; }; @@ -5470,7 +5470,7 @@ main (int argc, char **argv) we can see them. We should initialize them before calling read_input_list. */ #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \ - Call;} while(0) + Call;} while (0) POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos)); POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos)); POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos)); diff --git a/gcc/genmodes.c b/gcc/genmodes.c index dc384833871..a0b2f21f11b 100644 --- a/gcc/genmodes.c +++ b/gcc/genmodes.c @@ -418,7 +418,7 @@ complete_all_modes (void) } /* For each mode in class CLASS, construct a corresponding complex mode. */ -#define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__) +#define COMPLEX_MODES(C) make_complex_modes (MODE_##C, __FILE__, __LINE__) static void make_complex_modes (enum mode_class cl, const char *file, unsigned int line) @@ -474,7 +474,7 @@ make_complex_modes (enum mode_class cl, /* For all modes in class CL, construct vector modes of width WIDTH, having as many components as necessary. */ -#define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__) +#define VECTOR_MODES(C, W) make_vector_modes (MODE_##C, W, __FILE__, __LINE__) static void ATTRIBUTE_UNUSED make_vector_modes (enum mode_class cl, unsigned int width, const char *file, unsigned int line) @@ -522,7 +522,8 @@ make_vector_modes (enum mode_class cl, unsigned int width, /* Input. */ -#define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__) +#define _SPECIAL_MODE(C, N) \ + make_special_mode (MODE_##C, #N, __FILE__, __LINE__) #define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N) #define CC_MODE(N) _SPECIAL_MODE (CC, N) @@ -704,11 +705,11 @@ make_vector_mode (enum mode_class bclass, #define _ADD_ADJUST(A, M, X, C1, C2) \ new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__) -#define ADJUST_BYTESIZE(M, X) _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM) -#define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM) -#define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST(format, M, X, FLOAT, FLOAT) -#define ADJUST_IBIT(M, X) _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM) -#define ADJUST_FBIT(M, X) _ADD_ADJUST(fbit, M, X, FRACT, UACCUM) +#define ADJUST_BYTESIZE(M, X) _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM) +#define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST (alignment, M, X, RANDOM, RANDOM) +#define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST (format, M, X, FLOAT, FLOAT) +#define ADJUST_IBIT(M, X) _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM) +#define ADJUST_FBIT(M, X) _ADD_ADJUST (fbit, M, X, FRACT, UACCUM) static void create_modes (void) diff --git a/gcc/genopinit.c b/gcc/genopinit.c index fb8071765dd..9c7cf2c06a4 100644 --- a/gcc/genopinit.c +++ b/gcc/genopinit.c @@ -194,7 +194,7 @@ match_pattern (pattern *p, const char *name, const char *pat) for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--) { const char *p, *q; - for (p = GET_MODE_NAME(i), q = name; *p; p++, q++) + for (p = GET_MODE_NAME (i), q = name; *p; p++, q++) if (TOLOWER (*p) != *q) break; if (*p == 0 @@ -372,7 +372,7 @@ main (int argc, char **argv) /* Sort the (real) optabs. Better than forcing the optabs.def file to remain sorted by kind. We also scrogged any real ordering with the purging of the X patterns above. */ - qsort (optabs, n, sizeof(optab_def), optab_kind_cmp); + qsort (optabs, n, sizeof (optab_def), optab_kind_cmp); /* Emit the optab enumeration for the header file. */ fprintf (h_file, "enum optab_tag {\n"); diff --git a/gcc/genoutput.c b/gcc/genoutput.c index 59afaa452aa..c3a0936fc97 100644 --- a/gcc/genoutput.c +++ b/gcc/genoutput.c @@ -286,9 +286,9 @@ output_operand_data (void) pred = lookup_predicate (d->predicate); printf (" %d\n", pred && pred->codes[MEM]); - printf(" },\n"); + printf (" },\n"); } - printf("};\n\n\n"); + printf ("};\n\n\n"); } static void @@ -415,7 +415,7 @@ output_insn_data (void) printf (" %d,\n", d->n_alternatives); printf (" %d\n", d->output_format); - printf(" },\n"); + printf (" },\n"); } printf ("};\n\n\n"); } @@ -1112,7 +1112,7 @@ main (int argc, char **argv) next_index_number++; } - printf("\n\n"); + printf ("\n\n"); output_operand_data (); output_insn_data (); output_get_insn_name (); @@ -1223,7 +1223,7 @@ note_constraint (rtx exp, int lineno) } } new_cdata = XNEWVAR (struct constraint_data, sizeof (struct constraint_data) + namelen); - strcpy (CONST_CAST(char *, new_cdata->name), name); + strcpy (CONST_CAST (char *, new_cdata->name), name); new_cdata->namelen = namelen; new_cdata->lineno = lineno; new_cdata->next_this_letter = *slot; diff --git a/gcc/genpeep.c b/gcc/genpeep.c index 81bd9df64bb..a14d061a50b 100644 --- a/gcc/genpeep.c +++ b/gcc/genpeep.c @@ -334,7 +334,7 @@ print_code (RTX_CODE code) { const char *p1; for (p1 = GET_RTX_NAME (code); *p1; p1++) - putchar (TOUPPER(*p1)); + putchar (TOUPPER (*p1)); } extern int main (int, char **); diff --git a/gcc/genpreds.c b/gcc/genpreds.c index 98488e30b8b..f3d9dac9c55 100644 --- a/gcc/genpreds.c +++ b/gcc/genpreds.c @@ -529,7 +529,7 @@ write_match_code_switch (rtx exp) putchar (TOUPPER (*code)); code++; } - fputs(":\n", stdout); + fputs (":\n", stdout); } } @@ -596,9 +596,9 @@ write_predicate_stmts (rtx exp) break; } - fputs(" return ",stdout); + fputs (" return ",stdout); write_predicate_expr (exp); - fputs(";\n", stdout); + fputs (";\n", stdout); } /* Given a predicate, write out a complete C function to compute it. */ @@ -932,7 +932,7 @@ write_lookup_constraint (void) " switch (str[0])\n" " {"); - for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++) + for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++) { struct constraint_data *c = constraints_by_letter_table[i]; if (!c) @@ -975,7 +975,7 @@ write_insn_constraint_len (void) " switch (fc)\n" " {"); - for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++) + for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++) { struct constraint_data *c = constraints_by_letter_table[i]; diff --git a/gcc/genrecog.c b/gcc/genrecog.c index 691b0281175..814be7d17e3 100644 --- a/gcc/genrecog.c +++ b/gcc/genrecog.c @@ -58,7 +58,7 @@ #include "gensupport.h" #define OUTPUT_LABEL(INDENT_STRING, LABEL_NUMBER) \ - printf("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER)) + printf ("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER)) /* Ways of obtaining an rtx to be tested. */ enum position_type { @@ -1619,7 +1619,7 @@ write_afterward (struct decision *start, struct decision *afterward, const char *indent) { if (!afterward || start->subroutine_number > 0) - printf("%sgoto ret0;\n", indent); + printf ("%sgoto ret0;\n", indent); else { change_state (start->position, afterward->position, indent); @@ -1669,7 +1669,7 @@ write_switch (struct decision *start, int depth) struct decision *ret; RTX_CODE code; - memset (codemap, 0, sizeof(codemap)); + memset (codemap, 0, sizeof (codemap)); printf (" switch (GET_CODE (x%d))\n {\n", depth); code = p->tests->u.code; @@ -1762,7 +1762,8 @@ write_switch (struct decision *start, int depth) if (type == DT_elt_zero_wide_safe) { indent = " "; - printf(" if ((int) XWINT (x%d, 0) == XWINT (x%d, 0))\n", depth, depth); + printf (" if ((int) XWINT (x%d, 0) == XWINT (x%d, 0))\n", + depth, depth); } printf ("%s switch (", indent); switch (type) @@ -1937,7 +1938,7 @@ write_action (struct decision *p, struct decision_test *test, if (test->type == DT_accept_op) { - printf("%soperands[%d] = x%d;\n", indent, test->u.opno, depth); + printf ("%soperands[%d] = x%d;\n", indent, test->u.opno, depth); /* Only allow DT_accept_insn to follow. */ if (test->next) @@ -1992,7 +1993,7 @@ write_action (struct decision *p, struct decision_test *test, } else { - printf("%sgoto L%d;\n", indent, success->number); + printf ("%sgoto L%d;\n", indent, success->number); success->need_label = 1; } @@ -2357,7 +2358,7 @@ make_insn_sequence (rtx insn, enum routine_type type) validate_pattern (x, insn, NULL_RTX, 0); - memset(&head, 0, sizeof(head)); + memset (&head, 0, sizeof (head)); last = add_to_sequence (x, &head, &root_pos, type, 1); /* Find the end of the test chain on the last node. */ @@ -2423,7 +2424,7 @@ make_insn_sequence (rtx insn, enum routine_type type) } /* Recognize it. */ - memset (&clobber_head, 0, sizeof(clobber_head)); + memset (&clobber_head, 0, sizeof (clobber_head)); last = add_to_sequence (new_rtx, &clobber_head, &root_pos, type, 1); @@ -2493,7 +2494,7 @@ process_tree (struct decision_head *head, enum routine_type subroutine_type) /* We run this after find_afterward, because find_afterward needs the redundant DT_mode tests on predicates to determine whether two tests can both be true or not. */ - simplify_tests(head); + simplify_tests (head); write_subroutines (head, subroutine_type); } @@ -2601,12 +2602,12 @@ debug_decision_2 (struct decision_test *test) break; case DT_pred: fprintf (stderr, "pred=(%s,%s)", - test->u.pred.name, GET_MODE_NAME(test->u.pred.mode)); + test->u.pred.name, GET_MODE_NAME (test->u.pred.mode)); break; case DT_c_test: { char sub[16+4]; - strncpy (sub, test->u.c_test, sizeof(sub)); + strncpy (sub, test->u.c_test, sizeof (sub)); memcpy (sub+16, "...", 4); fprintf (stderr, "c_test=\"%s\"", sub); } diff --git a/gcc/gensupport.c b/gcc/gensupport.c index c7a27c42617..28165e37137 100644 --- a/gcc/gensupport.c +++ b/gcc/gensupport.c @@ -392,7 +392,7 @@ static struct queue_elem * queue_pattern (rtx pattern, struct queue_elem ***list_tail, const char *filename, int lineno) { - struct queue_elem *e = XNEW(struct queue_elem); + struct queue_elem *e = XNEW (struct queue_elem); e->data = pattern; e->filename = filename; e->lineno = lineno; @@ -429,7 +429,7 @@ remove_from_queue (struct queue_elem *elem, struct queue_elem **queue) static void add_define_attr (const char *name) { - struct queue_elem *e = XNEW(struct queue_elem); + struct queue_elem *e = XNEW (struct queue_elem); rtx t1 = rtx_alloc (DEFINE_ATTR); XSTR (t1, 0) = name; XSTR (t1, 1) = "no,yes"; @@ -2870,7 +2870,7 @@ record_insn_name (int code, const char *name) new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512); insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size); memset (insn_name_ptr + insn_name_ptr_size, 0, - sizeof(char *) * (new_size - insn_name_ptr_size)); + sizeof (char *) * (new_size - insn_name_ptr_size)); insn_name_ptr_size = new_size; } diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c index 0bb2eb19f23..dcabd61433d 100644 --- a/gcc/ggc-common.c +++ b/gcc/ggc-common.c @@ -488,7 +488,7 @@ gt_pch_save (FILE *f) char *this_object = NULL; size_t this_object_size = 0; struct mmap_info mmi; - const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity(); + const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity (); gt_pch_save_stringpool (); @@ -749,7 +749,7 @@ default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED, size_t default_gt_pch_alloc_granularity (void) { - return getpagesize(); + return getpagesize (); } #if HAVE_MMAP_FILE @@ -837,7 +837,7 @@ ggc_rlimit_bound (double limit) static int ggc_min_expand_heuristic (void) { - double min_expand = physmem_total(); + double min_expand = physmem_total (); /* Adjust for rlimits. */ min_expand = ggc_rlimit_bound (min_expand); @@ -856,7 +856,7 @@ ggc_min_expand_heuristic (void) static int ggc_min_heapsize_heuristic (void) { - double phys_kbytes = physmem_total(); + double phys_kbytes = physmem_total (); double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2); phys_kbytes /= 1024; /* Convert to Kbytes. */ diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c index 487a6d45c78..249aa010507 100644 --- a/gcc/ggc-page.c +++ b/gcc/ggc-page.c @@ -462,7 +462,7 @@ static struct globals /* The size in bytes required to maintain a bitmap for the objects on a page-entry. */ #define BITMAP_SIZE(Num_objects) \ - (CEIL ((Num_objects), HOST_BITS_PER_LONG) * sizeof(long)) + (CEIL ((Num_objects), HOST_BITS_PER_LONG) * sizeof (long)) /* Allocate pages in chunks of this size, to throttle calls to memory allocation routines. The first page is used, the rest go onto the @@ -785,7 +785,7 @@ alloc_page (unsigned order) page = alloc_anon (NULL, G.pagesize * GGC_QUIRE_SIZE, false); if (page == NULL) { - page = alloc_anon(NULL, G.pagesize, true); + page = alloc_anon (NULL, G.pagesize, true); entries = 1; } @@ -1644,7 +1644,7 @@ init_ggc (void) { unsigned order; - G.pagesize = getpagesize(); + G.pagesize = getpagesize (); G.lg_pagesize = exact_log2 (G.pagesize); #ifdef HAVE_MMAP_DEV_ZERO @@ -2163,7 +2163,7 @@ ggc_print_statistics (void) } fprintf (stderr, "%-5s %10lu%c %10lu%c %10lu%c\n", "Total", SCALE (G.bytes_mapped), STAT_LABEL (G.bytes_mapped), - SCALE (G.allocated), STAT_LABEL(G.allocated), + SCALE (G.allocated), STAT_LABEL (G.allocated), SCALE (total_overhead), STAT_LABEL (total_overhead)); if (GATHER_STATISTICS) @@ -2315,13 +2315,13 @@ ggc_pch_write_object (struct ggc_pch_data *d, if (size != OBJECT_SIZE (order)) { - unsigned padding = OBJECT_SIZE(order) - size; + unsigned padding = OBJECT_SIZE (order) - size; /* To speed small writes, we use a nulled-out array that's larger than most padding requests as the source for our null bytes. This permits us to do the padding with fwrite() rather than fseek(), and limits the chance the OS may try to flush any outstanding writes. */ - if (padding <= sizeof(emptyBytes)) + if (padding <= sizeof (emptyBytes)) { if (fwrite (emptyBytes, 1, padding, f) != padding) fatal_error ("can%'t write PCH file"); @@ -2419,7 +2419,7 @@ ggc_pch_read (FILE *f, void *addr) #endif /* Since we free all the allocated objects, the free list becomes useless. Validate it now, which will also clear it. */ - validate_free_objects(); + validate_free_objects (); /* No object read from a PCH file should ever be freed. So, set the context depth to 1, and set the depth of all the currently-allocated diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index c77d00bca01..dd2aed73e77 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -2825,7 +2825,7 @@ fold_array_ctor_reference (tree type, tree ctor, else low_bound = double_int_zero; /* Static constructors for variably sized objects makes no sense. */ - gcc_assert (TREE_CODE(TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))) + gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))) == INTEGER_CST); elt_size = tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))); diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c index a46a69f56ed..cf6bac2b35e 100644 --- a/gcc/gimple-low.c +++ b/gcc/gimple-low.c @@ -118,7 +118,8 @@ lower_function_body (void) need to do anything special. Otherwise build one by hand. */ if (gimple_seq_may_fallthru (lowered_body) && (data.return_statements.is_empty () - || gimple_return_retval (data.return_statements.last().stmt) != NULL)) + || (gimple_return_retval (data.return_statements.last().stmt) + != NULL))) { x = gimple_build_return (NULL); gimple_set_location (x, cfun->function_end_locus); @@ -197,8 +198,8 @@ const pass_data pass_data_lower_cf = class pass_lower_cf : public gimple_opt_pass { public: - pass_lower_cf(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_cf, ctxt) + pass_lower_cf (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_cf, ctxt) {} /* opt_pass methods: */ @@ -707,7 +708,7 @@ block_may_fallthru (const_tree block) { /* This CONST_CAST is okay because expr_last returns its argument unmodified and we assign it to a const_tree. */ - const_tree stmt = expr_last (CONST_CAST_TREE(block)); + const_tree stmt = expr_last (CONST_CAST_TREE (block)); switch (stmt ? TREE_CODE (stmt) : ERROR_MARK) { diff --git a/gcc/gimple-pretty-print.c b/gcc/gimple-pretty-print.c index 1599c804e7a..1e985e0dbd7 100644 --- a/gcc/gimple-pretty-print.c +++ b/gcc/gimple-pretty-print.c @@ -524,7 +524,7 @@ dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags) else gcc_unreachable (); if (!(flags & TDF_RHS_ONLY)) - pp_semicolon(buffer); + pp_semicolon (buffer); } } @@ -2285,7 +2285,7 @@ gimple_dump_bb_buff (pretty_printer *buffer, basic_block bb, int indent, pp_newline_and_flush (buffer); gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl)); dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl), - pp_buffer(buffer)->stream, stmt); + pp_buffer (buffer)->stream, stmt); } dump_implicit_edges (buffer, bb, indent, flags); diff --git a/gcc/gimple-ssa-strength-reduction.c b/gcc/gimple-ssa-strength-reduction.c index 8d48adde01d..139a4a16472 100644 --- a/gcc/gimple-ssa-strength-reduction.c +++ b/gcc/gimple-ssa-strength-reduction.c @@ -3564,8 +3564,8 @@ const pass_data pass_data_strength_reduction = class pass_strength_reduction : public gimple_opt_pass { public: - pass_strength_reduction(gcc::context *ctxt) - : gimple_opt_pass(pass_data_strength_reduction, ctxt) + pass_strength_reduction (gcc::context *ctxt) + : gimple_opt_pass (pass_data_strength_reduction, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/gimple.c b/gcc/gimple.c index 6a182700cfd..e12f7d92c2e 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -54,7 +54,7 @@ EXPORTED_CONST size_t gimple_ops_offset_[] = { }; #undef DEFGSSTRUCT -#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof(struct STRUCT), +#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT), static const size_t gsstruct_code_size[] = { #include "gsstruct.def" }; @@ -2153,7 +2153,7 @@ gimple_set_lhs (gimple stmt, tree lhs) else if (code == GIMPLE_CALL) gimple_call_set_lhs (stmt, lhs); else - gcc_unreachable(); + gcc_unreachable (); } diff --git a/gcc/gimple.h b/gcc/gimple.h index a031c8d777c..376fda2c6f2 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -5037,7 +5037,7 @@ gsi_start_1 (gimple_seq *seq) return i; } -#define gsi_start(x) gsi_start_1(&(x)) +#define gsi_start(x) gsi_start_1 (&(x)) static inline gimple_stmt_iterator gsi_none (void) @@ -5080,7 +5080,7 @@ gsi_last_1 (gimple_seq *seq) return i; } -#define gsi_last(x) gsi_last_1(&(x)) +#define gsi_last(x) gsi_last_1 (&(x)) /* Return a new iterator pointing to the last statement in basic block BB. */ diff --git a/gcc/godump.c b/gcc/godump.c index 81efa2877cb..0303e4f0628 100644 --- a/gcc/godump.c +++ b/gcc/godump.c @@ -1213,7 +1213,7 @@ go_finish (const char *filename) break; default: - gcc_unreachable(); + gcc_unreachable (); } } diff --git a/gcc/graphite-clast-to-gimple.c b/gcc/graphite-clast-to-gimple.c index d40164c6774..d0e23021f5d 100644 --- a/gcc/graphite-clast-to-gimple.c +++ b/gcc/graphite-clast-to-gimple.c @@ -1306,7 +1306,7 @@ translate_clast (loop_p context_loop, struct clast_stmt *stmt, edge next_e, next_e = translate_clast_assignment ((struct clast_assignment *) stmt, next_e, level, ip); else - gcc_unreachable(); + gcc_unreachable (); recompute_all_dominators (); graphite_verify (); @@ -1409,7 +1409,7 @@ init_cloog_input_file (int scop_number) /* Extend the scattering to NEW_DIMS scattering dimensions. */ static -isl_map *extend_scattering(isl_map *scattering, int new_dims) +isl_map *extend_scattering (isl_map *scattering, int new_dims) { int old_dims, i; isl_space *space; @@ -1462,12 +1462,13 @@ build_cloog_union_domain (scop_p scop, int nb_scattering_dims) /* Dead code elimination: when the domain of a PBB is empty, don't generate code for the PBB. */ - if (isl_set_is_empty(pbb->domain)) + if (isl_set_is_empty (pbb->domain)) continue; - domain = cloog_domain_from_isl_set(isl_set_copy(pbb->domain)); - scattering = cloog_scattering_from_isl_map(extend_scattering(isl_map_copy(pbb->transformed), - nb_scattering_dims)); + domain = cloog_domain_from_isl_set (isl_set_copy (pbb->domain)); + scattering = cloog_scattering_from_isl_map + (extend_scattering (isl_map_copy (pbb->transformed), + nb_scattering_dims)); union_domain = cloog_union_domain_add_domain (union_domain, "", domain, scattering, pbb); diff --git a/gcc/graphite-optimize-isl.c b/gcc/graphite-optimize-isl.c index f47e21a5023..b9b21566fb5 100644 --- a/gcc/graphite-optimize-isl.c +++ b/gcc/graphite-optimize-isl.c @@ -114,7 +114,7 @@ scop_get_dependences (scop_p scop) */ static isl_basic_map * -getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize) +getTileMap (isl_ctx *ctx, int scheduleDimensions, int tileSize) { int x; /* We construct @@ -124,11 +124,11 @@ getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize) s1 = a1 * 32 and s1 = p1 and t1 <= p1 < t1 + 32} and project out the auxilary dimensions a0 and a1. */ - isl_space *Space = isl_space_alloc(ctx, 0, scheduleDimensions, - scheduleDimensions * 3); - isl_basic_map *tileMap = isl_basic_map_universe(isl_space_copy(Space)); + isl_space *Space = isl_space_alloc (ctx, 0, scheduleDimensions, + scheduleDimensions * 3); + isl_basic_map *tileMap = isl_basic_map_universe (isl_space_copy (Space)); - isl_local_space *LocalSpace = isl_local_space_from_space(Space); + isl_local_space *LocalSpace = isl_local_space_from_space (Space); for (x = 0; x < scheduleDimensions; x++) { @@ -140,29 +140,29 @@ getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize) isl_constraint *c; /* sX = aX * tileSize; */ - c = isl_equality_alloc(isl_local_space_copy(LocalSpace)); - isl_constraint_set_coefficient_si(c, isl_dim_out, sX, 1); - isl_constraint_set_coefficient_si(c, isl_dim_out, aX, -tileSize); - tileMap = isl_basic_map_add_constraint(tileMap, c); + c = isl_equality_alloc (isl_local_space_copy (LocalSpace)); + isl_constraint_set_coefficient_si (c, isl_dim_out, sX, 1); + isl_constraint_set_coefficient_si (c, isl_dim_out, aX, -tileSize); + tileMap = isl_basic_map_add_constraint (tileMap, c); /* pX = sX; */ - c = isl_equality_alloc(isl_local_space_copy(LocalSpace)); - isl_constraint_set_coefficient_si(c, isl_dim_out, pX, 1); - isl_constraint_set_coefficient_si(c, isl_dim_in, sX, -1); - tileMap = isl_basic_map_add_constraint(tileMap, c); + c = isl_equality_alloc (isl_local_space_copy (LocalSpace)); + isl_constraint_set_coefficient_si (c, isl_dim_out, pX, 1); + isl_constraint_set_coefficient_si (c, isl_dim_in, sX, -1); + tileMap = isl_basic_map_add_constraint (tileMap, c); /* tX <= pX */ - c = isl_inequality_alloc(isl_local_space_copy(LocalSpace)); - isl_constraint_set_coefficient_si(c, isl_dim_out, pX, 1); - isl_constraint_set_coefficient_si(c, isl_dim_out, tX, -1); - tileMap = isl_basic_map_add_constraint(tileMap, c); + c = isl_inequality_alloc (isl_local_space_copy (LocalSpace)); + isl_constraint_set_coefficient_si (c, isl_dim_out, pX, 1); + isl_constraint_set_coefficient_si (c, isl_dim_out, tX, -1); + tileMap = isl_basic_map_add_constraint (tileMap, c); /* pX <= tX + (tileSize - 1) */ - c = isl_inequality_alloc(isl_local_space_copy(LocalSpace)); - isl_constraint_set_coefficient_si(c, isl_dim_out, tX, 1); - isl_constraint_set_coefficient_si(c, isl_dim_out, pX, -1); - isl_constraint_set_constant_si(c, tileSize - 1); - tileMap = isl_basic_map_add_constraint(tileMap, c); + c = isl_inequality_alloc (isl_local_space_copy (LocalSpace)); + isl_constraint_set_coefficient_si (c, isl_dim_out, tX, 1); + isl_constraint_set_coefficient_si (c, isl_dim_out, pX, -1); + isl_constraint_set_constant_si (c, tileSize - 1); + tileMap = isl_basic_map_add_constraint (tileMap, c); } /* Project out auxiliary dimensions. @@ -170,10 +170,10 @@ getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize) The auxiliary dimensions are transformed into existentially quantified ones. This reduces the number of visible scattering dimensions and allows Cloog to produces better code. */ - tileMap = isl_basic_map_project_out(tileMap, isl_dim_out, - 2 * scheduleDimensions, - scheduleDimensions); - isl_local_space_free(LocalSpace); + tileMap = isl_basic_map_project_out (tileMap, isl_dim_out, + 2 * scheduleDimensions, + scheduleDimensions); + isl_local_space_free (LocalSpace); return tileMap; } @@ -185,7 +185,7 @@ getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize) static bool DisableTiling = false; static isl_union_map * -getScheduleForBand(isl_band *Band, int *Dimensions) +getScheduleForBand (isl_band *Band, int *Dimensions) { isl_union_map *PartialSchedule; isl_ctx *ctx; @@ -193,8 +193,8 @@ getScheduleForBand(isl_band *Band, int *Dimensions) isl_basic_map *TileMap; isl_union_map *TileUMap; - PartialSchedule = isl_band_get_partial_schedule(Band); - *Dimensions = isl_band_n_member(Band); + PartialSchedule = isl_band_get_partial_schedule (Band); + *Dimensions = isl_band_n_member (Band); if (DisableTiling) return PartialSchedule; @@ -203,15 +203,15 @@ getScheduleForBand(isl_band *Band, int *Dimensions) if (*Dimensions == 1) return PartialSchedule; - ctx = isl_union_map_get_ctx(PartialSchedule); - Space = isl_union_map_get_space(PartialSchedule); + ctx = isl_union_map_get_ctx (PartialSchedule); + Space = isl_union_map_get_space (PartialSchedule); - TileMap = getTileMap(ctx, *Dimensions, 32); - TileUMap = isl_union_map_from_map(isl_map_from_basic_map(TileMap)); - TileUMap = isl_union_map_align_params(TileUMap, Space); + TileMap = getTileMap (ctx, *Dimensions, 32); + TileUMap = isl_union_map_from_map (isl_map_from_basic_map (TileMap)); + TileUMap = isl_union_map_align_params (TileUMap, Space); *Dimensions = 2 * *Dimensions; - return isl_union_map_apply_range(PartialSchedule, TileUMap); + return isl_union_map_apply_range (PartialSchedule, TileUMap); } /* Create a map that pre-vectorizes one scheduling dimension. @@ -253,9 +253,9 @@ getScheduleForBand(isl_band *Band, int *Dimensions) currently constant and not yet target specific. This function does not reason about parallelism. */ static isl_map * -getPrevectorMap(isl_ctx *ctx, int DimToVectorize, - int ScheduleDimensions, - int VectorWidth) +getPrevectorMap (isl_ctx *ctx, int DimToVectorize, + int ScheduleDimensions, + int VectorWidth) { isl_space *Space; isl_local_space *LocalSpace, *LocalSpaceRange; @@ -270,9 +270,9 @@ getPrevectorMap(isl_ctx *ctx, int DimToVectorize, /* assert (0 <= DimToVectorize && DimToVectorize < ScheduleDimensions);*/ - Space = isl_space_alloc(ctx, 0, ScheduleDimensions, ScheduleDimensions + 1); - TilingMap = isl_map_universe(isl_space_copy(Space)); - LocalSpace = isl_local_space_from_space(Space); + Space = isl_space_alloc (ctx, 0, ScheduleDimensions, ScheduleDimensions + 1); + TilingMap = isl_map_universe (isl_space_copy (Space)); + LocalSpace = isl_local_space_from_space (Space); PointDimension = ScheduleDimensions; TileDimension = DimToVectorize; @@ -280,43 +280,43 @@ getPrevectorMap(isl_ctx *ctx, int DimToVectorize, DimToVectorize to the point loop at the innermost dimension. */ for (i = 0; i < ScheduleDimensions; i++) { - c = isl_equality_alloc(isl_local_space_copy(LocalSpace)); - isl_constraint_set_coefficient_si(c, isl_dim_in, i, -1); + c = isl_equality_alloc (isl_local_space_copy (LocalSpace)); + isl_constraint_set_coefficient_si (c, isl_dim_in, i, -1); if (i == DimToVectorize) - isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, 1); + isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, 1); else - isl_constraint_set_coefficient_si(c, isl_dim_out, i, 1); + isl_constraint_set_coefficient_si (c, isl_dim_out, i, 1); - TilingMap = isl_map_add_constraint(TilingMap, c); + TilingMap = isl_map_add_constraint (TilingMap, c); } /* it % 'VectorWidth' = 0 */ - LocalSpaceRange = isl_local_space_range(isl_local_space_copy(LocalSpace)); - Aff = isl_aff_zero_on_domain(LocalSpaceRange); - Aff = isl_aff_set_constant_si(Aff, VectorWidth); - Aff = isl_aff_set_coefficient_si(Aff, isl_dim_in, TileDimension, 1); - isl_int_init(VectorWidthMP); - isl_int_set_si(VectorWidthMP, VectorWidth); - Aff = isl_aff_mod(Aff, VectorWidthMP); - isl_int_clear(VectorWidthMP); - Modulo = isl_pw_aff_zero_set(isl_pw_aff_from_aff(Aff)); - TilingMap = isl_map_intersect_range(TilingMap, Modulo); + LocalSpaceRange = isl_local_space_range (isl_local_space_copy (LocalSpace)); + Aff = isl_aff_zero_on_domain (LocalSpaceRange); + Aff = isl_aff_set_constant_si (Aff, VectorWidth); + Aff = isl_aff_set_coefficient_si (Aff, isl_dim_in, TileDimension, 1); + isl_int_init (VectorWidthMP); + isl_int_set_si (VectorWidthMP, VectorWidth); + Aff = isl_aff_mod (Aff, VectorWidthMP); + isl_int_clear (VectorWidthMP); + Modulo = isl_pw_aff_zero_set (isl_pw_aff_from_aff (Aff)); + TilingMap = isl_map_intersect_range (TilingMap, Modulo); /* it <= ip */ - c = isl_inequality_alloc(isl_local_space_copy(LocalSpace)); - isl_constraint_set_coefficient_si(c, isl_dim_out, TileDimension, -1); - isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, 1); - TilingMap = isl_map_add_constraint(TilingMap, c); + c = isl_inequality_alloc (isl_local_space_copy (LocalSpace)); + isl_constraint_set_coefficient_si (c, isl_dim_out, TileDimension, -1); + isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, 1); + TilingMap = isl_map_add_constraint (TilingMap, c); /* ip <= it + ('VectorWidth' - 1) */ - c = isl_inequality_alloc(LocalSpace); - isl_constraint_set_coefficient_si(c, isl_dim_out, TileDimension, 1); - isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, -1); - isl_constraint_set_constant_si(c, VectorWidth - 1); - TilingMap = isl_map_add_constraint(TilingMap, c); + c = isl_inequality_alloc (LocalSpace); + isl_constraint_set_coefficient_si (c, isl_dim_out, TileDimension, 1); + isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, -1); + isl_constraint_set_constant_si (c, VectorWidth - 1); + TilingMap = isl_map_add_constraint (TilingMap, c); - isl_map_dump(TilingMap); + isl_map_dump (TilingMap); return TilingMap; } @@ -329,15 +329,15 @@ static bool EnablePollyVector = false; individual bands to the overall schedule. In case tiling is requested, the individual bands are tiled. */ static isl_union_map * -getScheduleForBandList(isl_band_list *BandList) +getScheduleForBandList (isl_band_list *BandList) { int NumBands, i; isl_union_map *Schedule; isl_ctx *ctx; - ctx = isl_band_list_get_ctx(BandList); - NumBands = isl_band_list_n_band(BandList); - Schedule = isl_union_map_empty(isl_space_params_alloc(ctx, 0)); + ctx = isl_band_list_get_ctx (BandList); + NumBands = isl_band_list_n_band (BandList); + Schedule = isl_union_map_empty (isl_space_params_alloc (ctx, 0)); for (i = 0; i < NumBands; i++) { @@ -346,61 +346,61 @@ getScheduleForBandList(isl_band_list *BandList) int ScheduleDimensions; isl_space *Space; - Band = isl_band_list_get_band(BandList, i); - PartialSchedule = getScheduleForBand(Band, &ScheduleDimensions); - Space = isl_union_map_get_space(PartialSchedule); + Band = isl_band_list_get_band (BandList, i); + PartialSchedule = getScheduleForBand (Band, &ScheduleDimensions); + Space = isl_union_map_get_space (PartialSchedule); - if (isl_band_has_children(Band)) + if (isl_band_has_children (Band)) { isl_band_list *Children; isl_union_map *SuffixSchedule; - Children = isl_band_get_children(Band); - SuffixSchedule = getScheduleForBandList(Children); - PartialSchedule = isl_union_map_flat_range_product(PartialSchedule, - SuffixSchedule); - isl_band_list_free(Children); + Children = isl_band_get_children (Band); + SuffixSchedule = getScheduleForBandList (Children); + PartialSchedule = isl_union_map_flat_range_product (PartialSchedule, + SuffixSchedule); + isl_band_list_free (Children); } else if (EnablePollyVector) { for (i = ScheduleDimensions - 1 ; i >= 0 ; i--) { - if (isl_band_member_is_zero_distance(Band, i)) + if (isl_band_member_is_zero_distance (Band, i)) { isl_map *TileMap; isl_union_map *TileUMap; - TileMap = getPrevectorMap(ctx, i, ScheduleDimensions, 4); - TileUMap = isl_union_map_from_map(TileMap); - TileUMap = isl_union_map_align_params(TileUMap, - isl_space_copy(Space)); - PartialSchedule = isl_union_map_apply_range(PartialSchedule, - TileUMap); + TileMap = getPrevectorMap (ctx, i, ScheduleDimensions, 4); + TileUMap = isl_union_map_from_map (TileMap); + TileUMap = isl_union_map_align_params + (TileUMap, isl_space_copy (Space)); + PartialSchedule = isl_union_map_apply_range + (PartialSchedule, TileUMap); break; } } } - Schedule = isl_union_map_union(Schedule, PartialSchedule); + Schedule = isl_union_map_union (Schedule, PartialSchedule); - isl_band_free(Band); - isl_space_free(Space); + isl_band_free (Band); + isl_space_free (Space); } return Schedule; } static isl_union_map * -getScheduleMap(isl_schedule *Schedule) +getScheduleMap (isl_schedule *Schedule) { - isl_band_list *BandList = isl_schedule_get_band_forest(Schedule); - isl_union_map *ScheduleMap = getScheduleForBandList(BandList); - isl_band_list_free(BandList); + isl_band_list *BandList = isl_schedule_get_band_forest (Schedule); + isl_union_map *ScheduleMap = getScheduleForBandList (BandList); + isl_band_list_free (BandList); return ScheduleMap; } static int -getSingleMap(__isl_take isl_map *map, void *user) +getSingleMap (__isl_take isl_map *map, void *user) { isl_map **singleMap = (isl_map **) user; *singleMap = map; @@ -420,12 +420,13 @@ apply_schedule_map_to_scop (scop_p scop, isl_union_map *schedule_map) isl_union_map *stmtBand; isl_map *stmtSchedule; - stmtBand = isl_union_map_intersect_domain(isl_union_map_copy(schedule_map), - isl_union_set_from_set(domain)); - isl_union_map_foreach_map(stmtBand, getSingleMap, &stmtSchedule); - isl_map_free(pbb->transformed); + stmtBand = isl_union_map_intersect_domain + (isl_union_map_copy (schedule_map), + isl_union_set_from_set (domain)); + isl_union_map_foreach_map (stmtBand, getSingleMap, &stmtSchedule); + isl_map_free (pbb->transformed); pbb->transformed = stmtSchedule; - isl_union_map_free(stmtBand); + isl_union_map_free (stmtBand); } } @@ -442,20 +443,20 @@ optimize_isl (scop_p scop) domain = scop_get_domains (scop); dependences = scop_get_dependences (scop); - dependences = isl_union_map_gist_domain(dependences, - isl_union_set_copy(domain)); - dependences = isl_union_map_gist_range(dependences, - isl_union_set_copy(domain)); + dependences = isl_union_map_gist_domain (dependences, + isl_union_set_copy (domain)); + dependences = isl_union_map_gist_range (dependences, + isl_union_set_copy (domain)); validity = dependences; proximity = isl_union_map_copy (validity); - isl_options_set_schedule_max_constant_term(scop->ctx, CONSTANT_BOUND); - isl_options_set_schedule_maximize_band_depth(scop->ctx, 1); - isl_options_set_schedule_fuse(scop->ctx, ISL_SCHEDULE_FUSE_MIN); - isl_options_set_on_error(scop->ctx, ISL_ON_ERROR_CONTINUE); + isl_options_set_schedule_max_constant_term (scop->ctx, CONSTANT_BOUND); + isl_options_set_schedule_maximize_band_depth (scop->ctx, 1); + isl_options_set_schedule_fuse (scop->ctx, ISL_SCHEDULE_FUSE_MIN); + isl_options_set_on_error (scop->ctx, ISL_ON_ERROR_CONTINUE); schedule = isl_union_set_compute_schedule (domain, validity, proximity); - isl_options_set_on_error(scop->ctx, ISL_ON_ERROR_ABORT); + isl_options_set_on_error (scop->ctx, ISL_ON_ERROR_ABORT); if (!schedule) return false; diff --git a/gcc/graphite-poly.h b/gcc/graphite-poly.h index 52d6b1cdc53..9720f3f60f5 100644 --- a/gcc/graphite-poly.h +++ b/gcc/graphite-poly.h @@ -403,7 +403,7 @@ extern int scop_do_interchange (scop_p); extern int scop_do_strip_mine (scop_p, int); extern bool scop_do_block (scop_p); extern bool flatten_all_loops (scop_p); -extern bool optimize_isl(scop_p); +extern bool optimize_isl (scop_p); extern void pbb_number_of_iterations_at_time (poly_bb_p, graphite_dim_t, mpz_t); extern void debug_gmp_value (mpz_t); diff --git a/gcc/graphite-sese-to-poly.c b/gcc/graphite-sese-to-poly.c index 49856914782..3949098f83c 100644 --- a/gcc/graphite-sese-to-poly.c +++ b/gcc/graphite-sese-to-poly.c @@ -665,7 +665,7 @@ extract_affine_name (scop_p s, tree e, __isl_take isl_space *space) id = isl_id_for_ssa_name (s, e); dimension = isl_space_find_dim_by_id (space, isl_dim_param, id); - isl_id_free(id); + isl_id_free (id); dom = isl_set_universe (isl_space_copy (space)); aff = isl_aff_zero_on_domain (isl_local_space_from_space (space)); aff = isl_aff_add_coefficient_si (aff, isl_dim_param, dimension, 1); @@ -994,7 +994,7 @@ build_loop_iteration_domains (scop_p scop, struct loop *loop, if (TREE_CODE (nb_iters) == INTEGER_CST) { c = isl_inequality_alloc - (isl_local_space_from_space(isl_space_copy (space))); + (isl_local_space_from_space (isl_space_copy (space))); c = isl_constraint_set_coefficient_si (c, isl_dim_set, pos, -1); tree_int_to_gmp (nb_iters, g); isl_int_set_gmp (v, g); @@ -1132,8 +1132,8 @@ add_condition_to_pbb (poly_bb_p pbb, gimple stmt, enum tree_code code) break; default: - isl_pw_aff_free(lhs); - isl_pw_aff_free(rhs); + isl_pw_aff_free (lhs); + isl_pw_aff_free (rhs); return; } diff --git a/gcc/graphite.c b/gcc/graphite.c index 2cea3894da8..cbd0b5a1568 100644 --- a/gcc/graphite.c +++ b/gcc/graphite.c @@ -265,7 +265,7 @@ graphite_transform_loops (void) return; ctx = isl_ctx_alloc (); - isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT); + isl_options_set_on_error (ctx, ISL_ON_ERROR_ABORT); if (!graphite_initialize (ctx)) return; diff --git a/gcc/haifa-sched.c b/gcc/haifa-sched.c index 61eaaefa418..aab5748f67b 100644 --- a/gcc/haifa-sched.c +++ b/gcc/haifa-sched.c @@ -2605,7 +2605,7 @@ rank_for_schedule (const void *x, const void *y) } info_val = (*current_sched_info->rank) (tmp, tmp2); - if(flag_sched_rank_heuristic && info_val) + if (flag_sched_rank_heuristic && info_val) return info_val; /* Compare insns based on their relation to the last scheduled @@ -7879,7 +7879,7 @@ create_check_block_twin (rtx insn, bool mutate_p) /* Fix priorities. If MUTATE_P is nonzero, this is not necessary, because it'll be done later in add_to_speculative_block. */ { - rtx_vec_t priorities_roots = rtx_vec_t(); + rtx_vec_t priorities_roots = rtx_vec_t (); clear_priorities (twin, &priorities_roots); calc_priorities (priorities_roots); diff --git a/gcc/hash-table.c b/gcc/hash-table.c index d3cb7b10818..1cf7b234862 100644 --- a/gcc/hash-table.c +++ b/gcc/hash-table.c @@ -111,7 +111,7 @@ unsigned int hash_table_higher_prime_index (unsigned long n) { unsigned int low = 0; - unsigned int high = sizeof(prime_tab) / sizeof(prime_tab[0]); + unsigned int high = sizeof (prime_tab) / sizeof (prime_tab[0]); while (low != high) { diff --git a/gcc/hash-table.h b/gcc/hash-table.h index 00637789923..6d01188fe40 100644 --- a/gcc/hash-table.h +++ b/gcc/hash-table.h @@ -456,8 +456,8 @@ public: int (*Callback) (value_type **slot, Argument argument)> void traverse (Argument argument); - iterator begin(); - iterator end(); + iterator begin (); + iterator end (); }; @@ -522,7 +522,7 @@ hash_table <Descriptor, Allocator>::remove_elt (const value_type *value) template <typename Descriptor, template <typename Type> class Allocator> inline size_t -hash_table <Descriptor, Allocator>::size() +hash_table <Descriptor, Allocator>::size () { return htab->size; } @@ -556,7 +556,7 @@ hash_table <Descriptor, Allocator>::elements_with_deleted () template <typename Descriptor, template <typename Type> class Allocator> inline double -hash_table <Descriptor, Allocator>::collisions() +hash_table <Descriptor, Allocator>::collisions () { if (htab->searches == 0) return 0.0; diff --git a/gcc/hwint.c b/gcc/hwint.c index 134fe1da2cc..9e99dd99e0b 100644 --- a/gcc/hwint.c +++ b/gcc/hwint.c @@ -93,7 +93,7 @@ ctz_hwi (unsigned HOST_WIDE_INT x) int clz_hwi (unsigned HOST_WIDE_INT x) { - return HOST_BITS_PER_WIDE_INT - 1 - floor_log2(x); + return HOST_BITS_PER_WIDE_INT - 1 - floor_log2 (x); } /* Similar to ctz_hwi, except that the least significant bit is numbered diff --git a/gcc/hwint.h b/gcc/hwint.h index 9930baac100..d2c2ec377b0 100644 --- a/gcc/hwint.h +++ b/gcc/hwint.h @@ -37,7 +37,7 @@ # if GCC_VERSION >= 3000 # define HAVE_LONG_LONG 1 # define SIZEOF_LONG_LONG 8 -extern char sizeof_long_long_must_be_8[sizeof(long long) == 8 ? 1 : -1]; +extern char sizeof_long_long_must_be_8[sizeof (long long) == 8 ? 1 : -1]; # endif #endif @@ -110,11 +110,11 @@ extern char sizeof_long_long_must_be_8[sizeof(long long) == 8 ? 1 : -1]; #endif -#define HOST_WIDE_INT_UC(X) HOST_WIDE_INT_C(X ## U) -#define HOST_WIDE_INT_1 HOST_WIDE_INT_C(1) -#define HOST_WIDE_INT_1U HOST_WIDE_INT_UC(1) -#define HOST_WIDE_INT_M1 HOST_WIDE_INT_C(-1) -#define HOST_WIDE_INT_M1U HOST_WIDE_INT_UC(-1) +#define HOST_WIDE_INT_UC(X) HOST_WIDE_INT_C (X ## U) +#define HOST_WIDE_INT_1 HOST_WIDE_INT_C (1) +#define HOST_WIDE_INT_1U HOST_WIDE_INT_UC (1) +#define HOST_WIDE_INT_M1 HOST_WIDE_INT_C (-1) +#define HOST_WIDE_INT_M1U HOST_WIDE_INT_UC (-1) /* This is a magic identifier which allows GCC to figure out the type of HOST_WIDE_INT for %wd specifier checks. You must issue this @@ -168,7 +168,7 @@ typedef HOST_WIDE_INT __gcc_host_wide_int__; # define HOST_WIDEST_INT_PRINT_UNSIGNED HOST_WIDE_INT_PRINT_UNSIGNED # define HOST_WIDEST_INT_PRINT_HEX HOST_WIDE_INT_PRINT_HEX # define HOST_WIDEST_INT_PRINT_DOUBLE_HEX HOST_WIDE_INT_PRINT_DOUBLE_HEX -# define HOST_WIDEST_INT_C(X) HOST_WIDE_INT(X) +# define HOST_WIDEST_INT_C(X) HOST_WIDE_INT (X) #else # if HOST_BITS_PER_LONGLONG >= 64 # define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_LONGLONG diff --git a/gcc/ifcvt.c b/gcc/ifcvt.c index 747fab9cabc..fafff9d0925 100644 --- a/gcc/ifcvt.c +++ b/gcc/ifcvt.c @@ -336,7 +336,7 @@ cond_exec_process_insns (ce_if_block_t *ce_info ATTRIBUTE_UNUSED, if (NOTE_P (insn) || DEBUG_INSN_P (insn)) goto insn_done; - gcc_assert(NONJUMP_INSN_P (insn) || CALL_P (insn)); + gcc_assert (NONJUMP_INSN_P (insn) || CALL_P (insn)); /* Remove USE insns that get in the way. */ if (reload_completed && GET_CODE (PATTERN (insn)) == USE) @@ -4503,8 +4503,8 @@ const pass_data pass_data_rtl_ifcvt = class pass_rtl_ifcvt : public rtl_opt_pass { public: - pass_rtl_ifcvt(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_ifcvt, ctxt) + pass_rtl_ifcvt (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_ifcvt, ctxt) {} /* opt_pass methods: */ @@ -4558,8 +4558,8 @@ const pass_data pass_data_if_after_combine = class pass_if_after_combine : public rtl_opt_pass { public: - pass_if_after_combine(gcc::context *ctxt) - : rtl_opt_pass(pass_data_if_after_combine, ctxt) + pass_if_after_combine (gcc::context *ctxt) + : rtl_opt_pass (pass_data_if_after_combine, ctxt) {} /* opt_pass methods: */ @@ -4612,8 +4612,8 @@ const pass_data pass_data_if_after_reload = class pass_if_after_reload : public rtl_opt_pass { public: - pass_if_after_reload(gcc::context *ctxt) - : rtl_opt_pass(pass_data_if_after_reload, ctxt) + pass_if_after_reload (gcc::context *ctxt) + : rtl_opt_pass (pass_data_if_after_reload, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/incpath.c b/gcc/incpath.c index 018da982c14..54b636034f3 100644 --- a/gcc/incpath.c +++ b/gcc/incpath.c @@ -33,7 +33,7 @@ VMS has non-numeric inodes. */ #ifdef VMS # define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A))) -# define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC)) +# define INO_T_COPY(DEST, SRC) memcpy (&(DEST), &(SRC), sizeof (SRC)) #elif !defined (HOST_LACKS_INODE_NUMBERS) # define INO_T_EQ(A, B) ((A) == (B)) # define INO_T_COPY(DEST, SRC) (DEST) = (SRC) @@ -41,7 +41,7 @@ #if defined INO_T_EQ #define DIRS_EQ(A, B) ((A)->dev == (B)->dev \ - && INO_T_EQ((A)->ino, (B)->ino)) + && INO_T_EQ ((A)->ino, (B)->ino)) #else #define DIRS_EQ(A, B) (!filename_cmp ((A)->canonical_name, (B)->canonical_name)) #endif @@ -128,7 +128,7 @@ add_standard_paths (const char *sysroot, const char *iprefix, const char *imultilib, int cxx_stdinc) { const struct default_include *p; - int relocated = cpp_relocated(); + int relocated = cpp_relocated (); size_t len; if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0) diff --git a/gcc/init-regs.c b/gcc/init-regs.c index ddb0b3792ba..2a15b3e0a6f 100644 --- a/gcc/init-regs.c +++ b/gcc/init-regs.c @@ -158,8 +158,8 @@ const pass_data pass_data_initialize_regs = class pass_initialize_regs : public rtl_opt_pass { public: - pass_initialize_regs(gcc::context *ctxt) - : rtl_opt_pass(pass_data_initialize_regs, ctxt) + pass_initialize_regs (gcc::context *ctxt) + : rtl_opt_pass (pass_data_initialize_regs, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/input.h b/gcc/input.h index 56f6de0e0e4..8fdc7b28d92 100644 --- a/gcc/input.h +++ b/gcc/input.h @@ -37,7 +37,7 @@ extern char builtins_location_check[(BUILTINS_LOCATION < RESERVED_LOCATION_COUNT) ? 1 : -1]; extern expanded_location expand_location (source_location); -extern const char * location_get_source_line(expanded_location xloc); +extern const char *location_get_source_line (expanded_location xloc); extern expanded_location expand_location_to_spelling_point (source_location); extern source_location expansion_point_location_if_in_system_header (source_location); @@ -51,10 +51,11 @@ extern location_t input_location; #define LOCATION_LINE(LOC) ((expand_location (LOC)).line) #define LOCATION_COLUMN(LOC)((expand_location (LOC)).column) #define LOCATION_LOCUS(LOC) \ - ((IS_ADHOC_LOC(LOC)) ? get_location_from_adhoc_loc (line_table, LOC) : (LOC)) + ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \ + : (LOC)) #define LOCATION_BLOCK(LOC) \ ((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \ - : NULL)) + : NULL)) #define input_line LOCATION_LINE (input_location) #define input_filename LOCATION_FILE (input_location) diff --git a/gcc/intl.c b/gcc/intl.c index 262745f8049..aa443509a6f 100644 --- a/gcc/intl.c +++ b/gcc/intl.c @@ -140,7 +140,7 @@ char * get_spaces (const char *str) { size_t len = gcc_gettext_width (str); - char *spaces = XNEWVEC(char, len + 1); + char *spaces = XNEWVEC (char, len + 1); memset (spaces, ' ', len); spaces[len] = '\0'; return spaces; diff --git a/gcc/intl.h b/gcc/intl.h index e1c6c2b22f6..d34973e88fc 100644 --- a/gcc/intl.h +++ b/gcc/intl.h @@ -38,12 +38,12 @@ extern size_t gcc_gettext_width (const char *); # define bindtextdomain(domain, directory) (domain) # undef gettext # define gettext(msgid) (msgid) -# define ngettext(singular,plural,n) fake_ngettext(singular,plural,n) +# define ngettext(singular,plural,n) fake_ngettext (singular, plural, n) # define gcc_init_libintl() /* nothing */ -# define gcc_gettext_width(s) strlen(s) +# define gcc_gettext_width(s) strlen (s) -extern const char *fake_ngettext(const char *singular,const char *plural, - unsigned long int n); +extern const char *fake_ngettext (const char *singular, const char *plural, + unsigned long int n); #endif diff --git a/gcc/ipa-cp.c b/gcc/ipa-cp.c index 86f5501c388..c38ba82e5f0 100644 --- a/gcc/ipa-cp.c +++ b/gcc/ipa-cp.c @@ -3023,7 +3023,7 @@ intersect_aggregates_with_edge (struct cgraph_edge *cs, int index, } else { - inter.release(); + inter.release (); return vec<ipa_agg_jf_item_t>(); } return inter; @@ -3194,7 +3194,7 @@ cgraph_edge_brings_all_agg_vals_for_node (struct cgraph_edge *cs, return false; values = intersect_aggregates_with_edge (cs, i, values); - if (!values.exists()) + if (!values.exists ()) return false; for (struct ipa_agg_replacement_value *av = aggval; av; av = av->next) @@ -3213,7 +3213,7 @@ cgraph_edge_brings_all_agg_vals_for_node (struct cgraph_edge *cs, } if (!found) { - values.release(); + values.release (); return false; } } @@ -3679,19 +3679,19 @@ const pass_data pass_data_ipa_cp = class pass_ipa_cp : public ipa_opt_pass_d { public: - pass_ipa_cp(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_cp, ctxt, - ipcp_generate_summary, /* generate_summary */ - ipcp_write_summary, /* write_summary */ - ipcp_read_summary, /* read_summary */ - ipa_prop_write_all_agg_replacement, /* - write_optimization_summary */ - ipa_prop_read_all_agg_replacement, /* - read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - ipcp_transform_function, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_cp (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_cp, ctxt, + ipcp_generate_summary, /* generate_summary */ + ipcp_write_summary, /* write_summary */ + ipcp_read_summary, /* read_summary */ + ipa_prop_write_all_agg_replacement, /* + write_optimization_summary */ + ipa_prop_read_all_agg_replacement, /* + read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + ipcp_transform_function, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ diff --git a/gcc/ipa-devirt.c b/gcc/ipa-devirt.c index c610e7bd14d..10499e1cfc0 100644 --- a/gcc/ipa-devirt.c +++ b/gcc/ipa-devirt.c @@ -373,7 +373,7 @@ add_type_duplicate (odr_type val, tree type) unsigned int i; TYPE_BINFO (val->type) = TYPE_BINFO (type); - for (i = 0; i < val->types->length(); i++) + for (i = 0; i < val->types->length (); i++) { if (TYPE_BINFO ((*val->types)[i]) == master_binfo) @@ -438,7 +438,7 @@ get_odr_type (tree type, bool insert) } /* First record bases, then add into array so ids are increasing. */ if (odr_types_ptr) - val->id = odr_types.length(); + val->id = odr_types.length (); vec_safe_push (odr_types_ptr, val); } return val; @@ -460,17 +460,17 @@ dump_odr_type (FILE *f, odr_type t, int indent=0) DECL_SOURCE_FILE (TYPE_NAME (t->type)), DECL_SOURCE_LINE (TYPE_NAME (t->type))); } - if (t->bases.length()) + if (t->bases.length ()) { fprintf (f, "%*s base odr type ids: ", indent * 2, ""); - for (i = 0; i < t->bases.length(); i++) + for (i = 0; i < t->bases.length (); i++) fprintf (f, " %i", t->bases[i]->id); fprintf (f, "\n"); } - if (t->derived_types.length()) + if (t->derived_types.length ()) { fprintf (f, "%*s derived types:\n", indent * 2, ""); - for (i = 0; i < t->derived_types.length(); i++) + for (i = 0; i < t->derived_types.length (); i++) dump_odr_type (f, t->derived_types[i], indent + 1); } fprintf (f, "\n"); @@ -485,19 +485,19 @@ dump_type_inheritance_graph (FILE *f) if (!odr_types_ptr) return; fprintf (f, "\n\nType inheritance graph:\n"); - for (i = 0; i < odr_types.length(); i++) + for (i = 0; i < odr_types.length (); i++) { - if (odr_types[i]->bases.length() == 0) + if (odr_types[i]->bases.length () == 0) dump_odr_type (f, odr_types[i]); } - for (i = 0; i < odr_types.length(); i++) + for (i = 0; i < odr_types.length (); i++) { - if (odr_types[i]->types && odr_types[i]->types->length()) + if (odr_types[i]->types && odr_types[i]->types->length ()) { unsigned int j; fprintf (f, "Duplicate tree types for odr type %i\n", i); print_node (f, "", odr_types[i]->type, 0); - for (j = 0; j < odr_types[i]->types->length(); j++) + for (j = 0; j < odr_types[i]->types->length (); j++) { tree t; fprintf (f, "duplicate #%i\n", j); @@ -665,7 +665,7 @@ possible_polymorphic_call_targets_1 (vec <cgraph_node *> &nodes, record_binfo (nodes, binfo, otr_type, binfo, otr_token, inserted, matched_vtables, type->anonymous_namespace); - for (i = 0; i < type->derived_types.length(); i++) + for (i = 0; i < type->derived_types.length (); i++) possible_polymorphic_call_targets_1 (nodes, inserted, matched_vtables, otr_type, @@ -854,7 +854,7 @@ possible_polymorphic_call_targets (tree otr_type, /* Walk recursively all derived types. Here we need to lookup proper basetype via their BINFO walk that is done by record_binfo */ - for (i = 0; i < type->derived_types.length(); i++) + for (i = 0; i < type->derived_types.length (); i++) possible_polymorphic_call_targets_1 (nodes, inserted, matched_vtables, otr_type, type->derived_types[i], @@ -1030,7 +1030,7 @@ ipa_devirt (void) nmultiple++; continue; } - for (i = 0; i < targets.length(); i++) + for (i = 0; i < targets.length (); i++) if (likely_target_p (targets[i])) { if (likely_target) @@ -1163,17 +1163,17 @@ const pass_data pass_data_ipa_devirt = class pass_ipa_devirt : public ipa_opt_pass_d { public: - pass_ipa_devirt(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_devirt, ctxt, - NULL, /* generate_summary */ - NULL, /* write_summary */ - NULL, /* read_summary */ - NULL, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_devirt (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_devirt, ctxt, + NULL, /* generate_summary */ + NULL, /* write_summary */ + NULL, /* read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c index ba6221e41fd..00a21d9288a 100644 --- a/gcc/ipa-inline-analysis.c +++ b/gcc/ipa-inline-analysis.c @@ -2739,8 +2739,8 @@ const pass_data pass_data_inline_parameters = class pass_inline_parameters : public gimple_opt_pass { public: - pass_inline_parameters(gcc::context *ctxt) - : gimple_opt_pass(pass_data_inline_parameters, ctxt) + pass_inline_parameters (gcc::context *ctxt) + : gimple_opt_pass (pass_data_inline_parameters, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/ipa-inline.c b/gcc/ipa-inline.c index 3672e57e471..7735bb9da7b 100644 --- a/gcc/ipa-inline.c +++ b/gcc/ipa-inline.c @@ -904,8 +904,8 @@ edge_badness (struct cgraph_edge *edge, bool dump) sreal tmp, relbenefit_real, growth_real; int relbenefit = relative_time_benefit (callee_info, edge, edge_time); - sreal_init(&relbenefit_real, relbenefit, 0); - sreal_init(&growth_real, growth, 0); + sreal_init (&relbenefit_real, relbenefit, 0); + sreal_init (&growth_real, growth, 0); /* relative_edge_count. */ sreal_init (&tmp, edge->count, 0); @@ -2311,8 +2311,8 @@ const pass_data pass_data_early_inline = class pass_early_inline : public gimple_opt_pass { public: - pass_early_inline(gcc::context *ctxt) - : gimple_opt_pass(pass_data_early_inline, ctxt) + pass_early_inline (gcc::context *ctxt) + : gimple_opt_pass (pass_data_early_inline, ctxt) {} /* opt_pass methods: */ @@ -2361,17 +2361,17 @@ const pass_data pass_data_ipa_inline = class pass_ipa_inline : public ipa_opt_pass_d { public: - pass_ipa_inline(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_inline, ctxt, - inline_generate_summary, /* generate_summary */ - inline_write_summary, /* write_summary */ - inline_read_summary, /* read_summary */ - NULL, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - inline_transform, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_inline (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_inline, ctxt, + inline_generate_summary, /* generate_summary */ + inline_write_summary, /* write_summary */ + inline_read_summary, /* read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + inline_transform, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ diff --git a/gcc/ipa-profile.c b/gcc/ipa-profile.c index 424e4a6b6fe..bae9aecd3b1 100644 --- a/gcc/ipa-profile.c +++ b/gcc/ipa-profile.c @@ -240,7 +240,7 @@ ipa_profile_write_summary (void) = lto_create_simple_output_block (LTO_section_ipa_profile); unsigned int i; - streamer_write_uhwi_stream (ob->main_stream, histogram.length()); + streamer_write_uhwi_stream (ob->main_stream, histogram.length ()); for (i = 0; i < histogram.length (); i++) { streamer_write_gcov_count_stream (ob->main_stream, histogram[i]->count); @@ -560,7 +560,7 @@ ipa_profile (void) set_hot_bb_threshold (threshold); } } - histogram.release(); + histogram.release (); free_alloc_pool (histogram_pool); /* Produce speculative calls: we saved common traget from porfiling into @@ -732,17 +732,17 @@ const pass_data pass_data_ipa_profile = class pass_ipa_profile : public ipa_opt_pass_d { public: - pass_ipa_profile(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_profile, ctxt, - ipa_profile_generate_summary, /* generate_summary */ - ipa_profile_write_summary, /* write_summary */ - ipa_profile_read_summary, /* read_summary */ - NULL, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_profile (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_profile, ctxt, + ipa_profile_generate_summary, /* generate_summary */ + ipa_profile_write_summary, /* write_summary */ + ipa_profile_read_summary, /* read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ diff --git a/gcc/ipa-pure-const.c b/gcc/ipa-pure-const.c index 55b679d98a2..bc0a17bc5dc 100644 --- a/gcc/ipa-pure-const.c +++ b/gcc/ipa-pure-const.c @@ -759,7 +759,7 @@ analyze_function (struct cgraph_node *fn, bool ipa) gimple_stmt_iterator gsi; struct walk_stmt_info wi; - memset (&wi, 0, sizeof(wi)); + memset (&wi, 0, sizeof (wi)); for (gsi = gsi_start_bb (this_block); !gsi_end_p (gsi); gsi_next (&gsi)) @@ -1520,17 +1520,17 @@ const pass_data pass_data_ipa_pure_const = class pass_ipa_pure_const : public ipa_opt_pass_d { public: - pass_ipa_pure_const(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_pure_const, ctxt, - pure_const_generate_summary, /* generate_summary */ - pure_const_write_summary, /* write_summary */ - pure_const_read_summary, /* read_summary */ - NULL, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_pure_const (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_pure_const, ctxt, + pure_const_generate_summary, /* generate_summary */ + pure_const_write_summary, /* write_summary */ + pure_const_read_summary, /* read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ @@ -1704,8 +1704,8 @@ const pass_data pass_data_local_pure_const = class pass_local_pure_const : public gimple_opt_pass { public: - pass_local_pure_const(gcc::context *ctxt) - : gimple_opt_pass(pass_data_local_pure_const, ctxt) + pass_local_pure_const (gcc::context *ctxt) + : gimple_opt_pass (pass_data_local_pure_const, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c index e6f19fdd1bf..d9463804ea2 100644 --- a/gcc/ipa-reference.c +++ b/gcc/ipa-reference.c @@ -578,8 +578,7 @@ generate_summary (void) EXECUTE_IF_SET_IN_BITMAP (l->statics_written, 0, index, bi) { - fprintf(dump_file, "%s ", - get_static_name (index)); + fprintf (dump_file, "%s ", get_static_name (index)); } } } @@ -949,7 +948,7 @@ stream_out_bitmap (struct lto_simple_output_block *ob, EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi) { tree decl = (tree)splay_tree_lookup (reference_vars_to_consider, index)->value; - lto_output_var_decl_index(ob->decl_state, ob->main_stream, decl); + lto_output_var_decl_index (ob->decl_state, ob->main_stream, decl); } } @@ -1175,20 +1174,20 @@ const pass_data pass_data_ipa_reference = class pass_ipa_reference : public ipa_opt_pass_d { public: - pass_ipa_reference(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_reference, ctxt, - NULL, /* generate_summary */ - NULL, /* write_summary */ - NULL, /* read_summary */ - ipa_reference_write_optimization_summary, /* - write_optimization_summary */ - ipa_reference_read_optimization_summary, /* - read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ - {} + pass_ipa_reference (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_reference, ctxt, + NULL, /* generate_summary */ + NULL, /* write_summary */ + NULL, /* read_summary */ + ipa_reference_write_optimization_summary, /* + write_optimization_summary */ + ipa_reference_read_optimization_summary, /* + read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ + {} /* opt_pass methods: */ bool gate () { return gate_reference (); } diff --git a/gcc/ipa-split.c b/gcc/ipa-split.c index 322258a66f8..874e7b83542 100644 --- a/gcc/ipa-split.c +++ b/gcc/ipa-split.c @@ -1650,8 +1650,8 @@ const pass_data pass_data_split_functions = class pass_split_functions : public gimple_opt_pass { public: - pass_split_functions(gcc::context *ctxt) - : gimple_opt_pass(pass_data_split_functions, ctxt) + pass_split_functions (gcc::context *ctxt) + : gimple_opt_pass (pass_data_split_functions, ctxt) {} /* opt_pass methods: */ @@ -1710,8 +1710,8 @@ const pass_data pass_data_feedback_split_functions = class pass_feedback_split_functions : public gimple_opt_pass { public: - pass_feedback_split_functions(gcc::context *ctxt) - : gimple_opt_pass(pass_data_feedback_split_functions, ctxt) + pass_feedback_split_functions (gcc::context *ctxt) + : gimple_opt_pass (pass_data_feedback_split_functions, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/ipa-utils.c b/gcc/ipa-utils.c index 12ce0ca0292..b59be8c6392 100644 --- a/gcc/ipa-utils.c +++ b/gcc/ipa-utils.c @@ -54,9 +54,9 @@ ipa_print_order (FILE* out, fprintf (out, "\n\n ordered call graph: %s\n", note); for (i = count - 1; i >= 0; i--) - dump_cgraph_node(dump_file, order[i]); + dump_cgraph_node (dump_file, order[i]); fprintf (out, "\n"); - fflush(out); + fflush (out); } diff --git a/gcc/ipa.c b/gcc/ipa.c index 67b3bc0f07c..92343fb22c9 100644 --- a/gcc/ipa.c +++ b/gcc/ipa.c @@ -173,7 +173,7 @@ walk_polymorphic_call_targets (pointer_set_t *reachable_call_targets, if (!pointer_set_insert (reachable_call_targets, cache_token)) { - for (i = 0; i < targets.length(); i++) + for (i = 0; i < targets.length (); i++) { struct cgraph_node *n = targets[i]; @@ -204,7 +204,7 @@ walk_polymorphic_call_targets (pointer_set_t *reachable_call_targets, make the edge direct. */ if (final) { - if (targets.length() <= 1) + if (targets.length () <= 1) { cgraph_node *target, *node = edge->caller; if (targets.length () == 1) @@ -882,7 +882,7 @@ function_and_variable_visibility (bool whole_program) struct varpool_node *vnode; /* All aliases should be procssed at this point. */ - gcc_checking_assert (!alias_pairs || !alias_pairs->length()); + gcc_checking_assert (!alias_pairs || !alias_pairs->length ()); FOR_EACH_FUNCTION (node) { @@ -1122,8 +1122,9 @@ const pass_data pass_data_ipa_function_and_variable_visibility = class pass_ipa_function_and_variable_visibility : public simple_ipa_opt_pass { public: - pass_ipa_function_and_variable_visibility(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_function_and_variable_visibility, ctxt) + pass_ipa_function_and_variable_visibility (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_function_and_variable_visibility, + ctxt) {} /* opt_pass methods: */ @@ -1170,8 +1171,8 @@ const pass_data pass_data_ipa_free_inline_summary = class pass_ipa_free_inline_summary : public simple_ipa_opt_pass { public: - pass_ipa_free_inline_summary(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_free_inline_summary, ctxt) + pass_ipa_free_inline_summary (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_free_inline_summary, ctxt) {} /* opt_pass methods: */ @@ -1226,17 +1227,17 @@ const pass_data pass_data_ipa_whole_program_visibility = class pass_ipa_whole_program_visibility : public ipa_opt_pass_d { public: - pass_ipa_whole_program_visibility(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_whole_program_visibility, ctxt, - NULL, /* generate_summary */ - NULL, /* write_summary */ - NULL, /* read_summary */ - NULL, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_whole_program_visibility (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_whole_program_visibility, ctxt, + NULL, /* generate_summary */ + NULL, /* write_summary */ + NULL, /* read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ @@ -1559,17 +1560,17 @@ const pass_data pass_data_ipa_cdtor_merge = class pass_ipa_cdtor_merge : public ipa_opt_pass_d { public: - pass_ipa_cdtor_merge(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_cdtor_merge, ctxt, - NULL, /* generate_summary */ - NULL, /* write_summary */ - NULL, /* read_summary */ - NULL, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_cdtor_merge (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_cdtor_merge, ctxt, + NULL, /* generate_summary */ + NULL, /* write_summary */ + NULL, /* read_summary */ + NULL, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ diff --git a/gcc/ira-build.c b/gcc/ira-build.c index 0e2fd0c5510..32aec6f1da4 100644 --- a/gcc/ira-build.c +++ b/gcc/ira-build.c @@ -2408,8 +2408,8 @@ remove_unnecessary_regions (bool all_p) mark_all_loops_for_removal (); else mark_loops_for_removal (); - children_vec.create(last_basic_block + number_of_loops (cfun)); - removed_loop_vec.create(last_basic_block + number_of_loops (cfun)); + children_vec.create (last_basic_block + number_of_loops (cfun)); + removed_loop_vec.create (last_basic_block + number_of_loops (cfun)); remove_uneccesary_loop_nodes_from_loop_tree (ira_loop_tree_root); children_vec.release (); if (all_p) diff --git a/gcc/ira.c b/gcc/ira.c index 44fa0bc2835..203fbff6a26 100644 --- a/gcc/ira.c +++ b/gcc/ira.c @@ -3515,7 +3515,7 @@ setup_reg_equiv (void) static void print_insn_chain (FILE *file, struct insn_chain *c) { - fprintf (file, "insn=%d, ", INSN_UID(c->insn)); + fprintf (file, "insn=%d, ", INSN_UID (c->insn)); bitmap_print (file, &c->live_throughout, "live_throughout: ", ", "); bitmap_print (file, &c->dead_or_set, "dead_or_set: ", "\n"); } @@ -4391,9 +4391,9 @@ allocate_initial_values (void) /* Update global register liveness information. */ FOR_EACH_BB (bb) { - if (REGNO_REG_SET_P(df_get_live_in (bb), regno)) + if (REGNO_REG_SET_P (df_get_live_in (bb), regno)) SET_REGNO_REG_SET (df_get_live_in (bb), new_regno); - if (REGNO_REG_SET_P(df_get_live_out (bb), regno)) + if (REGNO_REG_SET_P (df_get_live_out (bb), regno)) SET_REGNO_REG_SET (df_get_live_out (bb), new_regno); } } @@ -4792,8 +4792,8 @@ const pass_data pass_data_ira = class pass_ira : public rtl_opt_pass { public: - pass_ira(gcc::context *ctxt) - : rtl_opt_pass(pass_data_ira, ctxt) + pass_ira (gcc::context *ctxt) + : rtl_opt_pass (pass_data_ira, ctxt) {} /* opt_pass methods: */ @@ -4836,8 +4836,8 @@ const pass_data pass_data_reload = class pass_reload : public rtl_opt_pass { public: - pass_reload(gcc::context *ctxt) - : rtl_opt_pass(pass_data_reload, ctxt) + pass_reload (gcc::context *ctxt) + : rtl_opt_pass (pass_data_reload, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/jump.c b/gcc/jump.c index 6f7bcb72d1c..a27aaa94b8d 100644 --- a/gcc/jump.c +++ b/gcc/jump.c @@ -159,8 +159,8 @@ const pass_data pass_data_cleanup_barriers = class pass_cleanup_barriers : public rtl_opt_pass { public: - pass_cleanup_barriers(gcc::context *ctxt) - : rtl_opt_pass(pass_data_cleanup_barriers, ctxt) + pass_cleanup_barriers (gcc::context *ctxt) + : rtl_opt_pass (pass_data_cleanup_barriers, ctxt) {} /* opt_pass methods: */ @@ -401,9 +401,9 @@ reversed_comparison_code_parts (enum rtx_code code, const_rtx arg0, /* These CONST_CAST's are okay because prev_nonnote_insn just returns its argument and we assign it to a const_rtx variable. */ - for (prev = prev_nonnote_insn (CONST_CAST_RTX(insn)); + for (prev = prev_nonnote_insn (CONST_CAST_RTX (insn)); prev != 0 && !LABEL_P (prev); - prev = prev_nonnote_insn (CONST_CAST_RTX(prev))) + prev = prev_nonnote_insn (CONST_CAST_RTX (prev))) { const_rtx set = set_of (arg0, prev); if (set && GET_CODE (set) == SET diff --git a/gcc/loop-doloop.c b/gcc/loop-doloop.c index 3b86f841fc9..b989454ed9e 100644 --- a/gcc/loop-doloop.c +++ b/gcc/loop-doloop.c @@ -556,7 +556,7 @@ doloop_modify (struct loop *loop, struct niter_desc *desc, || !iter.fits_shwi ()) iter_rtx = const0_rtx; else - iter_rtx = GEN_INT (iter.to_shwi()); + iter_rtx = GEN_INT (iter.to_shwi ()); init = gen_doloop_begin (counter_reg, desc->const_iter ? desc->niter_expr : const0_rtx, iter_rtx, @@ -673,7 +673,7 @@ doloop_optimize (struct loop *loop) || !iter.fits_shwi ()) iterations_max = const0_rtx; else - iterations_max = GEN_INT (iter.to_shwi()); + iterations_max = GEN_INT (iter.to_shwi ()); level = get_loop_level (loop) + 1; /* Generate looping insn. If the pattern FAILs then give up trying diff --git a/gcc/loop-init.c b/gcc/loop-init.c index d45f42d9153..c7aee1da6b9 100644 --- a/gcc/loop-init.c +++ b/gcc/loop-init.c @@ -336,8 +336,8 @@ const pass_data pass_data_loop2 = class pass_loop2 : public rtl_opt_pass { public: - pass_loop2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_loop2, ctxt) + pass_loop2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_loop2, ctxt) {} /* opt_pass methods: */ @@ -390,8 +390,8 @@ const pass_data pass_data_rtl_loop_init = class pass_rtl_loop_init : public rtl_opt_pass { public: - pass_rtl_loop_init(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_loop_init, ctxt) + pass_rtl_loop_init (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_loop_init, ctxt) {} /* opt_pass methods: */ @@ -448,8 +448,8 @@ const pass_data pass_data_rtl_loop_done = class pass_rtl_loop_done : public rtl_opt_pass { public: - pass_rtl_loop_done(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_loop_done, ctxt) + pass_rtl_loop_done (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_loop_done, ctxt) {} /* opt_pass methods: */ @@ -502,8 +502,8 @@ const pass_data pass_data_rtl_move_loop_invariants = class pass_rtl_move_loop_invariants : public rtl_opt_pass { public: - pass_rtl_move_loop_invariants(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_move_loop_invariants, ctxt) + pass_rtl_move_loop_invariants (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_move_loop_invariants, ctxt) {} /* opt_pass methods: */ @@ -556,8 +556,8 @@ const pass_data pass_data_rtl_unswitch = class pass_rtl_unswitch : public rtl_opt_pass { public: - pass_rtl_unswitch(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_unswitch, ctxt) + pass_rtl_unswitch (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_unswitch, ctxt) {} /* opt_pass methods: */ @@ -623,8 +623,8 @@ const pass_data pass_data_rtl_unroll_and_peel_loops = class pass_rtl_unroll_and_peel_loops : public rtl_opt_pass { public: - pass_rtl_unroll_and_peel_loops(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_unroll_and_peel_loops, ctxt) + pass_rtl_unroll_and_peel_loops (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_unroll_and_peel_loops, ctxt) {} /* opt_pass methods: */ @@ -683,8 +683,8 @@ const pass_data pass_data_rtl_doloop = class pass_rtl_doloop : public rtl_opt_pass { public: - pass_rtl_doloop(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_doloop, ctxt) + pass_rtl_doloop (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_doloop, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/loop-invariant.c b/gcc/loop-invariant.c index 73200e199b2..c5d6b5ac29d 100644 --- a/gcc/loop-invariant.c +++ b/gcc/loop-invariant.c @@ -180,7 +180,7 @@ static vec<invariant_p> invariants; static void check_invariant_table_size (void) { - if (invariant_table_size < DF_DEFS_TABLE_SIZE()) + if (invariant_table_size < DF_DEFS_TABLE_SIZE ()) { unsigned int new_size = DF_DEFS_TABLE_SIZE () + (DF_DEFS_TABLE_SIZE () / 4); invariant_table = XRESIZEVEC (struct invariant *, invariant_table, new_size); @@ -274,13 +274,13 @@ invariant_for_use (df_ref use) return NULL; def = defs->ref; check_invariant_table_size (); - if (!invariant_table[DF_REF_ID(def)]) + if (!invariant_table[DF_REF_ID (def)]) return NULL; def_bb = DF_REF_BB (def); if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb)) return NULL; - return invariant_table[DF_REF_ID(def)]; + return invariant_table[DF_REF_ID (def)]; } /* Computes hash value for invariant expression X in INSN. */ @@ -807,7 +807,7 @@ check_dependency (basic_block bb, df_ref use, bitmap depends_on) def = defs->ref; check_invariant_table_size (); - inv = invariant_table[DF_REF_ID(def)]; + inv = invariant_table[DF_REF_ID (def)]; if (!inv) return false; @@ -908,7 +908,7 @@ find_invariant_insn (rtx insn, bool always_reached, bool always_executed) { ref = df_find_def (insn, dest); check_invariant_table_size (); - invariant_table[DF_REF_ID(ref)] = inv; + invariant_table[DF_REF_ID (ref)] = inv; } } diff --git a/gcc/loop-iv.c b/gcc/loop-iv.c index 9112e886318..07f28e3affe 100644 --- a/gcc/loop-iv.c +++ b/gcc/loop-iv.c @@ -99,8 +99,8 @@ static unsigned int iv_ref_table_size = 0; static struct rtx_iv ** iv_ref_table; /* Induction variable stored at the reference. */ -#define DF_REF_IV(REF) iv_ref_table[DF_REF_ID(REF)] -#define DF_REF_IV_SET(REF, IV) iv_ref_table[DF_REF_ID(REF)] = (IV) +#define DF_REF_IV(REF) iv_ref_table[DF_REF_ID (REF)] +#define DF_REF_IV_SET(REF, IV) iv_ref_table[DF_REF_ID (REF)] = (IV) /* The current loop. */ @@ -212,7 +212,7 @@ lowpart_subreg (enum machine_mode outer_mode, rtx expr, static void check_iv_ref_table_size (void) { - if (iv_ref_table_size < DF_DEFS_TABLE_SIZE()) + if (iv_ref_table_size < DF_DEFS_TABLE_SIZE ()) { unsigned int new_size = DF_DEFS_TABLE_SIZE () + (DF_DEFS_TABLE_SIZE () / 4); iv_ref_table = XRESIZEVEC (struct rtx_iv *, iv_ref_table, new_size); diff --git a/gcc/lower-subreg.c b/gcc/lower-subreg.c index ac67398a2db..57b4b3c2467 100644 --- a/gcc/lower-subreg.c +++ b/gcc/lower-subreg.c @@ -1709,8 +1709,8 @@ const pass_data pass_data_lower_subreg = class pass_lower_subreg : public rtl_opt_pass { public: - pass_lower_subreg(gcc::context *ctxt) - : rtl_opt_pass(pass_data_lower_subreg, ctxt) + pass_lower_subreg (gcc::context *ctxt) + : rtl_opt_pass (pass_data_lower_subreg, ctxt) {} /* opt_pass methods: */ @@ -1748,8 +1748,8 @@ const pass_data pass_data_lower_subreg2 = class pass_lower_subreg2 : public rtl_opt_pass { public: - pass_lower_subreg2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_lower_subreg2, ctxt) + pass_lower_subreg2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_lower_subreg2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/lto-cgraph.c b/gcc/lto-cgraph.c index 952588dba2f..211eda97269 100644 --- a/gcc/lto-cgraph.c +++ b/gcc/lto-cgraph.c @@ -853,7 +853,7 @@ compute_ltrans_boundary (lto_symtab_encoder_t in_encoder) if (!pointer_set_insert (reachable_call_targets, cache_token)) { - for (i = 0; i < targets.length(); i++) + for (i = 0; i < targets.length (); i++) { struct cgraph_node *callee = targets[i]; @@ -1560,7 +1560,8 @@ input_symtab (void) ib = lto_create_simple_input_block (file_data, LTO_section_refs, &data, &len); if (!ib) - fatal_error("cannot find LTO section refs in %s", file_data->file_name); + fatal_error ("cannot find LTO section refs in %s", + file_data->file_name); input_refs (ib, nodes); lto_destroy_simple_input_block (file_data, LTO_section_refs, ib, data, len); diff --git a/gcc/lto-streamer-in.c b/gcc/lto-streamer-in.c index 78957565edb..72d450ca9d9 100644 --- a/gcc/lto-streamer-in.c +++ b/gcc/lto-streamer-in.c @@ -652,7 +652,7 @@ input_cfg (struct lto_input_block *ib, struct function *fn, index = streamer_read_hwi (ib); } - p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn); + p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION (fn); index = streamer_read_hwi (ib); while (index != -1) { diff --git a/gcc/lto-streamer-out.c b/gcc/lto-streamer-out.c index 8f823f2c712..20d8bfa9c42 100644 --- a/gcc/lto-streamer-out.c +++ b/gcc/lto-streamer-out.c @@ -2034,17 +2034,17 @@ const pass_data pass_data_ipa_lto_gimple_out = class pass_ipa_lto_gimple_out : public ipa_opt_pass_d { public: - pass_ipa_lto_gimple_out(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_lto_gimple_out, ctxt, - NULL, /* generate_summary */ - lto_output, /* write_summary */ - NULL, /* read_summary */ - lto_output, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_lto_gimple_out (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_lto_gimple_out, ctxt, + NULL, /* generate_summary */ + lto_output, /* write_summary */ + NULL, /* read_summary */ + lto_output, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ @@ -2248,7 +2248,7 @@ write_symbol (struct streamer_tree_cache_d *cache, && !targetm.binds_local_p (t)) visibility = GCCPV_DEFAULT; else - switch (DECL_VISIBILITY(t)) + switch (DECL_VISIBILITY (t)) { case VISIBILITY_DEFAULT: visibility = GCCPV_DEFAULT; @@ -2458,7 +2458,7 @@ produce_asm_for_decls (void) lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state); } lto_write_stream (decl_state_stream); - free(decl_state_stream); + free (decl_state_stream); lto_write_stream (ob->main_stream); lto_write_stream (ob->string_stream); @@ -2506,17 +2506,17 @@ const pass_data pass_data_ipa_lto_finish_out = class pass_ipa_lto_finish_out : public ipa_opt_pass_d { public: - pass_ipa_lto_finish_out(gcc::context *ctxt) - : ipa_opt_pass_d(pass_data_ipa_lto_finish_out, ctxt, - NULL, /* generate_summary */ - produce_asm_for_decls, /* write_summary */ - NULL, /* read_summary */ - produce_asm_for_decls, /* write_optimization_summary */ - NULL, /* read_optimization_summary */ - NULL, /* stmt_fixup */ - 0, /* function_transform_todo_flags_start */ - NULL, /* function_transform */ - NULL) /* variable_transform */ + pass_ipa_lto_finish_out (gcc::context *ctxt) + : ipa_opt_pass_d (pass_data_ipa_lto_finish_out, ctxt, + NULL, /* generate_summary */ + produce_asm_for_decls, /* write_summary */ + NULL, /* read_summary */ + produce_asm_for_decls, /* write_optimization_summary */ + NULL, /* read_optimization_summary */ + NULL, /* stmt_fixup */ + 0, /* function_transform_todo_flags_start */ + NULL, /* function_transform */ + NULL) /* variable_transform */ {} /* opt_pass methods: */ diff --git a/gcc/lto-wrapper.c b/gcc/lto-wrapper.c index 15a34dd6956..755993ca634 100644 --- a/gcc/lto-wrapper.c +++ b/gcc/lto-wrapper.c @@ -744,7 +744,7 @@ run_gcc (unsigned argc, char *argv[]) if (lto_mode == LTO_MODE_LTO) { - printf("%s\n", flto_out); + printf ("%s\n", flto_out); free (flto_out); flto_out = NULL; } @@ -820,9 +820,9 @@ cont: { char *dumpbase = (char *) xmalloc (strlen (linker_output) - + sizeof(DUMPBASE_SUFFIX) + 1); + + sizeof (DUMPBASE_SUFFIX) + 1); snprintf (dumpbase, - strlen (linker_output) + sizeof(DUMPBASE_SUFFIX), + strlen (linker_output) + sizeof (DUMPBASE_SUFFIX), "%s.ltrans%u", linker_output, i); argv_ptr[0] = dumpbase; } diff --git a/gcc/mcf.c b/gcc/mcf.c index 7a716f58177..52020b8c2f8 100644 --- a/gcc/mcf.c +++ b/gcc/mcf.c @@ -385,7 +385,7 @@ add_fixup_edge (fixup_graph_type *fixup_graph, int src, int dest, edge_type type, gcov_type weight, gcov_type cost, gcov_type max_capacity) { - fixup_edge_p curr_edge = add_edge(fixup_graph, src, dest, cost); + fixup_edge_p curr_edge = add_edge (fixup_graph, src, dest, cost); curr_edge->type = type; curr_edge->weight = weight; curr_edge->max_capacity = max_capacity; diff --git a/gcc/mode-switching.c b/gcc/mode-switching.c index 56c4d0fef9a..23ed63b10f8 100644 --- a/gcc/mode-switching.c +++ b/gcc/mode-switching.c @@ -804,8 +804,8 @@ const pass_data pass_data_mode_switching = class pass_mode_switching : public rtl_opt_pass { public: - pass_mode_switching(gcc::context *ctxt) - : rtl_opt_pass(pass_data_mode_switching, ctxt) + pass_mode_switching (gcc::context *ctxt) + : rtl_opt_pass (pass_data_mode_switching, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/modulo-sched.c b/gcc/modulo-sched.c index 3ad2ec77f1e..599c025f57d 100644 --- a/gcc/modulo-sched.c +++ b/gcc/modulo-sched.c @@ -3374,8 +3374,8 @@ const pass_data pass_data_sms = class pass_sms : public rtl_opt_pass { public: - pass_sms(gcc::context *ctxt) - : rtl_opt_pass(pass_data_sms, ctxt) + pass_sms (gcc::context *ctxt) + : rtl_opt_pass (pass_data_sms, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/omp-low.c b/gcc/omp-low.c index fa9aca49a3a..84b2357b754 100644 --- a/gcc/omp-low.c +++ b/gcc/omp-low.c @@ -6860,8 +6860,8 @@ const pass_data pass_data_expand_omp = class pass_expand_omp : public gimple_opt_pass { public: - pass_expand_omp(gcc::context *ctxt) - : gimple_opt_pass(pass_data_expand_omp, ctxt) + pass_expand_omp (gcc::context *ctxt) + : gimple_opt_pass (pass_data_expand_omp, ctxt) {} /* opt_pass methods: */ @@ -8056,8 +8056,8 @@ const pass_data pass_data_lower_omp = class pass_lower_omp : public gimple_opt_pass { public: - pass_lower_omp(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_omp, ctxt) + pass_lower_omp (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_omp, ctxt) {} /* opt_pass methods: */ @@ -8337,8 +8337,8 @@ const pass_data pass_data_diagnose_omp_blocks = class pass_diagnose_omp_blocks : public gimple_opt_pass { public: - pass_diagnose_omp_blocks(gcc::context *ctxt) - : gimple_opt_pass(pass_data_diagnose_omp_blocks, ctxt) + pass_diagnose_omp_blocks (gcc::context *ctxt) + : gimple_opt_pass (pass_data_diagnose_omp_blocks, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/optabs.c b/gcc/optabs.c index 3238885c187..06a626c839b 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -401,8 +401,8 @@ optab_for_tree_code (enum tree_code code, const_tree type, case FLOOR_DIV_EXPR: case ROUND_DIV_EXPR: case EXACT_DIV_EXPR: - if (TYPE_SATURATING(type)) - return TYPE_UNSIGNED(type) ? usdiv_optab : ssdiv_optab; + if (TYPE_SATURATING (type)) + return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab; return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab; case LSHIFT_EXPR: @@ -413,8 +413,8 @@ optab_for_tree_code (enum tree_code code, const_tree type, gcc_assert (subtype == optab_scalar); } - if (TYPE_SATURATING(type)) - return TYPE_UNSIGNED(type) ? usashl_optab : ssashl_optab; + if (TYPE_SATURATING (type)) + return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab; return ashl_optab; case RSHIFT_EXPR: @@ -556,23 +556,23 @@ optab_for_tree_code (enum tree_code code, const_tree type, { case POINTER_PLUS_EXPR: case PLUS_EXPR: - if (TYPE_SATURATING(type)) - return TYPE_UNSIGNED(type) ? usadd_optab : ssadd_optab; + if (TYPE_SATURATING (type)) + return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab; return trapv ? addv_optab : add_optab; case MINUS_EXPR: - if (TYPE_SATURATING(type)) - return TYPE_UNSIGNED(type) ? ussub_optab : sssub_optab; + if (TYPE_SATURATING (type)) + return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab; return trapv ? subv_optab : sub_optab; case MULT_EXPR: - if (TYPE_SATURATING(type)) - return TYPE_UNSIGNED(type) ? usmul_optab : ssmul_optab; + if (TYPE_SATURATING (type)) + return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab; return trapv ? smulv_optab : smul_optab; case NEGATE_EXPR: - if (TYPE_SATURATING(type)) - return TYPE_UNSIGNED(type) ? usneg_optab : ssneg_optab; + if (TYPE_SATURATING (type)) + return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab; return trapv ? negv_optab : neg_optab; case ABS_EXPR: @@ -5714,7 +5714,7 @@ gen_interclass_conv_libfunc (convert_optab tab, fname = GET_MODE_NAME (fmode); tname = GET_MODE_NAME (tmode); - if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode)) + if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode)) { libfunc_name = dec_name; suffix = dec_suffix; @@ -5847,7 +5847,7 @@ gen_intraclass_conv_libfunc (convert_optab tab, const char *opname, fname = GET_MODE_NAME (fmode); tname = GET_MODE_NAME (tmode); - if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode)) + if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode)) { libfunc_name = dec_name; suffix = dec_suffix; @@ -7585,7 +7585,7 @@ expand_atomic_store (rtx mem, rtx val, enum memmodel model, bool use_release) /* If the size of the object is greater than word size on this target, a default store will not be atomic, Try a mem_exchange and throw away the result. If that doesn't work, don't do anything. */ - if (GET_MODE_PRECISION(mode) > BITS_PER_WORD) + if (GET_MODE_PRECISION (mode) > BITS_PER_WORD) { rtx target = maybe_emit_atomic_exchange (NULL_RTX, mem, val, model); if (!target) diff --git a/gcc/opts.c b/gcc/opts.c index b1fadb16232..8adfc9bc3dd 100644 --- a/gcc/opts.c +++ b/gcc/opts.c @@ -169,7 +169,7 @@ base_of_path (const char *path, const char **base_out) char c = *p; while (c) { - if (IS_DIR_SEPARATOR(c)) + if (IS_DIR_SEPARATOR (c)) { base = p + 1; dot = 0; @@ -888,7 +888,7 @@ wrap_help (const char *help, } } - printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help); + printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help); item_width = 0; while (help[len] == ' ') len++; diff --git a/gcc/pass_manager.h b/gcc/pass_manager.h index 04c6237d791..cca6a3567cd 100644 --- a/gcc/pass_manager.h +++ b/gcc/pass_manager.h @@ -49,7 +49,7 @@ class pass_manager public: void *operator new (size_t sz); - pass_manager(context *ctxt); + pass_manager (context *ctxt); void register_pass (struct register_pass_info *pass_info); void register_one_dump_file (struct opt_pass *pass); diff --git a/gcc/passes.c b/gcc/passes.c index f3f85fd3b94..e64281e1d53 100644 --- a/gcc/passes.c +++ b/gcc/passes.c @@ -107,12 +107,12 @@ opt_pass::execute () return 0; } -opt_pass::opt_pass(const pass_data &data, context *ctxt) - : pass_data(data), - sub(NULL), - next(NULL), - static_pass_number(0), - ctxt_(ctxt) +opt_pass::opt_pass (const pass_data &data, context *ctxt) + : pass_data (data), + sub (NULL), + next (NULL), + static_pass_number (0), + ctxt_ (ctxt) { } @@ -350,8 +350,8 @@ const pass_data pass_data_early_local_passes = class pass_early_local_passes : public simple_ipa_opt_pass { public: - pass_early_local_passes(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_early_local_passes, ctxt) + pass_early_local_passes (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_early_local_passes, ctxt) {} /* opt_pass methods: */ @@ -398,8 +398,8 @@ const pass_data pass_data_all_early_optimizations = class pass_all_early_optimizations : public gimple_opt_pass { public: - pass_all_early_optimizations(gcc::context *ctxt) - : gimple_opt_pass(pass_data_all_early_optimizations, ctxt) + pass_all_early_optimizations (gcc::context *ctxt) + : gimple_opt_pass (pass_data_all_early_optimizations, ctxt) {} /* opt_pass methods: */ @@ -443,8 +443,8 @@ const pass_data pass_data_all_optimizations = class pass_all_optimizations : public gimple_opt_pass { public: - pass_all_optimizations(gcc::context *ctxt) - : gimple_opt_pass(pass_data_all_optimizations, ctxt) + pass_all_optimizations (gcc::context *ctxt) + : gimple_opt_pass (pass_data_all_optimizations, ctxt) {} /* opt_pass methods: */ @@ -488,8 +488,8 @@ const pass_data pass_data_all_optimizations_g = class pass_all_optimizations_g : public gimple_opt_pass { public: - pass_all_optimizations_g(gcc::context *ctxt) - : gimple_opt_pass(pass_data_all_optimizations_g, ctxt) + pass_all_optimizations_g (gcc::context *ctxt) + : gimple_opt_pass (pass_data_all_optimizations_g, ctxt) {} /* opt_pass methods: */ @@ -533,8 +533,8 @@ const pass_data pass_data_rest_of_compilation = class pass_rest_of_compilation : public rtl_opt_pass { public: - pass_rest_of_compilation(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rest_of_compilation, ctxt) + pass_rest_of_compilation (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rest_of_compilation, ctxt) {} /* opt_pass methods: */ @@ -576,8 +576,8 @@ const pass_data pass_data_postreload = class pass_postreload : public rtl_opt_pass { public: - pass_postreload(gcc::context *ctxt) - : rtl_opt_pass(pass_data_postreload, ctxt) + pass_postreload (gcc::context *ctxt) + : rtl_opt_pass (pass_data_postreload, ctxt) {} /* opt_pass methods: */ @@ -836,7 +836,7 @@ dump_one_pass (struct opt_pass *pass, int pass_indent) const char *pn; bool is_on, is_really_on; - is_on = pass->has_gate ? pass->gate() : true; + is_on = pass->has_gate ? pass->gate () : true; is_really_on = override_gate_status (pass, current_function_decl, is_on); if (pass->static_pass_number <= 0) @@ -879,7 +879,7 @@ pass_manager::dump_passes () const { struct cgraph_node *n, *node = NULL; - create_pass_tab(); + create_pass_tab (); FOR_EACH_FUNCTION (n) if (DECL_STRUCT_FUNCTION (n->symbol.decl)) @@ -1485,10 +1485,10 @@ pass_manager::operator new (size_t sz) } pass_manager::pass_manager (context *ctxt) -: all_passes(NULL), all_small_ipa_passes(NULL), all_lowering_passes(NULL), - all_regular_ipa_passes(NULL), all_lto_gen_passes(NULL), - all_late_ipa_passes(NULL), passes_by_id(NULL), passes_by_id_size(0), - ctxt_(ctxt) +: all_passes (NULL), all_small_ipa_passes (NULL), all_lowering_passes (NULL), + all_regular_ipa_passes (NULL), all_lto_gen_passes (NULL), + all_late_ipa_passes (NULL), passes_by_id (NULL), passes_by_id_size (0), + ctxt_ (ctxt) { struct opt_pass **p; @@ -2090,7 +2090,7 @@ apply_ipa_transforms (void *data) if (!node->global.inlined_to && node->ipa_transforms_to_apply.exists ()) { *(bool *)data = true; - execute_all_ipa_transforms(); + execute_all_ipa_transforms (); rebuild_cgraph_edges (); } } @@ -2139,7 +2139,7 @@ execute_one_pass (struct opt_pass *pass) /* Check whether gate check should be avoided. User controls the value of the gate through the parameter "gate_status". */ - gate_status = pass->has_gate ? pass->gate() : true; + gate_status = pass->has_gate ? pass->gate () : true; gate_status = override_gate_status (pass, current_function_decl, gate_status); /* Override gate with plugin. */ diff --git a/gcc/plugin.c b/gcc/plugin.c index 3b39a0b30d9..d7dcb5f4d36 100644 --- a/gcc/plugin.c +++ b/gcc/plugin.c @@ -803,7 +803,7 @@ dump_active_plugins (FILE *file) for (ci = plugin_callbacks[event]; ci; ci = ci->next) fprintf (file, " %s", ci->plugin_name); - putc('\n', file); + putc ('\n', file); } } diff --git a/gcc/postreload-gcse.c b/gcc/postreload-gcse.c index 0f3ed7acda6..941007f5220 100644 --- a/gcc/postreload-gcse.c +++ b/gcc/postreload-gcse.c @@ -892,7 +892,7 @@ get_avail_load_store_reg (rtx insn) { if (REG_P (SET_DEST (PATTERN (insn)))) /* A load. */ - return SET_DEST(PATTERN(insn)); + return SET_DEST (PATTERN (insn)); else { /* A store. */ @@ -1344,8 +1344,8 @@ const pass_data pass_data_gcse2 = class pass_gcse2 : public rtl_opt_pass { public: - pass_gcse2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_gcse2, ctxt) + pass_gcse2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_gcse2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/postreload.c b/gcc/postreload.c index 97d7e5d0332..b0c63422357 100644 --- a/gcc/postreload.c +++ b/gcc/postreload.c @@ -2359,8 +2359,8 @@ const pass_data pass_data_postreload_cse = class pass_postreload_cse : public rtl_opt_pass { public: - pass_postreload_cse(gcc::context *ctxt) - : rtl_opt_pass(pass_data_postreload_cse, ctxt) + pass_postreload_cse (gcc::context *ctxt) + : rtl_opt_pass (pass_data_postreload_cse, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/predict.c b/gcc/predict.c index aa66ecdbbdb..2472fca81cd 100644 --- a/gcc/predict.c +++ b/gcc/predict.c @@ -2957,8 +2957,8 @@ const pass_data pass_data_profile = class pass_profile : public gimple_opt_pass { public: - pass_profile(gcc::context *ctxt) - : gimple_opt_pass(pass_data_profile, ctxt) + pass_profile (gcc::context *ctxt) + : gimple_opt_pass (pass_data_profile, ctxt) {} /* opt_pass methods: */ @@ -2995,8 +2995,8 @@ const pass_data pass_data_strip_predict_hints = class pass_strip_predict_hints : public gimple_opt_pass { public: - pass_strip_predict_hints(gcc::context *ctxt) - : gimple_opt_pass(pass_data_strip_predict_hints, ctxt) + pass_strip_predict_hints (gcc::context *ctxt) + : gimple_opt_pass (pass_data_strip_predict_hints, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/prefix.c b/gcc/prefix.c index 058e19156c5..6092fbf1987 100644 --- a/gcc/prefix.c +++ b/gcc/prefix.c @@ -250,7 +250,7 @@ update_path (const char *path, const char *key) const int len = strlen (std_prefix); if (! filename_ncmp (path, std_prefix, len) - && (IS_DIR_SEPARATOR(path[len]) + && (IS_DIR_SEPARATOR (path[len]) || path[len] == '\0') && key != 0) { diff --git a/gcc/pretty-print.c b/gcc/pretty-print.c index 05f345ca2a8..8cec71b762a 100644 --- a/gcc/pretty-print.c +++ b/gcc/pretty-print.c @@ -773,7 +773,7 @@ pretty_printer::pretty_printer (const char *p, int l) format_decoder (), emitted_prefix (), need_newline (), - translate_identifiers(true), + translate_identifiers (true), show_color () { pp_line_cutoff (this) = l; diff --git a/gcc/print-rtl.c b/gcc/print-rtl.c index a1ba0dcc71e..7d712c1562d 100644 --- a/gcc/print-rtl.c +++ b/gcc/print-rtl.c @@ -399,7 +399,8 @@ print_rtx (const_rtx in_rtx) redundant with line number information and do not print anything when there is no location information available. */ if (INSN_LOCATION (in_rtx) && insn_file (in_rtx)) - fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx)); + fprintf (outfile, " %s:%i", insn_file (in_rtx), + insn_line (in_rtx)); #endif } else if (i == 6 && GET_CODE (in_rtx) == ASM_OPERANDS) diff --git a/gcc/print-tree.c b/gcc/print-tree.c index 22f007879db..4ded0d6360a 100644 --- a/gcc/print-tree.c +++ b/gcc/print-tree.c @@ -818,7 +818,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent) if (ch >= ' ' && ch < 127) putc (ch, file); else - fprintf(file, "\\%03o", ch & 0xFF); + fprintf (file, "\\%03o", ch & 0xFF); } fputc ('\"', file); } diff --git a/gcc/profile.c b/gcc/profile.c index 94a3f07c6f3..edc202cf767 100644 --- a/gcc/profile.c +++ b/gcc/profile.c @@ -275,11 +275,11 @@ get_exec_counts (unsigned cfg_checksum, unsigned lineno_checksum) if (!counts) return NULL; - get_working_sets(); + get_working_sets (); if (dump_file && profile_info) - fprintf(dump_file, "Merged %u profiles with maximal count %u.\n", - profile_info->runs, (unsigned) profile_info->sum_max); + fprintf (dump_file, "Merged %u profiles with maximal count %u.\n", + profile_info->runs, (unsigned) profile_info->sum_max); return counts; } @@ -976,7 +976,7 @@ branch_prob (void) unsigned num_edges, ignored_edges; unsigned num_instrumented; struct edge_list *el; - histogram_values values = histogram_values(); + histogram_values values = histogram_values (); unsigned cfg_checksum, lineno_checksum; total_num_times_called++; diff --git a/gcc/read-md.c b/gcc/read-md.c index d32072be7a5..c108d51fd06 100644 --- a/gcc/read-md.c +++ b/gcc/read-md.c @@ -672,7 +672,7 @@ scan_comma_elt (const char **pstr) if (*p == ',') p++; - while (ISSPACE(*p)) + while (ISSPACE (*p)) p++; if (*p == '\0') diff --git a/gcc/real.c b/gcc/real.c index b80aeac843f..b59be66af94 100644 --- a/gcc/real.c +++ b/gcc/real.c @@ -2855,7 +2855,7 @@ real_hash (const REAL_VALUE_TYPE *r) gcc_unreachable (); } - if (sizeof(unsigned long) > sizeof(unsigned int)) + if (sizeof (unsigned long) > sizeof (unsigned int)) for (i = 0; i < SIGSZ; ++i) { unsigned long s = r->sig[i]; diff --git a/gcc/real.h b/gcc/real.h index 2ff84f6d295..b92453411d7 100644 --- a/gcc/real.h +++ b/gcc/real.h @@ -73,7 +73,7 @@ struct GTY(()) real_value { /* Verify the guess. */ extern char test_real_width - [sizeof(REAL_VALUE_TYPE) <= REAL_WIDTH*sizeof(HOST_WIDE_INT) ? 1 : -1]; + [sizeof (REAL_VALUE_TYPE) <= REAL_WIDTH * sizeof (HOST_WIDE_INT) ? 1 : -1]; /* Calculate the format for CONST_DOUBLE. We need as many slots as are necessary to overlay a REAL_VALUE_TYPE on them. This could be diff --git a/gcc/recog.c b/gcc/recog.c index 690b20e4751..f64753ad6ca 100644 --- a/gcc/recog.c +++ b/gcc/recog.c @@ -3801,8 +3801,8 @@ const pass_data pass_data_peephole2 = class pass_peephole2 : public rtl_opt_pass { public: - pass_peephole2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_peephole2, ctxt) + pass_peephole2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_peephole2, ctxt) {} /* opt_pass methods: */ @@ -3849,8 +3849,8 @@ const pass_data pass_data_split_all_insns = class pass_split_all_insns : public rtl_opt_pass { public: - pass_split_all_insns(gcc::context *ctxt) - : rtl_opt_pass(pass_data_split_all_insns, ctxt) + pass_split_all_insns (gcc::context *ctxt) + : rtl_opt_pass (pass_data_split_all_insns, ctxt) {} /* opt_pass methods: */ @@ -3900,8 +3900,8 @@ const pass_data pass_data_split_after_reload = class pass_split_after_reload : public rtl_opt_pass { public: - pass_split_after_reload(gcc::context *ctxt) - : rtl_opt_pass(pass_data_split_after_reload, ctxt) + pass_split_after_reload (gcc::context *ctxt) + : rtl_opt_pass (pass_data_split_after_reload, ctxt) {} /* opt_pass methods: */ @@ -3962,8 +3962,8 @@ const pass_data pass_data_split_before_regstack = class pass_split_before_regstack : public rtl_opt_pass { public: - pass_split_before_regstack(gcc::context *ctxt) - : rtl_opt_pass(pass_data_split_before_regstack, ctxt) + pass_split_before_regstack (gcc::context *ctxt) + : rtl_opt_pass (pass_data_split_before_regstack, ctxt) {} /* opt_pass methods: */ @@ -4021,8 +4021,8 @@ const pass_data pass_data_split_before_sched2 = class pass_split_before_sched2 : public rtl_opt_pass { public: - pass_split_before_sched2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_split_before_sched2, ctxt) + pass_split_before_sched2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_split_before_sched2, ctxt) {} /* opt_pass methods: */ @@ -4071,8 +4071,8 @@ const pass_data pass_data_split_for_shorten_branches = class pass_split_for_shorten_branches : public rtl_opt_pass { public: - pass_split_for_shorten_branches(gcc::context *ctxt) - : rtl_opt_pass(pass_data_split_for_shorten_branches, ctxt) + pass_split_for_shorten_branches (gcc::context *ctxt) + : rtl_opt_pass (pass_data_split_for_shorten_branches, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/ree.c b/gcc/ree.c index 541bdb5a131..fa05feed749 100644 --- a/gcc/ree.c +++ b/gcc/ree.c @@ -800,7 +800,7 @@ add_removable_extension (const_rtx expr, rtx insn, /* Second, make sure the reaching definitions don't feed another and different extension. FIXME: this obviously can be improved. */ for (def = defs; def; def = def->next) - if ((idx = def_map[INSN_UID(DF_REF_INSN (def->ref))]) + if ((idx = def_map[INSN_UID (DF_REF_INSN (def->ref))]) && (cand = &(*insn_list)[idx - 1]) && cand->code != code) { @@ -820,7 +820,7 @@ add_removable_extension (const_rtx expr, rtx insn, idx = insn_list->length (); for (def = defs; def; def = def->next) - def_map[INSN_UID(DF_REF_INSN (def->ref))] = idx; + def_map[INSN_UID (DF_REF_INSN (def->ref))] = idx; } } @@ -961,8 +961,8 @@ const pass_data pass_data_ree = class pass_ree : public rtl_opt_pass { public: - pass_ree(gcc::context *ctxt) - : rtl_opt_pass(pass_data_ree, ctxt) + pass_ree (gcc::context *ctxt) + : rtl_opt_pass (pass_data_ree, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/reg-stack.c b/gcc/reg-stack.c index 69c05b62ad4..1917c46fe96 100644 --- a/gcc/reg-stack.c +++ b/gcc/reg-stack.c @@ -253,7 +253,7 @@ static void replace_reg (rtx *, int); static void remove_regno_note (rtx, enum reg_note, unsigned int); static int get_hard_regnum (stack_ptr, rtx); static rtx emit_pop_insn (rtx, stack_ptr, rtx, enum emit_where); -static void swap_to_top(rtx, stack_ptr, rtx, rtx); +static void swap_to_top (rtx, stack_ptr, rtx, rtx); static bool move_for_stack_reg (rtx, stack_ptr, rtx); static bool move_nan_for_stack_reg (rtx, stack_ptr, rtx); static int swap_rtx_condition_1 (rtx); @@ -3314,8 +3314,8 @@ const pass_data pass_data_stack_regs = class pass_stack_regs : public rtl_opt_pass { public: - pass_stack_regs(gcc::context *ctxt) - : rtl_opt_pass(pass_data_stack_regs, ctxt) + pass_stack_regs (gcc::context *ctxt) + : rtl_opt_pass (pass_data_stack_regs, ctxt) {} /* opt_pass methods: */ @@ -3363,8 +3363,8 @@ const pass_data pass_data_stack_regs_run = class pass_stack_regs_run : public rtl_opt_pass { public: - pass_stack_regs_run(gcc::context *ctxt) - : rtl_opt_pass(pass_data_stack_regs_run, ctxt) + pass_stack_regs_run (gcc::context *ctxt) + : rtl_opt_pass (pass_data_stack_regs_run, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/regcprop.c b/gcc/regcprop.c index 19f33495170..0fa0afbc824 100644 --- a/gcc/regcprop.c +++ b/gcc/regcprop.c @@ -1256,8 +1256,8 @@ const pass_data pass_data_cprop_hardreg = class pass_cprop_hardreg : public rtl_opt_pass { public: - pass_cprop_hardreg(gcc::context *ctxt) - : rtl_opt_pass(pass_data_cprop_hardreg, ctxt) + pass_cprop_hardreg (gcc::context *ctxt) + : rtl_opt_pass (pass_data_cprop_hardreg, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/reginfo.c b/gcc/reginfo.c index d385dc74c48..26318dc503a 100644 --- a/gcc/reginfo.c +++ b/gcc/reginfo.c @@ -447,7 +447,7 @@ init_reg_sets_1 (void) } } - COPY_HARD_REG_SET(call_fixed_reg_set, fixed_reg_set); + COPY_HARD_REG_SET (call_fixed_reg_set, fixed_reg_set); /* Preserve global registers if called more than once. */ for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) @@ -495,7 +495,7 @@ init_reg_modes_target (void) for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) for (j = 0; j < MAX_MACHINE_MODE; j++) - hard_regno_nregs[i][j] = HARD_REGNO_NREGS(i, (enum machine_mode)j); + hard_regno_nregs[i][j] = HARD_REGNO_NREGS (i, (enum machine_mode)j); for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) { @@ -980,8 +980,8 @@ const pass_data pass_data_reginfo_init = class pass_reginfo_init : public rtl_opt_pass { public: - pass_reginfo_init(gcc::context *ctxt) - : rtl_opt_pass(pass_data_reginfo_init, ctxt) + pass_reginfo_init (gcc::context *ctxt) + : rtl_opt_pass (pass_data_reginfo_init, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/regmove.c b/gcc/regmove.c index c8686d36aec..85c7ff490c8 100644 --- a/gcc/regmove.c +++ b/gcc/regmove.c @@ -1382,8 +1382,8 @@ const pass_data pass_data_regmove = class pass_regmove : public rtl_opt_pass { public: - pass_regmove(gcc::context *ctxt) - : rtl_opt_pass(pass_data_regmove, ctxt) + pass_regmove (gcc::context *ctxt) + : rtl_opt_pass (pass_data_regmove, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/regrename.c b/gcc/regrename.c index 6830bd8389a..5b2c85799bb 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -1862,8 +1862,8 @@ const pass_data pass_data_regrename = class pass_regrename : public rtl_opt_pass { public: - pass_regrename(gcc::context *ctxt) - : rtl_opt_pass(pass_data_regrename, ctxt) + pass_regrename (gcc::context *ctxt) + : rtl_opt_pass (pass_data_regrename, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/regs.h b/gcc/regs.h index 090d6b64e83..b5fa3f3995f 100644 --- a/gcc/regs.h +++ b/gcc/regs.h @@ -69,7 +69,7 @@ extern struct regstat_n_sets_and_refs_t *regstat_n_sets_and_refs; /* Indexed by n, gives number of times (REG n) is used or set. */ static inline int -REG_N_REFS(int regno) +REG_N_REFS (int regno) { return regstat_n_sets_and_refs[regno].refs; } diff --git a/gcc/regstat.c b/gcc/regstat.c index 5b1f3c421ee..85678a70f68 100644 --- a/gcc/regstat.c +++ b/gcc/regstat.c @@ -172,7 +172,7 @@ regstat_bb_compute_ri (unsigned int bb_index, while (link) { if (REG_NOTE_KIND (link) == REG_DEAD) - REG_N_DEATHS(REGNO (XEXP (link, 0)))++; + REG_N_DEATHS (REGNO (XEXP (link, 0)))++; link = XEXP (link, 1); } diff --git a/gcc/reload1.c b/gcc/reload1.c index 6cb0f57295a..bb13bf802d1 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -2325,7 +2325,7 @@ mark_home_live_1 (int regno, enum machine_mode mode) return; lim = end_hard_regno (mode, i); while (i < lim) - df_set_regs_ever_live(i++, true); + df_set_regs_ever_live (i++, true); } /* Mark the slots in regs_ever_live for the hard regs diff --git a/gcc/reorg.c b/gcc/reorg.c index e65cbf7e54b..e9aa889b17d 100644 --- a/gcc/reorg.c +++ b/gcc/reorg.c @@ -2173,7 +2173,7 @@ fill_simple_delay_slots (int non_jumps_p) && ! (maybe_never && may_trap_or_fault_p (pat)) && (trial = try_split (pat, trial, 0)) && eligible_for_delay (insn, slots_filled, trial, flags) - && ! can_throw_internal(trial)) + && ! can_throw_internal (trial)) { next_trial = next_nonnote_insn (trial); delay_list = add_to_delay_list (trial, delay_list); @@ -2363,8 +2363,8 @@ fill_slots_from_thread (rtx insn, rtx condition, rtx thread, int flags; /* Validate our arguments. */ - gcc_assert(condition != const_true_rtx || thread_if_true); - gcc_assert(own_thread || thread_if_true); + gcc_assert (condition != const_true_rtx || thread_if_true); + gcc_assert (own_thread || thread_if_true); flags = get_jump_flags (insn, JUMP_LABEL (insn)); @@ -3888,8 +3888,8 @@ const pass_data pass_data_delay_slots = class pass_delay_slots : public rtl_opt_pass { public: - pass_delay_slots(gcc::context *ctxt) - : rtl_opt_pass(pass_data_delay_slots, ctxt) + pass_delay_slots (gcc::context *ctxt) + : rtl_opt_pass (pass_data_delay_slots, ctxt) {} /* opt_pass methods: */ @@ -3941,8 +3941,8 @@ const pass_data pass_data_machine_reorg = class pass_machine_reorg : public rtl_opt_pass { public: - pass_machine_reorg(gcc::context *ctxt) - : rtl_opt_pass(pass_data_machine_reorg, ctxt) + pass_machine_reorg (gcc::context *ctxt) + : rtl_opt_pass (pass_data_machine_reorg, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/rtl.c b/gcc/rtl.c index b2d88f783b7..52b7747b693 100644 --- a/gcc/rtl.c +++ b/gcc/rtl.c @@ -222,7 +222,7 @@ shared_const_p (const_rtx orig) a LABEL_REF, it isn't sharable. */ return (GET_CODE (XEXP (orig, 0)) == PLUS && GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF - && CONST_INT_P(XEXP (XEXP (orig, 0), 1))); + && CONST_INT_P (XEXP (XEXP (orig, 0), 1))); } diff --git a/gcc/rtl.h b/gcc/rtl.h index f7e5cffa08d..247a0d06701 100644 --- a/gcc/rtl.h +++ b/gcc/rtl.h @@ -544,7 +544,7 @@ struct GTY((variable_size)) rtvec_def { if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ __FUNCTION__); \ - if (GET_RTX_FORMAT(_code)[_n] != C1) \ + if (GET_RTX_FORMAT (_code)[_n] != C1) \ rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__, \ __FUNCTION__); \ &_rtx->u.fld[_n]; })) @@ -555,8 +555,8 @@ struct GTY((variable_size)) rtvec_def { if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ __FUNCTION__); \ - if (GET_RTX_FORMAT(_code)[_n] != C1 \ - && GET_RTX_FORMAT(_code)[_n] != C2) \ + if (GET_RTX_FORMAT (_code)[_n] != C1 \ + && GET_RTX_FORMAT (_code)[_n] != C2) \ rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__, \ __FUNCTION__); \ &_rtx->u.fld[_n]; })) @@ -589,7 +589,7 @@ struct GTY((variable_size)) rtvec_def { if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \ rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \ __FUNCTION__); \ - if (GET_RTX_FORMAT(_code)[_n] != 'w') \ + if (GET_RTX_FORMAT (_code)[_n] != 'w') \ rtl_check_failed_type1 (_rtx, _n, 'w', __FILE__, __LINE__, \ __FUNCTION__); \ &_rtx->u.hwint[_n]; })) @@ -679,39 +679,39 @@ extern void rtvec_check_failed_bounds (const_rtvec, int, const char *, int, #if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007) #define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1) \ + if (GET_CODE (_rtx) != C1) \ rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) #define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2) \ + if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2) \ rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) #define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ - && GET_CODE(_rtx) != C3) \ + if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE (_rtx) != C3) \ rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) #define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ - && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4) \ + if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2 \ + && GET_CODE (_rtx) != C3 && GET_CODE(_rtx) != C4) \ rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) #define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ - && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ - && GET_CODE(_rtx) != C5) \ + if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \ + && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \ + && GET_CODE (_rtx) != C5) \ rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) @@ -719,9 +719,9 @@ extern void rtvec_check_failed_bounds (const_rtvec, int, const char *, int, #define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) \ __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ - && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ - && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6) \ + if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \ + && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \ + && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6) \ rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) @@ -729,10 +729,10 @@ extern void rtvec_check_failed_bounds (const_rtvec, int, const char *, int, #define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) \ __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ - && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ - && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \ - && GET_CODE(_rtx) != C7) \ + if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \ + && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \ + && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6 \ + && GET_CODE (_rtx) != C7) \ rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) @@ -740,10 +740,10 @@ extern void rtvec_check_failed_bounds (const_rtvec, int, const char *, int, #define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) \ __extension__ \ ({ __typeof (RTX) const _rtx = (RTX); \ - if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \ - && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \ - && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \ - && GET_CODE(_rtx) != C7 && GET_CODE(_rtx) != C8) \ + if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \ + && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \ + && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6 \ + && GET_CODE (_rtx) != C7 && GET_CODE (_rtx) != C8) \ rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \ __FUNCTION__); \ _rtx; }) @@ -844,56 +844,57 @@ extern void rtl_check_failed_flag (const char *, const_rtx, const char *, #define INSN_CODE(INSN) XINT (INSN, 6) #define RTX_FRAME_RELATED_P(RTX) \ - (RTL_FLAG_CHECK6("RTX_FRAME_RELATED_P", (RTX), DEBUG_INSN, INSN, \ - CALL_INSN, JUMP_INSN, BARRIER, SET)->frame_related) + (RTL_FLAG_CHECK6 ("RTX_FRAME_RELATED_P", (RTX), DEBUG_INSN, INSN, \ + CALL_INSN, JUMP_INSN, BARRIER, SET)->frame_related) /* 1 if RTX is an insn that has been deleted. */ #define INSN_DELETED_P(RTX) \ - (RTL_FLAG_CHECK8("INSN_DELETED_P", (RTX), DEBUG_INSN, INSN, \ - CALL_INSN, JUMP_INSN, JUMP_TABLE_DATA, \ - CODE_LABEL, BARRIER, NOTE)->volatil) + (RTL_FLAG_CHECK8 ("INSN_DELETED_P", (RTX), DEBUG_INSN, INSN, \ + CALL_INSN, JUMP_INSN, JUMP_TABLE_DATA, \ + CODE_LABEL, BARRIER, NOTE)->volatil) /* 1 if RTX is a call to a const function. Built from ECF_CONST and TREE_READONLY. */ #define RTL_CONST_CALL_P(RTX) \ - (RTL_FLAG_CHECK1("RTL_CONST_CALL_P", (RTX), CALL_INSN)->unchanging) + (RTL_FLAG_CHECK1 ("RTL_CONST_CALL_P", (RTX), CALL_INSN)->unchanging) /* 1 if RTX is a call to a pure function. Built from ECF_PURE and DECL_PURE_P. */ #define RTL_PURE_CALL_P(RTX) \ - (RTL_FLAG_CHECK1("RTL_PURE_CALL_P", (RTX), CALL_INSN)->return_val) + (RTL_FLAG_CHECK1 ("RTL_PURE_CALL_P", (RTX), CALL_INSN)->return_val) /* 1 if RTX is a call to a const or pure function. */ #define RTL_CONST_OR_PURE_CALL_P(RTX) \ - (RTL_CONST_CALL_P(RTX) || RTL_PURE_CALL_P(RTX)) + (RTL_CONST_CALL_P (RTX) || RTL_PURE_CALL_P (RTX)) /* 1 if RTX is a call to a looping const or pure function. Built from ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P. */ #define RTL_LOOPING_CONST_OR_PURE_CALL_P(RTX) \ - (RTL_FLAG_CHECK1("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN)->call) + (RTL_FLAG_CHECK1 ("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN)->call) /* 1 if RTX is a call_insn for a sibling call. */ #define SIBLING_CALL_P(RTX) \ - (RTL_FLAG_CHECK1("SIBLING_CALL_P", (RTX), CALL_INSN)->jump) + (RTL_FLAG_CHECK1 ("SIBLING_CALL_P", (RTX), CALL_INSN)->jump) /* 1 if RTX is a jump_insn, call_insn, or insn that is an annulling branch. */ #define INSN_ANNULLED_BRANCH_P(RTX) \ - (RTL_FLAG_CHECK1("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN)->unchanging) + (RTL_FLAG_CHECK1 ("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN)->unchanging) /* 1 if RTX is an insn in a delay slot and is from the target of the branch. If the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be executed if the branch is taken. For annulled branches with this bit clear, the insn should be executed only if the branch is not taken. */ #define INSN_FROM_TARGET_P(RTX) \ - (RTL_FLAG_CHECK3("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, CALL_INSN)->in_struct) + (RTL_FLAG_CHECK3 ("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, \ + CALL_INSN)->in_struct) /* In an ADDR_DIFF_VEC, the flags for RTX for use by branch shortening. See the comments for ADDR_DIFF_VEC in rtl.def. */ -#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS(RTX, 4) +#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS (RTX, 4) /* In a VALUE, the value cselib has assigned to RTX. This is a "struct cselib_val_struct", see cselib.h. */ -#define CSELIB_VAL_PTR(RTX) X0CSELIB(RTX, 0) +#define CSELIB_VAL_PTR(RTX) X0CSELIB (RTX, 0) /* Holds a list of notes on what this insn does to various REGs. It is a chain of EXPR_LIST rtx's, where the second operand is the @@ -1003,7 +1004,7 @@ extern const char * const reg_note_name[]; /* 1 if RTX is emitted after a call, but it should take effect before the call returns. */ #define NOTE_DURING_CALL_P(RTX) \ - (RTL_FLAG_CHECK1("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call) + (RTL_FLAG_CHECK1 ("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call) /* DEBUG_EXPR_DECL corresponding to a DEBUG_EXPR RTX. */ #define DEBUG_EXPR_TREE_DECL(RTX) XCTREE (RTX, 0, DEBUG_EXPR) @@ -1109,7 +1110,8 @@ enum label_kind /* For a REG rtx, REGNO extracts the register number. REGNO can only be used on RHS. Use SET_REGNO to change the value. */ #define REGNO(RTX) (rhs_regno(RTX)) -#define SET_REGNO(RTX,N) (df_ref_change_reg_with_loc (REGNO(RTX), N, RTX), XCUINT (RTX, 0, REG) = N) +#define SET_REGNO(RTX,N) \ + (df_ref_change_reg_with_loc (REGNO (RTX), N, RTX), XCUINT (RTX, 0, REG) = N) #define SET_REGNO_RAW(RTX,N) (XCUINT (RTX, 0, REG) = N) /* ORIGINAL_REGNO holds the number the register originally had; for a @@ -1128,19 +1130,19 @@ rhs_regno (const_rtx x) /* 1 if RTX is a reg or parallel that is the current function's return value. */ #define REG_FUNCTION_VALUE_P(RTX) \ - (RTL_FLAG_CHECK2("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val) + (RTL_FLAG_CHECK2 ("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val) /* 1 if RTX is a reg that corresponds to a variable declared by the user. */ #define REG_USERVAR_P(RTX) \ - (RTL_FLAG_CHECK1("REG_USERVAR_P", (RTX), REG)->volatil) + (RTL_FLAG_CHECK1 ("REG_USERVAR_P", (RTX), REG)->volatil) /* 1 if RTX is a reg that holds a pointer value. */ #define REG_POINTER(RTX) \ - (RTL_FLAG_CHECK1("REG_POINTER", (RTX), REG)->frame_related) + (RTL_FLAG_CHECK1 ("REG_POINTER", (RTX), REG)->frame_related) /* 1 if RTX is a mem that holds a pointer value. */ #define MEM_POINTER(RTX) \ - (RTL_FLAG_CHECK1("MEM_POINTER", (RTX), MEM)->frame_related) + (RTL_FLAG_CHECK1 ("MEM_POINTER", (RTX), MEM)->frame_related) /* 1 if the given register REG corresponds to a hard register. */ #define HARD_REGISTER_P(REG) (HARD_REGISTER_NUM_P (REGNO (REG))) @@ -1149,7 +1151,7 @@ rhs_regno (const_rtx x) #define HARD_REGISTER_NUM_P(REG_NO) ((REG_NO) < FIRST_PSEUDO_REGISTER) /* For a CONST_INT rtx, INTVAL extracts the integer. */ -#define INTVAL(RTX) XCWINT(RTX, 0, CONST_INT) +#define INTVAL(RTX) XCWINT (RTX, 0, CONST_INT) #define UINTVAL(RTX) ((unsigned HOST_WIDE_INT) INTVAL (RTX)) /* For a CONST_DOUBLE: @@ -1165,9 +1167,9 @@ rhs_regno (const_rtx x) #define CONST_FIXED_VALUE(r) \ ((const struct fixed_value *) XCNMPFV (r, CONST_FIXED, VOIDmode)) #define CONST_FIXED_VALUE_HIGH(r) \ - ((HOST_WIDE_INT) (CONST_FIXED_VALUE(r)->data.high)) + ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.high)) #define CONST_FIXED_VALUE_LOW(r) \ - ((HOST_WIDE_INT) (CONST_FIXED_VALUE(r)->data.low)) + ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.low)) /* For a CONST_VECTOR, return element #n. */ #define CONST_VECTOR_ELT(RTX, N) XCVECEXP (RTX, 0, N, CONST_VECTOR) @@ -1387,11 +1389,12 @@ get_full_set_src_cost (rtx x, struct full_rtx_costs *c) when assigning to SUBREG_REG. */ #define SUBREG_PROMOTED_VAR_P(RTX) \ - (RTL_FLAG_CHECK1("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct) + (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct) #define SUBREG_PROMOTED_UNSIGNED_SET(RTX, VAL) \ do { \ - rtx const _rtx = RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_SET", (RTX), SUBREG); \ + rtx const _rtx = RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_UNSIGNED_SET", \ + (RTX), SUBREG); \ if ((VAL) < 0) \ _rtx->volatil = 1; \ else { \ @@ -1409,13 +1412,13 @@ do { \ emit special code (ptr_extend insns) on some architectures. */ #define SUBREG_PROMOTED_UNSIGNED_P(RTX) \ - ((RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) \ + ((RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) \ ? -1 : (int) (RTX)->unchanging) /* True if the subreg was generated by LRA for reload insns. Such subregs are valid only during LRA. */ #define LRA_SUBREG_P(RTX) \ - (RTL_FLAG_CHECK1("LRA_SUBREG_P", (RTX), SUBREG)->jump) + (RTL_FLAG_CHECK1 ("LRA_SUBREG_P", (RTX), SUBREG)->jump) /* Access various components of an ASM_OPERANDS rtx. */ @@ -1440,22 +1443,22 @@ do { \ /* 1 if RTX is a mem that is statically allocated in read-only memory. */ #define MEM_READONLY_P(RTX) \ - (RTL_FLAG_CHECK1("MEM_READONLY_P", (RTX), MEM)->unchanging) + (RTL_FLAG_CHECK1 ("MEM_READONLY_P", (RTX), MEM)->unchanging) /* 1 if RTX is a mem and we should keep the alias set for this mem unchanged when we access a component. Set to 1, or example, when we are already in a non-addressable component of an aggregate. */ #define MEM_KEEP_ALIAS_SET_P(RTX) \ - (RTL_FLAG_CHECK1("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump) + (RTL_FLAG_CHECK1 ("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump) /* 1 if RTX is a mem or asm_operand for a volatile reference. */ #define MEM_VOLATILE_P(RTX) \ - (RTL_FLAG_CHECK3("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \ - ASM_INPUT)->volatil) + (RTL_FLAG_CHECK3 ("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \ + ASM_INPUT)->volatil) /* 1 if RTX is a mem that cannot trap. */ #define MEM_NOTRAP_P(RTX) \ - (RTL_FLAG_CHECK1("MEM_NOTRAP_P", (RTX), MEM)->call) + (RTL_FLAG_CHECK1 ("MEM_NOTRAP_P", (RTX), MEM)->call) /* The memory attribute block. We provide access macros for each value in the block and provide defaults if none specified. */ @@ -1521,25 +1524,24 @@ do { \ /* Likewise in an expr_list for a REG_LABEL_OPERAND or REG_LABEL_TARGET note. */ #define LABEL_REF_NONLOCAL_P(RTX) \ - (RTL_FLAG_CHECK1("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil) + (RTL_FLAG_CHECK1 ("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil) /* 1 if RTX is a code_label that should always be considered to be needed. */ #define LABEL_PRESERVE_P(RTX) \ - (RTL_FLAG_CHECK2("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct) + (RTL_FLAG_CHECK2 ("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct) /* During sched, 1 if RTX is an insn that must be scheduled together with the preceding insn. */ #define SCHED_GROUP_P(RTX) \ - (RTL_FLAG_CHECK4("SCHED_GROUP_P", (RTX), DEBUG_INSN, INSN, \ - JUMP_INSN, CALL_INSN \ - )->in_struct) + (RTL_FLAG_CHECK4 ("SCHED_GROUP_P", (RTX), DEBUG_INSN, INSN, \ + JUMP_INSN, CALL_INSN)->in_struct) /* For a SET rtx, SET_DEST is the place that is set and SET_SRC is the value it is set to. */ -#define SET_DEST(RTX) XC2EXP(RTX, 0, SET, CLOBBER) -#define SET_SRC(RTX) XCEXP(RTX, 1, SET) +#define SET_DEST(RTX) XC2EXP (RTX, 0, SET, CLOBBER) +#define SET_SRC(RTX) XCEXP (RTX, 1, SET) #define SET_IS_RETURN_P(RTX) \ - (RTL_FLAG_CHECK1("SET_IS_RETURN_P", (RTX), SET)->jump) + (RTL_FLAG_CHECK1 ("SET_IS_RETURN_P", (RTX), SET)->jump) /* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */ #define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF) @@ -1554,26 +1556,26 @@ do { \ /* 1 if RTX is a symbol_ref that addresses this function's rtl constants pool. */ #define CONSTANT_POOL_ADDRESS_P(RTX) \ - (RTL_FLAG_CHECK1("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging) + (RTL_FLAG_CHECK1 ("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging) /* 1 if RTX is a symbol_ref that addresses a value in the file's tree constant pool. This information is private to varasm.c. */ #define TREE_CONSTANT_POOL_ADDRESS_P(RTX) \ - (RTL_FLAG_CHECK1("TREE_CONSTANT_POOL_ADDRESS_P", \ - (RTX), SYMBOL_REF)->frame_related) + (RTL_FLAG_CHECK1 ("TREE_CONSTANT_POOL_ADDRESS_P", \ + (RTX), SYMBOL_REF)->frame_related) /* Used if RTX is a symbol_ref, for machine-specific purposes. */ #define SYMBOL_REF_FLAG(RTX) \ - (RTL_FLAG_CHECK1("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil) + (RTL_FLAG_CHECK1 ("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil) /* 1 if RTX is a symbol_ref that has been the library function in emit_library_call. */ #define SYMBOL_REF_USED(RTX) \ - (RTL_FLAG_CHECK1("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used) + (RTL_FLAG_CHECK1 ("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used) /* 1 if RTX is a symbol_ref for a weak symbol. */ #define SYMBOL_REF_WEAK(RTX) \ - (RTL_FLAG_CHECK1("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val) + (RTL_FLAG_CHECK1 ("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val) /* A pointer attached to the SYMBOL_REF; either SYMBOL_REF_DECL or SYMBOL_REF_CONSTANT. */ @@ -1656,7 +1658,7 @@ do { \ /* True if RTX is flagged to be a scheduling barrier. */ #define PREFETCH_SCHEDULE_BARRIER_P(RTX) \ - (RTL_FLAG_CHECK1("PREFETCH_SCHEDULE_BARRIER_P", (RTX), PREFETCH)->volatil) + (RTL_FLAG_CHECK1 ("PREFETCH_SCHEDULE_BARRIER_P", (RTX), PREFETCH)->volatil) /* Indicate whether the machine has any sort of auto increment addressing. If not, we can avoid checking for REG_INC notes. */ @@ -2072,7 +2074,7 @@ extern bool insn_could_throw_p (const_rtx); extern bool insn_nothrow_p (const_rtx); extern bool can_nonlocal_goto (const_rtx); extern void copy_reg_eh_region_note_forward (rtx, rtx, rtx); -extern void copy_reg_eh_region_note_backward(rtx, rtx, rtx); +extern void copy_reg_eh_region_note_backward (rtx, rtx, rtx); extern int inequality_comparisons_p (const_rtx); extern rtx replace_rtx (rtx, rtx, rtx); extern int replace_label (rtx *, void *); diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c index 7b2ec2406c0..9769b69bdb5 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -3713,7 +3713,7 @@ keep_with_call_p (const_rtx insn) /* This CONST_CAST is okay because next_nonnote_insn just returns its argument and we assign it to a const_rtx variable. */ - const_rtx i2 = next_nonnote_insn (CONST_CAST_RTX(insn)); + const_rtx i2 = next_nonnote_insn (CONST_CAST_RTX (insn)); if (i2 && keep_with_call_p (i2)) return true; } diff --git a/gcc/sbitmap.c b/gcc/sbitmap.c index bc77d43a617..ceadd09edda 100644 --- a/gcc/sbitmap.c +++ b/gcc/sbitmap.c @@ -30,15 +30,15 @@ along with GCC; see the file COPYING3. If not see #if GCC_VERSION >= 3400 # if SBITMAP_ELT_BITS == HOST_BITS_PER_LONG -# define do_popcount(x) __builtin_popcountl(x) +# define do_popcount(x) __builtin_popcountl (x) # elif SBITMAP_ELT_BITS == HOST_BITS_PER_LONGLONG -# define do_popcount(x) __builtin_popcountll(x) +# define do_popcount(x) __builtin_popcountll (x) # else # error "internal error: sbitmap.h and hwint.h are inconsistent" # endif #else static unsigned long sbitmap_elt_popcount (SBITMAP_ELT_TYPE); -# define do_popcount(x) sbitmap_elt_popcount((x)) +# define do_popcount(x) sbitmap_elt_popcount (x) #endif typedef SBITMAP_ELT_TYPE *sbitmap_ptr; diff --git a/gcc/sched-rgn.c b/gcc/sched-rgn.c index e1a2dce16a2..bf9b10df3a9 100644 --- a/gcc/sched-rgn.c +++ b/gcc/sched-rgn.c @@ -3638,8 +3638,8 @@ const pass_data pass_data_sched = class pass_sched : public rtl_opt_pass { public: - pass_sched(gcc::context *ctxt) - : rtl_opt_pass(pass_data_sched, ctxt) + pass_sched (gcc::context *ctxt) + : rtl_opt_pass (pass_data_sched, ctxt) {} /* opt_pass methods: */ @@ -3677,8 +3677,8 @@ const pass_data pass_data_sched2 = class pass_sched2 : public rtl_opt_pass { public: - pass_sched2(gcc::context *ctxt) - : rtl_opt_pass(pass_data_sched2, ctxt) + pass_sched2 (gcc::context *ctxt) + : rtl_opt_pass (pass_data_sched2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/sdbout.c b/gcc/sdbout.c index 13c11c29682..1eedde3f520 100644 --- a/gcc/sdbout.c +++ b/gcc/sdbout.c @@ -155,7 +155,7 @@ static void sdbout_global_decl (tree); #endif #ifndef PUT_SDB_SCL -#define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM) +#define PUT_SDB_SCL(a) fprintf (asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM) #endif #ifndef PUT_SDB_INT_VAL @@ -182,15 +182,16 @@ do { fprintf (asm_out_file, "\t.def\t"); \ #endif #ifndef PUT_SDB_PLAIN_DEF -#define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM) +#define PUT_SDB_PLAIN_DEF(a) \ + fprintf (asm_out_file, "\t.def\t.%s%s", a, SDB_DELIM) #endif #ifndef PUT_SDB_ENDEF -#define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file) +#define PUT_SDB_ENDEF fputs ("\t.endef\n", asm_out_file) #endif #ifndef PUT_SDB_TYPE -#define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM) +#define PUT_SDB_TYPE(a) fprintf (asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM) #endif #ifndef PUT_SDB_SIZE @@ -198,19 +199,19 @@ do { fprintf (asm_out_file, "\t.def\t"); \ do { \ fprintf (asm_out_file, "\t.size\t" HOST_WIDE_INT_PRINT_DEC "%s", \ (HOST_WIDE_INT) (a), SDB_DELIM); \ - } while(0) + } while (0) #endif #ifndef PUT_SDB_START_DIM -#define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t") +#define PUT_SDB_START_DIM fprintf (asm_out_file, "\t.dim\t") #endif #ifndef PUT_SDB_NEXT_DIM -#define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a) +#define PUT_SDB_NEXT_DIM(a) fprintf (asm_out_file, "%d,", a) #endif #ifndef PUT_SDB_LAST_DIM -#define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM) +#define PUT_SDB_LAST_DIM(a) fprintf (asm_out_file, "%d%s", a, SDB_DELIM) #endif #ifndef PUT_SDB_TAG diff --git a/gcc/sel-sched-ir.c b/gcc/sel-sched-ir.c index 47e769534db..4eb27c5da5d 100644 --- a/gcc/sel-sched-ir.c +++ b/gcc/sel-sched-ir.c @@ -4881,7 +4881,7 @@ in_same_ebb_p (insn_t insn, insn_t succ) { basic_block ptr = BLOCK_FOR_INSN (insn); - for(;;) + for (;;) { if (ptr == BLOCK_FOR_INSN (succ)) return true; diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c index 46c66b4f3ed..08fdc772292 100644 --- a/gcc/sel-sched.c +++ b/gcc/sel-sched.c @@ -509,12 +509,12 @@ typedef vec<vinsn_t> vinsn_vec_t; can't be moved up due to bookkeeping created during code motion to another fence. See comment near the call to update_and_record_unavailable_insns for the detailed explanations. */ -static vinsn_vec_t vec_bookkeeping_blocked_vinsns = vinsn_vec_t(); +static vinsn_vec_t vec_bookkeeping_blocked_vinsns = vinsn_vec_t (); /* This vector has vinsns which are scheduled with renaming on the first fence and then seen on the second. For expressions with such vinsns, target availability information may be wrong. */ -static vinsn_vec_t vec_target_unavailable_vinsns = vinsn_vec_t(); +static vinsn_vec_t vec_target_unavailable_vinsns = vinsn_vec_t (); /* Vector to store temporary nops inserted in move_op to prevent removal of empty bbs. */ @@ -809,7 +809,7 @@ count_occurrences_1 (rtx *cur_rtx, void *arg) /* Bail out if mode is different or more than one register is used. */ if (GET_MODE (*cur_rtx) != GET_MODE (p->x) || (HARD_REGISTER_P (*cur_rtx) - && hard_regno_nregs[REGNO(*cur_rtx)][GET_MODE (*cur_rtx)] > 1)) + && hard_regno_nregs[REGNO (*cur_rtx)][GET_MODE (*cur_rtx)] > 1)) { p->n = 0; return 1; diff --git a/gcc/sparseset.c b/gcc/sparseset.c index 3c25a6de355..279c22bf72b 100644 --- a/gcc/sparseset.c +++ b/gcc/sparseset.c @@ -30,7 +30,7 @@ sparseset_alloc (SPARSESET_ELT_TYPE n_elms) unsigned int n_bytes = sizeof (struct sparseset_def) + ((n_elms - 1) * 2 * sizeof (SPARSESET_ELT_TYPE)); - sparseset set = XNEWVAR(struct sparseset_def, n_bytes); + sparseset set = XNEWVAR (struct sparseset_def, n_bytes); /* Mark the sparseset as defined to silence some valgrind uninitialized read errors when accessing set->sparse[n] when "n" is not, and never has diff --git a/gcc/stack-ptr-mod.c b/gcc/stack-ptr-mod.c index 737a07f5727..68ccd1619ed 100644 --- a/gcc/stack-ptr-mod.c +++ b/gcc/stack-ptr-mod.c @@ -110,8 +110,8 @@ const pass_data pass_data_stack_ptr_mod = class pass_stack_ptr_mod : public rtl_opt_pass { public: - pass_stack_ptr_mod(gcc::context *ctxt) - : rtl_opt_pass(pass_data_stack_ptr_mod, ctxt) + pass_stack_ptr_mod (gcc::context *ctxt) + : rtl_opt_pass (pass_data_stack_ptr_mod, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/statistics.c b/gcc/statistics.c index b198b3455fa..62590ba3528 100644 --- a/gcc/statistics.c +++ b/gcc/statistics.c @@ -76,7 +76,7 @@ stats_counter_hasher::equal (const value_type *c1, const compare_type *c2) inline void stats_counter_hasher::remove (value_type *v) { - free (CONST_CAST(char *, v->id)); + free (CONST_CAST (char *, v->id)); free (v); } diff --git a/gcc/stmt.c b/gcc/stmt.c index c56e419312b..2e17db1cfae 100644 --- a/gcc/stmt.c +++ b/gcc/stmt.c @@ -1641,11 +1641,11 @@ dump_case_nodes (FILE *f, struct case_node *root, fputs (";; ", f); if (high == low) - fprintf(f, "%*s" HOST_WIDE_INT_PRINT_DEC, - indent_step * indent_level, "", low); + fprintf (f, "%*s" HOST_WIDE_INT_PRINT_DEC, + indent_step * indent_level, "", low); else - fprintf(f, "%*s" HOST_WIDE_INT_PRINT_DEC " ... " HOST_WIDE_INT_PRINT_DEC, - indent_step * indent_level, "", low, high); + fprintf (f, "%*s" HOST_WIDE_INT_PRINT_DEC " ... " HOST_WIDE_INT_PRINT_DEC, + indent_step * indent_level, "", low, high); fputs ("\n", f); dump_case_nodes (f, root->right, indent_step, indent_level); @@ -1802,7 +1802,7 @@ get_outgoing_edge_probs (basic_block bb) int prob_sum = 0; if (!bb) return 0; - FOR_EACH_EDGE(e, ei, bb->succs) + FOR_EACH_EDGE (e, ei, bb->succs) prob_sum += e->probability; return prob_sum; } @@ -1851,7 +1851,7 @@ emit_case_dispatch_table (tree index_expr, tree index_type, rtx fallback_label = label_rtx (case_list->code_label); rtx table_label = gen_label_rtx (); bool has_gaps = false; - edge default_edge = stmt_bb ? EDGE_SUCC(stmt_bb, 0) : NULL; + edge default_edge = stmt_bb ? EDGE_SUCC (stmt_bb, 0) : NULL; int default_prob = default_edge ? default_edge->probability : 0; int base = get_outgoing_edge_probs (stmt_bb); bool try_with_tablejump = false; @@ -1976,7 +1976,7 @@ reset_out_edges_aux (basic_block bb) { edge e; edge_iterator ei; - FOR_EACH_EDGE(e, ei, bb->succs) + FOR_EACH_EDGE (e, ei, bb->succs) e->aux = (void *)0; } @@ -2042,7 +2042,7 @@ expand_case (gimple stmt) /* Find the default case target label. */ default_label = label_rtx (CASE_LABEL (gimple_switch_default_label (stmt))); - edge default_edge = EDGE_SUCC(bb, 0); + edge default_edge = EDGE_SUCC (bb, 0); int default_prob = default_edge->probability; /* Get upper and lower bounds of case values. */ diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index 6f6b3107841..02998365804 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -1352,7 +1352,7 @@ place_field (record_layout_info rli, tree field) /* Cause a new bitfield to be captured, either this time (if currently a bitfield) or next time we see one. */ - if (!DECL_BIT_FIELD_TYPE(field) + if (!DECL_BIT_FIELD_TYPE (field) || integer_zerop (DECL_SIZE (field))) rli->prev_field = NULL; } diff --git a/gcc/store-motion.c b/gcc/store-motion.c index e0b58477d4c..68f293c6252 100644 --- a/gcc/store-motion.c +++ b/gcc/store-motion.c @@ -271,7 +271,7 @@ store_ops_ok (const_rtx x, int *regs_set) for (; x; x = XEXP (x, 1)) { reg = XEXP (x, 0); - if (regs_set[REGNO(reg)]) + if (regs_set[REGNO (reg)]) return false; } @@ -1256,8 +1256,8 @@ const pass_data pass_data_rtl_store_motion = class pass_rtl_store_motion : public rtl_opt_pass { public: - pass_rtl_store_motion(gcc::context *ctxt) - : rtl_opt_pass(pass_data_rtl_store_motion, ctxt) + pass_rtl_store_motion (gcc::context *ctxt) + : rtl_opt_pass (pass_data_rtl_store_motion, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/streamer-hooks.h b/gcc/streamer-hooks.h index 11e00b20155..d989cc90452 100644 --- a/gcc/streamer-hooks.h +++ b/gcc/streamer-hooks.h @@ -61,19 +61,19 @@ struct streamer_hooks { }; #define stream_write_tree(OB, EXPR, REF_P) \ - streamer_hooks.write_tree(OB, EXPR, REF_P, REF_P) + streamer_hooks.write_tree (OB, EXPR, REF_P, REF_P) #define stream_write_tree_shallow_non_ref(OB, EXPR, REF_P) \ - streamer_hooks.write_tree(OB, EXPR, REF_P, false) + streamer_hooks.write_tree (OB, EXPR, REF_P, false) #define stream_read_tree(IB, DATA_IN) \ - streamer_hooks.read_tree(IB, DATA_IN) + streamer_hooks.read_tree (IB, DATA_IN) #define stream_input_location(BP, DATA_IN) \ - streamer_hooks.input_location(BP, DATA_IN) + streamer_hooks.input_location (BP, DATA_IN) #define stream_output_location(OB, BP, LOC) \ - streamer_hooks.output_location(OB, BP, LOC) + streamer_hooks.output_location (OB, BP, LOC) /* Streamer hooks. */ extern struct streamer_hooks streamer_hooks; diff --git a/gcc/system.h b/gcc/system.h index b735a96c10b..fab1c7bb32f 100644 --- a/gcc/system.h +++ b/gcc/system.h @@ -27,7 +27,7 @@ along with GCC; see the file COPYING3. If not see #ifndef va_copy # ifdef __va_copy -# define va_copy(d,s) __va_copy((d),(s)) +# define va_copy(d,s) __va_copy (d, s) # else # define va_copy(d,s) ((d) = (s)) # endif @@ -53,9 +53,9 @@ along with GCC; see the file COPYING3. If not see #undef fopen #undef freopen -#define fopen(PATH,MODE) fopen_unlocked(PATH,MODE) -#define fdopen(FILDES,MODE) fdopen_unlocked(FILDES,MODE) -#define freopen(PATH,MODE,STREAM) freopen_unlocked(PATH,MODE,STREAM) +#define fopen(PATH, MODE) fopen_unlocked (PATH, MODE) +#define fdopen(FILDES, MODE) fdopen_unlocked (FILDES, MODE) +#define freopen(PATH, MODE, STREAM) freopen_unlocked (PATH, MODE, STREAM) /* The compiler is not a multi-threaded application and therefore we do not have to use the locking functions. In fact, using the locking @@ -294,7 +294,7 @@ extern int errno; /* The outer cast is needed to work around a bug in Cray C 5.0.3.0. It is necessary at least when t == time_t. */ #define INTTYPE_MINIMUM(t) ((t) (INTTYPE_SIGNED (t) \ - ? ~ (t) 0 << (sizeof(t) * CHAR_BIT - 1) : (t) 0)) + ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0)) #define INTTYPE_MAXIMUM(t) ((t) (~ (t) 0 - INTTYPE_MINIMUM (t))) /* Use that infrastructure to provide a few constants. */ @@ -536,7 +536,7 @@ extern int snprintf (char *, size_t, const char *, ...); #endif #if defined (HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF -extern int vsnprintf(char *, size_t, const char *, va_list); +extern int vsnprintf (char *, size_t, const char *, va_list); #endif #ifdef __cplusplus @@ -611,11 +611,11 @@ extern int vsnprintf(char *, size_t, const char *, va_list); /* Some systems have mkdir that takes a single argument. */ #ifdef MKDIR_TAKES_ONE_ARG -# define mkdir(a,b) mkdir(a) +# define mkdir(a,b) mkdir (a) #endif #ifndef HAVE_KILL -# define kill(p,s) raise(s) +# define kill(p,s) raise (s) #endif /* Provide a way to print an address via printf. */ @@ -693,7 +693,7 @@ extern void fancy_abort (const char *, int, const char *) ATTRIBUTE_NORETURN; ((void)(!(EXPR) ? fancy_abort (__FILE__, __LINE__, __FUNCTION__), 0 : 0)) #elif (GCC_VERSION >= 4005) #define gcc_assert(EXPR) \ - ((void)(__builtin_expect(!(EXPR), 0) ? __builtin_unreachable(), 0 : 0)) + ((void)(__builtin_expect (!(EXPR), 0) ? __builtin_unreachable (), 0 : 0)) #else /* Include EXPR, so that unused variable warnings do not occur. */ #define gcc_assert(EXPR) ((void)(0 && (EXPR))) @@ -708,7 +708,7 @@ extern void fancy_abort (const char *, int, const char *) ATTRIBUTE_NORETURN; /* Use gcc_unreachable() to mark unreachable locations (like an unreachable default case of a switch. Do not use gcc_assert(0). */ #if (GCC_VERSION >= 4005) && !ENABLE_ASSERT_CHECKING -#define gcc_unreachable() __builtin_unreachable() +#define gcc_unreachable() __builtin_unreachable () #else #define gcc_unreachable() (fancy_abort (__FILE__, __LINE__, __FUNCTION__)) #endif @@ -1011,11 +1011,11 @@ helper_const_non_const_cast (const char *p) #define CONST_CAST2(TOTYPE,FROMTYPE,X) ((TOTYPE)(FROMTYPE)(X)) #endif #endif -#define CONST_CAST(TYPE,X) CONST_CAST2(TYPE, const TYPE, (X)) -#define CONST_CAST_TREE(X) CONST_CAST(union tree_node *, (X)) -#define CONST_CAST_RTX(X) CONST_CAST(struct rtx_def *, (X)) -#define CONST_CAST_BB(X) CONST_CAST(struct basic_block_def *, (X)) -#define CONST_CAST_GIMPLE(X) CONST_CAST(union gimple_statement_d *, (X)) +#define CONST_CAST(TYPE,X) CONST_CAST2 (TYPE, const TYPE, (X)) +#define CONST_CAST_TREE(X) CONST_CAST (union tree_node *, (X)) +#define CONST_CAST_RTX(X) CONST_CAST (struct rtx_def *, (X)) +#define CONST_CAST_BB(X) CONST_CAST (struct basic_block_def *, (X)) +#define CONST_CAST_GIMPLE(X) CONST_CAST (union gimple_statement_d *, (X)) /* Activate certain diagnostics as warnings (not errors via the -Werror flag). */ diff --git a/gcc/target-hooks-macros.h b/gcc/target-hooks-macros.h index fb392c292d5..602b2a42d28 100644 --- a/gcc/target-hooks-macros.h +++ b/gcc/target-hooks-macros.h @@ -37,7 +37,7 @@ HOOK_VECTOR_END: Close a struct declaration, providing a member declarator name for nested use. */ #ifndef HOOK_VECTOR_1 -#define HOOK_VECTOR_1(NAME, FRAGMENT) HOOKSTRUCT(FRAGMENT) +#define HOOK_VECTOR_1(NAME, FRAGMENT) HOOKSTRUCT (FRAGMENT) #endif #define HOOK_VECTOR(INIT_NAME, SNAME) HOOK_VECTOR_1 (INIT_NAME, struct SNAME {) #define HOOK_VECTOR_END(DECL_NAME) HOOK_VECTOR_1(,} DECL_NAME ;) diff --git a/gcc/targhooks.c b/gcc/targhooks.c index 798aacf73a0..ec73a6406d2 100644 --- a/gcc/targhooks.c +++ b/gcc/targhooks.c @@ -93,7 +93,7 @@ void default_external_libcall (rtx fun ATTRIBUTE_UNUSED) { #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL - ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun); + ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun); #endif } @@ -1427,7 +1427,7 @@ default_debug_unwind_info (void) mode for registers used in apply_builtin_return and apply_builtin_arg. */ enum machine_mode -default_get_reg_raw_mode(int regno) +default_get_reg_raw_mode (int regno) { return reg_raw_mode[regno]; } diff --git a/gcc/targhooks.h b/gcc/targhooks.h index aaddae93209..b3bd15503cd 100644 --- a/gcc/targhooks.h +++ b/gcc/targhooks.h @@ -193,7 +193,7 @@ extern int default_label_align_max_skip (rtx); extern int default_jump_align_max_skip (rtx); extern section * default_function_section(tree decl, enum node_frequency freq, bool startup, bool exit); -extern enum machine_mode default_get_reg_raw_mode(int); +extern enum machine_mode default_get_reg_raw_mode (int); extern void *default_get_pch_validity (size_t *); extern const char *default_pch_valid_p (const void *, size_t); diff --git a/gcc/toplev.c b/gcc/toplev.c index 3473211efb1..feba0510f61 100644 --- a/gcc/toplev.c +++ b/gcc/toplev.c @@ -706,17 +706,19 @@ print_version (FILE *file, const char *indent) two string formats, "i.j.k" and "i.j" when k is zero. As of gmp-4.3.0, GMP always uses the 3 number format. */ #define GCC_GMP_STRINGIFY_VERSION3(X) #X -#define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X) +#define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X) #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z)) #define GCC_GMP_VERSION \ GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL) #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0 -#define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \ - GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) +#define GCC_GMP_STRINGIFY_VERSION \ + GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \ + GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) #else -#define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \ - GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \ - GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL) +#define GCC_GMP_STRINGIFY_VERSION \ + GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \ + GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \ + GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL) #endif fprintf (file, file == stderr ? _(fmt2) : fmt2, @@ -1170,11 +1172,11 @@ general_init (const char *argv0) /* This must be done after global_init_params but before argument processing. */ - init_ggc_heuristics(); + init_ggc_heuristics (); /* Create the singleton holder for global state. Doing so also creates the pass manager and with it the passes. */ - g = new gcc::context(); + g = new gcc::context (); statistics_early_init (); finish_params (); diff --git a/gcc/tracer.c b/gcc/tracer.c index aa1736c685e..57055662ea5 100644 --- a/gcc/tracer.c +++ b/gcc/tracer.c @@ -417,8 +417,8 @@ const pass_data pass_data_tracer = class pass_tracer : public gimple_opt_pass { public: - pass_tracer(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tracer, ctxt) + pass_tracer (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tracer, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/trans-mem.c b/gcc/trans-mem.c index fbc876a5386..82f3ee08a39 100644 --- a/gcc/trans-mem.c +++ b/gcc/trans-mem.c @@ -821,8 +821,8 @@ const pass_data pass_data_diagnose_tm_blocks = class pass_diagnose_tm_blocks : public gimple_opt_pass { public: - pass_diagnose_tm_blocks(gcc::context *ctxt) - : gimple_opt_pass(pass_data_diagnose_tm_blocks, ctxt) + pass_diagnose_tm_blocks (gcc::context *ctxt) + : gimple_opt_pass (pass_data_diagnose_tm_blocks, ctxt) {} /* opt_pass methods: */ @@ -1631,7 +1631,7 @@ lower_transaction (gimple_stmt_iterator *gsi, struct walk_stmt_info *wi) /* If the transaction calls abort or if this is an outer transaction, add an "over" label afterwards. */ if ((this_state & (GTMA_HAVE_ABORT)) - || (gimple_transaction_subcode(stmt) & GTMA_IS_OUTER)) + || (gimple_transaction_subcode (stmt) & GTMA_IS_OUTER)) { tree label = create_artificial_label (UNKNOWN_LOCATION); gimple_transaction_set_label (stmt, label); @@ -1744,8 +1744,8 @@ const pass_data pass_data_lower_tm = class pass_lower_tm : public gimple_opt_pass { public: - pass_lower_tm(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_tm, ctxt) + pass_lower_tm (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_tm, ctxt) {} /* opt_pass methods: */ @@ -2024,8 +2024,8 @@ const pass_data pass_data_tm_init = class pass_tm_init : public gimple_opt_pass { public: - pass_tm_init(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tm_init, ctxt) + pass_tm_init (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tm_init, ctxt) {} /* opt_pass methods: */ @@ -2753,8 +2753,8 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED) ei->probability = PROB_ALWAYS; et->probability = PROB_LIKELY; ef->probability = PROB_UNLIKELY; - et->count = apply_probability(test_bb->count, et->probability); - ef->count = apply_probability(test_bb->count, ef->probability); + et->count = apply_probability (test_bb->count, et->probability); + ef->count = apply_probability (test_bb->count, ef->probability); code_bb->count = et->count; code_bb->frequency = EDGE_FREQUENCY (et); @@ -2793,14 +2793,14 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED) fallthru_edge->flags = EDGE_FALSE_VALUE; fallthru_edge->probability = PROB_VERY_LIKELY; fallthru_edge->count - = apply_probability(test_bb->count, fallthru_edge->probability); + = apply_probability (test_bb->count, fallthru_edge->probability); // Abort/over edge. redirect_edge_pred (abort_edge, test_bb); abort_edge->flags = EDGE_TRUE_VALUE; abort_edge->probability = PROB_VERY_UNLIKELY; abort_edge->count - = apply_probability(test_bb->count, abort_edge->probability); + = apply_probability (test_bb->count, abort_edge->probability); transaction_bb = test_bb; } @@ -2842,13 +2842,13 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED) inst_edge->flags = EDGE_FALSE_VALUE; inst_edge->probability = REG_BR_PROB_BASE / 2; inst_edge->count - = apply_probability(test_bb->count, inst_edge->probability); + = apply_probability (test_bb->count, inst_edge->probability); redirect_edge_pred (uninst_edge, test_bb); uninst_edge->flags = EDGE_TRUE_VALUE; uninst_edge->probability = REG_BR_PROB_BASE / 2; uninst_edge->count - = apply_probability(test_bb->count, uninst_edge->probability); + = apply_probability (test_bb->count, uninst_edge->probability); } // If we have no previous special cases, and we have PHIs at the beginning @@ -3000,8 +3000,8 @@ const pass_data pass_data_tm_mark = class pass_tm_mark : public gimple_opt_pass { public: - pass_tm_mark(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tm_mark, ctxt) + pass_tm_mark (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tm_mark, ctxt) {} /* opt_pass methods: */ @@ -3183,8 +3183,8 @@ const pass_data pass_data_tm_edges = class pass_tm_edges : public gimple_opt_pass { public: - pass_tm_edges(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tm_edges, ctxt) + pass_tm_edges (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tm_edges, ctxt) {} /* opt_pass methods: */ @@ -3923,8 +3923,8 @@ const pass_data pass_data_tm_memopt = class pass_tm_memopt : public gimple_opt_pass { public: - pass_tm_memopt(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tm_memopt, ctxt) + pass_tm_memopt (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tm_memopt, ctxt) {} /* opt_pass methods: */ @@ -4287,7 +4287,7 @@ ipa_tm_scan_irr_block (basic_block bb) if (find_tm_replacement_function (fn)) break; - node = cgraph_get_node(fn); + node = cgraph_get_node (fn); d = get_cg_data (&node, true); /* Return true if irrevocable, but above all, believe @@ -4991,7 +4991,7 @@ ipa_tm_insert_gettmclone_call (struct cgraph_node *node, cgraph_create_edge (node, cgraph_get_create_node (gettm_fn), g, 0, compute_call_stmt_bb_frequency (node->symbol.decl, - gimple_bb(g))); + gimple_bb (g))); /* Cast return value from tm_gettmclone* into appropriate function pointer. */ @@ -5272,9 +5272,9 @@ ipa_tm_transform_clone (struct cgraph_node *node) static unsigned int ipa_tm_execute (void) { - cgraph_node_queue tm_callees = cgraph_node_queue(); + cgraph_node_queue tm_callees = cgraph_node_queue (); /* List of functions that will go irrevocable. */ - cgraph_node_queue irr_worklist = cgraph_node_queue(); + cgraph_node_queue irr_worklist = cgraph_node_queue (); struct cgraph_node *node; struct tm_ipa_cg_data *d; @@ -5558,8 +5558,8 @@ const pass_data pass_data_ipa_tm = class pass_ipa_tm : public simple_ipa_opt_pass { public: - pass_ipa_tm(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_tm, ctxt) + pass_ipa_tm (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_tm, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-browser.c b/gcc/tree-browser.c index b236cabd8df..dad06a5175a 100644 --- a/gcc/tree-browser.c +++ b/gcc/tree-browser.c @@ -46,7 +46,7 @@ struct tb_command { TB_CODE comm_code; }; -#define DEFTBCODE(code, str, help) { help, str, sizeof(str) - 1, code }, +#define DEFTBCODE(code, str, help) { help, str, sizeof (str) - 1, code }, static const struct tb_command tb_commands[] = { #include "tree-browser.def" diff --git a/gcc/tree-call-cdce.c b/gcc/tree-call-cdce.c index cf4116e68ae..c38f694a5db 100644 --- a/gcc/tree-call-cdce.c +++ b/gcc/tree-call-cdce.c @@ -946,8 +946,8 @@ const pass_data pass_data_call_cdce = class pass_call_cdce : public gimple_opt_pass { public: - pass_call_cdce(gcc::context *ctxt) - : gimple_opt_pass(pass_data_call_cdce, ctxt) + pass_call_cdce (gcc::context *ctxt) + : gimple_opt_pass (pass_data_call_cdce, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-cfg.c b/gcc/tree-cfg.c index d1a6c31c27d..be661818340 100644 --- a/gcc/tree-cfg.c +++ b/gcc/tree-cfg.c @@ -273,8 +273,8 @@ const pass_data pass_data_build_cfg = class pass_build_cfg : public gimple_opt_pass { public: - pass_build_cfg(gcc::context *ctxt) - : gimple_opt_pass(pass_data_build_cfg, ctxt) + pass_build_cfg (gcc::context *ctxt) + : gimple_opt_pass (pass_data_build_cfg, ctxt) {} /* opt_pass methods: */ @@ -3360,7 +3360,7 @@ verify_gimple_assign_unary (gimple stmt) { if ((!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type)) && (!VECTOR_INTEGER_TYPE_P (rhs1_type) - || !VECTOR_FLOAT_TYPE_P(lhs_type))) + || !VECTOR_FLOAT_TYPE_P (lhs_type))) { error ("invalid types in conversion to floating point"); debug_generic_expr (lhs_type); @@ -3375,7 +3375,7 @@ verify_gimple_assign_unary (gimple stmt) { if ((!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type)) && (!VECTOR_INTEGER_TYPE_P (lhs_type) - || !VECTOR_FLOAT_TYPE_P(rhs1_type))) + || !VECTOR_FLOAT_TYPE_P (rhs1_type))) { error ("invalid types in conversion to integer"); debug_generic_expr (lhs_type); @@ -7957,8 +7957,8 @@ const pass_data pass_data_split_crit_edges = class pass_split_crit_edges : public gimple_opt_pass { public: - pass_split_crit_edges(gcc::context *ctxt) - : gimple_opt_pass(pass_data_split_crit_edges, ctxt) + pass_split_crit_edges (gcc::context *ctxt) + : gimple_opt_pass (pass_data_split_crit_edges, ctxt) {} /* opt_pass methods: */ @@ -8129,8 +8129,8 @@ const pass_data pass_data_warn_function_return = class pass_warn_function_return : public gimple_opt_pass { public: - pass_warn_function_return(gcc::context *ctxt) - : gimple_opt_pass(pass_data_warn_function_return, ctxt) + pass_warn_function_return (gcc::context *ctxt) + : gimple_opt_pass (pass_data_warn_function_return, ctxt) {} /* opt_pass methods: */ @@ -8183,8 +8183,8 @@ const pass_data pass_data_warn_function_noreturn = class pass_warn_function_noreturn : public gimple_opt_pass { public: - pass_warn_function_noreturn(gcc::context *ctxt) - : gimple_opt_pass(pass_data_warn_function_noreturn, ctxt) + pass_warn_function_noreturn (gcc::context *ctxt) + : gimple_opt_pass (pass_data_warn_function_noreturn, ctxt) {} /* opt_pass methods: */ @@ -8300,8 +8300,8 @@ const pass_data pass_data_warn_unused_result = class pass_warn_unused_result : public gimple_opt_pass { public: - pass_warn_unused_result(gcc::context *ctxt) - : gimple_opt_pass(pass_data_warn_unused_result, ctxt) + pass_warn_unused_result (gcc::context *ctxt) + : gimple_opt_pass (pass_data_warn_unused_result, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-cfgcleanup.c b/gcc/tree-cfgcleanup.c index e0acbed8ef2..37d6d03822b 100644 --- a/gcc/tree-cfgcleanup.c +++ b/gcc/tree-cfgcleanup.c @@ -1009,8 +1009,8 @@ const pass_data pass_data_merge_phi = class pass_merge_phi : public gimple_opt_pass { public: - pass_merge_phi(gcc::context *ctxt) - : gimple_opt_pass(pass_data_merge_phi, ctxt) + pass_merge_phi (gcc::context *ctxt) + : gimple_opt_pass (pass_data_merge_phi, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c index 91798ecdee6..0f26ab68de9 100644 --- a/gcc/tree-complex.c +++ b/gcc/tree-complex.c @@ -1657,8 +1657,8 @@ const pass_data pass_data_lower_complex = class pass_lower_complex : public gimple_opt_pass { public: - pass_lower_complex(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_complex, ctxt) + pass_lower_complex (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_complex, ctxt) {} /* opt_pass methods: */ @@ -1704,8 +1704,8 @@ const pass_data pass_data_lower_complex_O0 = class pass_lower_complex_O0 : public gimple_opt_pass { public: - pass_lower_complex_O0(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_complex_O0, ctxt) + pass_lower_complex_O0 (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_complex_O0, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-data-ref.c b/gcc/tree-data-ref.c index 71d6d6774c2..530f00d82d0 100644 --- a/gcc/tree-data-ref.c +++ b/gcc/tree-data-ref.c @@ -1136,13 +1136,13 @@ common_affine_function (conflict_function *cf) affine_fn comm; if (!CF_NONTRIVIAL_P (cf)) - return affine_fn(); + return affine_fn (); comm = cf->fns[0]; for (i = 1; i < cf->n; i++) if (!affine_function_equal_p (comm, cf->fns[i])) - return affine_fn(); + return affine_fn (); return comm; } @@ -1637,12 +1637,12 @@ conflict_fn (unsigned n, ...) va_list ap; gcc_assert (0 < n && n <= MAX_DIM); - va_start(ap, n); + va_start (ap, n); ret->n = n; for (i = 0; i < n; i++) ret->fns[i] = va_arg (ap, affine_fn); - va_end(ap); + va_end (ap); return ret; } diff --git a/gcc/tree-data-ref.h b/gcc/tree-data-ref.h index 0763382bf8c..14a5a21af83 100644 --- a/gcc/tree-data-ref.h +++ b/gcc/tree-data-ref.h @@ -144,7 +144,7 @@ struct access_matrix #define AM_NB_INDUCTION_VARS(M) (M)->nb_induction_vars #define AM_PARAMETERS(M) (M)->parameters #define AM_MATRIX(M) (M)->matrix -#define AM_NB_PARAMETERS(M) (AM_PARAMETERS(M)).length () +#define AM_NB_PARAMETERS(M) (AM_PARAMETERS (M)).length () #define AM_CONST_COLUMN_INDEX(M) (AM_NB_INDUCTION_VARS (M) + AM_NB_PARAMETERS (M)) #define AM_NB_COLUMNS(M) (AM_NB_INDUCTION_VARS (M) + AM_NB_PARAMETERS (M) + 1) #define AM_GET_SUBSCRIPT_ACCESS_VECTOR(M, I) AM_MATRIX (M)[I] @@ -162,7 +162,7 @@ am_vector_index_for_loop (struct access_matrix *access_matrix, int loop_num) if (l->num == loop_num) return i; - gcc_unreachable(); + gcc_unreachable (); } struct data_reference diff --git a/gcc/tree-eh.c b/gcc/tree-eh.c index 51eab57c716..e8462cff4a4 100644 --- a/gcc/tree-eh.c +++ b/gcc/tree-eh.c @@ -1737,7 +1737,7 @@ lower_try_finally (struct leh_state *state, gimple tp) { gimple_seq new_eh_seq = eh_seq; eh_seq = old_eh_seq; - gimple_seq_add_seq(&eh_seq, new_eh_seq); + gimple_seq_add_seq (&eh_seq, new_eh_seq); } } @@ -2177,8 +2177,8 @@ const pass_data pass_data_lower_eh = class pass_lower_eh : public gimple_opt_pass { public: - pass_lower_eh(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_eh, ctxt) + pass_lower_eh (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_eh, ctxt) {} /* opt_pass methods: */ @@ -3054,8 +3054,8 @@ const pass_data pass_data_refactor_eh = class pass_refactor_eh : public gimple_opt_pass { public: - pass_refactor_eh(gcc::context *ctxt) - : gimple_opt_pass(pass_data_refactor_eh, ctxt) + pass_refactor_eh (gcc::context *ctxt) + : gimple_opt_pass (pass_data_refactor_eh, ctxt) {} /* opt_pass methods: */ @@ -3281,8 +3281,8 @@ const pass_data pass_data_lower_resx = class pass_lower_resx : public gimple_opt_pass { public: - pass_lower_resx(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_resx, ctxt) + pass_lower_resx (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_resx, ctxt) {} /* opt_pass methods: */ @@ -3692,8 +3692,8 @@ const pass_data pass_data_lower_eh_dispatch = class pass_lower_eh_dispatch : public gimple_opt_pass { public: - pass_lower_eh_dispatch(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_eh_dispatch, ctxt) + pass_lower_eh_dispatch (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_eh_dispatch, ctxt) {} /* opt_pass methods: */ @@ -4536,8 +4536,8 @@ const pass_data pass_data_cleanup_eh = class pass_cleanup_eh : public gimple_opt_pass { public: - pass_cleanup_eh(gcc::context *ctxt) - : gimple_opt_pass(pass_data_cleanup_eh, ctxt) + pass_cleanup_eh (gcc::context *ctxt) + : gimple_opt_pass (pass_data_cleanup_eh, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-emutls.c b/gcc/tree-emutls.c index 23d50389b98..73592953912 100644 --- a/gcc/tree-emutls.c +++ b/gcc/tree-emutls.c @@ -606,7 +606,7 @@ static inline void clear_access_vars (void) { memset (access_vars.address (), 0, - access_vars.length () * sizeof(tree)); + access_vars.length () * sizeof (tree)); } /* Lower the entire function NODE. */ @@ -831,8 +831,8 @@ const pass_data pass_data_ipa_lower_emutls = class pass_ipa_lower_emutls : public simple_ipa_opt_pass { public: - pass_ipa_lower_emutls(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_lower_emutls, ctxt) + pass_ipa_lower_emutls (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_lower_emutls, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index cf96817649c..3f3c3be3830 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -569,8 +569,8 @@ extern void threadedge_initialize_values (void); extern void threadedge_finalize_values (void); extern vec<tree> ssa_name_values; #define SSA_NAME_VALUE(x) \ - (SSA_NAME_VERSION(x) < ssa_name_values.length () \ - ? ssa_name_values[SSA_NAME_VERSION(x)] \ + (SSA_NAME_VERSION (x) < ssa_name_values.length () \ + ? ssa_name_values[SSA_NAME_VERSION (x)] \ : NULL_TREE) extern void set_ssa_name_value (tree, tree); extern bool potentially_threadable_block (basic_block); diff --git a/gcc/tree-if-conv.c b/gcc/tree-if-conv.c index 4851023d27f..b487381e4be 100644 --- a/gcc/tree-if-conv.c +++ b/gcc/tree-if-conv.c @@ -1842,8 +1842,8 @@ const pass_data pass_data_if_conversion = class pass_if_conversion : public gimple_opt_pass { public: - pass_if_conversion(gcc::context *ctxt) - : gimple_opt_pass(pass_data_if_conversion, ctxt) + pass_if_conversion (gcc::context *ctxt) + : gimple_opt_pass (pass_data_if_conversion, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-into-ssa.c b/gcc/tree-into-ssa.c index d67b94e11bb..2fe710e1bfb 100644 --- a/gcc/tree-into-ssa.c +++ b/gcc/tree-into-ssa.c @@ -2402,8 +2402,8 @@ const pass_data pass_data_build_ssa = class pass_build_ssa : public gimple_opt_pass { public: - pass_build_ssa(gcc::context *ctxt) - : gimple_opt_pass(pass_data_build_ssa, ctxt) + pass_build_ssa (gcc::context *ctxt) + : gimple_opt_pass (pass_data_build_ssa, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-iterator.c b/gcc/tree-iterator.c index 7359684cf3c..53347b54dc6 100644 --- a/gcc/tree-iterator.c +++ b/gcc/tree-iterator.c @@ -39,7 +39,7 @@ alloc_stmt_list (void) if (!vec_safe_is_empty (stmt_list_cache)) { list = stmt_list_cache->pop (); - memset (list, 0, sizeof(struct tree_base)); + memset (list, 0, sizeof (struct tree_base)); TREE_SET_CODE (list, STATEMENT_LIST); } else diff --git a/gcc/tree-loop-distribution.c b/gcc/tree-loop-distribution.c index 51b6ef03b4e..b7cafeaa62a 100644 --- a/gcc/tree-loop-distribution.c +++ b/gcc/tree-loop-distribution.c @@ -240,7 +240,7 @@ dot_rdg (struct graph *rdg) { /* When debugging, you may want to enable the following code. */ #if 1 - FILE *file = popen("dot -Tx11", "w"); + FILE *file = popen ("dot -Tx11", "w"); if (!file) return; dot_rdg_1 (file, rdg); @@ -1784,8 +1784,8 @@ const pass_data pass_data_loop_distribution = class pass_loop_distribution : public gimple_opt_pass { public: - pass_loop_distribution(gcc::context *ctxt) - : gimple_opt_pass(pass_data_loop_distribution, ctxt) + pass_loop_distribution (gcc::context *ctxt) + : gimple_opt_pass (pass_data_loop_distribution, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-mudflap.c b/gcc/tree-mudflap.c index 439d22f312a..9616762f24e 100644 --- a/gcc/tree-mudflap.c +++ b/gcc/tree-mudflap.c @@ -1390,8 +1390,8 @@ const pass_data pass_data_mudflap_1 = class pass_mudflap_1 : public gimple_opt_pass { public: - pass_mudflap_1(gcc::context *ctxt) - : gimple_opt_pass(pass_data_mudflap_1, ctxt) + pass_mudflap_1 (gcc::context *ctxt) + : gimple_opt_pass (pass_data_mudflap_1, ctxt) {} /* opt_pass methods: */ @@ -1429,8 +1429,8 @@ const pass_data pass_data_mudflap_2 = class pass_mudflap_2 : public gimple_opt_pass { public: - pass_mudflap_2(gcc::context *ctxt) - : gimple_opt_pass(pass_data_mudflap_2, ctxt) + pass_mudflap_2 (gcc::context *ctxt) + : gimple_opt_pass (pass_data_mudflap_2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c index c4f9b808af5..c6703b78acf 100644 --- a/gcc/tree-nested.c +++ b/gcc/tree-nested.c @@ -2304,7 +2304,7 @@ remap_vla_decls (tree block, struct nesting_info *root) static bool fold_mem_refs (const void *e, void *data ATTRIBUTE_UNUSED) { - tree *ref_p = CONST_CAST2(tree *, const tree *, (const tree *)e); + tree *ref_p = CONST_CAST2 (tree *, const tree *, (const tree *)e); *ref_p = fold (*ref_p); return true; } diff --git a/gcc/tree-nomudflap.c b/gcc/tree-nomudflap.c index 6659f05f5b1..fe9ea6058bd 100644 --- a/gcc/tree-nomudflap.c +++ b/gcc/tree-nomudflap.c @@ -105,8 +105,8 @@ const pass_data pass_data_mudflap_1 = class pass_mudflap_1 : public gimple_opt_pass { public: - pass_mudflap_1(gcc::context *ctxt) - : gimple_opt_pass(pass_data_mudflap_1, ctxt) + pass_mudflap_1 (gcc::context *ctxt) + : gimple_opt_pass (pass_data_mudflap_1, ctxt) {} /* opt_pass methods: */ @@ -142,8 +142,8 @@ const pass_data pass_data_mudflap_2 = class pass_mudflap_2 : public gimple_opt_pass { public: - pass_mudflap_2(gcc::context *ctxt) - : gimple_opt_pass(pass_data_mudflap_2, ctxt) + pass_mudflap_2 (gcc::context *ctxt) + : gimple_opt_pass (pass_data_mudflap_2, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-nrv.c b/gcc/tree-nrv.c index 1961a297429..1fec697589c 100644 --- a/gcc/tree-nrv.c +++ b/gcc/tree-nrv.c @@ -289,8 +289,8 @@ const pass_data pass_data_nrv = class pass_nrv : public gimple_opt_pass { public: - pass_nrv(gcc::context *ctxt) - : gimple_opt_pass(pass_data_nrv, ctxt) + pass_nrv (gcc::context *ctxt) + : gimple_opt_pass (pass_data_nrv, ctxt) {} /* opt_pass methods: */ @@ -393,8 +393,8 @@ const pass_data pass_data_return_slot = class pass_return_slot : public gimple_opt_pass { public: - pass_return_slot(gcc::context *ctxt) - : gimple_opt_pass(pass_data_return_slot, ctxt) + pass_return_slot (gcc::context *ctxt) + : gimple_opt_pass (pass_data_return_slot, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-object-size.c b/gcc/tree-object-size.c index 44da78eeddc..9721457262b 100644 --- a/gcc/tree-object-size.c +++ b/gcc/tree-object-size.c @@ -392,7 +392,8 @@ alloc_object_size (const_gimple call, int object_size_type) if (!callee) return unknown[object_size_type]; - alloc_size = lookup_attribute ("alloc_size", TYPE_ATTRIBUTES (TREE_TYPE(callee))); + alloc_size = lookup_attribute ("alloc_size", + TYPE_ATTRIBUTES (TREE_TYPE (callee))); if (alloc_size && TREE_VALUE (alloc_size)) { tree p = TREE_VALUE (alloc_size); @@ -1282,8 +1283,8 @@ const pass_data pass_data_object_sizes = class pass_object_sizes : public gimple_opt_pass { public: - pass_object_sizes(gcc::context *ctxt) - : gimple_opt_pass(pass_data_object_sizes, ctxt) + pass_object_sizes (gcc::context *ctxt) + : gimple_opt_pass (pass_data_object_sizes, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-optimize.c b/gcc/tree-optimize.c index 0c278d0292c..66631464885 100644 --- a/gcc/tree-optimize.c +++ b/gcc/tree-optimize.c @@ -108,8 +108,8 @@ const pass_data pass_data_cleanup_cfg_post_optimizing = class pass_cleanup_cfg_post_optimizing : public gimple_opt_pass { public: - pass_cleanup_cfg_post_optimizing(gcc::context *ctxt) - : gimple_opt_pass(pass_data_cleanup_cfg_post_optimizing, ctxt) + pass_cleanup_cfg_post_optimizing (gcc::context *ctxt) + : gimple_opt_pass (pass_data_cleanup_cfg_post_optimizing, ctxt) {} /* opt_pass methods: */ @@ -250,8 +250,8 @@ const pass_data pass_data_fixup_cfg = class pass_fixup_cfg : public gimple_opt_pass { public: - pass_fixup_cfg(gcc::context *ctxt) - : gimple_opt_pass(pass_data_fixup_cfg, ctxt) + pass_fixup_cfg (gcc::context *ctxt) + : gimple_opt_pass (pass_data_fixup_cfg, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-pass.h b/gcc/tree-pass.h index ea1a62f4368..3400329b3c1 100644 --- a/gcc/tree-pass.h +++ b/gcc/tree-pass.h @@ -102,7 +102,7 @@ public: virtual unsigned int execute (); protected: - opt_pass(const pass_data&, gcc::context *); + opt_pass (const pass_data&, gcc::context *); public: /* A list of sub-passes to run, dependent on gate predicate. */ @@ -122,8 +122,8 @@ protected: class gimple_opt_pass : public opt_pass { protected: - gimple_opt_pass(const pass_data& data, gcc::context *ctxt) - : opt_pass(data, ctxt) + gimple_opt_pass (const pass_data& data, gcc::context *ctxt) + : opt_pass (data, ctxt) { } }; @@ -132,8 +132,8 @@ protected: class rtl_opt_pass : public opt_pass { protected: - rtl_opt_pass(const pass_data& data, gcc::context *ctxt) - : opt_pass(data, ctxt) + rtl_opt_pass (const pass_data& data, gcc::context *ctxt) + : opt_pass (data, ctxt) { } }; @@ -174,27 +174,26 @@ public: void (*variable_transform) (struct varpool_node *); protected: - ipa_opt_pass_d(const pass_data& data, gcc::context *ctxt, - void (*generate_summary) (void), - void (*write_summary) (void), - void (*read_summary) (void), - void (*write_optimization_summary) (void), - void (*read_optimization_summary) (void), - void (*stmt_fixup) (struct cgraph_node *, gimple *), - unsigned int function_transform_todo_flags_start, - unsigned int (*function_transform) (struct cgraph_node *), - void (*variable_transform) (struct varpool_node *)) - : opt_pass(data, ctxt), - generate_summary(generate_summary), - write_summary(write_summary), - read_summary(read_summary), - write_optimization_summary(write_optimization_summary), - read_optimization_summary(read_optimization_summary), - stmt_fixup(stmt_fixup), - function_transform_todo_flags_start( - function_transform_todo_flags_start), - function_transform(function_transform), - variable_transform(variable_transform) + ipa_opt_pass_d (const pass_data& data, gcc::context *ctxt, + void (*generate_summary) (void), + void (*write_summary) (void), + void (*read_summary) (void), + void (*write_optimization_summary) (void), + void (*read_optimization_summary) (void), + void (*stmt_fixup) (struct cgraph_node *, gimple *), + unsigned int function_transform_todo_flags_start, + unsigned int (*function_transform) (struct cgraph_node *), + void (*variable_transform) (struct varpool_node *)) + : opt_pass (data, ctxt), + generate_summary (generate_summary), + write_summary (write_summary), + read_summary (read_summary), + write_optimization_summary (write_optimization_summary), + read_optimization_summary (read_optimization_summary), + stmt_fixup (stmt_fixup), + function_transform_todo_flags_start (function_transform_todo_flags_start), + function_transform (function_transform), + variable_transform (variable_transform) { } }; @@ -204,8 +203,8 @@ protected: class simple_ipa_opt_pass : public opt_pass { protected: - simple_ipa_opt_pass(const pass_data& data, gcc::context *ctxt) - : opt_pass(data, ctxt) + simple_ipa_opt_pass (const pass_data& data, gcc::context *ctxt) + : opt_pass (data, ctxt) { } }; diff --git a/gcc/tree-pretty-print.c b/gcc/tree-pretty-print.c index bd6fd81d47e..c357b06f978 100644 --- a/gcc/tree-pretty-print.c +++ b/gcc/tree-pretty-print.c @@ -46,7 +46,7 @@ static void do_niy (pretty_printer *, const_tree); #define INDENT(SPACE) do { \ int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0) -#define NIY do_niy(buffer,node) +#define NIY do_niy (buffer, node) static pretty_printer buffer; static int initialized = 0; diff --git a/gcc/tree-profile.c b/gcc/tree-profile.c index a2c4209646f..a0e49b53047 100644 --- a/gcc/tree-profile.c +++ b/gcc/tree-profile.c @@ -607,7 +607,7 @@ tree_profiling (void) pop_cfun (); } - del_node_map(); + del_node_map (); return 0; } @@ -641,8 +641,8 @@ const pass_data pass_data_ipa_tree_profile = class pass_ipa_tree_profile : public simple_ipa_opt_pass { public: - pass_ipa_tree_profile(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_tree_profile, ctxt) + pass_ipa_tree_profile (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_tree_profile, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c index bda45a6f63b..06379024450 100644 --- a/gcc/tree-scalar-evolution.c +++ b/gcc/tree-scalar-evolution.c @@ -2071,7 +2071,7 @@ struct instantiate_cache_type htab_t map; vec<scev_info_str> entries; - instantiate_cache_type () : map (NULL), entries(vNULL) {} + instantiate_cache_type () : map (NULL), entries (vNULL) {} ~instantiate_cache_type (); tree get (unsigned slot) { return entries[slot].chrec; } void set (unsigned slot, tree chrec) { entries[slot].chrec = chrec; } diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c index 58c7565dcf6..a2529cb4b55 100644 --- a/gcc/tree-sra.c +++ b/gcc/tree-sra.c @@ -3468,8 +3468,8 @@ const pass_data pass_data_sra_early = class pass_sra_early : public gimple_opt_pass { public: - pass_sra_early(gcc::context *ctxt) - : gimple_opt_pass(pass_data_sra_early, ctxt) + pass_sra_early (gcc::context *ctxt) + : gimple_opt_pass (pass_data_sra_early, ctxt) {} /* opt_pass methods: */ @@ -3506,8 +3506,8 @@ const pass_data pass_data_sra = class pass_sra : public gimple_opt_pass { public: - pass_sra(gcc::context *ctxt) - : gimple_opt_pass(pass_data_sra, ctxt) + pass_sra (gcc::context *ctxt) + : gimple_opt_pass (pass_data_sra, ctxt) {} /* opt_pass methods: */ @@ -4292,7 +4292,7 @@ analyze_all_param_acesses (void) repr_state = splice_all_param_accesses (representatives); if (repr_state == NO_GOOD_ACCESS) - return ipa_parm_adjustment_vec(); + return ipa_parm_adjustment_vec (); /* If there are any parameters passed by reference which are not modified directly, we need to check whether they can be modified indirectly. */ @@ -4356,7 +4356,7 @@ analyze_all_param_acesses (void) adjustments = turn_representatives_into_adjustments (representatives, adjustments_count); else - adjustments = ipa_parm_adjustment_vec(); + adjustments = ipa_parm_adjustment_vec (); representatives.release (); return adjustments; @@ -4952,7 +4952,7 @@ ipa_sra_preliminary_function_checks (struct cgraph_node *node) } if ((DECL_COMDAT (node->symbol.decl) || DECL_EXTERNAL (node->symbol.decl)) - && inline_summary(node)->size >= MAX_INLINE_INSNS_AUTO) + && inline_summary (node)->size >= MAX_INLINE_INSNS_AUTO) { if (dump_file) fprintf (dump_file, "Function too big to be made truly local.\n"); @@ -5088,8 +5088,8 @@ const pass_data pass_data_early_ipa_sra = class pass_early_ipa_sra : public gimple_opt_pass { public: - pass_early_ipa_sra(gcc::context *ctxt) - : gimple_opt_pass(pass_data_early_ipa_sra, ctxt) + pass_early_ipa_sra (gcc::context *ctxt) + : gimple_opt_pass (pass_data_early_ipa_sra, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-ccp.c b/gcc/tree-ssa-ccp.c index 1f044063bb6..849e9e92702 100644 --- a/gcc/tree-ssa-ccp.c +++ b/gcc/tree-ssa-ccp.c @@ -2166,8 +2166,8 @@ const pass_data pass_data_ccp = class pass_ccp : public gimple_opt_pass { public: - pass_ccp(gcc::context *ctxt) - : gimple_opt_pass(pass_data_ccp, ctxt) + pass_ccp (gcc::context *ctxt) + : gimple_opt_pass (pass_data_ccp, ctxt) {} /* opt_pass methods: */ @@ -2583,8 +2583,8 @@ const pass_data pass_data_fold_builtins = class pass_fold_builtins : public gimple_opt_pass { public: - pass_fold_builtins(gcc::context *ctxt) - : gimple_opt_pass(pass_data_fold_builtins, ctxt) + pass_fold_builtins (gcc::context *ctxt) + : gimple_opt_pass (pass_data_fold_builtins, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-coalesce.c b/gcc/tree-ssa-coalesce.c index cfcd1e07b80..087272fe13a 100644 --- a/gcc/tree-ssa-coalesce.c +++ b/gcc/tree-ssa-coalesce.c @@ -635,7 +635,7 @@ new_live_track (var_map map) ptr->map = map; lim = num_basevars (map); bitmap_obstack_initialize (&ptr->obstack); - ptr->live_base_partitions = (bitmap *) xmalloc(sizeof (bitmap *) * lim); + ptr->live_base_partitions = (bitmap *) xmalloc (sizeof (bitmap *) * lim); ptr->live_base_var = BITMAP_ALLOC (&ptr->obstack); for (x = 0; x < lim; x++) ptr->live_base_partitions[x] = BITMAP_ALLOC (&ptr->obstack); diff --git a/gcc/tree-ssa-copy.c b/gcc/tree-ssa-copy.c index 2172a9a12bf..a20fc97f2ad 100644 --- a/gcc/tree-ssa-copy.c +++ b/gcc/tree-ssa-copy.c @@ -858,8 +858,8 @@ const pass_data pass_data_copy_prop = class pass_copy_prop : public gimple_opt_pass { public: - pass_copy_prop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_copy_prop, ctxt) + pass_copy_prop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_copy_prop, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c index f6e4b451541..f4395e44cb7 100644 --- a/gcc/tree-ssa-copyrename.c +++ b/gcc/tree-ssa-copyrename.c @@ -455,8 +455,8 @@ const pass_data pass_data_rename_ssa_copies = class pass_rename_ssa_copies : public gimple_opt_pass { public: - pass_rename_ssa_copies(gcc::context *ctxt) - : gimple_opt_pass(pass_data_rename_ssa_copies, ctxt) + pass_rename_ssa_copies (gcc::context *ctxt) + : gimple_opt_pass (pass_data_rename_ssa_copies, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-dce.c b/gcc/tree-ssa-dce.c index 8e8f37ce8c8..c132baf82ee 100644 --- a/gcc/tree-ssa-dce.c +++ b/gcc/tree-ssa-dce.c @@ -1560,8 +1560,8 @@ const pass_data pass_data_dce = class pass_dce : public gimple_opt_pass { public: - pass_dce(gcc::context *ctxt) - : gimple_opt_pass(pass_data_dce, ctxt) + pass_dce (gcc::context *ctxt) + : gimple_opt_pass (pass_data_dce, ctxt) {} /* opt_pass methods: */ @@ -1599,8 +1599,8 @@ const pass_data pass_data_dce_loop = class pass_dce_loop : public gimple_opt_pass { public: - pass_dce_loop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_dce_loop, ctxt) + pass_dce_loop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_dce_loop, ctxt) {} /* opt_pass methods: */ @@ -1638,8 +1638,8 @@ const pass_data pass_data_cd_dce = class pass_cd_dce : public gimple_opt_pass { public: - pass_cd_dce(gcc::context *ctxt) - : gimple_opt_pass(pass_data_cd_dce, ctxt) + pass_cd_dce (gcc::context *ctxt) + : gimple_opt_pass (pass_data_cd_dce, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-dom.c b/gcc/tree-ssa-dom.c index 81119c36891..495b6b8b957 100644 --- a/gcc/tree-ssa-dom.c +++ b/gcc/tree-ssa-dom.c @@ -935,8 +935,8 @@ const pass_data pass_data_dominator = class pass_dominator : public gimple_opt_pass { public: - pass_dominator(gcc::context *ctxt) - : gimple_opt_pass(pass_data_dominator, ctxt) + pass_dominator (gcc::context *ctxt) + : gimple_opt_pass (pass_data_dominator, ctxt) {} /* opt_pass methods: */ @@ -3128,8 +3128,8 @@ const pass_data pass_data_phi_only_cprop = class pass_phi_only_cprop : public gimple_opt_pass { public: - pass_phi_only_cprop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_phi_only_cprop, ctxt) + pass_phi_only_cprop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_phi_only_cprop, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-dse.c b/gcc/tree-ssa-dse.c index d0669504325..45c8b2f685f 100644 --- a/gcc/tree-ssa-dse.c +++ b/gcc/tree-ssa-dse.c @@ -375,8 +375,8 @@ const pass_data pass_data_dse = class pass_dse : public gimple_opt_pass { public: - pass_dse(gcc::context *ctxt) - : gimple_opt_pass(pass_data_dse, ctxt) + pass_dse (gcc::context *ctxt) + : gimple_opt_pass (pass_data_dse, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-forwprop.c b/gcc/tree-ssa-forwprop.c index ddcfe4c24be..ee8240e35f1 100644 --- a/gcc/tree-ssa-forwprop.c +++ b/gcc/tree-ssa-forwprop.c @@ -3177,9 +3177,9 @@ simplify_permutation (gimple_stmt_iterator *gsi) return 0; arg1 = arg0; } - opt = fold_ternary (VEC_PERM_EXPR, TREE_TYPE(op0), arg0, arg1, op2); + opt = fold_ternary (VEC_PERM_EXPR, TREE_TYPE (op0), arg0, arg1, op2); if (!opt - || (TREE_CODE (opt) != CONSTRUCTOR && TREE_CODE(opt) != VECTOR_CST)) + || (TREE_CODE (opt) != CONSTRUCTOR && TREE_CODE (opt) != VECTOR_CST)) return 0; gimple_assign_set_rhs_from_tree (gsi, opt); update_stmt (gsi_stmt (*gsi)); @@ -3560,8 +3560,8 @@ const pass_data pass_data_forwprop = class pass_forwprop : public gimple_opt_pass { public: - pass_forwprop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_forwprop, ctxt) + pass_forwprop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_forwprop, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-ifcombine.c b/gcc/tree-ssa-ifcombine.c index c45d42a891d..2a7745194e3 100644 --- a/gcc/tree-ssa-ifcombine.c +++ b/gcc/tree-ssa-ifcombine.c @@ -668,8 +668,8 @@ const pass_data pass_data_tree_ifcombine = class pass_tree_ifcombine : public gimple_opt_pass { public: - pass_tree_ifcombine(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tree_ifcombine, ctxt) + pass_tree_ifcombine (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tree_ifcombine, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-live.c b/gcc/tree-ssa-live.c index eb36a901faf..7705f1312b8 100644 --- a/gcc/tree-ssa-live.c +++ b/gcc/tree-ssa-live.c @@ -1237,7 +1237,7 @@ dump_var_map (FILE *f, var_map map) { if (t++ == 0) { - fprintf(f, "Partition %d (", x); + fprintf (f, "Partition %d (", x); print_generic_expr (f, partition_to_var (map, p), TDF_SLIM); fprintf (f, " - "); } diff --git a/gcc/tree-ssa-loop-ch.c b/gcc/tree-ssa-loop-ch.c index 0e87770b5b6..faa6bbcc585 100644 --- a/gcc/tree-ssa-loop-ch.c +++ b/gcc/tree-ssa-loop-ch.c @@ -277,8 +277,8 @@ const pass_data pass_data_ch = class pass_ch : public gimple_opt_pass { public: - pass_ch(gcc::context *ctxt) - : gimple_opt_pass(pass_data_ch, ctxt) + pass_ch (gcc::context *ctxt) + : gimple_opt_pass (pass_data_ch, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-loop-im.c b/gcc/tree-ssa-loop-im.c index c12ed7fb590..fc255289f24 100644 --- a/gcc/tree-ssa-loop-im.c +++ b/gcc/tree-ssa-loop-im.c @@ -227,7 +227,7 @@ get_lim_data (gimple stmt) static void free_lim_aux_data (struct lim_aux_data *data) { - data->depends.release(); + data->depends.release (); free (data); } @@ -1695,12 +1695,12 @@ for_all_locs_in_loop (struct loop *loop, mem_ref_p ref, FN fn) struct rewrite_mem_ref_loc { rewrite_mem_ref_loc (tree tmp_var_) : tmp_var (tmp_var_) {} - bool operator()(mem_ref_loc_p loc); + bool operator () (mem_ref_loc_p loc); tree tmp_var; }; bool -rewrite_mem_ref_loc::operator()(mem_ref_loc_p loc) +rewrite_mem_ref_loc::operator () (mem_ref_loc_p loc) { *loc->ref = tmp_var; update_stmt (loc->stmt); @@ -1720,12 +1720,12 @@ rewrite_mem_refs (struct loop *loop, mem_ref_p ref, tree tmp_var) struct first_mem_ref_loc_1 { first_mem_ref_loc_1 (mem_ref_loc_p *locp_) : locp (locp_) {} - bool operator()(mem_ref_loc_p loc); + bool operator () (mem_ref_loc_p loc); mem_ref_loc_p *locp; }; bool -first_mem_ref_loc_1::operator()(mem_ref_loc_p loc) +first_mem_ref_loc_1::operator () (mem_ref_loc_p loc) { *locp = loc; return true; @@ -2001,12 +2001,12 @@ execute_sm_if_changed (edge ex, tree mem, tree tmp_var, tree flag) struct sm_set_flag_if_changed { sm_set_flag_if_changed (tree flag_) : flag (flag_) {} - bool operator()(mem_ref_loc_p loc); + bool operator () (mem_ref_loc_p loc); tree flag; }; bool -sm_set_flag_if_changed::operator()(mem_ref_loc_p loc) +sm_set_flag_if_changed::operator () (mem_ref_loc_p loc) { /* Only set the flag for writes. */ if (is_gimple_assign (loc->stmt) @@ -2130,14 +2130,14 @@ struct ref_always_accessed { ref_always_accessed (struct loop *loop_, tree base_, bool stored_p_) : loop (loop_), base (base_), stored_p (stored_p_) {} - bool operator()(mem_ref_loc_p loc); + bool operator () (mem_ref_loc_p loc); struct loop *loop; tree base; bool stored_p; }; bool -ref_always_accessed::operator()(mem_ref_loc_p loc) +ref_always_accessed::operator () (mem_ref_loc_p loc) { struct loop *must_exec; diff --git a/gcc/tree-ssa-loop-ivopts.c b/gcc/tree-ssa-loop-ivopts.c index 5f80ce007c8..7b684a62819 100644 --- a/gcc/tree-ssa-loop-ivopts.c +++ b/gcc/tree-ssa-loop-ivopts.c @@ -3920,7 +3920,7 @@ get_loop_invariant_expr_id (struct ivopts_data *data, tree ubase, if (ratio == 1) { - if(operand_equal_p (ubase, cbase, 0)) + if (operand_equal_p (ubase, cbase, 0)) return -1; if (TREE_CODE (ubase) == ADDR_EXPR diff --git a/gcc/tree-ssa-loop-prefetch.c b/gcc/tree-ssa-loop-prefetch.c index bf313fe9152..d75155d15d6 100644 --- a/gcc/tree-ssa-loop-prefetch.c +++ b/gcc/tree-ssa-loop-prefetch.c @@ -555,7 +555,7 @@ gather_memory_references_ref (struct loop *loop, struct mem_ref_group **refs, fprintf (dump_file, "Memory expression %p\n",(void *) ref ); print_generic_expr (dump_file, ref, TDF_TREE); fprintf (dump_file,":"); - dump_mem_details( dump_file, base, step, delta, write_p); + dump_mem_details (dump_file, base, step, delta, write_p); fprintf (dump_file, "Ignoring %p, non-constant step prefetching is " "limited to inner most loops \n", @@ -572,7 +572,7 @@ gather_memory_references_ref (struct loop *loop, struct mem_ref_group **refs, fprintf (dump_file, "Memory expression %p\n",(void *) ref ); print_generic_expr (dump_file, ref, TDF_TREE); fprintf (dump_file,":"); - dump_mem_details(dump_file, base, step, delta, write_p); + dump_mem_details (dump_file, base, step, delta, write_p); fprintf (dump_file, "Not prefetching, ignoring %p due to " "loop variant step\n", diff --git a/gcc/tree-ssa-loop.c b/gcc/tree-ssa-loop.c index cb3eec8dd38..947f4d4782f 100644 --- a/gcc/tree-ssa-loop.c +++ b/gcc/tree-ssa-loop.c @@ -61,8 +61,8 @@ const pass_data pass_data_tree_loop = class pass_tree_loop : public gimple_opt_pass { public: - pass_tree_loop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tree_loop, ctxt) + pass_tree_loop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tree_loop, ctxt) {} /* opt_pass methods: */ @@ -117,8 +117,8 @@ const pass_data pass_data_tree_loop_init = class pass_tree_loop_init : public gimple_opt_pass { public: - pass_tree_loop_init(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tree_loop_init, ctxt) + pass_tree_loop_init (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tree_loop_init, ctxt) {} /* opt_pass methods: */ @@ -171,8 +171,8 @@ const pass_data pass_data_lim = class pass_lim : public gimple_opt_pass { public: - pass_lim(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lim, ctxt) + pass_lim (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lim, ctxt) {} /* opt_pass methods: */ @@ -227,8 +227,8 @@ const pass_data pass_data_tree_unswitch = class pass_tree_unswitch : public gimple_opt_pass { public: - pass_tree_unswitch(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tree_unswitch, ctxt) + pass_tree_unswitch (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tree_unswitch, ctxt) {} /* opt_pass methods: */ @@ -282,8 +282,8 @@ const pass_data pass_data_predcom = class pass_predcom : public gimple_opt_pass { public: - pass_predcom(gcc::context *ctxt) - : gimple_opt_pass(pass_data_predcom, ctxt) + pass_predcom (gcc::context *ctxt) + : gimple_opt_pass (pass_data_predcom, ctxt) {} /* opt_pass methods: */ @@ -337,8 +337,8 @@ const pass_data pass_data_vectorize = class pass_vectorize : public gimple_opt_pass { public: - pass_vectorize(gcc::context *ctxt) - : gimple_opt_pass(pass_data_vectorize, ctxt) + pass_vectorize (gcc::context *ctxt) + : gimple_opt_pass (pass_data_vectorize, ctxt) {} /* opt_pass methods: */ @@ -404,8 +404,8 @@ const pass_data pass_data_graphite = class pass_graphite : public gimple_opt_pass { public: - pass_graphite(gcc::context *ctxt) - : gimple_opt_pass(pass_data_graphite, ctxt) + pass_graphite (gcc::context *ctxt) + : gimple_opt_pass (pass_data_graphite, ctxt) {} /* opt_pass methods: */ @@ -441,8 +441,8 @@ const pass_data pass_data_graphite_transforms = class pass_graphite_transforms : public gimple_opt_pass { public: - pass_graphite_transforms(gcc::context *ctxt) - : gimple_opt_pass(pass_data_graphite_transforms, ctxt) + pass_graphite_transforms (gcc::context *ctxt) + : gimple_opt_pass (pass_data_graphite_transforms, ctxt) {} /* opt_pass methods: */ @@ -497,8 +497,8 @@ const pass_data pass_data_check_data_deps = class pass_check_data_deps : public gimple_opt_pass { public: - pass_check_data_deps(gcc::context *ctxt) - : gimple_opt_pass(pass_data_check_data_deps, ctxt) + pass_check_data_deps (gcc::context *ctxt) + : gimple_opt_pass (pass_data_check_data_deps, ctxt) {} /* opt_pass methods: */ @@ -552,8 +552,8 @@ const pass_data pass_data_iv_canon = class pass_iv_canon : public gimple_opt_pass { public: - pass_iv_canon(gcc::context *ctxt) - : gimple_opt_pass(pass_data_iv_canon, ctxt) + pass_iv_canon (gcc::context *ctxt) + : gimple_opt_pass (pass_data_iv_canon, ctxt) {} /* opt_pass methods: */ @@ -599,8 +599,8 @@ const pass_data pass_data_scev_cprop = class pass_scev_cprop : public gimple_opt_pass { public: - pass_scev_cprop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_scev_cprop, ctxt) + pass_scev_cprop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_scev_cprop, ctxt) {} /* opt_pass methods: */ @@ -650,8 +650,8 @@ const pass_data pass_data_record_bounds = class pass_record_bounds : public gimple_opt_pass { public: - pass_record_bounds(gcc::context *ctxt) - : gimple_opt_pass(pass_data_record_bounds, ctxt) + pass_record_bounds (gcc::context *ctxt) + : gimple_opt_pass (pass_data_record_bounds, ctxt) {} /* opt_pass methods: */ @@ -706,8 +706,8 @@ const pass_data pass_data_complete_unroll = class pass_complete_unroll : public gimple_opt_pass { public: - pass_complete_unroll(gcc::context *ctxt) - : gimple_opt_pass(pass_data_complete_unroll, ctxt) + pass_complete_unroll (gcc::context *ctxt) + : gimple_opt_pass (pass_data_complete_unroll, ctxt) {} /* opt_pass methods: */ @@ -771,8 +771,8 @@ const pass_data pass_data_complete_unrolli = class pass_complete_unrolli : public gimple_opt_pass { public: - pass_complete_unrolli(gcc::context *ctxt) - : gimple_opt_pass(pass_data_complete_unrolli, ctxt) + pass_complete_unrolli (gcc::context *ctxt) + : gimple_opt_pass (pass_data_complete_unrolli, ctxt) {} /* opt_pass methods: */ @@ -828,8 +828,8 @@ const pass_data pass_data_parallelize_loops = class pass_parallelize_loops : public gimple_opt_pass { public: - pass_parallelize_loops(gcc::context *ctxt) - : gimple_opt_pass(pass_data_parallelize_loops, ctxt) + pass_parallelize_loops (gcc::context *ctxt) + : gimple_opt_pass (pass_data_parallelize_loops, ctxt) {} /* opt_pass methods: */ @@ -883,8 +883,8 @@ const pass_data pass_data_loop_prefetch = class pass_loop_prefetch : public gimple_opt_pass { public: - pass_loop_prefetch(gcc::context *ctxt) - : gimple_opt_pass(pass_data_loop_prefetch, ctxt) + pass_loop_prefetch (gcc::context *ctxt) + : gimple_opt_pass (pass_data_loop_prefetch, ctxt) {} /* opt_pass methods: */ @@ -939,8 +939,8 @@ const pass_data pass_data_iv_optimize = class pass_iv_optimize : public gimple_opt_pass { public: - pass_iv_optimize(gcc::context *ctxt) - : gimple_opt_pass(pass_data_iv_optimize, ctxt) + pass_iv_optimize (gcc::context *ctxt) + : gimple_opt_pass (pass_data_iv_optimize, ctxt) {} /* opt_pass methods: */ @@ -988,8 +988,8 @@ const pass_data pass_data_tree_loop_done = class pass_tree_loop_done : public gimple_opt_pass { public: - pass_tree_loop_done(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tree_loop_done, ctxt) + pass_tree_loop_done (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tree_loop_done, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-math-opts.c b/gcc/tree-ssa-math-opts.c index 149e080ff19..f7f8ec91fce 100644 --- a/gcc/tree-ssa-math-opts.c +++ b/gcc/tree-ssa-math-opts.c @@ -657,8 +657,8 @@ const pass_data pass_data_cse_reciprocals = class pass_cse_reciprocals : public gimple_opt_pass { public: - pass_cse_reciprocals(gcc::context *ctxt) - : gimple_opt_pass(pass_data_cse_reciprocals, ctxt) + pass_cse_reciprocals (gcc::context *ctxt) + : gimple_opt_pass (pass_data_cse_reciprocals, ctxt) {} /* opt_pass methods: */ @@ -1575,8 +1575,8 @@ const pass_data pass_data_cse_sincos = class pass_cse_sincos : public gimple_opt_pass { public: - pass_cse_sincos(gcc::context *ctxt) - : gimple_opt_pass(pass_data_cse_sincos, ctxt) + pass_cse_sincos (gcc::context *ctxt) + : gimple_opt_pass (pass_data_cse_sincos, ctxt) {} /* opt_pass methods: */ @@ -2065,8 +2065,8 @@ const pass_data pass_data_optimize_bswap = class pass_optimize_bswap : public gimple_opt_pass { public: - pass_optimize_bswap(gcc::context *ctxt) - : gimple_opt_pass(pass_data_optimize_bswap, ctxt) + pass_optimize_bswap (gcc::context *ctxt) + : gimple_opt_pass (pass_data_optimize_bswap, ctxt) {} /* opt_pass methods: */ @@ -2871,8 +2871,8 @@ const pass_data pass_data_optimize_widening_mul = class pass_optimize_widening_mul : public gimple_opt_pass { public: - pass_optimize_widening_mul(gcc::context *ctxt) - : gimple_opt_pass(pass_data_optimize_widening_mul, ctxt) + pass_optimize_widening_mul (gcc::context *ctxt) + : gimple_opt_pass (pass_data_optimize_widening_mul, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index 7e02bd8bfb5..6bb36729617 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -1203,7 +1203,7 @@ verify_imm_links (FILE *f, tree var) fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr, (void *)ptr->use); print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM); - fprintf(f, "\n"); + fprintf (f, "\n"); return true; } @@ -1238,7 +1238,7 @@ dump_immediate_uses_for (FILE *file, tree var) else print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM); } - fprintf(file, "\n"); + fprintf (file, "\n"); } @@ -1253,7 +1253,7 @@ dump_immediate_uses (FILE *file) fprintf (file, "Immediate_uses: \n\n"); for (x = 1; x < num_ssa_names; x++) { - var = ssa_name(x); + var = ssa_name (x); if (!var) continue; dump_immediate_uses_for (file, var); diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c index 39d04ab2801..d9dbed3e71b 100644 --- a/gcc/tree-ssa-phiopt.c +++ b/gcc/tree-ssa-phiopt.c @@ -2034,8 +2034,8 @@ const pass_data pass_data_phiopt = class pass_phiopt : public gimple_opt_pass { public: - pass_phiopt(gcc::context *ctxt) - : gimple_opt_pass(pass_data_phiopt, ctxt) + pass_phiopt (gcc::context *ctxt) + : gimple_opt_pass (pass_data_phiopt, ctxt) {} /* opt_pass methods: */ @@ -2080,8 +2080,8 @@ const pass_data pass_data_cselim = class pass_cselim : public gimple_opt_pass { public: - pass_cselim(gcc::context *ctxt) - : gimple_opt_pass(pass_data_cselim, ctxt) + pass_cselim (gcc::context *ctxt) + : gimple_opt_pass (pass_data_cselim, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-phiprop.c b/gcc/tree-ssa-phiprop.c index 66b220fadd1..f3ea552795d 100644 --- a/gcc/tree-ssa-phiprop.c +++ b/gcc/tree-ssa-phiprop.c @@ -414,8 +414,8 @@ const pass_data pass_data_phiprop = class pass_phiprop : public gimple_opt_pass { public: - pass_phiprop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_phiprop, ctxt) + pass_phiprop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_phiprop, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-pre.c b/gcc/tree-ssa-pre.c index 6c813270eb6..243f37e70a8 100644 --- a/gcc/tree-ssa-pre.c +++ b/gcc/tree-ssa-pre.c @@ -360,10 +360,10 @@ typedef struct bitmap_set } *bitmap_set_t; #define FOR_EACH_EXPR_ID_IN_SET(set, id, bi) \ - EXECUTE_IF_SET_IN_BITMAP(&(set)->expressions, 0, (id), (bi)) + EXECUTE_IF_SET_IN_BITMAP (&(set)->expressions, 0, (id), (bi)) #define FOR_EACH_VALUE_ID_IN_SET(set, id, bi) \ - EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi)) + EXECUTE_IF_SET_IN_BITMAP (&(set)->values, 0, (id), (bi)) /* Mapping from value id to expressions with that value_id. */ static vec<bitmap> value_expressions; @@ -1344,7 +1344,7 @@ get_expr_type (const pre_expr e) case NARY: return PRE_EXPR_NARY (e)->type; } - gcc_unreachable(); + gcc_unreachable (); } /* Get a representative SSA_NAME for a given expression. @@ -1488,7 +1488,7 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, else { new_val_id = get_next_value_id (); - value_expressions.safe_grow_cleared (get_max_value_id() + 1); + value_expressions.safe_grow_cleared (get_max_value_id () + 1); nary = vn_nary_op_insert_pieces (newnary->length, newnary->opcode, newnary->type, @@ -1673,7 +1673,8 @@ phi_translate_1 (pre_expr expr, bitmap_set_t set1, bitmap_set_t set2, if (changed || !same_valid) { new_val_id = get_next_value_id (); - value_expressions.safe_grow_cleared(get_max_value_id() + 1); + value_expressions.safe_grow_cleared + (get_max_value_id () + 1); } else new_val_id = ref->value_id; @@ -4629,7 +4630,7 @@ init_pre (void) expressions.create (0); expressions.safe_push (NULL); value_expressions.create (get_max_value_id () + 1); - value_expressions.safe_grow_cleared (get_max_value_id() + 1); + value_expressions.safe_grow_cleared (get_max_value_id () + 1); name_to_id.create (0); inserted_exprs = BITMAP_ALLOC (NULL); @@ -4789,8 +4790,8 @@ const pass_data pass_data_pre = class pass_pre : public gimple_opt_pass { public: - pass_pre(gcc::context *ctxt) - : gimple_opt_pass(pass_data_pre, ctxt) + pass_pre (gcc::context *ctxt) + : gimple_opt_pass (pass_data_pre, ctxt) {} /* opt_pass methods: */ @@ -4859,8 +4860,8 @@ const pass_data pass_data_fre = class pass_fre : public gimple_opt_pass { public: - pass_fre(gcc::context *ctxt) - : gimple_opt_pass(pass_data_fre, ctxt) + pass_fre (gcc::context *ctxt) + : gimple_opt_pass (pass_data_fre, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-reassoc.c b/gcc/tree-ssa-reassoc.c index b378f57e8f5..62c46a14598 100644 --- a/gcc/tree-ssa-reassoc.c +++ b/gcc/tree-ssa-reassoc.c @@ -4480,8 +4480,8 @@ const pass_data pass_data_reassoc = class pass_reassoc : public gimple_opt_pass { public: - pass_reassoc(gcc::context *ctxt) - : gimple_opt_pass(pass_data_reassoc, ctxt) + pass_reassoc (gcc::context *ctxt) + : gimple_opt_pass (pass_data_reassoc, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-sink.c b/gcc/tree-ssa-sink.c index cc9cff886f7..e3d62fb9b4e 100644 --- a/gcc/tree-ssa-sink.c +++ b/gcc/tree-ssa-sink.c @@ -607,8 +607,8 @@ const pass_data pass_data_sink_code = class pass_sink_code : public gimple_opt_pass { public: - pass_sink_code(gcc::context *ctxt) - : gimple_opt_pass(pass_data_sink_code, ctxt) + pass_sink_code (gcc::context *ctxt) + : gimple_opt_pass (pass_data_sink_code, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c index c30ab33ef28..5df1ddf59bd 100644 --- a/gcc/tree-ssa-strlen.c +++ b/gcc/tree-ssa-strlen.c @@ -2098,8 +2098,8 @@ const pass_data pass_data_strlen = class pass_strlen : public gimple_opt_pass { public: - pass_strlen(gcc::context *ctxt) - : gimple_opt_pass(pass_data_strlen, ctxt) + pass_strlen (gcc::context *ctxt) + : gimple_opt_pass (pass_data_strlen, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c index 112fba636fb..46acc9ab9ad 100644 --- a/gcc/tree-ssa-structalias.c +++ b/gcc/tree-ssa-structalias.c @@ -1747,7 +1747,7 @@ do_complex_constraint (constraint_graph_t graph, constraint_t c, bitmap delta) { if (c->rhs.type == ADDRESSOF) { - gcc_unreachable(); + gcc_unreachable (); } else { @@ -2096,7 +2096,7 @@ label_visit (constraint_graph_t graph, struct scc_info *si, unsigned int n) } } else - bitmap_ior_into(graph->points_to[n], graph->points_to[w]); + bitmap_ior_into (graph->points_to[n], graph->points_to[w]); } } @@ -4301,8 +4301,8 @@ find_func_aliases_for_builtin_call (gimple t) rhsc.safe_push (nul); get_constraint_for (gimple_call_lhs (t), &lhsc); process_all_all_constraints (lhsc, rhsc); - lhsc.release(); - rhsc.release(); + lhsc.release (); + rhsc.release (); } return true; /* Trampolines are special - they set up passing the static @@ -6980,8 +6980,8 @@ const pass_data pass_data_build_alias = class pass_build_alias : public gimple_opt_pass { public: - pass_build_alias(gcc::context *ctxt) - : gimple_opt_pass(pass_data_build_alias, ctxt) + pass_build_alias (gcc::context *ctxt) + : gimple_opt_pass (pass_data_build_alias, ctxt) {} /* opt_pass methods: */ @@ -7020,8 +7020,8 @@ const pass_data pass_data_build_ealias = class pass_build_ealias : public gimple_opt_pass { public: - pass_build_ealias(gcc::context *ctxt) - : gimple_opt_pass(pass_data_build_ealias, ctxt) + pass_build_ealias (gcc::context *ctxt) + : gimple_opt_pass (pass_data_build_ealias, ctxt) {} /* opt_pass methods: */ @@ -7414,8 +7414,8 @@ const pass_data pass_data_ipa_pta = class pass_ipa_pta : public simple_ipa_opt_pass { public: - pass_ipa_pta(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_pta, ctxt) + pass_ipa_pta (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_pta, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-threadedge.c b/gcc/tree-ssa-threadedge.c index 467d9827a52..cf62785c316 100644 --- a/gcc/tree-ssa-threadedge.c +++ b/gcc/tree-ssa-threadedge.c @@ -1022,7 +1022,7 @@ thread_across_edge (gimple dummy_cond, for (unsigned int i = 0; i < path.length (); i++) delete path[i]; - path.release(); + path.release (); } BITMAP_FREE (visited); } diff --git a/gcc/tree-ssa-threadupdate.c b/gcc/tree-ssa-threadupdate.c index 75273ca3da5..05d56826a15 100644 --- a/gcc/tree-ssa-threadupdate.c +++ b/gcc/tree-ssa-threadupdate.c @@ -364,8 +364,8 @@ create_edge_and_update_destination_phis (struct redirection_data *rd, if (rd->outgoing_edge->aux) { e->aux = XNEWVEC (edge, 2); - THREAD_TARGET(e) = THREAD_TARGET (rd->outgoing_edge); - THREAD_TARGET2(e) = THREAD_TARGET2 (rd->outgoing_edge); + THREAD_TARGET (e) = THREAD_TARGET (rd->outgoing_edge); + THREAD_TARGET2 (e) = THREAD_TARGET2 (rd->outgoing_edge); } else { @@ -1306,7 +1306,7 @@ mark_threaded_blocks (bitmap threaded_blocks) else bitmap_copy (threaded_blocks, tmp); - BITMAP_FREE(tmp); + BITMAP_FREE (tmp); } diff --git a/gcc/tree-ssa-uncprop.c b/gcc/tree-ssa-uncprop.c index a13ccf01135..0bff196f899 100644 --- a/gcc/tree-ssa-uncprop.c +++ b/gcc/tree-ssa-uncprop.c @@ -603,8 +603,8 @@ const pass_data pass_data_uncprop = class pass_uncprop : public gimple_opt_pass { public: - pass_uncprop(gcc::context *ctxt) - : gimple_opt_pass(pass_data_uncprop, ctxt) + pass_uncprop (gcc::context *ctxt) + : gimple_opt_pass (pass_data_uncprop, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa-uninit.c b/gcc/tree-ssa-uninit.c index bd46ddfb18e..044efb34807 100644 --- a/gcc/tree-ssa-uninit.c +++ b/gcc/tree-ssa-uninit.c @@ -2193,8 +2193,8 @@ const pass_data pass_data_late_warn_uninitialized = class pass_late_warn_uninitialized : public gimple_opt_pass { public: - pass_late_warn_uninitialized(gcc::context *ctxt) - : gimple_opt_pass(pass_data_late_warn_uninitialized, ctxt) + pass_late_warn_uninitialized (gcc::context *ctxt) + : gimple_opt_pass (pass_data_late_warn_uninitialized, ctxt) {} /* opt_pass methods: */ @@ -2254,8 +2254,8 @@ const pass_data pass_data_early_warn_uninitialized = class pass_early_warn_uninitialized : public gimple_opt_pass { public: - pass_early_warn_uninitialized(gcc::context *ctxt) - : gimple_opt_pass(pass_data_early_warn_uninitialized, ctxt) + pass_early_warn_uninitialized (gcc::context *ctxt) + : gimple_opt_pass (pass_data_early_warn_uninitialized, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index 1452126d243..421e200da9f 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -1247,8 +1247,8 @@ const pass_data pass_data_init_datastructures = class pass_init_datastructures : public gimple_opt_pass { public: - pass_init_datastructures(gcc::context *ctxt) - : gimple_opt_pass(pass_data_init_datastructures, ctxt) + pass_init_datastructures (gcc::context *ctxt) + : gimple_opt_pass (pass_data_init_datastructures, ctxt) {} /* opt_pass methods: */ @@ -1778,8 +1778,8 @@ const pass_data pass_data_update_address_taken = class pass_update_address_taken : public gimple_opt_pass { public: - pass_update_address_taken(gcc::context *ctxt) - : gimple_opt_pass(pass_data_update_address_taken, ctxt) + pass_update_address_taken (gcc::context *ctxt) + : gimple_opt_pass (pass_data_update_address_taken, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c index d54d8c9e6de..a51f60307ec 100644 --- a/gcc/tree-ssanames.c +++ b/gcc/tree-ssanames.c @@ -553,8 +553,8 @@ const pass_data pass_data_release_ssa_names = class pass_release_ssa_names : public gimple_opt_pass { public: - pass_release_ssa_names(gcc::context *ctxt) - : gimple_opt_pass(pass_data_release_ssa_names, ctxt) + pass_release_ssa_names (gcc::context *ctxt) + : gimple_opt_pass (pass_data_release_ssa_names, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-stdarg.c b/gcc/tree-stdarg.c index 922835366b5..d7cd291f3a8 100644 --- a/gcc/tree-stdarg.c +++ b/gcc/tree-stdarg.c @@ -1005,8 +1005,8 @@ const pass_data pass_data_stdarg = class pass_stdarg : public gimple_opt_pass { public: - pass_stdarg(gcc::context *ctxt) - : gimple_opt_pass(pass_data_stdarg, ctxt) + pass_stdarg (gcc::context *ctxt) + : gimple_opt_pass (pass_data_stdarg, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-switch-conversion.c b/gcc/tree-switch-conversion.c index 2dd13fc9a54..a0d33067a8f 100644 --- a/gcc/tree-switch-conversion.c +++ b/gcc/tree-switch-conversion.c @@ -365,7 +365,7 @@ emit_case_bit_tests (gimple swtch, tree index_expr, test[k].lo |= (HOST_WIDE_INT) 1 << j; } - qsort (test, count, sizeof(*test), case_bit_test_cmp); + qsort (test, count, sizeof (*test), case_bit_test_cmp); /* We generate two jumps to the default case label. Split the default edge, so that we don't have to do any PHI node @@ -1485,8 +1485,8 @@ const pass_data pass_data_convert_switch = class pass_convert_switch : public gimple_opt_pass { public: - pass_convert_switch(gcc::context *ctxt) - : gimple_opt_pass(pass_data_convert_switch, ctxt) + pass_convert_switch (gcc::context *ctxt) + : gimple_opt_pass (pass_data_convert_switch, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-tailcall.c b/gcc/tree-tailcall.c index c91c9da0222..9e770cb8dbc 100644 --- a/gcc/tree-tailcall.c +++ b/gcc/tree-tailcall.c @@ -1083,8 +1083,8 @@ const pass_data pass_data_tail_recursion = class pass_tail_recursion : public gimple_opt_pass { public: - pass_tail_recursion(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tail_recursion, ctxt) + pass_tail_recursion (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tail_recursion, ctxt) {} /* opt_pass methods: */ @@ -1122,8 +1122,8 @@ const pass_data pass_data_tail_calls = class pass_tail_calls : public gimple_opt_pass { public: - pass_tail_calls(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tail_calls, ctxt) + pass_tail_calls (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tail_calls, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c index b8988d9d264..e7b2f334401 100644 --- a/gcc/tree-vect-data-refs.c +++ b/gcc/tree-vect-data-refs.c @@ -1223,7 +1223,7 @@ vect_peeling_hash_choose_best_peeling (loop_vec_info loop_vinfo, struct _vect_peel_extended_info res; res.peel_info.dr = NULL; - res.body_cost_vec = stmt_vector_for_cost(); + res.body_cost_vec = stmt_vector_for_cost (); if (!unlimited_cost_model ()) { @@ -1358,7 +1358,7 @@ vect_enhance_data_refs_alignment (loop_vec_info loop_vinfo) unsigned possible_npeel_number = 1; tree vectype; unsigned int nelements, mis, same_align_drs_max = 0; - stmt_vector_for_cost body_cost_vec = stmt_vector_for_cost(); + stmt_vector_for_cost body_cost_vec = stmt_vector_for_cost (); if (dump_enabled_p ()) dump_printf_loc (MSG_NOTE, vect_location, @@ -2538,7 +2538,7 @@ vect_analyze_data_ref_accesses (loop_vec_info loop_vinfo, bb_vec_info bb_vinfo) /* Sort the array of datarefs to make building the interleaving chains linear. */ - qsort (datarefs.address(), datarefs.length (), + qsort (datarefs.address (), datarefs.length (), sizeof (data_reference_p), dr_group_sort_cmp); /* Build the interleaving chains. */ diff --git a/gcc/tree-vect-generic.c b/gcc/tree-vect-generic.c index 4f67ca02467..07158fb05e9 100644 --- a/gcc/tree-vect-generic.c +++ b/gcc/tree-vect-generic.c @@ -1477,8 +1477,8 @@ const pass_data pass_data_lower_vector = class pass_lower_vector : public gimple_opt_pass { public: - pass_lower_vector(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_vector, ctxt) + pass_lower_vector (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_vector, ctxt) {} /* opt_pass methods: */ @@ -1518,8 +1518,8 @@ const pass_data pass_data_lower_vector_ssa = class pass_lower_vector_ssa : public gimple_opt_pass { public: - pass_lower_vector_ssa(gcc::context *ctxt) - : gimple_opt_pass(pass_data_lower_vector_ssa, ctxt) + pass_lower_vector_ssa (gcc::context *ctxt) + : gimple_opt_pass (pass_data_lower_vector_ssa, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-vect-loop-manip.c b/gcc/tree-vect-loop-manip.c index bd77473e9a3..574446a7dde 100644 --- a/gcc/tree-vect-loop-manip.c +++ b/gcc/tree-vect-loop-manip.c @@ -923,10 +923,10 @@ set_prologue_iterations (basic_block bb_before_first_loop, unshare_expr (LOOP_VINFO_NITERS_UNCHANGED (loop_vec_info_for_loop (loop))); e = single_pred_edge (bb_before_first_loop); - cond_bb = split_edge(e); + cond_bb = split_edge (e); e = single_pred_edge (bb_before_first_loop); - then_bb = split_edge(e); + then_bb = split_edge (e); set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb); e_false = make_single_succ_edge (cond_bb, bb_before_first_loop, @@ -2449,7 +2449,7 @@ vect_loop_versioning (loop_vec_info loop_vinfo, "alignment\n"); } - free_original_copy_tables(); + free_original_copy_tables (); /* Loop versioning violates an assumption we try to maintain during vectorization - that the loop exit block has a single predecessor. diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c index fcea4d0654b..7d9c9ed8d7d 100644 --- a/gcc/tree-vect-stmts.c +++ b/gcc/tree-vect-stmts.c @@ -2675,7 +2675,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi, { if (modifier == WIDEN) { - vec_oprnds0.create (multi_step_cvt ? vect_pow2(multi_step_cvt) : 1); + vec_oprnds0.create (multi_step_cvt ? vect_pow2 (multi_step_cvt) : 1); if (op_type == binary_op) vec_oprnds1.create (1); } @@ -4790,7 +4790,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt, (unshare_expr (DR_BASE_ADDRESS (dr)), size_binop (PLUS_EXPR, convert_to_ptrofftype (unshare_expr (DR_OFFSET (dr))), - convert_to_ptrofftype (DR_INIT(dr)))); + convert_to_ptrofftype (DR_INIT (dr)))); stride_step = fold_convert (sizetype, unshare_expr (DR_STEP (dr))); /* For a load with loop-invariant (but other than power-of-2) diff --git a/gcc/tree-vectorizer.c b/gcc/tree-vectorizer.c index 638c19b72ee..87404cf0536 100644 --- a/gcc/tree-vectorizer.c +++ b/gcc/tree-vectorizer.c @@ -510,8 +510,8 @@ const pass_data pass_data_slp_vectorize = class pass_slp_vectorize : public gimple_opt_pass { public: - pass_slp_vectorize(gcc::context *ctxt) - : gimple_opt_pass(pass_data_slp_vectorize, ctxt) + pass_slp_vectorize (gcc::context *ctxt) + : gimple_opt_pass (pass_data_slp_vectorize, ctxt) {} /* opt_pass methods: */ @@ -550,7 +550,7 @@ increase_alignment (void) tree t; unsigned int alignment; - t = TREE_TYPE(decl); + t = TREE_TYPE (decl); if (TREE_CODE (t) != ARRAY_TYPE) continue; vectype = get_vectype_for_scalar_type (strip_array_types (t)); @@ -600,8 +600,8 @@ const pass_data pass_data_ipa_increase_alignment = class pass_ipa_increase_alignment : public simple_ipa_opt_pass { public: - pass_ipa_increase_alignment(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_increase_alignment, ctxt) + pass_ipa_increase_alignment (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_increase_alignment, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree-vectorizer.h b/gcc/tree-vectorizer.h index 7cb8f4d9d06..a5cef5a58ad 100644 --- a/gcc/tree-vectorizer.h +++ b/gcc/tree-vectorizer.h @@ -27,7 +27,7 @@ along with GCC; see the file COPYING3. If not see typedef source_location LOC; #define UNKNOWN_LOC UNKNOWN_LOCATION -#define EXPR_LOC(e) EXPR_LOCATION(e) +#define EXPR_LOC(e) EXPR_LOCATION (e) #define LOC_FILE(l) LOCATION_FILE (l) #define LOC_LINE(l) LOCATION_LINE (l) @@ -356,7 +356,7 @@ typedef struct _loop_vec_info { && TREE_INT_CST_LOW ((n)) > 0) #define LOOP_VINFO_NITERS_KNOWN_P(L) \ -NITERS_KNOWN_P((L)->num_iters) +NITERS_KNOWN_P ((L)->num_iters) static inline loop_vec_info loop_vec_info_for_loop (struct loop *loop) diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index 16007244c9b..caf3d55dc49 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -5854,7 +5854,7 @@ find_assert_locations_1 (basic_block bb, sbitmap live) } /* Traverse all PHI nodes in BB, updating live. */ - for (si = gsi_start_phis (bb); !gsi_end_p(si); gsi_next (&si)) + for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) { use_operand_p arg_p; ssa_op_iter i; @@ -9665,8 +9665,8 @@ const pass_data pass_data_vrp = class pass_vrp : public gimple_opt_pass { public: - pass_vrp(gcc::context *ctxt) - : gimple_opt_pass(pass_data_vrp, ctxt) + pass_vrp (gcc::context *ctxt) + : gimple_opt_pass (pass_data_vrp, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tree.c b/gcc/tree.c index 1c881e4a4ce..ebee116f0c5 100644 --- a/gcc/tree.c +++ b/gcc/tree.c @@ -1007,7 +1007,7 @@ copy_node_stat (tree node MEM_STAT_DECL) TYPE_SYMTAB_ADDRESS (t) = 0; /* Do not copy the values cache. */ - if (TYPE_CACHED_VALUES_P(t)) + if (TYPE_CACHED_VALUES_P (t)) { TYPE_CACHED_VALUES_P (t) = 0; TYPE_CACHED_VALUES (t) = NULL_TREE; @@ -1112,7 +1112,7 @@ force_fit_type_double (tree type, double_int cst, int overflowable, bool sign_extended_type = !TYPE_UNSIGNED (type); /* If we need to set overflow flags, return a new unshared node. */ - if (overflowed || !double_int_fits_to_tree_p(type, cst)) + if (overflowed || !double_int_fits_to_tree_p (type, cst)) { if (overflowed || overflowable < 0 @@ -1726,7 +1726,7 @@ build_one_cst (tree type) case FIXED_POINT_TYPE: /* We can only generate 1 for accum types. */ gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type))); - return build_fixed (type, FCONST1(TYPE_MODE (type))); + return build_fixed (type, FCONST1 (TYPE_MODE (type))); case VECTOR_TYPE: { @@ -4118,8 +4118,8 @@ build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL) read_only = 1; side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); + PROCESS_ARG (0); + PROCESS_ARG (1); TREE_READONLY (t) = read_only; TREE_CONSTANT (t) = constant; @@ -4158,9 +4158,9 @@ build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1, else side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); - PROCESS_ARG(2); + PROCESS_ARG (0); + PROCESS_ARG (1); + PROCESS_ARG (2); if (code == COND_EXPR) TREE_READONLY (t) = read_only; @@ -4187,10 +4187,10 @@ build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1, side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); - PROCESS_ARG(2); - PROCESS_ARG(3); + PROCESS_ARG (0); + PROCESS_ARG (1); + PROCESS_ARG (2); + PROCESS_ARG (3); TREE_SIDE_EFFECTS (t) = side_effects; TREE_THIS_VOLATILE (t) @@ -4214,11 +4214,11 @@ build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1, side_effects = TREE_SIDE_EFFECTS (t); - PROCESS_ARG(0); - PROCESS_ARG(1); - PROCESS_ARG(2); - PROCESS_ARG(3); - PROCESS_ARG(4); + PROCESS_ARG (0); + PROCESS_ARG (1); + PROCESS_ARG (2); + PROCESS_ARG (3); + PROCESS_ARG (4); TREE_SIDE_EFFECTS (t) = side_effects; TREE_THIS_VOLATILE (t) @@ -5515,8 +5515,8 @@ const pass_data pass_data_ipa_free_lang_data = class pass_ipa_free_lang_data : public simple_ipa_opt_pass { public: - pass_ipa_free_lang_data(gcc::context *ctxt) - : simple_ipa_opt_pass(pass_data_ipa_free_lang_data, ctxt) + pass_ipa_free_lang_data (gcc::context *ctxt) + : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt) {} /* opt_pass methods: */ @@ -6680,9 +6680,11 @@ attribute_list_contained (const_tree l1, const_tree l2) /* This CONST_CAST is okay because lookup_attribute does not modify its argument and the return value is assigned to a const_tree. */ - for (attr = lookup_ident_attribute (get_attribute_name (t2), CONST_CAST_TREE(l1)); + for (attr = lookup_ident_attribute (get_attribute_name (t2), + CONST_CAST_TREE (l1)); attr != NULL_TREE && !attribute_value_equal (t2, attr); - attr = lookup_ident_attribute (get_attribute_name (t2), TREE_CHAIN (attr))) + attr = lookup_ident_attribute (get_attribute_name (t2), + TREE_CHAIN (attr))) ; if (attr == NULL_TREE) @@ -7801,9 +7803,9 @@ strip_array_types (tree type) true) or would not differ from ARGTYPES. */ static tree -maybe_canonicalize_argtypes(tree argtypes, - bool *any_structural_p, - bool *any_noncanonical_p) +maybe_canonicalize_argtypes (tree argtypes, + bool *any_structural_p, + bool *any_noncanonical_p) { tree arg; bool any_noncanonical_argtypes_p = false; @@ -9342,7 +9344,7 @@ tree_contains_struct_check_failed (const_tree node, { internal_error ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d", - TS_ENUM_NAME(en), + TS_ENUM_NAME (en), tree_code_name[TREE_CODE (node)], function, trim_filename (file), line); } @@ -10998,7 +11000,8 @@ walk_tree_1 (tree *tp, walk_tree_fn func, void *data, unsigned HOST_WIDE_INT idx; constructor_elt *ce; - for (idx = 0; vec_safe_iterate(CONSTRUCTOR_ELTS (*tp), idx, &ce); idx++) + for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce); + idx++) WALK_SUBTREE (ce->value); } break; @@ -11304,7 +11307,7 @@ stdarg_p (const_tree fntype) if (!fntype) return false; - FOREACH_FUNCTION_ARGS(fntype, t, args_iter) + FOREACH_FUNCTION_ARGS (fntype, t, args_iter) { n = t; } diff --git a/gcc/tree.h b/gcc/tree.h index b1d168b0593..4cd7e9e9f65 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -577,7 +577,7 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, exit of a function. Calls for which this is true are candidates for tail call optimizations. */ #define CALL_EXPR_TAILCALL(NODE) \ - (CALL_EXPR_CHECK(NODE)->base.addressable_flag) + (CALL_EXPR_CHECK (NODE)->base.addressable_flag) /* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the CASE_LOW operand has been processed. */ @@ -585,9 +585,9 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, (CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag) #define PREDICT_EXPR_OUTCOME(NODE) \ - ((enum prediction) (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag)) + ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag)) #define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \ - (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag = (int) OUTCOME) + (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME) #define PREDICT_EXPR_PREDICTOR(NODE) \ ((enum br_predictor)tree_low_cst (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0), 0)) @@ -659,7 +659,7 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, /* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector of cached values, or is something else. */ -#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK(NODE)->base.public_flag) +#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK (NODE)->base.public_flag) /* In a SAVE_EXPR, indicates that the original expression has already been substituted with a VAR_DECL that contains the value. */ @@ -669,7 +669,7 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, /* Set on a CALL_EXPR if this stdarg call should be passed the argument pack. */ #define CALL_EXPR_VA_ARG_PACK(NODE) \ - (CALL_EXPR_CHECK(NODE)->base.public_flag) + (CALL_EXPR_CHECK (NODE)->base.public_flag) /* In any expression, decl, or constant, nonzero means it has side effects or reevaluation of the whole expression could produce a different value. @@ -848,19 +848,19 @@ extern void omp_clause_range_check_failed (const_tree, const char *, int, /* These flags are available for each language front end to use internally. */ #define TREE_LANG_FLAG_0(NODE) \ - (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0) + (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0) #define TREE_LANG_FLAG_1(NODE) \ - (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1) + (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1) #define TREE_LANG_FLAG_2(NODE) \ - (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2) + (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2) #define TREE_LANG_FLAG_3(NODE) \ - (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3) + (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3) #define TREE_LANG_FLAG_4(NODE) \ - (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4) + (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4) #define TREE_LANG_FLAG_5(NODE) \ - (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5) + (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5) #define TREE_LANG_FLAG_6(NODE) \ - (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6) + (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6) /* Define additional fields and accessors for nodes representing constants. */ @@ -1131,7 +1131,7 @@ extern void protected_set_expr_location (tree, location_t); #define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1) #define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2) #define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3) -#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3) +#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH (NODE) - 3) /* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE. We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if @@ -1654,10 +1654,10 @@ extern enum machine_mode vector_type_mode (const_tree); #define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values) #define TYPE_FIELDS(NODE) \ (RECORD_OR_UNION_CHECK (NODE)->type_non_common.values) -#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type_non_common.values) +#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK (NODE)->type_non_common.values) #define TYPE_ARG_TYPES(NODE) \ (FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values) -#define TYPE_VALUES_RAW(NODE) (TYPE_CHECK(NODE)->type_non_common.values) +#define TYPE_VALUES_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.values) #define TYPE_METHODS(NODE) \ (RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval) @@ -1686,11 +1686,11 @@ extern enum machine_mode vector_type_mode (const_tree); /* For record and union types, information about this type, as a base type for itself. */ -#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type_non_common.binfo) +#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo) /* For non record and union types, used in a language-dependent way. */ #define TYPE_LANG_SLOT_1(NODE) \ - (NOT_RECORD_OR_UNION_CHECK(NODE)->type_non_common.binfo) + (NOT_RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo) /* Define accessor macros for information about type inheritance and basetypes. @@ -1713,16 +1713,16 @@ extern enum machine_mode vector_type_mode (const_tree); #define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag) /* Flags for language dependent use. */ -#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0(TREE_BINFO_CHECK(NODE)) -#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1(TREE_BINFO_CHECK(NODE)) -#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2(TREE_BINFO_CHECK(NODE)) -#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3(TREE_BINFO_CHECK(NODE)) -#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4(TREE_BINFO_CHECK(NODE)) -#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5(TREE_BINFO_CHECK(NODE)) -#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6(TREE_BINFO_CHECK(NODE)) +#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE)) +#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE)) +#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE)) +#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE)) +#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE)) +#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE)) +#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE)) /* The actual data type node being inherited in this basetype. */ -#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK(NODE)) +#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK (NODE)) /* The offset where this basetype appears in its containing type. BINFO_OFFSET slot holds the offset (in bytes) @@ -1730,19 +1730,19 @@ extern enum machine_mode vector_type_mode (const_tree); object that is allocated on behalf of this `type'. This is always 0 except when there is multiple inheritance. */ -#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK(NODE)->binfo.offset) +#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK (NODE)->binfo.offset) #define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE))) /* The virtual function table belonging to this basetype. Virtual function tables provide a mechanism for run-time method dispatching. The entries of a virtual function table are language-dependent. */ -#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtable) +#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtable) /* The virtual functions in the virtual function table. This is a TREE_LIST that is used as an initial approximation for building a virtual function table for this basetype. */ -#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK(NODE)->binfo.virtuals) +#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK (NODE)->binfo.virtuals) /* A vector of binfos for the direct basetypes inherited by this basetype. @@ -1750,7 +1750,7 @@ extern enum machine_mode vector_type_mode (const_tree); If this basetype describes type D as inherited in C, and if the basetypes of D are E and F, then this vector contains binfos for inheritance of E and F by C. */ -#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK(NODE)->binfo.base_binfos) +#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos) /* The number of basetypes for NODE. */ #define BINFO_N_BASE_BINFOS(NODE) (BINFO_BASE_BINFOS (NODE)->length ()) @@ -1768,12 +1768,13 @@ extern enum machine_mode vector_type_mode (const_tree); base. The actual contents are language-dependent. In the C++ front-end this field is an INTEGER_CST giving an offset into the vtable where the offset to the virtual base can be found. */ -#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vptr_field) +#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vptr_field) /* Indicates the accesses this binfo has to its bases. The values are access_public_node, access_protected_node or access_private_node. If this array is not present, public access is implied. */ -#define BINFO_BASE_ACCESSES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_accesses) +#define BINFO_BASE_ACCESSES(NODE) \ + (TREE_BINFO_CHECK (NODE)->binfo.base_accesses) #define BINFO_BASE_ACCESS(NODE,N) \ (*BINFO_BASE_ACCESSES (NODE))[(N)] @@ -1782,18 +1783,18 @@ extern enum machine_mode vector_type_mode (const_tree); /* The index in the VTT where this subobject's sub-VTT can be found. NULL_TREE if there is no sub-VTT. */ -#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_subvtt) +#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt) /* The index in the VTT where the vptr for this subobject can be found. NULL_TREE if there is no secondary vptr in the VTT. */ -#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_vptr) +#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr) /* The BINFO_INHERITANCE_CHAIN points at the binfo for the base inheriting this base for non-virtual bases. For virtual bases it points either to the binfo for which this is a primary binfo, or to the binfo of the most derived type. */ #define BINFO_INHERITANCE_CHAIN(NODE) \ - (TREE_BINFO_CHECK(NODE)->binfo.inheritance) + (TREE_BINFO_CHECK (NODE)->binfo.inheritance) /* Define fields and accessors for nodes representing declared names. */ @@ -2718,7 +2719,7 @@ inline tree contains_struct_check (tree __t, const enum tree_node_structure_enum __s, const char *__f, int __l, const char *__g) { - if (tree_contains_struct[TREE_CODE(__t)][__s] != 1) + if (tree_contains_struct[TREE_CODE (__t)][__s] != 1) tree_contains_struct_check_failed (__t, __s, __f, __l, __g); return __t; } @@ -2727,7 +2728,7 @@ inline tree tree_class_check (tree __t, const enum tree_code_class __class, const char *__f, int __l, const char *__g) { - if (TREE_CODE_CLASS (TREE_CODE(__t)) != __class) + if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class) tree_class_check_failed (__t, __class, __f, __l, __g); return __t; } @@ -2928,7 +2929,7 @@ inline const_tree contains_struct_check (const_tree __t, const enum tree_node_structure_enum __s, const char *__f, int __l, const char *__g) { - if (tree_contains_struct[TREE_CODE(__t)][__s] != 1) + if (tree_contains_struct[TREE_CODE (__t)][__s] != 1) tree_contains_struct_check_failed (__t, __s, __f, __l, __g); return __t; } @@ -2937,7 +2938,7 @@ inline const_tree tree_class_check (const_tree __t, const enum tree_code_class __class, const char *__f, int __l, const char *__g) { - if (TREE_CODE_CLASS (TREE_CODE(__t)) != __class) + if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class) tree_class_check_failed (__t, __class, __f, __l, __g); return __t; } @@ -3476,13 +3477,13 @@ extern tree build_all_ones_cst (tree); extern tree build_zero_cst (tree); extern tree build_string (int, const char *); extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL); -#define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO) +#define build_tree_list(t, q) build_tree_list_stat (t, q MEM_STAT_INFO) extern tree build_tree_list_vec_stat (const vec<tree, va_gc> *MEM_STAT_DECL); #define build_tree_list_vec(v) build_tree_list_vec_stat (v MEM_STAT_INFO) extern tree build_decl_stat (location_t, enum tree_code, tree, tree MEM_STAT_DECL); extern tree build_fn_decl (const char *, tree); -#define build_decl(l,c,t,q) build_decl_stat (l,c,t,q MEM_STAT_INFO) +#define build_decl(l,c,t,q) build_decl_stat (l, c, t, q MEM_STAT_INFO) extern tree build_translation_unit_decl (tree); extern tree build_block (tree, tree, tree, tree); extern tree build_empty_stmt (location_t); @@ -3490,7 +3491,7 @@ extern tree build_omp_clause (location_t, enum omp_clause_code); extern tree find_omp_clause (tree, enum omp_clause_code); extern tree build_vl_exp_stat (enum tree_code, int MEM_STAT_DECL); -#define build_vl_exp(c,n) build_vl_exp_stat (c,n MEM_STAT_INFO) +#define build_vl_exp(c, n) build_vl_exp_stat (c, n MEM_STAT_INFO) extern tree build_call_nary (tree, tree, int, ...); extern tree build_call_valist (tree, tree, int, va_list); @@ -4301,7 +4302,7 @@ extern tree fold_build_call_array_loc (location_t, tree, tree, int, tree *); extern tree fold_build_call_array_initializer_loc (location_t, tree, tree, int, tree *); extern bool fold_convertible_p (const_tree, const_tree); #define fold_convert(T1,T2)\ - fold_convert_loc(UNKNOWN_LOCATION, T1, T2) + fold_convert_loc (UNKNOWN_LOCATION, T1, T2) extern tree fold_convert_loc (location_t, tree, tree); extern tree fold_single_bit_test (location_t, enum tree_code, tree, tree, tree); extern tree fold_ignored_result (tree); @@ -4321,7 +4322,7 @@ extern tree omit_one_operand_loc (location_t, tree, tree, tree); omit_two_operands_loc (UNKNOWN_LOCATION, T1, T2, T3, T4) extern tree omit_two_operands_loc (location_t, tree, tree, tree, tree); #define invert_truthvalue(T)\ - invert_truthvalue_loc(UNKNOWN_LOCATION, T) + invert_truthvalue_loc (UNKNOWN_LOCATION, T) extern tree invert_truthvalue_loc (location_t, tree); extern tree fold_unary_to_constant (enum tree_code, tree, tree); extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree); diff --git a/gcc/tsan.c b/gcc/tsan.c index 1c642a6642b..363f1608513 100644 --- a/gcc/tsan.c +++ b/gcc/tsan.c @@ -753,8 +753,8 @@ const pass_data pass_data_tsan = class pass_tsan : public gimple_opt_pass { public: - pass_tsan(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tsan, ctxt) + pass_tsan (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tsan, ctxt) {} /* opt_pass methods: */ @@ -798,8 +798,8 @@ const pass_data pass_data_tsan_O0 = class pass_tsan_O0 : public gimple_opt_pass { public: - pass_tsan_O0(gcc::context *ctxt) - : gimple_opt_pass(pass_data_tsan_O0, ctxt) + pass_tsan_O0 (gcc::context *ctxt) + : gimple_opt_pass (pass_data_tsan_O0, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/tsystem.h b/gcc/tsystem.h index 157bc225e12..bc628a076d8 100644 --- a/gcc/tsystem.h +++ b/gcc/tsystem.h @@ -129,7 +129,7 @@ extern int errno; #define gcc_unreachable() (abort ()) #define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; TOTYPE _nq;})(X))._nq) -#define CONST_CAST(TYPE,X) CONST_CAST2(TYPE, const TYPE, (X)) +#define CONST_CAST(TYPE,X) CONST_CAST2 (TYPE, const TYPE, (X)) /* Filename handling macros. */ #include "filenames.h" diff --git a/gcc/value-prof.c b/gcc/value-prof.c index 160a416d4d3..597e9c0f5c0 100644 --- a/gcc/value-prof.c +++ b/gcc/value-prof.c @@ -249,7 +249,7 @@ dump_histogram_value (FILE *dump_file, histogram_value hist) if (hist->hvalue.counters) { unsigned int i; - fprintf(dump_file, " ["); + fprintf (dump_file, " ["); for (i = 0; i < hist->hdata.intvl.steps; i++) fprintf (dump_file, " %d:"HOST_WIDEST_INT_PRINT_DEC, hist->hdata.intvl.int_start + i, @@ -1568,7 +1568,7 @@ gimple_stringop_fixed_value (gimple vcall_stmt, tree icall_size, int prob, fndecl = gimple_call_fndecl (vcall_stmt); if (!interesting_stringop_to_profile_p (fndecl, vcall_stmt, &size_arg)) - gcc_unreachable(); + gcc_unreachable (); cond_bb = gimple_bb (vcall_stmt); gsi = gsi_for_stmt (vcall_stmt); diff --git a/gcc/var-tracking.c b/gcc/var-tracking.c index 5d39c500a51..24c61ccd2a2 100644 --- a/gcc/var-tracking.c +++ b/gcc/var-tracking.c @@ -2877,7 +2877,7 @@ variable_union (variable src, dataflow_set *set) /* The most common case, much simpler, no qsort is needed. */ location_chain dstnode = dst->var_part[j].loc_chain; dst->var_part[k].loc_chain = dstnode; - VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET(dst, j); + VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j); node2 = dstnode; for (node = src->var_part[i].loc_chain; node; node = node->next) if (!((REG_P (dstnode->loc) @@ -10256,8 +10256,8 @@ const pass_data pass_data_variable_tracking = class pass_variable_tracking : public rtl_opt_pass { public: - pass_variable_tracking(gcc::context *ctxt) - : rtl_opt_pass(pass_data_variable_tracking, ctxt) + pass_variable_tracking (gcc::context *ctxt) + : rtl_opt_pass (pass_data_variable_tracking, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/varasm.c b/gcc/varasm.c index 0504eeb4f39..12fb7c46b33 100644 --- a/gcc/varasm.c +++ b/gcc/varasm.c @@ -3085,7 +3085,7 @@ compare_constant (const tree t1, const tree t2) case MINUS_EXPR: case RANGE_EXPR: return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0)) - && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))); + && compare_constant (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1))); CASE_CONVERT: case VIEW_CONVERT_EXPR: @@ -5546,9 +5546,9 @@ void do_assemble_alias (tree decl, tree target) { /* Emulated TLS had better not get this var. */ - gcc_assert(!(!targetm.have_tls - && TREE_CODE (decl) == VAR_DECL - && DECL_THREAD_LOCAL_P (decl))); + gcc_assert (!(!targetm.have_tls + && TREE_CODE (decl) == VAR_DECL + && DECL_THREAD_LOCAL_P (decl))); if (TREE_ASM_WRITTEN (decl)) return; diff --git a/gcc/vec.h b/gcc/vec.h index 09a1d0a4d86..a75d3bfc765 100644 --- a/gcc/vec.h +++ b/gcc/vec.h @@ -719,7 +719,7 @@ vec_safe_grow_cleared (vec<T, A, vl_embed> *&v, unsigned len CXX_MEM_STAT_INFO) { unsigned oldlen = vec_safe_length (v); vec_safe_grow (v, len PASS_MEM_STAT); - memset (&(v->address()[oldlen]), 0, sizeof (T) * (len - oldlen)); + memset (&(v->address ()[oldlen]), 0, sizeof (T) * (len - oldlen)); } @@ -858,7 +858,7 @@ vec<T, A, vl_embed>::space (unsigned nelems) const element of this vector. Use this to iterate over the elements of a vector as follows, - for (ix = 0; vec<T, A>::iterate(v, ix, &ptr); ix++) + for (ix = 0; vec<T, A>::iterate (v, ix, &ptr); ix++) continue; */ template<typename T, typename A> @@ -882,7 +882,7 @@ vec<T, A, vl_embed>::iterate (unsigned ix, T *ptr) const IX'th element of this vector. Use this to iterate over the elements of a vector as follows, - for (ix = 0; v->iterate(ix, &ptr); ix++) + for (ix = 0; v->iterate (ix, &ptr); ix++) continue; This variant is for vectors of objects. */ @@ -916,7 +916,7 @@ vec<T, A, vl_embed>::copy (ALONE_MEM_STAT_DECL) const { vec_alloc (new_vec, len PASS_MEM_STAT); new_vec->embedded_init (len, len); - memcpy (new_vec->address(), vecdata_, sizeof (T) * len); + memcpy (new_vec->address (), vecdata_, sizeof (T) * len); } return new_vec; } @@ -929,11 +929,11 @@ template<typename T, typename A> inline void vec<T, A, vl_embed>::splice (vec<T, A, vl_embed> &src) { - unsigned len = src.length(); + unsigned len = src.length (); if (len) { gcc_checking_assert (space (len)); - memcpy (address() + length(), src.address(), len * sizeof (T)); + memcpy (address () + length (), src.address (), len * sizeof (T)); vecpfx_.num_ += len; } } @@ -1008,7 +1008,7 @@ template<typename T, typename A> inline void vec<T, A, vl_embed>::ordered_remove (unsigned ix) { - gcc_checking_assert (ix < length()); + gcc_checking_assert (ix < length ()); T *slot = &vecdata_[ix]; memmove (slot, slot + 1, (--vecpfx_.num_ - ix) * sizeof (T)); } @@ -1021,7 +1021,7 @@ template<typename T, typename A> inline void vec<T, A, vl_embed>::unordered_remove (unsigned ix) { - gcc_checking_assert (ix < length()); + gcc_checking_assert (ix < length ()); vecdata_[ix] = vecdata_[--vecpfx_.num_]; } @@ -1033,7 +1033,7 @@ template<typename T, typename A> inline void vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len) { - gcc_checking_assert (ix + len <= length()); + gcc_checking_assert (ix + len <= length ()); T *slot = &vecdata_[ix]; vecpfx_.num_ -= len; memmove (slot, slot + len, (vecpfx_.num_ - ix) * sizeof (T)); @@ -1047,7 +1047,7 @@ template<typename T, typename A> inline void vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *)) { - ::qsort (address(), length(), sizeof (T), cmp); + ::qsort (address (), length (), sizeof (T), cmp); } @@ -1091,7 +1091,7 @@ vec<T, A, vl_embed>::lower_bound (T obj, bool (*lessthan)(const T &, const T &)) final member): size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc); - void v->embedded_init(unsigned alloc, unsigned num); + void v->embedded_init (unsigned alloc, unsigned num); These allow the caller to perform the memory allocation. */ @@ -1137,7 +1137,7 @@ vec<T, A, vl_embed>::quick_grow_cleared (unsigned len) { unsigned oldlen = length (); quick_grow (len); - memset (&(address()[oldlen]), 0, sizeof (T) * (len - oldlen)); + memset (&(address ()[oldlen]), 0, sizeof (T) * (len - oldlen)); } @@ -1232,10 +1232,10 @@ public: { return vec_ != NULL; } bool is_empty (void) const - { return vec_ ? vec_->is_empty() : true; } + { return vec_ ? vec_->is_empty () : true; } unsigned length (void) const - { return vec_ ? vec_->length() : 0; } + { return vec_ ? vec_->length () : 0; } T *address (void) { return vec_ ? vec_->vecdata_ : NULL; } @@ -1250,13 +1250,13 @@ public: { return !(*this == other); } bool operator==(const vec &other) const - { return address() == other.address(); } + { return address () == other.address (); } T &operator[] (unsigned ix) { return (*vec_)[ix]; } T &last (void) - { return vec_->last(); } + { return vec_->last (); } bool space (int nelems) const { return vec_ ? vec_->space (nelems) : nelems == 0; } @@ -1285,8 +1285,8 @@ public: unsigned lower_bound (T, bool (*)(const T &, const T &)) const; template<typename T1> - friend void va_stack::alloc(vec<T1, va_stack, vl_ptr>&, unsigned, - vec<T1, va_stack, vl_embed> *); + friend void va_stack::alloc (vec<T1, va_stack, vl_ptr>&, unsigned, + vec<T1, va_stack, vl_embed> *); /* FIXME - This field should be private, but we need to cater to compilers that have stricter notions of PODness for types. */ @@ -1386,7 +1386,7 @@ vec_free (vec<T> *&v) element of this vector. Use this to iterate over the elements of a vector as follows, - for (ix = 0; v.iterate(ix, &ptr); ix++) + for (ix = 0; v.iterate (ix, &ptr); ix++) continue; */ template<typename T, typename A> @@ -1407,7 +1407,7 @@ vec<T, A, vl_ptr>::iterate (unsigned ix, T *ptr) const IX'th element of this vector. Use this to iterate over the elements of a vector as follows, - for (ix = 0; v->iterate(ix, &ptr); ix++) + for (ix = 0; v->iterate (ix, &ptr); ix++) continue; This variant is for vectors of objects. */ @@ -1544,9 +1544,9 @@ template<typename T, typename A> inline void vec<T, A, vl_ptr>::safe_splice (vec<T, A, vl_ptr> &src MEM_STAT_DECL) { - if (src.length()) + if (src.length ()) { - reserve_exact (src.length()); + reserve_exact (src.length ()); splice (src); } } @@ -1626,7 +1626,7 @@ vec<T, A, vl_ptr>::safe_grow_cleared (unsigned len MEM_STAT_DECL) { unsigned oldlen = length (); safe_grow (len PASS_MEM_STAT); - memset (&(address()[oldlen]), 0, sizeof (T) * (len - oldlen)); + memset (&(address ()[oldlen]), 0, sizeof (T) * (len - oldlen)); } diff --git a/gcc/vmsdbgout.c b/gcc/vmsdbgout.c index 9f05c1cd32b..9f308a6fdf2 100644 --- a/gcc/vmsdbgout.c +++ b/gcc/vmsdbgout.c @@ -221,9 +221,9 @@ const struct gcc_debug_hooks vmsdbg_debug_hooks #ifndef UNALIGNED_OFFSET_ASM_OP #define UNALIGNED_OFFSET_ASM_OP(OFFSET) \ - (NUMBYTES(OFFSET) == 4 \ + (NUMBYTES (OFFSET) == 4 \ ? VMS_UNALIGNED_LONG_ASM_OP \ - : (NUMBYTES(OFFSET) == 2 ? VMS_UNALIGNED_SHORT_ASM_OP : VMS_ASM_BYTE_OP)) + : (NUMBYTES (OFFSET) == 2 ? VMS_UNALIGNED_SHORT_ASM_OP : VMS_ASM_BYTE_OP)) #endif /* Definitions of defaults for formats and names of various special @@ -329,7 +329,7 @@ static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; #ifndef ASM_OUTPUT_DEBUG_DATA #define ASM_OUTPUT_DEBUG_DATA(FILE,VALUE) \ - fprintf ((FILE), "\t%s\t%#lx", UNALIGNED_OFFSET_ASM_OP(VALUE), VALUE) + fprintf ((FILE), "\t%s\t%#lx", UNALIGNED_OFFSET_ASM_OP (VALUE), VALUE) #endif #ifndef ASM_OUTPUT_DEBUG_ADDR_DATA @@ -351,7 +351,7 @@ static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES]; #define ASM_OUTPUT_DEBUG_STRING(FILE,P) \ do \ { \ - register int slen = strlen(P); \ + register int slen = strlen (P); \ register const char *p = (P); \ register int i; \ fprintf (FILE, "\t.ascii \""); \ diff --git a/gcc/vtable-verify.c b/gcc/vtable-verify.c index 1b5cc0c6e98..d954d1f91e0 100644 --- a/gcc/vtable-verify.c +++ b/gcc/vtable-verify.c @@ -173,7 +173,7 @@ vtbl_map_node_registration_find (struct vtbl_map_node *node, struct vtable_registration key; struct vtable_registration **slot; - gcc_assert (node && node->registered.is_created()); + gcc_assert (node && node->registered.is_created ()); key.vtable_decl = vtable_decl; slot = (struct vtable_registration **) node->registered.find_slot (&key, @@ -182,7 +182,7 @@ vtbl_map_node_registration_find (struct vtbl_map_node *node, if (slot && (*slot)) { unsigned i; - for (i = 0; i < ((*slot)->offsets).length(); ++i) + for (i = 0; i < ((*slot)->offsets).length (); ++i) if ((*slot)->offsets[i] == offset) return true; } @@ -203,7 +203,7 @@ vtbl_map_node_registration_insert (struct vtbl_map_node *node, struct vtable_registration **slot; bool inserted_something = false; - if (!node || !node->registered.is_created()) + if (!node || !node->registered.is_created ()) return false; key.vtable_decl = vtable_decl; @@ -227,7 +227,7 @@ vtbl_map_node_registration_insert (struct vtbl_map_node *node, contains the offset. If not, we need to add the offset. */ unsigned i; bool found = false; - for (i = 0; i < ((*slot)->offsets).length() && !found; ++i) + for (i = 0; i < ((*slot)->offsets).length () && !found; ++i) if ((*slot)->offsets[i] == offset) found = true; @@ -319,7 +319,7 @@ vtbl_map_get_node (tree class_type) tree class_name; unsigned int type_quals; - if (!vtbl_map_hash.is_created()) + if (!vtbl_map_hash.is_created ()) return NULL; gcc_assert (TREE_CODE (class_type) == RECORD_TYPE); @@ -356,7 +356,7 @@ find_or_create_vtbl_map_node (tree base_class_type) tree class_type_decl; unsigned int type_quals; - if (!vtbl_map_hash.is_created()) + if (!vtbl_map_hash.is_created ()) vtbl_map_hash.create (10); /* Find the TYPE_DECL for the class. */ @@ -772,8 +772,8 @@ const pass_data pass_data_vtable_verify = class pass_vtable_verify : public gimple_opt_pass { public: - pass_vtable_verify(gcc::context *ctxt) - : gimple_opt_pass(pass_data_vtable_verify, ctxt) + pass_vtable_verify (gcc::context *ctxt) + : gimple_opt_pass (pass_data_vtable_verify, ctxt) {} /* opt_pass methods: */ diff --git a/gcc/web.c b/gcc/web.c index 90c18a81401..8e8c4658fd2 100644 --- a/gcc/web.c +++ b/gcc/web.c @@ -374,7 +374,7 @@ web_main (void) } /* Record the number of uses and defs at the beginning of the optimization. */ - def_entry = XCNEWVEC (struct web_entry, DF_DEFS_TABLE_SIZE()); + def_entry = XCNEWVEC (struct web_entry, DF_DEFS_TABLE_SIZE ()); used = XCNEWVEC (unsigned, max); use_entry = XCNEWVEC (struct web_entry, uses_num); @@ -469,8 +469,8 @@ const pass_data pass_data_web = class pass_web : public rtl_opt_pass { public: - pass_web(gcc::context *ctxt) - : rtl_opt_pass(pass_data_web, ctxt) + pass_web (gcc::context *ctxt) + : rtl_opt_pass (pass_data_web, ctxt) {} /* opt_pass methods: */ |