+2013-09-28 Richard Sandiford <rdsandiford@googlemail.com>
+
+ * alloc-pool.c, asan.c, auto-inc-dec.c, basic-block.h, bb-reorder.c,
+ bitmap.c, bitmap.h, bt-load.c, builtins.c, calls.c, cfgcleanup.c,
+ cfgexpand.c, cfghooks.c, cfgloop.c, cfgloopmanip.c, cfgrtl.c, cgraph.c,
+ cgraph.h, cgraphbuild.c, cgraphclones.c, cgraphunit.c, collect2.c,
+ combine-stack-adj.c, combine.c, compare-elim.c, context.c, context.h,
+ cprop.c, cse.c, cselib.c, dbxout.c, dce.c, defaults.h, df-core.c,
+ df-problems.c, df-scan.c, df.h, diagnostic.c, double-int.c, dse.c,
+ dumpfile.c, dwarf2asm.c, dwarf2cfi.c, dwarf2out.c, emit-rtl.c,
+ errors.c, except.c, expmed.c, expr.c, file-find.c, final.c,
+ fixed-value.c, fold-const.c, function.c, fwprop.c, gcc-ar.c, gcc.c,
+ gcov-io.c, gcov-io.h, gcov.c, gcse.c, genattr-common.c, genattr.c,
+ genattrtab.c, genautomata.c, genconfig.c, genemit.c, genextract.c,
+ genflags.c, gengenrtl.c, gengtype-state.c, gengtype.c, genmodes.c,
+ genopinit.c, genoutput.c, genpeep.c, genpreds.c, genrecog.c,
+ gensupport.c, ggc-common.c, ggc-page.c, gimple-fold.c, gimple-low.c,
+ gimple-pretty-print.c, gimple-ssa-strength-reduction.c, gimple.c,
+ gimple.h, godump.c, graphite-clast-to-gimple.c,
+ graphite-optimize-isl.c, graphite-poly.h, graphite-sese-to-poly.c,
+ graphite.c, haifa-sched.c, hash-table.c, hash-table.h, hwint.c,
+ hwint.h, ifcvt.c, incpath.c, init-regs.c, input.h, intl.c, intl.h,
+ ipa-cp.c, ipa-devirt.c, ipa-inline-analysis.c, ipa-inline.c,
+ ipa-profile.c, ipa-pure-const.c, ipa-reference.c, ipa-split.c,
+ ipa-utils.c, ipa.c, ira-build.c, ira.c, jump.c, loop-doloop.c,
+ loop-init.c, loop-invariant.c, loop-iv.c, lower-subreg.c, lto-cgraph.c,
+ lto-streamer-in.c, lto-streamer-out.c, lto-wrapper.c, mcf.c,
+ mode-switching.c, modulo-sched.c, omp-low.c, optabs.c, opts.c,
+ pass_manager.h, passes.c, plugin.c, postreload-gcse.c, postreload.c,
+ predict.c, prefix.c, pretty-print.c, print-rtl.c, print-tree.c,
+ profile.c, read-md.c, real.c, real.h, recog.c, ree.c, reg-stack.c,
+ regcprop.c, reginfo.c, regmove.c, regrename.c, regs.h, regstat.c,
+ reload1.c, reorg.c, rtl.c, rtl.h, rtlanal.c, sbitmap.c, sched-rgn.c,
+ sdbout.c, sel-sched-ir.c, sel-sched.c, sparseset.c, stack-ptr-mod.c,
+ statistics.c, stmt.c, stor-layout.c, store-motion.c, streamer-hooks.h,
+ system.h, target-hooks-macros.h, targhooks.c, targhooks.h, toplev.c,
+ tracer.c, trans-mem.c, tree-browser.c, tree-call-cdce.c, tree-cfg.c,
+ tree-cfgcleanup.c, tree-complex.c, tree-data-ref.c, tree-data-ref.h,
+ tree-eh.c, tree-emutls.c, tree-flow.h, tree-if-conv.c, tree-into-ssa.c,
+ tree-iterator.c, tree-loop-distribution.c, tree-mudflap.c,
+ tree-nested.c, tree-nomudflap.c, tree-nrv.c, tree-object-size.c,
+ tree-optimize.c, tree-pass.h, tree-pretty-print.c, tree-profile.c,
+ tree-scalar-evolution.c, tree-sra.c, tree-ssa-ccp.c,
+ tree-ssa-coalesce.c, tree-ssa-copy.c, tree-ssa-copyrename.c,
+ tree-ssa-dce.c, tree-ssa-dom.c, tree-ssa-dse.c, tree-ssa-forwprop.c,
+ tree-ssa-ifcombine.c, tree-ssa-live.c, tree-ssa-loop-ch.c,
+ tree-ssa-loop-im.c, tree-ssa-loop-ivopts.c, tree-ssa-loop-prefetch.c,
+ tree-ssa-loop.c, tree-ssa-math-opts.c, tree-ssa-operands.c,
+ tree-ssa-phiopt.c, tree-ssa-phiprop.c, tree-ssa-pre.c,
+ tree-ssa-reassoc.c, tree-ssa-sink.c, tree-ssa-strlen.c,
+ tree-ssa-structalias.c, tree-ssa-threadedge.c, tree-ssa-threadupdate.c,
+ tree-ssa-uncprop.c, tree-ssa-uninit.c, tree-ssa.c, tree-ssanames.c,
+ tree-stdarg.c, tree-switch-conversion.c, tree-tailcall.c,
+ tree-vect-data-refs.c, tree-vect-generic.c, tree-vect-loop-manip.c,
+ tree-vect-stmts.c, tree-vectorizer.c, tree-vectorizer.h, tree-vrp.c,
+ tree.c, tree.h, tsan.c, tsystem.h, value-prof.c, var-tracking.c,
+ varasm.c, vec.h, vmsdbgout.c, vtable-verify.c, web.c: Add missing
+ whitespace before "(".
+
2013-09-28 Sandra Loosemore <sandra@codesourcery.com>
* expr.h (extract_bit_field): Remove packedp parameter.
/* Pull the first free element from the free list, and return it. */
header = pool->returned_free_list;
- VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (header, sizeof(*header)));
+ VALGRIND_DISCARD (VALGRIND_MAKE_MEM_DEFINED (header, sizeof (*header)));
pool->returned_free_list = header->next;
pool->elts_free--;
class pass_asan : public gimple_opt_pass
{
public:
- pass_asan(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_asan, ctxt)
+ pass_asan (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_asan, ctxt)
{}
/* opt_pass methods: */
class pass_asan_O0 : public gimple_opt_pass
{
public:
- pass_asan_O0(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_asan_O0, ctxt)
+ pass_asan_O0 (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_asan_O0, ctxt)
{}
/* opt_pass methods: */
{
/* In this case, we must clear these vectors since the trick of
testing if the stale insn in the block will not work. */
- memset (reg_next_use, 0, max_reg * sizeof(rtx));
- memset (reg_next_inc_use, 0, max_reg * sizeof(rtx));
- memset (reg_next_def, 0, max_reg * sizeof(rtx));
+ memset (reg_next_use, 0, max_reg * sizeof (rtx));
+ memset (reg_next_inc_use, 0, max_reg * sizeof (rtx));
+ memset (reg_next_def, 0, max_reg * sizeof (rtx));
df_recompute_luids (bb);
merge_in_block (max_reg, bb);
}
class pass_inc_dec : public rtl_opt_pass
{
public:
- pass_inc_dec(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_inc_dec, ctxt)
+ pass_inc_dec (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_inc_dec, ctxt)
{}
/* opt_pass methods: */
struct rtl_bb_info, so that inlining the former into basic_block_def
is the better choice. */
typedef int __assert_gimple_bb_smaller_rtl_bb
- [(int)sizeof(struct rtl_bb_info)
- - (int)sizeof (struct gimple_bb_info)];
+ [(int) sizeof (struct rtl_bb_info)
+ - (int) sizeof (struct gimple_bb_info)];
#define BB_FREQ_MAX 10000
#define profile_status_for_function(FN) ((FN)->cfg->x_profile_status)
#define BASIC_BLOCK_FOR_FUNCTION(FN,N) \
- ((*basic_block_info_for_function(FN))[(N)])
+ ((*basic_block_info_for_function (FN))[(N)])
#define SET_BASIC_BLOCK_FOR_FUNCTION(FN,N,BB) \
- ((*basic_block_info_for_function(FN))[(N)] = (BB))
+ ((*basic_block_info_for_function (FN))[(N)] = (BB))
/* Defines for textual backward source compatibility. */
#define ENTRY_BLOCK_PTR (cfun->cfg->x_entry_block_ptr)
#define FOR_EACH_BB_REVERSE_FN(BB, FN) \
FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb)
-#define FOR_EACH_BB_REVERSE(BB) FOR_EACH_BB_REVERSE_FN(BB, cfun)
+#define FOR_EACH_BB_REVERSE(BB) FOR_EACH_BB_REVERSE_FN (BB, cfun)
/* For iterating over insns in basic block. */
#define FOR_BB_INSNS(BB, INSN) \
/* In profile.c. */
typedef struct gcov_working_set_info gcov_working_set_t;
-extern gcov_working_set_t *find_working_set(unsigned pct_times_10);
+extern gcov_working_set_t *find_working_set (unsigned pct_times_10);
/* Check tha probability is sane. */
class pass_reorder_blocks : public rtl_opt_pass
{
public:
- pass_reorder_blocks(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_reorder_blocks, ctxt)
+ pass_reorder_blocks (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_reorder_blocks, ctxt)
{}
/* opt_pass methods: */
class pass_duplicate_computed_gotos : public rtl_opt_pass
{
public:
- pass_duplicate_computed_gotos(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_duplicate_computed_gotos, ctxt)
+ pass_duplicate_computed_gotos (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_duplicate_computed_gotos, ctxt)
{}
/* opt_pass methods: */
class pass_partition_blocks : public rtl_opt_pass
{
public:
- pass_partition_blocks(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_partition_blocks, ctxt)
+ pass_partition_blocks (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_partition_blocks, ctxt)
{}
/* opt_pass methods: */
bit_no += ix * BITMAP_WORD_BITS;
#if GCC_VERSION >= 3004
- gcc_assert (sizeof(long) == sizeof (word));
+ gcc_assert (sizeof (long) == sizeof (word));
bit_no += __builtin_ctzl (word);
#else
/* Binary search for the first set bit. */
found_bit:
bit_no += ix * BITMAP_WORD_BITS;
#if GCC_VERSION >= 3004
- gcc_assert (sizeof(long) == sizeof (word));
+ gcc_assert (sizeof (long) == sizeof (word));
bit_no += BITMAP_WORD_BITS - __builtin_clzl (word) - 1;
#else
/* Hopefully this is a twos-complement host... */
extern unsigned bitmap_last_set_bit (const_bitmap);
/* Compute bitmap hash (for purposes of hashing etc.) */
-extern hashval_t bitmap_hash(const_bitmap);
+extern hashval_t bitmap_hash (const_bitmap);
/* Allocate a bitmap from a bit obstack. */
#define BITMAP_ALLOC(OBSTACK) bitmap_obstack_alloc (OBSTACK)
}
if (dump_file)
- dump_btrs_live(i);
+ dump_btrs_live (i);
}
}
for this one. */
bitmap_and_compl (reaching_defs, reaching_defs,
btr_defset[def->btr - first_btr]);
- bitmap_set_bit(reaching_defs, insn_uid);
+ bitmap_set_bit (reaching_defs, insn_uid);
}
if (user != NULL)
{
/* Find all the reaching defs for this use. */
- sbitmap reaching_defs_of_reg = sbitmap_alloc(max_uid);
+ sbitmap reaching_defs_of_reg = sbitmap_alloc (max_uid);
unsigned int uid = 0;
sbitmap_iterator sbi;
if (btr != -1)
{
move_btr_def (attempt, btr, def, live_range, &btrs_live_in_range);
- bitmap_copy(live_range, def->live_range);
+ bitmap_copy (live_range, def->live_range);
btr_used_near_def = 0;
def_moved = 1;
def_basic_block_freq = basic_block_freq (def->bb);
for (i = NUM_FIXED_BLOCKS; i < last_basic_block; i++)
{
basic_block bb = BASIC_BLOCK (i);
- fprintf(dump_file,
- "Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC
- " loop-depth = %d idom = %d\n",
- i, (HOST_WIDEST_INT) bb->count, bb_loop_depth (bb),
- get_immediate_dominator (CDI_DOMINATORS, bb)->index);
+ fprintf (dump_file,
+ "Basic block %d: count = " HOST_WIDEST_INT_PRINT_DEC
+ " loop-depth = %d idom = %d\n",
+ i, (HOST_WIDEST_INT) bb->count, bb_loop_depth (bb),
+ get_immediate_dominator (CDI_DOMINATORS, bb)->index);
}
}
class pass_branch_target_load_optimize1 : public rtl_opt_pass
{
public:
- pass_branch_target_load_optimize1(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_branch_target_load_optimize1, ctxt)
+ pass_branch_target_load_optimize1 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_branch_target_load_optimize1, ctxt)
{}
/* opt_pass methods: */
class pass_branch_target_load_optimize2 : public rtl_opt_pass
{
public:
- pass_branch_target_load_optimize2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_branch_target_load_optimize2, ctxt)
+ pass_branch_target_load_optimize2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_branch_target_load_optimize2, ctxt)
{}
/* opt_pass methods: */
else
#endif
emit_stack_restore (SAVE_BLOCK, old_stack_level);
- fixup_args_size_notes (call_insn, get_last_insn(), 0);
+ fixup_args_size_notes (call_insn, get_last_insn (), 0);
OK_DEFER_POP;
if (INDIRECT_REF_P (type))
type = TREE_TYPE (type);
- else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE(type)))
+ else if (POINTER_TYPE_P (type) && POINTER_TYPE_P (TREE_TYPE (type)))
type = TREE_TYPE (type);
wtype = va_list_type_node;
htype = type;
return MEMMODEL_SEQ_CST;
}
- if ((INTVAL(op) & MEMMODEL_MASK) >= MEMMODEL_LAST)
+ if ((INTVAL (op) & MEMMODEL_MASK) >= MEMMODEL_LAST)
{
warning (OPT_Winvalid_memory_model,
"invalid memory model argument to builtin");
STRIP_NOPS (addr);
gcc_assert (TREE_OPERAND (addr, 0) == fndecl);
- TREE_OPERAND (addr, 0) = builtin_decl_explicit(ext_call);
+ TREE_OPERAND (addr, 0) = builtin_decl_explicit (ext_call);
/* Expand the call here so we can emit trailing code. */
ret = expand_call (exp, target, ignore);
fold_builtin_fma (location_t loc, tree arg0, tree arg1, tree arg2, tree type)
{
if (validate_arg (arg0, REAL_TYPE)
- && validate_arg(arg1, REAL_TYPE)
- && validate_arg(arg2, REAL_TYPE))
+ && validate_arg (arg1, REAL_TYPE)
+ && validate_arg (arg2, REAL_TYPE))
{
tree tem = fold_fma (loc, type, arg0, arg1, arg2);
if (tem)
break;
CASE_FLT_FN (BUILT_IN_CCOS):
- return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ false);
+ return fold_builtin_ccos (loc, arg0, type, fndecl, /*hyper=*/ false);
CASE_FLT_FN (BUILT_IN_CCOSH):
- return fold_builtin_ccos(loc, arg0, type, fndecl, /*hyper=*/ true);
+ return fold_builtin_ccos (loc, arg0, type, fndecl, /*hyper=*/ true);
CASE_FLT_FN (BUILT_IN_CPROJ):
- return fold_builtin_cproj(loc, arg0, type);
+ return fold_builtin_cproj (loc, arg0, type);
CASE_FLT_FN (BUILT_IN_CSIN):
if (validate_arg (arg0, COMPLEX_TYPE)
CASE_FLT_FN (BUILT_IN_DREM):
CASE_FLT_FN (BUILT_IN_REMAINDER):
if (validate_arg (arg0, REAL_TYPE)
- && validate_arg(arg1, REAL_TYPE))
+ && validate_arg (arg1, REAL_TYPE))
return do_mpfr_arg2 (arg0, arg1, type, mpfr_remainder);
break;
CASE_FLT_FN_REENT (BUILT_IN_GAMMA): /* GAMMA_R */
CASE_FLT_FN_REENT (BUILT_IN_LGAMMA): /* LGAMMA_R */
if (validate_arg (arg0, REAL_TYPE)
- && validate_arg(arg1, POINTER_TYPE))
+ && validate_arg (arg1, POINTER_TYPE))
return do_mpfr_lgamma_r (arg0, arg1, type);
break;
CASE_FLT_FN (BUILT_IN_ATAN2):
if (validate_arg (arg0, REAL_TYPE)
- && validate_arg(arg1, REAL_TYPE))
+ && validate_arg (arg1, REAL_TYPE))
return do_mpfr_arg2 (arg0, arg1, type, mpfr_atan2);
break;
CASE_FLT_FN (BUILT_IN_FDIM):
if (validate_arg (arg0, REAL_TYPE)
- && validate_arg(arg1, REAL_TYPE))
+ && validate_arg (arg1, REAL_TYPE))
return do_mpfr_arg2 (arg0, arg1, type, mpfr_dim);
break;
CASE_FLT_FN (BUILT_IN_REMQUO):
if (validate_arg (arg0, REAL_TYPE)
- && validate_arg(arg1, REAL_TYPE)
- && validate_arg(arg2, POINTER_TYPE))
+ && validate_arg (arg1, REAL_TYPE)
+ && validate_arg (arg2, POINTER_TYPE))
return do_mpfr_remquo (arg0, arg1, arg2);
break;
&& host_integerp (arg1, 0)
&& TREE_CODE (arg2) == REAL_CST && !TREE_OVERFLOW (arg2))
{
- const HOST_WIDE_INT n = tree_low_cst(arg1, 0);
+ const HOST_WIDE_INT n = tree_low_cst (arg1, 0);
const REAL_VALUE_TYPE *const ra = &TREE_REAL_CST (arg2);
if (n == (long)n
negative integer. */
if (real_isfinite (ra)
&& ra->cl != rvc_zero
- && !(real_isneg(ra) && real_isinteger(ra, TYPE_MODE (type))))
+ && !(real_isneg (ra) && real_isinteger (ra, TYPE_MODE (type))))
{
const struct real_format *fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
const int prec = fmt->p;
mpc_t m;
mpc_init2 (m, prec);
- mpfr_from_real (mpc_realref(m), re, rnd);
- mpfr_from_real (mpc_imagref(m), im, rnd);
+ mpfr_from_real (mpc_realref (m), re, rnd);
+ mpfr_from_real (mpc_imagref (m), im, rnd);
mpfr_clear_flags ();
inexact = func (m, m, crnd);
result = do_mpc_ckconv (m, type, inexact, /*force_convert=*/ 0);
mpc_init2 (m0, prec);
mpc_init2 (m1, prec);
- mpfr_from_real (mpc_realref(m0), re0, rnd);
- mpfr_from_real (mpc_imagref(m0), im0, rnd);
- mpfr_from_real (mpc_realref(m1), re1, rnd);
- mpfr_from_real (mpc_imagref(m1), im1, rnd);
+ mpfr_from_real (mpc_realref (m0), re0, rnd);
+ mpfr_from_real (mpc_imagref (m0), im0, rnd);
+ mpfr_from_real (mpc_realref (m1), re1, rnd);
+ mpfr_from_real (mpc_imagref (m1), im1, rnd);
mpfr_clear_flags ();
inexact = func (m0, m0, m1, crnd);
result = do_mpc_ckconv (m0, type, inexact, do_nonfinite);
if (val != NULL_RTX)
{
if (idx >= internal_arg_pointer_exp_state.cache.length ())
- internal_arg_pointer_exp_state.cache.safe_grow_cleared(idx + 1);
+ internal_arg_pointer_exp_state.cache
+ .safe_grow_cleared (idx + 1);
internal_arg_pointer_exp_state.cache[idx] = val;
}
}
class pass_jump : public rtl_opt_pass
{
public:
- pass_jump(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_jump, ctxt)
+ pass_jump (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_jump, ctxt)
{}
/* opt_pass methods: */
class pass_jump2 : public rtl_opt_pass
{
public:
- pass_jump2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_jump2, ctxt)
+ pass_jump2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_jump2, ctxt)
{}
/* opt_pass methods: */
|| pt->vars == NULL
/* The pointed-to vars bitmap is shared, it is enough to
visit it once. */
- || pointer_set_insert(visited, pt->vars))
+ || pointer_set_insert (visited, pt->vars))
return;
bitmap_clear (temp);
{
/* stack_alignment_estimated shouldn't change after stack
realign decision made */
- gcc_assert(!crtl->stack_realign_processed);
+ gcc_assert (!crtl->stack_realign_processed);
crtl->stack_alignment_estimated = align;
}
case SPCT_FLAG_DEFAULT:
if (cfun->calls_alloca || has_protected_decls)
- create_stack_guard();
+ create_stack_guard ();
break;
default:
var_end_seq
= asan_emit_stack_protection (virtual_stack_vars_rtx,
data.asan_vec.address (),
- data.asan_decl_vec. address(),
+ data.asan_decl_vec. address (),
data.asan_vec.length ());
}
class pass_expand : public rtl_opt_pass
{
public:
- pass_expand(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_expand, ctxt)
+ pass_expand (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_expand, ctxt)
{}
/* opt_pass methods: */
|| bb == EXIT_BLOCK_PTR_FOR_FUNCTION (cfun))
continue;
gcc_assert (cfg_hooks->account_profile_record);
- cfg_hooks->account_profile_record(bb, after_pass, record);
+ cfg_hooks->account_profile_record (bb, after_pass, record);
}
}
/* Gather all loop headers in reverse completion order and allocate
loop structures for loops that are not already present. */
- larray.create (loops->larray->length());
+ larray.create (loops->larray->length ());
for (b = 0; b < n_basic_blocks - NUM_FIXED_BLOCKS; b++)
{
basic_block header = BASIC_BLOCK (rc_order[b]);
}
}
- larray.release();
+ larray.release ();
return loops;
}
remove_bb_from_loops (body[i]);
add_bb_to_loop (body[i], loop_outer (loop));
}
- free(body);
+ free (body);
while (loop->inner)
{
class pass_free_cfg : public rtl_opt_pass
{
public:
- pass_free_cfg(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_free_cfg, ctxt)
+ pass_free_cfg (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_free_cfg, ctxt)
{}
/* opt_pass methods: */
emit_barrier_after_bb (basic_block bb)
{
rtx barrier = emit_barrier_after (BB_END (bb));
- gcc_assert (current_ir_type() == IR_RTL_CFGRTL
+ gcc_assert (current_ir_type () == IR_RTL_CFGRTL
|| current_ir_type () == IR_RTL_CFGLAYOUT);
if (current_ir_type () == IR_RTL_CFGLAYOUT)
BB_FOOTER (bb) = unlink_insn_chain (barrier, barrier);
again (in compgoto). Ensure we don't call this before going back
into linearized RTL when any layout fixes would have been committed. */
if (!crtl->bb_reorder_complete
- || current_ir_type() != IR_RTL_CFGRTL)
+ || current_ir_type () != IR_RTL_CFGRTL)
return err;
FOR_EACH_BB (bb)
class pass_into_cfg_layout_mode : public rtl_opt_pass
{
public:
- pass_into_cfg_layout_mode(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_into_cfg_layout_mode, ctxt)
+ pass_into_cfg_layout_mode (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_into_cfg_layout_mode, ctxt)
{}
/* opt_pass methods: */
class pass_outof_cfg_layout_mode : public rtl_opt_pass
{
public:
- pass_outof_cfg_layout_mode(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_outof_cfg_layout_mode, ctxt)
+ pass_outof_cfg_layout_mode (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_outof_cfg_layout_mode, ctxt)
{}
/* opt_pass methods: */
end_sequence ();
/* Add the new cond , in the new head. */
- emit_insn_after(seq, BB_END(cond_bb));
+ emit_insn_after (seq, BB_END (cond_bb));
}
}
if (cfun->value_histograms)
free_histograms ();
- pop_cfun();
+ pop_cfun ();
gimple_set_body (decl, NULL);
/* Struct function hangs a lot of data that would leak if we didn't
removed all pointers to it. */
/* Clear out the node to NULL all pointers and add the node to the free
list. */
- memset (node, 0, sizeof(*node));
+ memset (node, 0, sizeof (*node));
node->symbol.type = SYMTAB_FUNCTION;
node->uid = uid;
SET_NEXT_FREE_NODE (node, free_nodes);
fprintf (f, "(%.2f per call) ",
edge->frequency / (double)CGRAPH_FREQ_BASE);
if (edge->speculative)
- fprintf(f, "(speculative) ");
+ fprintf (f, "(speculative) ");
if (!edge->inline_failed)
- fprintf(f, "(inlined) ");
+ fprintf (f, "(inlined) ");
if (edge->indirect_inlining_edge)
- fprintf(f, "(indirect_inlining) ");
+ fprintf (f, "(indirect_inlining) ");
if (edge->can_throw_external)
- fprintf(f, "(can throw external) ");
+ fprintf (f, "(can throw external) ");
}
fprintf (f, "\n Calls: ");
fprintf (f, "%s/%i ", cgraph_node_asm_name (edge->callee),
edge->callee->symbol.order);
if (edge->speculative)
- fprintf(f, "(speculative) ");
+ fprintf (f, "(speculative) ");
if (!edge->inline_failed)
- fprintf(f, "(inlined) ");
+ fprintf (f, "(inlined) ");
if (edge->indirect_inlining_edge)
- fprintf(f, "(indirect_inlining) ");
+ fprintf (f, "(indirect_inlining) ");
if (edge->count)
fprintf (f, "("HOST_WIDEST_INT_PRINT_DEC"x) ",
(HOST_WIDEST_INT)edge->count);
fprintf (f, "(%.2f per call) ",
edge->frequency / (double)CGRAPH_FREQ_BASE);
if (edge->can_throw_external)
- fprintf(f, "(can throw external) ");
+ fprintf (f, "(can throw external) ");
}
fprintf (f, "\n");
/* Return asm name of varpool node. */
static inline const char *
-varpool_node_asm_name(struct varpool_node *node)
+varpool_node_asm_name (struct varpool_node *node)
{
return symtab_node_asm_name ((symtab_node)node);
}
/* Return name of cgraph node. */
static inline const char *
-cgraph_node_name(struct cgraph_node *node)
+cgraph_node_name (struct cgraph_node *node)
{
return symtab_node_name ((symtab_node)node);
}
/* Return name of varpool node. */
static inline const char *
-varpool_node_name(struct varpool_node *node)
+varpool_node_name (struct varpool_node *node)
{
return symtab_node_name ((symtab_node)node);
}
class pass_build_cgraph_edges : public gimple_opt_pass
{
public:
- pass_build_cgraph_edges(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_build_cgraph_edges, ctxt)
+ pass_build_cgraph_edges (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_build_cgraph_edges, ctxt)
{}
/* opt_pass methods: */
class pass_rebuild_cgraph_edges : public gimple_opt_pass
{
public:
- pass_rebuild_cgraph_edges(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_rebuild_cgraph_edges, ctxt)
+ pass_rebuild_cgraph_edges (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_rebuild_cgraph_edges, ctxt)
{}
/* opt_pass methods: */
class pass_remove_cgraph_callee_edges : public gimple_opt_pass
{
public:
- pass_remove_cgraph_callee_edges(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_remove_cgraph_callee_edges, ctxt)
+ pass_remove_cgraph_callee_edges (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_remove_cgraph_callee_edges, ctxt)
{}
/* opt_pass methods: */
SET_DECL_RTL (new_decl, NULL);
/* When the old decl was a con-/destructor make sure the clone isn't. */
- DECL_STATIC_CONSTRUCTOR(new_decl) = 0;
- DECL_STATIC_DESTRUCTOR(new_decl) = 0;
+ DECL_STATIC_CONSTRUCTOR (new_decl) = 0;
+ DECL_STATIC_DESTRUCTOR (new_decl) = 0;
/* Create the new version's call-graph node.
and update the edges of the new node. */
dump_possible_polymorphic_call_targets
(cgraph_dump_file, edge);
- for (i = 0; i < targets.length(); i++)
+ for (i = 0; i < targets.length (); i++)
{
/* Do not bother to mark virtual methods in anonymous namespace;
either we will find use of virtual table defining it, or it is
make the edge direct. */
if (final)
{
- if (targets.length() <= 1)
+ if (targets.length () <= 1)
{
cgraph_node *target;
if (targets.length () == 1)
{
if (ch == p->name[0]
&& (!p->two_underscores || ((s - orig_s) >= 2))
- && strncmp(s, p->name, p->len) == 0)
+ && strncmp (s, p->name, p->len) == 0)
{
return p->ret;
}
plus number of partitions. */
for (lto_ld_argv_size = 0; lto_ld_argv[lto_ld_argv_size]; lto_ld_argv_size++)
;
- out_lto_ld_argv = XCNEWVEC(char *, num_files + lto_ld_argv_size + 1);
+ out_lto_ld_argv = XCNEWVEC (char *, num_files + lto_ld_argv_size + 1);
out_lto_ld_argv_size = 0;
/* After running the LTO back end, we will relink, substituting
"%d destructors found\n",
destructors.number),
destructors.number);
- notice_translated (ngettext("%d frame table found\n",
- "%d frame tables found\n",
- frame_tables.number),
+ notice_translated (ngettext ("%d frame table found\n",
+ "%d frame tables found\n",
+ frame_tables.number),
frame_tables.number);
}
sort_ids (&constructors);
sort_ids (&destructors);
- maybe_unlink(output_file);
+ maybe_unlink (output_file);
outf = fopen (c_file, "w");
if (outf == (FILE *) 0)
fatal_error ("fopen %s: %m", c_file);
{
int sig = WTERMSIG (status);
error ("%s terminated with signal %d [%s]%s",
- prog, sig, strsignal(sig),
- WCOREDUMP(status) ? ", core dumped" : "");
+ prog, sig, strsignal (sig),
+ WCOREDUMP (status) ? ", core dumped" : "");
exit (FATAL_EXIT_CODE);
}
if (shared_obj)
{
- COLLECT_SHARED_INIT_FUNC(stream, initname);
- COLLECT_SHARED_FINI_FUNC(stream, fininame);
+ COLLECT_SHARED_INIT_FUNC (stream, initname);
+ COLLECT_SHARED_FINI_FUNC (stream, fininame);
}
}
#if defined (EXTENDED_COFF)
-# define GCC_SYMBOLS(X) (SYMHEADER(X).isymMax + SYMHEADER(X).iextMax)
+# define GCC_SYMBOLS(X) (SYMHEADER (X).isymMax + SYMHEADER (X).iextMax)
# define GCC_SYMENT SYMR
# define GCC_OK_SYMBOL(X) ((X).st == stProc || (X).st == stGlobal)
# define GCC_SYMINC(X) (1)
-# define GCC_SYMZERO(X) (SYMHEADER(X).isymMax)
-# define GCC_CHECK_HDR(X) (PSYMTAB(X) != 0)
+# define GCC_SYMZERO(X) (SYMHEADER (X).isymMax)
+# define GCC_CHECK_HDR(X) (PSYMTAB (X) != 0)
#else
-# define GCC_SYMBOLS(X) (HEADER(ldptr).f_nsyms)
+# define GCC_SYMBOLS(X) (HEADER (ldptr).f_nsyms)
# define GCC_SYMENT SYMENT
# if defined (C_WEAKEXT)
# define GCC_OK_SYMBOL(X) \
while (ldclose (ldptr) == FAILURE);
#else
/* Otherwise we simply close ldptr. */
- (void) ldclose(ldptr);
+ (void) ldclose (ldptr);
#endif
}
#endif /* OBJECT_FORMAT_COFF */
if (libpaths[i]->max_len > l)
l = libpaths[i]->max_len;
- lib_buf = XNEWVEC (char, l + strlen(name) + 10);
+ lib_buf = XNEWVEC (char, l + strlen (name) + 10);
for (i = 0; libpaths[i]; i++)
{
may contain directories both with trailing DIR_SEPARATOR and
without it. */
const char *p = "";
- if (!IS_DIR_SEPARATOR (list->prefix[strlen(list->prefix)-1]))
+ if (!IS_DIR_SEPARATOR (list->prefix[strlen (list->prefix)-1]))
p = "/";
for (j = 0; j < 2; j++)
{
class pass_stack_adjustments : public rtl_opt_pass
{
public:
- pass_stack_adjustments(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_stack_adjustments, ctxt)
+ pass_stack_adjustments (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_stack_adjustments, ctxt)
{}
/* opt_pass methods: */
buf->next = undobuf.undos, undobuf.undos = buf;
}
-#define SUBST(INTO, NEWVAL) do_SUBST(&(INTO), (NEWVAL))
+#define SUBST(INTO, NEWVAL) do_SUBST (&(INTO), (NEWVAL))
/* Similar to SUBST, but NEWVAL is an int expression. Note that substitution
for the value of a HOST_WIDE_INT value (including CONST_INT) is
buf->next = undobuf.undos, undobuf.undos = buf;
}
-#define SUBST_INT(INTO, NEWVAL) do_SUBST_INT(&(INTO), (NEWVAL))
+#define SUBST_INT(INTO, NEWVAL) do_SUBST_INT (&(INTO), (NEWVAL))
/* Similar to SUBST, but just substitute the mode. This is used when
changing the mode of a pseudo-register, so that any other
buf->next = undobuf.undos, undobuf.undos = buf;
}
-#define SUBST_MODE(INTO, NEWVAL) do_SUBST_MODE(&(INTO), (NEWVAL))
+#define SUBST_MODE(INTO, NEWVAL) do_SUBST_MODE (&(INTO), (NEWVAL))
#ifndef HAVE_cc0
/* Similar to SUBST, but NEWVAL is a LOG_LINKS expression. */
INSN_COST (insn) = insn_rtx_cost (PATTERN (insn),
optimize_this_for_speed_p);
if (dump_file)
- fprintf(dump_file, "insn_cost %d: %d\n",
- INSN_UID (insn), INSN_COST (insn));
+ fprintf (dump_file, "insn_cost %d: %d\n",
+ INSN_UID (insn), INSN_COST (insn));
}
}
{
unsigned int regno;
- if (!REG_P(x))
+ if (!REG_P (x))
return false;
regno = REGNO (x);
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)
{
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)
{
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)
{
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)
{
this shift are known to be zero for both inputs and if the type of
comparison is compatible with the shift. */
if (GET_CODE (op0) == GET_CODE (op1)
- && HWI_COMPUTABLE_MODE_P (GET_MODE(op0))
+ && HWI_COMPUTABLE_MODE_P (GET_MODE (op0))
&& ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ))
|| ((GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFT)
&& (code != GT && code != LT && code != GE && code != LE))
class pass_combine : public rtl_opt_pass
{
public:
- pass_combine(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_combine, ctxt)
+ pass_combine (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_combine, ctxt)
{}
/* opt_pass methods: */
{
public:
find_comparison_dom_walker (cdi_direction direction)
- : dom_walker(direction) {}
+ : dom_walker (direction) {}
virtual void before_dom_children (basic_block);
};
class pass_compare_elim_after_reload : public rtl_opt_pass
{
public:
- pass_compare_elim_after_reload(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_compare_elim_after_reload, ctxt)
+ pass_compare_elim_after_reload (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_compare_elim_after_reload, ctxt)
{}
/* opt_pass methods: */
/* The singleton holder of global state: */
gcc::context *g;
-gcc::context::context()
+gcc::context::context ()
{
passes_ = new gcc::pass_manager (this);
}
class context
{
public:
- context();
+ context ();
/* Pass-management. */
/* Record bitmap_index of the implicit set in implicit_set_indexes. */
if (implicit)
- implicit_set_indexes[BLOCK_FOR_INSN(insn)->index] = cur_expr->bitmap_index;
+ implicit_set_indexes[BLOCK_FOR_INSN (insn)->index]
+ = cur_expr->bitmap_index;
}
/* Determine whether the rtx X should be treated as a constant for CPROP.
implicit_sets[dest->index] = new_rtx;
if (dump_file)
{
- fprintf(dump_file, "Implicit set of reg %d in ",
- REGNO (XEXP (cond, 0)));
- fprintf(dump_file, "basic block %d\n", dest->index);
+ fprintf (dump_file, "Implicit set of reg %d in ",
+ REGNO (XEXP (cond, 0)));
+ fprintf (dump_file, "basic block %d\n", dest->index);
}
count++;
}
class pass_rtl_cprop : public rtl_opt_pass
{
public:
- pass_rtl_cprop(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_cprop, ctxt)
+ pass_rtl_cprop (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_cprop, ctxt)
{}
/* opt_pass methods: */
a cost of 2. Aside from these special cases, call `rtx_cost'. */
#define CHEAP_REGNO(N) \
- (REGNO_PTR_FRAME_P(N) \
+ (REGNO_PTR_FRAME_P (N) \
|| (HARD_REGISTER_NUM_P (N) \
&& FIXED_REGNO_P (N) && REGNO_REG_CLASS (N) != NO_REGS))
/* Set what we are trying to extend and the operation it might
have been extended with. */
- memset (memory_extend_rtx, 0, sizeof(*memory_extend_rtx));
+ memset (memory_extend_rtx, 0, sizeof (*memory_extend_rtx));
PUT_CODE (memory_extend_rtx, LOAD_EXTEND_OP (mode));
XEXP (memory_extend_rtx, 0) = src;
class pass_cse : public rtl_opt_pass
{
public:
- pass_cse(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_cse, ctxt)
+ pass_cse (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_cse, ctxt)
{}
/* opt_pass methods: */
class pass_cse2 : public rtl_opt_pass
{
public:
- pass_cse2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_cse2, ctxt)
+ pass_cse2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_cse2, ctxt)
{}
/* opt_pass methods: */
class pass_cse_after_global_opts : public rtl_opt_pass
{
public:
- pass_cse_after_global_opts(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_cse_after_global_opts, ctxt)
+ pass_cse_after_global_opts (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_cse_after_global_opts, ctxt)
{}
/* opt_pass methods: */
int n_sets);
#define PRESERVED_VALUE_P(RTX) \
- (RTL_FLAG_CHECK1("PRESERVED_VALUE_P", (RTX), VALUE)->unchanging)
+ (RTL_FLAG_CHECK1 ("PRESERVED_VALUE_P", (RTX), VALUE)->unchanging)
#define SP_BASED_VALUE_P(RTX) \
- (RTL_FLAG_CHECK1("SP_BASED_VALUE_P", (RTX), VALUE)->jump)
+ (RTL_FLAG_CHECK1 ("SP_BASED_VALUE_P", (RTX), VALUE)->jump)
\f
#define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
/* Add STR, a normal C string, to the string being built. */
-#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
+#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
/* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
#define stabstr_I(id) obstack_grow (&stabstr_ob, \
tree context = decl_type_context (decl);
if (context != NULL_TREE
- && TREE_CODE(context) == RECORD_TYPE
+ && TREE_CODE (context) == RECORD_TYPE
&& TYPE_NAME (context) != 0
&& (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
|| (DECL_NAME (TYPE_NAME (context)) != 0)))
for thread-local symbols. Can be handled via same mechanism as used
in dwarf2out.c. */
if (TREE_CODE (decl) != VAR_DECL
- || !TREE_STATIC(decl)
- || !DECL_HAS_VALUE_EXPR_P(decl)
+ || !TREE_STATIC (decl)
+ || !DECL_HAS_VALUE_EXPR_P (decl)
|| DECL_THREAD_LOCAL_P (decl)
|| !is_fortran ())
return NULL;
if (CONST_INT_P (XEXP (sym_addr, 0)))
{
name =
- targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 1), 0));
+ targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 1), 0));
*value = INTVAL (XEXP (sym_addr, 0));
cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
}
else
{
name =
- targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 0), 0));
+ targetm.strip_name_encoding (XSTR (XEXP (sym_addr, 0), 0));
*value = INTVAL (XEXP (sym_addr, 1));
cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
}
break;
case SYMBOL_REF:
- name = targetm.strip_name_encoding(XSTR (sym_addr, 0));
+ name = targetm.strip_name_encoding (XSTR (sym_addr, 0));
*value = 0;
cdecl = SYMBOL_REF_DECL (sym_addr);
break;
/* Check area common symbol is offset into. If this is not public, then
it is not a symbol in a common block. It must be a .lcomm symbol, not
a .comm symbol. */
- if (cdecl == NULL || !TREE_PUBLIC(cdecl))
+ if (cdecl == NULL || !TREE_PUBLIC (cdecl))
name = NULL;
}
else
class pass_ud_rtl_dce : public rtl_opt_pass
{
public:
- pass_ud_rtl_dce(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_ud_rtl_dce, ctxt)
+ pass_ud_rtl_dce (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_ud_rtl_dce, ctxt)
{}
/* opt_pass methods: */
class pass_fast_rtl_dce : public rtl_opt_pass
{
public:
- pass_fast_rtl_dce(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_fast_rtl_dce, ctxt)
+ pass_fast_rtl_dce (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_fast_rtl_dce, ctxt)
{}
/* opt_pass methods: */
int c = p[i]; \
if (c == '\"' || c == '\\') \
putc ('\\', asm_out_file); \
- if (ISPRINT(c)) \
+ if (ISPRINT (c)) \
putc (c, asm_out_file); \
else \
{ \
The VAX assembler fails to stop reading the escape \
after three digits, so this is the only way we \
can get it to parse the data properly. */ \
- if (i < thissize - 1 && ISDIGIT(p[i + 1])) \
+ if (i < thissize - 1 && ISDIGIT (p[i + 1])) \
fprintf (asm_out_file, "\"\n\t.ascii \""); \
} \
} \
/* If we have named sections, and we're using crtstuff to run ctors,
use them for registering eh frame information. */
#if defined (TARGET_ASM_NAMED_SECTION) && DWARF2_UNWIND_INFO \
- && !defined(EH_FRAME_IN_DATA_SECTION)
+ && !defined (EH_FRAME_IN_DATA_SECTION)
#ifndef EH_FRAME_SECTION_NAME
#define EH_FRAME_SECTION_NAME ".eh_frame"
#endif
SET_RATIO or more simple move-instruction sequences, we will do a movmem
or libcall instead. */
#ifndef SET_RATIO
-#define SET_RATIO(speed) MOVE_RATIO(speed)
+#define SET_RATIO(speed) MOVE_RATIO (speed)
#endif
/* Supply a default definition for FUNCTION_ARG_PADDING:
{
basic_block bb;
bitmap_initialize (&blocks_to_reset, &df_bitmap_obstack);
- FOR_ALL_BB(bb)
+ FOR_ALL_BB (bb)
{
bitmap_set_bit (&blocks_to_reset, bb->index);
}
class pass_df_initialize_opt : public rtl_opt_pass
{
public:
- pass_df_initialize_opt(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_df_initialize_opt, ctxt)
+ pass_df_initialize_opt (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_df_initialize_opt, ctxt)
{}
/* opt_pass methods: */
class pass_df_initialize_no_opt : public rtl_opt_pass
{
public:
- pass_df_initialize_no_opt(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_df_initialize_no_opt, ctxt)
+ pass_df_initialize_no_opt (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_df_initialize_no_opt, ctxt)
{}
/* opt_pass methods: */
class pass_df_finish : public rtl_opt_pass
{
public:
- pass_df_finish(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_df_finish, ctxt)
+ pass_df_finish (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_df_finish, ctxt)
{}
/* opt_pass methods: */
{
df_dump_problem_function fun = dflow->problem->dump_start_fun;
if (fun)
- fun(file);
+ fun (file);
}
}
}
if (n_defs > DF_SPARSE_THRESHOLD)
{
bitmap_set_bit (&bb_info->sparse_kill, regno);
- bitmap_clear_range(&bb_info->gen, begin, n_defs);
+ bitmap_clear_range (&bb_info->gen, begin, n_defs);
}
else
{
{
struct df_rd_problem_data *problem_data
= (struct df_rd_problem_data *) df_rd->problem_data;
- unsigned int m = DF_REG_SIZE(df);
+ unsigned int m = DF_REG_SIZE (df);
unsigned int regno;
if (!df_rd->block_info)
{
bitmap_head tmp;
unsigned int regno;
- unsigned int m = DF_REG_SIZE(df);
+ unsigned int m = DF_REG_SIZE (df);
bool first_reg = true;
fprintf (file, "%s\t(%d) ", prefix, (int) bitmap_count_bits (defs_set));
/* The vectors that hold the refs are not pool allocated because
they come in many sizes. This makes them impossible to delete
all at once. */
- for (i = 0; i < DF_INSN_SIZE(); i++)
+ for (i = 0; i < DF_INSN_SIZE (); i++)
{
- struct df_insn_info *insn_info = DF_INSN_UID_GET(i);
+ struct df_insn_info *insn_info = DF_INSN_UID_GET (i);
/* Skip the insns that have no insn_info or have been
deleted. */
if (insn_info)
free (df->eq_use_regs);
df->eq_use_regs = NULL;
df->regs_size = 0;
- DF_REG_SIZE(df) = 0;
+ DF_REG_SIZE (df) = 0;
free (df->insns);
df->insns = NULL;
df_grow_bb_info (df_scan);
df_grow_reg_info ();
- insn_info = DF_INSN_UID_SAFE_GET (INSN_UID(insn));
+ insn_info = DF_INSN_UID_SAFE_GET (INSN_UID (insn));
/* The client has deferred rescanning. */
if (df->changeable_flags & DF_DEFER_INSN_RESCAN)
for (i = 0; i < DF_REG_SIZE (df); i++)
{
gcc_assert (df_reg_chain_mark (DF_REG_DEF_CHAIN (i), i, true, false)
- == DF_REG_DEF_COUNT(i));
+ == DF_REG_DEF_COUNT (i));
gcc_assert (df_reg_chain_mark (DF_REG_USE_CHAIN (i), i, false, false)
- == DF_REG_USE_COUNT(i));
+ == DF_REG_USE_COUNT (i));
gcc_assert (df_reg_chain_mark (DF_REG_EQ_USE_CHAIN (i), i, false, true)
- == DF_REG_EQ_USE_COUNT(i));
+ == DF_REG_EQ_USE_COUNT (i));
}
/* (2) There are various bitmaps whose value may change over the
bool redo_entry_and_exit;
};
-#define DF_SCAN_BB_INFO(BB) (df_scan_get_bb_info((BB)->index))
-#define DF_RD_BB_INFO(BB) (df_rd_get_bb_info((BB)->index))
-#define DF_LR_BB_INFO(BB) (df_lr_get_bb_info((BB)->index))
-#define DF_LIVE_BB_INFO(BB) (df_live_get_bb_info((BB)->index))
-#define DF_WORD_LR_BB_INFO(BB) (df_word_lr_get_bb_info((BB)->index))
-#define DF_MD_BB_INFO(BB) (df_md_get_bb_info((BB)->index))
+#define DF_SCAN_BB_INFO(BB) (df_scan_get_bb_info ((BB)->index))
+#define DF_RD_BB_INFO(BB) (df_rd_get_bb_info ((BB)->index))
+#define DF_LR_BB_INFO(BB) (df_lr_get_bb_info ((BB)->index))
+#define DF_LIVE_BB_INFO(BB) (df_live_get_bb_info ((BB)->index))
+#define DF_WORD_LR_BB_INFO(BB) (df_word_lr_get_bb_info ((BB)->index))
+#define DF_MD_BB_INFO(BB) (df_md_get_bb_info ((BB)->index))
/* Most transformations that wish to use live register analysis will
use these macros. This info is the and of the lr and live sets. */
-#define DF_LIVE_IN(BB) (&DF_LIVE_BB_INFO(BB)->in)
-#define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO(BB)->out)
+#define DF_LIVE_IN(BB) (&DF_LIVE_BB_INFO (BB)->in)
+#define DF_LIVE_OUT(BB) (&DF_LIVE_BB_INFO (BB)->out)
/* These macros are used by passes that are not tolerant of
uninitialized variables. This intolerance should eventually
be fixed. */
-#define DF_LR_IN(BB) (&DF_LR_BB_INFO(BB)->in)
-#define DF_LR_OUT(BB) (&DF_LR_BB_INFO(BB)->out)
+#define DF_LR_IN(BB) (&DF_LR_BB_INFO (BB)->in)
+#define DF_LR_OUT(BB) (&DF_LR_BB_INFO (BB)->out)
/* These macros are used by passes that are not tolerant of
uninitialized variables. This intolerance should eventually
be fixed. */
-#define DF_WORD_LR_IN(BB) (&DF_WORD_LR_BB_INFO(BB)->in)
-#define DF_WORD_LR_OUT(BB) (&DF_WORD_LR_BB_INFO(BB)->out)
+#define DF_WORD_LR_IN(BB) (&DF_WORD_LR_BB_INFO (BB)->in)
+#define DF_WORD_LR_OUT(BB) (&DF_WORD_LR_BB_INFO (BB)->out)
/* Macros to access the elements within the ref structure. */
#define DF_REF_REAL_LOC(REF) (GET_CODE (*((REF)->regular_ref.loc)) == SUBREG \
? &SUBREG_REG (*((REF)->regular_ref.loc)) : ((REF)->regular_ref.loc))
#define DF_REF_REG(REF) ((REF)->base.reg)
-#define DF_REF_LOC(REF) (DF_REF_CLASS(REF) == DF_REF_REGULAR ? \
+#define DF_REF_LOC(REF) (DF_REF_CLASS (REF) == DF_REF_REGULAR ? \
(REF)->regular_ref.loc : NULL)
-#define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL(REF) ? \
- (REF)->artificial_ref.bb : BLOCK_FOR_INSN (DF_REF_INSN(REF)))
+#define DF_REF_BB(REF) (DF_REF_IS_ARTIFICIAL (REF) \
+ ? (REF)->artificial_ref.bb \
+ : BLOCK_FOR_INSN (DF_REF_INSN (REF)))
#define DF_REF_BBNO(REF) (DF_REF_BB (REF)->index)
#define DF_REF_INSN_INFO(REF) ((REF)->base.insn_info)
#define DF_REF_INSN(REF) ((REF)->base.insn_info->insn)
/* If DF_REF_IS_ARTIFICIAL () is true, this is not a real
definition/use, but an artificial one created to model always live
registers, eh uses, etc. */
-#define DF_REF_IS_ARTIFICIAL(REF) (DF_REF_CLASS(REF) == DF_REF_ARTIFICIAL)
+#define DF_REF_IS_ARTIFICIAL(REF) (DF_REF_CLASS (REF) == DF_REF_ARTIFICIAL)
#define DF_REF_REG_MARK(REF) (DF_REF_FLAGS_SET ((REF),DF_REF_REG_MARKER))
#define DF_REF_REG_UNMARK(REF) (DF_REF_FLAGS_CLEAR ((REF),DF_REF_REG_MARKER))
#define DF_REF_IS_REG_MARKED(REF) (DF_REF_FLAGS_IS_SET ((REF),DF_REF_REG_MARKER))
/* Macros to access the elements within the reg_info structure table. */
#define DF_REGNO_FIRST_DEF(REGNUM) \
-(DF_REG_DEF_GET(REGNUM) ? DF_REG_DEF_GET(REGNUM) : 0)
+(DF_REG_DEF_GET(REGNUM) ? DF_REG_DEF_GET (REGNUM) : 0)
#define DF_REGNO_LAST_USE(REGNUM) \
-(DF_REG_USE_GET(REGNUM) ? DF_REG_USE_GET(REGNUM) : 0)
+(DF_REG_USE_GET(REGNUM) ? DF_REG_USE_GET (REGNUM) : 0)
/* Macros to access the elements within the insn_info structure table. */
#define DF_INSN_SIZE() ((df)->insns_size)
-#define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID(INSN))])
+#define DF_INSN_INFO_GET(INSN) (df->insns[(INSN_UID (INSN))])
#define DF_INSN_INFO_SET(INSN,VAL) (df->insns[(INSN_UID (INSN))]=(VAL))
#define DF_INSN_INFO_LUID(II) ((II)->luid)
#define DF_INSN_INFO_DEFS(II) ((II)->defs)
#define DF_INSN_INFO_USES(II) ((II)->uses)
#define DF_INSN_INFO_EQ_USES(II) ((II)->eq_uses)
-#define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET(INSN)))
-#define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET(INSN)))
-#define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET(INSN)))
-#define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET(INSN)))
+#define DF_INSN_LUID(INSN) (DF_INSN_INFO_LUID (DF_INSN_INFO_GET (INSN)))
+#define DF_INSN_DEFS(INSN) (DF_INSN_INFO_DEFS (DF_INSN_INFO_GET (INSN)))
+#define DF_INSN_USES(INSN) (DF_INSN_INFO_USES (DF_INSN_INFO_GET (INSN)))
+#define DF_INSN_EQ_USES(INSN) (DF_INSN_INFO_EQ_USES (DF_INSN_INFO_GET (INSN)))
#define DF_INSN_UID_GET(UID) (df->insns[(UID)])
#define DF_INSN_UID_SET(UID,VAL) (df->insns[(UID)]=(VAL))
-#define DF_INSN_UID_SAFE_GET(UID) (((unsigned)(UID) < DF_INSN_SIZE()) \
+#define DF_INSN_UID_SAFE_GET(UID) (((unsigned)(UID) < DF_INSN_SIZE ()) \
? DF_INSN_UID_GET (UID) \
: NULL)
-#define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET(INSN)->luid)
-#define DF_INSN_UID_DEFS(INSN) (DF_INSN_UID_GET(INSN)->defs)
-#define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET(INSN)->uses)
-#define DF_INSN_UID_EQ_USES(INSN) (DF_INSN_UID_GET(INSN)->eq_uses)
-#define DF_INSN_UID_MWS(INSN) (DF_INSN_UID_GET(INSN)->mw_hardregs)
+#define DF_INSN_UID_LUID(INSN) (DF_INSN_UID_GET (INSN)->luid)
+#define DF_INSN_UID_DEFS(INSN) (DF_INSN_UID_GET (INSN)->defs)
+#define DF_INSN_UID_USES(INSN) (DF_INSN_UID_GET (INSN)->uses)
+#define DF_INSN_UID_EQ_USES(INSN) (DF_INSN_UID_GET (INSN)->eq_uses)
+#define DF_INSN_UID_MWS(INSN) (DF_INSN_UID_GET (INSN)->mw_hardregs)
/* An obstack for bitmap not related to specific dataflow problems.
This obstack should e.g. be used for bitmaps with a short life time
int line_width = strlen (line);
int column = *column_p;
- right_margin = MIN(line_width - column, right_margin);
+ right_margin = MIN (line_width - column, right_margin);
right_margin = max_width - right_margin;
if (line_width >= max_width && column > right_margin)
{
/* Skip functions in diagnostic.c. */
if (*pcount == 0
&& filename != NULL
- && strcmp (lbasename(filename), "diagnostic.c") == 0)
+ && strcmp (lbasename (filename), "diagnostic.c") == 0)
return 0;
/* Print up to 20 functions. We could make this a --param, but
pp_destroy_prefix (context->printer);
pp_set_prefix (context->printer, saved_prefix);
diagnostic_show_locus (context, &diagnostic);
- va_end(ap);
+ va_end (ap);
}
bool
for representing the value. The code to calculate count is
extracted from the GMP manual, section "Integer Import and Export":
http://gmplib.org/manual/Integer-Import-and-Export.html */
- numb = 8*sizeof(HOST_WIDE_INT);
+ numb = 8 * sizeof (HOST_WIDE_INT);
count = (mpz_sizeinbase (val, 2) + numb-1) / numb;
if (count < 2)
count = 2;
- vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof(HOST_WIDE_INT));
+ vp = (unsigned HOST_WIDE_INT *) alloca (count * sizeof (HOST_WIDE_INT));
vp[0] = 0;
vp[1] = 0;
if (group == clear_alias_group)
continue;
- memset (group->offset_map_n, 0, sizeof(int) * group->offset_map_size_n);
- memset (group->offset_map_p, 0, sizeof(int) * group->offset_map_size_p);
+ memset (group->offset_map_n, 0, sizeof (int) * group->offset_map_size_n);
+ memset (group->offset_map_p, 0, sizeof (int) * group->offset_map_size_p);
bitmap_clear (group->group_kill);
EXECUTE_IF_SET_IN_BITMAP (group->store2_n, 0, j, bi)
class pass_rtl_dse1 : public rtl_opt_pass
{
public:
- pass_rtl_dse1(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_dse1, ctxt)
+ pass_rtl_dse1 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_dse1, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_dse2 : public rtl_opt_pass
{
public:
- pass_rtl_dse2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_dse2, ctxt)
+ pass_rtl_dse2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_dse2, ctxt)
{}
/* opt_pass methods: */
if (dfi->alt_stream)
return dfi->alt_stream;
- stream = strcmp("stderr", dfi->alt_filename) == 0
+ stream = strcmp ("stderr", dfi->alt_filename) == 0
? stderr
- : strcmp("stdout", dfi->alt_filename) == 0
- ? stdout
+ : strcmp ("stdout", dfi->alt_filename) == 0
+ ? stdout
: fopen (dfi->alt_filename, dfi->alt_state < 0 ? "w" : "a");
if (!stream)
name = get_dump_file_name (phase);
if (name)
{
- stream = strcmp("stderr", name) == 0
+ stream = strcmp ("stderr", name) == 0
? stderr
- : strcmp("stdout", name) == 0
- ? stdout
+ : strcmp ("stdout", name) == 0
+ ? stdout
: fopen (name, dfi->pstate < 0 ? "w" : "a");
if (!stream)
error ("could not open dump file %qs: %m", name);
return;
dfi = get_dump_file_info (phase);
if (dfi->pstream && (!dfi->pfilename
- || (strcmp("stderr", dfi->pfilename) != 0
- && strcmp("stdout", dfi->pfilename) != 0)))
+ || (strcmp ("stderr", dfi->pfilename) != 0
+ && strcmp ("stdout", dfi->pfilename) != 0)))
fclose (dfi->pstream);
- if (dfi->alt_stream && strcmp("stderr", dfi->alt_filename) != 0
- && strcmp("stdout", dfi->alt_filename) != 0)
+ if (dfi->alt_stream && strcmp ("stderr", dfi->alt_filename) != 0
+ && strcmp ("stdout", dfi->alt_filename) != 0)
fclose (dfi->alt_stream);
dfi->alt_stream = NULL;
return NULL;
dfi = get_dump_file_info (phase);
- stream = strcmp("stderr", name) == 0
+ stream = strcmp ("stderr", name) == 0
? stderr
- : strcmp("stdout", name) == 0
- ? stdout
+ : strcmp ("stdout", name) == 0
+ ? stdout
: fopen (name, dfi->pstate < 0 ? "w" : "a");
if (!stream)
int c = str[i];
if (c == '\"' || c == '\\')
fputc ('\\', asm_out_file);
- if (ISPRINT(c))
+ if (ISPRINT (c))
fputc (c, asm_out_file);
else
fprintf (asm_out_file, "\\%o", c);
dw_stack_pointer_regnum = DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM);
dw_frame_pointer_regnum = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM);
- memset (&cie_trace, 0, sizeof(cie_trace));
+ memset (&cie_trace, 0, sizeof (cie_trace));
cur_trace = &cie_trace;
add_cfi_vec = &cie_cfi_vec;
cie_cfi_row = cur_row = new_cfi_row ();
/* On entry, the Canonical Frame Address is at SP. */
- memset(&loc, 0, sizeof (loc));
+ memset (&loc, 0, sizeof (loc));
loc.reg = dw_stack_pointer_regnum;
loc.offset = INCOMING_FRAME_SP_OFFSET;
def_cfa_1 (&loc);
if (!cfi)
{
dw_cfa_location dummy;
- memset(&dummy, 0, sizeof(dummy));
+ memset (&dummy, 0, sizeof (dummy));
dummy.reg = INVALID_REGNUM;
cfi = def_cfa_0 (&dummy, &row->cfa);
}
class pass_dwarf2_frame : public rtl_opt_pass
{
public:
- pass_dwarf2_frame(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_dwarf2_frame, ctxt)
+ pass_dwarf2_frame (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_dwarf2_frame, ctxt)
{}
/* opt_pass methods: */
if (node->refcount == 0)
return 1;
- gcc_assert(node->index == NO_INDEX_ASSIGNED);
+ gcc_assert (node->index == NO_INDEX_ASSIGNED);
node->index = *index;
*index += 1;
context, if any. This is stored in the type unit DIE for link-time
ODR (one-definition rule) checking. */
- if (is_cxx() && name != NULL)
+ if (is_cxx () && name != NULL)
{
md5_init_ctx (&ctx);
case dw_val_class_flag:
return v1->v.val_flag == v2->v.val_flag;
case dw_val_class_str:
- return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
+ return !strcmp (v1->v.val_str->str, v2->v.val_str->str);
case dw_val_class_addr:
r1 = v1->v.val_addr;
if (die->die_tag == DW_TAG_subprogram && ! is_declaration_die (die))
return 1;
- FOR_EACH_CHILD (die, c, if (contains_subprogram_definition(c)) return 1);
+ FOR_EACH_CHILD (die, c, if (contains_subprogram_definition (c)) return 1);
return 0;
}
dw_die_ref c;
dw_die_ref clone = clone_die (die);
- FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree(c)));
+ FOR_EACH_CHILD (die, c, add_child_die (clone, clone_tree (c)));
return clone;
}
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
else if (strcmp (common_lang, TRANSLATION_UNIT_LANGUAGE (t)) == 0)
;
else if (strncmp (common_lang, "GNU C", 5) == 0
- && strncmp(TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
+ && strncmp (TRANSLATION_UNIT_LANGUAGE (t), "GNU C", 5) == 0)
/* Mixing C and C++ is ok, use C++ in that case. */
common_lang = "GNU C++";
else
find_string_form (node);
if (node->form == DW_FORM_GNU_str_index && node->refcount > 0)
{
- gcc_assert(node->index == NO_INDEX_ASSIGNED);
+ gcc_assert (node->index == NO_INDEX_ASSIGNED);
node->index = *index;
*index += 1;
}
NEXT_INSN (to) = NEXT_INSN (after);
PREV_INSN (from) = after;
NEXT_INSN (after) = from;
- if (after == get_last_insn())
+ if (after == get_last_insn ())
set_last_insn (to);
}
if (after_after)
PREV_INSN (after_after) = last;
- if (after == get_last_insn())
+ if (after == get_last_insn ())
set_last_insn (last);
return last;
rtx
emit_insn (rtx x)
{
- rtx last = get_last_insn();
+ rtx last = get_last_insn ();
rtx insn;
if (x == NULL_RTX)
rtx
emit_debug_insn (rtx x)
{
- rtx last = get_last_insn();
+ rtx last = get_last_insn ();
rtx insn;
if (x == NULL_RTX)
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
- FCONST0(mode).data.high = 0;
- FCONST0(mode).data.low = 0;
- FCONST0(mode).mode = mode;
+ FCONST0 (mode).data.high = 0;
+ FCONST0 (mode).data.low = 0;
+ FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode);
}
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
- FCONST0(mode).data.high = 0;
- FCONST0(mode).data.low = 0;
- FCONST0(mode).mode = mode;
+ FCONST0 (mode).data.high = 0;
+ FCONST0 (mode).data.low = 0;
+ FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode);
}
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
- FCONST0(mode).data.high = 0;
- FCONST0(mode).data.low = 0;
- FCONST0(mode).mode = mode;
+ FCONST0 (mode).data.high = 0;
+ FCONST0 (mode).data.low = 0;
+ FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode);
/* We store the value 1. */
- FCONST1(mode).data.high = 0;
- FCONST1(mode).data.low = 0;
- FCONST1(mode).mode = mode;
- FCONST1(mode).data
+ FCONST1 (mode).data.high = 0;
+ FCONST1 (mode).data.low = 0;
+ FCONST1 (mode).mode = mode;
+ FCONST1 (mode).data
= double_int_one.lshift (GET_MODE_FBIT (mode),
HOST_BITS_PER_DOUBLE_INT,
SIGNED_FIXED_POINT_MODE_P (mode));
mode != VOIDmode;
mode = GET_MODE_WIDER_MODE (mode))
{
- FCONST0(mode).data.high = 0;
- FCONST0(mode).data.low = 0;
- FCONST0(mode).mode = mode;
+ FCONST0 (mode).data.high = 0;
+ FCONST0 (mode).data.low = 0;
+ FCONST0 (mode).mode = mode;
const_tiny_rtx[0][(int) mode] = CONST_FIXED_FROM_FIXED_VALUE (
FCONST0 (mode), mode);
/* We store the value 1. */
- FCONST1(mode).data.high = 0;
- FCONST1(mode).data.low = 0;
- FCONST1(mode).mode = mode;
- FCONST1(mode).data
+ FCONST1 (mode).data.high = 0;
+ FCONST1 (mode).data.low = 0;
+ FCONST1 (mode).mode = mode;
+ FCONST1 (mode).data
= double_int_one.lshift (GET_MODE_FBIT (mode),
HOST_BITS_PER_DOUBLE_INT,
SIGNED_FIXED_POINT_MODE_P (mode));
fprintf (stderr, "%s: warning: ", progname);
vfprintf (stderr, format, ap);
va_end (ap);
- fputc('\n', stderr);
+ fputc ('\n', stderr);
}
fprintf (stderr, "%s: ", progname);
vfprintf (stderr, format, ap);
va_end (ap);
- fputc('\n', stderr);
+ fputc ('\n', stderr);
have_error = 1;
}
fprintf (stderr, "%s: ", progname);
vfprintf (stderr, format, ap);
va_end (ap);
- fputc('\n', stderr);
+ fputc ('\n', stderr);
exit (FATAL_EXIT_CODE);
}
gcc_assert (ifun->eh->region_array);
gcc_assert (ifun->eh->region_tree);
- b_outer = sbitmap_alloc (ifun->eh->region_array->length());
+ b_outer = sbitmap_alloc (ifun->eh->region_array->length ());
bitmap_clear (b_outer);
do
class pass_set_nothrow_function_flags : public rtl_opt_pass
{
public:
- pass_set_nothrow_function_flags(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_set_nothrow_function_flags, ctxt)
+ pass_set_nothrow_function_flags (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_set_nothrow_function_flags, ctxt)
{}
/* opt_pass methods: */
class pass_convert_to_eh_region_ranges : public rtl_opt_pass
{
public:
- pass_convert_to_eh_region_ranges(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_convert_to_eh_region_ranges, ctxt)
+ pass_convert_to_eh_region_ranges (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_convert_to_eh_region_ranges, ctxt)
{}
/* opt_pass methods: */
`unsigned int' */
if (HOST_BITS_PER_INT >= GET_MODE_UNIT_BITSIZE (mode))
{
- op_cost = neg_cost(speed, mode);
+ op_cost = neg_cost (speed, mode);
if (MULT_COST_LESS (&alg->cost, mult_cost))
{
limit.cost = alg->cost.cost - op_cost;
calculation of the synth_mult. */
coeff = -(unsigned HOST_WIDE_INT) coeff;
max_cost = (set_src_cost (gen_rtx_MULT (mode, fake_reg, op1), speed)
- - neg_cost(speed, mode));
+ - neg_cost (speed, mode));
if (max_cost <= 0)
goto skip_synth;
{
if (rem_flag)
return const0_rtx;
- return expand_unop (mode, flag_trapv && GET_MODE_CLASS(mode) == MODE_INT
+ return expand_unop (mode, flag_trapv && GET_MODE_CLASS (mode) == MODE_INT
? negv_optab : neg_optab, op0, target, 0);
}
}
else if (CONSTANT_P (src) && GET_MODE (dst) != BLKmode
&& XVECLEN (dst, 0) > 1)
- tmps[i] = simplify_gen_subreg (mode, src, GET_MODE(dst), bytepos);
+ tmps[i] = simplify_gen_subreg (mode, src, GET_MODE (dst), bytepos);
else if (CONSTANT_P (src))
{
HOST_WIDE_INT len = (HOST_WIDE_INT) bytelen;
&& optab_handler (mov_optab, GET_MODE_INNER (mode)) != CODE_FOR_nothing
&& !(REG_P (x)
&& HARD_REGISTER_P (x)
- && hard_regno_nregs[REGNO(x)][mode] == 1)
+ && hard_regno_nregs[REGNO (x)][mode] == 1)
&& !(REG_P (y)
&& HARD_REGISTER_P (y)
- && hard_regno_nregs[REGNO(y)][mode] == 1))
+ && hard_regno_nregs[REGNO (y)][mode] == 1))
try_int = false;
/* Not possible if the values are inherently not adjacent. */
else if (GET_CODE (x) == CONCAT || GET_CODE (y) == CONCAT)
if (TREE_ADDRESSABLE (exp)
&& ! MEM_P (result)
- && ! targetm.calls.allocate_stack_slots_for_args())
+ && ! targetm.calls.allocate_stack_slots_for_args ())
{
error ("local frame unavailable (naked function?)");
return result;
static bool debug = false;
void
-find_file_set_debug(bool debug_state)
+find_file_set_debug (bool debug_state)
{
debug = debug_state;
}
freq_threshold = freq_max / PARAM_VALUE (PARAM_ALIGN_THRESHOLD);
if (dump_file)
- fprintf(dump_file, "freq_max: %i\n",freq_max);
+ fprintf (dump_file, "freq_max: %i\n",freq_max);
FOR_EACH_BB (bb)
{
rtx label = BB_HEAD (bb);
|| optimize_bb_for_size_p (bb))
{
if (dump_file)
- fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n",
- bb->index, bb->frequency, bb->loop_father->num,
- bb_loop_depth (bb));
+ fprintf (dump_file,
+ "BB %4i freq %4i loop %2i loop_depth %2i skipped.\n",
+ bb->index, bb->frequency, bb->loop_father->num,
+ bb_loop_depth (bb));
continue;
}
max_log = LABEL_ALIGN (label);
}
if (dump_file)
{
- fprintf(dump_file, "BB %4i freq %4i loop %2i loop_depth %2i fall %4i branch %4i",
- bb->index, bb->frequency, bb->loop_father->num,
- bb_loop_depth (bb),
- fallthru_frequency, branch_frequency);
+ fprintf (dump_file, "BB %4i freq %4i loop %2i loop_depth"
+ " %2i fall %4i branch %4i",
+ bb->index, bb->frequency, bb->loop_father->num,
+ bb_loop_depth (bb),
+ fallthru_frequency, branch_frequency);
if (!bb->loop_father->inner && bb->loop_father->num)
fprintf (dump_file, " inner_loop");
if (bb->loop_father->header == bb)
{
log = JUMP_ALIGN (label);
if (dump_file)
- fprintf(dump_file, " jump alignment added.\n");
+ fprintf (dump_file, " jump alignment added.\n");
if (max_log < log)
{
max_log = log;
{
log = LOOP_ALIGN (label);
if (dump_file)
- fprintf(dump_file, " internal loop alignment added.\n");
+ fprintf (dump_file, " internal loop alignment added.\n");
if (max_log < log)
{
max_log = log;
class pass_compute_alignments : public rtl_opt_pass
{
public:
- pass_compute_alignments(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_compute_alignments, ctxt)
+ pass_compute_alignments (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_compute_alignments, ctxt)
{}
/* opt_pass methods: */
INSN_ADDRESSES (uid) = insn_current_address + insn_lengths[uid];
if (NOTE_P (insn) || BARRIER_P (insn)
- || LABEL_P (insn) || DEBUG_INSN_P(insn))
+ || LABEL_P (insn) || DEBUG_INSN_P (insn))
continue;
if (INSN_DELETED_P (insn))
continue;
class pass_final : public rtl_opt_pass
{
public:
- pass_final(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_final, ctxt)
+ pass_final (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_final, ctxt)
{}
/* opt_pass methods: */
class pass_shorten_branches : public rtl_opt_pass
{
public:
- pass_shorten_branches(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_shorten_branches, ctxt)
+ pass_shorten_branches (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_shorten_branches, ctxt)
{}
/* opt_pass methods: */
class pass_clean_state : public rtl_opt_pass
{
public:
- pass_clean_state(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_clean_state, ctxt)
+ pass_clean_state (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_clean_state, ctxt)
{}
/* opt_pass methods: */
else if (UNSIGNED_SCALAR_FIXED_POINT_MODE_P (mode))
value.data = payload.zext (GET_MODE_IBIT (mode) + GET_MODE_FBIT (mode));
else
- gcc_unreachable();
+ gcc_unreachable ();
value.mode = mode;
if (TREE_CODE (arg1) == INTEGER_CST)
{
double_int cst1 = tree_to_double_int (arg1);
- double_int ncst1 = (-cst1).ext(TYPE_PRECISION (TREE_TYPE (arg1)),
- TYPE_UNSIGNED (TREE_TYPE (arg1)));
+ double_int ncst1 = (-cst1).ext (TYPE_PRECISION (TREE_TYPE (arg1)),
+ TYPE_UNSIGNED (TREE_TYPE (arg1)));
if ((cst1 & ncst1) == ncst1
&& multiple_of_p (type, arg0,
double_int_to_tree (TREE_TYPE (arg1), ncst1)))
class pass_instantiate_virtual_regs : public rtl_opt_pass
{
public:
- pass_instantiate_virtual_regs(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_instantiate_virtual_regs, ctxt)
+ pass_instantiate_virtual_regs (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_instantiate_virtual_regs, ctxt)
{}
/* opt_pass methods: */
bool
use_register_for_decl (const_tree decl)
{
- if (!targetm.calls.allocate_stack_slots_for_args())
+ if (!targetm.calls.allocate_stack_slots_for_args ())
return true;
/* Honor volatile. */
class pass_leaf_regs : public rtl_opt_pass
{
public:
- pass_leaf_regs(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_leaf_regs, ctxt)
+ pass_leaf_regs (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_leaf_regs, ctxt)
{}
/* opt_pass methods: */
class pass_thread_prologue_and_epilogue : public rtl_opt_pass
{
public:
- pass_thread_prologue_and_epilogue(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_thread_prologue_and_epilogue, ctxt)
+ pass_thread_prologue_and_epilogue (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_thread_prologue_and_epilogue, ctxt)
{}
/* opt_pass methods: */
class pass_match_asm_constraints : public rtl_opt_pass
{
public:
- pass_match_asm_constraints(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_match_asm_constraints, ctxt)
+ pass_match_asm_constraints (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_match_asm_constraints, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_fwprop : public rtl_opt_pass
{
public:
- pass_rtl_fwprop(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_fwprop, ctxt)
+ pass_rtl_fwprop (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_fwprop, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_fwprop_addr : public rtl_opt_pass
{
public:
- pass_rtl_fwprop_addr(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_fwprop_addr, ctxt)
+ pass_rtl_fwprop_addr (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_fwprop_addr, ctxt)
{}
/* opt_pass methods: */
}
int
-main(int ac, char **av)
+main (int ac, char **av)
{
const char *exe_name;
char *plugin;
nargv[1] = "--plugin";
nargv[2] = plugin;
if (is_ar && av[1] && av[1][0] != '-')
- av[1] = concat("-", av[1], NULL);
+ av[1] = concat ("-", av[1], NULL);
for (k = 1; k < ac; k++)
nargv[2 + k] = av[k];
nargv[2 + k] = NULL;
err_msg = pex_one (PEX_LAST|PEX_SEARCH,
exe_name,
CONST_CAST2 (char * const *, const char **, nargv),
- concat("gcc-", exe_name, NULL),
+ concat ("gcc-", exe_name, NULL),
NULL,NULL, &status, &err);
if (err_msg)
- fprintf(stderr, "Error running %s: %s\n", exe_name, err_msg);
+ fprintf (stderr, "Error running %s: %s\n", exe_name, err_msg);
else if (status)
{
if (WIFSIGNALED (status))
{
int sig = WTERMSIG (status);
fprintf (stderr, "%s terminated with signal %d [%s]%s\n",
- exe_name, sig, strsignal(sig),
- WCOREDUMP(status) ? ", core dumped" : "");
+ exe_name, sig, strsignal (sig),
+ WCOREDUMP (status) ? ", core dumped" : "");
}
else if (WIFEXITED (status))
exit_code = WEXITSTATUS (status);
/* Prepend "--traditional-format" to whatever asm_spec we had before. */
{
static const char tf[] = "--traditional-format ";
- obstack_grow (&obstack, tf, sizeof(tf) - 1);
+ obstack_grow (&obstack, tf, sizeof (tf) - 1);
obstack_grow0 (&obstack, asm_spec, strlen (asm_spec));
asm_spec = XOBFINISH (&obstack, const char *);
}
defined LINKER_HASH_STYLE
# ifdef LINK_BUILDID_SPEC
/* Prepend LINK_BUILDID_SPEC to whatever link_spec we had before. */
- obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof(LINK_BUILDID_SPEC) - 1);
+ obstack_grow (&obstack, LINK_BUILDID_SPEC, sizeof (LINK_BUILDID_SPEC) - 1);
# endif
# ifdef LINK_EH_SPEC
/* Prepend LINK_EH_SPEC to whatever link_spec we had before. */
- obstack_grow (&obstack, LINK_EH_SPEC, sizeof(LINK_EH_SPEC) - 1);
+ obstack_grow (&obstack, LINK_EH_SPEC, sizeof (LINK_EH_SPEC) - 1);
# endif
# ifdef LINKER_HASH_STYLE
/* Prepend --hash-style=LINKER_HASH_STYLE to whatever link_spec we had
before. */
{
static const char hash_style[] = "--hash-style=";
- obstack_grow (&obstack, hash_style, sizeof(hash_style) - 1);
- obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof(LINKER_HASH_STYLE) - 1);
+ obstack_grow (&obstack, hash_style, sizeof (hash_style) - 1);
+ obstack_grow (&obstack, LINKER_HASH_STYLE, sizeof (LINKER_HASH_STYLE) - 1);
obstack_1grow (&obstack, ' ');
}
# endif
/* Free the old spec. */
if (old_spec && sl->alloc_p)
- free (CONST_CAST(char *, old_spec));
+ free (CONST_CAST (char *, old_spec));
sl->user_p = user_p;
sl->alloc_p = true;
#endif
#ifdef DEFAULT_LINKER
- if (! strcmp(name, "ld") && access (DEFAULT_LINKER, mode) == 0)
+ if (! strcmp (name, "ld") && access (DEFAULT_LINKER, mode) == 0)
return xstrdup (DEFAULT_LINKER);
#endif
a_is_negated = false;
a_is_spectype = false;
- SKIP_WHITE();
+ SKIP_WHITE ();
if (*p == '!')
p++, a_is_negated = true;
- SKIP_WHITE();
+ SKIP_WHITE ();
if (*p == '%' && p[1] == ':')
{
atom = NULL;
p++, a_is_spectype = true;
atom = p;
- while (ISIDNUM(*p) || *p == '-' || *p == '+' || *p == '='
+ while (ISIDNUM (*p) || *p == '-' || *p == '+' || *p == '='
|| *p == ',' || *p == '.' || *p == '@')
p++;
end_atom = p;
p++, a_is_starred = 1;
}
- SKIP_WHITE();
+ SKIP_WHITE ();
switch (*p)
{
case '&': case '}':
while (length-- && !IS_DIR_SEPARATOR (arg[length]))
if (arg[length] == '.')
{
- (CONST_CAST(char *, arg))[length] = 0;
+ (CONST_CAST (char *, arg))[length] = 0;
dot = 1;
break;
}
do_spec_1 (arg, 1, NULL);
if (dot)
- (CONST_CAST(char *, arg))[length] = '.';
+ (CONST_CAST (char *, arg))[length] = '.';
do_spec_1 (suffix_subst, 1, NULL);
}
else
}
#endif
- return ret ^ getpid();
+ return ret ^ getpid ();
}
/* %:compare-debug-dump-opt spec function. Save the last argument,
name = xstrdup (argv[0]);
- for (i = strlen(name) - 1; i >= 0; i--)
+ for (i = strlen (name) - 1; i >= 0; i--)
if (IS_DIR_SEPARATOR (name[i]))
break;
h_cnt++;
}
}
- gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH(h_cnt));
+ gcov_write_tag_length (tag, GCOV_TAG_SUMMARY_LENGTH (h_cnt));
gcov_write_unsigned (summary->checksum);
for (csum = summary->ctrs, ix = GCOV_COUNTERS_SUMMABLE; ix--; csum++)
{
while (!cur_bitvector)
{
h_ix = bv_ix * 32;
- gcc_assert(bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE);
+ gcc_assert (bv_ix < GCOV_HISTOGRAM_BITVECTOR_SIZE);
cur_bitvector = histo_bitvector[bv_ix++];
}
while (!(cur_bitvector & 0x1))
h_ix++;
cur_bitvector >>= 1;
}
- gcc_assert(h_ix < GCOV_HISTOGRAM_SIZE);
+ gcc_assert (h_ix < GCOV_HISTOGRAM_SIZE);
csum->histogram[h_ix].num_counters = gcov_read_unsigned ();
csum->histogram[h_ix].min_value = gcov_read_counter ();
gcov_bucket_type tmp_histo[GCOV_HISTOGRAM_SIZE];
int src_done = 0;
- memset(tmp_histo, 0, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+ memset (tmp_histo, 0, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
/* Assume that the counters are in the same relative order in both
histograms. Walk the histograms from largest to smallest entry,
/* The merged counters get placed in the new merged histogram
at the entry for the merged min_value. */
- tmp_i = gcov_histo_index(merge_min);
+ tmp_i = gcov_histo_index (merge_min);
gcc_assert (tmp_i < GCOV_HISTOGRAM_SIZE);
tmp_histo[tmp_i].num_counters += merge_num;
tmp_histo[tmp_i].cum_value += merge_cum;
}
/* At this point, tmp_i should be the smallest non-zero entry in the
tmp_histo. */
- gcc_assert(tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE
- && tmp_histo[tmp_i].num_counters > 0);
+ gcc_assert (tmp_i >= 0 && tmp_i < GCOV_HISTOGRAM_SIZE
+ && tmp_histo[tmp_i].num_counters > 0);
tmp_histo[tmp_i].cum_value += src_cum;
/* Finally, copy the merged histogram into tgt_histo. */
- memcpy(tgt_histo, tmp_histo, sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
+ memcpy (tgt_histo, tmp_histo,
+ sizeof (gcov_bucket_type) * GCOV_HISTOGRAM_SIZE);
}
#endif /* !IN_GCOV */
/* Return nonzero if SUB is an immediate subtag of TAG. */
#define GCOV_TAG_IS_SUBTAG(TAG,SUB) \
(GCOV_TAG_MASK (TAG) >> 8 == GCOV_TAG_MASK (SUB) \
- && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK(TAG)))
+ && !(((SUB) ^ (TAG)) & ~GCOV_TAG_MASK (TAG)))
/* Return nonzero if SUB is at a sublevel to TAG. */
#define GCOV_TAG_IS_SUBLEVEL(TAG,SUB) \
static void function_summary (const coverage_t *, const char *);
static const char *format_gcov (gcov_type, gcov_type, int);
static void accumulate_line_counts (source_t *);
-static void output_gcov_file(const char *, source_t *);
+static void output_gcov_file (const char *, source_t *);
static int output_branch_count (FILE *, int, const arc_t *);
static void output_lines (FILE *, const source_t *);
static char *make_gcov_file_name (const char *, const char *);
for (; argno != argc; argno++)
{
if (flag_display_progress)
- printf("Processing file %d out of %d\n",
- argno - first_arg + 1, argc - first_arg);
+ printf ("Processing file %d out of %d\n",
+ argno - first_arg + 1, argc - first_arg);
process_file (argv[argno]);
}
/* Find the 'basename'. */
cptr = lbasename (file_name);
- result = XNEWVEC(char, strlen (cptr) + strlen (gcov) + 1);
+ result = XNEWVEC (char, strlen (cptr) + strlen (gcov) + 1);
sprintf (result, "%s%s", cptr, gcov);
return result;
branch_type = (arc->count > 0) ? "taken" : "nottaken";
else
branch_type = "notexec";
- fprintf(gcov_file, "branch:%d,%s\n", line_num, branch_type);
+ fprintf (gcov_file, "branch:%d,%s\n", line_num, branch_type);
}
}
}
}
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);
class pass_rtl_pre : public rtl_opt_pass
{
public:
- pass_rtl_pre(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_pre, ctxt)
+ pass_rtl_pre (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_pre, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_hoist : public rtl_opt_pass
{
public:
- pass_rtl_hoist(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_hoist, ctxt)
+ pass_rtl_hoist (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_hoist, ctxt)
{}
/* opt_pass methods: */
write_upcase (const char *str)
{
for (; *str; str++)
- putchar (TOUPPER(*str));
+ putchar (TOUPPER (*str));
}
static void
/* Output flag masks for use by reorg.
Flags are used to hold branch direction for use by eligible_for_... */
- printf("\n#define ATTR_FLAG_forward\t0x1\n");
- printf("#define ATTR_FLAG_backward\t0x2\n");
+ printf ("\n#define ATTR_FLAG_forward\t0x1\n");
+ printf ("#define ATTR_FLAG_backward\t0x2\n");
- puts("\n#endif /* GCC_INSN_ATTR_H */");
+ puts ("\n#endif /* GCC_INSN_ATTR_H */");
if (ferror (stdout) || fflush (stdout) || fclose (stdout))
return FATAL_EXIT_CODE;
`return_val' (ATTR_PERMANENT_P): This rtx is permanent and unique
(see attr_rtx). */
-#define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), unchanging))
-#define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG((RTX), in_struct))
-#define ATTR_PERMANENT_P(RTX) (RTX_FLAG((RTX), return_val))
+#define ATTR_IND_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), unchanging))
+#define ATTR_CURR_SIMPLIFIED_P(RTX) (RTX_FLAG ((RTX), in_struct))
+#define ATTR_PERMANENT_P(RTX) (RTX_FLAG ((RTX), return_val))
#if 0
#define strcmp_check(S1, S2) ((S1) == (S2) \
x = evaluate_eq_attr (exp, attr, av->value,
insn_code, insn_index);
x = SIMPLIFY_TEST_EXP (x, insn_code, insn_index);
- if (attr_rtx_cost(x) < 7)
+ if (attr_rtx_cost (x) < 7)
return x;
}
}
while (*str)
{
/* The argument of TOUPPER should not have side effects. */
- fputc (TOUPPER(*str), outf);
+ fputc (TOUPPER (*str), outf);
str++;
}
}
{
FILE *outf;
-#define IS_ATTR_GROUP(X) (!strncmp(attr->name,X,strlen(X)))
+#define IS_ATTR_GROUP(X) (!strncmp (attr->name, X, strlen (X)))
if (IS_ATTR_GROUP ("*internal_dfa_insn_code"))
outf = dfa_file;
else if (IS_ATTR_GROUP ("*insn_default_latency"))
form_reservs_matter (automaton_t automaton)
{
int cycle, unit;
- reserv_sets_t reservs_matter = alloc_empty_reserv_sets();
+ reserv_sets_t reservs_matter = alloc_empty_reserv_sets ();
for (cycle = 0; cycle < max_cycles_num; cycle++)
for (unit = 0; unit < description->units_num; unit++)
{
size_t i;
arc_t arc;
- vla_hwint_t transition_vect = vla_hwint_t();
+ vla_hwint_t transition_vect = vla_hwint_t ();
undefined_vect_el_value = automaton->achieved_states_num;
automaton->trans_table = create_state_ainsn_table (automaton);
{
size_t i;
arc_t arc;
- vla_hwint_t dead_lock_vect = vla_hwint_t();
+ vla_hwint_t dead_lock_vect = vla_hwint_t ();
/* Create vect of pointers to states ordered by num of
transitions from the state (state with the maximum num is the
static void
output_reserved_units_table (automaton_t automaton)
{
- vla_hwint_t reserved_units_table = vla_hwint_t();
+ vla_hwint_t reserved_units_table = vla_hwint_t ();
int state_byte_size;
int reserved_units_size;
size_t n;
printf ("#define MAX_INSNS_PER_PEEP2 %d\n", max_insns_per_peep2);
}
- puts("\n#endif /* GCC_INSN_CONFIG_H */");
+ puts ("\n#endif /* GCC_INSN_CONFIG_H */");
if (ferror (stdout) || fflush (stdout) || fclose (stdout))
return FATAL_EXIT_CODE;
{
const char *p1;
for (p1 = GET_RTX_NAME (code); *p1; p1++)
- putchar (TOUPPER(*p1));
+ putchar (TOUPPER (*p1));
}
static void
p->duplocs = p->oplocs + op_count;
p->dupnums = (int *)(p->duplocs + dup_count);
- memcpy(p->oplocs, acc.oplocs.address(), op_count*sizeof(locstr));
- memcpy(p->duplocs, acc.duplocs.address(), dup_count*sizeof(locstr));
- memcpy(p->dupnums, acc.dupnums.address(), dup_count*sizeof(int));
+ memcpy (p->oplocs, acc.oplocs.address (), op_count * sizeof (locstr));
+ memcpy (p->duplocs, acc.duplocs.address (), dup_count * sizeof (locstr));
+ memcpy (p->dupnums, acc.dupnums.address (), dup_count * sizeof (int));
done:
acc.oplocs.release ();
{
if (ISLOWER (path[i]))
printf (", 0, %d)", path[i] - 'a');
- else if (ISDIGIT(path[i]))
+ else if (ISDIGIT (path[i]))
printf (", %d)", path[i] - '0');
else
gcc_unreachable ();
for (i = 0; name[i]; i++)
putchar (TOUPPER (name[i]));
- putchar('(');
+ putchar ('(');
for (i = 0; i < expect - 1; i++)
printf ("%c, ", i + 'A');
printf ("%c) gen_%s (", i + 'A', name);
for (insn_ptr = insns; *insn_ptr; insn_ptr++)
gen_proto (*insn_ptr);
- puts("\n#endif /* GCC_INSN_FLAGS_H */");
+ puts ("\n#endif /* GCC_INSN_FLAGS_H */");
if (have_error || ferror (stdout) || fflush (stdout) || fclose (stdout))
return FATAL_EXIT_CODE;
{
#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];
\f
class s_expr_writer
{
public:
- s_expr_writer();
+ s_expr_writer ();
void write_new_line ();
void write_any_indent (int leading_spaces);
class state_writer : public s_expr_writer
{
public:
- state_writer();
+ state_writer ();
private:
void write_state_fileloc (struct fileloc *floc);
/* class s_expr_writer's trivial constructor. */
-s_expr_writer::s_expr_writer()
+s_expr_writer::s_expr_writer ()
: indent_amount_(0),
had_recent_newline_(0)
{
/* class state_writer's trivial constructor. */
-state_writer::state_writer()
- : s_expr_writer(),
- state_written_type_count(0)
+state_writer::state_writer ()
+ : s_expr_writer (),
+ state_written_type_count (0)
{
}
else \
fatal ("%s:%d: Invalid state file; " Fmt, \
state_path, state_line, __VA_ARGS__); \
- } while(0)
+ } while (0)
/* Find or allocate an identifier in our name hash table. */
extern GTY(()) gcc::some_type *some_ptr;
where the autogenerated functions will refer to simply "some_type",
where they can be resolved into their namespace. */
- if (0 == strncmp(s, "gcc::", 5))
+ if (0 == strncmp (s, "gcc::", 5))
s += 5;
for (p = typedefs; p != NULL; p = p->next)
/* Create a fake field with the given type and name. NEXT is the next
field in the chain. */
#define create_field(next,type,name) \
- create_field_all(next,type,name, 0, this_file, __LINE__)
+ create_field_all (next,type,name, 0, this_file, __LINE__)
/* Like create_field, but the field is only valid when condition COND
is true. */
else
{
/* This can happen only when files_rules is buggy! */
- gcc_unreachable();
+ gcc_unreachable ();
}
/* Always skip the character after the dollar. */
pt++;
oprintf (of, "%lu%s", (unsigned long) strlen (id_for_tag),
id_for_tag);
if (id_for_tag != t->u.s.tag)
- free (CONST_CAST(char *, id_for_tag));
+ free (CONST_CAST (char *, id_for_tag));
}
break;
case TYPE_PARAM_STRUCT:
const char *id_for_tag = filter_type_name (s->u.s.tag);
oprintf (of, "gt_%sx_%s", prefix, id_for_tag);
if (id_for_tag != s->u.s.tag)
- free (CONST_CAST(char *, id_for_tag));
+ free (CONST_CAST (char *, id_for_tag));
}
else if (s->kind == TYPE_PARAM_STRUCT)
{
"#define gt_%sx_%s gt_%sx_%s\n",
wtd->prefix, s->u.s.tag, wtd->prefix, t_id_for_tag);
if (t_id_for_tag != t->u.s.tag)
- free (CONST_CAST(char *, t_id_for_tag));
+ free (CONST_CAST (char *, t_id_for_tag));
}
else
error_at_line (&s->u.s.line,
wtd->prefix, s_id_for_tag);
if (s_id_for_tag != s->u.s.tag)
- free (CONST_CAST(char *, s_id_for_tag));
+ free (CONST_CAST (char *, s_id_for_tag));
if (s->u.s.line.file == NULL)
{
else
oprintf (f, " NULL");
if (id_for_tag != tp->u.s.tag)
- free (CONST_CAST(char *, id_for_tag));
+ free (CONST_CAST (char *, id_for_tag));
}
else if (!has_length && tp->kind == TYPE_PARAM_STRUCT)
{
oprintf (f, ", n");
oprintf (f, " MEM_STAT_INFO)))\n");
if (type_name_as_id != type_name)
- free (CONST_CAST(char *, type_name_as_id));
+ free (CONST_CAST (char *, type_name_as_id));
}
/* Writes a typed allocator definition into output F for a struct or
relevant to plugin input files. */
if (nb_plugin_files > 0)
{
- struct fileloc* filoc = type_fileloc(s);
+ struct fileloc* filoc = type_fileloc (s);
if (!filoc || !filoc->file->inpisplugin)
continue;
};
we can see them. We should initialize them before calling
read_input_list. */
#define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
- Call;} while(0)
+ Call;} while (0)
POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos));
POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos));
POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos));
}
/* For each mode in class CLASS, construct a corresponding complex mode. */
-#define COMPLEX_MODES(C) make_complex_modes(MODE_##C, __FILE__, __LINE__)
+#define COMPLEX_MODES(C) make_complex_modes (MODE_##C, __FILE__, __LINE__)
static void
make_complex_modes (enum mode_class cl,
const char *file, unsigned int line)
/* For all modes in class CL, construct vector modes of width
WIDTH, having as many components as necessary. */
-#define VECTOR_MODES(C, W) make_vector_modes(MODE_##C, W, __FILE__, __LINE__)
+#define VECTOR_MODES(C, W) make_vector_modes (MODE_##C, W, __FILE__, __LINE__)
static void ATTRIBUTE_UNUSED
make_vector_modes (enum mode_class cl, unsigned int width,
const char *file, unsigned int line)
/* Input. */
-#define _SPECIAL_MODE(C, N) make_special_mode(MODE_##C, #N, __FILE__, __LINE__)
+#define _SPECIAL_MODE(C, N) \
+ make_special_mode (MODE_##C, #N, __FILE__, __LINE__)
#define RANDOM_MODE(N) _SPECIAL_MODE (RANDOM, N)
#define CC_MODE(N) _SPECIAL_MODE (CC, N)
#define _ADD_ADJUST(A, M, X, C1, C2) \
new_adjust (#M, &adj_##A, #A, #X, MODE_##C1, MODE_##C2, __FILE__, __LINE__)
-#define ADJUST_BYTESIZE(M, X) _ADD_ADJUST(bytesize, M, X, RANDOM, RANDOM)
-#define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST(alignment, M, X, RANDOM, RANDOM)
-#define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST(format, M, X, FLOAT, FLOAT)
-#define ADJUST_IBIT(M, X) _ADD_ADJUST(ibit, M, X, ACCUM, UACCUM)
-#define ADJUST_FBIT(M, X) _ADD_ADJUST(fbit, M, X, FRACT, UACCUM)
+#define ADJUST_BYTESIZE(M, X) _ADD_ADJUST (bytesize, M, X, RANDOM, RANDOM)
+#define ADJUST_ALIGNMENT(M, X) _ADD_ADJUST (alignment, M, X, RANDOM, RANDOM)
+#define ADJUST_FLOAT_FORMAT(M, X) _ADD_ADJUST (format, M, X, FLOAT, FLOAT)
+#define ADJUST_IBIT(M, X) _ADD_ADJUST (ibit, M, X, ACCUM, UACCUM)
+#define ADJUST_FBIT(M, X) _ADD_ADJUST (fbit, M, X, FRACT, UACCUM)
static void
create_modes (void)
for (i = (MAX_MACHINE_MODE) - 1; i >= 0; i--)
{
const char *p, *q;
- for (p = GET_MODE_NAME(i), q = name; *p; p++, q++)
+ for (p = GET_MODE_NAME (i), q = name; *p; p++, q++)
if (TOLOWER (*p) != *q)
break;
if (*p == 0
/* Sort the (real) optabs. Better than forcing the optabs.def file to
remain sorted by kind. We also scrogged any real ordering with the
purging of the X patterns above. */
- qsort (optabs, n, sizeof(optab_def), optab_kind_cmp);
+ qsort (optabs, n, sizeof (optab_def), optab_kind_cmp);
/* Emit the optab enumeration for the header file. */
fprintf (h_file, "enum optab_tag {\n");
pred = lookup_predicate (d->predicate);
printf (" %d\n", pred && pred->codes[MEM]);
- printf(" },\n");
+ printf (" },\n");
}
- printf("};\n\n\n");
+ printf ("};\n\n\n");
}
static void
printf (" %d,\n", d->n_alternatives);
printf (" %d\n", d->output_format);
- printf(" },\n");
+ printf (" },\n");
}
printf ("};\n\n\n");
}
next_index_number++;
}
- printf("\n\n");
+ printf ("\n\n");
output_operand_data ();
output_insn_data ();
output_get_insn_name ();
}
}
new_cdata = XNEWVAR (struct constraint_data, sizeof (struct constraint_data) + namelen);
- strcpy (CONST_CAST(char *, new_cdata->name), name);
+ strcpy (CONST_CAST (char *, new_cdata->name), name);
new_cdata->namelen = namelen;
new_cdata->lineno = lineno;
new_cdata->next_this_letter = *slot;
{
const char *p1;
for (p1 = GET_RTX_NAME (code); *p1; p1++)
- putchar (TOUPPER(*p1));
+ putchar (TOUPPER (*p1));
}
extern int main (int, char **);
putchar (TOUPPER (*code));
code++;
}
- fputs(":\n", stdout);
+ fputs (":\n", stdout);
}
}
break;
}
- fputs(" return ",stdout);
+ fputs (" return ",stdout);
write_predicate_expr (exp);
- fputs(";\n", stdout);
+ fputs (";\n", stdout);
}
/* Given a predicate, write out a complete C function to compute it. */
" switch (str[0])\n"
" {");
- for (i = 0; i < ARRAY_SIZE(constraints_by_letter_table); i++)
+ for (i = 0; i < ARRAY_SIZE (constraints_by_letter_table); i++)
{
struct constraint_data *c = constraints_by_letter_table[i];
if (!c)
" 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];
#include "gensupport.h"
#define OUTPUT_LABEL(INDENT_STRING, LABEL_NUMBER) \
- printf("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER))
+ printf ("%sL%d: ATTRIBUTE_UNUSED_LABEL\n", (INDENT_STRING), (LABEL_NUMBER))
/* Ways of obtaining an rtx to be tested. */
enum position_type {
const char *indent)
{
if (!afterward || start->subroutine_number > 0)
- printf("%sgoto ret0;\n", indent);
+ printf ("%sgoto ret0;\n", indent);
else
{
change_state (start->position, afterward->position, indent);
struct decision *ret;
RTX_CODE code;
- memset (codemap, 0, sizeof(codemap));
+ memset (codemap, 0, sizeof (codemap));
printf (" switch (GET_CODE (x%d))\n {\n", depth);
code = p->tests->u.code;
if (type == DT_elt_zero_wide_safe)
{
indent = " ";
- printf(" if ((int) XWINT (x%d, 0) == XWINT (x%d, 0))\n", depth, depth);
+ printf (" if ((int) XWINT (x%d, 0) == XWINT (x%d, 0))\n",
+ depth, depth);
}
printf ("%s switch (", indent);
switch (type)
if (test->type == DT_accept_op)
{
- printf("%soperands[%d] = x%d;\n", indent, test->u.opno, depth);
+ printf ("%soperands[%d] = x%d;\n", indent, test->u.opno, depth);
/* Only allow DT_accept_insn to follow. */
if (test->next)
}
else
{
- printf("%sgoto L%d;\n", indent, success->number);
+ printf ("%sgoto L%d;\n", indent, success->number);
success->need_label = 1;
}
validate_pattern (x, insn, NULL_RTX, 0);
- memset(&head, 0, sizeof(head));
+ memset (&head, 0, sizeof (head));
last = add_to_sequence (x, &head, &root_pos, type, 1);
/* Find the end of the test chain on the last node. */
}
/* Recognize it. */
- memset (&clobber_head, 0, sizeof(clobber_head));
+ memset (&clobber_head, 0, sizeof (clobber_head));
last = add_to_sequence (new_rtx, &clobber_head, &root_pos,
type, 1);
/* We run this after find_afterward, because find_afterward needs
the redundant DT_mode tests on predicates to determine whether
two tests can both be true or not. */
- simplify_tests(head);
+ simplify_tests (head);
write_subroutines (head, subroutine_type);
}
break;
case DT_pred:
fprintf (stderr, "pred=(%s,%s)",
- test->u.pred.name, GET_MODE_NAME(test->u.pred.mode));
+ test->u.pred.name, GET_MODE_NAME (test->u.pred.mode));
break;
case DT_c_test:
{
char sub[16+4];
- strncpy (sub, test->u.c_test, sizeof(sub));
+ strncpy (sub, test->u.c_test, sizeof (sub));
memcpy (sub+16, "...", 4);
fprintf (stderr, "c_test=\"%s\"", sub);
}
queue_pattern (rtx pattern, struct queue_elem ***list_tail,
const char *filename, int lineno)
{
- struct queue_elem *e = XNEW(struct queue_elem);
+ struct queue_elem *e = XNEW (struct queue_elem);
e->data = pattern;
e->filename = filename;
e->lineno = lineno;
static void
add_define_attr (const char *name)
{
- struct queue_elem *e = XNEW(struct queue_elem);
+ struct queue_elem *e = XNEW (struct queue_elem);
rtx t1 = rtx_alloc (DEFINE_ATTR);
XSTR (t1, 0) = name;
XSTR (t1, 1) = "no,yes";
new_size = (insn_name_ptr_size ? insn_name_ptr_size * 2 : 512);
insn_name_ptr = XRESIZEVEC (char *, insn_name_ptr, new_size);
memset (insn_name_ptr + insn_name_ptr_size, 0,
- sizeof(char *) * (new_size - insn_name_ptr_size));
+ sizeof (char *) * (new_size - insn_name_ptr_size));
insn_name_ptr_size = new_size;
}
char *this_object = NULL;
size_t this_object_size = 0;
struct mmap_info mmi;
- const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity();
+ const size_t mmap_offset_alignment = host_hooks.gt_pch_alloc_granularity ();
gt_pch_save_stringpool ();
size_t
default_gt_pch_alloc_granularity (void)
{
- return getpagesize();
+ return getpagesize ();
}
#if HAVE_MMAP_FILE
static int
ggc_min_expand_heuristic (void)
{
- double min_expand = physmem_total();
+ double min_expand = physmem_total ();
/* Adjust for rlimits. */
min_expand = ggc_rlimit_bound (min_expand);
static int
ggc_min_heapsize_heuristic (void)
{
- double phys_kbytes = physmem_total();
+ double phys_kbytes = physmem_total ();
double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
phys_kbytes /= 1024; /* Convert to Kbytes. */
/* The size in bytes required to maintain a bitmap for the objects
on a page-entry. */
#define BITMAP_SIZE(Num_objects) \
- (CEIL ((Num_objects), HOST_BITS_PER_LONG) * sizeof(long))
+ (CEIL ((Num_objects), HOST_BITS_PER_LONG) * sizeof (long))
/* Allocate pages in chunks of this size, to throttle calls to memory
allocation routines. The first page is used, the rest go onto the
page = alloc_anon (NULL, G.pagesize * GGC_QUIRE_SIZE, false);
if (page == NULL)
{
- page = alloc_anon(NULL, G.pagesize, true);
+ page = alloc_anon (NULL, G.pagesize, true);
entries = 1;
}
{
unsigned order;
- G.pagesize = getpagesize();
+ G.pagesize = getpagesize ();
G.lg_pagesize = exact_log2 (G.pagesize);
#ifdef HAVE_MMAP_DEV_ZERO
}
fprintf (stderr, "%-5s %10lu%c %10lu%c %10lu%c\n", "Total",
SCALE (G.bytes_mapped), STAT_LABEL (G.bytes_mapped),
- SCALE (G.allocated), STAT_LABEL(G.allocated),
+ SCALE (G.allocated), STAT_LABEL (G.allocated),
SCALE (total_overhead), STAT_LABEL (total_overhead));
if (GATHER_STATISTICS)
if (size != OBJECT_SIZE (order))
{
- unsigned padding = OBJECT_SIZE(order) - size;
+ unsigned padding = OBJECT_SIZE (order) - size;
/* To speed small writes, we use a nulled-out array that's larger
than most padding requests as the source for our null bytes. This
permits us to do the padding with fwrite() rather than fseek(), and
limits the chance the OS may try to flush any outstanding writes. */
- if (padding <= sizeof(emptyBytes))
+ if (padding <= sizeof (emptyBytes))
{
if (fwrite (emptyBytes, 1, padding, f) != padding)
fatal_error ("can%'t write PCH file");
#endif
/* Since we free all the allocated objects, the free list becomes
useless. Validate it now, which will also clear it. */
- validate_free_objects();
+ validate_free_objects ();
/* No object read from a PCH file should ever be freed. So, set the
context depth to 1, and set the depth of all the currently-allocated
else
low_bound = double_int_zero;
/* Static constructors for variably sized objects makes no sense. */
- gcc_assert (TREE_CODE(TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))))
+ gcc_assert (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))))
== INTEGER_CST);
elt_size =
tree_to_double_int (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor))));
need to do anything special. Otherwise build one by hand. */
if (gimple_seq_may_fallthru (lowered_body)
&& (data.return_statements.is_empty ()
- || gimple_return_retval (data.return_statements.last().stmt) != NULL))
+ || (gimple_return_retval (data.return_statements.last().stmt)
+ != NULL)))
{
x = gimple_build_return (NULL);
gimple_set_location (x, cfun->function_end_locus);
class pass_lower_cf : public gimple_opt_pass
{
public:
- pass_lower_cf(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_cf, ctxt)
+ pass_lower_cf (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_cf, ctxt)
{}
/* opt_pass methods: */
{
/* This CONST_CAST is okay because expr_last returns its argument
unmodified and we assign it to a const_tree. */
- const_tree stmt = expr_last (CONST_CAST_TREE(block));
+ const_tree stmt = expr_last (CONST_CAST_TREE (block));
switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
{
else
gcc_unreachable ();
if (!(flags & TDF_RHS_ONLY))
- pp_semicolon(buffer);
+ pp_semicolon (buffer);
}
}
pp_newline_and_flush (buffer);
gcc_checking_assert (DECL_STRUCT_FUNCTION (current_function_decl));
dump_histograms_for_stmt (DECL_STRUCT_FUNCTION (current_function_decl),
- pp_buffer(buffer)->stream, stmt);
+ pp_buffer (buffer)->stream, stmt);
}
dump_implicit_edges (buffer, bb, indent, flags);
class pass_strength_reduction : public gimple_opt_pass
{
public:
- pass_strength_reduction(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_strength_reduction, ctxt)
+ pass_strength_reduction (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_strength_reduction, ctxt)
{}
/* opt_pass methods: */
};
#undef DEFGSSTRUCT
-#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof(struct STRUCT),
+#define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
static const size_t gsstruct_code_size[] = {
#include "gsstruct.def"
};
else if (code == GIMPLE_CALL)
gimple_call_set_lhs (stmt, lhs);
else
- gcc_unreachable();
+ gcc_unreachable ();
}
return i;
}
-#define gsi_start(x) gsi_start_1(&(x))
+#define gsi_start(x) gsi_start_1 (&(x))
static inline gimple_stmt_iterator
gsi_none (void)
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. */
break;
default:
- gcc_unreachable();
+ gcc_unreachable ();
}
}
next_e = translate_clast_assignment ((struct clast_assignment *) stmt,
next_e, level, ip);
else
- gcc_unreachable();
+ gcc_unreachable ();
recompute_all_dominators ();
graphite_verify ();
/* Extend the scattering to NEW_DIMS scattering dimensions. */
static
-isl_map *extend_scattering(isl_map *scattering, int new_dims)
+isl_map *extend_scattering (isl_map *scattering, int new_dims)
{
int old_dims, i;
isl_space *space;
/* Dead code elimination: when the domain of a PBB is empty,
don't generate code for the PBB. */
- if (isl_set_is_empty(pbb->domain))
+ if (isl_set_is_empty (pbb->domain))
continue;
- domain = cloog_domain_from_isl_set(isl_set_copy(pbb->domain));
- scattering = cloog_scattering_from_isl_map(extend_scattering(isl_map_copy(pbb->transformed),
- nb_scattering_dims));
+ domain = cloog_domain_from_isl_set (isl_set_copy (pbb->domain));
+ scattering = cloog_scattering_from_isl_map
+ (extend_scattering (isl_map_copy (pbb->transformed),
+ nb_scattering_dims));
union_domain = cloog_union_domain_add_domain (union_domain, "", domain,
scattering, pbb);
*/
static isl_basic_map *
-getTileMap(isl_ctx *ctx, int scheduleDimensions, int tileSize)
+getTileMap (isl_ctx *ctx, int scheduleDimensions, int tileSize)
{
int x;
/* We construct
s1 = a1 * 32 and s1 = p1 and t1 <= p1 < t1 + 32}
and project out the auxilary dimensions a0 and a1. */
- isl_space *Space = isl_space_alloc(ctx, 0, scheduleDimensions,
- scheduleDimensions * 3);
- isl_basic_map *tileMap = isl_basic_map_universe(isl_space_copy(Space));
+ isl_space *Space = isl_space_alloc (ctx, 0, scheduleDimensions,
+ scheduleDimensions * 3);
+ isl_basic_map *tileMap = isl_basic_map_universe (isl_space_copy (Space));
- isl_local_space *LocalSpace = isl_local_space_from_space(Space);
+ isl_local_space *LocalSpace = isl_local_space_from_space (Space);
for (x = 0; x < scheduleDimensions; x++)
{
isl_constraint *c;
/* sX = aX * tileSize; */
- c = isl_equality_alloc(isl_local_space_copy(LocalSpace));
- isl_constraint_set_coefficient_si(c, isl_dim_out, sX, 1);
- isl_constraint_set_coefficient_si(c, isl_dim_out, aX, -tileSize);
- tileMap = isl_basic_map_add_constraint(tileMap, c);
+ c = isl_equality_alloc (isl_local_space_copy (LocalSpace));
+ isl_constraint_set_coefficient_si (c, isl_dim_out, sX, 1);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, aX, -tileSize);
+ tileMap = isl_basic_map_add_constraint (tileMap, c);
/* pX = sX; */
- c = isl_equality_alloc(isl_local_space_copy(LocalSpace));
- isl_constraint_set_coefficient_si(c, isl_dim_out, pX, 1);
- isl_constraint_set_coefficient_si(c, isl_dim_in, sX, -1);
- tileMap = isl_basic_map_add_constraint(tileMap, c);
+ c = isl_equality_alloc (isl_local_space_copy (LocalSpace));
+ isl_constraint_set_coefficient_si (c, isl_dim_out, pX, 1);
+ isl_constraint_set_coefficient_si (c, isl_dim_in, sX, -1);
+ tileMap = isl_basic_map_add_constraint (tileMap, c);
/* tX <= pX */
- c = isl_inequality_alloc(isl_local_space_copy(LocalSpace));
- isl_constraint_set_coefficient_si(c, isl_dim_out, pX, 1);
- isl_constraint_set_coefficient_si(c, isl_dim_out, tX, -1);
- tileMap = isl_basic_map_add_constraint(tileMap, c);
+ c = isl_inequality_alloc (isl_local_space_copy (LocalSpace));
+ isl_constraint_set_coefficient_si (c, isl_dim_out, pX, 1);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, tX, -1);
+ tileMap = isl_basic_map_add_constraint (tileMap, c);
/* pX <= tX + (tileSize - 1) */
- c = isl_inequality_alloc(isl_local_space_copy(LocalSpace));
- isl_constraint_set_coefficient_si(c, isl_dim_out, tX, 1);
- isl_constraint_set_coefficient_si(c, isl_dim_out, pX, -1);
- isl_constraint_set_constant_si(c, tileSize - 1);
- tileMap = isl_basic_map_add_constraint(tileMap, c);
+ c = isl_inequality_alloc (isl_local_space_copy (LocalSpace));
+ isl_constraint_set_coefficient_si (c, isl_dim_out, tX, 1);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, pX, -1);
+ isl_constraint_set_constant_si (c, tileSize - 1);
+ tileMap = isl_basic_map_add_constraint (tileMap, c);
}
/* Project out auxiliary dimensions.
The auxiliary dimensions are transformed into existentially quantified ones.
This reduces the number of visible scattering dimensions and allows Cloog
to produces better code. */
- tileMap = isl_basic_map_project_out(tileMap, isl_dim_out,
- 2 * scheduleDimensions,
- scheduleDimensions);
- isl_local_space_free(LocalSpace);
+ tileMap = isl_basic_map_project_out (tileMap, isl_dim_out,
+ 2 * scheduleDimensions,
+ scheduleDimensions);
+ isl_local_space_free (LocalSpace);
return tileMap;
}
static bool DisableTiling = false;
static isl_union_map *
-getScheduleForBand(isl_band *Band, int *Dimensions)
+getScheduleForBand (isl_band *Band, int *Dimensions)
{
isl_union_map *PartialSchedule;
isl_ctx *ctx;
isl_basic_map *TileMap;
isl_union_map *TileUMap;
- PartialSchedule = isl_band_get_partial_schedule(Band);
- *Dimensions = isl_band_n_member(Band);
+ PartialSchedule = isl_band_get_partial_schedule (Band);
+ *Dimensions = isl_band_n_member (Band);
if (DisableTiling)
return PartialSchedule;
if (*Dimensions == 1)
return PartialSchedule;
- ctx = isl_union_map_get_ctx(PartialSchedule);
- Space = isl_union_map_get_space(PartialSchedule);
+ ctx = isl_union_map_get_ctx (PartialSchedule);
+ Space = isl_union_map_get_space (PartialSchedule);
- TileMap = getTileMap(ctx, *Dimensions, 32);
- TileUMap = isl_union_map_from_map(isl_map_from_basic_map(TileMap));
- TileUMap = isl_union_map_align_params(TileUMap, Space);
+ TileMap = getTileMap (ctx, *Dimensions, 32);
+ TileUMap = isl_union_map_from_map (isl_map_from_basic_map (TileMap));
+ TileUMap = isl_union_map_align_params (TileUMap, Space);
*Dimensions = 2 * *Dimensions;
- return isl_union_map_apply_range(PartialSchedule, TileUMap);
+ return isl_union_map_apply_range (PartialSchedule, TileUMap);
}
/* Create a map that pre-vectorizes one scheduling dimension.
currently constant and not yet target specific. This function does not reason
about parallelism. */
static isl_map *
-getPrevectorMap(isl_ctx *ctx, int DimToVectorize,
- int ScheduleDimensions,
- int VectorWidth)
+getPrevectorMap (isl_ctx *ctx, int DimToVectorize,
+ int ScheduleDimensions,
+ int VectorWidth)
{
isl_space *Space;
isl_local_space *LocalSpace, *LocalSpaceRange;
/* assert (0 <= DimToVectorize && DimToVectorize < ScheduleDimensions);*/
- Space = isl_space_alloc(ctx, 0, ScheduleDimensions, ScheduleDimensions + 1);
- TilingMap = isl_map_universe(isl_space_copy(Space));
- LocalSpace = isl_local_space_from_space(Space);
+ Space = isl_space_alloc (ctx, 0, ScheduleDimensions, ScheduleDimensions + 1);
+ TilingMap = isl_map_universe (isl_space_copy (Space));
+ LocalSpace = isl_local_space_from_space (Space);
PointDimension = ScheduleDimensions;
TileDimension = DimToVectorize;
DimToVectorize to the point loop at the innermost dimension. */
for (i = 0; i < ScheduleDimensions; i++)
{
- c = isl_equality_alloc(isl_local_space_copy(LocalSpace));
- isl_constraint_set_coefficient_si(c, isl_dim_in, i, -1);
+ c = isl_equality_alloc (isl_local_space_copy (LocalSpace));
+ isl_constraint_set_coefficient_si (c, isl_dim_in, i, -1);
if (i == DimToVectorize)
- isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, 1);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, 1);
else
- isl_constraint_set_coefficient_si(c, isl_dim_out, i, 1);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, i, 1);
- TilingMap = isl_map_add_constraint(TilingMap, c);
+ TilingMap = isl_map_add_constraint (TilingMap, c);
}
/* it % 'VectorWidth' = 0 */
- LocalSpaceRange = isl_local_space_range(isl_local_space_copy(LocalSpace));
- Aff = isl_aff_zero_on_domain(LocalSpaceRange);
- Aff = isl_aff_set_constant_si(Aff, VectorWidth);
- Aff = isl_aff_set_coefficient_si(Aff, isl_dim_in, TileDimension, 1);
- isl_int_init(VectorWidthMP);
- isl_int_set_si(VectorWidthMP, VectorWidth);
- Aff = isl_aff_mod(Aff, VectorWidthMP);
- isl_int_clear(VectorWidthMP);
- Modulo = isl_pw_aff_zero_set(isl_pw_aff_from_aff(Aff));
- TilingMap = isl_map_intersect_range(TilingMap, Modulo);
+ LocalSpaceRange = isl_local_space_range (isl_local_space_copy (LocalSpace));
+ Aff = isl_aff_zero_on_domain (LocalSpaceRange);
+ Aff = isl_aff_set_constant_si (Aff, VectorWidth);
+ Aff = isl_aff_set_coefficient_si (Aff, isl_dim_in, TileDimension, 1);
+ isl_int_init (VectorWidthMP);
+ isl_int_set_si (VectorWidthMP, VectorWidth);
+ Aff = isl_aff_mod (Aff, VectorWidthMP);
+ isl_int_clear (VectorWidthMP);
+ Modulo = isl_pw_aff_zero_set (isl_pw_aff_from_aff (Aff));
+ TilingMap = isl_map_intersect_range (TilingMap, Modulo);
/* it <= ip */
- c = isl_inequality_alloc(isl_local_space_copy(LocalSpace));
- isl_constraint_set_coefficient_si(c, isl_dim_out, TileDimension, -1);
- isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, 1);
- TilingMap = isl_map_add_constraint(TilingMap, c);
+ c = isl_inequality_alloc (isl_local_space_copy (LocalSpace));
+ isl_constraint_set_coefficient_si (c, isl_dim_out, TileDimension, -1);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, 1);
+ TilingMap = isl_map_add_constraint (TilingMap, c);
/* ip <= it + ('VectorWidth' - 1) */
- c = isl_inequality_alloc(LocalSpace);
- isl_constraint_set_coefficient_si(c, isl_dim_out, TileDimension, 1);
- isl_constraint_set_coefficient_si(c, isl_dim_out, PointDimension, -1);
- isl_constraint_set_constant_si(c, VectorWidth - 1);
- TilingMap = isl_map_add_constraint(TilingMap, c);
+ c = isl_inequality_alloc (LocalSpace);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, TileDimension, 1);
+ isl_constraint_set_coefficient_si (c, isl_dim_out, PointDimension, -1);
+ isl_constraint_set_constant_si (c, VectorWidth - 1);
+ TilingMap = isl_map_add_constraint (TilingMap, c);
- isl_map_dump(TilingMap);
+ isl_map_dump (TilingMap);
return TilingMap;
}
individual bands to the overall schedule. In case tiling is requested,
the individual bands are tiled. */
static isl_union_map *
-getScheduleForBandList(isl_band_list *BandList)
+getScheduleForBandList (isl_band_list *BandList)
{
int NumBands, i;
isl_union_map *Schedule;
isl_ctx *ctx;
- ctx = isl_band_list_get_ctx(BandList);
- NumBands = isl_band_list_n_band(BandList);
- Schedule = isl_union_map_empty(isl_space_params_alloc(ctx, 0));
+ ctx = isl_band_list_get_ctx (BandList);
+ NumBands = isl_band_list_n_band (BandList);
+ Schedule = isl_union_map_empty (isl_space_params_alloc (ctx, 0));
for (i = 0; i < NumBands; i++)
{
int ScheduleDimensions;
isl_space *Space;
- Band = isl_band_list_get_band(BandList, i);
- PartialSchedule = getScheduleForBand(Band, &ScheduleDimensions);
- Space = isl_union_map_get_space(PartialSchedule);
+ Band = isl_band_list_get_band (BandList, i);
+ PartialSchedule = getScheduleForBand (Band, &ScheduleDimensions);
+ Space = isl_union_map_get_space (PartialSchedule);
- if (isl_band_has_children(Band))
+ if (isl_band_has_children (Band))
{
isl_band_list *Children;
isl_union_map *SuffixSchedule;
- Children = isl_band_get_children(Band);
- SuffixSchedule = getScheduleForBandList(Children);
- PartialSchedule = isl_union_map_flat_range_product(PartialSchedule,
- SuffixSchedule);
- isl_band_list_free(Children);
+ Children = isl_band_get_children (Band);
+ SuffixSchedule = getScheduleForBandList (Children);
+ PartialSchedule = isl_union_map_flat_range_product (PartialSchedule,
+ SuffixSchedule);
+ isl_band_list_free (Children);
}
else if (EnablePollyVector)
{
for (i = ScheduleDimensions - 1 ; i >= 0 ; i--)
{
- if (isl_band_member_is_zero_distance(Band, i))
+ if (isl_band_member_is_zero_distance (Band, i))
{
isl_map *TileMap;
isl_union_map *TileUMap;
- TileMap = getPrevectorMap(ctx, i, ScheduleDimensions, 4);
- TileUMap = isl_union_map_from_map(TileMap);
- TileUMap = isl_union_map_align_params(TileUMap,
- isl_space_copy(Space));
- PartialSchedule = isl_union_map_apply_range(PartialSchedule,
- TileUMap);
+ TileMap = getPrevectorMap (ctx, i, ScheduleDimensions, 4);
+ TileUMap = isl_union_map_from_map (TileMap);
+ TileUMap = isl_union_map_align_params
+ (TileUMap, isl_space_copy (Space));
+ PartialSchedule = isl_union_map_apply_range
+ (PartialSchedule, TileUMap);
break;
}
}
}
- Schedule = isl_union_map_union(Schedule, PartialSchedule);
+ Schedule = isl_union_map_union (Schedule, PartialSchedule);
- isl_band_free(Band);
- isl_space_free(Space);
+ isl_band_free (Band);
+ isl_space_free (Space);
}
return Schedule;
}
static isl_union_map *
-getScheduleMap(isl_schedule *Schedule)
+getScheduleMap (isl_schedule *Schedule)
{
- isl_band_list *BandList = isl_schedule_get_band_forest(Schedule);
- isl_union_map *ScheduleMap = getScheduleForBandList(BandList);
- isl_band_list_free(BandList);
+ isl_band_list *BandList = isl_schedule_get_band_forest (Schedule);
+ isl_union_map *ScheduleMap = getScheduleForBandList (BandList);
+ isl_band_list_free (BandList);
return ScheduleMap;
}
static int
-getSingleMap(__isl_take isl_map *map, void *user)
+getSingleMap (__isl_take isl_map *map, void *user)
{
isl_map **singleMap = (isl_map **) user;
*singleMap = map;
isl_union_map *stmtBand;
isl_map *stmtSchedule;
- stmtBand = isl_union_map_intersect_domain(isl_union_map_copy(schedule_map),
- isl_union_set_from_set(domain));
- isl_union_map_foreach_map(stmtBand, getSingleMap, &stmtSchedule);
- isl_map_free(pbb->transformed);
+ stmtBand = isl_union_map_intersect_domain
+ (isl_union_map_copy (schedule_map),
+ isl_union_set_from_set (domain));
+ isl_union_map_foreach_map (stmtBand, getSingleMap, &stmtSchedule);
+ isl_map_free (pbb->transformed);
pbb->transformed = stmtSchedule;
- isl_union_map_free(stmtBand);
+ isl_union_map_free (stmtBand);
}
}
domain = scop_get_domains (scop);
dependences = scop_get_dependences (scop);
- dependences = isl_union_map_gist_domain(dependences,
- isl_union_set_copy(domain));
- dependences = isl_union_map_gist_range(dependences,
- isl_union_set_copy(domain));
+ dependences = isl_union_map_gist_domain (dependences,
+ isl_union_set_copy (domain));
+ dependences = isl_union_map_gist_range (dependences,
+ isl_union_set_copy (domain));
validity = dependences;
proximity = isl_union_map_copy (validity);
- isl_options_set_schedule_max_constant_term(scop->ctx, CONSTANT_BOUND);
- isl_options_set_schedule_maximize_band_depth(scop->ctx, 1);
- isl_options_set_schedule_fuse(scop->ctx, ISL_SCHEDULE_FUSE_MIN);
- isl_options_set_on_error(scop->ctx, ISL_ON_ERROR_CONTINUE);
+ isl_options_set_schedule_max_constant_term (scop->ctx, CONSTANT_BOUND);
+ isl_options_set_schedule_maximize_band_depth (scop->ctx, 1);
+ isl_options_set_schedule_fuse (scop->ctx, ISL_SCHEDULE_FUSE_MIN);
+ isl_options_set_on_error (scop->ctx, ISL_ON_ERROR_CONTINUE);
schedule = isl_union_set_compute_schedule (domain, validity, proximity);
- isl_options_set_on_error(scop->ctx, ISL_ON_ERROR_ABORT);
+ isl_options_set_on_error (scop->ctx, ISL_ON_ERROR_ABORT);
if (!schedule)
return false;
extern int scop_do_strip_mine (scop_p, int);
extern bool scop_do_block (scop_p);
extern bool flatten_all_loops (scop_p);
-extern bool optimize_isl(scop_p);
+extern bool optimize_isl (scop_p);
extern void pbb_number_of_iterations_at_time (poly_bb_p, graphite_dim_t, mpz_t);
extern void debug_gmp_value (mpz_t);
id = isl_id_for_ssa_name (s, e);
dimension = isl_space_find_dim_by_id (space, isl_dim_param, id);
- isl_id_free(id);
+ isl_id_free (id);
dom = isl_set_universe (isl_space_copy (space));
aff = isl_aff_zero_on_domain (isl_local_space_from_space (space));
aff = isl_aff_add_coefficient_si (aff, isl_dim_param, dimension, 1);
if (TREE_CODE (nb_iters) == INTEGER_CST)
{
c = isl_inequality_alloc
- (isl_local_space_from_space(isl_space_copy (space)));
+ (isl_local_space_from_space (isl_space_copy (space)));
c = isl_constraint_set_coefficient_si (c, isl_dim_set, pos, -1);
tree_int_to_gmp (nb_iters, g);
isl_int_set_gmp (v, g);
break;
default:
- isl_pw_aff_free(lhs);
- isl_pw_aff_free(rhs);
+ isl_pw_aff_free (lhs);
+ isl_pw_aff_free (rhs);
return;
}
return;
ctx = isl_ctx_alloc ();
- isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
+ isl_options_set_on_error (ctx, ISL_ON_ERROR_ABORT);
if (!graphite_initialize (ctx))
return;
}
info_val = (*current_sched_info->rank) (tmp, tmp2);
- if(flag_sched_rank_heuristic && info_val)
+ if (flag_sched_rank_heuristic && info_val)
return info_val;
/* Compare insns based on their relation to the last scheduled
/* Fix priorities. If MUTATE_P is nonzero, this is not necessary,
because it'll be done later in add_to_speculative_block. */
{
- rtx_vec_t priorities_roots = rtx_vec_t();
+ rtx_vec_t priorities_roots = rtx_vec_t ();
clear_priorities (twin, &priorities_roots);
calc_priorities (priorities_roots);
hash_table_higher_prime_index (unsigned long n)
{
unsigned int low = 0;
- unsigned int high = sizeof(prime_tab) / sizeof(prime_tab[0]);
+ unsigned int high = sizeof (prime_tab) / sizeof (prime_tab[0]);
while (low != high)
{
int (*Callback) (value_type **slot, Argument argument)>
void traverse (Argument argument);
- iterator begin();
- iterator end();
+ iterator begin ();
+ iterator end ();
};
template <typename Descriptor,
template <typename Type> class Allocator>
inline size_t
-hash_table <Descriptor, Allocator>::size()
+hash_table <Descriptor, Allocator>::size ()
{
return htab->size;
}
template <typename Descriptor,
template <typename Type> class Allocator>
inline double
-hash_table <Descriptor, Allocator>::collisions()
+hash_table <Descriptor, Allocator>::collisions ()
{
if (htab->searches == 0)
return 0.0;
int
clz_hwi (unsigned HOST_WIDE_INT x)
{
- return HOST_BITS_PER_WIDE_INT - 1 - floor_log2(x);
+ return HOST_BITS_PER_WIDE_INT - 1 - floor_log2 (x);
}
/* Similar to ctz_hwi, except that the least significant bit is numbered
# if GCC_VERSION >= 3000
# define HAVE_LONG_LONG 1
# define SIZEOF_LONG_LONG 8
-extern char sizeof_long_long_must_be_8[sizeof(long long) == 8 ? 1 : -1];
+extern char sizeof_long_long_must_be_8[sizeof (long long) == 8 ? 1 : -1];
# endif
#endif
#endif
-#define HOST_WIDE_INT_UC(X) HOST_WIDE_INT_C(X ## U)
-#define HOST_WIDE_INT_1 HOST_WIDE_INT_C(1)
-#define HOST_WIDE_INT_1U HOST_WIDE_INT_UC(1)
-#define HOST_WIDE_INT_M1 HOST_WIDE_INT_C(-1)
-#define HOST_WIDE_INT_M1U HOST_WIDE_INT_UC(-1)
+#define HOST_WIDE_INT_UC(X) HOST_WIDE_INT_C (X ## U)
+#define HOST_WIDE_INT_1 HOST_WIDE_INT_C (1)
+#define HOST_WIDE_INT_1U HOST_WIDE_INT_UC (1)
+#define HOST_WIDE_INT_M1 HOST_WIDE_INT_C (-1)
+#define HOST_WIDE_INT_M1U HOST_WIDE_INT_UC (-1)
/* This is a magic identifier which allows GCC to figure out the type
of HOST_WIDE_INT for %wd specifier checks. You must issue this
# define HOST_WIDEST_INT_PRINT_UNSIGNED HOST_WIDE_INT_PRINT_UNSIGNED
# define HOST_WIDEST_INT_PRINT_HEX HOST_WIDE_INT_PRINT_HEX
# define HOST_WIDEST_INT_PRINT_DOUBLE_HEX HOST_WIDE_INT_PRINT_DOUBLE_HEX
-# define HOST_WIDEST_INT_C(X) HOST_WIDE_INT(X)
+# define HOST_WIDEST_INT_C(X) HOST_WIDE_INT (X)
#else
# if HOST_BITS_PER_LONGLONG >= 64
# define HOST_BITS_PER_WIDEST_INT HOST_BITS_PER_LONGLONG
if (NOTE_P (insn) || DEBUG_INSN_P (insn))
goto insn_done;
- gcc_assert(NONJUMP_INSN_P (insn) || CALL_P (insn));
+ gcc_assert (NONJUMP_INSN_P (insn) || CALL_P (insn));
/* Remove USE insns that get in the way. */
if (reload_completed && GET_CODE (PATTERN (insn)) == USE)
class pass_rtl_ifcvt : public rtl_opt_pass
{
public:
- pass_rtl_ifcvt(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_ifcvt, ctxt)
+ pass_rtl_ifcvt (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_ifcvt, ctxt)
{}
/* opt_pass methods: */
class pass_if_after_combine : public rtl_opt_pass
{
public:
- pass_if_after_combine(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_if_after_combine, ctxt)
+ pass_if_after_combine (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_if_after_combine, ctxt)
{}
/* opt_pass methods: */
class pass_if_after_reload : public rtl_opt_pass
{
public:
- pass_if_after_reload(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_if_after_reload, ctxt)
+ pass_if_after_reload (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_if_after_reload, ctxt)
{}
/* opt_pass methods: */
VMS has non-numeric inodes. */
#ifdef VMS
# define INO_T_EQ(A, B) (!memcmp (&(A), &(B), sizeof (A)))
-# define INO_T_COPY(DEST, SRC) memcpy(&(DEST), &(SRC), sizeof (SRC))
+# define INO_T_COPY(DEST, SRC) memcpy (&(DEST), &(SRC), sizeof (SRC))
#elif !defined (HOST_LACKS_INODE_NUMBERS)
# define INO_T_EQ(A, B) ((A) == (B))
# define INO_T_COPY(DEST, SRC) (DEST) = (SRC)
#if defined INO_T_EQ
#define DIRS_EQ(A, B) ((A)->dev == (B)->dev \
- && INO_T_EQ((A)->ino, (B)->ino))
+ && INO_T_EQ ((A)->ino, (B)->ino))
#else
#define DIRS_EQ(A, B) (!filename_cmp ((A)->canonical_name, (B)->canonical_name))
#endif
const char *imultilib, int cxx_stdinc)
{
const struct default_include *p;
- int relocated = cpp_relocated();
+ int relocated = cpp_relocated ();
size_t len;
if (iprefix && (len = cpp_GCC_INCLUDE_DIR_len) != 0)
class pass_initialize_regs : public rtl_opt_pass
{
public:
- pass_initialize_regs(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_initialize_regs, ctxt)
+ pass_initialize_regs (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_initialize_regs, ctxt)
{}
/* opt_pass methods: */
< RESERVED_LOCATION_COUNT) ? 1 : -1];
extern expanded_location expand_location (source_location);
-extern const char * location_get_source_line(expanded_location xloc);
+extern const char *location_get_source_line (expanded_location xloc);
extern expanded_location expand_location_to_spelling_point (source_location);
extern source_location expansion_point_location_if_in_system_header (source_location);
#define LOCATION_LINE(LOC) ((expand_location (LOC)).line)
#define LOCATION_COLUMN(LOC)((expand_location (LOC)).column)
#define LOCATION_LOCUS(LOC) \
- ((IS_ADHOC_LOC(LOC)) ? get_location_from_adhoc_loc (line_table, LOC) : (LOC))
+ ((IS_ADHOC_LOC (LOC)) ? get_location_from_adhoc_loc (line_table, LOC) \
+ : (LOC))
#define LOCATION_BLOCK(LOC) \
((tree) ((IS_ADHOC_LOC (LOC)) ? get_data_from_adhoc_loc (line_table, (LOC)) \
- : NULL))
+ : NULL))
#define input_line LOCATION_LINE (input_location)
#define input_filename LOCATION_FILE (input_location)
get_spaces (const char *str)
{
size_t len = gcc_gettext_width (str);
- char *spaces = XNEWVEC(char, len + 1);
+ char *spaces = XNEWVEC (char, len + 1);
memset (spaces, ' ', len);
spaces[len] = '\0';
return spaces;
# define bindtextdomain(domain, directory) (domain)
# undef gettext
# define gettext(msgid) (msgid)
-# define ngettext(singular,plural,n) fake_ngettext(singular,plural,n)
+# define ngettext(singular,plural,n) fake_ngettext (singular, plural, n)
# define gcc_init_libintl() /* nothing */
-# define gcc_gettext_width(s) strlen(s)
+# define gcc_gettext_width(s) strlen (s)
-extern const char *fake_ngettext(const char *singular,const char *plural,
- unsigned long int n);
+extern const char *fake_ngettext (const char *singular, const char *plural,
+ unsigned long int n);
#endif
}
else
{
- inter.release();
+ inter.release ();
return vec<ipa_agg_jf_item_t>();
}
return inter;
return false;
values = intersect_aggregates_with_edge (cs, i, values);
- if (!values.exists())
+ if (!values.exists ())
return false;
for (struct ipa_agg_replacement_value *av = aggval; av; av = av->next)
}
if (!found)
{
- values.release();
+ values.release ();
return false;
}
}
class pass_ipa_cp : public ipa_opt_pass_d
{
public:
- pass_ipa_cp(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_cp, ctxt,
- ipcp_generate_summary, /* generate_summary */
- ipcp_write_summary, /* write_summary */
- ipcp_read_summary, /* read_summary */
- ipa_prop_write_all_agg_replacement, /*
- write_optimization_summary */
- ipa_prop_read_all_agg_replacement, /*
- read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- ipcp_transform_function, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_cp (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_cp, ctxt,
+ ipcp_generate_summary, /* generate_summary */
+ ipcp_write_summary, /* write_summary */
+ ipcp_read_summary, /* read_summary */
+ ipa_prop_write_all_agg_replacement, /*
+ write_optimization_summary */
+ ipa_prop_read_all_agg_replacement, /*
+ read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ ipcp_transform_function, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
unsigned int i;
TYPE_BINFO (val->type) = TYPE_BINFO (type);
- for (i = 0; i < val->types->length(); i++)
+ for (i = 0; i < val->types->length (); i++)
{
if (TYPE_BINFO ((*val->types)[i])
== master_binfo)
}
/* First record bases, then add into array so ids are increasing. */
if (odr_types_ptr)
- val->id = odr_types.length();
+ val->id = odr_types.length ();
vec_safe_push (odr_types_ptr, val);
}
return val;
DECL_SOURCE_FILE (TYPE_NAME (t->type)),
DECL_SOURCE_LINE (TYPE_NAME (t->type)));
}
- if (t->bases.length())
+ if (t->bases.length ())
{
fprintf (f, "%*s base odr type ids: ", indent * 2, "");
- for (i = 0; i < t->bases.length(); i++)
+ for (i = 0; i < t->bases.length (); i++)
fprintf (f, " %i", t->bases[i]->id);
fprintf (f, "\n");
}
- if (t->derived_types.length())
+ if (t->derived_types.length ())
{
fprintf (f, "%*s derived types:\n", indent * 2, "");
- for (i = 0; i < t->derived_types.length(); i++)
+ for (i = 0; i < t->derived_types.length (); i++)
dump_odr_type (f, t->derived_types[i], indent + 1);
}
fprintf (f, "\n");
if (!odr_types_ptr)
return;
fprintf (f, "\n\nType inheritance graph:\n");
- for (i = 0; i < odr_types.length(); i++)
+ for (i = 0; i < odr_types.length (); i++)
{
- if (odr_types[i]->bases.length() == 0)
+ if (odr_types[i]->bases.length () == 0)
dump_odr_type (f, odr_types[i]);
}
- for (i = 0; i < odr_types.length(); i++)
+ for (i = 0; i < odr_types.length (); i++)
{
- if (odr_types[i]->types && odr_types[i]->types->length())
+ if (odr_types[i]->types && odr_types[i]->types->length ())
{
unsigned int j;
fprintf (f, "Duplicate tree types for odr type %i\n", i);
print_node (f, "", odr_types[i]->type, 0);
- for (j = 0; j < odr_types[i]->types->length(); j++)
+ for (j = 0; j < odr_types[i]->types->length (); j++)
{
tree t;
fprintf (f, "duplicate #%i\n", j);
record_binfo (nodes, binfo, otr_type, binfo, otr_token, inserted,
matched_vtables, type->anonymous_namespace);
- for (i = 0; i < type->derived_types.length(); i++)
+ for (i = 0; i < type->derived_types.length (); i++)
possible_polymorphic_call_targets_1 (nodes, inserted,
matched_vtables,
otr_type,
/* Walk recursively all derived types. Here we need to lookup proper basetype
via their BINFO walk that is done by record_binfo */
- for (i = 0; i < type->derived_types.length(); i++)
+ for (i = 0; i < type->derived_types.length (); i++)
possible_polymorphic_call_targets_1 (nodes, inserted,
matched_vtables,
otr_type, type->derived_types[i],
nmultiple++;
continue;
}
- for (i = 0; i < targets.length(); i++)
+ for (i = 0; i < targets.length (); i++)
if (likely_target_p (targets[i]))
{
if (likely_target)
class pass_ipa_devirt : public ipa_opt_pass_d
{
public:
- pass_ipa_devirt(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_devirt, ctxt,
- NULL, /* generate_summary */
- NULL, /* write_summary */
- NULL, /* read_summary */
- NULL, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_devirt (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_devirt, ctxt,
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
class pass_inline_parameters : public gimple_opt_pass
{
public:
- pass_inline_parameters(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_inline_parameters, ctxt)
+ pass_inline_parameters (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_inline_parameters, ctxt)
{}
/* opt_pass methods: */
sreal tmp, relbenefit_real, growth_real;
int relbenefit = relative_time_benefit (callee_info, edge, edge_time);
- sreal_init(&relbenefit_real, relbenefit, 0);
- sreal_init(&growth_real, growth, 0);
+ sreal_init (&relbenefit_real, relbenefit, 0);
+ sreal_init (&growth_real, growth, 0);
/* relative_edge_count. */
sreal_init (&tmp, edge->count, 0);
class pass_early_inline : public gimple_opt_pass
{
public:
- pass_early_inline(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_early_inline, ctxt)
+ pass_early_inline (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_early_inline, ctxt)
{}
/* opt_pass methods: */
class pass_ipa_inline : public ipa_opt_pass_d
{
public:
- pass_ipa_inline(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_inline, ctxt,
- inline_generate_summary, /* generate_summary */
- inline_write_summary, /* write_summary */
- inline_read_summary, /* read_summary */
- NULL, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- inline_transform, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_inline (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_inline, ctxt,
+ inline_generate_summary, /* generate_summary */
+ inline_write_summary, /* write_summary */
+ inline_read_summary, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ inline_transform, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
= lto_create_simple_output_block (LTO_section_ipa_profile);
unsigned int i;
- streamer_write_uhwi_stream (ob->main_stream, histogram.length());
+ streamer_write_uhwi_stream (ob->main_stream, histogram.length ());
for (i = 0; i < histogram.length (); i++)
{
streamer_write_gcov_count_stream (ob->main_stream, histogram[i]->count);
set_hot_bb_threshold (threshold);
}
}
- histogram.release();
+ histogram.release ();
free_alloc_pool (histogram_pool);
/* Produce speculative calls: we saved common traget from porfiling into
class pass_ipa_profile : public ipa_opt_pass_d
{
public:
- pass_ipa_profile(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_profile, ctxt,
- ipa_profile_generate_summary, /* generate_summary */
- ipa_profile_write_summary, /* write_summary */
- ipa_profile_read_summary, /* read_summary */
- NULL, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_profile (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_profile, ctxt,
+ ipa_profile_generate_summary, /* generate_summary */
+ ipa_profile_write_summary, /* write_summary */
+ ipa_profile_read_summary, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
gimple_stmt_iterator gsi;
struct walk_stmt_info wi;
- memset (&wi, 0, sizeof(wi));
+ memset (&wi, 0, sizeof (wi));
for (gsi = gsi_start_bb (this_block);
!gsi_end_p (gsi);
gsi_next (&gsi))
class pass_ipa_pure_const : public ipa_opt_pass_d
{
public:
- pass_ipa_pure_const(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_pure_const, ctxt,
- pure_const_generate_summary, /* generate_summary */
- pure_const_write_summary, /* write_summary */
- pure_const_read_summary, /* read_summary */
- NULL, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_pure_const (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_pure_const, ctxt,
+ pure_const_generate_summary, /* generate_summary */
+ pure_const_write_summary, /* write_summary */
+ pure_const_read_summary, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
class pass_local_pure_const : public gimple_opt_pass
{
public:
- pass_local_pure_const(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_local_pure_const, ctxt)
+ pass_local_pure_const (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_local_pure_const, ctxt)
{}
/* opt_pass methods: */
EXECUTE_IF_SET_IN_BITMAP (l->statics_written,
0, index, bi)
{
- fprintf(dump_file, "%s ",
- get_static_name (index));
+ fprintf (dump_file, "%s ", get_static_name (index));
}
}
}
EXECUTE_IF_AND_IN_BITMAP (bits, ltrans_statics, 0, index, bi)
{
tree decl = (tree)splay_tree_lookup (reference_vars_to_consider, index)->value;
- lto_output_var_decl_index(ob->decl_state, ob->main_stream, decl);
+ lto_output_var_decl_index (ob->decl_state, ob->main_stream, decl);
}
}
class pass_ipa_reference : public ipa_opt_pass_d
{
public:
- pass_ipa_reference(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_reference, ctxt,
- NULL, /* generate_summary */
- NULL, /* write_summary */
- NULL, /* read_summary */
- ipa_reference_write_optimization_summary, /*
- write_optimization_summary */
- ipa_reference_read_optimization_summary, /*
- read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
- {}
+ pass_ipa_reference (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_reference, ctxt,
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ ipa_reference_write_optimization_summary, /*
+ write_optimization_summary */
+ ipa_reference_read_optimization_summary, /*
+ read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
+ {}
/* opt_pass methods: */
bool gate () { return gate_reference (); }
class pass_split_functions : public gimple_opt_pass
{
public:
- pass_split_functions(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_split_functions, ctxt)
+ pass_split_functions (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_split_functions, ctxt)
{}
/* opt_pass methods: */
class pass_feedback_split_functions : public gimple_opt_pass
{
public:
- pass_feedback_split_functions(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_feedback_split_functions, ctxt)
+ pass_feedback_split_functions (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_feedback_split_functions, ctxt)
{}
/* opt_pass methods: */
fprintf (out, "\n\n ordered call graph: %s\n", note);
for (i = count - 1; i >= 0; i--)
- dump_cgraph_node(dump_file, order[i]);
+ dump_cgraph_node (dump_file, order[i]);
fprintf (out, "\n");
- fflush(out);
+ fflush (out);
}
\f
if (!pointer_set_insert (reachable_call_targets,
cache_token))
{
- for (i = 0; i < targets.length(); i++)
+ for (i = 0; i < targets.length (); i++)
{
struct cgraph_node *n = targets[i];
make the edge direct. */
if (final)
{
- if (targets.length() <= 1)
+ if (targets.length () <= 1)
{
cgraph_node *target, *node = edge->caller;
if (targets.length () == 1)
struct varpool_node *vnode;
/* All aliases should be procssed at this point. */
- gcc_checking_assert (!alias_pairs || !alias_pairs->length());
+ gcc_checking_assert (!alias_pairs || !alias_pairs->length ());
FOR_EACH_FUNCTION (node)
{
class pass_ipa_function_and_variable_visibility : public simple_ipa_opt_pass
{
public:
- pass_ipa_function_and_variable_visibility(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_function_and_variable_visibility, ctxt)
+ pass_ipa_function_and_variable_visibility (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_function_and_variable_visibility,
+ ctxt)
{}
/* opt_pass methods: */
class pass_ipa_free_inline_summary : public simple_ipa_opt_pass
{
public:
- pass_ipa_free_inline_summary(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_free_inline_summary, ctxt)
+ pass_ipa_free_inline_summary (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_free_inline_summary, ctxt)
{}
/* opt_pass methods: */
class pass_ipa_whole_program_visibility : public ipa_opt_pass_d
{
public:
- pass_ipa_whole_program_visibility(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_whole_program_visibility, ctxt,
- NULL, /* generate_summary */
- NULL, /* write_summary */
- NULL, /* read_summary */
- NULL, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_whole_program_visibility (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_whole_program_visibility, ctxt,
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
class pass_ipa_cdtor_merge : public ipa_opt_pass_d
{
public:
- pass_ipa_cdtor_merge(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_cdtor_merge, ctxt,
- NULL, /* generate_summary */
- NULL, /* write_summary */
- NULL, /* read_summary */
- NULL, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_cdtor_merge (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_cdtor_merge, ctxt,
+ NULL, /* generate_summary */
+ NULL, /* write_summary */
+ NULL, /* read_summary */
+ NULL, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
mark_all_loops_for_removal ();
else
mark_loops_for_removal ();
- children_vec.create(last_basic_block + number_of_loops (cfun));
- removed_loop_vec.create(last_basic_block + number_of_loops (cfun));
+ children_vec.create (last_basic_block + number_of_loops (cfun));
+ removed_loop_vec.create (last_basic_block + number_of_loops (cfun));
remove_uneccesary_loop_nodes_from_loop_tree (ira_loop_tree_root);
children_vec.release ();
if (all_p)
static void
print_insn_chain (FILE *file, struct insn_chain *c)
{
- fprintf (file, "insn=%d, ", INSN_UID(c->insn));
+ fprintf (file, "insn=%d, ", INSN_UID (c->insn));
bitmap_print (file, &c->live_throughout, "live_throughout: ", ", ");
bitmap_print (file, &c->dead_or_set, "dead_or_set: ", "\n");
}
/* Update global register liveness information. */
FOR_EACH_BB (bb)
{
- if (REGNO_REG_SET_P(df_get_live_in (bb), regno))
+ if (REGNO_REG_SET_P (df_get_live_in (bb), regno))
SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
- if (REGNO_REG_SET_P(df_get_live_out (bb), regno))
+ if (REGNO_REG_SET_P (df_get_live_out (bb), regno))
SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);
}
}
class pass_ira : public rtl_opt_pass
{
public:
- pass_ira(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_ira, ctxt)
+ pass_ira (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_ira, ctxt)
{}
/* opt_pass methods: */
class pass_reload : public rtl_opt_pass
{
public:
- pass_reload(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_reload, ctxt)
+ pass_reload (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_reload, ctxt)
{}
/* opt_pass methods: */
class pass_cleanup_barriers : public rtl_opt_pass
{
public:
- pass_cleanup_barriers(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_cleanup_barriers, ctxt)
+ pass_cleanup_barriers (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_cleanup_barriers, ctxt)
{}
/* opt_pass methods: */
/* These CONST_CAST's are okay because prev_nonnote_insn just
returns its argument and we assign it to a const_rtx
variable. */
- for (prev = prev_nonnote_insn (CONST_CAST_RTX(insn));
+ for (prev = prev_nonnote_insn (CONST_CAST_RTX (insn));
prev != 0 && !LABEL_P (prev);
- prev = prev_nonnote_insn (CONST_CAST_RTX(prev)))
+ prev = prev_nonnote_insn (CONST_CAST_RTX (prev)))
{
const_rtx set = set_of (arg0, prev);
if (set && GET_CODE (set) == SET
|| !iter.fits_shwi ())
iter_rtx = const0_rtx;
else
- iter_rtx = GEN_INT (iter.to_shwi());
+ iter_rtx = GEN_INT (iter.to_shwi ());
init = gen_doloop_begin (counter_reg,
desc->const_iter ? desc->niter_expr : const0_rtx,
iter_rtx,
|| !iter.fits_shwi ())
iterations_max = const0_rtx;
else
- iterations_max = GEN_INT (iter.to_shwi());
+ iterations_max = GEN_INT (iter.to_shwi ());
level = get_loop_level (loop) + 1;
/* Generate looping insn. If the pattern FAILs then give up trying
class pass_loop2 : public rtl_opt_pass
{
public:
- pass_loop2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_loop2, ctxt)
+ pass_loop2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_loop2, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_loop_init : public rtl_opt_pass
{
public:
- pass_rtl_loop_init(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_loop_init, ctxt)
+ pass_rtl_loop_init (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_loop_init, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_loop_done : public rtl_opt_pass
{
public:
- pass_rtl_loop_done(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_loop_done, ctxt)
+ pass_rtl_loop_done (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_loop_done, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_move_loop_invariants : public rtl_opt_pass
{
public:
- pass_rtl_move_loop_invariants(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_move_loop_invariants, ctxt)
+ pass_rtl_move_loop_invariants (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_move_loop_invariants, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_unswitch : public rtl_opt_pass
{
public:
- pass_rtl_unswitch(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_unswitch, ctxt)
+ pass_rtl_unswitch (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_unswitch, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_unroll_and_peel_loops : public rtl_opt_pass
{
public:
- pass_rtl_unroll_and_peel_loops(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_unroll_and_peel_loops, ctxt)
+ pass_rtl_unroll_and_peel_loops (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_unroll_and_peel_loops, ctxt)
{}
/* opt_pass methods: */
class pass_rtl_doloop : public rtl_opt_pass
{
public:
- pass_rtl_doloop(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_doloop, ctxt)
+ pass_rtl_doloop (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_doloop, ctxt)
{}
/* opt_pass methods: */
static void
check_invariant_table_size (void)
{
- if (invariant_table_size < DF_DEFS_TABLE_SIZE())
+ if (invariant_table_size < DF_DEFS_TABLE_SIZE ())
{
unsigned int new_size = DF_DEFS_TABLE_SIZE () + (DF_DEFS_TABLE_SIZE () / 4);
invariant_table = XRESIZEVEC (struct invariant *, invariant_table, new_size);
return NULL;
def = defs->ref;
check_invariant_table_size ();
- if (!invariant_table[DF_REF_ID(def)])
+ if (!invariant_table[DF_REF_ID (def)])
return NULL;
def_bb = DF_REF_BB (def);
if (!dominated_by_p (CDI_DOMINATORS, bb, def_bb))
return NULL;
- return invariant_table[DF_REF_ID(def)];
+ return invariant_table[DF_REF_ID (def)];
}
/* Computes hash value for invariant expression X in INSN. */
def = defs->ref;
check_invariant_table_size ();
- inv = invariant_table[DF_REF_ID(def)];
+ inv = invariant_table[DF_REF_ID (def)];
if (!inv)
return false;
{
ref = df_find_def (insn, dest);
check_invariant_table_size ();
- invariant_table[DF_REF_ID(ref)] = inv;
+ invariant_table[DF_REF_ID (ref)] = inv;
}
}
static struct rtx_iv ** iv_ref_table;
/* Induction variable stored at the reference. */
-#define DF_REF_IV(REF) iv_ref_table[DF_REF_ID(REF)]
-#define DF_REF_IV_SET(REF, IV) iv_ref_table[DF_REF_ID(REF)] = (IV)
+#define DF_REF_IV(REF) iv_ref_table[DF_REF_ID (REF)]
+#define DF_REF_IV_SET(REF, IV) iv_ref_table[DF_REF_ID (REF)] = (IV)
/* The current loop. */
static void
check_iv_ref_table_size (void)
{
- if (iv_ref_table_size < DF_DEFS_TABLE_SIZE())
+ if (iv_ref_table_size < DF_DEFS_TABLE_SIZE ())
{
unsigned int new_size = DF_DEFS_TABLE_SIZE () + (DF_DEFS_TABLE_SIZE () / 4);
iv_ref_table = XRESIZEVEC (struct rtx_iv *, iv_ref_table, new_size);
class pass_lower_subreg : public rtl_opt_pass
{
public:
- pass_lower_subreg(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_lower_subreg, ctxt)
+ pass_lower_subreg (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_lower_subreg, ctxt)
{}
/* opt_pass methods: */
class pass_lower_subreg2 : public rtl_opt_pass
{
public:
- pass_lower_subreg2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_lower_subreg2, ctxt)
+ pass_lower_subreg2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_lower_subreg2, ctxt)
{}
/* opt_pass methods: */
if (!pointer_set_insert (reachable_call_targets,
cache_token))
{
- for (i = 0; i < targets.length(); i++)
+ for (i = 0; i < targets.length (); i++)
{
struct cgraph_node *callee = targets[i];
ib = lto_create_simple_input_block (file_data, LTO_section_refs,
&data, &len);
if (!ib)
- fatal_error("cannot find LTO section refs in %s", file_data->file_name);
+ fatal_error ("cannot find LTO section refs in %s",
+ file_data->file_name);
input_refs (ib, nodes);
lto_destroy_simple_input_block (file_data, LTO_section_refs,
ib, data, len);
index = streamer_read_hwi (ib);
}
- p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION(fn);
+ p_bb = ENTRY_BLOCK_PTR_FOR_FUNCTION (fn);
index = streamer_read_hwi (ib);
while (index != -1)
{
class pass_ipa_lto_gimple_out : public ipa_opt_pass_d
{
public:
- pass_ipa_lto_gimple_out(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_lto_gimple_out, ctxt,
- NULL, /* generate_summary */
- lto_output, /* write_summary */
- NULL, /* read_summary */
- lto_output, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_lto_gimple_out (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_lto_gimple_out, ctxt,
+ NULL, /* generate_summary */
+ lto_output, /* write_summary */
+ NULL, /* read_summary */
+ lto_output, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
&& !targetm.binds_local_p (t))
visibility = GCCPV_DEFAULT;
else
- switch (DECL_VISIBILITY(t))
+ switch (DECL_VISIBILITY (t))
{
case VISIBILITY_DEFAULT:
visibility = GCCPV_DEFAULT;
lto_output_decl_state_refs (ob, decl_state_stream, fn_out_state);
}
lto_write_stream (decl_state_stream);
- free(decl_state_stream);
+ free (decl_state_stream);
lto_write_stream (ob->main_stream);
lto_write_stream (ob->string_stream);
class pass_ipa_lto_finish_out : public ipa_opt_pass_d
{
public:
- pass_ipa_lto_finish_out(gcc::context *ctxt)
- : ipa_opt_pass_d(pass_data_ipa_lto_finish_out, ctxt,
- NULL, /* generate_summary */
- produce_asm_for_decls, /* write_summary */
- NULL, /* read_summary */
- produce_asm_for_decls, /* write_optimization_summary */
- NULL, /* read_optimization_summary */
- NULL, /* stmt_fixup */
- 0, /* function_transform_todo_flags_start */
- NULL, /* function_transform */
- NULL) /* variable_transform */
+ pass_ipa_lto_finish_out (gcc::context *ctxt)
+ : ipa_opt_pass_d (pass_data_ipa_lto_finish_out, ctxt,
+ NULL, /* generate_summary */
+ produce_asm_for_decls, /* write_summary */
+ NULL, /* read_summary */
+ produce_asm_for_decls, /* write_optimization_summary */
+ NULL, /* read_optimization_summary */
+ NULL, /* stmt_fixup */
+ 0, /* function_transform_todo_flags_start */
+ NULL, /* function_transform */
+ NULL) /* variable_transform */
{}
/* opt_pass methods: */
if (lto_mode == LTO_MODE_LTO)
{
- printf("%s\n", flto_out);
+ printf ("%s\n", flto_out);
free (flto_out);
flto_out = NULL;
}
{
char *dumpbase
= (char *) xmalloc (strlen (linker_output)
- + sizeof(DUMPBASE_SUFFIX) + 1);
+ + sizeof (DUMPBASE_SUFFIX) + 1);
snprintf (dumpbase,
- strlen (linker_output) + sizeof(DUMPBASE_SUFFIX),
+ strlen (linker_output) + sizeof (DUMPBASE_SUFFIX),
"%s.ltrans%u", linker_output, i);
argv_ptr[0] = dumpbase;
}
edge_type type, gcov_type weight, gcov_type cost,
gcov_type max_capacity)
{
- fixup_edge_p curr_edge = add_edge(fixup_graph, src, dest, cost);
+ fixup_edge_p curr_edge = add_edge (fixup_graph, src, dest, cost);
curr_edge->type = type;
curr_edge->weight = weight;
curr_edge->max_capacity = max_capacity;
class pass_mode_switching : public rtl_opt_pass
{
public:
- pass_mode_switching(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_mode_switching, ctxt)
+ pass_mode_switching (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_mode_switching, ctxt)
{}
/* opt_pass methods: */
class pass_sms : public rtl_opt_pass
{
public:
- pass_sms(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_sms, ctxt)
+ pass_sms (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_sms, ctxt)
{}
/* opt_pass methods: */
class pass_expand_omp : public gimple_opt_pass
{
public:
- pass_expand_omp(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_expand_omp, ctxt)
+ pass_expand_omp (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_expand_omp, ctxt)
{}
/* opt_pass methods: */
class pass_lower_omp : public gimple_opt_pass
{
public:
- pass_lower_omp(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_omp, ctxt)
+ pass_lower_omp (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_omp, ctxt)
{}
/* opt_pass methods: */
class pass_diagnose_omp_blocks : public gimple_opt_pass
{
public:
- pass_diagnose_omp_blocks(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_diagnose_omp_blocks, ctxt)
+ pass_diagnose_omp_blocks (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_diagnose_omp_blocks, ctxt)
{}
/* opt_pass methods: */
case FLOOR_DIV_EXPR:
case ROUND_DIV_EXPR:
case EXACT_DIV_EXPR:
- if (TYPE_SATURATING(type))
- return TYPE_UNSIGNED(type) ? usdiv_optab : ssdiv_optab;
+ if (TYPE_SATURATING (type))
+ return TYPE_UNSIGNED (type) ? usdiv_optab : ssdiv_optab;
return TYPE_UNSIGNED (type) ? udiv_optab : sdiv_optab;
case LSHIFT_EXPR:
gcc_assert (subtype == optab_scalar);
}
- if (TYPE_SATURATING(type))
- return TYPE_UNSIGNED(type) ? usashl_optab : ssashl_optab;
+ if (TYPE_SATURATING (type))
+ return TYPE_UNSIGNED (type) ? usashl_optab : ssashl_optab;
return ashl_optab;
case RSHIFT_EXPR:
{
case POINTER_PLUS_EXPR:
case PLUS_EXPR:
- if (TYPE_SATURATING(type))
- return TYPE_UNSIGNED(type) ? usadd_optab : ssadd_optab;
+ if (TYPE_SATURATING (type))
+ return TYPE_UNSIGNED (type) ? usadd_optab : ssadd_optab;
return trapv ? addv_optab : add_optab;
case MINUS_EXPR:
- if (TYPE_SATURATING(type))
- return TYPE_UNSIGNED(type) ? ussub_optab : sssub_optab;
+ if (TYPE_SATURATING (type))
+ return TYPE_UNSIGNED (type) ? ussub_optab : sssub_optab;
return trapv ? subv_optab : sub_optab;
case MULT_EXPR:
- if (TYPE_SATURATING(type))
- return TYPE_UNSIGNED(type) ? usmul_optab : ssmul_optab;
+ if (TYPE_SATURATING (type))
+ return TYPE_UNSIGNED (type) ? usmul_optab : ssmul_optab;
return trapv ? smulv_optab : smul_optab;
case NEGATE_EXPR:
- if (TYPE_SATURATING(type))
- return TYPE_UNSIGNED(type) ? usneg_optab : ssneg_optab;
+ if (TYPE_SATURATING (type))
+ return TYPE_UNSIGNED (type) ? usneg_optab : ssneg_optab;
return trapv ? negv_optab : neg_optab;
case ABS_EXPR:
fname = GET_MODE_NAME (fmode);
tname = GET_MODE_NAME (tmode);
- if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode))
+ if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode))
{
libfunc_name = dec_name;
suffix = dec_suffix;
fname = GET_MODE_NAME (fmode);
tname = GET_MODE_NAME (tmode);
- if (DECIMAL_FLOAT_MODE_P(fmode) || DECIMAL_FLOAT_MODE_P(tmode))
+ if (DECIMAL_FLOAT_MODE_P (fmode) || DECIMAL_FLOAT_MODE_P (tmode))
{
libfunc_name = dec_name;
suffix = dec_suffix;
/* If the size of the object is greater than word size on this target,
a default store will not be atomic, Try a mem_exchange and throw away
the result. If that doesn't work, don't do anything. */
- if (GET_MODE_PRECISION(mode) > BITS_PER_WORD)
+ if (GET_MODE_PRECISION (mode) > BITS_PER_WORD)
{
rtx target = maybe_emit_atomic_exchange (NULL_RTX, mem, val, model);
if (!target)
char c = *p;
while (c)
{
- if (IS_DIR_SEPARATOR(c))
+ if (IS_DIR_SEPARATOR (c))
{
base = p + 1;
dot = 0;
}
}
- printf( " %-*.*s %.*s\n", col_width, item_width, item, len, help);
+ printf (" %-*.*s %.*s\n", col_width, item_width, item, len, help);
item_width = 0;
while (help[len] == ' ')
len++;
public:
void *operator new (size_t sz);
- pass_manager(context *ctxt);
+ pass_manager (context *ctxt);
void register_pass (struct register_pass_info *pass_info);
void register_one_dump_file (struct opt_pass *pass);
return 0;
}
-opt_pass::opt_pass(const pass_data &data, context *ctxt)
- : pass_data(data),
- sub(NULL),
- next(NULL),
- static_pass_number(0),
- ctxt_(ctxt)
+opt_pass::opt_pass (const pass_data &data, context *ctxt)
+ : pass_data (data),
+ sub (NULL),
+ next (NULL),
+ static_pass_number (0),
+ ctxt_ (ctxt)
{
}
class pass_early_local_passes : public simple_ipa_opt_pass
{
public:
- pass_early_local_passes(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_early_local_passes, ctxt)
+ pass_early_local_passes (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_early_local_passes, ctxt)
{}
/* opt_pass methods: */
class pass_all_early_optimizations : public gimple_opt_pass
{
public:
- pass_all_early_optimizations(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_all_early_optimizations, ctxt)
+ pass_all_early_optimizations (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_all_early_optimizations, ctxt)
{}
/* opt_pass methods: */
class pass_all_optimizations : public gimple_opt_pass
{
public:
- pass_all_optimizations(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_all_optimizations, ctxt)
+ pass_all_optimizations (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_all_optimizations, ctxt)
{}
/* opt_pass methods: */
class pass_all_optimizations_g : public gimple_opt_pass
{
public:
- pass_all_optimizations_g(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_all_optimizations_g, ctxt)
+ pass_all_optimizations_g (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_all_optimizations_g, ctxt)
{}
/* opt_pass methods: */
class pass_rest_of_compilation : public rtl_opt_pass
{
public:
- pass_rest_of_compilation(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rest_of_compilation, ctxt)
+ pass_rest_of_compilation (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rest_of_compilation, ctxt)
{}
/* opt_pass methods: */
class pass_postreload : public rtl_opt_pass
{
public:
- pass_postreload(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_postreload, ctxt)
+ pass_postreload (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_postreload, ctxt)
{}
/* opt_pass methods: */
const char *pn;
bool is_on, is_really_on;
- is_on = pass->has_gate ? pass->gate() : true;
+ is_on = pass->has_gate ? pass->gate () : true;
is_really_on = override_gate_status (pass, current_function_decl, is_on);
if (pass->static_pass_number <= 0)
{
struct cgraph_node *n, *node = NULL;
- create_pass_tab();
+ create_pass_tab ();
FOR_EACH_FUNCTION (n)
if (DECL_STRUCT_FUNCTION (n->symbol.decl))
}
pass_manager::pass_manager (context *ctxt)
-: all_passes(NULL), all_small_ipa_passes(NULL), all_lowering_passes(NULL),
- all_regular_ipa_passes(NULL), all_lto_gen_passes(NULL),
- all_late_ipa_passes(NULL), passes_by_id(NULL), passes_by_id_size(0),
- ctxt_(ctxt)
+: all_passes (NULL), all_small_ipa_passes (NULL), all_lowering_passes (NULL),
+ all_regular_ipa_passes (NULL), all_lto_gen_passes (NULL),
+ all_late_ipa_passes (NULL), passes_by_id (NULL), passes_by_id_size (0),
+ ctxt_ (ctxt)
{
struct opt_pass **p;
if (!node->global.inlined_to && node->ipa_transforms_to_apply.exists ())
{
*(bool *)data = true;
- execute_all_ipa_transforms();
+ execute_all_ipa_transforms ();
rebuild_cgraph_edges ();
}
}
/* Check whether gate check should be avoided.
User controls the value of the gate through the parameter "gate_status". */
- gate_status = pass->has_gate ? pass->gate() : true;
+ gate_status = pass->has_gate ? pass->gate () : true;
gate_status = override_gate_status (pass, current_function_decl, gate_status);
/* Override gate with plugin. */
for (ci = plugin_callbacks[event]; ci; ci = ci->next)
fprintf (file, " %s", ci->plugin_name);
- putc('\n', file);
+ putc ('\n', file);
}
}
{
if (REG_P (SET_DEST (PATTERN (insn))))
/* A load. */
- return SET_DEST(PATTERN(insn));
+ return SET_DEST (PATTERN (insn));
else
{
/* A store. */
class pass_gcse2 : public rtl_opt_pass
{
public:
- pass_gcse2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_gcse2, ctxt)
+ pass_gcse2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_gcse2, ctxt)
{}
/* opt_pass methods: */
class pass_postreload_cse : public rtl_opt_pass
{
public:
- pass_postreload_cse(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_postreload_cse, ctxt)
+ pass_postreload_cse (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_postreload_cse, ctxt)
{}
/* opt_pass methods: */
class pass_profile : public gimple_opt_pass
{
public:
- pass_profile(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_profile, ctxt)
+ pass_profile (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_profile, ctxt)
{}
/* opt_pass methods: */
class pass_strip_predict_hints : public gimple_opt_pass
{
public:
- pass_strip_predict_hints(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_strip_predict_hints, ctxt)
+ pass_strip_predict_hints (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_strip_predict_hints, ctxt)
{}
/* opt_pass methods: */
const int len = strlen (std_prefix);
if (! filename_ncmp (path, std_prefix, len)
- && (IS_DIR_SEPARATOR(path[len])
+ && (IS_DIR_SEPARATOR (path[len])
|| path[len] == '\0')
&& key != 0)
{
format_decoder (),
emitted_prefix (),
need_newline (),
- translate_identifiers(true),
+ translate_identifiers (true),
show_color ()
{
pp_line_cutoff (this) = l;
redundant with line number information and do not print anything
when there is no location information available. */
if (INSN_LOCATION (in_rtx) && insn_file (in_rtx))
- fprintf(outfile, " %s:%i", insn_file (in_rtx), insn_line (in_rtx));
+ fprintf (outfile, " %s:%i", insn_file (in_rtx),
+ insn_line (in_rtx));
#endif
}
else if (i == 6 && GET_CODE (in_rtx) == ASM_OPERANDS)
if (ch >= ' ' && ch < 127)
putc (ch, file);
else
- fprintf(file, "\\%03o", ch & 0xFF);
+ fprintf (file, "\\%03o", ch & 0xFF);
}
fputc ('\"', file);
}
if (!counts)
return NULL;
- get_working_sets();
+ get_working_sets ();
if (dump_file && profile_info)
- fprintf(dump_file, "Merged %u profiles with maximal count %u.\n",
- profile_info->runs, (unsigned) profile_info->sum_max);
+ fprintf (dump_file, "Merged %u profiles with maximal count %u.\n",
+ profile_info->runs, (unsigned) profile_info->sum_max);
return counts;
}
unsigned num_edges, ignored_edges;
unsigned num_instrumented;
struct edge_list *el;
- histogram_values values = histogram_values();
+ histogram_values values = histogram_values ();
unsigned cfg_checksum, lineno_checksum;
total_num_times_called++;
if (*p == ',')
p++;
- while (ISSPACE(*p))
+ while (ISSPACE (*p))
p++;
if (*p == '\0')
gcc_unreachable ();
}
- if (sizeof(unsigned long) > sizeof(unsigned int))
+ if (sizeof (unsigned long) > sizeof (unsigned int))
for (i = 0; i < SIGSZ; ++i)
{
unsigned long s = r->sig[i];
/* Verify the guess. */
extern char test_real_width
- [sizeof(REAL_VALUE_TYPE) <= REAL_WIDTH*sizeof(HOST_WIDE_INT) ? 1 : -1];
+ [sizeof (REAL_VALUE_TYPE) <= REAL_WIDTH * sizeof (HOST_WIDE_INT) ? 1 : -1];
/* Calculate the format for CONST_DOUBLE. We need as many slots as
are necessary to overlay a REAL_VALUE_TYPE on them. This could be
class pass_peephole2 : public rtl_opt_pass
{
public:
- pass_peephole2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_peephole2, ctxt)
+ pass_peephole2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_peephole2, ctxt)
{}
/* opt_pass methods: */
class pass_split_all_insns : public rtl_opt_pass
{
public:
- pass_split_all_insns(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_split_all_insns, ctxt)
+ pass_split_all_insns (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_split_all_insns, ctxt)
{}
/* opt_pass methods: */
class pass_split_after_reload : public rtl_opt_pass
{
public:
- pass_split_after_reload(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_split_after_reload, ctxt)
+ pass_split_after_reload (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_split_after_reload, ctxt)
{}
/* opt_pass methods: */
class pass_split_before_regstack : public rtl_opt_pass
{
public:
- pass_split_before_regstack(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_split_before_regstack, ctxt)
+ pass_split_before_regstack (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_split_before_regstack, ctxt)
{}
/* opt_pass methods: */
class pass_split_before_sched2 : public rtl_opt_pass
{
public:
- pass_split_before_sched2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_split_before_sched2, ctxt)
+ pass_split_before_sched2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_split_before_sched2, ctxt)
{}
/* opt_pass methods: */
class pass_split_for_shorten_branches : public rtl_opt_pass
{
public:
- pass_split_for_shorten_branches(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_split_for_shorten_branches, ctxt)
+ pass_split_for_shorten_branches (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_split_for_shorten_branches, ctxt)
{}
/* opt_pass methods: */
/* Second, make sure the reaching definitions don't feed another and
different extension. FIXME: this obviously can be improved. */
for (def = defs; def; def = def->next)
- if ((idx = def_map[INSN_UID(DF_REF_INSN (def->ref))])
+ if ((idx = def_map[INSN_UID (DF_REF_INSN (def->ref))])
&& (cand = &(*insn_list)[idx - 1])
&& cand->code != code)
{
idx = insn_list->length ();
for (def = defs; def; def = def->next)
- def_map[INSN_UID(DF_REF_INSN (def->ref))] = idx;
+ def_map[INSN_UID (DF_REF_INSN (def->ref))] = idx;
}
}
class pass_ree : public rtl_opt_pass
{
public:
- pass_ree(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_ree, ctxt)
+ pass_ree (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_ree, ctxt)
{}
/* opt_pass methods: */
static void remove_regno_note (rtx, enum reg_note, unsigned int);
static int get_hard_regnum (stack_ptr, rtx);
static rtx emit_pop_insn (rtx, stack_ptr, rtx, enum emit_where);
-static void swap_to_top(rtx, stack_ptr, rtx, rtx);
+static void swap_to_top (rtx, stack_ptr, rtx, rtx);
static bool move_for_stack_reg (rtx, stack_ptr, rtx);
static bool move_nan_for_stack_reg (rtx, stack_ptr, rtx);
static int swap_rtx_condition_1 (rtx);
class pass_stack_regs : public rtl_opt_pass
{
public:
- pass_stack_regs(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_stack_regs, ctxt)
+ pass_stack_regs (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_stack_regs, ctxt)
{}
/* opt_pass methods: */
class pass_stack_regs_run : public rtl_opt_pass
{
public:
- pass_stack_regs_run(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_stack_regs_run, ctxt)
+ pass_stack_regs_run (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_stack_regs_run, ctxt)
{}
/* opt_pass methods: */
class pass_cprop_hardreg : public rtl_opt_pass
{
public:
- pass_cprop_hardreg(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_cprop_hardreg, ctxt)
+ pass_cprop_hardreg (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_cprop_hardreg, ctxt)
{}
/* opt_pass methods: */
}
}
- COPY_HARD_REG_SET(call_fixed_reg_set, fixed_reg_set);
+ COPY_HARD_REG_SET (call_fixed_reg_set, fixed_reg_set);
/* Preserve global registers if called more than once. */
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
for (j = 0; j < MAX_MACHINE_MODE; j++)
- hard_regno_nregs[i][j] = HARD_REGNO_NREGS(i, (enum machine_mode)j);
+ hard_regno_nregs[i][j] = HARD_REGNO_NREGS (i, (enum machine_mode)j);
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
class pass_reginfo_init : public rtl_opt_pass
{
public:
- pass_reginfo_init(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_reginfo_init, ctxt)
+ pass_reginfo_init (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_reginfo_init, ctxt)
{}
/* opt_pass methods: */
class pass_regmove : public rtl_opt_pass
{
public:
- pass_regmove(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_regmove, ctxt)
+ pass_regmove (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_regmove, ctxt)
{}
/* opt_pass methods: */
class pass_regrename : public rtl_opt_pass
{
public:
- pass_regrename(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_regrename, ctxt)
+ pass_regrename (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_regrename, ctxt)
{}
/* opt_pass methods: */
/* Indexed by n, gives number of times (REG n) is used or set. */
static inline int
-REG_N_REFS(int regno)
+REG_N_REFS (int regno)
{
return regstat_n_sets_and_refs[regno].refs;
}
while (link)
{
if (REG_NOTE_KIND (link) == REG_DEAD)
- REG_N_DEATHS(REGNO (XEXP (link, 0)))++;
+ REG_N_DEATHS (REGNO (XEXP (link, 0)))++;
link = XEXP (link, 1);
}
return;
lim = end_hard_regno (mode, i);
while (i < lim)
- df_set_regs_ever_live(i++, true);
+ df_set_regs_ever_live (i++, true);
}
/* Mark the slots in regs_ever_live for the hard regs
&& ! (maybe_never && may_trap_or_fault_p (pat))
&& (trial = try_split (pat, trial, 0))
&& eligible_for_delay (insn, slots_filled, trial, flags)
- && ! can_throw_internal(trial))
+ && ! can_throw_internal (trial))
{
next_trial = next_nonnote_insn (trial);
delay_list = add_to_delay_list (trial, delay_list);
int flags;
/* Validate our arguments. */
- gcc_assert(condition != const_true_rtx || thread_if_true);
- gcc_assert(own_thread || thread_if_true);
+ gcc_assert (condition != const_true_rtx || thread_if_true);
+ gcc_assert (own_thread || thread_if_true);
flags = get_jump_flags (insn, JUMP_LABEL (insn));
class pass_delay_slots : public rtl_opt_pass
{
public:
- pass_delay_slots(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_delay_slots, ctxt)
+ pass_delay_slots (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_delay_slots, ctxt)
{}
/* opt_pass methods: */
class pass_machine_reorg : public rtl_opt_pass
{
public:
- pass_machine_reorg(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_machine_reorg, ctxt)
+ pass_machine_reorg (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_machine_reorg, ctxt)
{}
/* opt_pass methods: */
a LABEL_REF, it isn't sharable. */
return (GET_CODE (XEXP (orig, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
- && CONST_INT_P(XEXP (XEXP (orig, 0), 1)));
+ && CONST_INT_P (XEXP (XEXP (orig, 0), 1)));
}
if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \
rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
__FUNCTION__); \
- if (GET_RTX_FORMAT(_code)[_n] != C1) \
+ if (GET_RTX_FORMAT (_code)[_n] != C1) \
rtl_check_failed_type1 (_rtx, _n, C1, __FILE__, __LINE__, \
__FUNCTION__); \
&_rtx->u.fld[_n]; }))
if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \
rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
__FUNCTION__); \
- if (GET_RTX_FORMAT(_code)[_n] != C1 \
- && GET_RTX_FORMAT(_code)[_n] != C2) \
+ if (GET_RTX_FORMAT (_code)[_n] != C1 \
+ && GET_RTX_FORMAT (_code)[_n] != C2) \
rtl_check_failed_type2 (_rtx, _n, C1, C2, __FILE__, __LINE__, \
__FUNCTION__); \
&_rtx->u.fld[_n]; }))
if (_n < 0 || _n >= GET_RTX_LENGTH (_code)) \
rtl_check_failed_bounds (_rtx, _n, __FILE__, __LINE__, \
__FUNCTION__); \
- if (GET_RTX_FORMAT(_code)[_n] != 'w') \
+ if (GET_RTX_FORMAT (_code)[_n] != 'w') \
rtl_check_failed_type1 (_rtx, _n, 'w', __FILE__, __LINE__, \
__FUNCTION__); \
&_rtx->u.hwint[_n]; }))
#if defined ENABLE_RTL_FLAG_CHECKING && (GCC_VERSION >= 2007)
#define RTL_FLAG_CHECK1(NAME, RTX, C1) __extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1) \
+ if (GET_CODE (_rtx) != C1) \
rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define RTL_FLAG_CHECK2(NAME, RTX, C1, C2) __extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2) \
+ if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2) \
rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define RTL_FLAG_CHECK3(NAME, RTX, C1, C2, C3) __extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
- && GET_CODE(_rtx) != C3) \
+ if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2 \
+ && GET_CODE (_rtx) != C3) \
rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define RTL_FLAG_CHECK4(NAME, RTX, C1, C2, C3, C4) __extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
- && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4) \
+ if (GET_CODE (_rtx) != C1 && GET_CODE(_rtx) != C2 \
+ && GET_CODE (_rtx) != C3 && GET_CODE(_rtx) != C4) \
rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define RTL_FLAG_CHECK5(NAME, RTX, C1, C2, C3, C4, C5) __extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
- && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
- && GET_CODE(_rtx) != C5) \
+ if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \
+ && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \
+ && GET_CODE (_rtx) != C5) \
rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define RTL_FLAG_CHECK6(NAME, RTX, C1, C2, C3, C4, C5, C6) \
__extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
- && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
- && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6) \
+ if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \
+ && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \
+ && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6) \
rtl_check_failed_flag (NAME,_rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define RTL_FLAG_CHECK7(NAME, RTX, C1, C2, C3, C4, C5, C6, C7) \
__extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
- && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
- && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
- && GET_CODE(_rtx) != C7) \
+ if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \
+ && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \
+ && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6 \
+ && GET_CODE (_rtx) != C7) \
rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define RTL_FLAG_CHECK8(NAME, RTX, C1, C2, C3, C4, C5, C6, C7, C8) \
__extension__ \
({ __typeof (RTX) const _rtx = (RTX); \
- if (GET_CODE(_rtx) != C1 && GET_CODE(_rtx) != C2 \
- && GET_CODE(_rtx) != C3 && GET_CODE(_rtx) != C4 \
- && GET_CODE(_rtx) != C5 && GET_CODE(_rtx) != C6 \
- && GET_CODE(_rtx) != C7 && GET_CODE(_rtx) != C8) \
+ if (GET_CODE (_rtx) != C1 && GET_CODE (_rtx) != C2 \
+ && GET_CODE (_rtx) != C3 && GET_CODE (_rtx) != C4 \
+ && GET_CODE (_rtx) != C5 && GET_CODE (_rtx) != C6 \
+ && GET_CODE (_rtx) != C7 && GET_CODE (_rtx) != C8) \
rtl_check_failed_flag (NAME, _rtx, __FILE__, __LINE__, \
__FUNCTION__); \
_rtx; })
#define INSN_CODE(INSN) XINT (INSN, 6)
#define RTX_FRAME_RELATED_P(RTX) \
- (RTL_FLAG_CHECK6("RTX_FRAME_RELATED_P", (RTX), DEBUG_INSN, INSN, \
- CALL_INSN, JUMP_INSN, BARRIER, SET)->frame_related)
+ (RTL_FLAG_CHECK6 ("RTX_FRAME_RELATED_P", (RTX), DEBUG_INSN, INSN, \
+ CALL_INSN, JUMP_INSN, BARRIER, SET)->frame_related)
/* 1 if RTX is an insn that has been deleted. */
#define INSN_DELETED_P(RTX) \
- (RTL_FLAG_CHECK8("INSN_DELETED_P", (RTX), DEBUG_INSN, INSN, \
- CALL_INSN, JUMP_INSN, JUMP_TABLE_DATA, \
- CODE_LABEL, BARRIER, NOTE)->volatil)
+ (RTL_FLAG_CHECK8 ("INSN_DELETED_P", (RTX), DEBUG_INSN, INSN, \
+ CALL_INSN, JUMP_INSN, JUMP_TABLE_DATA, \
+ CODE_LABEL, BARRIER, NOTE)->volatil)
/* 1 if RTX is a call to a const function. Built from ECF_CONST and
TREE_READONLY. */
#define RTL_CONST_CALL_P(RTX) \
- (RTL_FLAG_CHECK1("RTL_CONST_CALL_P", (RTX), CALL_INSN)->unchanging)
+ (RTL_FLAG_CHECK1 ("RTL_CONST_CALL_P", (RTX), CALL_INSN)->unchanging)
/* 1 if RTX is a call to a pure function. Built from ECF_PURE and
DECL_PURE_P. */
#define RTL_PURE_CALL_P(RTX) \
- (RTL_FLAG_CHECK1("RTL_PURE_CALL_P", (RTX), CALL_INSN)->return_val)
+ (RTL_FLAG_CHECK1 ("RTL_PURE_CALL_P", (RTX), CALL_INSN)->return_val)
/* 1 if RTX is a call to a const or pure function. */
#define RTL_CONST_OR_PURE_CALL_P(RTX) \
- (RTL_CONST_CALL_P(RTX) || RTL_PURE_CALL_P(RTX))
+ (RTL_CONST_CALL_P (RTX) || RTL_PURE_CALL_P (RTX))
/* 1 if RTX is a call to a looping const or pure function. Built from
ECF_LOOPING_CONST_OR_PURE and DECL_LOOPING_CONST_OR_PURE_P. */
#define RTL_LOOPING_CONST_OR_PURE_CALL_P(RTX) \
- (RTL_FLAG_CHECK1("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN)->call)
+ (RTL_FLAG_CHECK1 ("CONST_OR_PURE_CALL_P", (RTX), CALL_INSN)->call)
/* 1 if RTX is a call_insn for a sibling call. */
#define SIBLING_CALL_P(RTX) \
- (RTL_FLAG_CHECK1("SIBLING_CALL_P", (RTX), CALL_INSN)->jump)
+ (RTL_FLAG_CHECK1 ("SIBLING_CALL_P", (RTX), CALL_INSN)->jump)
/* 1 if RTX is a jump_insn, call_insn, or insn that is an annulling branch. */
#define INSN_ANNULLED_BRANCH_P(RTX) \
- (RTL_FLAG_CHECK1("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN)->unchanging)
+ (RTL_FLAG_CHECK1 ("INSN_ANNULLED_BRANCH_P", (RTX), JUMP_INSN)->unchanging)
/* 1 if RTX is an insn in a delay slot and is from the target of the branch.
If the branch insn has INSN_ANNULLED_BRANCH_P set, this insn should only be
executed if the branch is taken. For annulled branches with this bit
clear, the insn should be executed only if the branch is not taken. */
#define INSN_FROM_TARGET_P(RTX) \
- (RTL_FLAG_CHECK3("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, CALL_INSN)->in_struct)
+ (RTL_FLAG_CHECK3 ("INSN_FROM_TARGET_P", (RTX), INSN, JUMP_INSN, \
+ CALL_INSN)->in_struct)
/* In an ADDR_DIFF_VEC, the flags for RTX for use by branch shortening.
See the comments for ADDR_DIFF_VEC in rtl.def. */
-#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS(RTX, 4)
+#define ADDR_DIFF_VEC_FLAGS(RTX) X0ADVFLAGS (RTX, 4)
/* In a VALUE, the value cselib has assigned to RTX.
This is a "struct cselib_val_struct", see cselib.h. */
-#define CSELIB_VAL_PTR(RTX) X0CSELIB(RTX, 0)
+#define CSELIB_VAL_PTR(RTX) X0CSELIB (RTX, 0)
/* Holds a list of notes on what this insn does to various REGs.
It is a chain of EXPR_LIST rtx's, where the second operand is the
/* 1 if RTX is emitted after a call, but it should take effect before
the call returns. */
#define NOTE_DURING_CALL_P(RTX) \
- (RTL_FLAG_CHECK1("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call)
+ (RTL_FLAG_CHECK1 ("NOTE_VAR_LOCATION_DURING_CALL_P", (RTX), NOTE)->call)
/* DEBUG_EXPR_DECL corresponding to a DEBUG_EXPR RTX. */
#define DEBUG_EXPR_TREE_DECL(RTX) XCTREE (RTX, 0, DEBUG_EXPR)
/* For a REG rtx, REGNO extracts the register number. REGNO can only
be used on RHS. Use SET_REGNO to change the value. */
#define REGNO(RTX) (rhs_regno(RTX))
-#define SET_REGNO(RTX,N) (df_ref_change_reg_with_loc (REGNO(RTX), N, RTX), XCUINT (RTX, 0, REG) = N)
+#define SET_REGNO(RTX,N) \
+ (df_ref_change_reg_with_loc (REGNO (RTX), N, RTX), XCUINT (RTX, 0, REG) = N)
#define SET_REGNO_RAW(RTX,N) (XCUINT (RTX, 0, REG) = N)
/* ORIGINAL_REGNO holds the number the register originally had; for a
/* 1 if RTX is a reg or parallel that is the current function's return
value. */
#define REG_FUNCTION_VALUE_P(RTX) \
- (RTL_FLAG_CHECK2("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val)
+ (RTL_FLAG_CHECK2 ("REG_FUNCTION_VALUE_P", (RTX), REG, PARALLEL)->return_val)
/* 1 if RTX is a reg that corresponds to a variable declared by the user. */
#define REG_USERVAR_P(RTX) \
- (RTL_FLAG_CHECK1("REG_USERVAR_P", (RTX), REG)->volatil)
+ (RTL_FLAG_CHECK1 ("REG_USERVAR_P", (RTX), REG)->volatil)
/* 1 if RTX is a reg that holds a pointer value. */
#define REG_POINTER(RTX) \
- (RTL_FLAG_CHECK1("REG_POINTER", (RTX), REG)->frame_related)
+ (RTL_FLAG_CHECK1 ("REG_POINTER", (RTX), REG)->frame_related)
/* 1 if RTX is a mem that holds a pointer value. */
#define MEM_POINTER(RTX) \
- (RTL_FLAG_CHECK1("MEM_POINTER", (RTX), MEM)->frame_related)
+ (RTL_FLAG_CHECK1 ("MEM_POINTER", (RTX), MEM)->frame_related)
/* 1 if the given register REG corresponds to a hard register. */
#define HARD_REGISTER_P(REG) (HARD_REGISTER_NUM_P (REGNO (REG)))
#define HARD_REGISTER_NUM_P(REG_NO) ((REG_NO) < FIRST_PSEUDO_REGISTER)
/* For a CONST_INT rtx, INTVAL extracts the integer. */
-#define INTVAL(RTX) XCWINT(RTX, 0, CONST_INT)
+#define INTVAL(RTX) XCWINT (RTX, 0, CONST_INT)
#define UINTVAL(RTX) ((unsigned HOST_WIDE_INT) INTVAL (RTX))
/* For a CONST_DOUBLE:
#define CONST_FIXED_VALUE(r) \
((const struct fixed_value *) XCNMPFV (r, CONST_FIXED, VOIDmode))
#define CONST_FIXED_VALUE_HIGH(r) \
- ((HOST_WIDE_INT) (CONST_FIXED_VALUE(r)->data.high))
+ ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.high))
#define CONST_FIXED_VALUE_LOW(r) \
- ((HOST_WIDE_INT) (CONST_FIXED_VALUE(r)->data.low))
+ ((HOST_WIDE_INT) (CONST_FIXED_VALUE (r)->data.low))
/* For a CONST_VECTOR, return element #n. */
#define CONST_VECTOR_ELT(RTX, N) XCVECEXP (RTX, 0, N, CONST_VECTOR)
when assigning to SUBREG_REG. */
#define SUBREG_PROMOTED_VAR_P(RTX) \
- (RTL_FLAG_CHECK1("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct)
+ (RTL_FLAG_CHECK1 ("SUBREG_PROMOTED", (RTX), SUBREG)->in_struct)
#define SUBREG_PROMOTED_UNSIGNED_SET(RTX, VAL) \
do { \
- rtx const _rtx = RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_SET", (RTX), SUBREG); \
+ rtx const _rtx = RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_UNSIGNED_SET", \
+ (RTX), SUBREG); \
if ((VAL) < 0) \
_rtx->volatil = 1; \
else { \
emit special code (ptr_extend insns) on some architectures. */
#define SUBREG_PROMOTED_UNSIGNED_P(RTX) \
- ((RTL_FLAG_CHECK1("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) \
+ ((RTL_FLAG_CHECK1 ("SUBREG_PROMOTED_UNSIGNED_P", (RTX), SUBREG)->volatil) \
? -1 : (int) (RTX)->unchanging)
/* True if the subreg was generated by LRA for reload insns. Such
subregs are valid only during LRA. */
#define LRA_SUBREG_P(RTX) \
- (RTL_FLAG_CHECK1("LRA_SUBREG_P", (RTX), SUBREG)->jump)
+ (RTL_FLAG_CHECK1 ("LRA_SUBREG_P", (RTX), SUBREG)->jump)
/* Access various components of an ASM_OPERANDS rtx. */
/* 1 if RTX is a mem that is statically allocated in read-only memory. */
#define MEM_READONLY_P(RTX) \
- (RTL_FLAG_CHECK1("MEM_READONLY_P", (RTX), MEM)->unchanging)
+ (RTL_FLAG_CHECK1 ("MEM_READONLY_P", (RTX), MEM)->unchanging)
/* 1 if RTX is a mem and we should keep the alias set for this mem
unchanged when we access a component. Set to 1, or example, when we
are already in a non-addressable component of an aggregate. */
#define MEM_KEEP_ALIAS_SET_P(RTX) \
- (RTL_FLAG_CHECK1("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump)
+ (RTL_FLAG_CHECK1 ("MEM_KEEP_ALIAS_SET_P", (RTX), MEM)->jump)
/* 1 if RTX is a mem or asm_operand for a volatile reference. */
#define MEM_VOLATILE_P(RTX) \
- (RTL_FLAG_CHECK3("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \
- ASM_INPUT)->volatil)
+ (RTL_FLAG_CHECK3 ("MEM_VOLATILE_P", (RTX), MEM, ASM_OPERANDS, \
+ ASM_INPUT)->volatil)
/* 1 if RTX is a mem that cannot trap. */
#define MEM_NOTRAP_P(RTX) \
- (RTL_FLAG_CHECK1("MEM_NOTRAP_P", (RTX), MEM)->call)
+ (RTL_FLAG_CHECK1 ("MEM_NOTRAP_P", (RTX), MEM)->call)
/* The memory attribute block. We provide access macros for each value
in the block and provide defaults if none specified. */
/* Likewise in an expr_list for a REG_LABEL_OPERAND or
REG_LABEL_TARGET note. */
#define LABEL_REF_NONLOCAL_P(RTX) \
- (RTL_FLAG_CHECK1("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil)
+ (RTL_FLAG_CHECK1 ("LABEL_REF_NONLOCAL_P", (RTX), LABEL_REF)->volatil)
/* 1 if RTX is a code_label that should always be considered to be needed. */
#define LABEL_PRESERVE_P(RTX) \
- (RTL_FLAG_CHECK2("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct)
+ (RTL_FLAG_CHECK2 ("LABEL_PRESERVE_P", (RTX), CODE_LABEL, NOTE)->in_struct)
/* During sched, 1 if RTX is an insn that must be scheduled together
with the preceding insn. */
#define SCHED_GROUP_P(RTX) \
- (RTL_FLAG_CHECK4("SCHED_GROUP_P", (RTX), DEBUG_INSN, INSN, \
- JUMP_INSN, CALL_INSN \
- )->in_struct)
+ (RTL_FLAG_CHECK4 ("SCHED_GROUP_P", (RTX), DEBUG_INSN, INSN, \
+ JUMP_INSN, CALL_INSN)->in_struct)
/* For a SET rtx, SET_DEST is the place that is set
and SET_SRC is the value it is set to. */
-#define SET_DEST(RTX) XC2EXP(RTX, 0, SET, CLOBBER)
-#define SET_SRC(RTX) XCEXP(RTX, 1, SET)
+#define SET_DEST(RTX) XC2EXP (RTX, 0, SET, CLOBBER)
+#define SET_SRC(RTX) XCEXP (RTX, 1, SET)
#define SET_IS_RETURN_P(RTX) \
- (RTL_FLAG_CHECK1("SET_IS_RETURN_P", (RTX), SET)->jump)
+ (RTL_FLAG_CHECK1 ("SET_IS_RETURN_P", (RTX), SET)->jump)
/* For a TRAP_IF rtx, TRAP_CONDITION is an expression. */
#define TRAP_CONDITION(RTX) XCEXP (RTX, 0, TRAP_IF)
/* 1 if RTX is a symbol_ref that addresses this function's rtl
constants pool. */
#define CONSTANT_POOL_ADDRESS_P(RTX) \
- (RTL_FLAG_CHECK1("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging)
+ (RTL_FLAG_CHECK1 ("CONSTANT_POOL_ADDRESS_P", (RTX), SYMBOL_REF)->unchanging)
/* 1 if RTX is a symbol_ref that addresses a value in the file's
tree constant pool. This information is private to varasm.c. */
#define TREE_CONSTANT_POOL_ADDRESS_P(RTX) \
- (RTL_FLAG_CHECK1("TREE_CONSTANT_POOL_ADDRESS_P", \
- (RTX), SYMBOL_REF)->frame_related)
+ (RTL_FLAG_CHECK1 ("TREE_CONSTANT_POOL_ADDRESS_P", \
+ (RTX), SYMBOL_REF)->frame_related)
/* Used if RTX is a symbol_ref, for machine-specific purposes. */
#define SYMBOL_REF_FLAG(RTX) \
- (RTL_FLAG_CHECK1("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil)
+ (RTL_FLAG_CHECK1 ("SYMBOL_REF_FLAG", (RTX), SYMBOL_REF)->volatil)
/* 1 if RTX is a symbol_ref that has been the library function in
emit_library_call. */
#define SYMBOL_REF_USED(RTX) \
- (RTL_FLAG_CHECK1("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used)
+ (RTL_FLAG_CHECK1 ("SYMBOL_REF_USED", (RTX), SYMBOL_REF)->used)
/* 1 if RTX is a symbol_ref for a weak symbol. */
#define SYMBOL_REF_WEAK(RTX) \
- (RTL_FLAG_CHECK1("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val)
+ (RTL_FLAG_CHECK1 ("SYMBOL_REF_WEAK", (RTX), SYMBOL_REF)->return_val)
/* A pointer attached to the SYMBOL_REF; either SYMBOL_REF_DECL or
SYMBOL_REF_CONSTANT. */
/* True if RTX is flagged to be a scheduling barrier. */
#define PREFETCH_SCHEDULE_BARRIER_P(RTX) \
- (RTL_FLAG_CHECK1("PREFETCH_SCHEDULE_BARRIER_P", (RTX), PREFETCH)->volatil)
+ (RTL_FLAG_CHECK1 ("PREFETCH_SCHEDULE_BARRIER_P", (RTX), PREFETCH)->volatil)
/* Indicate whether the machine has any sort of auto increment addressing.
If not, we can avoid checking for REG_INC notes. */
extern bool insn_nothrow_p (const_rtx);
extern bool can_nonlocal_goto (const_rtx);
extern void copy_reg_eh_region_note_forward (rtx, rtx, rtx);
-extern void copy_reg_eh_region_note_backward(rtx, rtx, rtx);
+extern void copy_reg_eh_region_note_backward (rtx, rtx, rtx);
extern int inequality_comparisons_p (const_rtx);
extern rtx replace_rtx (rtx, rtx, rtx);
extern int replace_label (rtx *, void *);
/* This CONST_CAST is okay because next_nonnote_insn just
returns its argument and we assign it to a const_rtx
variable. */
- const_rtx i2 = next_nonnote_insn (CONST_CAST_RTX(insn));
+ const_rtx i2 = next_nonnote_insn (CONST_CAST_RTX (insn));
if (i2 && keep_with_call_p (i2))
return true;
}
#if GCC_VERSION >= 3400
# if SBITMAP_ELT_BITS == HOST_BITS_PER_LONG
-# define do_popcount(x) __builtin_popcountl(x)
+# define do_popcount(x) __builtin_popcountl (x)
# elif SBITMAP_ELT_BITS == HOST_BITS_PER_LONGLONG
-# define do_popcount(x) __builtin_popcountll(x)
+# define do_popcount(x) __builtin_popcountll (x)
# else
# error "internal error: sbitmap.h and hwint.h are inconsistent"
# endif
#else
static unsigned long sbitmap_elt_popcount (SBITMAP_ELT_TYPE);
-# define do_popcount(x) sbitmap_elt_popcount((x))
+# define do_popcount(x) sbitmap_elt_popcount (x)
#endif
typedef SBITMAP_ELT_TYPE *sbitmap_ptr;
class pass_sched : public rtl_opt_pass
{
public:
- pass_sched(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_sched, ctxt)
+ pass_sched (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_sched, ctxt)
{}
/* opt_pass methods: */
class pass_sched2 : public rtl_opt_pass
{
public:
- pass_sched2(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_sched2, ctxt)
+ pass_sched2 (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_sched2, ctxt)
{}
/* opt_pass methods: */
#endif
#ifndef PUT_SDB_SCL
-#define PUT_SDB_SCL(a) fprintf(asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
+#define PUT_SDB_SCL(a) fprintf (asm_out_file, "\t.scl\t%d%s", (a), SDB_DELIM)
#endif
#ifndef PUT_SDB_INT_VAL
#endif
#ifndef PUT_SDB_PLAIN_DEF
-#define PUT_SDB_PLAIN_DEF(a) fprintf(asm_out_file,"\t.def\t.%s%s",a, SDB_DELIM)
+#define PUT_SDB_PLAIN_DEF(a) \
+ fprintf (asm_out_file, "\t.def\t.%s%s", a, SDB_DELIM)
#endif
#ifndef PUT_SDB_ENDEF
-#define PUT_SDB_ENDEF fputs("\t.endef\n", asm_out_file)
+#define PUT_SDB_ENDEF fputs ("\t.endef\n", asm_out_file)
#endif
#ifndef PUT_SDB_TYPE
-#define PUT_SDB_TYPE(a) fprintf(asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
+#define PUT_SDB_TYPE(a) fprintf (asm_out_file, "\t.type\t0%o%s", a, SDB_DELIM)
#endif
#ifndef PUT_SDB_SIZE
do { \
fprintf (asm_out_file, "\t.size\t" HOST_WIDE_INT_PRINT_DEC "%s", \
(HOST_WIDE_INT) (a), SDB_DELIM); \
- } while(0)
+ } while (0)
#endif
#ifndef PUT_SDB_START_DIM
-#define PUT_SDB_START_DIM fprintf(asm_out_file, "\t.dim\t")
+#define PUT_SDB_START_DIM fprintf (asm_out_file, "\t.dim\t")
#endif
#ifndef PUT_SDB_NEXT_DIM
-#define PUT_SDB_NEXT_DIM(a) fprintf(asm_out_file, "%d,", a)
+#define PUT_SDB_NEXT_DIM(a) fprintf (asm_out_file, "%d,", a)
#endif
#ifndef PUT_SDB_LAST_DIM
-#define PUT_SDB_LAST_DIM(a) fprintf(asm_out_file, "%d%s", a, SDB_DELIM)
+#define PUT_SDB_LAST_DIM(a) fprintf (asm_out_file, "%d%s", a, SDB_DELIM)
#endif
#ifndef PUT_SDB_TAG
{
basic_block ptr = BLOCK_FOR_INSN (insn);
- for(;;)
+ for (;;)
{
if (ptr == BLOCK_FOR_INSN (succ))
return true;
can't be moved up due to bookkeeping created during code motion to another
fence. See comment near the call to update_and_record_unavailable_insns
for the detailed explanations. */
-static vinsn_vec_t vec_bookkeeping_blocked_vinsns = vinsn_vec_t();
+static vinsn_vec_t vec_bookkeeping_blocked_vinsns = vinsn_vec_t ();
/* This vector has vinsns which are scheduled with renaming on the first fence
and then seen on the second. For expressions with such vinsns, target
availability information may be wrong. */
-static vinsn_vec_t vec_target_unavailable_vinsns = vinsn_vec_t();
+static vinsn_vec_t vec_target_unavailable_vinsns = vinsn_vec_t ();
/* Vector to store temporary nops inserted in move_op to prevent removal
of empty bbs. */
/* Bail out if mode is different or more than one register is used. */
if (GET_MODE (*cur_rtx) != GET_MODE (p->x)
|| (HARD_REGISTER_P (*cur_rtx)
- && hard_regno_nregs[REGNO(*cur_rtx)][GET_MODE (*cur_rtx)] > 1))
+ && hard_regno_nregs[REGNO (*cur_rtx)][GET_MODE (*cur_rtx)] > 1))
{
p->n = 0;
return 1;
unsigned int n_bytes = sizeof (struct sparseset_def)
+ ((n_elms - 1) * 2 * sizeof (SPARSESET_ELT_TYPE));
- sparseset set = XNEWVAR(struct sparseset_def, n_bytes);
+ sparseset set = XNEWVAR (struct sparseset_def, n_bytes);
/* Mark the sparseset as defined to silence some valgrind uninitialized
read errors when accessing set->sparse[n] when "n" is not, and never has
class pass_stack_ptr_mod : public rtl_opt_pass
{
public:
- pass_stack_ptr_mod(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_stack_ptr_mod, ctxt)
+ pass_stack_ptr_mod (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_stack_ptr_mod, ctxt)
{}
/* opt_pass methods: */
inline void
stats_counter_hasher::remove (value_type *v)
{
- free (CONST_CAST(char *, v->id));
+ free (CONST_CAST (char *, v->id));
free (v);
}
fputs (";; ", f);
if (high == low)
- fprintf(f, "%*s" HOST_WIDE_INT_PRINT_DEC,
- indent_step * indent_level, "", low);
+ fprintf (f, "%*s" HOST_WIDE_INT_PRINT_DEC,
+ indent_step * indent_level, "", low);
else
- fprintf(f, "%*s" HOST_WIDE_INT_PRINT_DEC " ... " HOST_WIDE_INT_PRINT_DEC,
- indent_step * indent_level, "", low, high);
+ fprintf (f, "%*s" HOST_WIDE_INT_PRINT_DEC " ... " HOST_WIDE_INT_PRINT_DEC,
+ indent_step * indent_level, "", low, high);
fputs ("\n", f);
dump_case_nodes (f, root->right, indent_step, indent_level);
int prob_sum = 0;
if (!bb)
return 0;
- FOR_EACH_EDGE(e, ei, bb->succs)
+ FOR_EACH_EDGE (e, ei, bb->succs)
prob_sum += e->probability;
return prob_sum;
}
rtx fallback_label = label_rtx (case_list->code_label);
rtx table_label = gen_label_rtx ();
bool has_gaps = false;
- edge default_edge = stmt_bb ? EDGE_SUCC(stmt_bb, 0) : NULL;
+ edge default_edge = stmt_bb ? EDGE_SUCC (stmt_bb, 0) : NULL;
int default_prob = default_edge ? default_edge->probability : 0;
int base = get_outgoing_edge_probs (stmt_bb);
bool try_with_tablejump = false;
{
edge e;
edge_iterator ei;
- FOR_EACH_EDGE(e, ei, bb->succs)
+ FOR_EACH_EDGE (e, ei, bb->succs)
e->aux = (void *)0;
}
/* Find the default case target label. */
default_label = label_rtx (CASE_LABEL (gimple_switch_default_label (stmt)));
- edge default_edge = EDGE_SUCC(bb, 0);
+ edge default_edge = EDGE_SUCC (bb, 0);
int default_prob = default_edge->probability;
/* Get upper and lower bounds of case values. */
/* Cause a new bitfield to be captured, either this time (if
currently a bitfield) or next time we see one. */
- if (!DECL_BIT_FIELD_TYPE(field)
+ if (!DECL_BIT_FIELD_TYPE (field)
|| integer_zerop (DECL_SIZE (field)))
rli->prev_field = NULL;
}
for (; x; x = XEXP (x, 1))
{
reg = XEXP (x, 0);
- if (regs_set[REGNO(reg)])
+ if (regs_set[REGNO (reg)])
return false;
}
class pass_rtl_store_motion : public rtl_opt_pass
{
public:
- pass_rtl_store_motion(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_rtl_store_motion, ctxt)
+ pass_rtl_store_motion (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_rtl_store_motion, ctxt)
{}
/* opt_pass methods: */
};
#define stream_write_tree(OB, EXPR, REF_P) \
- streamer_hooks.write_tree(OB, EXPR, REF_P, REF_P)
+ streamer_hooks.write_tree (OB, EXPR, REF_P, REF_P)
#define stream_write_tree_shallow_non_ref(OB, EXPR, REF_P) \
- streamer_hooks.write_tree(OB, EXPR, REF_P, false)
+ streamer_hooks.write_tree (OB, EXPR, REF_P, false)
#define stream_read_tree(IB, DATA_IN) \
- streamer_hooks.read_tree(IB, DATA_IN)
+ streamer_hooks.read_tree (IB, DATA_IN)
#define stream_input_location(BP, DATA_IN) \
- streamer_hooks.input_location(BP, DATA_IN)
+ streamer_hooks.input_location (BP, DATA_IN)
#define stream_output_location(OB, BP, LOC) \
- streamer_hooks.output_location(OB, BP, LOC)
+ streamer_hooks.output_location (OB, BP, LOC)
/* Streamer hooks. */
extern struct streamer_hooks streamer_hooks;
#ifndef va_copy
# ifdef __va_copy
-# define va_copy(d,s) __va_copy((d),(s))
+# define va_copy(d,s) __va_copy (d, s)
# else
# define va_copy(d,s) ((d) = (s))
# endif
#undef fopen
#undef freopen
-#define fopen(PATH,MODE) fopen_unlocked(PATH,MODE)
-#define fdopen(FILDES,MODE) fdopen_unlocked(FILDES,MODE)
-#define freopen(PATH,MODE,STREAM) freopen_unlocked(PATH,MODE,STREAM)
+#define fopen(PATH, MODE) fopen_unlocked (PATH, MODE)
+#define fdopen(FILDES, MODE) fdopen_unlocked (FILDES, MODE)
+#define freopen(PATH, MODE, STREAM) freopen_unlocked (PATH, MODE, STREAM)
/* The compiler is not a multi-threaded application and therefore we
do not have to use the locking functions. In fact, using the locking
/* The outer cast is needed to work around a bug in Cray C 5.0.3.0.
It is necessary at least when t == time_t. */
#define INTTYPE_MINIMUM(t) ((t) (INTTYPE_SIGNED (t) \
- ? ~ (t) 0 << (sizeof(t) * CHAR_BIT - 1) : (t) 0))
+ ? ~ (t) 0 << (sizeof (t) * CHAR_BIT - 1) : (t) 0))
#define INTTYPE_MAXIMUM(t) ((t) (~ (t) 0 - INTTYPE_MINIMUM (t)))
/* Use that infrastructure to provide a few constants. */
#endif
#if defined (HAVE_DECL_VSNPRINTF) && !HAVE_DECL_VSNPRINTF
-extern int vsnprintf(char *, size_t, const char *, va_list);
+extern int vsnprintf (char *, size_t, const char *, va_list);
#endif
#ifdef __cplusplus
/* Some systems have mkdir that takes a single argument. */
#ifdef MKDIR_TAKES_ONE_ARG
-# define mkdir(a,b) mkdir(a)
+# define mkdir(a,b) mkdir (a)
#endif
#ifndef HAVE_KILL
-# define kill(p,s) raise(s)
+# define kill(p,s) raise (s)
#endif
/* Provide a way to print an address via printf. */
((void)(!(EXPR) ? fancy_abort (__FILE__, __LINE__, __FUNCTION__), 0 : 0))
#elif (GCC_VERSION >= 4005)
#define gcc_assert(EXPR) \
- ((void)(__builtin_expect(!(EXPR), 0) ? __builtin_unreachable(), 0 : 0))
+ ((void)(__builtin_expect (!(EXPR), 0) ? __builtin_unreachable (), 0 : 0))
#else
/* Include EXPR, so that unused variable warnings do not occur. */
#define gcc_assert(EXPR) ((void)(0 && (EXPR)))
/* Use gcc_unreachable() to mark unreachable locations (like an
unreachable default case of a switch. Do not use gcc_assert(0). */
#if (GCC_VERSION >= 4005) && !ENABLE_ASSERT_CHECKING
-#define gcc_unreachable() __builtin_unreachable()
+#define gcc_unreachable() __builtin_unreachable ()
#else
#define gcc_unreachable() (fancy_abort (__FILE__, __LINE__, __FUNCTION__))
#endif
#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((TOTYPE)(FROMTYPE)(X))
#endif
#endif
-#define CONST_CAST(TYPE,X) CONST_CAST2(TYPE, const TYPE, (X))
-#define CONST_CAST_TREE(X) CONST_CAST(union tree_node *, (X))
-#define CONST_CAST_RTX(X) CONST_CAST(struct rtx_def *, (X))
-#define CONST_CAST_BB(X) CONST_CAST(struct basic_block_def *, (X))
-#define CONST_CAST_GIMPLE(X) CONST_CAST(union gimple_statement_d *, (X))
+#define CONST_CAST(TYPE,X) CONST_CAST2 (TYPE, const TYPE, (X))
+#define CONST_CAST_TREE(X) CONST_CAST (union tree_node *, (X))
+#define CONST_CAST_RTX(X) CONST_CAST (struct rtx_def *, (X))
+#define CONST_CAST_BB(X) CONST_CAST (struct basic_block_def *, (X))
+#define CONST_CAST_GIMPLE(X) CONST_CAST (union gimple_statement_d *, (X))
/* Activate certain diagnostics as warnings (not errors via the
-Werror flag). */
HOOK_VECTOR_END: Close a struct declaration, providing a member declarator
name for nested use. */
#ifndef HOOK_VECTOR_1
-#define HOOK_VECTOR_1(NAME, FRAGMENT) HOOKSTRUCT(FRAGMENT)
+#define HOOK_VECTOR_1(NAME, FRAGMENT) HOOKSTRUCT (FRAGMENT)
#endif
#define HOOK_VECTOR(INIT_NAME, SNAME) HOOK_VECTOR_1 (INIT_NAME, struct SNAME {)
#define HOOK_VECTOR_END(DECL_NAME) HOOK_VECTOR_1(,} DECL_NAME ;)
default_external_libcall (rtx fun ATTRIBUTE_UNUSED)
{
#ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
- ASM_OUTPUT_EXTERNAL_LIBCALL(asm_out_file, fun);
+ ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
#endif
}
mode for registers used in apply_builtin_return and apply_builtin_arg. */
enum machine_mode
-default_get_reg_raw_mode(int regno)
+default_get_reg_raw_mode (int regno)
{
return reg_raw_mode[regno];
}
extern int default_jump_align_max_skip (rtx);
extern section * default_function_section(tree decl, enum node_frequency freq,
bool startup, bool exit);
-extern enum machine_mode default_get_reg_raw_mode(int);
+extern enum machine_mode default_get_reg_raw_mode (int);
extern void *default_get_pch_validity (size_t *);
extern const char *default_pch_valid_p (const void *, size_t);
two string formats, "i.j.k" and "i.j" when k is zero. As of
gmp-4.3.0, GMP always uses the 3 number format. */
#define GCC_GMP_STRINGIFY_VERSION3(X) #X
-#define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X)
+#define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X)
#define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
#define GCC_GMP_VERSION \
GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
#if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
-#define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
- GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR)
+#define GCC_GMP_STRINGIFY_VERSION \
+ GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
+ GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR)
#else
-#define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \
- GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \
- GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL)
+#define GCC_GMP_STRINGIFY_VERSION \
+ GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
+ GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \
+ GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL)
#endif
fprintf (file,
file == stderr ? _(fmt2) : fmt2,
/* This must be done after global_init_params but before argument
processing. */
- init_ggc_heuristics();
+ init_ggc_heuristics ();
/* Create the singleton holder for global state.
Doing so also creates the pass manager and with it the passes. */
- g = new gcc::context();
+ g = new gcc::context ();
statistics_early_init ();
finish_params ();
class pass_tracer : public gimple_opt_pass
{
public:
- pass_tracer(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tracer, ctxt)
+ pass_tracer (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tracer, ctxt)
{}
/* opt_pass methods: */
class pass_diagnose_tm_blocks : public gimple_opt_pass
{
public:
- pass_diagnose_tm_blocks(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_diagnose_tm_blocks, ctxt)
+ pass_diagnose_tm_blocks (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_diagnose_tm_blocks, ctxt)
{}
/* opt_pass methods: */
/* If the transaction calls abort or if this is an outer transaction,
add an "over" label afterwards. */
if ((this_state & (GTMA_HAVE_ABORT))
- || (gimple_transaction_subcode(stmt) & GTMA_IS_OUTER))
+ || (gimple_transaction_subcode (stmt) & GTMA_IS_OUTER))
{
tree label = create_artificial_label (UNKNOWN_LOCATION);
gimple_transaction_set_label (stmt, label);
class pass_lower_tm : public gimple_opt_pass
{
public:
- pass_lower_tm(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_tm, ctxt)
+ pass_lower_tm (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_tm, ctxt)
{}
/* opt_pass methods: */
class pass_tm_init : public gimple_opt_pass
{
public:
- pass_tm_init(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tm_init, ctxt)
+ pass_tm_init (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tm_init, ctxt)
{}
/* opt_pass methods: */
ei->probability = PROB_ALWAYS;
et->probability = PROB_LIKELY;
ef->probability = PROB_UNLIKELY;
- et->count = apply_probability(test_bb->count, et->probability);
- ef->count = apply_probability(test_bb->count, ef->probability);
+ et->count = apply_probability (test_bb->count, et->probability);
+ ef->count = apply_probability (test_bb->count, ef->probability);
code_bb->count = et->count;
code_bb->frequency = EDGE_FREQUENCY (et);
fallthru_edge->flags = EDGE_FALSE_VALUE;
fallthru_edge->probability = PROB_VERY_LIKELY;
fallthru_edge->count
- = apply_probability(test_bb->count, fallthru_edge->probability);
+ = apply_probability (test_bb->count, fallthru_edge->probability);
// Abort/over edge.
redirect_edge_pred (abort_edge, test_bb);
abort_edge->flags = EDGE_TRUE_VALUE;
abort_edge->probability = PROB_VERY_UNLIKELY;
abort_edge->count
- = apply_probability(test_bb->count, abort_edge->probability);
+ = apply_probability (test_bb->count, abort_edge->probability);
transaction_bb = test_bb;
}
inst_edge->flags = EDGE_FALSE_VALUE;
inst_edge->probability = REG_BR_PROB_BASE / 2;
inst_edge->count
- = apply_probability(test_bb->count, inst_edge->probability);
+ = apply_probability (test_bb->count, inst_edge->probability);
redirect_edge_pred (uninst_edge, test_bb);
uninst_edge->flags = EDGE_TRUE_VALUE;
uninst_edge->probability = REG_BR_PROB_BASE / 2;
uninst_edge->count
- = apply_probability(test_bb->count, uninst_edge->probability);
+ = apply_probability (test_bb->count, uninst_edge->probability);
}
// If we have no previous special cases, and we have PHIs at the beginning
class pass_tm_mark : public gimple_opt_pass
{
public:
- pass_tm_mark(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tm_mark, ctxt)
+ pass_tm_mark (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tm_mark, ctxt)
{}
/* opt_pass methods: */
class pass_tm_edges : public gimple_opt_pass
{
public:
- pass_tm_edges(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tm_edges, ctxt)
+ pass_tm_edges (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tm_edges, ctxt)
{}
/* opt_pass methods: */
class pass_tm_memopt : public gimple_opt_pass
{
public:
- pass_tm_memopt(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tm_memopt, ctxt)
+ pass_tm_memopt (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tm_memopt, ctxt)
{}
/* opt_pass methods: */
if (find_tm_replacement_function (fn))
break;
- node = cgraph_get_node(fn);
+ node = cgraph_get_node (fn);
d = get_cg_data (&node, true);
/* Return true if irrevocable, but above all, believe
cgraph_create_edge (node, cgraph_get_create_node (gettm_fn), g, 0,
compute_call_stmt_bb_frequency (node->symbol.decl,
- gimple_bb(g)));
+ gimple_bb (g)));
/* Cast return value from tm_gettmclone* into appropriate function
pointer. */
static unsigned int
ipa_tm_execute (void)
{
- cgraph_node_queue tm_callees = cgraph_node_queue();
+ cgraph_node_queue tm_callees = cgraph_node_queue ();
/* List of functions that will go irrevocable. */
- cgraph_node_queue irr_worklist = cgraph_node_queue();
+ cgraph_node_queue irr_worklist = cgraph_node_queue ();
struct cgraph_node *node;
struct tm_ipa_cg_data *d;
class pass_ipa_tm : public simple_ipa_opt_pass
{
public:
- pass_ipa_tm(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_tm, ctxt)
+ pass_ipa_tm (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_tm, ctxt)
{}
/* opt_pass methods: */
TB_CODE comm_code;
};
-#define DEFTBCODE(code, str, help) { help, str, sizeof(str) - 1, code },
+#define DEFTBCODE(code, str, help) { help, str, sizeof (str) - 1, code },
static const struct tb_command tb_commands[] =
{
#include "tree-browser.def"
class pass_call_cdce : public gimple_opt_pass
{
public:
- pass_call_cdce(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_call_cdce, ctxt)
+ pass_call_cdce (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_call_cdce, ctxt)
{}
/* opt_pass methods: */
class pass_build_cfg : public gimple_opt_pass
{
public:
- pass_build_cfg(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_build_cfg, ctxt)
+ pass_build_cfg (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_build_cfg, ctxt)
{}
/* opt_pass methods: */
{
if ((!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type))
&& (!VECTOR_INTEGER_TYPE_P (rhs1_type)
- || !VECTOR_FLOAT_TYPE_P(lhs_type)))
+ || !VECTOR_FLOAT_TYPE_P (lhs_type)))
{
error ("invalid types in conversion to floating point");
debug_generic_expr (lhs_type);
{
if ((!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type))
&& (!VECTOR_INTEGER_TYPE_P (lhs_type)
- || !VECTOR_FLOAT_TYPE_P(rhs1_type)))
+ || !VECTOR_FLOAT_TYPE_P (rhs1_type)))
{
error ("invalid types in conversion to integer");
debug_generic_expr (lhs_type);
class pass_split_crit_edges : public gimple_opt_pass
{
public:
- pass_split_crit_edges(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_split_crit_edges, ctxt)
+ pass_split_crit_edges (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_split_crit_edges, ctxt)
{}
/* opt_pass methods: */
class pass_warn_function_return : public gimple_opt_pass
{
public:
- pass_warn_function_return(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_warn_function_return, ctxt)
+ pass_warn_function_return (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_warn_function_return, ctxt)
{}
/* opt_pass methods: */
class pass_warn_function_noreturn : public gimple_opt_pass
{
public:
- pass_warn_function_noreturn(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_warn_function_noreturn, ctxt)
+ pass_warn_function_noreturn (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_warn_function_noreturn, ctxt)
{}
/* opt_pass methods: */
class pass_warn_unused_result : public gimple_opt_pass
{
public:
- pass_warn_unused_result(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_warn_unused_result, ctxt)
+ pass_warn_unused_result (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_warn_unused_result, ctxt)
{}
/* opt_pass methods: */
class pass_merge_phi : public gimple_opt_pass
{
public:
- pass_merge_phi(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_merge_phi, ctxt)
+ pass_merge_phi (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_merge_phi, ctxt)
{}
/* opt_pass methods: */
class pass_lower_complex : public gimple_opt_pass
{
public:
- pass_lower_complex(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_complex, ctxt)
+ pass_lower_complex (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_complex, ctxt)
{}
/* opt_pass methods: */
class pass_lower_complex_O0 : public gimple_opt_pass
{
public:
- pass_lower_complex_O0(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_complex_O0, ctxt)
+ pass_lower_complex_O0 (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_complex_O0, ctxt)
{}
/* opt_pass methods: */
affine_fn comm;
if (!CF_NONTRIVIAL_P (cf))
- return affine_fn();
+ return affine_fn ();
comm = cf->fns[0];
for (i = 1; i < cf->n; i++)
if (!affine_function_equal_p (comm, cf->fns[i]))
- return affine_fn();
+ return affine_fn ();
return comm;
}
va_list ap;
gcc_assert (0 < n && n <= MAX_DIM);
- va_start(ap, n);
+ va_start (ap, n);
ret->n = n;
for (i = 0; i < n; i++)
ret->fns[i] = va_arg (ap, affine_fn);
- va_end(ap);
+ va_end (ap);
return ret;
}
#define AM_NB_INDUCTION_VARS(M) (M)->nb_induction_vars
#define AM_PARAMETERS(M) (M)->parameters
#define AM_MATRIX(M) (M)->matrix
-#define AM_NB_PARAMETERS(M) (AM_PARAMETERS(M)).length ()
+#define AM_NB_PARAMETERS(M) (AM_PARAMETERS (M)).length ()
#define AM_CONST_COLUMN_INDEX(M) (AM_NB_INDUCTION_VARS (M) + AM_NB_PARAMETERS (M))
#define AM_NB_COLUMNS(M) (AM_NB_INDUCTION_VARS (M) + AM_NB_PARAMETERS (M) + 1)
#define AM_GET_SUBSCRIPT_ACCESS_VECTOR(M, I) AM_MATRIX (M)[I]
if (l->num == loop_num)
return i;
- gcc_unreachable();
+ gcc_unreachable ();
}
struct data_reference
{
gimple_seq new_eh_seq = eh_seq;
eh_seq = old_eh_seq;
- gimple_seq_add_seq(&eh_seq, new_eh_seq);
+ gimple_seq_add_seq (&eh_seq, new_eh_seq);
}
}
class pass_lower_eh : public gimple_opt_pass
{
public:
- pass_lower_eh(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_eh, ctxt)
+ pass_lower_eh (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_eh, ctxt)
{}
/* opt_pass methods: */
class pass_refactor_eh : public gimple_opt_pass
{
public:
- pass_refactor_eh(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_refactor_eh, ctxt)
+ pass_refactor_eh (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_refactor_eh, ctxt)
{}
/* opt_pass methods: */
class pass_lower_resx : public gimple_opt_pass
{
public:
- pass_lower_resx(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_resx, ctxt)
+ pass_lower_resx (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_resx, ctxt)
{}
/* opt_pass methods: */
class pass_lower_eh_dispatch : public gimple_opt_pass
{
public:
- pass_lower_eh_dispatch(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_eh_dispatch, ctxt)
+ pass_lower_eh_dispatch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_eh_dispatch, ctxt)
{}
/* opt_pass methods: */
class pass_cleanup_eh : public gimple_opt_pass
{
public:
- pass_cleanup_eh(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_cleanup_eh, ctxt)
+ pass_cleanup_eh (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cleanup_eh, ctxt)
{}
/* opt_pass methods: */
clear_access_vars (void)
{
memset (access_vars.address (), 0,
- access_vars.length () * sizeof(tree));
+ access_vars.length () * sizeof (tree));
}
/* Lower the entire function NODE. */
class pass_ipa_lower_emutls : public simple_ipa_opt_pass
{
public:
- pass_ipa_lower_emutls(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_lower_emutls, ctxt)
+ pass_ipa_lower_emutls (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_lower_emutls, ctxt)
{}
/* opt_pass methods: */
extern void threadedge_finalize_values (void);
extern vec<tree> ssa_name_values;
#define SSA_NAME_VALUE(x) \
- (SSA_NAME_VERSION(x) < ssa_name_values.length () \
- ? ssa_name_values[SSA_NAME_VERSION(x)] \
+ (SSA_NAME_VERSION (x) < ssa_name_values.length () \
+ ? ssa_name_values[SSA_NAME_VERSION (x)] \
: NULL_TREE)
extern void set_ssa_name_value (tree, tree);
extern bool potentially_threadable_block (basic_block);
class pass_if_conversion : public gimple_opt_pass
{
public:
- pass_if_conversion(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_if_conversion, ctxt)
+ pass_if_conversion (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_if_conversion, ctxt)
{}
/* opt_pass methods: */
class pass_build_ssa : public gimple_opt_pass
{
public:
- pass_build_ssa(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_build_ssa, ctxt)
+ pass_build_ssa (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_build_ssa, ctxt)
{}
/* opt_pass methods: */
if (!vec_safe_is_empty (stmt_list_cache))
{
list = stmt_list_cache->pop ();
- memset (list, 0, sizeof(struct tree_base));
+ memset (list, 0, sizeof (struct tree_base));
TREE_SET_CODE (list, STATEMENT_LIST);
}
else
{
/* When debugging, you may want to enable the following code. */
#if 1
- FILE *file = popen("dot -Tx11", "w");
+ FILE *file = popen ("dot -Tx11", "w");
if (!file)
return;
dot_rdg_1 (file, rdg);
class pass_loop_distribution : public gimple_opt_pass
{
public:
- pass_loop_distribution(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_loop_distribution, ctxt)
+ pass_loop_distribution (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_loop_distribution, ctxt)
{}
/* opt_pass methods: */
class pass_mudflap_1 : public gimple_opt_pass
{
public:
- pass_mudflap_1(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_mudflap_1, ctxt)
+ pass_mudflap_1 (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_mudflap_1, ctxt)
{}
/* opt_pass methods: */
class pass_mudflap_2 : public gimple_opt_pass
{
public:
- pass_mudflap_2(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_mudflap_2, ctxt)
+ pass_mudflap_2 (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_mudflap_2, ctxt)
{}
/* opt_pass methods: */
static bool
fold_mem_refs (const void *e, void *data ATTRIBUTE_UNUSED)
{
- tree *ref_p = CONST_CAST2(tree *, const tree *, (const tree *)e);
+ tree *ref_p = CONST_CAST2 (tree *, const tree *, (const tree *)e);
*ref_p = fold (*ref_p);
return true;
}
class pass_mudflap_1 : public gimple_opt_pass
{
public:
- pass_mudflap_1(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_mudflap_1, ctxt)
+ pass_mudflap_1 (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_mudflap_1, ctxt)
{}
/* opt_pass methods: */
class pass_mudflap_2 : public gimple_opt_pass
{
public:
- pass_mudflap_2(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_mudflap_2, ctxt)
+ pass_mudflap_2 (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_mudflap_2, ctxt)
{}
/* opt_pass methods: */
class pass_nrv : public gimple_opt_pass
{
public:
- pass_nrv(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_nrv, ctxt)
+ pass_nrv (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_nrv, ctxt)
{}
/* opt_pass methods: */
class pass_return_slot : public gimple_opt_pass
{
public:
- pass_return_slot(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_return_slot, ctxt)
+ pass_return_slot (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_return_slot, ctxt)
{}
/* opt_pass methods: */
if (!callee)
return unknown[object_size_type];
- alloc_size = lookup_attribute ("alloc_size", TYPE_ATTRIBUTES (TREE_TYPE(callee)));
+ alloc_size = lookup_attribute ("alloc_size",
+ TYPE_ATTRIBUTES (TREE_TYPE (callee)));
if (alloc_size && TREE_VALUE (alloc_size))
{
tree p = TREE_VALUE (alloc_size);
class pass_object_sizes : public gimple_opt_pass
{
public:
- pass_object_sizes(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_object_sizes, ctxt)
+ pass_object_sizes (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_object_sizes, ctxt)
{}
/* opt_pass methods: */
class pass_cleanup_cfg_post_optimizing : public gimple_opt_pass
{
public:
- pass_cleanup_cfg_post_optimizing(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_cleanup_cfg_post_optimizing, ctxt)
+ pass_cleanup_cfg_post_optimizing (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cleanup_cfg_post_optimizing, ctxt)
{}
/* opt_pass methods: */
class pass_fixup_cfg : public gimple_opt_pass
{
public:
- pass_fixup_cfg(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_fixup_cfg, ctxt)
+ pass_fixup_cfg (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_fixup_cfg, ctxt)
{}
/* opt_pass methods: */
virtual unsigned int execute ();
protected:
- opt_pass(const pass_data&, gcc::context *);
+ opt_pass (const pass_data&, gcc::context *);
public:
/* A list of sub-passes to run, dependent on gate predicate. */
class gimple_opt_pass : public opt_pass
{
protected:
- gimple_opt_pass(const pass_data& data, gcc::context *ctxt)
- : opt_pass(data, ctxt)
+ gimple_opt_pass (const pass_data& data, gcc::context *ctxt)
+ : opt_pass (data, ctxt)
{
}
};
class rtl_opt_pass : public opt_pass
{
protected:
- rtl_opt_pass(const pass_data& data, gcc::context *ctxt)
- : opt_pass(data, ctxt)
+ rtl_opt_pass (const pass_data& data, gcc::context *ctxt)
+ : opt_pass (data, ctxt)
{
}
};
void (*variable_transform) (struct varpool_node *);
protected:
- ipa_opt_pass_d(const pass_data& data, gcc::context *ctxt,
- void (*generate_summary) (void),
- void (*write_summary) (void),
- void (*read_summary) (void),
- void (*write_optimization_summary) (void),
- void (*read_optimization_summary) (void),
- void (*stmt_fixup) (struct cgraph_node *, gimple *),
- unsigned int function_transform_todo_flags_start,
- unsigned int (*function_transform) (struct cgraph_node *),
- void (*variable_transform) (struct varpool_node *))
- : opt_pass(data, ctxt),
- generate_summary(generate_summary),
- write_summary(write_summary),
- read_summary(read_summary),
- write_optimization_summary(write_optimization_summary),
- read_optimization_summary(read_optimization_summary),
- stmt_fixup(stmt_fixup),
- function_transform_todo_flags_start(
- function_transform_todo_flags_start),
- function_transform(function_transform),
- variable_transform(variable_transform)
+ ipa_opt_pass_d (const pass_data& data, gcc::context *ctxt,
+ void (*generate_summary) (void),
+ void (*write_summary) (void),
+ void (*read_summary) (void),
+ void (*write_optimization_summary) (void),
+ void (*read_optimization_summary) (void),
+ void (*stmt_fixup) (struct cgraph_node *, gimple *),
+ unsigned int function_transform_todo_flags_start,
+ unsigned int (*function_transform) (struct cgraph_node *),
+ void (*variable_transform) (struct varpool_node *))
+ : opt_pass (data, ctxt),
+ generate_summary (generate_summary),
+ write_summary (write_summary),
+ read_summary (read_summary),
+ write_optimization_summary (write_optimization_summary),
+ read_optimization_summary (read_optimization_summary),
+ stmt_fixup (stmt_fixup),
+ function_transform_todo_flags_start (function_transform_todo_flags_start),
+ function_transform (function_transform),
+ variable_transform (variable_transform)
{
}
};
class simple_ipa_opt_pass : public opt_pass
{
protected:
- simple_ipa_opt_pass(const pass_data& data, gcc::context *ctxt)
- : opt_pass(data, ctxt)
+ simple_ipa_opt_pass (const pass_data& data, gcc::context *ctxt)
+ : opt_pass (data, ctxt)
{
}
};
#define INDENT(SPACE) do { \
int i; for (i = 0; i<SPACE; i++) pp_space (buffer); } while (0)
-#define NIY do_niy(buffer,node)
+#define NIY do_niy (buffer, node)
static pretty_printer buffer;
static int initialized = 0;
pop_cfun ();
}
- del_node_map();
+ del_node_map ();
return 0;
}
class pass_ipa_tree_profile : public simple_ipa_opt_pass
{
public:
- pass_ipa_tree_profile(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_tree_profile, ctxt)
+ pass_ipa_tree_profile (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_tree_profile, ctxt)
{}
/* opt_pass methods: */
htab_t map;
vec<scev_info_str> entries;
- instantiate_cache_type () : map (NULL), entries(vNULL) {}
+ instantiate_cache_type () : map (NULL), entries (vNULL) {}
~instantiate_cache_type ();
tree get (unsigned slot) { return entries[slot].chrec; }
void set (unsigned slot, tree chrec) { entries[slot].chrec = chrec; }
class pass_sra_early : public gimple_opt_pass
{
public:
- pass_sra_early(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_sra_early, ctxt)
+ pass_sra_early (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_sra_early, ctxt)
{}
/* opt_pass methods: */
class pass_sra : public gimple_opt_pass
{
public:
- pass_sra(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_sra, ctxt)
+ pass_sra (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_sra, ctxt)
{}
/* opt_pass methods: */
repr_state = splice_all_param_accesses (representatives);
if (repr_state == NO_GOOD_ACCESS)
- return ipa_parm_adjustment_vec();
+ return ipa_parm_adjustment_vec ();
/* If there are any parameters passed by reference which are not modified
directly, we need to check whether they can be modified indirectly. */
adjustments = turn_representatives_into_adjustments (representatives,
adjustments_count);
else
- adjustments = ipa_parm_adjustment_vec();
+ adjustments = ipa_parm_adjustment_vec ();
representatives.release ();
return adjustments;
}
if ((DECL_COMDAT (node->symbol.decl) || DECL_EXTERNAL (node->symbol.decl))
- && inline_summary(node)->size >= MAX_INLINE_INSNS_AUTO)
+ && inline_summary (node)->size >= MAX_INLINE_INSNS_AUTO)
{
if (dump_file)
fprintf (dump_file, "Function too big to be made truly local.\n");
class pass_early_ipa_sra : public gimple_opt_pass
{
public:
- pass_early_ipa_sra(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_early_ipa_sra, ctxt)
+ pass_early_ipa_sra (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_early_ipa_sra, ctxt)
{}
/* opt_pass methods: */
class pass_ccp : public gimple_opt_pass
{
public:
- pass_ccp(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_ccp, ctxt)
+ pass_ccp (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_ccp, ctxt)
{}
/* opt_pass methods: */
class pass_fold_builtins : public gimple_opt_pass
{
public:
- pass_fold_builtins(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_fold_builtins, ctxt)
+ pass_fold_builtins (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_fold_builtins, ctxt)
{}
/* opt_pass methods: */
ptr->map = map;
lim = num_basevars (map);
bitmap_obstack_initialize (&ptr->obstack);
- ptr->live_base_partitions = (bitmap *) xmalloc(sizeof (bitmap *) * lim);
+ ptr->live_base_partitions = (bitmap *) xmalloc (sizeof (bitmap *) * lim);
ptr->live_base_var = BITMAP_ALLOC (&ptr->obstack);
for (x = 0; x < lim; x++)
ptr->live_base_partitions[x] = BITMAP_ALLOC (&ptr->obstack);
class pass_copy_prop : public gimple_opt_pass
{
public:
- pass_copy_prop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_copy_prop, ctxt)
+ pass_copy_prop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_copy_prop, ctxt)
{}
/* opt_pass methods: */
class pass_rename_ssa_copies : public gimple_opt_pass
{
public:
- pass_rename_ssa_copies(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_rename_ssa_copies, ctxt)
+ pass_rename_ssa_copies (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_rename_ssa_copies, ctxt)
{}
/* opt_pass methods: */
class pass_dce : public gimple_opt_pass
{
public:
- pass_dce(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_dce, ctxt)
+ pass_dce (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_dce, ctxt)
{}
/* opt_pass methods: */
class pass_dce_loop : public gimple_opt_pass
{
public:
- pass_dce_loop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_dce_loop, ctxt)
+ pass_dce_loop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_dce_loop, ctxt)
{}
/* opt_pass methods: */
class pass_cd_dce : public gimple_opt_pass
{
public:
- pass_cd_dce(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_cd_dce, ctxt)
+ pass_cd_dce (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cd_dce, ctxt)
{}
/* opt_pass methods: */
class pass_dominator : public gimple_opt_pass
{
public:
- pass_dominator(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_dominator, ctxt)
+ pass_dominator (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_dominator, ctxt)
{}
/* opt_pass methods: */
class pass_phi_only_cprop : public gimple_opt_pass
{
public:
- pass_phi_only_cprop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_phi_only_cprop, ctxt)
+ pass_phi_only_cprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_phi_only_cprop, ctxt)
{}
/* opt_pass methods: */
class pass_dse : public gimple_opt_pass
{
public:
- pass_dse(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_dse, ctxt)
+ pass_dse (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_dse, ctxt)
{}
/* opt_pass methods: */
return 0;
arg1 = arg0;
}
- opt = fold_ternary (VEC_PERM_EXPR, TREE_TYPE(op0), arg0, arg1, op2);
+ opt = fold_ternary (VEC_PERM_EXPR, TREE_TYPE (op0), arg0, arg1, op2);
if (!opt
- || (TREE_CODE (opt) != CONSTRUCTOR && TREE_CODE(opt) != VECTOR_CST))
+ || (TREE_CODE (opt) != CONSTRUCTOR && TREE_CODE (opt) != VECTOR_CST))
return 0;
gimple_assign_set_rhs_from_tree (gsi, opt);
update_stmt (gsi_stmt (*gsi));
class pass_forwprop : public gimple_opt_pass
{
public:
- pass_forwprop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_forwprop, ctxt)
+ pass_forwprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_forwprop, ctxt)
{}
/* opt_pass methods: */
class pass_tree_ifcombine : public gimple_opt_pass
{
public:
- pass_tree_ifcombine(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tree_ifcombine, ctxt)
+ pass_tree_ifcombine (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tree_ifcombine, ctxt)
{}
/* opt_pass methods: */
{
if (t++ == 0)
{
- fprintf(f, "Partition %d (", x);
+ fprintf (f, "Partition %d (", x);
print_generic_expr (f, partition_to_var (map, p), TDF_SLIM);
fprintf (f, " - ");
}
class pass_ch : public gimple_opt_pass
{
public:
- pass_ch(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_ch, ctxt)
+ pass_ch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_ch, ctxt)
{}
/* opt_pass methods: */
static void
free_lim_aux_data (struct lim_aux_data *data)
{
- data->depends.release();
+ data->depends.release ();
free (data);
}
struct rewrite_mem_ref_loc
{
rewrite_mem_ref_loc (tree tmp_var_) : tmp_var (tmp_var_) {}
- bool operator()(mem_ref_loc_p loc);
+ bool operator () (mem_ref_loc_p loc);
tree tmp_var;
};
bool
-rewrite_mem_ref_loc::operator()(mem_ref_loc_p loc)
+rewrite_mem_ref_loc::operator () (mem_ref_loc_p loc)
{
*loc->ref = tmp_var;
update_stmt (loc->stmt);
struct first_mem_ref_loc_1
{
first_mem_ref_loc_1 (mem_ref_loc_p *locp_) : locp (locp_) {}
- bool operator()(mem_ref_loc_p loc);
+ bool operator () (mem_ref_loc_p loc);
mem_ref_loc_p *locp;
};
bool
-first_mem_ref_loc_1::operator()(mem_ref_loc_p loc)
+first_mem_ref_loc_1::operator () (mem_ref_loc_p loc)
{
*locp = loc;
return true;
struct sm_set_flag_if_changed
{
sm_set_flag_if_changed (tree flag_) : flag (flag_) {}
- bool operator()(mem_ref_loc_p loc);
+ bool operator () (mem_ref_loc_p loc);
tree flag;
};
bool
-sm_set_flag_if_changed::operator()(mem_ref_loc_p loc)
+sm_set_flag_if_changed::operator () (mem_ref_loc_p loc)
{
/* Only set the flag for writes. */
if (is_gimple_assign (loc->stmt)
{
ref_always_accessed (struct loop *loop_, tree base_, bool stored_p_)
: loop (loop_), base (base_), stored_p (stored_p_) {}
- bool operator()(mem_ref_loc_p loc);
+ bool operator () (mem_ref_loc_p loc);
struct loop *loop;
tree base;
bool stored_p;
};
bool
-ref_always_accessed::operator()(mem_ref_loc_p loc)
+ref_always_accessed::operator () (mem_ref_loc_p loc)
{
struct loop *must_exec;
if (ratio == 1)
{
- if(operand_equal_p (ubase, cbase, 0))
+ if (operand_equal_p (ubase, cbase, 0))
return -1;
if (TREE_CODE (ubase) == ADDR_EXPR
fprintf (dump_file, "Memory expression %p\n",(void *) ref );
print_generic_expr (dump_file, ref, TDF_TREE);
fprintf (dump_file,":");
- dump_mem_details( dump_file, base, step, delta, write_p);
+ dump_mem_details (dump_file, base, step, delta, write_p);
fprintf (dump_file,
"Ignoring %p, non-constant step prefetching is "
"limited to inner most loops \n",
fprintf (dump_file, "Memory expression %p\n",(void *) ref );
print_generic_expr (dump_file, ref, TDF_TREE);
fprintf (dump_file,":");
- dump_mem_details(dump_file, base, step, delta, write_p);
+ dump_mem_details (dump_file, base, step, delta, write_p);
fprintf (dump_file,
"Not prefetching, ignoring %p due to "
"loop variant step\n",
class pass_tree_loop : public gimple_opt_pass
{
public:
- pass_tree_loop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tree_loop, ctxt)
+ pass_tree_loop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tree_loop, ctxt)
{}
/* opt_pass methods: */
class pass_tree_loop_init : public gimple_opt_pass
{
public:
- pass_tree_loop_init(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tree_loop_init, ctxt)
+ pass_tree_loop_init (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tree_loop_init, ctxt)
{}
/* opt_pass methods: */
class pass_lim : public gimple_opt_pass
{
public:
- pass_lim(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lim, ctxt)
+ pass_lim (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lim, ctxt)
{}
/* opt_pass methods: */
class pass_tree_unswitch : public gimple_opt_pass
{
public:
- pass_tree_unswitch(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tree_unswitch, ctxt)
+ pass_tree_unswitch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tree_unswitch, ctxt)
{}
/* opt_pass methods: */
class pass_predcom : public gimple_opt_pass
{
public:
- pass_predcom(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_predcom, ctxt)
+ pass_predcom (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_predcom, ctxt)
{}
/* opt_pass methods: */
class pass_vectorize : public gimple_opt_pass
{
public:
- pass_vectorize(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_vectorize, ctxt)
+ pass_vectorize (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_vectorize, ctxt)
{}
/* opt_pass methods: */
class pass_graphite : public gimple_opt_pass
{
public:
- pass_graphite(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_graphite, ctxt)
+ pass_graphite (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_graphite, ctxt)
{}
/* opt_pass methods: */
class pass_graphite_transforms : public gimple_opt_pass
{
public:
- pass_graphite_transforms(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_graphite_transforms, ctxt)
+ pass_graphite_transforms (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_graphite_transforms, ctxt)
{}
/* opt_pass methods: */
class pass_check_data_deps : public gimple_opt_pass
{
public:
- pass_check_data_deps(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_check_data_deps, ctxt)
+ pass_check_data_deps (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_check_data_deps, ctxt)
{}
/* opt_pass methods: */
class pass_iv_canon : public gimple_opt_pass
{
public:
- pass_iv_canon(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_iv_canon, ctxt)
+ pass_iv_canon (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_iv_canon, ctxt)
{}
/* opt_pass methods: */
class pass_scev_cprop : public gimple_opt_pass
{
public:
- pass_scev_cprop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_scev_cprop, ctxt)
+ pass_scev_cprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_scev_cprop, ctxt)
{}
/* opt_pass methods: */
class pass_record_bounds : public gimple_opt_pass
{
public:
- pass_record_bounds(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_record_bounds, ctxt)
+ pass_record_bounds (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_record_bounds, ctxt)
{}
/* opt_pass methods: */
class pass_complete_unroll : public gimple_opt_pass
{
public:
- pass_complete_unroll(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_complete_unroll, ctxt)
+ pass_complete_unroll (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_complete_unroll, ctxt)
{}
/* opt_pass methods: */
class pass_complete_unrolli : public gimple_opt_pass
{
public:
- pass_complete_unrolli(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_complete_unrolli, ctxt)
+ pass_complete_unrolli (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_complete_unrolli, ctxt)
{}
/* opt_pass methods: */
class pass_parallelize_loops : public gimple_opt_pass
{
public:
- pass_parallelize_loops(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_parallelize_loops, ctxt)
+ pass_parallelize_loops (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_parallelize_loops, ctxt)
{}
/* opt_pass methods: */
class pass_loop_prefetch : public gimple_opt_pass
{
public:
- pass_loop_prefetch(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_loop_prefetch, ctxt)
+ pass_loop_prefetch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_loop_prefetch, ctxt)
{}
/* opt_pass methods: */
class pass_iv_optimize : public gimple_opt_pass
{
public:
- pass_iv_optimize(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_iv_optimize, ctxt)
+ pass_iv_optimize (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_iv_optimize, ctxt)
{}
/* opt_pass methods: */
class pass_tree_loop_done : public gimple_opt_pass
{
public:
- pass_tree_loop_done(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tree_loop_done, ctxt)
+ pass_tree_loop_done (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tree_loop_done, ctxt)
{}
/* opt_pass methods: */
class pass_cse_reciprocals : public gimple_opt_pass
{
public:
- pass_cse_reciprocals(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_cse_reciprocals, ctxt)
+ pass_cse_reciprocals (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cse_reciprocals, ctxt)
{}
/* opt_pass methods: */
class pass_cse_sincos : public gimple_opt_pass
{
public:
- pass_cse_sincos(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_cse_sincos, ctxt)
+ pass_cse_sincos (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cse_sincos, ctxt)
{}
/* opt_pass methods: */
class pass_optimize_bswap : public gimple_opt_pass
{
public:
- pass_optimize_bswap(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_optimize_bswap, ctxt)
+ pass_optimize_bswap (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_optimize_bswap, ctxt)
{}
/* opt_pass methods: */
class pass_optimize_widening_mul : public gimple_opt_pass
{
public:
- pass_optimize_widening_mul(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_optimize_widening_mul, ctxt)
+ pass_optimize_widening_mul (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_optimize_widening_mul, ctxt)
{}
/* opt_pass methods: */
fprintf (f, " IMM ERROR : (use_p : tree - %p:%p)", (void *)ptr,
(void *)ptr->use);
print_generic_expr (f, USE_FROM_PTR (ptr), TDF_SLIM);
- fprintf(f, "\n");
+ fprintf (f, "\n");
return true;
}
else
print_gimple_stmt (file, USE_STMT (use_p), 0, TDF_SLIM);
}
- fprintf(file, "\n");
+ fprintf (file, "\n");
}
fprintf (file, "Immediate_uses: \n\n");
for (x = 1; x < num_ssa_names; x++)
{
- var = ssa_name(x);
+ var = ssa_name (x);
if (!var)
continue;
dump_immediate_uses_for (file, var);
class pass_phiopt : public gimple_opt_pass
{
public:
- pass_phiopt(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_phiopt, ctxt)
+ pass_phiopt (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_phiopt, ctxt)
{}
/* opt_pass methods: */
class pass_cselim : public gimple_opt_pass
{
public:
- pass_cselim(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_cselim, ctxt)
+ pass_cselim (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_cselim, ctxt)
{}
/* opt_pass methods: */
class pass_phiprop : public gimple_opt_pass
{
public:
- pass_phiprop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_phiprop, ctxt)
+ pass_phiprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_phiprop, ctxt)
{}
/* opt_pass methods: */
} *bitmap_set_t;
#define FOR_EACH_EXPR_ID_IN_SET(set, id, bi) \
- EXECUTE_IF_SET_IN_BITMAP(&(set)->expressions, 0, (id), (bi))
+ EXECUTE_IF_SET_IN_BITMAP (&(set)->expressions, 0, (id), (bi))
#define FOR_EACH_VALUE_ID_IN_SET(set, id, bi) \
- EXECUTE_IF_SET_IN_BITMAP(&(set)->values, 0, (id), (bi))
+ EXECUTE_IF_SET_IN_BITMAP (&(set)->values, 0, (id), (bi))
/* Mapping from value id to expressions with that value_id. */
static vec<bitmap> value_expressions;
case NARY:
return PRE_EXPR_NARY (e)->type;
}
- gcc_unreachable();
+ gcc_unreachable ();
}
/* Get a representative SSA_NAME for a given expression.
else
{
new_val_id = get_next_value_id ();
- value_expressions.safe_grow_cleared (get_max_value_id() + 1);
+ value_expressions.safe_grow_cleared (get_max_value_id () + 1);
nary = vn_nary_op_insert_pieces (newnary->length,
newnary->opcode,
newnary->type,
if (changed || !same_valid)
{
new_val_id = get_next_value_id ();
- value_expressions.safe_grow_cleared(get_max_value_id() + 1);
+ value_expressions.safe_grow_cleared
+ (get_max_value_id () + 1);
}
else
new_val_id = ref->value_id;
expressions.create (0);
expressions.safe_push (NULL);
value_expressions.create (get_max_value_id () + 1);
- value_expressions.safe_grow_cleared (get_max_value_id() + 1);
+ value_expressions.safe_grow_cleared (get_max_value_id () + 1);
name_to_id.create (0);
inserted_exprs = BITMAP_ALLOC (NULL);
class pass_pre : public gimple_opt_pass
{
public:
- pass_pre(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_pre, ctxt)
+ pass_pre (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_pre, ctxt)
{}
/* opt_pass methods: */
class pass_fre : public gimple_opt_pass
{
public:
- pass_fre(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_fre, ctxt)
+ pass_fre (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_fre, ctxt)
{}
/* opt_pass methods: */
class pass_reassoc : public gimple_opt_pass
{
public:
- pass_reassoc(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_reassoc, ctxt)
+ pass_reassoc (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_reassoc, ctxt)
{}
/* opt_pass methods: */
class pass_sink_code : public gimple_opt_pass
{
public:
- pass_sink_code(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_sink_code, ctxt)
+ pass_sink_code (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_sink_code, ctxt)
{}
/* opt_pass methods: */
class pass_strlen : public gimple_opt_pass
{
public:
- pass_strlen(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_strlen, ctxt)
+ pass_strlen (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_strlen, ctxt)
{}
/* opt_pass methods: */
{
if (c->rhs.type == ADDRESSOF)
{
- gcc_unreachable();
+ gcc_unreachable ();
}
else
{
}
}
else
- bitmap_ior_into(graph->points_to[n], graph->points_to[w]);
+ bitmap_ior_into (graph->points_to[n], graph->points_to[w]);
}
}
rhsc.safe_push (nul);
get_constraint_for (gimple_call_lhs (t), &lhsc);
process_all_all_constraints (lhsc, rhsc);
- lhsc.release();
- rhsc.release();
+ lhsc.release ();
+ rhsc.release ();
}
return true;
/* Trampolines are special - they set up passing the static
class pass_build_alias : public gimple_opt_pass
{
public:
- pass_build_alias(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_build_alias, ctxt)
+ pass_build_alias (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_build_alias, ctxt)
{}
/* opt_pass methods: */
class pass_build_ealias : public gimple_opt_pass
{
public:
- pass_build_ealias(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_build_ealias, ctxt)
+ pass_build_ealias (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_build_ealias, ctxt)
{}
/* opt_pass methods: */
class pass_ipa_pta : public simple_ipa_opt_pass
{
public:
- pass_ipa_pta(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_pta, ctxt)
+ pass_ipa_pta (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_pta, ctxt)
{}
/* opt_pass methods: */
for (unsigned int i = 0; i < path.length (); i++)
delete path[i];
- path.release();
+ path.release ();
}
BITMAP_FREE (visited);
}
if (rd->outgoing_edge->aux)
{
e->aux = XNEWVEC (edge, 2);
- THREAD_TARGET(e) = THREAD_TARGET (rd->outgoing_edge);
- THREAD_TARGET2(e) = THREAD_TARGET2 (rd->outgoing_edge);
+ THREAD_TARGET (e) = THREAD_TARGET (rd->outgoing_edge);
+ THREAD_TARGET2 (e) = THREAD_TARGET2 (rd->outgoing_edge);
}
else
{
else
bitmap_copy (threaded_blocks, tmp);
- BITMAP_FREE(tmp);
+ BITMAP_FREE (tmp);
}
class pass_uncprop : public gimple_opt_pass
{
public:
- pass_uncprop(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_uncprop, ctxt)
+ pass_uncprop (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_uncprop, ctxt)
{}
/* opt_pass methods: */
class pass_late_warn_uninitialized : public gimple_opt_pass
{
public:
- pass_late_warn_uninitialized(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_late_warn_uninitialized, ctxt)
+ pass_late_warn_uninitialized (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_late_warn_uninitialized, ctxt)
{}
/* opt_pass methods: */
class pass_early_warn_uninitialized : public gimple_opt_pass
{
public:
- pass_early_warn_uninitialized(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_early_warn_uninitialized, ctxt)
+ pass_early_warn_uninitialized (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_early_warn_uninitialized, ctxt)
{}
/* opt_pass methods: */
class pass_init_datastructures : public gimple_opt_pass
{
public:
- pass_init_datastructures(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_init_datastructures, ctxt)
+ pass_init_datastructures (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_init_datastructures, ctxt)
{}
/* opt_pass methods: */
class pass_update_address_taken : public gimple_opt_pass
{
public:
- pass_update_address_taken(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_update_address_taken, ctxt)
+ pass_update_address_taken (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_update_address_taken, ctxt)
{}
/* opt_pass methods: */
class pass_release_ssa_names : public gimple_opt_pass
{
public:
- pass_release_ssa_names(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_release_ssa_names, ctxt)
+ pass_release_ssa_names (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_release_ssa_names, ctxt)
{}
/* opt_pass methods: */
class pass_stdarg : public gimple_opt_pass
{
public:
- pass_stdarg(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_stdarg, ctxt)
+ pass_stdarg (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_stdarg, ctxt)
{}
/* opt_pass methods: */
test[k].lo |= (HOST_WIDE_INT) 1 << j;
}
- qsort (test, count, sizeof(*test), case_bit_test_cmp);
+ qsort (test, count, sizeof (*test), case_bit_test_cmp);
/* We generate two jumps to the default case label.
Split the default edge, so that we don't have to do any PHI node
class pass_convert_switch : public gimple_opt_pass
{
public:
- pass_convert_switch(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_convert_switch, ctxt)
+ pass_convert_switch (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_convert_switch, ctxt)
{}
/* opt_pass methods: */
class pass_tail_recursion : public gimple_opt_pass
{
public:
- pass_tail_recursion(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tail_recursion, ctxt)
+ pass_tail_recursion (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tail_recursion, ctxt)
{}
/* opt_pass methods: */
class pass_tail_calls : public gimple_opt_pass
{
public:
- pass_tail_calls(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tail_calls, ctxt)
+ pass_tail_calls (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tail_calls, ctxt)
{}
/* opt_pass methods: */
struct _vect_peel_extended_info res;
res.peel_info.dr = NULL;
- res.body_cost_vec = stmt_vector_for_cost();
+ res.body_cost_vec = stmt_vector_for_cost ();
if (!unlimited_cost_model ())
{
unsigned possible_npeel_number = 1;
tree vectype;
unsigned int nelements, mis, same_align_drs_max = 0;
- stmt_vector_for_cost body_cost_vec = stmt_vector_for_cost();
+ stmt_vector_for_cost body_cost_vec = stmt_vector_for_cost ();
if (dump_enabled_p ())
dump_printf_loc (MSG_NOTE, vect_location,
/* Sort the array of datarefs to make building the interleaving chains
linear. */
- qsort (datarefs.address(), datarefs.length (),
+ qsort (datarefs.address (), datarefs.length (),
sizeof (data_reference_p), dr_group_sort_cmp);
/* Build the interleaving chains. */
class pass_lower_vector : public gimple_opt_pass
{
public:
- pass_lower_vector(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_vector, ctxt)
+ pass_lower_vector (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_vector, ctxt)
{}
/* opt_pass methods: */
class pass_lower_vector_ssa : public gimple_opt_pass
{
public:
- pass_lower_vector_ssa(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_lower_vector_ssa, ctxt)
+ pass_lower_vector_ssa (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_lower_vector_ssa, ctxt)
{}
/* opt_pass methods: */
unshare_expr (LOOP_VINFO_NITERS_UNCHANGED (loop_vec_info_for_loop (loop)));
e = single_pred_edge (bb_before_first_loop);
- cond_bb = split_edge(e);
+ cond_bb = split_edge (e);
e = single_pred_edge (bb_before_first_loop);
- then_bb = split_edge(e);
+ then_bb = split_edge (e);
set_immediate_dominator (CDI_DOMINATORS, then_bb, cond_bb);
e_false = make_single_succ_edge (cond_bb, bb_before_first_loop,
"alignment\n");
}
- free_original_copy_tables();
+ free_original_copy_tables ();
/* Loop versioning violates an assumption we try to maintain during
vectorization - that the loop exit block has a single predecessor.
{
if (modifier == WIDEN)
{
- vec_oprnds0.create (multi_step_cvt ? vect_pow2(multi_step_cvt) : 1);
+ vec_oprnds0.create (multi_step_cvt ? vect_pow2 (multi_step_cvt) : 1);
if (op_type == binary_op)
vec_oprnds1.create (1);
}
(unshare_expr (DR_BASE_ADDRESS (dr)),
size_binop (PLUS_EXPR,
convert_to_ptrofftype (unshare_expr (DR_OFFSET (dr))),
- convert_to_ptrofftype (DR_INIT(dr))));
+ convert_to_ptrofftype (DR_INIT (dr))));
stride_step = fold_convert (sizetype, unshare_expr (DR_STEP (dr)));
/* For a load with loop-invariant (but other than power-of-2)
class pass_slp_vectorize : public gimple_opt_pass
{
public:
- pass_slp_vectorize(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_slp_vectorize, ctxt)
+ pass_slp_vectorize (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_slp_vectorize, ctxt)
{}
/* opt_pass methods: */
tree t;
unsigned int alignment;
- t = TREE_TYPE(decl);
+ t = TREE_TYPE (decl);
if (TREE_CODE (t) != ARRAY_TYPE)
continue;
vectype = get_vectype_for_scalar_type (strip_array_types (t));
class pass_ipa_increase_alignment : public simple_ipa_opt_pass
{
public:
- pass_ipa_increase_alignment(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_increase_alignment, ctxt)
+ pass_ipa_increase_alignment (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_increase_alignment, ctxt)
{}
/* opt_pass methods: */
typedef source_location LOC;
#define UNKNOWN_LOC UNKNOWN_LOCATION
-#define EXPR_LOC(e) EXPR_LOCATION(e)
+#define EXPR_LOC(e) EXPR_LOCATION (e)
#define LOC_FILE(l) LOCATION_FILE (l)
#define LOC_LINE(l) LOCATION_LINE (l)
&& TREE_INT_CST_LOW ((n)) > 0)
#define LOOP_VINFO_NITERS_KNOWN_P(L) \
-NITERS_KNOWN_P((L)->num_iters)
+NITERS_KNOWN_P ((L)->num_iters)
static inline loop_vec_info
loop_vec_info_for_loop (struct loop *loop)
}
/* Traverse all PHI nodes in BB, updating live. */
- for (si = gsi_start_phis (bb); !gsi_end_p(si); gsi_next (&si))
+ for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
{
use_operand_p arg_p;
ssa_op_iter i;
class pass_vrp : public gimple_opt_pass
{
public:
- pass_vrp(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_vrp, ctxt)
+ pass_vrp (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_vrp, ctxt)
{}
/* opt_pass methods: */
TYPE_SYMTAB_ADDRESS (t) = 0;
/* Do not copy the values cache. */
- if (TYPE_CACHED_VALUES_P(t))
+ if (TYPE_CACHED_VALUES_P (t))
{
TYPE_CACHED_VALUES_P (t) = 0;
TYPE_CACHED_VALUES (t) = NULL_TREE;
bool sign_extended_type = !TYPE_UNSIGNED (type);
/* If we need to set overflow flags, return a new unshared node. */
- if (overflowed || !double_int_fits_to_tree_p(type, cst))
+ if (overflowed || !double_int_fits_to_tree_p (type, cst))
{
if (overflowed
|| overflowable < 0
case FIXED_POINT_TYPE:
/* We can only generate 1 for accum types. */
gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
- return build_fixed (type, FCONST1(TYPE_MODE (type)));
+ return build_fixed (type, FCONST1 (TYPE_MODE (type)));
case VECTOR_TYPE:
{
read_only = 1;
side_effects = TREE_SIDE_EFFECTS (t);
- PROCESS_ARG(0);
- PROCESS_ARG(1);
+ PROCESS_ARG (0);
+ PROCESS_ARG (1);
TREE_READONLY (t) = read_only;
TREE_CONSTANT (t) = constant;
else
side_effects = TREE_SIDE_EFFECTS (t);
- PROCESS_ARG(0);
- PROCESS_ARG(1);
- PROCESS_ARG(2);
+ PROCESS_ARG (0);
+ PROCESS_ARG (1);
+ PROCESS_ARG (2);
if (code == COND_EXPR)
TREE_READONLY (t) = read_only;
side_effects = TREE_SIDE_EFFECTS (t);
- PROCESS_ARG(0);
- PROCESS_ARG(1);
- PROCESS_ARG(2);
- PROCESS_ARG(3);
+ PROCESS_ARG (0);
+ PROCESS_ARG (1);
+ PROCESS_ARG (2);
+ PROCESS_ARG (3);
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
side_effects = TREE_SIDE_EFFECTS (t);
- PROCESS_ARG(0);
- PROCESS_ARG(1);
- PROCESS_ARG(2);
- PROCESS_ARG(3);
- PROCESS_ARG(4);
+ PROCESS_ARG (0);
+ PROCESS_ARG (1);
+ PROCESS_ARG (2);
+ PROCESS_ARG (3);
+ PROCESS_ARG (4);
TREE_SIDE_EFFECTS (t) = side_effects;
TREE_THIS_VOLATILE (t)
class pass_ipa_free_lang_data : public simple_ipa_opt_pass
{
public:
- pass_ipa_free_lang_data(gcc::context *ctxt)
- : simple_ipa_opt_pass(pass_data_ipa_free_lang_data, ctxt)
+ pass_ipa_free_lang_data (gcc::context *ctxt)
+ : simple_ipa_opt_pass (pass_data_ipa_free_lang_data, ctxt)
{}
/* opt_pass methods: */
/* This CONST_CAST is okay because lookup_attribute does not
modify its argument and the return value is assigned to a
const_tree. */
- for (attr = lookup_ident_attribute (get_attribute_name (t2), CONST_CAST_TREE(l1));
+ for (attr = lookup_ident_attribute (get_attribute_name (t2),
+ CONST_CAST_TREE (l1));
attr != NULL_TREE && !attribute_value_equal (t2, attr);
- attr = lookup_ident_attribute (get_attribute_name (t2), TREE_CHAIN (attr)))
+ attr = lookup_ident_attribute (get_attribute_name (t2),
+ TREE_CHAIN (attr)))
;
if (attr == NULL_TREE)
true) or would not differ from ARGTYPES. */
static tree
-maybe_canonicalize_argtypes(tree argtypes,
- bool *any_structural_p,
- bool *any_noncanonical_p)
+maybe_canonicalize_argtypes (tree argtypes,
+ bool *any_structural_p,
+ bool *any_noncanonical_p)
{
tree arg;
bool any_noncanonical_argtypes_p = false;
{
internal_error
("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
- TS_ENUM_NAME(en),
+ TS_ENUM_NAME (en),
tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
}
unsigned HOST_WIDE_INT idx;
constructor_elt *ce;
- for (idx = 0; vec_safe_iterate(CONSTRUCTOR_ELTS (*tp), idx, &ce); idx++)
+ for (idx = 0; vec_safe_iterate (CONSTRUCTOR_ELTS (*tp), idx, &ce);
+ idx++)
WALK_SUBTREE (ce->value);
}
break;
if (!fntype)
return false;
- FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
+ FOREACH_FUNCTION_ARGS (fntype, t, args_iter)
{
n = t;
}
exit of a function. Calls for which this is true are candidates for tail
call optimizations. */
#define CALL_EXPR_TAILCALL(NODE) \
- (CALL_EXPR_CHECK(NODE)->base.addressable_flag)
+ (CALL_EXPR_CHECK (NODE)->base.addressable_flag)
/* Used as a temporary field on a CASE_LABEL_EXPR to indicate that the
CASE_LOW operand has been processed. */
(CASE_LABEL_EXPR_CHECK (NODE)->base.addressable_flag)
#define PREDICT_EXPR_OUTCOME(NODE) \
- ((enum prediction) (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag))
+ ((enum prediction) (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag))
#define SET_PREDICT_EXPR_OUTCOME(NODE, OUTCOME) \
- (PREDICT_EXPR_CHECK(NODE)->base.addressable_flag = (int) OUTCOME)
+ (PREDICT_EXPR_CHECK (NODE)->base.addressable_flag = (int) OUTCOME)
#define PREDICT_EXPR_PREDICTOR(NODE) \
((enum br_predictor)tree_low_cst (TREE_OPERAND (PREDICT_EXPR_CHECK (NODE), 0), 0))
/* In a _TYPE, indicates whether TYPE_CACHED_VALUES contains a vector
of cached values, or is something else. */
-#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK(NODE)->base.public_flag)
+#define TYPE_CACHED_VALUES_P(NODE) (TYPE_CHECK (NODE)->base.public_flag)
/* In a SAVE_EXPR, indicates that the original expression has already
been substituted with a VAR_DECL that contains the value. */
/* Set on a CALL_EXPR if this stdarg call should be passed the argument
pack. */
#define CALL_EXPR_VA_ARG_PACK(NODE) \
- (CALL_EXPR_CHECK(NODE)->base.public_flag)
+ (CALL_EXPR_CHECK (NODE)->base.public_flag)
/* In any expression, decl, or constant, nonzero means it has side effects or
reevaluation of the whole expression could produce a different value.
/* These flags are available for each language front end to use internally. */
#define TREE_LANG_FLAG_0(NODE) \
- (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0)
+ (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_0)
#define TREE_LANG_FLAG_1(NODE) \
- (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)
+ (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_1)
#define TREE_LANG_FLAG_2(NODE) \
- (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)
+ (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_2)
#define TREE_LANG_FLAG_3(NODE) \
- (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)
+ (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_3)
#define TREE_LANG_FLAG_4(NODE) \
- (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)
+ (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_4)
#define TREE_LANG_FLAG_5(NODE) \
- (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)
+ (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_5)
#define TREE_LANG_FLAG_6(NODE) \
- (TREE_NOT_CHECK2(NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)
+ (TREE_NOT_CHECK2 (NODE, TREE_VEC, SSA_NAME)->base.u.bits.lang_flag_6)
\f
/* Define additional fields and accessors for nodes representing constants. */
#define CALL_EXPR_FN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 1)
#define CALL_EXPR_STATIC_CHAIN(NODE) TREE_OPERAND (CALL_EXPR_CHECK (NODE), 2)
#define CALL_EXPR_ARG(NODE, I) TREE_OPERAND (CALL_EXPR_CHECK (NODE), (I) + 3)
-#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH(NODE) - 3)
+#define call_expr_nargs(NODE) (VL_EXP_OPERAND_LENGTH (NODE) - 3)
/* CALL_EXPR_ARGP returns a pointer to the argument vector for NODE.
We can't use &CALL_EXPR_ARG (NODE, 0) because that will complain if
#define TYPE_DOMAIN(NODE) (ARRAY_TYPE_CHECK (NODE)->type_non_common.values)
#define TYPE_FIELDS(NODE) \
(RECORD_OR_UNION_CHECK (NODE)->type_non_common.values)
-#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK(NODE)->type_non_common.values)
+#define TYPE_CACHED_VALUES(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
#define TYPE_ARG_TYPES(NODE) \
(FUNC_OR_METHOD_CHECK (NODE)->type_non_common.values)
-#define TYPE_VALUES_RAW(NODE) (TYPE_CHECK(NODE)->type_non_common.values)
+#define TYPE_VALUES_RAW(NODE) (TYPE_CHECK (NODE)->type_non_common.values)
#define TYPE_METHODS(NODE) \
(RECORD_OR_UNION_CHECK (NODE)->type_non_common.maxval)
/* For record and union types, information about this type, as a base type
for itself. */
-#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK(NODE)->type_non_common.binfo)
+#define TYPE_BINFO(NODE) (RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo)
/* For non record and union types, used in a language-dependent way. */
#define TYPE_LANG_SLOT_1(NODE) \
- (NOT_RECORD_OR_UNION_CHECK(NODE)->type_non_common.binfo)
+ (NOT_RECORD_OR_UNION_CHECK (NODE)->type_non_common.binfo)
/* Define accessor macros for information about type inheritance
and basetypes.
#define BINFO_VIRTUAL_P(NODE) (TREE_BINFO_CHECK (NODE)->base.static_flag)
/* Flags for language dependent use. */
-#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0(TREE_BINFO_CHECK(NODE))
-#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1(TREE_BINFO_CHECK(NODE))
-#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2(TREE_BINFO_CHECK(NODE))
-#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3(TREE_BINFO_CHECK(NODE))
-#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4(TREE_BINFO_CHECK(NODE))
-#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5(TREE_BINFO_CHECK(NODE))
-#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6(TREE_BINFO_CHECK(NODE))
+#define BINFO_MARKED(NODE) TREE_LANG_FLAG_0 (TREE_BINFO_CHECK (NODE))
+#define BINFO_FLAG_1(NODE) TREE_LANG_FLAG_1 (TREE_BINFO_CHECK (NODE))
+#define BINFO_FLAG_2(NODE) TREE_LANG_FLAG_2 (TREE_BINFO_CHECK (NODE))
+#define BINFO_FLAG_3(NODE) TREE_LANG_FLAG_3 (TREE_BINFO_CHECK (NODE))
+#define BINFO_FLAG_4(NODE) TREE_LANG_FLAG_4 (TREE_BINFO_CHECK (NODE))
+#define BINFO_FLAG_5(NODE) TREE_LANG_FLAG_5 (TREE_BINFO_CHECK (NODE))
+#define BINFO_FLAG_6(NODE) TREE_LANG_FLAG_6 (TREE_BINFO_CHECK (NODE))
/* The actual data type node being inherited in this basetype. */
-#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK(NODE))
+#define BINFO_TYPE(NODE) TREE_TYPE (TREE_BINFO_CHECK (NODE))
/* The offset where this basetype appears in its containing type.
BINFO_OFFSET slot holds the offset (in bytes)
object that is allocated on behalf of this `type'.
This is always 0 except when there is multiple inheritance. */
-#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK(NODE)->binfo.offset)
+#define BINFO_OFFSET(NODE) (TREE_BINFO_CHECK (NODE)->binfo.offset)
#define BINFO_OFFSET_ZEROP(NODE) (integer_zerop (BINFO_OFFSET (NODE)))
/* The virtual function table belonging to this basetype. Virtual
function tables provide a mechanism for run-time method dispatching.
The entries of a virtual function table are language-dependent. */
-#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtable)
+#define BINFO_VTABLE(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtable)
/* The virtual functions in the virtual function table. This is
a TREE_LIST that is used as an initial approximation for building
a virtual function table for this basetype. */
-#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK(NODE)->binfo.virtuals)
+#define BINFO_VIRTUALS(NODE) (TREE_BINFO_CHECK (NODE)->binfo.virtuals)
/* A vector of binfos for the direct basetypes inherited by this
basetype.
If this basetype describes type D as inherited in C, and if the
basetypes of D are E and F, then this vector contains binfos for
inheritance of E and F by C. */
-#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK(NODE)->binfo.base_binfos)
+#define BINFO_BASE_BINFOS(NODE) (&TREE_BINFO_CHECK (NODE)->binfo.base_binfos)
/* The number of basetypes for NODE. */
#define BINFO_N_BASE_BINFOS(NODE) (BINFO_BASE_BINFOS (NODE)->length ())
base. The actual contents are language-dependent. In the C++
front-end this field is an INTEGER_CST giving an offset into the
vtable where the offset to the virtual base can be found. */
-#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vptr_field)
+#define BINFO_VPTR_FIELD(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vptr_field)
/* Indicates the accesses this binfo has to its bases. The values are
access_public_node, access_protected_node or access_private_node.
If this array is not present, public access is implied. */
-#define BINFO_BASE_ACCESSES(NODE) (TREE_BINFO_CHECK(NODE)->binfo.base_accesses)
+#define BINFO_BASE_ACCESSES(NODE) \
+ (TREE_BINFO_CHECK (NODE)->binfo.base_accesses)
#define BINFO_BASE_ACCESS(NODE,N) \
(*BINFO_BASE_ACCESSES (NODE))[(N)]
/* The index in the VTT where this subobject's sub-VTT can be found.
NULL_TREE if there is no sub-VTT. */
-#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_subvtt)
+#define BINFO_SUBVTT_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_subvtt)
/* The index in the VTT where the vptr for this subobject can be
found. NULL_TREE if there is no secondary vptr in the VTT. */
-#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK(NODE)->binfo.vtt_vptr)
+#define BINFO_VPTR_INDEX(NODE) (TREE_BINFO_CHECK (NODE)->binfo.vtt_vptr)
/* The BINFO_INHERITANCE_CHAIN points at the binfo for the base
inheriting this base for non-virtual bases. For virtual bases it
points either to the binfo for which this is a primary binfo, or to
the binfo of the most derived type. */
#define BINFO_INHERITANCE_CHAIN(NODE) \
- (TREE_BINFO_CHECK(NODE)->binfo.inheritance)
+ (TREE_BINFO_CHECK (NODE)->binfo.inheritance)
/* Define fields and accessors for nodes representing declared names. */
contains_struct_check (tree __t, const enum tree_node_structure_enum __s,
const char *__f, int __l, const char *__g)
{
- if (tree_contains_struct[TREE_CODE(__t)][__s] != 1)
+ if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
return __t;
}
tree_class_check (tree __t, const enum tree_code_class __class,
const char *__f, int __l, const char *__g)
{
- if (TREE_CODE_CLASS (TREE_CODE(__t)) != __class)
+ if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
tree_class_check_failed (__t, __class, __f, __l, __g);
return __t;
}
contains_struct_check (const_tree __t, const enum tree_node_structure_enum __s,
const char *__f, int __l, const char *__g)
{
- if (tree_contains_struct[TREE_CODE(__t)][__s] != 1)
+ if (tree_contains_struct[TREE_CODE (__t)][__s] != 1)
tree_contains_struct_check_failed (__t, __s, __f, __l, __g);
return __t;
}
tree_class_check (const_tree __t, const enum tree_code_class __class,
const char *__f, int __l, const char *__g)
{
- if (TREE_CODE_CLASS (TREE_CODE(__t)) != __class)
+ if (TREE_CODE_CLASS (TREE_CODE (__t)) != __class)
tree_class_check_failed (__t, __class, __f, __l, __g);
return __t;
}
extern tree build_zero_cst (tree);
extern tree build_string (int, const char *);
extern tree build_tree_list_stat (tree, tree MEM_STAT_DECL);
-#define build_tree_list(t,q) build_tree_list_stat(t,q MEM_STAT_INFO)
+#define build_tree_list(t, q) build_tree_list_stat (t, q MEM_STAT_INFO)
extern tree build_tree_list_vec_stat (const vec<tree, va_gc> *MEM_STAT_DECL);
#define build_tree_list_vec(v) build_tree_list_vec_stat (v MEM_STAT_INFO)
extern tree build_decl_stat (location_t, enum tree_code,
tree, tree MEM_STAT_DECL);
extern tree build_fn_decl (const char *, tree);
-#define build_decl(l,c,t,q) build_decl_stat (l,c,t,q MEM_STAT_INFO)
+#define build_decl(l,c,t,q) build_decl_stat (l, c, t, q MEM_STAT_INFO)
extern tree build_translation_unit_decl (tree);
extern tree build_block (tree, tree, tree, tree);
extern tree build_empty_stmt (location_t);
extern tree find_omp_clause (tree, enum omp_clause_code);
extern tree build_vl_exp_stat (enum tree_code, int MEM_STAT_DECL);
-#define build_vl_exp(c,n) build_vl_exp_stat (c,n MEM_STAT_INFO)
+#define build_vl_exp(c, n) build_vl_exp_stat (c, n MEM_STAT_INFO)
extern tree build_call_nary (tree, tree, int, ...);
extern tree build_call_valist (tree, tree, int, va_list);
extern tree fold_build_call_array_initializer_loc (location_t, tree, tree, int, tree *);
extern bool fold_convertible_p (const_tree, const_tree);
#define fold_convert(T1,T2)\
- fold_convert_loc(UNKNOWN_LOCATION, T1, T2)
+ fold_convert_loc (UNKNOWN_LOCATION, T1, T2)
extern tree fold_convert_loc (location_t, tree, tree);
extern tree fold_single_bit_test (location_t, enum tree_code, tree, tree, tree);
extern tree fold_ignored_result (tree);
omit_two_operands_loc (UNKNOWN_LOCATION, T1, T2, T3, T4)
extern tree omit_two_operands_loc (location_t, tree, tree, tree, tree);
#define invert_truthvalue(T)\
- invert_truthvalue_loc(UNKNOWN_LOCATION, T)
+ invert_truthvalue_loc (UNKNOWN_LOCATION, T)
extern tree invert_truthvalue_loc (location_t, tree);
extern tree fold_unary_to_constant (enum tree_code, tree, tree);
extern tree fold_binary_to_constant (enum tree_code, tree, tree, tree);
class pass_tsan : public gimple_opt_pass
{
public:
- pass_tsan(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tsan, ctxt)
+ pass_tsan (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tsan, ctxt)
{}
/* opt_pass methods: */
class pass_tsan_O0 : public gimple_opt_pass
{
public:
- pass_tsan_O0(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_tsan_O0, ctxt)
+ pass_tsan_O0 (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_tsan_O0, ctxt)
{}
/* opt_pass methods: */
#define gcc_unreachable() (abort ())
#define CONST_CAST2(TOTYPE,FROMTYPE,X) ((__extension__(union {FROMTYPE _q; TOTYPE _nq;})(X))._nq)
-#define CONST_CAST(TYPE,X) CONST_CAST2(TYPE, const TYPE, (X))
+#define CONST_CAST(TYPE,X) CONST_CAST2 (TYPE, const TYPE, (X))
/* Filename handling macros. */
#include "filenames.h"
if (hist->hvalue.counters)
{
unsigned int i;
- fprintf(dump_file, " [");
+ fprintf (dump_file, " [");
for (i = 0; i < hist->hdata.intvl.steps; i++)
fprintf (dump_file, " %d:"HOST_WIDEST_INT_PRINT_DEC,
hist->hdata.intvl.int_start + i,
fndecl = gimple_call_fndecl (vcall_stmt);
if (!interesting_stringop_to_profile_p (fndecl, vcall_stmt, &size_arg))
- gcc_unreachable();
+ gcc_unreachable ();
cond_bb = gimple_bb (vcall_stmt);
gsi = gsi_for_stmt (vcall_stmt);
/* The most common case, much simpler, no qsort is needed. */
location_chain dstnode = dst->var_part[j].loc_chain;
dst->var_part[k].loc_chain = dstnode;
- VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET(dst, j);
+ VAR_PART_OFFSET (dst, k) = VAR_PART_OFFSET (dst, j);
node2 = dstnode;
for (node = src->var_part[i].loc_chain; node; node = node->next)
if (!((REG_P (dstnode->loc)
class pass_variable_tracking : public rtl_opt_pass
{
public:
- pass_variable_tracking(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_variable_tracking, ctxt)
+ pass_variable_tracking (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_variable_tracking, ctxt)
{}
/* opt_pass methods: */
case MINUS_EXPR:
case RANGE_EXPR:
return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
- && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
+ && compare_constant (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
CASE_CONVERT:
case VIEW_CONVERT_EXPR:
do_assemble_alias (tree decl, tree target)
{
/* Emulated TLS had better not get this var. */
- gcc_assert(!(!targetm.have_tls
- && TREE_CODE (decl) == VAR_DECL
- && DECL_THREAD_LOCAL_P (decl)));
+ gcc_assert (!(!targetm.have_tls
+ && TREE_CODE (decl) == VAR_DECL
+ && DECL_THREAD_LOCAL_P (decl)));
if (TREE_ASM_WRITTEN (decl))
return;
{
unsigned oldlen = vec_safe_length (v);
vec_safe_grow (v, len PASS_MEM_STAT);
- memset (&(v->address()[oldlen]), 0, sizeof (T) * (len - oldlen));
+ memset (&(v->address ()[oldlen]), 0, sizeof (T) * (len - oldlen));
}
element of this vector. Use this to iterate over the elements of a
vector as follows,
- for (ix = 0; vec<T, A>::iterate(v, ix, &ptr); ix++)
+ for (ix = 0; vec<T, A>::iterate (v, ix, &ptr); ix++)
continue; */
template<typename T, typename A>
IX'th element of this vector. Use this to iterate over the
elements of a vector as follows,
- for (ix = 0; v->iterate(ix, &ptr); ix++)
+ for (ix = 0; v->iterate (ix, &ptr); ix++)
continue;
This variant is for vectors of objects. */
{
vec_alloc (new_vec, len PASS_MEM_STAT);
new_vec->embedded_init (len, len);
- memcpy (new_vec->address(), vecdata_, sizeof (T) * len);
+ memcpy (new_vec->address (), vecdata_, sizeof (T) * len);
}
return new_vec;
}
inline void
vec<T, A, vl_embed>::splice (vec<T, A, vl_embed> &src)
{
- unsigned len = src.length();
+ unsigned len = src.length ();
if (len)
{
gcc_checking_assert (space (len));
- memcpy (address() + length(), src.address(), len * sizeof (T));
+ memcpy (address () + length (), src.address (), len * sizeof (T));
vecpfx_.num_ += len;
}
}
inline void
vec<T, A, vl_embed>::ordered_remove (unsigned ix)
{
- gcc_checking_assert (ix < length());
+ gcc_checking_assert (ix < length ());
T *slot = &vecdata_[ix];
memmove (slot, slot + 1, (--vecpfx_.num_ - ix) * sizeof (T));
}
inline void
vec<T, A, vl_embed>::unordered_remove (unsigned ix)
{
- gcc_checking_assert (ix < length());
+ gcc_checking_assert (ix < length ());
vecdata_[ix] = vecdata_[--vecpfx_.num_];
}
inline void
vec<T, A, vl_embed>::block_remove (unsigned ix, unsigned len)
{
- gcc_checking_assert (ix + len <= length());
+ gcc_checking_assert (ix + len <= length ());
T *slot = &vecdata_[ix];
vecpfx_.num_ -= len;
memmove (slot, slot + len, (vecpfx_.num_ - ix) * sizeof (T));
inline void
vec<T, A, vl_embed>::qsort (int (*cmp) (const void *, const void *))
{
- ::qsort (address(), length(), sizeof (T), cmp);
+ ::qsort (address (), length (), sizeof (T), cmp);
}
final member):
size_t vec<T, A, vl_embed>::embedded_size (unsigned alloc);
- void v->embedded_init(unsigned alloc, unsigned num);
+ void v->embedded_init (unsigned alloc, unsigned num);
These allow the caller to perform the memory allocation. */
{
unsigned oldlen = length ();
quick_grow (len);
- memset (&(address()[oldlen]), 0, sizeof (T) * (len - oldlen));
+ memset (&(address ()[oldlen]), 0, sizeof (T) * (len - oldlen));
}
{ return vec_ != NULL; }
bool is_empty (void) const
- { return vec_ ? vec_->is_empty() : true; }
+ { return vec_ ? vec_->is_empty () : true; }
unsigned length (void) const
- { return vec_ ? vec_->length() : 0; }
+ { return vec_ ? vec_->length () : 0; }
T *address (void)
{ return vec_ ? vec_->vecdata_ : NULL; }
{ return !(*this == other); }
bool operator==(const vec &other) const
- { return address() == other.address(); }
+ { return address () == other.address (); }
T &operator[] (unsigned ix)
{ return (*vec_)[ix]; }
T &last (void)
- { return vec_->last(); }
+ { return vec_->last (); }
bool space (int nelems) const
{ return vec_ ? vec_->space (nelems) : nelems == 0; }
unsigned lower_bound (T, bool (*)(const T &, const T &)) const;
template<typename T1>
- friend void va_stack::alloc(vec<T1, va_stack, vl_ptr>&, unsigned,
- vec<T1, va_stack, vl_embed> *);
+ friend void va_stack::alloc (vec<T1, va_stack, vl_ptr>&, unsigned,
+ vec<T1, va_stack, vl_embed> *);
/* FIXME - This field should be private, but we need to cater to
compilers that have stricter notions of PODness for types. */
element of this vector. Use this to iterate over the elements of a
vector as follows,
- for (ix = 0; v.iterate(ix, &ptr); ix++)
+ for (ix = 0; v.iterate (ix, &ptr); ix++)
continue; */
template<typename T, typename A>
IX'th element of this vector. Use this to iterate over the
elements of a vector as follows,
- for (ix = 0; v->iterate(ix, &ptr); ix++)
+ for (ix = 0; v->iterate (ix, &ptr); ix++)
continue;
This variant is for vectors of objects. */
inline void
vec<T, A, vl_ptr>::safe_splice (vec<T, A, vl_ptr> &src MEM_STAT_DECL)
{
- if (src.length())
+ if (src.length ())
{
- reserve_exact (src.length());
+ reserve_exact (src.length ());
splice (src);
}
}
{
unsigned oldlen = length ();
safe_grow (len PASS_MEM_STAT);
- memset (&(address()[oldlen]), 0, sizeof (T) * (len - oldlen));
+ memset (&(address ()[oldlen]), 0, sizeof (T) * (len - oldlen));
}
#ifndef UNALIGNED_OFFSET_ASM_OP
#define UNALIGNED_OFFSET_ASM_OP(OFFSET) \
- (NUMBYTES(OFFSET) == 4 \
+ (NUMBYTES (OFFSET) == 4 \
? VMS_UNALIGNED_LONG_ASM_OP \
- : (NUMBYTES(OFFSET) == 2 ? VMS_UNALIGNED_SHORT_ASM_OP : VMS_ASM_BYTE_OP))
+ : (NUMBYTES (OFFSET) == 2 ? VMS_UNALIGNED_SHORT_ASM_OP : VMS_ASM_BYTE_OP))
#endif
/* Definitions of defaults for formats and names of various special
#ifndef ASM_OUTPUT_DEBUG_DATA
#define ASM_OUTPUT_DEBUG_DATA(FILE,VALUE) \
- fprintf ((FILE), "\t%s\t%#lx", UNALIGNED_OFFSET_ASM_OP(VALUE), VALUE)
+ fprintf ((FILE), "\t%s\t%#lx", UNALIGNED_OFFSET_ASM_OP (VALUE), VALUE)
#endif
#ifndef ASM_OUTPUT_DEBUG_ADDR_DATA
#define ASM_OUTPUT_DEBUG_STRING(FILE,P) \
do \
{ \
- register int slen = strlen(P); \
+ register int slen = strlen (P); \
register const char *p = (P); \
register int i; \
fprintf (FILE, "\t.ascii \""); \
struct vtable_registration key;
struct vtable_registration **slot;
- gcc_assert (node && node->registered.is_created());
+ gcc_assert (node && node->registered.is_created ());
key.vtable_decl = vtable_decl;
slot = (struct vtable_registration **) node->registered.find_slot (&key,
if (slot && (*slot))
{
unsigned i;
- for (i = 0; i < ((*slot)->offsets).length(); ++i)
+ for (i = 0; i < ((*slot)->offsets).length (); ++i)
if ((*slot)->offsets[i] == offset)
return true;
}
struct vtable_registration **slot;
bool inserted_something = false;
- if (!node || !node->registered.is_created())
+ if (!node || !node->registered.is_created ())
return false;
key.vtable_decl = vtable_decl;
contains the offset. If not, we need to add the offset. */
unsigned i;
bool found = false;
- for (i = 0; i < ((*slot)->offsets).length() && !found; ++i)
+ for (i = 0; i < ((*slot)->offsets).length () && !found; ++i)
if ((*slot)->offsets[i] == offset)
found = true;
tree class_name;
unsigned int type_quals;
- if (!vtbl_map_hash.is_created())
+ if (!vtbl_map_hash.is_created ())
return NULL;
gcc_assert (TREE_CODE (class_type) == RECORD_TYPE);
tree class_type_decl;
unsigned int type_quals;
- if (!vtbl_map_hash.is_created())
+ if (!vtbl_map_hash.is_created ())
vtbl_map_hash.create (10);
/* Find the TYPE_DECL for the class. */
class pass_vtable_verify : public gimple_opt_pass
{
public:
- pass_vtable_verify(gcc::context *ctxt)
- : gimple_opt_pass(pass_data_vtable_verify, ctxt)
+ pass_vtable_verify (gcc::context *ctxt)
+ : gimple_opt_pass (pass_data_vtable_verify, ctxt)
{}
/* opt_pass methods: */
}
/* Record the number of uses and defs at the beginning of the optimization. */
- def_entry = XCNEWVEC (struct web_entry, DF_DEFS_TABLE_SIZE());
+ def_entry = XCNEWVEC (struct web_entry, DF_DEFS_TABLE_SIZE ());
used = XCNEWVEC (unsigned, max);
use_entry = XCNEWVEC (struct web_entry, uses_num);
class pass_web : public rtl_opt_pass
{
public:
- pass_web(gcc::context *ctxt)
- : rtl_opt_pass(pass_data_web, ctxt)
+ pass_web (gcc::context *ctxt)
+ : rtl_opt_pass (pass_data_web, ctxt)
{}
/* opt_pass methods: */
projects / platform / upstream / linaro-gcc.git / commitdiff