git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

alloc-pool.c, [...]: Add missing whitespace before "(". 

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 "(".

From-SVN: r203004
This commit is contained in:
Richard Sandiford 2013-09-28 08:42:34 +00:00 committed by Richard Sandiford
parent c6285bd7bb
commit c328471880
256 changed files with 1612 additions and 1529 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
gcc/ChangeLog
View File

@ -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> 2013-09-28 Sandra Loosemore <sandra@codesourcery.com>
* expr.h (extract_bit_field): Remove packedp parameter. * expr.h (extract_bit_field): Remove packedp parameter.

2
gcc/alloc-pool.c
View File

@ -316,7 +316,7 @@ pool_alloc (alloc_pool pool)
/* Pull the first free element from the free list, and return it. */ /* Pull the first free element from the free list, and return it. */
header = pool->returned_free_list; 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->returned_free_list = header->next;
pool->elts_free--; pool->elts_free--;

8
gcc/asan.c
View File

@ -2268,8 +2268,8 @@ const pass_data pass_data_asan =
class pass_asan : public gimple_opt_pass class pass_asan : public gimple_opt_pass
{ {
public: public:
pass_asan(gcc::context *ctxt) pass_asan (gcc::context *ctxt)
: gimple_opt_pass(pass_data_asan, ctxt) : gimple_opt_pass (pass_data_asan, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -2314,8 +2314,8 @@ const pass_data pass_data_asan_O0 =
class pass_asan_O0 : public gimple_opt_pass class pass_asan_O0 : public gimple_opt_pass
{ {
public: public:
pass_asan_O0(gcc::context *ctxt) pass_asan_O0 (gcc::context *ctxt)
: gimple_opt_pass(pass_data_asan_O0, ctxt) : gimple_opt_pass (pass_data_asan_O0, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

10
gcc/auto-inc-dec.c
View File

@ -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 /* In this case, we must clear these vectors since the trick of
testing if the stale insn in the block will not work. */ testing if the stale insn in the block will not work. */
memset (reg_next_use, 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_inc_use, 0, max_reg * sizeof (rtx));
memset (reg_next_def, 0, max_reg * sizeof(rtx)); memset (reg_next_def, 0, max_reg * sizeof (rtx));
df_recompute_luids (bb); df_recompute_luids (bb);
merge_in_block (max_reg, 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 class pass_inc_dec : public rtl_opt_pass
{ {
public: public:
pass_inc_dec(gcc::context *ctxt) pass_inc_dec (gcc::context *ctxt)
: rtl_opt_pass(pass_data_inc_dec, ctxt) : rtl_opt_pass (pass_data_inc_dec, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

12
gcc/basic-block.h
View File

@ -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 struct rtl_bb_info, so that inlining the former into basic_block_def
is the better choice. */ is the better choice. */
typedef int __assert_gimple_bb_smaller_rtl_bb typedef int __assert_gimple_bb_smaller_rtl_bb
[(int)sizeof(struct rtl_bb_info) [(int) sizeof (struct rtl_bb_info)
- (int)sizeof (struct gimple_bb_info)]; - (int) sizeof (struct gimple_bb_info)];
#define BB_FREQ_MAX 10000 #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 profile_status_for_function(FN) ((FN)->cfg->x_profile_status)
#define BASIC_BLOCK_FOR_FUNCTION(FN,N) \ #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) \ #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. */ /* Defines for textual backward source compatibility. */
#define ENTRY_BLOCK_PTR (cfun->cfg->x_entry_block_ptr) #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) \ #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) 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. */ /* For iterating over insns in basic block. */
#define FOR_BB_INSNS(BB, INSN) \ #define FOR_BB_INSNS(BB, INSN) \
@ -951,7 +951,7 @@ extern void default_rtl_profile (void);
/* In profile.c. */ /* In profile.c. */
typedef struct gcov_working_set_info gcov_working_set_t; 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. */ /* Check tha probability is sane. */

12
gcc/bb-reorder.c
View File

@ -2329,8 +2329,8 @@ const pass_data pass_data_reorder_blocks =
class pass_reorder_blocks : public rtl_opt_pass class pass_reorder_blocks : public rtl_opt_pass
{ {
public: public:
pass_reorder_blocks(gcc::context *ctxt) pass_reorder_blocks (gcc::context *ctxt)
: rtl_opt_pass(pass_data_reorder_blocks, ctxt) : rtl_opt_pass (pass_data_reorder_blocks, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -2495,8 +2495,8 @@ const pass_data pass_data_duplicate_computed_gotos =
class pass_duplicate_computed_gotos : public rtl_opt_pass class pass_duplicate_computed_gotos : public rtl_opt_pass
{ {
public: public:
pass_duplicate_computed_gotos(gcc::context *ctxt) pass_duplicate_computed_gotos (gcc::context *ctxt)
: rtl_opt_pass(pass_data_duplicate_computed_gotos, ctxt) : rtl_opt_pass (pass_data_duplicate_computed_gotos, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -2719,8 +2719,8 @@ const pass_data pass_data_partition_blocks =
class pass_partition_blocks : public rtl_opt_pass class pass_partition_blocks : public rtl_opt_pass
{ {
public: public:
pass_partition_blocks(gcc::context *ctxt) pass_partition_blocks (gcc::context *ctxt)
: rtl_opt_pass(pass_data_partition_blocks, ctxt) : rtl_opt_pass (pass_data_partition_blocks, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

4
gcc/bitmap.c
View File

@ -811,7 +811,7 @@ bitmap_first_set_bit (const_bitmap a)
bit_no += ix * BITMAP_WORD_BITS; bit_no += ix * BITMAP_WORD_BITS;
#if GCC_VERSION >= 3004 #if GCC_VERSION >= 3004
gcc_assert (sizeof(long) == sizeof (word)); gcc_assert (sizeof (long) == sizeof (word));
bit_no += __builtin_ctzl (word); bit_no += __builtin_ctzl (word);
#else #else
/* Binary search for the first set bit. */ /* Binary search for the first set bit. */
@ -863,7 +863,7 @@ bitmap_last_set_bit (const_bitmap a)
found_bit: found_bit:
bit_no += ix * BITMAP_WORD_BITS; bit_no += ix * BITMAP_WORD_BITS;
#if GCC_VERSION >= 3004 #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; bit_no += BITMAP_WORD_BITS - __builtin_clzl (word) - 1;
#else #else
/* Hopefully this is a twos-complement host... */ /* Hopefully this is a twos-complement host... */

2
gcc/bitmap.h
View File

@ -300,7 +300,7 @@ extern unsigned bitmap_first_set_bit (const_bitmap);
extern unsigned bitmap_last_set_bit (const_bitmap); extern unsigned bitmap_last_set_bit (const_bitmap);
/* Compute bitmap hash (for purposes of hashing etc.) */ /* 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. */ /* Allocate a bitmap from a bit obstack. */
#define BITMAP_ALLOC(OBSTACK) bitmap_obstack_alloc (OBSTACK) #define BITMAP_ALLOC(OBSTACK) bitmap_obstack_alloc (OBSTACK)

26
gcc/bt-load.c
View File

@ -605,7 +605,7 @@ compute_defs_uses_and_gen (fibheap_t all_btr_defs, btr_def *def_array,
} }
if (dump_file) 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. */ for this one. */
bitmap_and_compl (reaching_defs, reaching_defs, bitmap_and_compl (reaching_defs, reaching_defs,
btr_defset[def->btr - first_btr]); btr_defset[def->btr - first_btr]);
bitmap_set_bit(reaching_defs, insn_uid); bitmap_set_bit (reaching_defs, insn_uid);
} }
if (user != NULL) if (user != NULL)
{ {
/* Find all the reaching defs for this use. */ /* 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; unsigned int uid = 0;
sbitmap_iterator sbi; sbitmap_iterator sbi;
@ -1363,7 +1363,7 @@ migrate_btr_def (btr_def def, int min_cost)
if (btr != -1) if (btr != -1)
{ {
move_btr_def (attempt, btr, def, live_range, &btrs_live_in_range); 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; btr_used_near_def = 0;
def_moved = 1; def_moved = 1;
def_basic_block_freq = basic_block_freq (def->bb); 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++) for (i = NUM_FIXED_BLOCKS; i < last_basic_block; i++)
{ {
basic_block bb = BASIC_BLOCK (i); basic_block bb = BASIC_BLOCK (i);
fprintf(dump_file, fprintf (dump_file,
"Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC "Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC
" loop-depth = %d idom = %d\n", " loop-depth = %d idom = %d\n",
i, (HOST_WIDEST_INT) bb->count, bb_loop_depth (bb), i, (HOST_WIDEST_INT) bb->count, bb_loop_depth (bb),
get_immediate_dominator (CDI_DOMINATORS, bb)->index); 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 class pass_branch_target_load_optimize1 : public rtl_opt_pass
{ {
public: public:
pass_branch_target_load_optimize1(gcc::context *ctxt) pass_branch_target_load_optimize1 (gcc::context *ctxt)
: rtl_opt_pass(pass_data_branch_target_load_optimize1, ctxt) : rtl_opt_pass (pass_data_branch_target_load_optimize1, ctxt)
{} {}
/* opt_pass methods: */ /* 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 class pass_branch_target_load_optimize2 : public rtl_opt_pass
{ {
public: public:
pass_branch_target_load_optimize2(gcc::context *ctxt) pass_branch_target_load_optimize2 (gcc::context *ctxt)
: rtl_opt_pass(pass_data_branch_target_load_optimize2, ctxt) : rtl_opt_pass (pass_data_branch_target_load_optimize2, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

46
gcc/builtins.c
View File

@ -1703,7 +1703,7 @@ expand_builtin_apply (rtx function, rtx arguments, rtx argsize)
else else
#endif #endif
emit_stack_restore (SAVE_BLOCK, old_stack_level); 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; OK_DEFER_POP;
@ -4172,7 +4172,7 @@ std_canonical_va_list_type (tree type)
if (INDIRECT_REF_P (type)) if (INDIRECT_REF_P (type))
type = TREE_TYPE (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); type = TREE_TYPE (type);
wtype = va_list_type_node; wtype = va_list_type_node;
htype = type; htype = type;
@ -5342,7 +5342,7 @@ get_memmodel (tree exp)
return MEMMODEL_SEQ_CST; return MEMMODEL_SEQ_CST;
} }
if ((INTVAL(op) & MEMMODEL_MASK) >= MEMMODEL_LAST) if ((INTVAL (op) & MEMMODEL_MASK) >= MEMMODEL_LAST)
{ {
warning (OPT_Winvalid_memory_model, warning (OPT_Winvalid_memory_model,
"invalid memory model argument to builtin"); "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); STRIP_NOPS (addr);
gcc_assert (TREE_OPERAND (addr, 0) == fndecl); 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. */ /* Expand the call here so we can emit trailing code. */
ret = expand_call (exp, target, ignore); 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) fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
{ {
if (validate_arg (arg0, REAL_TYPE) if (validate_arg (arg0, REAL_TYPE)
&& validate_arg(arg1, REAL_TYPE) && validate_arg (arg1, REAL_TYPE)
&& validate_arg(arg2, REAL_TYPE)) && validate_arg (arg2, REAL_TYPE))
{ {
tree tem = fold_fma (loc, type, arg0, arg1, arg2); tree tem = fold_fma (loc, type, arg0, arg1, arg2);
if (tem) if (tem)
@ -10387,13 +10387,13 @@ fold_builtin_1 (location_t loc, tree fndecl, tree arg0, bool ignore)
break; break;
CASE_FLT_FN (BUILT_IN_CCOS): 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): 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): 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): CASE_FLT_FN (BUILT_IN_CSIN):
if (validate_arg (arg0, COMPLEX_TYPE) 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_DREM):
CASE_FLT_FN (BUILT_IN_REMAINDER): CASE_FLT_FN (BUILT_IN_REMAINDER):
if (validate_arg (arg0, REAL_TYPE) 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); return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
break; break;
CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */ CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */ CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
if (validate_arg (arg0, REAL_TYPE) if (validate_arg (arg0, REAL_TYPE)
&& validate_arg(arg1, POINTER_TYPE)) && validate_arg (arg1, POINTER_TYPE))
return do_mpfr_lgamma_r (arg0, arg1, type); return do_mpfr_lgamma_r (arg0, arg1, type);
break; break;
CASE_FLT_FN (BUILT_IN_ATAN2): CASE_FLT_FN (BUILT_IN_ATAN2):
if (validate_arg (arg0, REAL_TYPE) 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); return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
break; break;
CASE_FLT_FN (BUILT_IN_FDIM): CASE_FLT_FN (BUILT_IN_FDIM):
if (validate_arg (arg0, REAL_TYPE) 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); return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
break; break;
@ -10969,8 +10969,8 @@ fold_builtin_3 (location_t loc, tree fndecl,
CASE_FLT_FN (BUILT_IN_REMQUO): CASE_FLT_FN (BUILT_IN_REMQUO):
if (validate_arg (arg0, REAL_TYPE) if (validate_arg (arg0, REAL_TYPE)
&& validate_arg(arg1, REAL_TYPE) && validate_arg (arg1, REAL_TYPE)
&& validate_arg(arg2, POINTER_TYPE)) && validate_arg (arg2, POINTER_TYPE))
return do_mpfr_remquo (arg0, arg1, arg2); return do_mpfr_remquo (arg0, arg1, arg2);
break; break;
@ -13943,7 +13943,7 @@ do_mpfr_bessel_n (tree arg1, tree arg2, tree type,
&& host_integerp (arg1, 0) && host_integerp (arg1, 0)
&& TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2)) && 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); const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
if (n == (long)n if (n == (long)n
@ -14071,7 +14071,7 @@ do_mpfr_lgamma_r (tree arg, tree arg_sg, tree type)
negative integer. */ negative integer. */
if (real_isfinite (ra) if (real_isfinite (ra)
&& ra->cl != rvc_zero && 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 struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
const int prec = fmt->p; 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_t m;
mpc_init2 (m, prec); mpc_init2 (m, prec);
mpfr_from_real (mpc_realref(m), re, rnd); mpfr_from_real (mpc_realref (m), re, rnd);
mpfr_from_real (mpc_imagref(m), im, rnd); mpfr_from_real (mpc_imagref (m), im, rnd);
mpfr_clear_flags (); mpfr_clear_flags ();
inexact = func (m, m, crnd); inexact = func (m, m, crnd);
result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0); 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 (m0, prec);
mpc_init2 (m1, prec); mpc_init2 (m1, prec);
mpfr_from_real (mpc_realref(m0), re0, rnd); mpfr_from_real (mpc_realref (m0), re0, rnd);
mpfr_from_real (mpc_imagref(m0), im0, rnd); mpfr_from_real (mpc_imagref (m0), im0, rnd);
mpfr_from_real (mpc_realref(m1), re1, rnd); mpfr_from_real (mpc_realref (m1), re1, rnd);
mpfr_from_real (mpc_imagref(m1), im1, rnd); mpfr_from_real (mpc_imagref (m1), im1, rnd);
mpfr_clear_flags (); mpfr_clear_flags ();
inexact = func (m0, m0, m1, crnd); inexact = func (m0, m0, m1, crnd);
result = do_mpc_ckconv (m0, type, inexact, do_nonfinite); result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);

3
gcc/calls.c
View File

@ -1732,7 +1732,8 @@ internal_arg_pointer_based_exp_scan (void)
if (val != NULL_RTX) if (val != NULL_RTX)
{ {
if (idx >= internal_arg_pointer_exp_state.cache.length ()) 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; internal_arg_pointer_exp_state.cache[idx] = val;
} }
} }

8
gcc/cfgcleanup.c
View File

@ -3089,8 +3089,8 @@ const pass_data pass_data_jump =
class pass_jump : public rtl_opt_pass class pass_jump : public rtl_opt_pass
{ {
public: public:
pass_jump(gcc::context *ctxt) pass_jump (gcc::context *ctxt)
: rtl_opt_pass(pass_data_jump, ctxt) : rtl_opt_pass (pass_data_jump, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -3133,8 +3133,8 @@ const pass_data pass_data_jump2 =
class pass_jump2 : public rtl_opt_pass class pass_jump2 : public rtl_opt_pass
{ {
public: public:
pass_jump2(gcc::context *ctxt) pass_jump2 (gcc::context *ctxt)
: rtl_opt_pass(pass_data_jump2, ctxt) : rtl_opt_pass (pass_data_jump2, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

12
gcc/cfgexpand.c
View File

@ -569,7 +569,7 @@ add_partitioned_vars_to_ptset (struct pt_solution *pt,
|| pt->vars == NULL || pt->vars == NULL
/* The pointed-to vars bitmap is shared, it is enough to /* The pointed-to vars bitmap is shared, it is enough to
visit it once. */ visit it once. */
|| pointer_set_insert(visited, pt->vars)) || pointer_set_insert (visited, pt->vars))
return; return;
bitmap_clear (temp); 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 /* stack_alignment_estimated shouldn't change after stack
realign decision made */ realign decision made */
gcc_assert(!crtl->stack_realign_processed); gcc_assert (!crtl->stack_realign_processed);
crtl->stack_alignment_estimated = align; crtl->stack_alignment_estimated = align;
} }
@ -1723,7 +1723,7 @@ expand_used_vars (void)
case SPCT_FLAG_DEFAULT: case SPCT_FLAG_DEFAULT:
if (cfun->calls_alloca || has_protected_decls) if (cfun->calls_alloca || has_protected_decls)
create_stack_guard(); create_stack_guard ();
break; break;
default: default:
@ -1770,7 +1770,7 @@ expand_used_vars (void)
var_end_seq var_end_seq
= asan_emit_stack_protection (virtual_stack_vars_rtx, = asan_emit_stack_protection (virtual_stack_vars_rtx,
data.asan_vec.address (), data.asan_vec.address (),
data.asan_decl_vec. address(), data.asan_decl_vec. address (),
data.asan_vec.length ()); data.asan_vec.length ());
} }
@ -4934,8 +4934,8 @@ const pass_data pass_data_expand =
class pass_expand : public rtl_opt_pass class pass_expand : public rtl_opt_pass
{ {
public: public:
pass_expand(gcc::context *ctxt) pass_expand (gcc::context *ctxt)
: rtl_opt_pass(pass_data_expand, ctxt) : rtl_opt_pass (pass_data_expand, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

2
gcc/cfghooks.c
View File

@ -1443,6 +1443,6 @@ account_profile_record (struct profile_record *record, int after_pass)
|| bb == EXIT_BLOCK_PTR_FOR_FUNCTION (cfun)) || bb == EXIT_BLOCK_PTR_FOR_FUNCTION (cfun))
continue; continue;
gcc_assert (cfg_hooks->account_profile_record); 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);
} }
} }

4
gcc/cfgloop.c
View File

@ -433,7 +433,7 @@ flow_loops_find (struct loops *loops)
/* Gather all loop headers in reverse completion order and allocate /* Gather all loop headers in reverse completion order and allocate
loop structures for loops that are not already present. */ 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++) for (b = 0; b < n_basic_blocks - NUM_FIXED_BLOCKS; b++)
{ {
basic_block header = BASIC_BLOCK (rc_order[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; return loops;
} }

2
gcc/cfgloopmanip.c
View File

@ -950,7 +950,7 @@ unloop (struct loop *loop, bool *irred_invalidated,
remove_bb_from_loops (body[i]); remove_bb_from_loops (body[i]);
add_bb_to_loop (body[i], loop_outer (loop)); add_bb_to_loop (body[i], loop_outer (loop));
} }
free(body); free (body);
while (loop->inner) while (loop->inner)
{ {

18
gcc/cfgrtl.c
View File

@ -479,8 +479,8 @@ const pass_data pass_data_free_cfg =
class pass_free_cfg : public rtl_opt_pass class pass_free_cfg : public rtl_opt_pass
{ {
public: public:
pass_free_cfg(gcc::context *ctxt) pass_free_cfg (gcc::context *ctxt)
: rtl_opt_pass(pass_data_free_cfg, ctxt) : rtl_opt_pass (pass_data_free_cfg, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -1441,7 +1441,7 @@ void
emit_barrier_after_bb (basic_block bb) emit_barrier_after_bb (basic_block bb)
{ {
rtx barrier = emit_barrier_after (BB_END (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); || current_ir_type () == IR_RTL_CFGLAYOUT);
if (current_ir_type () == IR_RTL_CFGLAYOUT) if (current_ir_type () == IR_RTL_CFGLAYOUT)
BB_FOOTER (bb) = unlink_insn_chain (barrier, barrier); 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 again (in compgoto). Ensure we don't call this before going back
into linearized RTL when any layout fixes would have been committed. */ into linearized RTL when any layout fixes would have been committed. */
if (!crtl->bb_reorder_complete if (!crtl->bb_reorder_complete
|| current_ir_type() != IR_RTL_CFGRTL) || current_ir_type () != IR_RTL_CFGRTL)
return err; return err;
FOR_EACH_BB (bb) 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 class pass_into_cfg_layout_mode : public rtl_opt_pass
{ {
public: public:
pass_into_cfg_layout_mode(gcc::context *ctxt) pass_into_cfg_layout_mode (gcc::context *ctxt)
: rtl_opt_pass(pass_data_into_cfg_layout_mode, ctxt) : rtl_opt_pass (pass_data_into_cfg_layout_mode, ctxt)
{} {}
/* opt_pass methods: */ /* 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 class pass_outof_cfg_layout_mode : public rtl_opt_pass
{ {
public: public:
pass_outof_cfg_layout_mode(gcc::context *ctxt) pass_outof_cfg_layout_mode (gcc::context *ctxt)
: rtl_opt_pass(pass_data_outof_cfg_layout_mode, ctxt) : rtl_opt_pass (pass_data_outof_cfg_layout_mode, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -4887,7 +4887,7 @@ rtl_lv_add_condition_to_bb (basic_block first_head ,
end_sequence (); end_sequence ();
/* Add the new cond , in the new head. */ /* Add the new cond , in the new head. */
emit_insn_after(seq, BB_END(cond_bb)); emit_insn_after (seq, BB_END (cond_bb));
} }

20
gcc/cgraph.c
View File

@ -1635,7 +1635,7 @@ release_function_body (tree decl)
} }
if (cfun->value_histograms) if (cfun->value_histograms)
free_histograms (); free_histograms ();
pop_cfun(); pop_cfun ();
gimple_set_body (decl, NULL); gimple_set_body (decl, NULL);
/* Struct function hangs a lot of data that would leak if we didn't /* Struct function hangs a lot of data that would leak if we didn't
removed all pointers to it. */ 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 /* Clear out the node to NULL all pointers and add the node to the free
list. */ list. */
memset (node, 0, sizeof(*node)); memset (node, 0, sizeof (*node));
node->symbol.type = SYMTAB_FUNCTION; node->symbol.type = SYMTAB_FUNCTION;
node->uid = uid; node->uid = uid;
SET_NEXT_FREE_NODE (node, free_nodes); 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) ", fprintf (f, "(%.2f per call) ",
edge->frequency / (double)CGRAPH_FREQ_BASE); edge->frequency / (double)CGRAPH_FREQ_BASE);
if (edge->speculative) if (edge->speculative)
fprintf(f, "(speculative) "); fprintf (f, "(speculative) ");
if (!edge->inline_failed) if (!edge->inline_failed)
fprintf(f, "(inlined) "); fprintf (f, "(inlined) ");
if (edge->indirect_inlining_edge) if (edge->indirect_inlining_edge)
fprintf(f, "(indirect_inlining) "); fprintf (f, "(indirect_inlining) ");
if (edge->can_throw_external) if (edge->can_throw_external)
fprintf(f, "(can throw external) "); fprintf (f, "(can throw external) ");
} }
fprintf (f, "\n Calls: "); 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), fprintf (f, "%s/%i ", cgraph_node_asm_name (edge->callee),
edge->callee->symbol.order); edge->callee->symbol.order);
if (edge->speculative) if (edge->speculative)
fprintf(f, "(speculative) "); fprintf (f, "(speculative) ");
if (!edge->inline_failed) if (!edge->inline_failed)
fprintf(f, "(inlined) "); fprintf (f, "(inlined) ");
if (edge->indirect_inlining_edge) if (edge->indirect_inlining_edge)
fprintf(f, "(indirect_inlining) "); fprintf (f, "(indirect_inlining) ");
if (edge->count) if (edge->count)
fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ", fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
(HOST_WIDEST_INT)edge->count); (HOST_WIDEST_INT)edge->count);
@ -1974,7 +1974,7 @@ dump_cgraph_node (FILE *f, struct cgraph_node *node)
fprintf (f, "(%.2f per call) ", fprintf (f, "(%.2f per call) ",
edge->frequency / (double)CGRAPH_FREQ_BASE); edge->frequency / (double)CGRAPH_FREQ_BASE);
if (edge->can_throw_external) if (edge->can_throw_external)
fprintf(f, "(can throw external) "); fprintf (f, "(can throw external) ");
} }
fprintf (f, "\n"); fprintf (f, "\n");

6
gcc/cgraph.h
View File

@ -901,21 +901,21 @@ cgraph_node_asm_name (struct cgraph_node *node)
/* Return asm name of varpool node. */ /* Return asm name of varpool node. */
static inline const char * 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 symtab_node_asm_name ((symtab_node)node);
} }
/* Return name of cgraph node. */ /* Return name of cgraph node. */
static inline const char * 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 symtab_node_name ((symtab_node)node);
} }
/* Return name of varpool node. */ /* Return name of varpool node. */
static inline const char * 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); return symtab_node_name ((symtab_node)node);
} }

12
gcc/cgraphbuild.c
View File

@ -393,8 +393,8 @@ const pass_data pass_data_build_cgraph_edges =
class pass_build_cgraph_edges : public gimple_opt_pass class pass_build_cgraph_edges : public gimple_opt_pass
{ {
public: public:
pass_build_cgraph_edges(gcc::context *ctxt) pass_build_cgraph_edges (gcc::context *ctxt)
: gimple_opt_pass(pass_data_build_cgraph_edges, ctxt) : gimple_opt_pass (pass_data_build_cgraph_edges, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -525,8 +525,8 @@ const pass_data pass_data_rebuild_cgraph_edges =
class pass_rebuild_cgraph_edges : public gimple_opt_pass class pass_rebuild_cgraph_edges : public gimple_opt_pass
{ {
public: public:
pass_rebuild_cgraph_edges(gcc::context *ctxt) pass_rebuild_cgraph_edges (gcc::context *ctxt)
: gimple_opt_pass(pass_data_rebuild_cgraph_edges, ctxt) : gimple_opt_pass (pass_data_rebuild_cgraph_edges, ctxt)
{} {}
/* opt_pass methods: */ /* 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 class pass_remove_cgraph_callee_edges : public gimple_opt_pass
{ {
public: public:
pass_remove_cgraph_callee_edges(gcc::context *ctxt) pass_remove_cgraph_callee_edges (gcc::context *ctxt)
: gimple_opt_pass(pass_data_remove_cgraph_callee_edges, ctxt) : gimple_opt_pass (pass_data_remove_cgraph_callee_edges, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

4
gcc/cgraphclones.c
View File

@ -750,8 +750,8 @@ cgraph_function_versioning (struct cgraph_node *old_version_node,
SET_DECL_RTL (new_decl, NULL); SET_DECL_RTL (new_decl, NULL);
/* When the old decl was a con-/destructor make sure the clone isn't. */ /* When the old decl was a con-/destructor make sure the clone isn't. */
DECL_STATIC_CONSTRUCTOR(new_decl) = 0; DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
DECL_STATIC_DESTRUCTOR(new_decl) = 0; DECL_STATIC_DESTRUCTOR (new_decl) = 0;
/* Create the new version's call-graph node. /* Create the new version's call-graph node.
and update the edges of the new node. */ and update the edges of the new node. */

4
gcc/cgraphunit.c
View File

@ -850,7 +850,7 @@ walk_polymorphic_call_targets (pointer_set_t *reachable_call_targets,
dump_possible_polymorphic_call_targets dump_possible_polymorphic_call_targets
(cgraph_dump_file, edge); (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; /* Do not bother to mark virtual methods in anonymous namespace;
either we will find use of virtual table defining it, or it is 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. */ make the edge direct. */
if (final) if (final)
{ {
if (targets.length() <= 1) if (targets.length () <= 1)
{ {
cgraph_node *target; cgraph_node *target;
if (targets.length () == 1) if (targets.length () == 1)

34
gcc/collect2.c
View File

@ -602,7 +602,7 @@ is_ctor_dtor (const char *s)
{ {
if (ch == p->name[0] if (ch == p->name[0]
&& (!p->two_underscores || ((s - orig_s) >= 2)) && (!p->two_underscores || ((s - orig_s) >= 2))
&& strncmp(s, p->name, p->len) == 0) && strncmp (s, p->name, p->len) == 0)
{ {
return p->ret; return p->ret;
} }
@ -777,7 +777,7 @@ maybe_run_lto_and_relink (char **lto_ld_argv, char **object_lst,
plus number of partitions. */ plus number of partitions. */
for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++) 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; out_lto_ld_argv_size = 0;
/* After running the LTO back end, we will relink, substituting /* After running the LTO back end, we will relink, substituting
@ -1644,9 +1644,9 @@ main (int argc, char **argv)
"%d destructors found\n", "%d destructors found\n",
destructors.number), destructors.number),
destructors.number); destructors.number);
notice_translated (ngettext("%d frame table found\n", notice_translated (ngettext ("%d frame table found\n",
"%d frame tables found\n", "%d frame tables found\n",
frame_tables.number), frame_tables.number),
frame_tables.number); frame_tables.number);
} }
@ -1698,7 +1698,7 @@ main (int argc, char **argv)
sort_ids (&constructors); sort_ids (&constructors);
sort_ids (&destructors); sort_ids (&destructors);
maybe_unlink(output_file); maybe_unlink (output_file);
outf = fopen (c_file, "w"); outf = fopen (c_file, "w");
if (outf == (FILE *) 0) if (outf == (FILE *) 0)
fatal_error ("fopen %s: %m", c_file); fatal_error ("fopen %s: %m", c_file);
@ -1812,8 +1812,8 @@ collect_wait (const char *prog, struct pex_obj *pex)
{ {
int sig = WTERMSIG (status); int sig = WTERMSIG (status);
error ("%s terminated with signal %d [%s]%s", error ("%s terminated with signal %d [%s]%s",
prog, sig, strsignal(sig), prog, sig, strsignal (sig),
WCOREDUMP(status) ? ", core dumped" : ""); WCOREDUMP (status) ? ", core dumped" : "");
exit (FATAL_EXIT_CODE); exit (FATAL_EXIT_CODE);
} }
@ -2255,8 +2255,8 @@ write_c_file_stat (FILE *stream, const char *name ATTRIBUTE_UNUSED)
if (shared_obj) if (shared_obj)
{ {
COLLECT_SHARED_INIT_FUNC(stream, initname); COLLECT_SHARED_INIT_FUNC (stream, initname);
COLLECT_SHARED_FINI_FUNC(stream, fininame); COLLECT_SHARED_FINI_FUNC (stream, fininame);
} }
} }
@ -2727,16 +2727,16 @@ scan_libraries (const char *prog_name)
#if defined (EXTENDED_COFF) #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_SYMENT SYMR
# define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal) # define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
# define GCC_SYMINC(X) (1) # define GCC_SYMINC(X) (1)
# define GCC_SYMZERO(X) (SYMHEADER(X).isymMax) # define GCC_SYMZERO(X) (SYMHEADER (X).isymMax)
# define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0) # define GCC_CHECK_HDR(X) (PSYMTAB (X) != 0)
#else #else
# define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms) # define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
# define GCC_SYMENT SYMENT # define GCC_SYMENT SYMENT
# if defined (C_WEAKEXT) # if defined (C_WEAKEXT)
# define GCC_OK_SYMBOL(X) \ # define GCC_OK_SYMBOL(X) \
@ -2994,7 +2994,7 @@ scan_prog_file (const char *prog_name, scanpass which_pass,
while (ldclose (ldptr) == FAILURE); while (ldclose (ldptr) == FAILURE);
#else #else
/* Otherwise we simply close ldptr. */ /* Otherwise we simply close ldptr. */
(void) ldclose(ldptr); (void) ldclose (ldptr);
#endif #endif
} }
#endif /* OBJECT_FORMAT_COFF */ #endif /* OBJECT_FORMAT_COFF */
@ -3014,7 +3014,7 @@ resolve_lib_name (const char *name)
if (libpaths[i]->max_len > l) if (libpaths[i]->max_len > l)
l = libpaths[i]->max_len; 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++) 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 may contain directories both with trailing DIR_SEPARATOR and
without it. */ without it. */
const char *p = ""; const char *p = "";
if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1])) if (!IS_DIR_SEPARATOR (list->prefix[strlen (list->prefix)-1]))
p = "/"; p = "/";
for (j = 0; j < 2; j++) for (j = 0; j < 2; j++)
{ {

4
gcc/combine-stack-adj.c
View File

@ -663,8 +663,8 @@ const pass_data pass_data_stack_adjustments =
class pass_stack_adjustments : public rtl_opt_pass class pass_stack_adjustments : public rtl_opt_pass
{ {
public: public:
pass_stack_adjustments(gcc::context *ctxt) pass_stack_adjustments (gcc::context *ctxt)
: rtl_opt_pass(pass_data_stack_adjustments, ctxt) : rtl_opt_pass (pass_data_stack_adjustments, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

26
gcc/combine.c
View File

@ -735,7 +735,7 @@ do_SUBST (rtx *into, rtx newval)
buf->next = undobuf.undos, undobuf.undos = buf; 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 /* 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 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; 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 /* Similar to SUBST, but just substitute the mode. This is used when
changing the mode of a pseudo-register, so that any other 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; 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 #ifndef HAVE_cc0
/* Similar to SUBST, but NEWVAL is a LOG_LINKS expression. */ /* 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), INSN_COST (insn) = insn_rtx_cost (PATTERN (insn),
optimize_this_for_speed_p); optimize_this_for_speed_p);
if (dump_file) if (dump_file)
fprintf(dump_file, "insn_cost %d: %d\n", fprintf (dump_file, "insn_cost %d: %d\n",
INSN_UID (insn), INSN_COST (insn)); 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; unsigned int regno;
if (!REG_P(x)) if (!REG_P (x))
return false; return false;
regno = REGNO (x); 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); 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) 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); 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) 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); 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) 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); 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) 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 this shift are known to be zero for both inputs and if the type of
comparison is compatible with the shift. */ comparison is compatible with the shift. */
if (GET_CODE (op0) == GET_CODE (op1) 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) == ROTATE && (code == NE || code == EQ))
|| ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT) || ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT)
&& (code != GT && code != LT && code != GE && code != LE)) && (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 class pass_combine : public rtl_opt_pass
{ {
public: public:
pass_combine(gcc::context *ctxt) pass_combine (gcc::context *ctxt)
: rtl_opt_pass(pass_data_combine, ctxt) : rtl_opt_pass (pass_data_combine, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

6
gcc/compare-elim.c
View File

@ -247,7 +247,7 @@ class find_comparison_dom_walker : public dom_walker
{ {
public: public:
find_comparison_dom_walker (cdi_direction direction) find_comparison_dom_walker (cdi_direction direction)
: dom_walker(direction) {} : dom_walker (direction) {}
virtual void before_dom_children (basic_block); 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 class pass_compare_elim_after_reload : public rtl_opt_pass
{ {
public: public:
pass_compare_elim_after_reload(gcc::context *ctxt) pass_compare_elim_after_reload (gcc::context *ctxt)
: rtl_opt_pass(pass_data_compare_elim_after_reload, ctxt) : rtl_opt_pass (pass_data_compare_elim_after_reload, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

2
gcc/context.c
View File

@ -27,7 +27,7 @@ along with GCC; see the file COPYING3. If not see
/* The singleton holder of global state: */ /* The singleton holder of global state: */
gcc::context *g; gcc::context *g;
gcc::context::context() gcc::context::context ()
{ {
passes_ = new gcc::pass_manager (this); passes_ = new gcc::pass_manager (this);
} }

2
gcc/context.h
View File

@ -30,7 +30,7 @@ class pass_manager;
class context class context
{ {
public: public:
context(); context ();
/* Pass-management. */ /* Pass-management. */

13
gcc/cprop.c
View File

@ -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. */ /* Record bitmap_index of the implicit set in implicit_set_indexes. */
if (implicit) 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. /* 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; implicit_sets[dest->index] = new_rtx;
if (dump_file) if (dump_file)
{ {
fprintf(dump_file, "Implicit set of reg %d in ", fprintf (dump_file, "Implicit set of reg %d in ",
REGNO (XEXP (cond, 0))); REGNO (XEXP (cond, 0)));
fprintf(dump_file, "basic block %d\n", dest->index); fprintf (dump_file, "basic block %d\n", dest->index);
} }
count++; count++;
} }
@ -1934,8 +1935,8 @@ const pass_data pass_data_rtl_cprop =
class pass_rtl_cprop : public rtl_opt_pass class pass_rtl_cprop : public rtl_opt_pass
{ {
public: public:
pass_rtl_cprop(gcc::context *ctxt) pass_rtl_cprop (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_cprop, ctxt) : rtl_opt_pass (pass_data_rtl_cprop, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

16
gcc/cse.c
View File

@ -468,7 +468,7 @@ struct table_elt
a cost of 2. Aside from these special cases, call `rtx_cost'. */ a cost of 2. Aside from these special cases, call `rtx_cost'. */
#define CHEAP_REGNO(N) \ #define CHEAP_REGNO(N) \
(REGNO_PTR_FRAME_P(N) \ (REGNO_PTR_FRAME_P (N) \
|| (HARD_REGISTER_NUM_P (N) \ || (HARD_REGISTER_NUM_P (N) \
&& FIXED_REGNO_P (N) && REGNO_REG_CLASS (N) != NO_REGS)) && 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 /* Set what we are trying to extend and the operation it might
have been extended with. */ 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)); PUT_CODE (memory_extend_rtx, LOAD_EXTEND_OP (mode));
XEXP (memory_extend_rtx, 0) = src; XEXP (memory_extend_rtx, 0) = src;
@ -7479,8 +7479,8 @@ const pass_data pass_data_cse =
class pass_cse : public rtl_opt_pass class pass_cse : public rtl_opt_pass
{ {
public: public:
pass_cse(gcc::context *ctxt) pass_cse (gcc::context *ctxt)
: rtl_opt_pass(pass_data_cse, ctxt) : rtl_opt_pass (pass_data_cse, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -7559,8 +7559,8 @@ const pass_data pass_data_cse2 =
class pass_cse2 : public rtl_opt_pass class pass_cse2 : public rtl_opt_pass
{ {
public: public:
pass_cse2(gcc::context *ctxt) pass_cse2 (gcc::context *ctxt)
: rtl_opt_pass(pass_data_cse2, ctxt) : rtl_opt_pass (pass_data_cse2, ctxt)
{} {}
/* opt_pass methods: */ /* 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 class pass_cse_after_global_opts : public rtl_opt_pass
{ {
public: public:
pass_cse_after_global_opts(gcc::context *ctxt) pass_cse_after_global_opts (gcc::context *ctxt)
: rtl_opt_pass(pass_data_cse_after_global_opts, ctxt) : rtl_opt_pass (pass_data_cse_after_global_opts, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

4
gcc/cselib.c
View File

@ -259,10 +259,10 @@ void (*cselib_record_sets_hook) (rtx insn, struct cselib_set *sets,
int n_sets); int n_sets);
#define PRESERVED_VALUE_P(RTX) \ #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) \ #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)

16
gcc/dbxout.c
View File

@ -636,7 +636,7 @@ dbxout_begin_complex_stabs_noforcetext (void)
#define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr) #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
/* Add STR, a normal C string, to the string being built. */ /* 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. */ /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
#define stabstr_I(id) obstack_grow (&stabstr_ob, \ #define stabstr_I(id) obstack_grow (&stabstr_ob, \
@ -2434,7 +2434,7 @@ dbxout_class_name_qualifiers (tree decl)
tree context = decl_type_context (decl); tree context = decl_type_context (decl);
if (context != NULL_TREE if (context != NULL_TREE
&& TREE_CODE(context) == RECORD_TYPE && TREE_CODE (context) == RECORD_TYPE
&& TYPE_NAME (context) != 0 && TYPE_NAME (context) != 0
&& (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
|| (DECL_NAME (TYPE_NAME (context)) != 0))) || (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 for thread-local symbols. Can be handled via same mechanism as used
in dwarf2out.c. */ in dwarf2out.c. */
if (TREE_CODE (decl) != VAR_DECL if (TREE_CODE (decl) != VAR_DECL
|| !TREE_STATIC(decl) || !TREE_STATIC (decl)
|| !DECL_HAS_VALUE_EXPR_P(decl) || !DECL_HAS_VALUE_EXPR_P (decl)
|| DECL_THREAD_LOCAL_P (decl) || DECL_THREAD_LOCAL_P (decl)
|| !is_fortran ()) || !is_fortran ())
return NULL; return NULL;
@ -3337,21 +3337,21 @@ dbxout_common_check (tree decl, int *value)
if (CONST_INT_P (XEXP (sym_addr, 0))) if (CONST_INT_P (XEXP (sym_addr, 0)))
{ {
name = 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)); *value = INTVAL (XEXP (sym_addr, 0));
cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1)); cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
} }
else else
{ {
name = 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)); *value = INTVAL (XEXP (sym_addr, 1));
cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0)); cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
} }
break; break;
case SYMBOL_REF: case SYMBOL_REF:
name = targetm.strip_name_encoding(XSTR (sym_addr, 0)); name = targetm.strip_name_encoding (XSTR (sym_addr, 0));
*value = 0; *value = 0;
cdecl = SYMBOL_REF_DECL (sym_addr); cdecl = SYMBOL_REF_DECL (sym_addr);
break; 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 /* 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 it is not a symbol in a common block. It must be a .lcomm symbol, not
a .comm symbol. */ a .comm symbol. */
if (cdecl == NULL || !TREE_PUBLIC(cdecl)) if (cdecl == NULL || !TREE_PUBLIC (cdecl))
name = NULL; name = NULL;
} }
else else

8
gcc/dce.c
View File

@ -806,8 +806,8 @@ const pass_data pass_data_ud_rtl_dce =
class pass_ud_rtl_dce : public rtl_opt_pass class pass_ud_rtl_dce : public rtl_opt_pass
{ {
public: public:
pass_ud_rtl_dce(gcc::context *ctxt) pass_ud_rtl_dce (gcc::context *ctxt)
: rtl_opt_pass(pass_data_ud_rtl_dce, ctxt) : rtl_opt_pass (pass_data_ud_rtl_dce, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -1239,8 +1239,8 @@ const pass_data pass_data_fast_rtl_dce =
class pass_fast_rtl_dce : public rtl_opt_pass class pass_fast_rtl_dce : public rtl_opt_pass
{ {
public: public:
pass_fast_rtl_dce(gcc::context *ctxt) pass_fast_rtl_dce (gcc::context *ctxt)
: rtl_opt_pass(pass_data_fast_rtl_dce, ctxt) : rtl_opt_pass (pass_data_fast_rtl_dce, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

8
gcc/defaults.h
View File

@ -76,7 +76,7 @@ see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
int c = p[i]; \ int c = p[i]; \
if (c == '\"' || c == '\\') \ if (c == '\"' || c == '\\') \
putc ('\\', asm_out_file); \ putc ('\\', asm_out_file); \
if (ISPRINT(c)) \ if (ISPRINT (c)) \
putc (c, asm_out_file); \ putc (c, asm_out_file); \
else \ 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 \ The VAX assembler fails to stop reading the escape \
after three digits, so this is the only way we \ after three digits, so this is the only way we \
can get it to parse the data properly. */ \ 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 \""); \ 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, /* If we have named sections, and we're using crtstuff to run ctors,
use them for registering eh frame information. */ use them for registering eh frame information. */
#if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \ #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 #ifndef EH_FRAME_SECTION_NAME
#define EH_FRAME_SECTION_NAME ".eh_frame" #define EH_FRAME_SECTION_NAME ".eh_frame"
#endif #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 SET_RATIO or more simple move-instruction sequences, we will do a movmem
or libcall instead. */ or libcall instead. */
#ifndef SET_RATIO #ifndef SET_RATIO
#define SET_RATIO(speed) MOVE_RATIO(speed) #define SET_RATIO(speed) MOVE_RATIO (speed)
#endif #endif
/* Supply a default definition for FUNCTION_ARG_PADDING: /* Supply a default definition for FUNCTION_ARG_PADDING:

16
gcc/df-core.c
View File

@ -549,7 +549,7 @@ df_set_blocks (bitmap blocks)
{ {
basic_block bb; basic_block bb;
bitmap_initialize (&blocks_to_reset, &df_bitmap_obstack); bitmap_initialize (&blocks_to_reset, &df_bitmap_obstack);
FOR_ALL_BB(bb) FOR_ALL_BB (bb)
{ {
bitmap_set_bit (&blocks_to_reset, bb->index); 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 class pass_df_initialize_opt : public rtl_opt_pass
{ {
public: public:
pass_df_initialize_opt(gcc::context *ctxt) pass_df_initialize_opt (gcc::context *ctxt)
: rtl_opt_pass(pass_data_df_initialize_opt, ctxt) : rtl_opt_pass (pass_data_df_initialize_opt, ctxt)
{} {}
/* opt_pass methods: */ /* 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 class pass_df_initialize_no_opt : public rtl_opt_pass
{ {
public: public:
pass_df_initialize_no_opt(gcc::context *ctxt) pass_df_initialize_no_opt (gcc::context *ctxt)
: rtl_opt_pass(pass_data_df_initialize_no_opt, ctxt) : rtl_opt_pass (pass_data_df_initialize_no_opt, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -878,8 +878,8 @@ const pass_data pass_data_df_finish =
class pass_df_finish : public rtl_opt_pass class pass_df_finish : public rtl_opt_pass
{ {
public: public:
pass_df_finish(gcc::context *ctxt) pass_df_finish (gcc::context *ctxt)
: rtl_opt_pass(pass_data_df_finish, ctxt) : rtl_opt_pass (pass_data_df_finish, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -2078,7 +2078,7 @@ df_dump_start (FILE *file)
{ {
df_dump_problem_function fun = dflow->problem->dump_start_fun; df_dump_problem_function fun = dflow->problem->dump_start_fun;
if (fun) if (fun)
fun(file); fun (file);
} }
} }
} }

6
gcc/df-problems.c
View File

@ -326,7 +326,7 @@ df_rd_bb_local_compute_process_def (struct df_rd_bb_info *bb_info,
if (n_defs > DF_SPARSE_THRESHOLD) if (n_defs > DF_SPARSE_THRESHOLD)
{ {
bitmap_set_bit (&bb_info->sparse_kill, regno); 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 else
{ {
@ -594,7 +594,7 @@ df_rd_start_dump (FILE *file)
{ {
struct df_rd_problem_data *problem_data struct df_rd_problem_data *problem_data
= (struct df_rd_problem_data *) df_rd->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; unsigned int regno;
if (!df_rd->block_info) 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; bitmap_head tmp;
unsigned int regno; unsigned int regno;
unsigned int m = DF_REG_SIZE(df); unsigned int m = DF_REG_SIZE (df);
bool first_reg = true; bool first_reg = true;
fprintf (file, "%s\t(%d) ", prefix, (int) bitmap_count_bits (defs_set)); fprintf (file, "%s\t(%d) ", prefix, (int) bitmap_count_bits (defs_set));

14
gcc/df-scan.c
View File

@ -191,9 +191,9 @@ df_scan_free_internal (void)
/* The vectors that hold the refs are not pool allocated because /* The vectors that hold the refs are not pool allocated because
they come in many sizes. This makes them impossible to delete they come in many sizes. This makes them impossible to delete
all at once. */ 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 /* Skip the insns that have no insn_info or have been
deleted. */ deleted. */
if (insn_info) if (insn_info)
@ -233,7 +233,7 @@ df_scan_free_internal (void)
free (df->eq_use_regs); free (df->eq_use_regs);
df->eq_use_regs = NULL; df->eq_use_regs = NULL;
df->regs_size = 0; df->regs_size = 0;
DF_REG_SIZE(df) = 0; DF_REG_SIZE (df) = 0;
free (df->insns); free (df->insns);
df->insns = NULL; df->insns = NULL;
@ -2188,7 +2188,7 @@ df_notes_rescan (rtx insn)
df_grow_bb_info (df_scan); df_grow_bb_info (df_scan);
df_grow_reg_info (); 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. */ /* The client has deferred rescanning. */
if (df->changeable_flags & DF_DEFER_INSN_RESCAN) 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++) for (i = 0; i < DF_REG_SIZE (df); i++)
{ {
gcc_assert (df_reg_chain_mark (DF_REG_DEF_CHAIN (i), i, true, false) 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) 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) 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 /* (2) There are various bitmaps whose value may change over the

59
gcc/df.h
View File

@ -607,29 +607,29 @@ struct df_d
bool redo_entry_and_exit; bool redo_entry_and_exit;
}; };
#define DF_SCAN_BB_INFO(BB) (df_scan_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_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_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_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_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_MD_BB_INFO(BB) (df_md_get_bb_info ((BB)->index))
/* Most transformations that wish to use live register analysis will /* Most transformations that wish to use live register analysis will
use these macros. This info is the and of the lr and live sets. */ 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_IN(BB) (&DF_LIVE_BB_INFO (BB)->in)
#define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO(BB)->out) #define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO (BB)->out)
/* These macros are used by passes that are not tolerant of /* These macros are used by passes that are not tolerant of
uninitialized variables. This intolerance should eventually uninitialized variables. This intolerance should eventually
be fixed. */ be fixed. */
#define DF_LR_IN(BB) (&DF_LR_BB_INFO(BB)->in) #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_OUT(BB) (&DF_LR_BB_INFO (BB)->out)
/* These macros are used by passes that are not tolerant of /* These macros are used by passes that are not tolerant of
uninitialized variables. This intolerance should eventually uninitialized variables. This intolerance should eventually
be fixed. */ be fixed. */
#define DF_WORD_LR_IN(BB) (&DF_WORD_LR_BB_INFO(BB)->in) #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_OUT(BB) (&DF_WORD_LR_BB_INFO (BB)->out)
/* Macros to access the elements within the ref structure. */ /* 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 \ #define DF_REF_REAL_LOC(REF) (GET_CODE (*((REF)->regular_ref.loc)) == SUBREG \
? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc)) ? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc))
#define DF_REF_REG(REF) ((REF)->base.reg) #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) (REF)->regular_ref.loc : NULL)
#define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL(REF) ? \ #define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL (REF) \
(REF)->artificial_ref.bb : BLOCK_FOR_INSN (DF_REF_INSN(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_BBNO(REF) (DF_REF_BB (REF)->index)
#define DF_REF_INSN_INFO(REF) ((REF)->base.insn_info) #define DF_REF_INSN_INFO(REF) ((REF)->base.insn_info)
#define DF_REF_INSN(REF) ((REF)->base.insn_info->insn) #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 /* If DF_REF_IS_ARTIFICIAL () is true, this is not a real
definition/use, but an artificial one created to model always live definition/use, but an artificial one created to model always live
registers, eh uses, etc. */ 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_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_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)) #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. */ /* Macros to access the elements within the reg_info structure table. */
#define DF_REGNO_FIRST_DEF(REGNUM) \ #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) \ #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. */ /* Macros to access the elements within the insn_info structure table. */
#define DF_INSN_SIZE() ((df)->insns_size) #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_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL))
#define DF_INSN_INFO_LUID(II) ((II)->luid) #define DF_INSN_INFO_LUID(II) ((II)->luid)
#define DF_INSN_INFO_DEFS(II) ((II)->defs) #define DF_INSN_INFO_DEFS(II) ((II)->defs)
#define DF_INSN_INFO_USES(II) ((II)->uses) #define DF_INSN_INFO_USES(II) ((II)->uses)
#define DF_INSN_INFO_EQ_USES(II) ((II)->eq_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_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_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_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_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_GET(UID) (df->insns[(UID)])
#define DF_INSN_UID_SET(UID,VAL) (df->insns[(UID)]=(VAL)) #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) \ ? DF_INSN_UID_GET (UID) \
: NULL) : NULL)
#define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET(INSN)->luid) #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_DEFS(INSN) (DF_INSN_UID_GET (INSN)->defs)
#define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET(INSN)->uses) #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_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_MWS(INSN) (DF_INSN_UID_GET (INSN)->mw_hardregs)
/* An obstack for bitmap not related to specific dataflow problems. /* An obstack for bitmap not related to specific dataflow problems.
This obstack should e.g. be used for bitmaps with a short life time This obstack should e.g. be used for bitmaps with a short life time

6
gcc/diagnostic.c
View File

@ -267,7 +267,7 @@ adjust_line (const char *line, int max_width, int *column_p)
int line_width = strlen (line); int line_width = strlen (line);
int column = *column_p; 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; right_margin = max_width - right_margin;
if (line_width >= max_width && column > 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. */ /* Skip functions in diagnostic.c. */
if (*pcount == 0 if (*pcount == 0
&& filename != NULL && filename != NULL
&& strcmp (lbasename(filename), "diagnostic.c") == 0) && strcmp (lbasename (filename), "diagnostic.c") == 0)
return 0; return 0;
/* Print up to 20 functions. We could make this a --param, but /* 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_destroy_prefix (context->printer);
pp_set_prefix (context->printer, saved_prefix); pp_set_prefix (context->printer, saved_prefix);
diagnostic_show_locus (context, &diagnostic); diagnostic_show_locus (context, &diagnostic);
va_end(ap); va_end (ap);
} }
bool bool

4
gcc/double-int.c
View File

@ -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 for representing the value. The code to calculate count is
extracted from the GMP manual, section "Integer Import and Export": extracted from the GMP manual, section "Integer Import and Export":
http://gmplib.org/manual/Integer-Import-and-Export.html */ 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; count = (mpz_sizeinbase (val, 2) + numb-1) / numb;
if (count < 2) if (count < 2)
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[0] = 0;
vp[1] = 0; vp[1] = 0;

12
gcc/dse.c
View File

@ -2916,8 +2916,8 @@ dse_step2_nospill (void)
if (group == clear_alias_group) if (group == clear_alias_group)
continue; continue;
memset (group->offset_map_n, 0, sizeof(int) * group->offset_map_size_n); 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_p, 0, sizeof (int) * group->offset_map_size_p);
bitmap_clear (group->group_kill); bitmap_clear (group->group_kill);
EXECUTE_IF_SET_IN_BITMAP (group->store2_n, 0, j, bi) 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 class pass_rtl_dse1 : public rtl_opt_pass
{ {
public: public:
pass_rtl_dse1(gcc::context *ctxt) pass_rtl_dse1 (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_dse1, ctxt) : rtl_opt_pass (pass_data_rtl_dse1, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -3787,8 +3787,8 @@ const pass_data pass_data_rtl_dse2 =
class pass_rtl_dse2 : public rtl_opt_pass class pass_rtl_dse2 : public rtl_opt_pass
{ {
public: public:
pass_rtl_dse2(gcc::context *ctxt) pass_rtl_dse2 (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_dse2, ctxt) : rtl_opt_pass (pass_data_rtl_dse2, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

26
gcc/dumpfile.c
View File

@ -240,10 +240,10 @@ dump_open_alternate_stream (struct dump_file_info *dfi)
if (dfi->alt_stream) if (dfi->alt_stream)
return dfi->alt_stream; return dfi->alt_stream;
stream = strcmp("stderr", dfi->alt_filename) == 0 stream = strcmp ("stderr", dfi->alt_filename) == 0
? stderr ? stderr
: strcmp("stdout", dfi->alt_filename) == 0 : strcmp ("stdout", dfi->alt_filename) == 0
? stdout ? stdout
: fopen (dfi->alt_filename, dfi->alt_state < 0 ? "w" : "a"); : fopen (dfi->alt_filename, dfi->alt_state < 0 ? "w" : "a");
if (!stream) if (!stream)
@ -404,10 +404,10 @@ dump_start (int phase, int *flag_ptr)
name = get_dump_file_name (phase); name = get_dump_file_name (phase);
if (name) if (name)
{ {
stream = strcmp("stderr", name) == 0 stream = strcmp ("stderr", name) == 0
? stderr ? stderr
: strcmp("stdout", name) == 0 : strcmp ("stdout", name) == 0
? stdout ? stdout
: fopen (name, dfi->pstate < 0 ? "w" : "a"); : fopen (name, dfi->pstate < 0 ? "w" : "a");
if (!stream) if (!stream)
error ("could not open dump file %qs: %m", name); error ("could not open dump file %qs: %m", name);
@ -451,12 +451,12 @@ dump_finish (int phase)
return; return;
dfi = get_dump_file_info (phase); dfi = get_dump_file_info (phase);
if (dfi->pstream && (!dfi->pfilename if (dfi->pstream && (!dfi->pfilename
|| (strcmp("stderr", dfi->pfilename) != 0 || (strcmp ("stderr", dfi->pfilename) != 0
&& strcmp("stdout", dfi->pfilename) != 0))) && strcmp ("stdout", dfi->pfilename) != 0)))
fclose (dfi->pstream); fclose (dfi->pstream);
if (dfi->alt_stream && strcmp("stderr", dfi->alt_filename) != 0 if (dfi->alt_stream && strcmp ("stderr", dfi->alt_filename) != 0
&& strcmp("stdout", dfi->alt_filename) != 0) && strcmp ("stdout", dfi->alt_filename) != 0)
fclose (dfi->alt_stream); fclose (dfi->alt_stream);
dfi->alt_stream = NULL; dfi->alt_stream = NULL;
@ -488,10 +488,10 @@ dump_begin (int phase, int *flag_ptr)
return NULL; return NULL;
dfi = get_dump_file_info (phase); dfi = get_dump_file_info (phase);
stream = strcmp("stderr", name) == 0 stream = strcmp ("stderr", name) == 0
? stderr ? stderr
: strcmp("stdout", name) == 0 : strcmp ("stdout", name) == 0
? stdout ? stdout
: fopen (name, dfi->pstate < 0 ? "w" : "a"); : fopen (name, dfi->pstate < 0 ? "w" : "a");
if (!stream) if (!stream)

2
gcc/dwarf2asm.c
View File

@ -315,7 +315,7 @@ dw2_asm_output_nstring (const char *str, size_t orig_len,
int c = str[i]; int c = str[i];
if (c == '\"' || c == '\\') if (c == '\"' || c == '\\')
fputc ('\\', asm_out_file); fputc ('\\', asm_out_file);
if (ISPRINT(c)) if (ISPRINT (c))
fputc (c, asm_out_file); fputc (c, asm_out_file);
else else
fprintf (asm_out_file, "\\%o", c); fprintf (asm_out_file, "\\%o", c);

10
gcc/dwarf2cfi.c
View File

@ -2841,14 +2841,14 @@ create_cie_data (void)
dw_stack_pointer_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM); dw_stack_pointer_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
dw_frame_pointer_regnum = DWARF_FRAME_REGNUM (HARD_FRAME_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; cur_trace = &cie_trace;
add_cfi_vec = &cie_cfi_vec; add_cfi_vec = &cie_cfi_vec;
cie_cfi_row = cur_row = new_cfi_row (); cie_cfi_row = cur_row = new_cfi_row ();
/* On entry, the Canonical Frame Address is at SP. */ /* 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.reg = dw_stack_pointer_regnum;
loc.offset = INCOMING_FRAME_SP_OFFSET; loc.offset = INCOMING_FRAME_SP_OFFSET;
def_cfa_1 (&loc); def_cfa_1 (&loc);
@ -3268,7 +3268,7 @@ dump_cfi_row (FILE *f, dw_cfi_row *row)
if (!cfi) if (!cfi)
{ {
dw_cfa_location dummy; dw_cfa_location dummy;
memset(&dummy, 0, sizeof(dummy)); memset (&dummy, 0, sizeof (dummy));
dummy.reg = INVALID_REGNUM; dummy.reg = INVALID_REGNUM;
cfi = def_cfa_0 (&dummy, &row->cfa); 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 class pass_dwarf2_frame : public rtl_opt_pass
{ {
public: public:
pass_dwarf2_frame(gcc::context *ctxt) pass_dwarf2_frame (gcc::context *ctxt)
: rtl_opt_pass(pass_data_dwarf2_frame, ctxt) : rtl_opt_pass (pass_data_dwarf2_frame, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

16
gcc/dwarf2out.c
View File

@ -4245,7 +4245,7 @@ index_addr_table_entry (void **h, void *v)
if (node->refcount == 0) if (node->refcount == 0)
return 1; return 1;
gcc_assert(node->index == NO_INDEX_ASSIGNED); gcc_assert (node->index == NO_INDEX_ASSIGNED);
node->index = *index; node->index = *index;
*index += 1; *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 context, if any. This is stored in the type unit DIE for link-time
ODR (one-definition rule) checking. */ ODR (one-definition rule) checking. */
if (is_cxx() && name != NULL) if (is_cxx () && name != NULL)
{ {
md5_init_ctx (&ctx); 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: case dw_val_class_flag:
return v1->v.val_flag == v2->v.val_flag; return v1->v.val_flag == v2->v.val_flag;
case dw_val_class_str: 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: case dw_val_class_addr:
r1 = v1->v.val_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)) if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die))
return 1; 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; return 0;
} }
@ -6860,7 +6860,7 @@ clone_tree (dw_die_ref die)
dw_die_ref c; dw_die_ref c;
dw_die_ref clone = clone_die (die); 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; return clone;
} }
@ -7052,7 +7052,7 @@ copy_declaration_context (dw_die_ref unit, dw_die_ref die)
add_dwarf_attr (die, a); 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 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 (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
; ;
else if (strncmp (common_lang, "GNU C", 5) == 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. */ /* Mixing C and C++ is ok, use C++ in that case. */
common_lang = "GNU C++"; common_lang = "GNU C++";
else else
@ -21996,7 +21996,7 @@ index_string (void **h, void *v)
find_string_form (node); find_string_form (node);
if (node->form == DW_FORM_GNU_str_index && node->refcount > 0) 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; node->index = *index;
*index += 1; *index += 1;
} }

48
gcc/emit-rtl.c
View File

@ -4090,7 +4090,7 @@ reorder_insns_nobb (rtx from, rtx to, rtx after)
NEXT_INSN (to) = NEXT_INSN (after); NEXT_INSN (to) = NEXT_INSN (after);
PREV_INSN (from) = after; PREV_INSN (from) = after;
NEXT_INSN (after) = from; NEXT_INSN (after) = from;
if (after == get_last_insn()) if (after == get_last_insn ())
set_last_insn (to); set_last_insn (to);
} }
@ -4300,7 +4300,7 @@ emit_insn_after_1 (rtx first, rtx after, basic_block bb)
if (after_after) if (after_after)
PREV_INSN (after_after) = last; PREV_INSN (after_after) = last;
if (after == get_last_insn()) if (after == get_last_insn ())
set_last_insn (last); set_last_insn (last);
return last; return last;
@ -4700,7 +4700,7 @@ emit_debug_insn_before (rtx pattern, rtx before)
rtx rtx
emit_insn (rtx x) emit_insn (rtx x)
{ {
rtx last = get_last_insn(); rtx last = get_last_insn ();
rtx insn; rtx insn;
if (x == NULL_RTX) if (x == NULL_RTX)
@ -4747,7 +4747,7 @@ emit_insn (rtx x)
rtx rtx
emit_debug_insn (rtx x) emit_debug_insn (rtx x)
{ {
rtx last = get_last_insn(); rtx last = get_last_insn ();
rtx insn; rtx insn;
if (x == NULL_RTX) if (x == NULL_RTX)
@ -5804,9 +5804,9 @@ init_emit_once (void)
mode != VOIDmode; mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode)) mode = GET_MODE_WIDER_MODE (mode))
{ {
FCONST0(mode).data.high = 0; FCONST0 (mode).data.high = 0;
FCONST0(mode).data.low = 0; FCONST0 (mode).data.low = 0;
FCONST0(mode).mode = mode; FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode); FCONST0 (mode), mode);
} }
@ -5815,9 +5815,9 @@ init_emit_once (void)
mode != VOIDmode; mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode)) mode = GET_MODE_WIDER_MODE (mode))
{ {
FCONST0(mode).data.high = 0; FCONST0 (mode).data.high = 0;
FCONST0(mode).data.low = 0; FCONST0 (mode).data.low = 0;
FCONST0(mode).mode = mode; FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode); FCONST0 (mode), mode);
} }
@ -5826,17 +5826,17 @@ init_emit_once (void)
mode != VOIDmode; mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode)) mode = GET_MODE_WIDER_MODE (mode))
{ {
FCONST0(mode).data.high = 0; FCONST0 (mode).data.high = 0;
FCONST0(mode).data.low = 0; FCONST0 (mode).data.low = 0;
FCONST0(mode).mode = mode; FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode); FCONST0 (mode), mode);
/* We store the value 1. */ /* We store the value 1. */
FCONST1(mode).data.high = 0; FCONST1 (mode).data.high = 0;
FCONST1(mode).data.low = 0; FCONST1 (mode).data.low = 0;
FCONST1(mode).mode = mode; FCONST1 (mode).mode = mode;
FCONST1(mode).data FCONST1 (mode).data
= double_int_one.lshift (GET_MODE_FBIT (mode), = double_int_one.lshift (GET_MODE_FBIT (mode),
HOST_BITS_PER_DOUBLE_INT, HOST_BITS_PER_DOUBLE_INT,
SIGNED_FIXED_POINT_MODE_P (mode)); SIGNED_FIXED_POINT_MODE_P (mode));
@ -5848,17 +5848,17 @@ init_emit_once (void)
mode != VOIDmode; mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode)) mode = GET_MODE_WIDER_MODE (mode))
{ {
FCONST0(mode).data.high = 0; FCONST0 (mode).data.high = 0;
FCONST0(mode).data.low = 0; FCONST0 (mode).data.low = 0;
FCONST0(mode).mode = mode; FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE ( const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode); FCONST0 (mode), mode);
/* We store the value 1. */ /* We store the value 1. */
FCONST1(mode).data.high = 0; FCONST1 (mode).data.high = 0;
FCONST1(mode).data.low = 0; FCONST1 (mode).data.low = 0;
FCONST1(mode).mode = mode; FCONST1 (mode).mode = mode;
FCONST1(mode).data FCONST1 (mode).data
= double_int_one.lshift (GET_MODE_FBIT (mode), = double_int_one.lshift (GET_MODE_FBIT (mode),
HOST_BITS_PER_DOUBLE_INT, HOST_BITS_PER_DOUBLE_INT,
SIGNED_FIXED_POINT_MODE_P (mode)); SIGNED_FIXED_POINT_MODE_P (mode));

6
gcc/errors.c
View File

@ -48,7 +48,7 @@ warning (const char *format, ...)
fprintf (stderr, "%s: warning: ", progname); fprintf (stderr, "%s: warning: ", progname);
vfprintf (stderr, format, ap); vfprintf (stderr, format, ap);
va_end (ap); va_end (ap);
fputc('\n', stderr); fputc ('\n', stderr);
} }
@ -63,7 +63,7 @@ error (const char *format, ...)
fprintf (stderr, "%s: ", progname); fprintf (stderr, "%s: ", progname);
vfprintf (stderr, format, ap); vfprintf (stderr, format, ap);
va_end (ap); va_end (ap);
fputc('\n', stderr); fputc ('\n', stderr);
have_error = 1; have_error = 1;
} }
@ -80,7 +80,7 @@ fatal (const char *format, ...)
fprintf (stderr, "%s: ", progname); fprintf (stderr, "%s: ", progname);
vfprintf (stderr, format, ap); vfprintf (stderr, format, ap);
va_end (ap); va_end (ap);
fputc('\n', stderr); fputc ('\n', stderr);
exit (FATAL_EXIT_CODE); exit (FATAL_EXIT_CODE);
} }

10
gcc/except.c
View File

@ -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_array);
gcc_assert (ifun->eh->region_tree); 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); bitmap_clear (b_outer);
do do
@ -2021,8 +2021,8 @@ const pass_data pass_data_set_nothrow_function_flags =
class pass_set_nothrow_function_flags : public rtl_opt_pass class pass_set_nothrow_function_flags : public rtl_opt_pass
{ {
public: public:
pass_set_nothrow_function_flags(gcc::context *ctxt) pass_set_nothrow_function_flags (gcc::context *ctxt)
: rtl_opt_pass(pass_data_set_nothrow_function_flags, ctxt) : rtl_opt_pass (pass_data_set_nothrow_function_flags, ctxt)
{} {}
/* opt_pass methods: */ /* 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 class pass_convert_to_eh_region_ranges : public rtl_opt_pass
{ {
public: public:
pass_convert_to_eh_region_ranges(gcc::context *ctxt) pass_convert_to_eh_region_ranges (gcc::context *ctxt)
: rtl_opt_pass(pass_data_convert_to_eh_region_ranges, ctxt) : rtl_opt_pass (pass_data_convert_to_eh_region_ranges, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

6
gcc/expmed.c
View File

@ -2806,7 +2806,7 @@ choose_mult_variant (enum machine_mode mode, HOST_WIDE_INT val,
`unsigned int' */ `unsigned int' */
if (HOST_BITS_PER_INT >= GET_MODE_UNIT_BITSIZE (mode)) 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)) if (MULT_COST_LESS (&alg->cost, mult_cost))
{ {
limit.cost = alg->cost.cost - op_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. */ calculation of the synth_mult. */
coeff = -(unsigned HOST_WIDE_INT) coeff; coeff = -(unsigned HOST_WIDE_INT) coeff;
max_cost = (set_src_cost (gen_rtx_MULT (mode, fake_reg, op1), speed) 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) if (max_cost <= 0)
goto skip_synth; goto skip_synth;
@ -3877,7 +3877,7 @@ expand_divmod (int rem_flag, enum tree_code code, enum machine_mode mode,
{ {
if (rem_flag) if (rem_flag)
return const0_rtx; 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); ? negv_optab : neg_optab, op0, target, 0);
} }

8
gcc/expr.c
View File

@ -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 else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
&& XVECLEN (dst, 0) > 1) && 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)) else if (CONSTANT_P (src))
{ {
HOST_WIDE_INT len = (HOST_WIDE_INT) bytelen; 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 && optab_handler (mov_optab, GET_MODE_INNER (mode)) != CODE_FOR_nothing
&& !(REG_P (x) && !(REG_P (x)
&& HARD_REGISTER_P (x) && HARD_REGISTER_P (x)
&& hard_regno_nregs[REGNO(x)][mode] == 1) && hard_regno_nregs[REGNO (x)][mode] == 1)
&& !(REG_P (y) && !(REG_P (y)
&& HARD_REGISTER_P (y) && HARD_REGISTER_P (y)
&& hard_regno_nregs[REGNO(y)][mode] == 1)) && hard_regno_nregs[REGNO (y)][mode] == 1))
try_int = false; try_int = false;
/* Not possible if the values are inherently not adjacent. */ /* Not possible if the values are inherently not adjacent. */
else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT) 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) if (TREE_ADDRESSABLE (exp)
&& ! MEM_P (result) && ! MEM_P (result)
&& ! targetm.calls.allocate_stack_slots_for_args()) && ! targetm.calls.allocate_stack_slots_for_args ())
{ {
error ("local frame unavailable (naked function?)"); error ("local frame unavailable (naked function?)");
return result; return result;

2
gcc/file-find.c
View File

@ -25,7 +25,7 @@ along with GCC; see the file COPYING3. If not see
static bool debug = false; static bool debug = false;
void void
find_file_set_debug(bool debug_state) find_file_set_debug (bool debug_state)
{ {
debug = debug_state; debug = debug_state;
} }

40
gcc/final.c
View File

@ -704,7 +704,7 @@ compute_alignments (void)
freq_threshold = freq_max / PARAM_VALUE (PARAM_ALIGN_THRESHOLD); freq_threshold = freq_max / PARAM_VALUE (PARAM_ALIGN_THRESHOLD);
if (dump_file) 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) FOR_EACH_BB (bb)
{ {
rtx label = BB_HEAD (bb); rtx label = BB_HEAD (bb);
@ -716,9 +716,10 @@ compute_alignments (void)
|| optimize_bb_for_size_p (bb)) || optimize_bb_for_size_p (bb))
{ {
if (dump_file) if (dump_file)
fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n", fprintf (dump_file,
bb->index, bb->frequency, bb->loop_father->num, "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n",
bb_loop_depth (bb)); bb->index, bb->frequency, bb->loop_father->num,
bb_loop_depth (bb));
continue; continue;
} }
max_log = LABEL_ALIGN (label); max_log = LABEL_ALIGN (label);
@ -733,10 +734,11 @@ compute_alignments (void)
} }
if (dump_file) if (dump_file)
{ {
fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i fall %4i branch %4i", fprintf (dump_file, "BB %4i freq %4i loop %2i loop_depth"
bb->index, bb->frequency, bb->loop_father->num, " %2i fall %4i branch %4i",
bb_loop_depth (bb), bb->index, bb->frequency, bb->loop_father->num,
fallthru_frequency, branch_frequency); bb_loop_depth (bb),
fallthru_frequency, branch_frequency);
if (!bb->loop_father->inner && bb->loop_father->num) if (!bb->loop_father->inner && bb->loop_father->num)
fprintf (dump_file, " inner_loop"); fprintf (dump_file, " inner_loop");
if (bb->loop_father->header == bb) if (bb->loop_father->header == bb)
@ -762,7 +764,7 @@ compute_alignments (void)
{ {
log = JUMP_ALIGN (label); log = JUMP_ALIGN (label);
if (dump_file) if (dump_file)
fprintf(dump_file, " jump alignment added.\n"); fprintf (dump_file, " jump alignment added.\n");
if (max_log < log) if (max_log < log)
{ {
max_log = log; max_log = log;
@ -779,7 +781,7 @@ compute_alignments (void)
{ {
log = LOOP_ALIGN (label); log = LOOP_ALIGN (label);
if (dump_file) if (dump_file)
fprintf(dump_file, " internal loop alignment added.\n"); fprintf (dump_file, " internal loop alignment added.\n");
if (max_log < log) if (max_log < log)
{ {
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 class pass_compute_alignments : public rtl_opt_pass
{ {
public: public:
pass_compute_alignments(gcc::context *ctxt) pass_compute_alignments (gcc::context *ctxt)
: rtl_opt_pass(pass_data_compute_alignments, ctxt) : rtl_opt_pass (pass_data_compute_alignments, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -1123,7 +1125,7 @@ shorten_branches (rtx first)
INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid]; INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid];
if (NOTE_P (insn) || BARRIER_P (insn) if (NOTE_P (insn) || BARRIER_P (insn)
|| LABEL_P (insn) || DEBUG_INSN_P(insn)) || LABEL_P (insn) || DEBUG_INSN_P (insn))
continue; continue;
if (INSN_DELETED_P (insn)) if (INSN_DELETED_P (insn))
continue; continue;
@ -4489,8 +4491,8 @@ const pass_data pass_data_final =
class pass_final : public rtl_opt_pass class pass_final : public rtl_opt_pass
{ {
public: public:
pass_final(gcc::context *ctxt) pass_final (gcc::context *ctxt)
: rtl_opt_pass(pass_data_final, ctxt) : rtl_opt_pass (pass_data_final, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -4535,8 +4537,8 @@ const pass_data pass_data_shorten_branches =
class pass_shorten_branches : public rtl_opt_pass class pass_shorten_branches : public rtl_opt_pass
{ {
public: public:
pass_shorten_branches(gcc::context *ctxt) pass_shorten_branches (gcc::context *ctxt)
: rtl_opt_pass(pass_data_shorten_branches, ctxt) : rtl_opt_pass (pass_data_shorten_branches, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -4699,8 +4701,8 @@ const pass_data pass_data_clean_state =
class pass_clean_state : public rtl_opt_pass class pass_clean_state : public rtl_opt_pass
{ {
public: public:
pass_clean_state(gcc::context *ctxt) pass_clean_state (gcc::context *ctxt)
: rtl_opt_pass(pass_data_clean_state, ctxt) : rtl_opt_pass (pass_data_clean_state, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

2
gcc/fixed-value.c
View File

@ -97,7 +97,7 @@ fixed_from_double_int (double_int payload, enum machine_mode mode)
else if (UNSIGNED_SCALAR_FIXED_POINT_MODE_P (mode)) else if (UNSIGNED_SCALAR_FIXED_POINT_MODE_P (mode))
value.data = payload.zext (GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode)); value.data = payload.zext (GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode));
else else
gcc_unreachable(); gcc_unreachable ();
value.mode = mode; value.mode = mode;

4
gcc/fold-const.c
View File

@ -11711,8 +11711,8 @@ fold_binary_loc (location_t loc,
if (TREE_CODE (arg1) == INTEGER_CST) if (TREE_CODE (arg1) == INTEGER_CST)
{ {
double_int cst1 = tree_to_double_int (arg1); double_int cst1 = tree_to_double_int (arg1);
double_int ncst1 = (-cst1).ext(TYPE_PRECISION (TREE_TYPE (arg1)), double_int ncst1 = (-cst1).ext (TYPE_PRECISION (TREE_TYPE (arg1)),
TYPE_UNSIGNED (TREE_TYPE (arg1))); TYPE_UNSIGNED (TREE_TYPE (arg1)));
if ((cst1 & ncst1) == ncst1 if ((cst1 & ncst1) == ncst1
&& multiple_of_p (type, arg0, && multiple_of_p (type, arg0,
double_int_to_tree (TREE_TYPE (arg1), ncst1))) double_int_to_tree (TREE_TYPE (arg1), ncst1)))

18
gcc/function.c
View File

@ -1970,8 +1970,8 @@ const pass_data pass_data_instantiate_virtual_regs =
class pass_instantiate_virtual_regs : public rtl_opt_pass class pass_instantiate_virtual_regs : public rtl_opt_pass
{ {
public: public:
pass_instantiate_virtual_regs(gcc::context *ctxt) pass_instantiate_virtual_regs (gcc::context *ctxt)
: rtl_opt_pass(pass_data_instantiate_virtual_regs, ctxt) : rtl_opt_pass (pass_data_instantiate_virtual_regs, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -2078,7 +2078,7 @@ aggregate_value_p (const_tree exp, const_tree fntype)
bool bool
use_register_for_decl (const_tree decl) 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; return true;
/* Honor volatile. */ /* Honor volatile. */
@ -7022,8 +7022,8 @@ const pass_data pass_data_leaf_regs =
class pass_leaf_regs : public rtl_opt_pass class pass_leaf_regs : public rtl_opt_pass
{ {
public: public:
pass_leaf_regs(gcc::context *ctxt) pass_leaf_regs (gcc::context *ctxt)
: rtl_opt_pass(pass_data_leaf_regs, ctxt) : rtl_opt_pass (pass_data_leaf_regs, ctxt)
{} {}
/* opt_pass methods: */ /* 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 class pass_thread_prologue_and_epilogue : public rtl_opt_pass
{ {
public: public:
pass_thread_prologue_and_epilogue(gcc::context *ctxt) pass_thread_prologue_and_epilogue (gcc::context *ctxt)
: rtl_opt_pass(pass_data_thread_prologue_and_epilogue, ctxt) : rtl_opt_pass (pass_data_thread_prologue_and_epilogue, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -7298,8 +7298,8 @@ const pass_data pass_data_match_asm_constraints =
class pass_match_asm_constraints : public rtl_opt_pass class pass_match_asm_constraints : public rtl_opt_pass
{ {
public: public:
pass_match_asm_constraints(gcc::context *ctxt) pass_match_asm_constraints (gcc::context *ctxt)
: rtl_opt_pass(pass_data_match_asm_constraints, ctxt) : rtl_opt_pass (pass_data_match_asm_constraints, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

8
gcc/fwprop.c
View File

@ -1504,8 +1504,8 @@ const pass_data pass_data_rtl_fwprop =
class pass_rtl_fwprop : public rtl_opt_pass class pass_rtl_fwprop : public rtl_opt_pass
{ {
public: public:
pass_rtl_fwprop(gcc::context *ctxt) pass_rtl_fwprop (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_fwprop, ctxt) : rtl_opt_pass (pass_data_rtl_fwprop, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -1570,8 +1570,8 @@ const pass_data pass_data_rtl_fwprop_addr =
class pass_rtl_fwprop_addr : public rtl_opt_pass class pass_rtl_fwprop_addr : public rtl_opt_pass
{ {
public: public:
pass_rtl_fwprop_addr(gcc::context *ctxt) pass_rtl_fwprop_addr (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_fwprop_addr, ctxt) : rtl_opt_pass (pass_data_rtl_fwprop_addr, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

12
gcc/gcc-ar.c
View File

@ -123,7 +123,7 @@ setup_prefixes (const char *exec_path)
} }
int int
main(int ac, char **av) main (int ac, char **av)
{ {
const char *exe_name; const char *exe_name;
char *plugin; char *plugin;
@ -166,7 +166,7 @@ main(int ac, char **av)
nargv[1] = "--plugin"; nargv[1] = "--plugin";
nargv[2] = plugin; nargv[2] = plugin;
if (is_ar && av[1] && av[1][0] != '-') 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++) for (k = 1; k < ac; k++)
nargv[2 + k] = av[k]; nargv[2 + k] = av[k];
nargv[2 + k] = NULL; nargv[2 + k] = NULL;
@ -176,18 +176,18 @@ main(int ac, char **av)
err_msg = pex_one (PEX_LAST|PEX_SEARCH, err_msg = pex_one (PEX_LAST|PEX_SEARCH,
exe_name, exe_name,
CONST_CAST2 (char * const *, const char **, nargv), CONST_CAST2 (char * const *, const char **, nargv),
concat("gcc-", exe_name, NULL), concat ("gcc-", exe_name, NULL),
NULL,NULL, &status, &err); NULL,NULL, &status, &err);
if (err_msg) 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) else if (status)
{ {
if (WIFSIGNALED (status)) if (WIFSIGNALED (status))
{ {
int sig = WTERMSIG (status); int sig = WTERMSIG (status);
fprintf (stderr, "%s terminated with signal %d [%s]%s\n", fprintf (stderr, "%s terminated with signal %d [%s]%s\n",
exe_name, sig, strsignal(sig), exe_name, sig, strsignal (sig),
WCOREDUMP(status) ? ", core dumped" : ""); WCOREDUMP (status) ? ", core dumped" : "");
} }
else if (WIFEXITED (status)) else if (WIFEXITED (status))
exit_code = WEXITSTATUS (status); exit_code = WEXITSTATUS (status);

30
gcc/gcc.c
View File

@ -1556,7 +1556,7 @@ init_spec (void)
/* Prepend "--traditional-format" to whatever asm_spec we had before. */ /* Prepend "--traditional-format" to whatever asm_spec we had before. */
{ {
static const char tf[] = "--traditional-format "; 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)); obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
asm_spec = XOBFINISH (&obstack, const char *); asm_spec = XOBFINISH (&obstack, const char *);
} }
@ -1566,19 +1566,19 @@ init_spec (void)
defined LINKER_HASH_STYLE defined LINKER_HASH_STYLE
# ifdef LINK_BUILDID_SPEC # ifdef LINK_BUILDID_SPEC
/* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */ /* 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 # endif
# ifdef LINK_EH_SPEC # ifdef LINK_EH_SPEC
/* Prepend LINK_EH_SPEC to whatever link_spec we had before. */ /* 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 # endif
# ifdef LINKER_HASH_STYLE # ifdef LINKER_HASH_STYLE
/* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had /* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
before. */ before. */
{ {
static const char hash_style[] = "--hash-style="; static const char hash_style[] = "--hash-style=";
obstack_grow (&obstack, hash_style, sizeof(hash_style) - 1); obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof(LINKER_HASH_STYLE) - 1); obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
obstack_1grow (&obstack, ' '); obstack_1grow (&obstack, ' ');
} }
# endif # endif
@ -1644,7 +1644,7 @@ set_spec (const char *name, const char *spec, bool user_p)
/* Free the old spec. */ /* Free the old spec. */
if (old_spec && sl->alloc_p) if (old_spec && sl->alloc_p)
free (CONST_CAST(char *, old_spec)); free (CONST_CAST (char *, old_spec));
sl->user_p = user_p; sl->user_p = user_p;
sl->alloc_p = true; sl->alloc_p = true;
@ -2490,7 +2490,7 @@ find_a_file (const struct path_prefix *pprefix, const char *name, int mode,
#endif #endif
#ifdef DEFAULT_LINKER #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); return xstrdup (DEFAULT_LINKER);
#endif #endif
@ -5741,11 +5741,11 @@ handle_braces (const char *p)
a_is_negated = false; a_is_negated = false;
a_is_spectype = false; a_is_spectype = false;
SKIP_WHITE(); SKIP_WHITE ();
if (*p == '!') if (*p == '!')
p++, a_is_negated = true; p++, a_is_negated = true;
SKIP_WHITE(); SKIP_WHITE ();
if (*p == '%' && p[1] == ':') if (*p == '%' && p[1] == ':')
{ {
atom = NULL; atom = NULL;
@ -5760,7 +5760,7 @@ handle_braces (const char *p)
p++, a_is_spectype = true; p++, a_is_spectype = true;
atom = p; atom = p;
while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '=' while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
|| *p == ',' || *p == '.' || *p == '@') || *p == ',' || *p == '.' || *p == '@')
p++; p++;
end_atom = p; end_atom = p;
@ -5769,7 +5769,7 @@ handle_braces (const char *p)
p++, a_is_starred = 1; p++, a_is_starred = 1;
} }
SKIP_WHITE(); SKIP_WHITE ();
switch (*p) switch (*p)
{ {
case '&': case '}': case '&': case '}':
@ -6074,13 +6074,13 @@ give_switch (int switchnum, int omit_first_word)
while (length-- && !IS_DIR_SEPARATOR (arg[length])) while (length-- && !IS_DIR_SEPARATOR (arg[length]))
if (arg[length] == '.') if (arg[length] == '.')
{ {
(CONST_CAST(char *, arg))[length] = 0; (CONST_CAST (char *, arg))[length] = 0;
dot = 1; dot = 1;
break; break;
} }
do_spec_1 (arg, 1, NULL); do_spec_1 (arg, 1, NULL);
if (dot) if (dot)
(CONST_CAST(char *, arg))[length] = '.'; (CONST_CAST (char *, arg))[length] = '.';
do_spec_1 (suffix_subst, 1, NULL); do_spec_1 (suffix_subst, 1, NULL);
} }
else else
@ -8395,7 +8395,7 @@ get_random_number (void)
} }
#endif #endif
return ret ^ getpid(); return ret ^ getpid ();
} }
/* %:compare-debug-dump-opt spec function. Save the last argument, /* %: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]); 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])) if (IS_DIR_SEPARATOR (name[i]))
break; break;

17
gcc/gcov-io.c
View File

@ -386,7 +386,7 @@ gcov_write_summary (gcov_unsigned_t tag, const struct gcov_summary *summary)
h_cnt++; 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); gcov_write_unsigned (summary->checksum);
for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++) for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
{ {
@ -559,7 +559,7 @@ gcov_read_summary (struct gcov_summary *summary)
while (!cur_bitvector) while (!cur_bitvector)
{ {
h_ix = bv_ix * 32; 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++]; cur_bitvector = histo_bitvector[bv_ix++];
} }
while (!(cur_bitvector & 0x1)) while (!(cur_bitvector & 0x1))
@ -567,7 +567,7 @@ gcov_read_summary (struct gcov_summary *summary)
h_ix++; h_ix++;
cur_bitvector >>= 1; 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].num_counters = gcov_read_unsigned ();
csum->histogram[h_ix].min_value = gcov_read_counter (); 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]; gcov_bucket_type tmp_histo[GCOV_HISTOGRAM_SIZE];
int src_done = 0; 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 /* Assume that the counters are in the same relative order in both
histograms. Walk the histograms from largest to smallest entry, 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 /* The merged counters get placed in the new merged histogram
at the entry for the merged min_value. */ 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); gcc_assert (tmp_i < GCOV_HISTOGRAM_SIZE);
tmp_histo[tmp_i].num_counters += merge_num; tmp_histo[tmp_i].num_counters += merge_num;
tmp_histo[tmp_i].cum_value += merge_cum; 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 /* At this point, tmp_i should be the smallest non-zero entry in the
tmp_histo. */ tmp_histo. */
gcc_assert(tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE gcc_assert (tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE
&& tmp_histo[tmp_i].num_counters > 0); && tmp_histo[tmp_i].num_counters > 0);
tmp_histo[tmp_i].cum_value += src_cum; tmp_histo[tmp_i].cum_value += src_cum;
/* Finally, copy the merged histogram into tgt_histo. */ /* 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 */ #endif /* !IN_GCOV */

2
gcc/gcov-io.h
View File

@ -382,7 +382,7 @@ typedef unsigned HOST_WIDEST_INT gcov_type_unsigned;
/* Return nonzero if SUB is an immediate subtag of TAG. */ /* Return nonzero if SUB is an immediate subtag of TAG. */
#define GCOV_TAG_IS_SUBTAG(TAG,SUB) \ #define GCOV_TAG_IS_SUBTAG(TAG,SUB) \
(GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (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. */ /* Return nonzero if SUB is at a sublevel to TAG. */
#define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \ #define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \

12
gcc/gcov.c
View File

@ -398,7 +398,7 @@ static void executed_summary (unsigned, unsigned);
static void function_summary (const coverage_t *, const char *); static void function_summary (const coverage_t *, const char *);
static const char *format_gcov (gcov_type, gcov_type, int); static const char *format_gcov (gcov_type, gcov_type, int);
static void accumulate_line_counts (source_t *); 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 int output_branch_count (FILE *, int, const arc_t *);
static void output_lines (FILE *, const source_t *); static void output_lines (FILE *, const source_t *);
static char *make_gcov_file_name (const char *, const char *); static char *make_gcov_file_name (const char *, const char *);
@ -448,8 +448,8 @@ main (int argc, char **argv)
for (; argno != argc; argno++) for (; argno != argc; argno++)
{ {
if (flag_display_progress) if (flag_display_progress)
printf("Processing file %d out of %d\n", printf ("Processing file %d out of %d\n",
argno - first_arg + 1, argc - first_arg); argno - first_arg + 1, argc - first_arg);
process_file (argv[argno]); process_file (argv[argno]);
} }
@ -621,7 +621,7 @@ get_gcov_intermediate_filename (const char *file_name)
/* Find the 'basename'. */ /* Find the 'basename'. */
cptr = lbasename (file_name); 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); sprintf (result, "%s%s", cptr, gcov);
return result; return result;
@ -699,7 +699,7 @@ output_intermediate_file (FILE *gcov_file, source_t *src)
branch_type = (arc->count > 0) ? "taken" : "nottaken"; branch_type = (arc->count > 0) ? "taken" : "nottaken";
else else
branch_type = "notexec"; 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 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); char *gcov_file_name = make_gcov_file_name (file_name, src->coverage.name);

8
gcc/gcse.c
View File

@ -4169,8 +4169,8 @@ const pass_data pass_data_rtl_pre =
class pass_rtl_pre : public rtl_opt_pass class pass_rtl_pre : public rtl_opt_pass
{ {
public: public:
pass_rtl_pre(gcc::context *ctxt) pass_rtl_pre (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_pre, ctxt) : rtl_opt_pass (pass_data_rtl_pre, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -4208,8 +4208,8 @@ const pass_data pass_data_rtl_hoist =
class pass_rtl_hoist : public rtl_opt_pass class pass_rtl_hoist : public rtl_opt_pass
{ {
public: public:
pass_rtl_hoist(gcc::context *ctxt) pass_rtl_hoist (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_hoist, ctxt) : rtl_opt_pass (pass_data_rtl_hoist, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

2
gcc/genattr-common.c
View File

@ -33,7 +33,7 @@ static void
write_upcase (const char *str) write_upcase (const char *str)
{ {
for (; *str; str++) for (; *str; str++)
putchar (TOUPPER(*str)); putchar (TOUPPER (*str));
} }
static void static void

6
gcc/genattr.c
View File

@ -361,10 +361,10 @@ main (int argc, char **argv)
/* Output flag masks for use by reorg. /* Output flag masks for use by reorg.
Flags are used to hold branch direction for use by eligible_for_... */ Flags are used to hold branch direction for use by eligible_for_... */
printf("\n#define ATTR_FLAG_forward\t0x1\n"); printf ("\n#define ATTR_FLAG_forward\t0x1\n");
printf("#define ATTR_FLAG_backward\t0x2\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)) if (ferror (stdout) || fflush (stdout) || fclose (stdout))
return FATAL_EXIT_CODE; return FATAL_EXIT_CODE;

12
gcc/genattrtab.c
View File

@ -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 `return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
(see attr_rtx). */ (see attr_rtx). */
#define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging)) #define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), unchanging))
#define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct)) #define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), in_struct))
#define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val)) #define ATTR_PERMANENT_P(RTX) (RTX_FLAG ((RTX), return_val))
#if 0 #if 0
#define strcmp_check(S1, S2) ((S1) == (S2) \ #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, x = evaluate_eq_attr (exp, attr, av->value,
insn_code, insn_index); insn_code, insn_index);
x = SIMPLIFY_TEST_EXP (x, 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; return x;
} }
} }
@ -4403,7 +4403,7 @@ write_upcase (FILE *outf, const char *str)
while (*str) while (*str)
{ {
/* The argument of TOUPPER should not have side effects. */ /* The argument of TOUPPER should not have side effects. */
fputc (TOUPPER(*str), outf); fputc (TOUPPER (*str), outf);
str++; str++;
} }
} }
@ -5285,7 +5285,7 @@ main (int argc, char **argv)
{ {
FILE *outf; 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")) if (IS_ATTR_GROUP ("*internal_dfa_insn_code"))
outf = dfa_file; outf = dfa_file;
else if (IS_ATTR_GROUP ("*insn_default_latency")) else if (IS_ATTR_GROUP ("*insn_default_latency"))

8
gcc/genautomata.c
View File

@ -5533,7 +5533,7 @@ static reserv_sets_t
form_reservs_matter (automaton_t automaton) form_reservs_matter (automaton_t automaton)
{ {
int cycle, unit; 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 (cycle = 0; cycle < max_cycles_num; cycle++)
for (unit = 0; unit < description->units_num; unit++) for (unit = 0; unit < description->units_num; unit++)
@ -7558,7 +7558,7 @@ output_trans_table (automaton_t automaton)
{ {
size_t i; size_t i;
arc_t arc; 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; undefined_vect_el_value = automaton->achieved_states_num;
automaton->trans_table = create_state_ainsn_table (automaton); automaton->trans_table = create_state_ainsn_table (automaton);
@ -7742,7 +7742,7 @@ output_dead_lock_vect (automaton_t automaton)
{ {
size_t i; size_t i;
arc_t arc; 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 /* Create vect of pointers to states ordered by num of
transitions from the state (state with the maximum num is the transitions from the state (state with the maximum num is the
@ -7787,7 +7787,7 @@ output_dead_lock_vect (automaton_t automaton)
static void static void
output_reserved_units_table (automaton_t automaton) 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 state_byte_size;
int reserved_units_size; int reserved_units_size;
size_t n; size_t n;

2
gcc/genconfig.c
View File

@ -355,7 +355,7 @@ main (int argc, char **argv)
printf ("#define MAX_INSNS_PER_PEEP2 %d\n", max_insns_per_peep2); 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)) if (ferror (stdout) || fflush (stdout) || fclose (stdout))
return FATAL_EXIT_CODE; return FATAL_EXIT_CODE;

2
gcc/genemit.c
View File

@ -68,7 +68,7 @@ print_code (RTX_CODE code)
{ {
const char *p1; const char *p1;
for (p1 = GET_RTX_NAME (code); *p1; p1++) for (p1 = GET_RTX_NAME (code); *p1; p1++)
putchar (TOUPPER(*p1)); putchar (TOUPPER (*p1));
} }
static void static void

8
gcc/genextract.c
View File

@ -165,9 +165,9 @@ gen_insn (rtx insn, int insn_code_number)
p->duplocs = p->oplocs + op_count; p->duplocs = p->oplocs + op_count;
p->dupnums = (int *)(p->duplocs + dup_count); p->dupnums = (int *)(p->duplocs + dup_count);
memcpy(p->oplocs, acc.oplocs.address(), op_count*sizeof(locstr)); memcpy (p->oplocs, acc.oplocs.address (), op_count * sizeof (locstr));
memcpy(p->duplocs, acc.duplocs.address(), dup_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->dupnums, acc.dupnums.address (), dup_count * sizeof (int));
done: done:
acc.oplocs.release (); acc.oplocs.release ();
@ -334,7 +334,7 @@ print_path (const char *path)
{ {
if (ISLOWER (path[i])) if (ISLOWER (path[i]))
printf (", 0, %d)", path[i] - 'a'); printf (", 0, %d)", path[i] - 'a');
else if (ISDIGIT(path[i])) else if (ISDIGIT (path[i]))
printf (", %d)", path[i] - '0'); printf (", %d)", path[i] - '0');
else else
gcc_unreachable (); gcc_unreachable ();

4
gcc/genflags.c
View File

@ -109,7 +109,7 @@ gen_macro (const char *name, int real, int expect)
for (i = 0; name[i]; i++) for (i = 0; name[i]; i++)
putchar (TOUPPER (name[i])); putchar (TOUPPER (name[i]));
putchar('('); putchar ('(');
for (i = 0; i < expect - 1; i++) for (i = 0; i < expect - 1; i++)
printf ("%c, ", i + 'A'); printf ("%c, ", i + 'A');
printf ("%c) gen_%s (", i + 'A', name); printf ("%c) gen_%s (", i + 'A', name);
@ -290,7 +290,7 @@ main (int argc, char **argv)
for (insn_ptr = insns; *insn_ptr; insn_ptr++) for (insn_ptr = insns; *insn_ptr; insn_ptr++)
gen_proto (*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)) if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
return FATAL_EXIT_CODE; return FATAL_EXIT_CODE;

2
gcc/gengenrtl.c
View File

@ -37,7 +37,7 @@ static const struct rtx_definition defs[] =
{ {
#include "rtl.def" /* rtl expressions are documented here */ #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]; static const char *formats[NUM_RTX_CODE];

14
gcc/gengtype-state.c
View File

@ -142,7 +142,7 @@ static long state_bol = 0; /* offset of beginning of line */
class s_expr_writer class s_expr_writer
{ {
public: public:
s_expr_writer(); s_expr_writer ();
void write_new_line (); void write_new_line ();
void write_any_indent (int leading_spaces); void write_any_indent (int leading_spaces);
@ -159,7 +159,7 @@ private:
class state_writer : public s_expr_writer class state_writer : public s_expr_writer
{ {
public: public:
state_writer(); state_writer ();
private: private:
void write_state_fileloc (struct fileloc *floc); void write_state_fileloc (struct fileloc *floc);
@ -205,7 +205,7 @@ private:
/* class s_expr_writer's trivial constructor. */ /* class s_expr_writer's trivial constructor. */
s_expr_writer::s_expr_writer() s_expr_writer::s_expr_writer ()
: indent_amount_(0), : indent_amount_(0),
had_recent_newline_(0) had_recent_newline_(0)
{ {
@ -269,9 +269,9 @@ s_expr_writer::end_s_expr (void)
/* class state_writer's trivial constructor. */ /* class state_writer's trivial constructor. */
state_writer::state_writer() state_writer::state_writer ()
: s_expr_writer(), : s_expr_writer (),
state_written_type_count(0) state_written_type_count (0)
{ {
} }
@ -309,7 +309,7 @@ fatal_reading_state (struct state_token_st* tok, const char*msg)
else \ else \
fatal ("%s:%d: Invalid state file; " Fmt, \ fatal ("%s:%d: Invalid state file; " Fmt, \
state_path, state_line, __VA_ARGS__); \ state_path, state_line, __VA_ARGS__); \
} while(0) } while (0)
/* Find or allocate an identifier in our name hash table. */ /* Find or allocate an identifier in our name hash table. */

22
gcc/gengtype.c
View File

@ -617,7 +617,7 @@ type_for_name (const char *s)
extern GTY(()) gcc::some_type *some_ptr; extern GTY(()) gcc::some_type *some_ptr;
where the autogenerated functions will refer to simply "some_type", where the autogenerated functions will refer to simply "some_type",
where they can be resolved into their namespace. */ where they can be resolved into their namespace. */
if (0 == strncmp(s, "gcc::", 5)) if (0 == strncmp (s, "gcc::", 5))
s += 5; s += 5;
for (p = typedefs; p != NULL; p = p->next) 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 /* Create a fake field with the given type and name. NEXT is the next
field in the chain. */ field in the chain. */
#define create_field(next,type,name) \ #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 /* Like create_field, but the field is only valid when condition COND
is true. */ is true. */
@ -2131,7 +2131,7 @@ matching_file_name_substitute (const char *filnam, regmatch_t pmatch[10],
else else
{ {
/* This can happen only when files_rules is buggy! */ /* This can happen only when files_rules is buggy! */
gcc_unreachable(); gcc_unreachable ();
} }
/* Always skip the character after the dollar. */ /* Always skip the character after the dollar. */
pt++; 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), oprintf (of, "%lu%s", (unsigned long) strlen (id_for_tag),
id_for_tag); id_for_tag);
if (id_for_tag != t->u.s.tag) if (id_for_tag != t->u.s.tag)
free (CONST_CAST(char *, id_for_tag)); free (CONST_CAST (char *, id_for_tag));
} }
break; break;
case TYPE_PARAM_STRUCT: 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); const char *id_for_tag = filter_type_name (s->u.s.tag);
oprintf (of, "gt_%sx_%s", prefix, id_for_tag); oprintf (of, "gt_%sx_%s", prefix, id_for_tag);
if (id_for_tag != s->u.s.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) 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", "#define gt_%sx_%s gt_%sx_%s\n",
wtd->prefix, s->u.s.tag, wtd->prefix, t_id_for_tag); wtd->prefix, s->u.s.tag, wtd->prefix, t_id_for_tag);
if (t_id_for_tag != t->u.s.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 else
error_at_line (&s->u.s.line, 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); wtd->prefix, s_id_for_tag);
if (s_id_for_tag != s->u.s.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) 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 else
oprintf (f, " NULL"); oprintf (f, " NULL");
if (id_for_tag != tp->u.s.tag) 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) 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, ", n");
oprintf (f, " MEM_STAT_INFO)))\n"); oprintf (f, " MEM_STAT_INFO)))\n");
if (type_name_as_id != type_name) 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 /* 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. */ relevant to plugin input files. */
if (nb_plugin_files > 0) if (nb_plugin_files > 0)
{ {
struct fileloc* filoc = type_fileloc(s); struct fileloc* filoc = type_fileloc (s);
if (!filoc || !filoc->file->inpisplugin) if (!filoc || !filoc->file->inpisplugin)
continue; continue;
}; };
@ -5470,7 +5470,7 @@ main (int argc, char **argv)
we can see them. We should initialize them before calling we can see them. We should initialize them before calling
read_input_list. */ read_input_list. */
#define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \ #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 ("CUMULATIVE_ARGS", &pos));
POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos)); POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos));
POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos)); POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos));

17
gcc/genmodes.c
View File

@ -418,7 +418,7 @@ complete_all_modes (void)
} }
/* For each mode in class CLASS, construct a corresponding complex mode. */ /* 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 static void
make_complex_modes (enum mode_class cl, make_complex_modes (enum mode_class cl,
const char *file, unsigned int line) 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 /* For all modes in class CL, construct vector modes of width
WIDTH, having as many components as necessary. */ 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 static void ATTRIBUTE_UNUSED
make_vector_modes (enum mode_class cl, unsigned int width, make_vector_modes (enum mode_class cl, unsigned int width,
const char *file, unsigned int line) const char *file, unsigned int line)
@ -522,7 +522,8 @@ make_vector_modes (enum mode_class cl, unsigned int width,
/* Input. */ /* 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 RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
#define CC_MODE(N) _SPECIAL_MODE (CC, 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) \ #define _ADD_ADJUST(A, M, X, C1, C2) \
new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__) 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_BYTESIZE(M, X) _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM)
#define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, 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_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_IBIT(M, X) _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM)
#define ADJUST_FBIT(M, X) _ADD_ADJUST(fbit, M, X, FRACT, UACCUM) #define ADJUST_FBIT(M, X) _ADD_ADJUST (fbit, M, X, FRACT, UACCUM)
static void static void
create_modes (void) create_modes (void)

4
gcc/genopinit.c
View File

@ -194,7 +194,7 @@ match_pattern (pattern *p, const char *name, const char *pat)
for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--) for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
{ {
const char *p, *q; 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) if (TOLOWER (*p) != *q)
break; break;
if (*p == 0 if (*p == 0
@ -372,7 +372,7 @@ main (int argc, char **argv)
/* Sort the (real) optabs. Better than forcing the optabs.def file to /* Sort the (real) optabs. Better than forcing the optabs.def file to
remain sorted by kind. We also scrogged any real ordering with the remain sorted by kind. We also scrogged any real ordering with the
purging of the X patterns above. */ 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. */ /* Emit the optab enumeration for the header file. */
fprintf (h_file, "enum optab_tag {\n"); fprintf (h_file, "enum optab_tag {\n");

10
gcc/genoutput.c
View File

@ -286,9 +286,9 @@ output_operand_data (void)
pred = lookup_predicate (d->predicate); pred = lookup_predicate (d->predicate);
printf (" %d\n", pred && pred->codes[MEM]); printf (" %d\n", pred && pred->codes[MEM]);
printf(" },\n"); printf (" },\n");
} }
printf("};\n\n\n"); printf ("};\n\n\n");
} }
static void static void
@ -415,7 +415,7 @@ output_insn_data (void)
printf (" %d,\n", d->n_alternatives); printf (" %d,\n", d->n_alternatives);
printf (" %d\n", d->output_format); printf (" %d\n", d->output_format);
printf(" },\n"); printf (" },\n");
} }
printf ("};\n\n\n"); printf ("};\n\n\n");
} }
@ -1112,7 +1112,7 @@ main (int argc, char **argv)
next_index_number++; next_index_number++;
} }
printf("\n\n"); printf ("\n\n");
output_operand_data (); output_operand_data ();
output_insn_data (); output_insn_data ();
output_get_insn_name (); 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); 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->namelen = namelen;
new_cdata->lineno = lineno; new_cdata->lineno = lineno;
new_cdata->next_this_letter = *slot; new_cdata->next_this_letter = *slot;

2
gcc/genpeep.c
View File

@ -334,7 +334,7 @@ print_code (RTX_CODE code)
{ {
const char *p1; const char *p1;
for (p1 = GET_RTX_NAME (code); *p1; p1++) for (p1 = GET_RTX_NAME (code); *p1; p1++)
putchar (TOUPPER(*p1)); putchar (TOUPPER (*p1));
} }
extern int main (int, char **); extern int main (int, char **);

10
gcc/genpreds.c
View File

@ -529,7 +529,7 @@ write_match_code_switch (rtx exp)
putchar (TOUPPER (*code)); putchar (TOUPPER (*code));
code++; code++;
} }
fputs(":\n", stdout); fputs (":\n", stdout);
} }
} }
@ -596,9 +596,9 @@ write_predicate_stmts (rtx exp)
break; break;
} }
fputs(" return ",stdout); fputs (" return ",stdout);
write_predicate_expr (exp); write_predicate_expr (exp);
fputs(";\n", stdout); fputs (";\n", stdout);
} }
/* Given a predicate, write out a complete C function to compute it. */ /* Given a predicate, write out a complete C function to compute it. */
@ -932,7 +932,7 @@ write_lookup_constraint (void)
" switch (str[0])\n" " 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]; struct constraint_data *c = constraints_by_letter_table[i];
if (!c) if (!c)
@ -975,7 +975,7 @@ write_insn_constraint_len (void)
" switch (fc)\n" " 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]; struct constraint_data *c = constraints_by_letter_table[i];

23
gcc/genrecog.c
View File

@ -58,7 +58,7 @@
#include "gensupport.h" #include "gensupport.h"
#define OUTPUT_LABEL(INDENT_STRING, LABEL_NUMBER) \ #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. */ /* Ways of obtaining an rtx to be tested. */
enum position_type { enum position_type {
@ -1619,7 +1619,7 @@ write_afterward (struct decision *start, struct decision *afterward,
const char *indent) const char *indent)
{ {
if (!afterward || start->subroutine_number > 0) if (!afterward || start->subroutine_number > 0)
printf("%sgoto ret0;\n", indent); printf ("%sgoto ret0;\n", indent);
else else
{ {
change_state (start->position, afterward->position, indent); change_state (start->position, afterward->position, indent);
@ -1669,7 +1669,7 @@ write_switch (struct decision *start, int depth)
struct decision *ret; struct decision *ret;
RTX_CODE code; RTX_CODE code;
memset (codemap, 0, sizeof(codemap)); memset (codemap, 0, sizeof (codemap));
printf (" switch (GET_CODE (x%d))\n {\n", depth); printf (" switch (GET_CODE (x%d))\n {\n", depth);
code = p->tests->u.code; code = p->tests->u.code;
@ -1762,7 +1762,8 @@ write_switch (struct decision *start, int depth)
if (type == DT_elt_zero_wide_safe) if (type == DT_elt_zero_wide_safe)
{ {
indent = " "; 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); printf ("%s switch (", indent);
switch (type) switch (type)
@ -1937,7 +1938,7 @@ write_action (struct decision *p, struct decision_test *test,
if (test->type == DT_accept_op) 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. */ /* Only allow DT_accept_insn to follow. */
if (test->next) if (test->next)
@ -1992,7 +1993,7 @@ write_action (struct decision *p, struct decision_test *test,
} }
else else
{ {
printf("%sgoto L%d;\n", indent, success->number); printf ("%sgoto L%d;\n", indent, success->number);
success->need_label = 1; success->need_label = 1;
} }
@ -2357,7 +2358,7 @@ make_insn_sequence (rtx insn, enum routine_type type)
validate_pattern (x, insn, NULL_RTX, 0); 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); last = add_to_sequence (x, &head, &root_pos, type, 1);
/* Find the end of the test chain on the last node. */ /* 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. */ /* 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, last = add_to_sequence (new_rtx, &clobber_head, &root_pos,
type, 1); 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 /* We run this after find_afterward, because find_afterward needs
the redundant DT_mode tests on predicates to determine whether the redundant DT_mode tests on predicates to determine whether
two tests can both be true or not. */ two tests can both be true or not. */
simplify_tests(head); simplify_tests (head);
write_subroutines (head, subroutine_type); write_subroutines (head, subroutine_type);
} }
@ -2601,12 +2602,12 @@ debug_decision_2 (struct decision_test *test)
break; break;
case DT_pred: case DT_pred:
fprintf (stderr, "pred=(%s,%s)", 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; break;
case DT_c_test: case DT_c_test:
{ {
char sub[16+4]; char sub[16+4];
strncpy (sub, test->u.c_test, sizeof(sub)); strncpy (sub, test->u.c_test, sizeof (sub));
memcpy (sub+16, "...", 4); memcpy (sub+16, "...", 4);
fprintf (stderr, "c_test=\"%s\"", sub); fprintf (stderr, "c_test=\"%s\"", sub);
} }

6
gcc/gensupport.c
View File

@ -392,7 +392,7 @@ static struct queue_elem *
queue_pattern (rtx pattern, struct queue_elem ***list_tail, queue_pattern (rtx pattern, struct queue_elem ***list_tail,
const char *filename, int lineno) 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->data = pattern;
e->filename = filename; e->filename = filename;
e->lineno = lineno; e->lineno = lineno;
@ -429,7 +429,7 @@ remove_from_queue (struct queue_elem *elem, struct queue_elem **queue)
static void static void
add_define_attr (const char *name) 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); rtx t1 = rtx_alloc (DEFINE_ATTR);
XSTR (t1, 0) = name; XSTR (t1, 0) = name;
XSTR (t1, 1) = "no,yes"; 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); new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size); insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size);
memset (insn_name_ptr + insn_name_ptr_size, 0, 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; insn_name_ptr_size = new_size;
} }

8
gcc/ggc-common.c
View File

@ -488,7 +488,7 @@ gt_pch_save (FILE *f)
char *this_object = NULL; char *this_object = NULL;
size_t this_object_size = 0; size_t this_object_size = 0;
struct mmap_info mmi; 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 (); gt_pch_save_stringpool ();
@ -749,7 +749,7 @@ default_gt_pch_use_address (void *base, size_t size, int fd ATTRIBUTE_UNUSED,
size_t size_t
default_gt_pch_alloc_granularity (void) default_gt_pch_alloc_granularity (void)
{ {
return getpagesize(); return getpagesize ();
} }
#if HAVE_MMAP_FILE #if HAVE_MMAP_FILE
@ -837,7 +837,7 @@ ggc_rlimit_bound (double limit)
static int static int
ggc_min_expand_heuristic (void) ggc_min_expand_heuristic (void)
{ {
double min_expand = physmem_total(); double min_expand = physmem_total ();
/* Adjust for rlimits. */ /* Adjust for rlimits. */
min_expand = ggc_rlimit_bound (min_expand); min_expand = ggc_rlimit_bound (min_expand);
@ -856,7 +856,7 @@ ggc_min_expand_heuristic (void)
static int static int
ggc_min_heapsize_heuristic (void) ggc_min_heapsize_heuristic (void)
{ {
double phys_kbytes = physmem_total(); double phys_kbytes = physmem_total ();
double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2); double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
phys_kbytes /= 1024; /* Convert to Kbytes. */ phys_kbytes /= 1024; /* Convert to Kbytes. */

14
gcc/ggc-page.c
View File

@ -462,7 +462,7 @@ static struct globals
/* The size in bytes required to maintain a bitmap for the objects /* The size in bytes required to maintain a bitmap for the objects
on a page-entry. */ on a page-entry. */
#define BITMAP_SIZE(Num_objects) \ #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 /* Allocate pages in chunks of this size, to throttle calls to memory
allocation routines. The first page is used, the rest go onto the 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); page = alloc_anon (NULL, G.pagesize * GGC_QUIRE_SIZE, false);
if (page == NULL) if (page == NULL)
{ {
page = alloc_anon(NULL, G.pagesize, true); page = alloc_anon (NULL, G.pagesize, true);
entries = 1; entries = 1;
} }
@ -1644,7 +1644,7 @@ init_ggc (void)
{ {
unsigned order; unsigned order;
G.pagesize = getpagesize(); G.pagesize = getpagesize ();
G.lg_pagesize = exact_log2 (G.pagesize); G.lg_pagesize = exact_log2 (G.pagesize);
#ifdef HAVE_MMAP_DEV_ZERO #ifdef HAVE_MMAP_DEV_ZERO
@ -2163,7 +2163,7 @@ ggc_print_statistics (void)
} }
fprintf (stderr, "%-5s %10lu%c %10lu%c %10lu%c\n", "Total", fprintf (stderr, "%-5s %10lu%c %10lu%c %10lu%c\n", "Total",
SCALE (G.bytes_mapped), STAT_LABEL (G.bytes_mapped), 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)); SCALE (total_overhead), STAT_LABEL (total_overhead));
if (GATHER_STATISTICS) if (GATHER_STATISTICS)
@ -2315,13 +2315,13 @@ ggc_pch_write_object (struct ggc_pch_data *d,
if (size != OBJECT_SIZE (order)) 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 /* 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 than most padding requests as the source for our null bytes. This
permits us to do the padding with fwrite() rather than fseek(), and permits us to do the padding with fwrite() rather than fseek(), and
limits the chance the OS may try to flush any outstanding writes. */ 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) if (fwrite (emptyBytes, 1, padding, f) != padding)
fatal_error ("can%'t write PCH file"); fatal_error ("can%'t write PCH file");
@ -2419,7 +2419,7 @@ ggc_pch_read (FILE *f, void *addr)
#endif #endif
/* Since we free all the allocated objects, the free list becomes /* Since we free all the allocated objects, the free list becomes
useless. Validate it now, which will also clear it. */ 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 /* 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 context depth to 1, and set the depth of all the currently-allocated

2
gcc/gimple-fold.c
View File

@ -2825,7 +2825,7 @@ fold_array_ctor_reference (tree type, tree ctor,
else else
low_bound = double_int_zero; low_bound = double_int_zero;
/* Static constructors for variably sized objects makes no sense. */ /* 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); == INTEGER_CST);
elt_size = elt_size =
tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))); tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))));

9
gcc/gimple-low.c
View File

@ -118,7 +118,8 @@ lower_function_body (void)
need to do anything special. Otherwise build one by hand. */ need to do anything special. Otherwise build one by hand. */
if (gimple_seq_may_fallthru (lowered_body) if (gimple_seq_may_fallthru (lowered_body)
&& (data.return_statements.is_empty () && (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); x = gimple_build_return (NULL);
gimple_set_location (x, cfun->function_end_locus); 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 class pass_lower_cf : public gimple_opt_pass
{ {
public: public:
pass_lower_cf(gcc::context *ctxt) pass_lower_cf (gcc::context *ctxt)
: gimple_opt_pass(pass_data_lower_cf, ctxt) : gimple_opt_pass (pass_data_lower_cf, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -707,7 +708,7 @@ block_may_fallthru (const_tree block)
{ {
/* This CONST_CAST is okay because expr_last returns its argument /* This CONST_CAST is okay because expr_last returns its argument
unmodified and we assign it to a const_tree. */ 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) switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
{ {

4
gcc/gimple-pretty-print.c
View File

@ -524,7 +524,7 @@ dump_gimple_assign (pretty_printer *buffer, gimple gs, int spc, int flags)
else else
gcc_unreachable (); gcc_unreachable ();
if (!(flags & TDF_RHS_ONLY)) 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); pp_newline_and_flush (buffer);
gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl)); gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl));
dump_histograms_for_stmt (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); dump_implicit_edges (buffer, bb, indent, flags);

4
gcc/gimple-ssa-strength-reduction.c
View File

@ -3564,8 +3564,8 @@ const pass_data pass_data_strength_reduction =
class pass_strength_reduction : public gimple_opt_pass class pass_strength_reduction : public gimple_opt_pass
{ {
public: public:
pass_strength_reduction(gcc::context *ctxt) pass_strength_reduction (gcc::context *ctxt)
: gimple_opt_pass(pass_data_strength_reduction, ctxt) : gimple_opt_pass (pass_data_strength_reduction, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

4
gcc/gimple.c
View File

@ -54,7 +54,7 @@ EXPORTED_CONST size_t gimple_ops_offset_[] = {
}; };
#undef DEFGSSTRUCT #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[] = { static const size_t gsstruct_code_size[] = {
#include "gsstruct.def" #include "gsstruct.def"
}; };
@ -2153,7 +2153,7 @@ gimple_set_lhs (gimple stmt, tree lhs)
else if (code == GIMPLE_CALL) else if (code == GIMPLE_CALL)
gimple_call_set_lhs (stmt, lhs); gimple_call_set_lhs (stmt, lhs);
else else
gcc_unreachable(); gcc_unreachable ();
} }

4
gcc/gimple.h
View File

@ -5037,7 +5037,7 @@ gsi_start_1 (gimple_seq *seq)
return i; return i;
} }
#define gsi_start(x) gsi_start_1(&(x)) #define gsi_start(x) gsi_start_1 (&(x))
static inline gimple_stmt_iterator static inline gimple_stmt_iterator
gsi_none (void) gsi_none (void)
@ -5080,7 +5080,7 @@ gsi_last_1 (gimple_seq *seq)
return i; 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. */ /* Return a new iterator pointing to the last statement in basic block BB. */

2
gcc/godump.c
View File

@ -1213,7 +1213,7 @@ go_finish (const char *filename)
break; break;
default: default:
gcc_unreachable(); gcc_unreachable ();
} }
} }

13
gcc/graphite-clast-to-gimple.c
View File

@ -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 = translate_clast_assignment ((struct clast_assignment *) stmt,
next_e, level, ip); next_e, level, ip);
else else
gcc_unreachable(); gcc_unreachable ();
recompute_all_dominators (); recompute_all_dominators ();
graphite_verify (); graphite_verify ();
@ -1409,7 +1409,7 @@ init_cloog_input_file (int scop_number)
/* Extend the scattering to NEW_DIMS scattering dimensions. */ /* Extend the scattering to NEW_DIMS scattering dimensions. */
static 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; int old_dims, i;
isl_space *space; 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, /* Dead code elimination: when the domain of a PBB is empty,
don't generate code for the PBB. */ don't generate code for the PBB. */
if (isl_set_is_empty(pbb->domain)) if (isl_set_is_empty (pbb->domain))
continue; continue;
domain = cloog_domain_from_isl_set(isl_set_copy(pbb->domain)); domain = cloog_domain_from_isl_set (isl_set_copy (pbb->domain));
scattering = cloog_scattering_from_isl_map(extend_scattering(isl_map_copy(pbb->transformed), scattering = cloog_scattering_from_isl_map
nb_scattering_dims)); (extend_scattering (isl_map_copy (pbb->transformed),
nb_scattering_dims));
union_domain = cloog_union_domain_add_domain (union_domain, "", domain, union_domain = cloog_union_domain_add_domain (union_domain, "", domain,
scattering, pbb); scattering, pbb);

217
gcc/graphite-optimize-isl.c
View File

@ -114,7 +114,7 @@ scop_get_dependences (scop_p scop)
*/ */
static isl_basic_map * static isl_basic_map *
getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize) getTileMap (isl_ctx *ctx, int scheduleDimensions, int tileSize)
{ {
int x; int x;
/* We construct /* 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} s1 = a1 * 32 and s1 = p1 and t1 <= p1 < t1 + 32}
and project out the auxilary dimensions a0 and a1. */ and project out the auxilary dimensions a0 and a1. */
isl_space *Space = isl_space_alloc(ctx, 0, scheduleDimensions, isl_space *Space = isl_space_alloc (ctx, 0, scheduleDimensions,
scheduleDimensions * 3); scheduleDimensions * 3);
isl_basic_map *tileMap = isl_basic_map_universe(isl_space_copy(Space)); 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++) for (x = 0; x < scheduleDimensions; x++)
{ {
@ -140,29 +140,29 @@ getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize)
isl_constraint *c; isl_constraint *c;
/* sX = aX * tileSize; */ /* sX = aX * tileSize; */
c = isl_equality_alloc(isl_local_space_copy(LocalSpace)); 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, sX, 1);
isl_constraint_set_coefficient_si(c, isl_dim_out, aX, -tileSize); isl_constraint_set_coefficient_si (c, isl_dim_out, aX, -tileSize);
tileMap = isl_basic_map_add_constraint(tileMap, c); tileMap = isl_basic_map_add_constraint (tileMap, c);
/* pX = sX; */ /* pX = sX; */
c = isl_equality_alloc(isl_local_space_copy(LocalSpace)); 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_out, pX, 1);
isl_constraint_set_coefficient_si(c, isl_dim_in, sX, -1); isl_constraint_set_coefficient_si (c, isl_dim_in, sX, -1);
tileMap = isl_basic_map_add_constraint(tileMap, c); tileMap = isl_basic_map_add_constraint (tileMap, c);
/* tX <= pX */ /* tX <= pX */
c = isl_inequality_alloc(isl_local_space_copy(LocalSpace)); 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, pX, 1);
isl_constraint_set_coefficient_si(c, isl_dim_out, tX, -1); isl_constraint_set_coefficient_si (c, isl_dim_out, tX, -1);
tileMap = isl_basic_map_add_constraint(tileMap, c); tileMap = isl_basic_map_add_constraint (tileMap, c);
/* pX <= tX + (tileSize - 1) */ /* pX <= tX + (tileSize - 1) */
c = isl_inequality_alloc(isl_local_space_copy(LocalSpace)); 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, tX, 1);
isl_constraint_set_coefficient_si(c, isl_dim_out, pX, -1); isl_constraint_set_coefficient_si (c, isl_dim_out, pX, -1);
isl_constraint_set_constant_si(c, tileSize - 1); isl_constraint_set_constant_si (c, tileSize - 1);
tileMap = isl_basic_map_add_constraint(tileMap, c); tileMap = isl_basic_map_add_constraint (tileMap, c);
} }
/* Project out auxiliary dimensions. /* 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. The auxiliary dimensions are transformed into existentially quantified ones.
This reduces the number of visible scattering dimensions and allows Cloog This reduces the number of visible scattering dimensions and allows Cloog
to produces better code. */ to produces better code. */
tileMap = isl_basic_map_project_out(tileMap, isl_dim_out, tileMap = isl_basic_map_project_out (tileMap, isl_dim_out,
2 * scheduleDimensions, 2 * scheduleDimensions,
scheduleDimensions); scheduleDimensions);
isl_local_space_free(LocalSpace); isl_local_space_free (LocalSpace);
return tileMap; return tileMap;
} }
@ -185,7 +185,7 @@ getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize)
static bool DisableTiling = false; static bool DisableTiling = false;
static isl_union_map * static isl_union_map *
getScheduleForBand(isl_band *Band, int *Dimensions) getScheduleForBand (isl_band *Band, int *Dimensions)
{ {
isl_union_map *PartialSchedule; isl_union_map *PartialSchedule;
isl_ctx *ctx; isl_ctx *ctx;
@ -193,8 +193,8 @@ getScheduleForBand(isl_band *Band, int *Dimensions)
isl_basic_map *TileMap; isl_basic_map *TileMap;
isl_union_map *TileUMap; isl_union_map *TileUMap;
PartialSchedule = isl_band_get_partial_schedule(Band); PartialSchedule = isl_band_get_partial_schedule (Band);
*Dimensions = isl_band_n_member(Band); *Dimensions = isl_band_n_member (Band);
if (DisableTiling) if (DisableTiling)
return PartialSchedule; return PartialSchedule;
@ -203,15 +203,15 @@ getScheduleForBand(isl_band *Band, int *Dimensions)
if (*Dimensions == 1) if (*Dimensions == 1)
return PartialSchedule; return PartialSchedule;
ctx = isl_union_map_get_ctx(PartialSchedule); ctx = isl_union_map_get_ctx (PartialSchedule);
Space = isl_union_map_get_space(PartialSchedule); Space = isl_union_map_get_space (PartialSchedule);
TileMap = getTileMap(ctx, *Dimensions, 32); TileMap = getTileMap (ctx, *Dimensions, 32);
TileUMap = isl_union_map_from_map(isl_map_from_basic_map(TileMap)); TileUMap = isl_union_map_from_map (isl_map_from_basic_map (TileMap));
TileUMap = isl_union_map_align_params(TileUMap, Space); TileUMap = isl_union_map_align_params (TileUMap, Space);
*Dimensions = 2 * *Dimensions; *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. /* 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 currently constant and not yet target specific. This function does not reason
about parallelism. */ about parallelism. */
static isl_map * static isl_map *
getPrevectorMap(isl_ctx *ctx, int DimToVectorize, getPrevectorMap (isl_ctx *ctx, int DimToVectorize,
int ScheduleDimensions, int ScheduleDimensions,
int VectorWidth) int VectorWidth)
{ {
isl_space *Space; isl_space *Space;
isl_local_space *LocalSpace, *LocalSpaceRange; isl_local_space *LocalSpace, *LocalSpaceRange;
@ -270,9 +270,9 @@ getPrevectorMap(isl_ctx *ctx, int DimToVectorize,
/* assert (0 <= DimToVectorize && DimToVectorize < ScheduleDimensions);*/ /* assert (0 <= DimToVectorize && DimToVectorize < ScheduleDimensions);*/
Space = isl_space_alloc(ctx, 0, ScheduleDimensions, ScheduleDimensions + 1); Space = isl_space_alloc (ctx, 0, ScheduleDimensions, ScheduleDimensions + 1);
TilingMap = isl_map_universe(isl_space_copy(Space)); TilingMap = isl_map_universe (isl_space_copy (Space));
LocalSpace = isl_local_space_from_space(Space); LocalSpace = isl_local_space_from_space (Space);
PointDimension = ScheduleDimensions; PointDimension = ScheduleDimensions;
TileDimension = DimToVectorize; TileDimension = DimToVectorize;
@ -280,43 +280,43 @@ getPrevectorMap(isl_ctx *ctx, int DimToVectorize,
DimToVectorize to the point loop at the innermost dimension. */ DimToVectorize to the point loop at the innermost dimension. */
for (i = 0; i < ScheduleDimensions; i++) for (i = 0; i < ScheduleDimensions; i++)
{ {
c = isl_equality_alloc(isl_local_space_copy(LocalSpace)); c = isl_equality_alloc (isl_local_space_copy (LocalSpace));
isl_constraint_set_coefficient_si(c, isl_dim_in, i, -1); isl_constraint_set_coefficient_si (c, isl_dim_in, i, -1);
if (i == DimToVectorize) 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 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 */ /* it % 'VectorWidth' = 0 */
LocalSpaceRange = isl_local_space_range(isl_local_space_copy(LocalSpace)); LocalSpaceRange = isl_local_space_range (isl_local_space_copy (LocalSpace));
Aff = isl_aff_zero_on_domain(LocalSpaceRange); Aff = isl_aff_zero_on_domain (LocalSpaceRange);
Aff = isl_aff_set_constant_si(Aff, VectorWidth); Aff = isl_aff_set_constant_si (Aff, VectorWidth);
Aff = isl_aff_set_coefficient_si(Aff, isl_dim_in, TileDimension, 1); Aff = isl_aff_set_coefficient_si (Aff, isl_dim_in, TileDimension, 1);
isl_int_init(VectorWidthMP); isl_int_init (VectorWidthMP);
isl_int_set_si(VectorWidthMP, VectorWidth); isl_int_set_si (VectorWidthMP, VectorWidth);
Aff = isl_aff_mod(Aff, VectorWidthMP); Aff = isl_aff_mod (Aff, VectorWidthMP);
isl_int_clear(VectorWidthMP); isl_int_clear (VectorWidthMP);
Modulo = isl_pw_aff_zero_set(isl_pw_aff_from_aff(Aff)); Modulo = isl_pw_aff_zero_set (isl_pw_aff_from_aff (Aff));
TilingMap = isl_map_intersect_range(TilingMap, Modulo); TilingMap = isl_map_intersect_range (TilingMap, Modulo);
/* it <= ip */ /* it <= ip */
c = isl_inequality_alloc(isl_local_space_copy(LocalSpace)); 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, TileDimension, -1);
isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, 1); isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, 1);
TilingMap = isl_map_add_constraint(TilingMap, c); TilingMap = isl_map_add_constraint (TilingMap, c);
/* ip <= it + ('VectorWidth' - 1) */ /* ip <= it + ('VectorWidth' - 1) */
c = isl_inequality_alloc(LocalSpace); 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, TileDimension, 1);
isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, -1); isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, -1);
isl_constraint_set_constant_si(c, VectorWidth - 1); isl_constraint_set_constant_si (c, VectorWidth - 1);
TilingMap = isl_map_add_constraint(TilingMap, c); TilingMap = isl_map_add_constraint (TilingMap, c);
isl_map_dump(TilingMap); isl_map_dump (TilingMap);
return TilingMap; return TilingMap;
} }
@ -329,15 +329,15 @@ static bool EnablePollyVector = false;
individual bands to the overall schedule. In case tiling is requested, individual bands to the overall schedule. In case tiling is requested,
the individual bands are tiled. */ the individual bands are tiled. */
static isl_union_map * static isl_union_map *
getScheduleForBandList(isl_band_list *BandList) getScheduleForBandList (isl_band_list *BandList)
{ {
int NumBands, i; int NumBands, i;
isl_union_map *Schedule; isl_union_map *Schedule;
isl_ctx *ctx; isl_ctx *ctx;
ctx = isl_band_list_get_ctx(BandList); ctx = isl_band_list_get_ctx (BandList);
NumBands = isl_band_list_n_band(BandList); NumBands = isl_band_list_n_band (BandList);
Schedule = isl_union_map_empty(isl_space_params_alloc(ctx, 0)); Schedule = isl_union_map_empty (isl_space_params_alloc (ctx, 0));
for (i = 0; i < NumBands; i++) for (i = 0; i < NumBands; i++)
{ {
@ -346,61 +346,61 @@ getScheduleForBandList(isl_band_list *BandList)
int ScheduleDimensions; int ScheduleDimensions;
isl_space *Space; isl_space *Space;
Band = isl_band_list_get_band(BandList, i); Band = isl_band_list_get_band (BandList, i);
PartialSchedule = getScheduleForBand(Band, &ScheduleDimensions); PartialSchedule = getScheduleForBand (Band, &ScheduleDimensions);
Space = isl_union_map_get_space(PartialSchedule); Space = isl_union_map_get_space (PartialSchedule);
if (isl_band_has_children(Band)) if (isl_band_has_children (Band))
{ {
isl_band_list *Children; isl_band_list *Children;
isl_union_map *SuffixSchedule; isl_union_map *SuffixSchedule;
Children = isl_band_get_children(Band); Children = isl_band_get_children (Band);
SuffixSchedule = getScheduleForBandList(Children); SuffixSchedule = getScheduleForBandList (Children);
PartialSchedule = isl_union_map_flat_range_product(PartialSchedule, PartialSchedule = isl_union_map_flat_range_product (PartialSchedule,
SuffixSchedule); SuffixSchedule);
isl_band_list_free(Children); isl_band_list_free (Children);
} }
else if (EnablePollyVector) else if (EnablePollyVector)
{ {
for (i = ScheduleDimensions - 1 ; i >= 0 ; i--) 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_map *TileMap;
isl_union_map *TileUMap; isl_union_map *TileUMap;
TileMap = getPrevectorMap(ctx, i, ScheduleDimensions, 4); TileMap = getPrevectorMap (ctx, i, ScheduleDimensions, 4);
TileUMap = isl_union_map_from_map(TileMap); TileUMap = isl_union_map_from_map (TileMap);
TileUMap = isl_union_map_align_params(TileUMap, TileUMap = isl_union_map_align_params
isl_space_copy(Space)); (TileUMap, isl_space_copy (Space));
PartialSchedule = isl_union_map_apply_range(PartialSchedule, PartialSchedule = isl_union_map_apply_range
TileUMap); (PartialSchedule, TileUMap);
break; break;
} }
} }
} }
Schedule = isl_union_map_union(Schedule, PartialSchedule); Schedule = isl_union_map_union (Schedule, PartialSchedule);
isl_band_free(Band); isl_band_free (Band);
isl_space_free(Space); isl_space_free (Space);
} }
return Schedule; return Schedule;
} }
static isl_union_map * static isl_union_map *
getScheduleMap(isl_schedule *Schedule) getScheduleMap (isl_schedule *Schedule)
{ {
isl_band_list *BandList = isl_schedule_get_band_forest(Schedule); isl_band_list *BandList = isl_schedule_get_band_forest (Schedule);
isl_union_map *ScheduleMap = getScheduleForBandList(BandList); isl_union_map *ScheduleMap = getScheduleForBandList (BandList);
isl_band_list_free(BandList); isl_band_list_free (BandList);
return ScheduleMap; return ScheduleMap;
} }
static int static int
getSingleMap(__isl_take isl_map *map, void *user) getSingleMap (__isl_take isl_map *map, void *user)
{ {
isl_map **singleMap = (isl_map **) user; isl_map **singleMap = (isl_map **) user;
*singleMap = map; *singleMap = map;
@ -420,12 +420,13 @@ apply_schedule_map_to_scop (scop_p scop, isl_union_map *schedule_map)
isl_union_map *stmtBand; isl_union_map *stmtBand;
isl_map *stmtSchedule; isl_map *stmtSchedule;
stmtBand = isl_union_map_intersect_domain(isl_union_map_copy(schedule_map), stmtBand = isl_union_map_intersect_domain
isl_union_set_from_set(domain)); (isl_union_map_copy (schedule_map),
isl_union_map_foreach_map(stmtBand, getSingleMap, &stmtSchedule); isl_union_set_from_set (domain));
isl_map_free(pbb->transformed); isl_union_map_foreach_map (stmtBand, getSingleMap, &stmtSchedule);
isl_map_free (pbb->transformed);
pbb->transformed = stmtSchedule; 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); domain = scop_get_domains (scop);
dependences = scop_get_dependences (scop); dependences = scop_get_dependences (scop);
dependences = isl_union_map_gist_domain(dependences, dependences = isl_union_map_gist_domain (dependences,
isl_union_set_copy(domain)); isl_union_set_copy (domain));
dependences = isl_union_map_gist_range(dependences, dependences = isl_union_map_gist_range (dependences,
isl_union_set_copy(domain)); isl_union_set_copy (domain));
validity = dependences; validity = dependences;
proximity = isl_union_map_copy (validity); proximity = isl_union_map_copy (validity);
isl_options_set_schedule_max_constant_term(scop->ctx, CONSTANT_BOUND); 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_maximize_band_depth (scop->ctx, 1);
isl_options_set_schedule_fuse(scop->ctx, ISL_SCHEDULE_FUSE_MIN); 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_on_error (scop->ctx, ISL_ON_ERROR_CONTINUE);
schedule = isl_union_set_compute_schedule (domain, validity, proximity); 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) if (!schedule)
return false; return false;

2
gcc/graphite-poly.h
View File

@ -403,7 +403,7 @@ extern int scop_do_interchange (scop_p);
extern int scop_do_strip_mine (scop_p, int); extern int scop_do_strip_mine (scop_p, int);
extern bool scop_do_block (scop_p); extern bool scop_do_block (scop_p);
extern bool flatten_all_loops (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 pbb_number_of_iterations_at_time (poly_bb_p, graphite_dim_t, mpz_t);
extern void debug_gmp_value (mpz_t); extern void debug_gmp_value (mpz_t);

8
gcc/graphite-sese-to-poly.c
View File

@ -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); id = isl_id_for_ssa_name (s, e);
dimension = isl_space_find_dim_by_id (space, isl_dim_param, id); 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)); dom = isl_set_universe (isl_space_copy (space));
aff = isl_aff_zero_on_domain (isl_local_space_from_space (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); 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) if (TREE_CODE (nb_iters) == INTEGER_CST)
{ {
c = isl_inequality_alloc 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); c = isl_constraint_set_coefficient_si (c, isl_dim_set, pos, -1);
tree_int_to_gmp (nb_iters, g); tree_int_to_gmp (nb_iters, g);
isl_int_set_gmp (v, 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; break;
default: default:
isl_pw_aff_free(lhs); isl_pw_aff_free (lhs);
isl_pw_aff_free(rhs); isl_pw_aff_free (rhs);
return; return;
} }

2
gcc/graphite.c
View File

@ -265,7 +265,7 @@ graphite_transform_loops (void)
return; return;
ctx = isl_ctx_alloc (); 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)) if (!graphite_initialize (ctx))
return; return;

4
gcc/haifa-sched.c
View File

@ -2605,7 +2605,7 @@ rank_for_schedule (const void *x, const void *y)
} }
info_val = (*current_sched_info->rank) (tmp, tmp2); 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; return info_val;
/* Compare insns based on their relation to the last scheduled /* 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, /* Fix priorities. If MUTATE_P is nonzero, this is not necessary,
because it'll be done later in add_to_speculative_block. */ 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); clear_priorities (twin, &priorities_roots);
calc_priorities (priorities_roots); calc_priorities (priorities_roots);

2
gcc/hash-table.c
View File

@ -111,7 +111,7 @@ unsigned int
hash_table_higher_prime_index (unsigned long n) hash_table_higher_prime_index (unsigned long n)
{ {
unsigned int low = 0; 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) while (low != high)
{ {

8
gcc/hash-table.h
View File

@ -456,8 +456,8 @@ public:
int (*Callback) (value_type **slot, Argument argument)> int (*Callback) (value_type **slot, Argument argument)>
void traverse (Argument argument); void traverse (Argument argument);
iterator begin(); iterator begin ();
iterator end(); iterator end ();
}; };
@ -522,7 +522,7 @@ hash_table <Descriptor, Allocator>::remove_elt (const value_type *value)
template <typename Descriptor, template <typename Descriptor,
template <typename Type> class Allocator> template <typename Type> class Allocator>
inline size_t inline size_t
hash_table <Descriptor, Allocator>::size() hash_table <Descriptor, Allocator>::size ()
{ {
return htab->size; return htab->size;
} }
@ -556,7 +556,7 @@ hash_table <Descriptor, Allocator>::elements_with_deleted ()
template <typename Descriptor, template <typename Descriptor,
template <typename Type> class Allocator> template <typename Type> class Allocator>
inline double inline double
hash_table <Descriptor, Allocator>::collisions() hash_table <Descriptor, Allocator>::collisions ()
{ {
if (htab->searches == 0) if (htab->searches == 0)
return 0.0; return 0.0;

2
gcc/hwint.c
View File

@ -93,7 +93,7 @@ ctz_hwi (unsigned HOST_WIDE_INT x)
int int
clz_hwi (unsigned HOST_WIDE_INT x) 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 /* Similar to ctz_hwi, except that the least significant bit is numbered

14
gcc/hwint.h
View File

@ -37,7 +37,7 @@
# if GCC_VERSION >= 3000 # if GCC_VERSION >= 3000
# define HAVE_LONG_LONG 1 # define HAVE_LONG_LONG 1
# define SIZEOF_LONG_LONG 8 # 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
#endif #endif
@ -110,11 +110,11 @@ extern char sizeof_long_long_must_be_8[sizeof(long long) == 8 ? 1 : -1];
#endif #endif
#define HOST_WIDE_INT_UC(X) HOST_WIDE_INT_C(X ## U) #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_1 HOST_WIDE_INT_C (1)
#define HOST_WIDE_INT_1U HOST_WIDE_INT_UC(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_M1 HOST_WIDE_INT_C (-1)
#define HOST_WIDE_INT_M1U HOST_WIDE_INT_UC(-1) #define HOST_WIDE_INT_M1U HOST_WIDE_INT_UC (-1)
/* This is a magic identifier which allows GCC to figure out the type /* 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 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_UNSIGNED HOST_WIDE_INT_PRINT_UNSIGNED
# define HOST_WIDEST_INT_PRINT_HEX HOST_WIDE_INT_PRINT_HEX # 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_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 #else
# if HOST_BITS_PER_LONGLONG >= 64 # if HOST_BITS_PER_LONGLONG >= 64
# define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_LONGLONG # define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_LONGLONG

14
gcc/ifcvt.c
View File

@ -336,7 +336,7 @@ cond_exec_process_insns (ce_if_block_t *ce_info ATTRIBUTE_UNUSED,
if (NOTE_P (insn) || DEBUG_INSN_P (insn)) if (NOTE_P (insn) || DEBUG_INSN_P (insn))
goto insn_done; 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. */ /* Remove USE insns that get in the way. */
if (reload_completed && GET_CODE (PATTERN (insn)) == USE) 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 class pass_rtl_ifcvt : public rtl_opt_pass
{ {
public: public:
pass_rtl_ifcvt(gcc::context *ctxt) pass_rtl_ifcvt (gcc::context *ctxt)
: rtl_opt_pass(pass_data_rtl_ifcvt, ctxt) : rtl_opt_pass (pass_data_rtl_ifcvt, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -4558,8 +4558,8 @@ const pass_data pass_data_if_after_combine =
class pass_if_after_combine : public rtl_opt_pass class pass_if_after_combine : public rtl_opt_pass
{ {
public: public:
pass_if_after_combine(gcc::context *ctxt) pass_if_after_combine (gcc::context *ctxt)
: rtl_opt_pass(pass_data_if_after_combine, ctxt) : rtl_opt_pass (pass_data_if_after_combine, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */
@ -4612,8 +4612,8 @@ const pass_data pass_data_if_after_reload =
class pass_if_after_reload : public rtl_opt_pass class pass_if_after_reload : public rtl_opt_pass
{ {
public: public:
pass_if_after_reload(gcc::context *ctxt) pass_if_after_reload (gcc::context *ctxt)
: rtl_opt_pass(pass_data_if_after_reload, ctxt) : rtl_opt_pass (pass_data_if_after_reload, ctxt)
{} {}
/* opt_pass methods: */ /* opt_pass methods: */

Some files were not shown because too many files have changed in this diff Show More