Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK
for trunk?
-- >8 --
At some point these flag start getting defined in terms of the previous
flag, which is inconvenient when we want to test if the flag is set
during a debugging session since we don't immediately know its actual
numeric value. It also results in a rather large AST that looks like
((1 << (1 << ...)) << 1). This patch defines all LOOKUP_* flags directly.
gcc/cp/ChangeLog:
* cp-tree.h (LOOKUP_NO_NARROWING): Determine value directly, not
in terms of the previous flag.
(LOOKUP_LIST_INIT_CTOR): Likewise.
(LOOKUP_COPY_PARM): Likewise.
(LOOKUP_LIST_ONLY): Likewise.
(LOOKUP_SPECULATIVE): Likewise.
(LOOKUP_DEFAULTED): Likewise.
(LOOKUP_ALREADY_DIGESTED): Likewise.
(LOOKUP_NO_RVAL_BIND): Likewise.
(LOOKUP_NO_NON_INTEGRAL): Likewise.
(LOOKUP_DELEGATING_CONS): Likewise.
(LOOKUP_ALLOW_FLEXARRAY_INIT): Likewise.
(LOOKUP_REWRITTEN): Likewise.
(LOOKUP_REVERSED): Likewise.
(LOOKUP_AGGREGATE_PAREN_INIT): Likewise.
(LOOKUP_SHORTCUT_BAD_CONVS): Likewise.
---
gcc/cp/cp-tree.h | 30 +++++++++++++++---------------
1 file changed, 15 insertions(+), 15 deletions(-)
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h
index fb8e0d8d98e3..bc0b8fd8b85b 100644
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -6224,52 +6224,52 @@ enum overload_flags { NO_SPECIAL = 0, DTOR_FLAG,
TYPENAME_FLAG };
/* Do not permit references to bind to temporaries. */
#define LOOKUP_NO_TEMP_BIND (1 << 6)
/* We're inside an init-list, so narrowing conversions are ill-formed. */
-#define LOOKUP_NO_NARROWING (LOOKUP_NO_TEMP_BIND << 1)
+#define LOOKUP_NO_NARROWING (1 << 7)
/* We're looking up a constructor for list-initialization. */
-#define LOOKUP_LIST_INIT_CTOR (LOOKUP_NO_NARROWING << 1)
+#define LOOKUP_LIST_INIT_CTOR (1 << 8)
/* This is the first parameter of a copy constructor. */
-#define LOOKUP_COPY_PARM (LOOKUP_LIST_INIT_CTOR << 1)
+#define LOOKUP_COPY_PARM (1 << 9)
/* We only want to consider list constructors. */
-#define LOOKUP_LIST_ONLY (LOOKUP_COPY_PARM << 1)
+#define LOOKUP_LIST_ONLY (1 << 10)
/* Return after determining which function to call and checking access.
Used by sythesized_method_walk to determine which functions will
be called to initialize subobjects, in order to determine exception
specification and possible implicit delete.
This is kind of a hack, but exiting early avoids problems with trying
to perform argument conversions when the class isn't complete yet. */
-#define LOOKUP_SPECULATIVE (LOOKUP_LIST_ONLY << 1)
+#define LOOKUP_SPECULATIVE (1 << 11)
/* Used by calls from defaulted functions to limit the overload set to avoid
cycles trying to declare them (core issue 1092). */
-#define LOOKUP_DEFAULTED (LOOKUP_SPECULATIVE << 1)
+#define LOOKUP_DEFAULTED (1 << 12)
/* Used in calls to store_init_value to suppress its usual call to
digest_init. */
-#define LOOKUP_ALREADY_DIGESTED (LOOKUP_DEFAULTED << 1)
+#define LOOKUP_ALREADY_DIGESTED (1 << 13)
/* Like LOOKUP_NO_TEMP_BIND, but also prevent binding to xvalues. */
-#define LOOKUP_NO_RVAL_BIND (LOOKUP_ALREADY_DIGESTED << 1)
+#define LOOKUP_NO_RVAL_BIND (1 << 14)
/* Used by case_conversion to disregard non-integral conversions. */
-#define LOOKUP_NO_NON_INTEGRAL (LOOKUP_NO_RVAL_BIND << 1)
+#define LOOKUP_NO_NON_INTEGRAL (1 << 15)
/* Used for delegating constructors in order to diagnose self-delegation. */
-#define LOOKUP_DELEGATING_CONS (LOOKUP_NO_NON_INTEGRAL << 1)
+#define LOOKUP_DELEGATING_CONS (1 << 16)
/* Allow initialization of a flexible array members. */
-#define LOOKUP_ALLOW_FLEXARRAY_INIT (LOOKUP_DELEGATING_CONS << 1)
+#define LOOKUP_ALLOW_FLEXARRAY_INIT (1 << 17)
/* We're looking for either a rewritten comparison operator candidate or the
operator to use on the former's result. We distinguish between the two by
knowing that comparisons other than == and <=> must be the latter, as must
a <=> expression trying to rewrite to <=> without reversing. */
-#define LOOKUP_REWRITTEN (LOOKUP_ALLOW_FLEXARRAY_INIT << 1)
+#define LOOKUP_REWRITTEN (1 << 18)
/* Reverse the order of the two arguments for comparison rewriting. First we
swap the arguments in add_operator_candidates, then we swap the conversions
in add_candidate (so that they correspond to the original order of the
args), then we swap the conversions back in build_new_op_1 (so they
correspond to the order of the args in the candidate). */
-#define LOOKUP_REVERSED (LOOKUP_REWRITTEN << 1)
+#define LOOKUP_REVERSED (1 << 19)
/* We're initializing an aggregate from a parenthesized list of values. */
-#define LOOKUP_AGGREGATE_PAREN_INIT (LOOKUP_REVERSED << 1)
+#define LOOKUP_AGGREGATE_PAREN_INIT (1 << 20)
/* We're computing conversions as part of a first pass of overload resolution
wherein we don't try to distinguish an unviable candidate from a
non-strictly viable candidate and thus can avoid computing unnecessary
bad conversions. */
-#define LOOKUP_SHORTCUT_BAD_CONVS (LOOKUP_AGGREGATE_PAREN_INIT << 1)
+#define LOOKUP_SHORTCUT_BAD_CONVS (1 << 21)
/* These flags are used by the conversion code.
CONV_IMPLICIT : Perform implicit conversions (standard and user-defined).
--
2.51.0.rc1
