CbC/CbC_gcc: gcc/genrecog.c comparison

comparison gcc/genrecog.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Generate code from machine description to recognize rtl as insns.
-Copyright (C) 1987-2018 Free Software Foundation, Inc.
+Copyright (C) 1987-2020 Free Software Foundation, Inc.
 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
 validate_pattern (SET_SRC (pattern), info, NULL_RTX, 0);
 return;
 }
 case CLOBBER:
-case CLOBBER_HIGH:
 validate_pattern (SET_DEST (pattern), info, pattern, '=');
 return;
 case ZERO_EXTRACT:
 validate_pattern (XEXP (pattern, 0), info, set, set ? '+' : 0);
 /* Simple list structure for items of type T, for use when being part
 of a list is an inherent property of T.  T must have members equivalent
 to "T *prev, *next;" and a function "void set_parent (list_head <T> *)"
 to set the parent list.  */
 template <typename T>
-struct list_head
+class list_head
 {
+public:
 /* A range of linked items.  */
-struct range
+class range
 {
+public:
 range (T *);
 range (T *, T *);
 T *start, *end;
 void set_parent (list_head *);
 list_head <T>::singleton () const
 {
 return first == last ? first : 0;
 }
-struct state;
+class state;
 /* Describes a possible successful return from a routine.  */
 struct acceptance_type
 {
 /* The type of routine we're returning from.  */
 {
 return !operator == (a, b);
 }
 /* Represents a parameter to a pattern routine.  */
-struct parameter
+class parameter
 {
+public:
 /* The C type of parameter.  */
 enum type_enum {
 /* Represents an invalid parameter.  */
 UNSET,
 /* Represents a routine that matches a partial rtx pattern, returning
 an ad-hoc enum value on success and -1 on failure.  The routine can
 be used by any subroutine type.  The match can be parameterized by
 things like mode, code and UNSPEC number.  */
-struct pattern_routine
+class pattern_routine
 {
+public:
 /* The state that implements the pattern.  */
 state *s;
 /* The deepest root position from which S can access all the rtxes it needs.
 This is NULL if the pattern doesn't need an rtx input, usually because
 /* All defined patterns.  */
 static vec <pattern_routine *> patterns;
 /* Represents one use of a pattern routine.  */
-struct pattern_use
+class pattern_use
 {
+public:
 /* The pattern routine to use.  */
 pattern_routine *routine;
 /* The values to pass as parameters.  This vector has the same length
 as ROUTINE->PARAM_TYPES.  */
 auto_vec <parameter, MAX_PATTERN_PARAMS> params;
 };
 /* Represents a test performed by a decision.  */
-struct rtx_test
+class rtx_test
 {
+public:
 rtx_test ();
 /* The types of test that can be performed.  Most of them take as input
 an rtx X.  Some also take as input a transition label LABEL; the others
 are booleans for which the transition label is always "true".
 return !operator == (a, b);
 }
 /* A simple set of transition labels.  Most transitions have a singleton
 label, so try to make that case as efficient as possible.  */
-struct int_set : public auto_vec <uint64_t, 1>
+class int_set : public auto_vec <uint64_t, 1>
 {
+public:
 typedef uint64_t *iterator;
 int_set ();
 int_set (uint64_t);
 int_set (const int_set &);
 operator != (const int_set &a, const int_set &b)
 {
 return !operator == (a, b);
 }
-struct decision;
+class decision;
 /* Represents a transition between states, dependent on the result of
 a test T.  */
-struct transition
+class transition
 {
+public:
 transition (const int_set &, state *, bool);
 void set_parent (list_head <transition> *);
 /* Links to other transitions for T.  Always null for boolean tests.  */
 /* Represents a test and the action that should be taken on the result.
 If a transition exists for the test outcome, the machine switches
 to the transition's target state.  If no suitable transition exists,
 the machine either falls through to the next decision or, if there are no
 more decisions to try, fails the match.  */
-struct decision : list_head <transition>
+class decision : public list_head <transition>
 {
+public:
 decision (const rtx_test &);
 void set_parent (list_head <decision> *s);
 bool if_statement_p (uint64_t * = 0) const;
 };
 /* Represents one machine state.  For each state the machine tries a list
 of decisions, in order, and acts on the first match.  It fails without
 further backtracking if no decisions match.  */
-struct state : list_head <decision>
+class state : public list_head <decision>
 {
+public:
 void set_parent (list_head <state> *) {}
 };
 transition::transition (const int_set &labels_in, state *to_in,
 			bool optional_in)
 /* Indicates that we have tested XVECLEN (X, 0) for a particular rtx X.  */
 const unsigned char TESTED_VECLEN = 2;
 /* Represents a set of conditions that are known to hold.  */
-struct known_conditions
+class known_conditions
 {
+public:
 /* A mask of TESTED_ values for each position, indexed by the position's
 id field.  */
 auto_vec <unsigned char> position_tests;
 /* Index N says whether operands[N] has been set.  */
 	operand_pos[d->test.pos->id] = this_operand;
 }
 }
 /* Statistics about a matching routine.  */
-struct stats
+class stats
 {
+public:
 stats ();
 /* The total number of decisions in the routine, excluding trivial
 ones that never fail.  */
 unsigned int num_decisions;
 	   st.longest_path, st.longest_path_code);
 fprintf (stderr, "  longest backtrack:   %6d (code: %6d)\n",
 	   st.longest_backtrack, st.longest_backtrack_code);
 }
-struct merge_pattern_info;
+class merge_pattern_info;
 /* Represents a transition from one pattern to another.  */
-struct merge_pattern_transition
+class merge_pattern_transition
 {
+public:
 merge_pattern_transition (merge_pattern_info *);
 /* The target pattern.  */
 merge_pattern_info *to;
 }
 /* Represents a pattern that can might match several states.  The pattern
 may replace parts of the test with a parameter value.  It may also
 replace transition labels with parameters.  */
-struct merge_pattern_info
+class merge_pattern_info
 {
+public:
 merge_pattern_info (unsigned int);
 /* If PARAM_TEST_P, the state's singleton test should be generalized
 to use the runtime value of PARAMS[PARAM_TEST].  */
 unsigned int param_test : 8;
 transitions.safe_grow_cleared (num_transitions);
 }
 /* Describes one way of matching a particular state to a particular
 pattern.  */
-struct merge_state_result
+class merge_state_result
 {
+public:
 merge_state_result (merge_pattern_info *, position *, merge_state_result *);
 /* A pattern that matches the state.  */
 merge_pattern_info *pattern;
 : pattern (pattern_in), root (root_in), prev (prev_in)
 {}
 /* Information about a state, used while trying to match it against
 a pattern.  */
-struct merge_state_info
+class merge_state_info
 {
+public:
 merge_state_info (state *);
 /* The state itself.  */
 state *s;
 continue;
 }
 /* Pairs a pattern that needs to be matched with the rtx position at
 which the pattern should occur.  */
-struct pattern_pos {
+class pattern_pos {
+public:
 pattern_pos () {}
 pattern_pos (rtx, position *);
 rtx pattern;
 position *pos;
 ES_FALLTHROUGH
 };
 /* Information used while writing out code.  */
-struct output_state
+class output_state
 {
+public:
 /* The type of routine that we're generating.  */
 routine_type type;
 /* Maps position ids to xN variable numbers.  The entry is only valid if
 it is less than the length of VAR_TO_ID, but this holds for every position
 /* Find the last non-clobber in the parallel.  */
 rtx pattern = *pattern_ptr;
 for (i = XVECLEN (pattern, 0); i > 0; i--)
 {
 rtx x = XVECEXP (pattern, 0, i - 1);
-if ((GET_CODE (x) != CLOBBER && GET_CODE (x) != CLOBBER_HIGH)
+if (GET_CODE (x) != CLOBBER
 	  || (!REG_P (XEXP (x, 0))
 	      && GET_CODE (XEXP (x, 0)) != MATCH_SCRATCH))
 	break;
 }

Mercurial > hg > CbC > CbC_gcc

comparison gcc/genrecog.c @ 145:1830386684a0