+2018-06-08 David Malcolm <dmalcolm@redhat.com>
+
+ * cfg.c (debug): Use TDF_NONE rather than 0.
+ * cfghooks.c (debug): Likewise.
+ * dumpfile.c (DUMP_FILE_INFO): Likewise; also for OPTGROUP.
+ (struct dump_option_value_info): Convert to...
+ (struct kv_pair): ...this template type.
+ (dump_options): Convert to kv_pair<dump_flags_t>; use TDF_NONE
+ rather than 0.
+ (optinfo_verbosity_options): Likewise.
+ (optgroup_options): Convert to kv_pair<optgroup_flags_t>; use
+ OPTGROUP_NONE.
+ (gcc::dump_manager::dump_register): Use optgroup_flags_t rather
+ than int for "optgroup_flags" param.
+ (dump_generic_expr_loc): Use dump_flags_t rather than int for
+ "dump_kind" param.
+ (dump_dec): Likewise.
+ (dump_finish): Use TDF_NONE rather than 0.
+ (gcc::dump_manager::opt_info_enable_passes): Use optgroup_flags_t
+ rather than int for "optgroup_flags" param. Use TDF_NONE rather
+ than 0. Update for change to option_ptr.
+ (opt_info_switch_p_1): Convert "optgroup_flags" param from int *
+ to optgroup_flags_t *. Use TDF_NONE and OPTGROUP_NONE rather than
+ 0. Update for changes to optinfo_verbosity_options and
+ optgroup_options.
+ (opt_info_switch_p): Convert optgroup_flags from int to
+ optgroup_flags_t.
+ (dump_basic_block): Use dump_flags_t rather than int
+ for "dump_kind" param.
+ * dumpfile.h (TDF_ADDRESS, TDF_SLIM, TDF_RAW, TDF_DETAILS,
+ TDF_STATS, TDF_BLOCKS, TDF_VOPS, TDF_LINENO, TDF_UID)
+ TDF_STMTADDR, TDF_GRAPH, TDF_MEMSYMS, TDF_RHS_ONLY, TDF_ASMNAME,
+ TDF_EH, TDF_NOUID, TDF_ALIAS, TDF_ENUMERATE_LOCALS, TDF_CSELIB,
+ TDF_SCEV, TDF_GIMPLE, TDF_FOLDING, MSG_OPTIMIZED_LOCATIONS,
+ MSG_MISSED_OPTIMIZATION, MSG_NOTE, MSG_ALL, TDF_COMPARE_DEBUG,
+ TDF_NONE): Convert from macros to...
+ (enum dump_flag): ...this new enum.
+ (dump_flags_t): Update to use enum.
+ (operator|, operator&, operator~, operator|=, operator&=):
+ Implement for dump_flags_t.
+ (OPTGROUP_NONE, OPTGROUP_IPA, OPTGROUP_LOOP, OPTGROUP_INLINE,
+ OPTGROUP_OMP, OPTGROUP_VEC, OPTGROUP_OTHER, OPTGROUP_ALL):
+ Convert from macros to...
+ (enum optgroup_flag): ...this new enum.
+ (optgroup_flags_t): New typedef.
+ (operator|, operator|=): Implement for optgroup_flags_t.
+ (struct dump_file_info): Convert field "alt_flags" to
+ dump_flags_t. Convert field "optgroup_flags" to
+ optgroup_flags_t.
+ (dump_basic_block): Use dump_flags_t rather than int for param.
+ (dump_generic_expr_loc): Likewise.
+ (dump_dec): Likewise.
+ (dump_register): Convert param "optgroup_flags" to
+ optgroup_flags_t.
+ (opt_info_enable_passes): Likewise.
+ * early-remat.c (early_remat::dump_edge_list): Use TDF_NONE rather
+ than 0.
+ * gimple-pretty-print.c (debug): Likewise.
+ * gimple-ssa-store-merging.c (bswap_replace): Likewise.
+ (merged_store_group::apply_stores): Likewise.
+ * gimple-ssa-strength-reduction.c (insert_initializers): Likewise.
+ * gimple.c (verify_gimple_pp): Likewise.
+ * graphite-poly.c (print_pbb_body): Likewise.
+ * passes.c (pass_manager::register_one_dump_file): Convert
+ local "optgroup_flags" to optgroup_flags_t.
+ * print-tree.c (print_node): Use TDF_NONE rather than 0.
+ (debug): Likewise.
+ (debug_body): Likewise.
+ * tree-pass.h (struct pass_data): Convert field "optgroup_flags"
+ to optgroup_flags_t.
+ * tree-pretty-print.c (print_struct_decl): Use TDF_NONE rather
+ than 0.
+ * tree-ssa-math-opts.c (convert_mult_to_fma_1): Likewise.
+ (convert_mult_to_fma): Likewise.
+ * tree-ssa-reassoc.c (undistribute_ops_list): Likewise.
+ * tree-ssa-sccvn.c (vn_eliminate): Likewise.
+ * tree-vect-data-refs.c (dump_lower_bound): Convert param
+ "dump_kind" to dump_flags_t.
+
2018-06-08 Segher Boessenkool <segher@kernel.crashing.org>
* config/rs6000/rs6000.c (min, max): Delete.
+2018-06-08 David Malcolm <dmalcolm@redhat.com>
+
+ * brigfrontend/brig-to-generic.cc
+ (brig_to_generic::write_globals): Use TDF_NONE rather than 0.
+ (dump_function): Likewise.
+
2018-05-18 Richard Sandiford <richard.sandiford@linaro.org>
* brigfrontend/brig-function.cc
fprintf (m_dump_file, "\n;; Function %s", kern_name.c_str());
fprintf (m_dump_file, "\n;; enabled by -%s\n\n",
dump_flag_name (TDI_original));
- print_generic_decl (m_dump_file, launcher, 0);
- print_generic_expr (m_dump_file, DECL_SAVED_TREE (launcher), 0);
+ print_generic_decl (m_dump_file, launcher, TDF_NONE);
+ print_generic_expr (m_dump_file, DECL_SAVED_TREE (launcher),
+ TDF_NONE);
fprintf (m_dump_file, "\n");
}
fprintf (dump_file, "\n;; Function %s", f->m_name.c_str ());
fprintf (dump_file, "\n;; enabled by -%s\n\n",
dump_flag_name (TDI_original));
- print_generic_decl (dump_file, f->m_func_decl, 0);
- print_generic_expr (dump_file, f->m_current_bind_expr, 0);
+ print_generic_decl (dump_file, f->m_func_decl, TDF_NONE);
+ print_generic_expr (dump_file, f->m_current_bind_expr, TDF_NONE);
fprintf (dump_file, "\n");
}
}
+2018-06-08 David Malcolm <dmalcolm@redhat.com>
+
+ * c-pretty-print.c (c_pretty_printer::statement): Use TDF_NONE
+ rather than 0.
+
2018-06-08 Martin Liska <mliska@suse.cz>
* c-attribs.c (handle_bnd_variable_size_attribute): Remove support
if (pp_needs_newline (this))
pp_newline_and_indent (this, 0);
- dump_generic_node (this, stmt, pp_indentation (this), 0, true);
+ dump_generic_node (this, stmt, pp_indentation (this), TDF_NONE, true);
}
\f
debug (edge_def &ref)
{
/* FIXME (crowl): Is this desireable? */
- dump_edge_info (stderr, &ref, 0, false);
- dump_edge_info (stderr, &ref, 0, true);
+ dump_edge_info (stderr, &ref, TDF_NONE, false);
+ dump_edge_info (stderr, &ref, TDF_NONE, true);
}
DEBUG_FUNCTION void
DEBUG_FUNCTION void
debug (basic_block_def &ref)
{
- dump_bb (stderr, &ref, 0, 0);
+ dump_bb (stderr, &ref, 0, TDF_NONE);
}
DEBUG_FUNCTION void
dump_flags_t dump_flags;
#define DUMP_FILE_INFO(suffix, swtch, dkind, num) \
- {suffix, swtch, NULL, NULL, NULL, NULL, NULL, dkind, 0, 0, 0, 0, 0, num, \
- false, false}
+ {suffix, swtch, NULL, NULL, NULL, NULL, NULL, dkind, TDF_NONE, TDF_NONE, \
+ OPTGROUP_NONE, 0, 0, num, false, false}
/* Table of tree dump switches. This must be consistent with the
TREE_DUMP_INDEX enumeration in dumpfile.h. */
};
/* Define a name->number mapping for a dump flag value. */
-struct dump_option_value_info
+template <typename ValueType>
+struct kv_pair
{
const char *const name; /* the name of the value */
- const dump_flags_t value; /* the value of the name */
+ const ValueType value; /* the value of the name */
};
/* Table of dump options. This must be consistent with the TDF_* flags
in dumpfile.h and opt_info_options below. */
-static const struct dump_option_value_info dump_options[] =
+static const kv_pair<dump_flags_t> dump_options[] =
{
{"address", TDF_ADDRESS},
{"asmname", TDF_ASMNAME},
{"all", dump_flags_t (~(TDF_RAW | TDF_SLIM | TDF_LINENO | TDF_GRAPH
| TDF_STMTADDR | TDF_RHS_ONLY | TDF_NOUID
| TDF_ENUMERATE_LOCALS | TDF_SCEV | TDF_GIMPLE))},
- {NULL, 0}
+ {NULL, TDF_NONE}
};
/* A subset of the dump_options table which is used for -fopt-info
types. This must be consistent with the MSG_* flags in dumpfile.h.
*/
-static const struct dump_option_value_info optinfo_verbosity_options[] =
+static const kv_pair<dump_flags_t> optinfo_verbosity_options[] =
{
{"optimized", MSG_OPTIMIZED_LOCATIONS},
{"missed", MSG_MISSED_OPTIMIZATION},
{"note", MSG_NOTE},
{"all", MSG_ALL},
- {NULL, 0}
+ {NULL, TDF_NONE}
};
/* Flags used for -fopt-info groups. */
-static const struct dump_option_value_info optgroup_options[] =
+static const kv_pair<optgroup_flags_t> optgroup_options[] =
{
{"ipa", OPTGROUP_IPA},
{"loop", OPTGROUP_LOOP},
{"omp", OPTGROUP_OMP},
{"vec", OPTGROUP_VEC},
{"optall", OPTGROUP_ALL},
- {NULL, 0}
+ {NULL, OPTGROUP_NONE}
};
gcc::dump_manager::dump_manager ():
unsigned int
gcc::dump_manager::
dump_register (const char *suffix, const char *swtch, const char *glob,
- dump_kind dkind, int optgroup_flags, bool take_ownership)
+ dump_kind dkind, optgroup_flags_t optgroup_flags,
+ bool take_ownership)
{
int num = m_next_dump++;
location. */
void
-dump_generic_expr_loc (int dump_kind, source_location loc,
+dump_generic_expr_loc (dump_flags_t dump_kind, source_location loc,
dump_flags_t extra_dump_flags, tree t)
{
if (dump_file && (dump_kind & pflags))
template<unsigned int N, typename C>
void
-dump_dec (int dump_kind, const poly_int<N, C> &value)
+dump_dec (dump_flags_t dump_kind, const poly_int<N, C> &value)
{
STATIC_ASSERT (poly_coeff_traits<C>::signedness >= 0);
signop sgn = poly_coeff_traits<C>::signedness ? SIGNED : UNSIGNED;
print_dec (value, alt_dump_file, sgn);
}
-template void dump_dec (int, const poly_uint16 &);
-template void dump_dec (int, const poly_int64 &);
-template void dump_dec (int, const poly_uint64 &);
-template void dump_dec (int, const poly_offset_int &);
-template void dump_dec (int, const poly_widest_int &);
+template void dump_dec (dump_flags_t, const poly_uint16 &);
+template void dump_dec (dump_flags_t, const poly_int64 &);
+template void dump_dec (dump_flags_t, const poly_uint64 &);
+template void dump_dec (dump_flags_t, const poly_offset_int &);
+template void dump_dec (dump_flags_t, const poly_widest_int &);
/* Start a dump for PHASE. Store user-supplied dump flags in
*FLAG_PTR. Return the number of streams opened. Set globals
dfi->pstream = NULL;
dump_file = NULL;
alt_dump_file = NULL;
- dump_flags = TDI_none;
- alt_flags = 0;
- pflags = 0;
+ dump_flags = TDF_NONE;
+ alt_flags = TDF_NONE;
+ pflags = TDF_NONE;
}
/* Begin a tree dump for PHASE. Stores any user supplied flag in
int
gcc::dump_manager::
-opt_info_enable_passes (int optgroup_flags, dump_flags_t flags,
+opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
const char *filename)
{
int n = 0;
return 0;
ptr = option_value;
- flags = 0;
+ flags = TDF_NONE;
while (*ptr)
{
- const struct dump_option_value_info *option_ptr;
+ const struct kv_pair<dump_flags_t> *option_ptr;
const char *end_ptr;
const char *eq_ptr;
unsigned length;
and filename. Return non-zero if it is a recognized switch. */
static int
-opt_info_switch_p_1 (const char *arg, dump_flags_t *flags, int *optgroup_flags,
- char **filename)
+opt_info_switch_p_1 (const char *arg, dump_flags_t *flags,
+ optgroup_flags_t *optgroup_flags, char **filename)
{
const char *option_value;
const char *ptr;
ptr = option_value;
*filename = NULL;
- *flags = 0;
- *optgroup_flags = 0;
+ *flags = TDF_NONE;
+ *optgroup_flags = OPTGROUP_NONE;
if (!ptr)
return 1; /* Handle '-fopt-info' without any additional options. */
while (*ptr)
{
- const struct dump_option_value_info *option_ptr;
const char *end_ptr;
const char *eq_ptr;
unsigned length;
end_ptr = ptr + strlen (ptr);
length = end_ptr - ptr;
- for (option_ptr = optinfo_verbosity_options; option_ptr->name;
- option_ptr++)
+ for (const kv_pair<dump_flags_t> *option_ptr = optinfo_verbosity_options;
+ option_ptr->name; option_ptr++)
if (strlen (option_ptr->name) == length
&& !memcmp (option_ptr->name, ptr, length))
{
goto found;
}
- for (option_ptr = optgroup_options; option_ptr->name; option_ptr++)
+ for (const kv_pair<optgroup_flags_t> *option_ptr = optgroup_options;
+ option_ptr->name; option_ptr++)
if (strlen (option_ptr->name) == length
&& !memcmp (option_ptr->name, ptr, length))
{
opt_info_switch_p (const char *arg)
{
dump_flags_t flags;
- int optgroup_flags;
+ optgroup_flags_t optgroup_flags;
char *filename;
static char *file_seen = NULL;
gcc::dump_manager *dumps = g->get_dumps ();
/* Print basic block on the dump streams. */
void
-dump_basic_block (int dump_kind, basic_block bb, int indent)
+dump_basic_block (dump_flags_t dump_kind, basic_block bb, int indent)
{
if (dump_file && (dump_kind & pflags))
dump_bb (dump_file, bb, indent, TDF_DETAILS);
the DUMP_OPTIONS array in dumpfile.c. The TDF_* flags coexist with
MSG_* flags (for -fopt-info) and the bit values must be chosen to
allow that. */
-#define TDF_ADDRESS (1 << 0) /* dump node addresses */
-#define TDF_SLIM (1 << 1) /* don't go wild following links */
-#define TDF_RAW (1 << 2) /* don't unparse the function */
-#define TDF_DETAILS (1 << 3) /* show more detailed info about
- each pass */
-#define TDF_STATS (1 << 4) /* dump various statistics about
- each pass */
-#define TDF_BLOCKS (1 << 5) /* display basic block boundaries */
-#define TDF_VOPS (1 << 6) /* display virtual operands */
-#define TDF_LINENO (1 << 7) /* display statement line numbers */
-#define TDF_UID (1 << 8) /* display decl UIDs */
-
-#define TDF_STMTADDR (1 << 9) /* Address of stmt. */
-
-#define TDF_GRAPH (1 << 10) /* a graph dump is being emitted */
-#define TDF_MEMSYMS (1 << 11) /* display memory symbols in expr.
- Implies TDF_VOPS. */
-
-#define TDF_RHS_ONLY (1 << 12) /* a flag to only print the RHS of
- a gimple stmt. */
-#define TDF_ASMNAME (1 << 13) /* display asm names of decls */
-#define TDF_EH (1 << 14) /* display EH region number
- holding this gimple statement. */
-#define TDF_NOUID (1 << 15) /* omit UIDs from dumps. */
-#define TDF_ALIAS (1 << 16) /* display alias information */
-#define TDF_ENUMERATE_LOCALS (1 << 17) /* Enumerate locals by uid. */
-#define TDF_CSELIB (1 << 18) /* Dump cselib details. */
-#define TDF_SCEV (1 << 19) /* Dump SCEV details. */
-#define TDF_GIMPLE (1 << 20) /* Dump in GIMPLE FE syntax */
-#define TDF_FOLDING (1 << 21) /* Dump folding details. */
-#define MSG_OPTIMIZED_LOCATIONS (1 << 22) /* -fopt-info optimized sources */
-#define MSG_MISSED_OPTIMIZATION (1 << 23) /* missed opportunities */
-#define MSG_NOTE (1 << 24) /* general optimization info */
-#define MSG_ALL (MSG_OPTIMIZED_LOCATIONS | MSG_MISSED_OPTIMIZATION \
- | MSG_NOTE)
-#define TDF_COMPARE_DEBUG (1 << 25) /* Dumping for -fcompare-debug. */
-
-
-/* Value of TDF_NONE is used just for bits filtered by TDF_KIND_MASK. */
-
-#define TDF_NONE 0
+enum dump_flag
+{
+ /* Value of TDF_NONE is used just for bits filtered by TDF_KIND_MASK. */
+ TDF_NONE = 0,
+
+ /* Dump node addresses. */
+ TDF_ADDRESS = (1 << 0),
+
+ /* Don't go wild following links. */
+ TDF_SLIM = (1 << 1),
+
+ /* Don't unparse the function. */
+ TDF_RAW = (1 << 2),
+
+ /* Show more detailed info about each pass. */
+ TDF_DETAILS = (1 << 3),
+
+ /* Dump various statistics about each pass. */
+ TDF_STATS = (1 << 4),
+
+ /* Display basic block boundaries. */
+ TDF_BLOCKS = (1 << 5),
+
+ /* Display virtual operands. */
+ TDF_VOPS = (1 << 6),
+
+ /* Display statement line numbers. */
+ TDF_LINENO = (1 << 7),
+
+ /* Display decl UIDs. */
+ TDF_UID = (1 << 8),
+
+ /* Address of stmt. */
+ TDF_STMTADDR = (1 << 9),
+
+ /* A graph dump is being emitted. */
+ TDF_GRAPH = (1 << 10),
+
+ /* Display memory symbols in expr.
+ Implies TDF_VOPS. */
+ TDF_MEMSYMS = (1 << 11),
+
+ /* A flag to only print the RHS of a gimple stmt. */
+ TDF_RHS_ONLY = (1 << 12),
+
+ /* Display asm names of decls. */
+ TDF_ASMNAME = (1 << 13),
+
+ /* Display EH region number holding this gimple statement. */
+ TDF_EH = (1 << 14),
+
+ /* Omit UIDs from dumps. */
+ TDF_NOUID = (1 << 15),
+
+ /* Display alias information. */
+ TDF_ALIAS = (1 << 16),
+
+ /* Enumerate locals by uid. */
+ TDF_ENUMERATE_LOCALS = (1 << 17),
+
+ /* Dump cselib details. */
+ TDF_CSELIB = (1 << 18),
+
+ /* Dump SCEV details. */
+ TDF_SCEV = (1 << 19),
+
+ /* Dump in GIMPLE FE syntax */
+ TDF_GIMPLE = (1 << 20),
+
+ /* Dump folding details. */
+ TDF_FOLDING = (1 << 21),
+
+ /* -fopt-info optimized sources. */
+ MSG_OPTIMIZED_LOCATIONS = (1 << 22),
+
+ /* Missed opportunities. */
+ MSG_MISSED_OPTIMIZATION = (1 << 23),
+
+ /* General optimization info. */
+ MSG_NOTE = (1 << 24),
+
+ MSG_ALL = (MSG_OPTIMIZED_LOCATIONS
+ | MSG_MISSED_OPTIMIZATION
+ | MSG_NOTE),
+
+ /* Dumping for -fcompare-debug. */
+ TDF_COMPARE_DEBUG = (1 << 25)
+};
+
+/* Dump flags type. */
+
+typedef enum dump_flag dump_flags_t;
+
+static inline dump_flags_t
+operator| (dump_flags_t lhs, dump_flags_t rhs)
+{
+ return (dump_flags_t)((int)lhs | (int)rhs);
+}
+
+static inline dump_flags_t
+operator& (dump_flags_t lhs, dump_flags_t rhs)
+{
+ return (dump_flags_t)((int)lhs & (int)rhs);
+}
+
+static inline dump_flags_t
+operator~ (dump_flags_t flags)
+{
+ return (dump_flags_t)~((int)flags);
+}
+
+static inline dump_flags_t &
+operator|= (dump_flags_t &lhs, dump_flags_t rhs)
+{
+ lhs = (dump_flags_t)((int)lhs | (int)rhs);
+ return lhs;
+}
+
+static inline dump_flags_t &
+operator&= (dump_flags_t &lhs, dump_flags_t rhs)
+{
+ lhs = (dump_flags_t)((int)lhs & (int)rhs);
+ return lhs;
+}
/* Flags to control high-level -fopt-info dumps. Usually these flags
define a group of passes. An optimization pass can be part of
multiple groups. */
-#define OPTGROUP_NONE (0)
-#define OPTGROUP_IPA (1 << 1) /* IPA optimization passes */
-#define OPTGROUP_LOOP (1 << 2) /* Loop optimization passes */
-#define OPTGROUP_INLINE (1 << 3) /* Inlining passes */
-#define OPTGROUP_OMP (1 << 4) /* OMP (Offloading and Multi
- Processing) transformations */
-#define OPTGROUP_VEC (1 << 5) /* Vectorization passes */
-#define OPTGROUP_OTHER (1 << 6) /* All other passes */
-#define OPTGROUP_ALL (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE \
- | OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
-/* Dump flags type. */
+enum optgroup_flag
+{
+ OPTGROUP_NONE = 0,
+
+ /* IPA optimization passes */
+ OPTGROUP_IPA = (1 << 1),
+
+ /* Loop optimization passes */
+ OPTGROUP_LOOP = (1 << 2),
+
+ /* Inlining passes */
+ OPTGROUP_INLINE = (1 << 3),
-typedef uint64_t dump_flags_t;
+ /* OMP (Offloading and Multi Processing) transformations */
+ OPTGROUP_OMP = (1 << 4),
+
+ /* Vectorization passes */
+ OPTGROUP_VEC = (1 << 5),
+
+ /* All other passes */
+ OPTGROUP_OTHER = (1 << 6),
+
+ OPTGROUP_ALL = (OPTGROUP_IPA | OPTGROUP_LOOP | OPTGROUP_INLINE
+ | OPTGROUP_OMP | OPTGROUP_VEC | OPTGROUP_OTHER)
+};
+
+typedef enum optgroup_flag optgroup_flags_t;
+
+static inline optgroup_flags_t
+operator| (optgroup_flags_t lhs, optgroup_flags_t rhs)
+{
+ return (optgroup_flags_t)((int)lhs | (int)rhs);
+}
+
+static inline optgroup_flags_t &
+operator|= (optgroup_flags_t &lhs, optgroup_flags_t rhs)
+{
+ lhs = (optgroup_flags_t)((int)lhs | (int)rhs);
+ return lhs;
+}
/* Define a tree dump switch. */
struct dump_file_info
/* Dump flags. */
dump_flags_t pflags;
/* A pass flags for -fopt-info. */
- int alt_flags;
+ dump_flags_t alt_flags;
/* Flags for -fopt-info given by a user. */
- int optgroup_flags;
+ optgroup_flags_t optgroup_flags;
/* State of pass-specific stream. */
int pstate;
/* State of the -fopt-info stream. */
extern void dump_printf_loc (dump_flags_t, source_location,
const char *, ...) ATTRIBUTE_PRINTF_3;
extern void dump_function (int phase, tree fn);
-extern void dump_basic_block (int, basic_block, int);
-extern void dump_generic_expr_loc (int, source_location, int, tree);
+extern void dump_basic_block (dump_flags_t, basic_block, int);
+extern void dump_generic_expr_loc (dump_flags_t, source_location, dump_flags_t, tree);
extern void dump_generic_expr (dump_flags_t, dump_flags_t, tree);
extern void dump_gimple_stmt_loc (dump_flags_t, source_location, dump_flags_t,
gimple *, int);
extern bool enable_rtl_dump_file (void);
template<unsigned int N, typename C>
-void dump_dec (int, const poly_int<N, C> &);
+void dump_dec (dump_flags_t, const poly_int<N, C> &);
/* In tree-dump.c */
extern void dump_node (const_tree, dump_flags_t, FILE *);
SUFFIX, SWTCH, and GLOB. */
unsigned int
dump_register (const char *suffix, const char *swtch, const char *glob,
- dump_kind dkind, int optgroup_flags, bool take_ownership);
+ dump_kind dkind, optgroup_flags_t optgroup_flags,
+ bool take_ownership);
/* Allow languages and middle-end to register their dumps before the
optimization passes. */
dump_enable_all (dump_kind dkind, dump_flags_t flags, const char *filename);
int
- opt_info_enable_passes (int optgroup_flags, dump_flags_t flags,
+ opt_info_enable_passes (optgroup_flags_t optgroup_flags, dump_flags_t flags,
const char *filename);
private:
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, do_succ ? bb->succs : bb->preds)
- dump_edge_info (dump_file, e, 0, do_succ);
+ dump_edge_info (dump_file, e, TDF_NONE, do_succ);
}
/* Print information about basic block BB to the dump file. */
DEBUG_FUNCTION void
debug (gimple &ref)
{
- print_gimple_stmt (stderr, &ref, 0, 0);
+ print_gimple_stmt (stderr, &ref, 0, TDF_NONE);
}
DEBUG_FUNCTION void
print_gimple_stmt (dump_file, cur_stmt, 0);
else
{
- print_generic_expr (dump_file, tgt, 0);
+ print_generic_expr (dump_file, tgt, TDF_NONE);
fprintf (dump_file, "\n");
}
}
print_gimple_stmt (dump_file, cur_stmt, 0);
else
{
- print_generic_expr (dump_file, tgt, 0);
+ print_generic_expr (dump_file, tgt, TDF_NONE);
fprintf (dump_file, "\n");
}
}
if (ret)
{
fputs ("After writing ", dump_file);
- print_generic_expr (dump_file, cst, 0);
+ print_generic_expr (dump_file, cst, TDF_NONE);
fprintf (dump_file, " of size " HOST_WIDE_INT_PRINT_DEC
" at position %d\n", info->bitsize, pos_in_buffer);
fputs (" the merged value contains ", dump_file);
fputs ("Using existing initializer: ", dump_file);
print_gimple_stmt (dump_file,
SSA_NAME_DEF_STMT (incr_vec[i].initializer),
- 0, 0);
+ 0, TDF_NONE);
}
continue;
}
verify_gimple_pp (const char *expected, gimple *stmt)
{
pretty_printer pp;
- pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, 0 /* flags */);
+ pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
ASSERT_STREQ (expected, pp_formatted_text (&pp));
}
print_pbb_body (FILE *file, poly_bb_p pbb)
{
fprintf (file, "Body (\n");
- dump_bb (file, pbb_bb (pbb), 0, 0);
+ dump_bb (file, pbb_bb (pbb), 0, TDF_NONE);
fprintf (file, ")\n");
}
char num[11];
dump_kind dkind;
int id;
- int optgroup_flags = OPTGROUP_NONE;
+ optgroup_flags_t optgroup_flags = OPTGROUP_NONE;
gcc::dump_manager *dumps = m_ctxt->get_dumps ();
/* See below in next_pass_1. */
{
pretty_printer buffer;
buffer.buffer->stream = file;
- pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4, 0);
+ pp_gimple_stmt_1 (&buffer, SSA_NAME_DEF_STMT (node), indent + 4,
+ TDF_NONE);
pp_flush (&buffer);
}
DEBUG_FUNCTION void
debug (const tree_node &ref)
{
- dump_tree_via_hooks (&ref, 0);
+ dump_tree_via_hooks (&ref, TDF_NONE);
}
DEBUG_FUNCTION void
debug_body (const tree_node &ref)
{
if (TREE_CODE (&ref) == FUNCTION_DECL)
- dump_function_to_file (const_cast <tree_node*> (&ref), stderr, 0);
+ dump_function_to_file (const_cast <tree_node*> (&ref), stderr, TDF_NONE);
else
debug (ref);
}
const char *name;
/* The -fopt-info optimization group flags as defined in dumpfile.h. */
- unsigned int optinfo_flags;
+ optgroup_flags_t optinfo_flags;
/* The timevar id associated with this pass. */
/* ??? Ideally would be dynamically assigned. */
|| TREE_CODE (node) == QUAL_UNION_TYPE))
pp_string (pp, "union ");
- dump_generic_node (pp, TYPE_NAME (node), spc, 0, false);
+ dump_generic_node (pp, TYPE_NAME (node), spc, TDF_NONE, false);
}
/* Print the contents of the structure. */
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Generated FMA ");
- print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, 0);
+ print_gimple_stmt (dump_file, gsi_stmt (gsi), 0, TDF_NONE);
fprintf (dump_file, "\n");
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Deferred generating FMA for multiplication ");
- print_gimple_stmt (dump_file, mul_stmt, 0, 0);
+ print_gimple_stmt (dump_file, mul_stmt, 0, TDF_NONE);
fprintf (dump_file, "\n");
}
{
fprintf (dump_file, "searching for un-distribute opportunities ");
print_generic_expr (dump_file,
- (*ops)[bitmap_first_set_bit (candidates)]->op, 0);
+ (*ops)[bitmap_first_set_bit (candidates)]->op, TDF_NONE);
fprintf (dump_file, " %d\n", nr_candidates);
}
if (dump_file && (dump_flags & TDF_DETAILS))
{
fprintf (dump_file, "Removing dead stmt ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0, TDF_NONE);
}
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
/* Dump LOWER_BOUND using flags DUMP_KIND. Dumps are known to be enabled. */
static void
-dump_lower_bound (int dump_kind, const vec_lower_bound &lower_bound)
+dump_lower_bound (dump_flags_t dump_kind, const vec_lower_bound &lower_bound)
{
dump_printf (dump_kind, "%s (", lower_bound.unsigned_p ? "unsigned" : "abs");
dump_generic_expr (dump_kind, TDF_SLIM, lower_bound.expr);
git://gcc.gnu.org / gcc.git / commitdiff