OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
d41f5c1fac
gcc/gcc/gimple-match.h
Martin Sebor 6c1dae73cd PR c++/61339 - add mismatch between struct and class [-Wmismatched-tags] to non-bugs 
gcc/c/ChangeLog:

	PR c++/61339
	* c-decl.c: Change class-key from class to struct and vice versa
	to match convention and avoid -Wclass-is-pod and -Wstruct-no-pod.
	* gimple-parser.c: Same.

gcc/c-family/ChangeLog:

	PR c++/61339
	* c-format.c (check_argument_type): Change class-key from class to
	struct and vice versa to match convention and avoid -Wclass-is-pod
	and -Wstruct-no-pod.
	* c-pretty-print.h: Same.

gcc/cp/ChangeLog:

	PR c++/61339
	* constexpr.c (cxx_eval_call_expression): Change class-key from class
	to struct and vice versa to match convention and avoid -Wclass-is-pod
	and -Wstruct-no-pod.
	* constraint.cc (get_concept_definition): Same.
	* cp-tree.h: Same.
	* cxx-pretty-print.h: Same.
	* error.c: Same.
	* logic.cc (term_list::replace): Same.
	* name-lookup.c (find_local_binding): Same.
	* pt.c (tsubst_binary_right_fold): Same.
	* search.c (field_accessor_p): Same.
	* semantics.c (expand_or_defer_fn): Same.

gcc/lto/ChangeLog:

	PR c++/61339
	* lto-dump.c: Change class-key from classi to struct and vice versa
	to match convention and avoid -Wclass-is-pod and -Wstruct-no-pod.

gcc/ChangeLog:

	PR c++/61339
	* align.h: Change class-key from class to struct and vice versa
	to match convention and avoid -Wclass-is-pod and -Wstruct-no-pod.
	* alloc-pool.h: Same.
	* asan.c (shadow_mem_size): Same.
	* auto-profile.c: Same.
	* basic-block.h: Same.
	* bitmap.h: Same.
	* cfgexpand.c (set_rtl): Same.
	(expand_one_stack_var_at): Same.
	* cfghooks.h: Same.
	* cfgloop.h: Same.
	* cgraph.h: Same.
	* config/i386/i386.h: Same.
	* df-problems.c (df_print_bb_index): Same.
	* df-scan.c: Same.
	* df.h (df_single_use): Same.
	* diagnostic-show-locus.c (layout::print_annotation_line): Same.
	(layout::annotation_line_showed_range_p): Same.
	(get_printed_columns): Same.
	(correction::ensure_terminated): Same.
	(line_corrections::~line_corrections): Same.
	* dojump.h: Same.
	* dse.c: Same.
	* dump-context.h: Same.
	* dumpfile.h: Same.
	* dwarf2out.c: Same.
	* edit-context.c: Same.
	* fibonacci_heap.c (test_union_of_equal_heaps): Same.
	* flags.h: Same.
	* function.c (assign_stack_local): Same.
	* function.h: Same.
	* gcc.c: Same.
	* gcov.c (block_info::block_info): Same.
	* genattrtab.c: Same.
	* genextract.c: Same.
	* genmatch.c (comparison_code_p): Same.
	(id_base::id_base): Same.
	(decision_tree::print): Same.
	* genoutput.c: Same.
	* genpreds.c (write_one_predicate_function): Same.
	* genrecog.c (validate_pattern): Same.
	(find_operand_positions): Same.
	(optimize_subroutine_group): Same.
	(merge_pattern_transition::merge_pattern_transition): Same.
	(merge_pattern_info::merge_pattern_info): Same.
	(merge_state_result::merge_state_result): Same.
	(merge_into_state): Same.
	* gensupport.c: Same.
	* gensupport.h: Same.
	* ggc-common.c (init_ggc_heuristics): Same.
	* ggc-tests.c (test_union): Same.
	* gimple-loop-interchange.cc (dump_induction): Same.
	* gimple-loop-versioning.cc: Same.
	* gimple-match.h (gimple_match_cond::any_else): Same.
	* gimple-ssa-backprop.c: Same.
	* gimple-ssa-sprintf.c: Same.
	* gimple-ssa-store-merging.c (store_operand_info::store_operand_info): Same.
	(store_immediate_info::store_immediate_info): Same.
	(merged_store_group::apply_stores): Same.
	(get_location_for_stmts): Same.
	* gimple-ssa-strength-reduction.c: Same.
	* gimple-ssa-warn-alloca.c: Same.
	* gimple-ssa-warn-restrict.c (pass_wrestrict::execute): Same.
	* godump.c (go_type_decl): Same.
	* hash-map-tests.c (test_map_of_strings_to_int): Same.
	* hash-map.h: Same.
	* hash-set-tests.c (test_set_of_strings): Same.
	* hsa-brig.c: Same.
	* hsa-common.h: Same.
	* hsa-gen.c (transformable_switch_to_sbr_p): Same.
	* input.c (assert_loceq): Same.
	* input.h: Same.
	* ipa-cp.c: Same.
	* ipa-devirt.c (possible_polymorphic_call_targets_1): Same.
	* ipa-fnsummary.h: Same.
	* ipa-inline.h: Same.
	* ipa-prop.h: Same.
	* ipa-split.c (visit_bb): Same.
	* ira-int.h (minmax_set_iter_next): Same.
	* loop-invariant.c: Same.
	* loop-iv.c: Same.
	* lra-eliminations.c: Same.
	* lra-int.h: Same.
	* lra-lives.c (mark_regno_dead): Same.
	* lra-remat.c: Same.
	* lra-spills.c: Same.
	* lto-streamer.h: Same.
	* mem-stats.h: Same.
	* omp-grid.c (omp_grid_lastprivate_predicate): Same.
	* omp-low.c (omp_clause_aligned_alignment): Same.
	* optabs-query.h (get_vcond_eq_icode): Same.
	* optabs.h: Same.
	* opts.c (wrap_help): Same.
	* poly-int.h: Same.
	* predict.c (predict_paths_leading_to_edge): Same.
	* pretty-print.h: Same.
	* profile-count.h: Same.
	* read-md.h: Same.
	* read-rtl-function.c: Same.
	* ree.c: Same.
	* reginfo.c: Same.
	* regrename.c: Same.
	* regrename.h: Same.
	* reload.h: Same.
	* rtl-iter.h: Same.
	* rtl.h (costs_add_n_insns): Same.
	* sanopt.c: Same.
	* sched-int.h: Same.
	* sel-sched-ir.h: Same.
	* selftest.h: Same.
	* sese.h (vec_find): Same.
	* stmt.c: Same.
	* target-globals.h: Same.
	* tree-affine.c (aff_combination_find_elt): Same.
	* tree-affine.h: Same.
	* tree-data-ref.h: Same.
	* tree-outof-ssa.c (ssa_is_replaceable_p): Same.
	* tree-predcom.c: Same.
	* tree-scalar-evolution.c (find_var_scev_info): Same.
	* tree-ssa-alias.h: Same.
	* tree-ssa-ccp.c: Same.
	* tree-ssa-coalesce.c (ssa_conflicts_dump): Same.
	* tree-ssa-loop-im.c (for_all_locs_in_loop): Same.
	(rewrite_mem_refs): Same.
	(execute_sm_if_changed): Same.
	(hoist_memory_references): Same.
	* tree-ssa-loop-ivopts.c (operator<=): Same.
	* tree-ssa-loop.h: Same.
	* tree-ssa-pre.c (get_or_alloc_expr_for_name): Same.
	* tree-ssa-structalias.c: Same.
	* tree-switch-conversion.h (cluster::cluster): Same.
	(simple_cluster::simple_cluster): Same.
	* tree-vect-patterns.c (type_conversion_p): Same.
	* tree-vectorizer.c (dump_stmt_cost): Same.
	* tree-vectorizer.h (loop_vec_info_for_loop): Same.
	* tree.c (protected_set_expr_location): Same.
	* tree.h (desired_pro_or_demotion_p): Same.
	(fndecl_built_in_p): Same.
	* unique-ptr-tests.cc: Same.
	* var-tracking.c (delete_variable_part): Same.
	* varasm.c (assemble_real): Same.
	(tree_output_constant_def): Same.
	* vec.c: Same.
	* wide-int-bitmask.h: Same.
	* wide-int.h (decompose): Same.

From-SVN: r273308
2019-07-09 10:36:00 -06:00

344 lines
8.8 KiB
C++
Raw Blame History

/* Gimple simplify definitions.
Copyright (C) 2011-2019 Free Software Foundation, Inc.
Contributed by Richard Guenther <rguenther@suse.de>
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#ifndef GCC_GIMPLE_MATCH_H
#define GCC_GIMPLE_MATCH_H
/* Helper to transparently allow tree codes and builtin function codes
exist in one storage entity. */
class code_helper
{
public:
code_helper () {}
code_helper (tree_code code) : rep ((int) code) {}
code_helper (combined_fn fn) : rep (-(int) fn) {}
operator tree_code () const { return (tree_code) rep; }
operator combined_fn () const { return (combined_fn) -rep; }
bool is_tree_code () const { return rep > 0; }
bool is_fn_code () const { return rep < 0; }
int get_rep () const { return rep; }
private:
int rep;
};
/* Represents the condition under which an operation should happen,
and the value to use otherwise. The condition applies elementwise
(as for VEC_COND_EXPR) if the values are vectors. */
class gimple_match_cond
{
public:
enum uncond { UNCOND };
/* Build an unconditional op. */
gimple_match_cond (uncond) : cond (NULL_TREE), else_value (NULL_TREE) {}
gimple_match_cond (tree, tree);
gimple_match_cond any_else () const;
/* The condition under which the operation occurs, or NULL_TREE
if the operation is unconditional. */
tree cond;
/* The value to use when the condition is false. This is NULL_TREE if
the operation is unconditional or if the value doesn't matter. */
tree else_value;
};
inline
gimple_match_cond::gimple_match_cond (tree cond_in, tree else_value_in)
: cond (cond_in), else_value (else_value_in)
{
}
/* Return a gimple_match_cond with the same condition but with an
arbitrary ELSE_VALUE. */
inline gimple_match_cond
gimple_match_cond::any_else () const
{
return gimple_match_cond (cond, NULL_TREE);
}
/* Represents an operation to be simplified, or the result of the
simplification. */
class gimple_match_op
{
public:
gimple_match_op ();
gimple_match_op (const gimple_match_cond &, code_helper, tree, unsigned int);
gimple_match_op (const gimple_match_cond &,
code_helper, tree, tree);
gimple_match_op (const gimple_match_cond &,
code_helper, tree, tree, tree);
gimple_match_op (const gimple_match_cond &,
code_helper, tree, tree, tree, tree);
gimple_match_op (const gimple_match_cond &,
code_helper, tree, tree, tree, tree, tree);
gimple_match_op (const gimple_match_cond &,
code_helper, tree, tree, tree, tree, tree, tree);
void set_op (code_helper, tree, unsigned int);
void set_op (code_helper, tree, tree);
void set_op (code_helper, tree, tree, tree);
void set_op (code_helper, tree, tree, tree, tree);
void set_op (code_helper, tree, tree, tree, tree, bool);
void set_op (code_helper, tree, tree, tree, tree, tree);
void set_op (code_helper, tree, tree, tree, tree, tree, tree);
void set_value (tree);
tree op_or_null (unsigned int) const;
bool resimplify (gimple_seq *, tree (*)(tree));
/* The maximum value of NUM_OPS. */
static const unsigned int MAX_NUM_OPS = 5;
/* The conditions under which the operation is performed, and the value to
use as a fallback. */
gimple_match_cond cond;
/* The operation being performed. */
code_helper code;
/* The type of the result. */
tree type;
/* For a BIT_FIELD_REF, whether the group of bits is stored in reverse order
from the target order. */
bool reverse;
/* The number of operands to CODE. */
unsigned int num_ops;
/* The operands to CODE. Only the first NUM_OPS entries are meaningful. */
tree ops[MAX_NUM_OPS];
};
inline
gimple_match_op::gimple_match_op ()
: cond (gimple_match_cond::UNCOND), type (NULL_TREE), reverse (false),
num_ops (0)
{
}
/* Constructor that takes the condition, code, type and number of
operands, but leaves the caller to fill in the operands. */
inline
gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in,
code_helper code_in, tree type_in,
unsigned int num_ops_in)
: cond (cond_in), code (code_in), type (type_in), reverse (false),
num_ops (num_ops_in)
{
}
/* Constructors for various numbers of operands. */
inline
gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in,
code_helper code_in, tree type_in,
tree op0)
: cond (cond_in), code (code_in), type (type_in), reverse (false),
num_ops (1)
{
ops[0] = op0;
}
inline
gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in,
code_helper code_in, tree type_in,
tree op0, tree op1)
: cond (cond_in), code (code_in), type (type_in), reverse (false),
num_ops (2)
{
ops[0] = op0;
ops[1] = op1;
}
inline
gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in,
code_helper code_in, tree type_in,
tree op0, tree op1, tree op2)
: cond (cond_in), code (code_in), type (type_in), reverse (false),
num_ops (3)
{
ops[0] = op0;
ops[1] = op1;
ops[2] = op2;
}
inline
gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in,
code_helper code_in, tree type_in,
tree op0, tree op1, tree op2, tree op3)
: cond (cond_in), code (code_in), type (type_in), reverse (false),
num_ops (4)
{
ops[0] = op0;
ops[1] = op1;
ops[2] = op2;
ops[3] = op3;
}
inline
gimple_match_op::gimple_match_op (const gimple_match_cond &cond_in,
code_helper code_in, tree type_in,
tree op0, tree op1, tree op2, tree op3,
tree op4)
: cond (cond_in), code (code_in), type (type_in), reverse (false),
num_ops (5)
{
ops[0] = op0;
ops[1] = op1;
ops[2] = op2;
ops[3] = op3;
ops[4] = op4;
}
/* Change the operation performed to CODE_IN, the type of the result to
TYPE_IN, and the number of operands to NUM_OPS_IN. The caller needs
to set the operands itself. */
inline void
gimple_match_op::set_op (code_helper code_in, tree type_in,
unsigned int num_ops_in)
{
code = code_in;
type = type_in;
num_ops = num_ops_in;
}
/* Functions for changing the operation performed, for various numbers
of operands. */
inline void
gimple_match_op::set_op (code_helper code_in, tree type_in, tree op0)
{
code = code_in;
type = type_in;
num_ops = 1;
ops[0] = op0;
}
inline void
gimple_match_op::set_op (code_helper code_in, tree type_in, tree op0, tree op1)
{
code = code_in;
type = type_in;
num_ops = 2;
ops[0] = op0;
ops[1] = op1;
}
inline void
gimple_match_op::set_op (code_helper code_in, tree type_in,
tree op0, tree op1, tree op2)
{
code = code_in;
type = type_in;
num_ops = 3;
ops[0] = op0;
ops[1] = op1;
ops[2] = op2;
}
inline void
gimple_match_op::set_op (code_helper code_in, tree type_in,
tree op0, tree op1, tree op2, bool reverse_in)
{
code = code_in;
type = type_in;
reverse = reverse_in;
num_ops = 3;
ops[0] = op0;
ops[1] = op1;
ops[2] = op2;
}
inline void
gimple_match_op::set_op (code_helper code_in, tree type_in,
tree op0, tree op1, tree op2, tree op3)
{
code = code_in;
type = type_in;
num_ops = 4;
ops[0] = op0;
ops[1] = op1;
ops[2] = op2;
ops[3] = op3;
}
inline void
gimple_match_op::set_op (code_helper code_in, tree type_in,
tree op0, tree op1, tree op2, tree op3, tree op4)
{
code = code_in;
type = type_in;
num_ops = 5;
ops[0] = op0;
ops[1] = op1;
ops[2] = op2;
ops[3] = op3;
ops[4] = op4;
}
/* Set the "operation" to be the single value VALUE, such as a constant
or SSA_NAME. */
inline void
gimple_match_op::set_value (tree value)
{
set_op (TREE_CODE (value), TREE_TYPE (value), value);
}
/* Return the value of operand I, or null if there aren't that many
operands. */
inline tree
gimple_match_op::op_or_null (unsigned int i) const
{
return i < num_ops ? ops[i] : NULL_TREE;
}
/* Return whether OP is a non-expression result and a gimple value. */
inline bool
gimple_simplified_result_is_gimple_val (const gimple_match_op *op)
{
return (op->code.is_tree_code ()
&& (TREE_CODE_LENGTH ((tree_code) op->code) == 0
|| ((tree_code) op->code) == ADDR_EXPR)
&& is_gimple_val (op->ops[0]));
}
extern tree (*mprts_hook) (gimple_match_op *);
bool gimple_simplify (gimple *, gimple_match_op *, gimple_seq *,
tree (*)(tree), tree (*)(tree));
tree maybe_push_res_to_seq (gimple_match_op *, gimple_seq *,
tree res = NULL_TREE);
void maybe_build_generic_op (gimple_match_op *);
#endif /* GCC_GIMPLE_MATCH_H */
Reference in New Issue View Git Blame Copy Permalink