if (cxx_dialect >= cxx11 && strcmp (thread_model, "single") != 0)
cpp_define (pfile, "__STDCPP_THREADS__=1");
#endif
+ if (flag_implicit_constexpr)
+ cpp_define (pfile, "__cpp_implicit_constexpr=20211111L");
}
/* Note that we define this for C as well, so that we know if
__attribute__((cleanup)) will interface with EH. */
&& flag_strong_eval_order == -1)
flag_strong_eval_order = (cxx_dialect >= cxx17 ? 2 : 1);
+ if (flag_implicit_constexpr && cxx_dialect < cxx14)
+ flag_implicit_constexpr = false;
+
/* Global sized deallocation is new in C++14. */
if (flag_sized_deallocation == -1)
flag_sized_deallocation = (cxx_dialect >= cxx14);
C++ ObjC++ Var(flag_implement_inlines) Init(1)
Export functions even if they can be inlined.
+fimplicit-constexpr
+C++ ObjC++ Var(flag_implicit_constexpr)
+Make inline functions constexpr by default.
+
fimplicit-inline-templates
C++ ObjC++ Var(flag_implicit_inline_templates) Init(1)
Emit implicit instantiations of inline templates.
# Run the testsuite in all standard conformance levels.
check-c++-all:
- $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) --stds=98,11,14,17,2a,concepts" check-g++
+ $(MAKE) RUNTESTFLAGS="$(RUNTESTFLAGS) --stds=98,11,14,17,20,23,impcx" check-g++
# Run the testsuite with garbage collection at every opportunity.
check-g++-strict-gc:
static bool
type_maybe_constexpr_destructor (tree t)
{
+ /* Until C++20, only trivial destruction is constexpr. */
+ if (TYPE_HAS_TRIVIAL_DESTRUCTOR (t))
+ return true;
+ if (cxx_dialect < cxx20)
+ return false;
if (CLASS_TYPE_P (t) && CLASSTYPE_LAZY_DESTRUCTOR (t))
/* Assume it's constexpr. */
return true;
- return type_has_constexpr_destructor (t);
+ tree fn = CLASSTYPE_DESTRUCTOR (t);
+ return (fn && maybe_constexpr_fn (fn));
}
/* Returns true iff class TYPE has a virtual destructor. */
if (cxx_dialect < cxx11)
CLASSTYPE_LITERAL_P (t) = false;
else if (CLASSTYPE_LITERAL_P (t)
- && TYPE_HAS_NONTRIVIAL_DESTRUCTOR (t)
- && (cxx_dialect < cxx20 || !type_maybe_constexpr_destructor (t)))
+ && !type_maybe_constexpr_destructor (t))
CLASSTYPE_LITERAL_P (t) = false;
else if (CLASSTYPE_LITERAL_P (t) && LAMBDA_TYPE_P (t))
CLASSTYPE_LITERAL_P (t) = (cxx_dialect >= cxx17);
#include "stor-layout.h"
#include "cgraph.h"
#include "opts.h"
+#include "stringpool.h"
+#include "attribs.h"
static bool verify_constant (tree, bool, bool *, bool *);
#define VERIFY_CONSTANT(X) \
inform (DECL_SOURCE_LOCATION (fun),
"lambdas are implicitly %<constexpr%> only in C++17 and later");
}
+ else if (DECL_DESTRUCTOR_P (fun))
+ {
+ if (cxx_dialect < cxx20)
+ {
+ ret = false;
+ if (complain)
+ error_at (DECL_SOURCE_LOCATION (fun),
+ "%<constexpr%> destructors only available"
+ " with %<-std=c++20%> or %<-std=gnu++20%>");
+ }
+ }
else if (!DECL_CONSTRUCTOR_P (fun))
{
tree rettype = TREE_TYPE (TREE_TYPE (fun));
maybe_save_constexpr_fundef (tree fun)
{
if (processing_template_decl
- || !DECL_DECLARED_CONSTEXPR_P (fun)
|| cp_function_chain->invalid_constexpr
|| (DECL_CLONED_FUNCTION_P (fun) && !DECL_DELETING_DESTRUCTOR_P (fun)))
return;
- bool complain = !DECL_GENERATED_P (fun);
+ /* With -fimplicit-constexpr, try to make inlines constexpr. We'll
+ actually set DECL_DECLARED_CONSTEXPR_P below if the checks pass. */
+ bool implicit = false;
+ if (flag_implicit_constexpr)
+ {
+ if (DECL_DELETING_DESTRUCTOR_P (fun)
+ && decl_implicit_constexpr_p (DECL_CLONED_FUNCTION (fun)))
+ /* Don't inherit implicit constexpr from the non-deleting
+ destructor. */
+ DECL_DECLARED_CONSTEXPR_P (fun) = false;
+
+ if (!DECL_DECLARED_CONSTEXPR_P (fun)
+ && DECL_DECLARED_INLINE_P (fun)
+ && !lookup_attribute ("noinline", DECL_ATTRIBUTES (fun)))
+ implicit = true;
+ }
+
+ if (!DECL_DECLARED_CONSTEXPR_P (fun) && !implicit)
+ return;
+
+ bool complain = !DECL_GENERATED_P (fun) && !implicit;
if (!is_valid_constexpr_fn (fun, complain))
return;
tree massaged = massage_constexpr_body (fun, DECL_SAVED_TREE (fun));
if (massaged == NULL_TREE || massaged == error_mark_node)
{
- if (!DECL_CONSTRUCTOR_P (fun))
+ if (!DECL_CONSTRUCTOR_P (fun) && complain)
error ("body of %<constexpr%> function %qD not a return-statement",
fun);
return;
if (!potential && complain)
return;
+ if (implicit)
+ {
+ if (potential)
+ {
+ DECL_DECLARED_CONSTEXPR_P (fun) = true;
+ DECL_LANG_SPECIFIC (fun)->u.fn.implicit_constexpr = true;
+ if (DECL_CONSTRUCTOR_P (fun))
+ TYPE_HAS_CONSTEXPR_CTOR (DECL_CONTEXT (fun)) = true;
+ }
+ else
+ /* Don't bother keeping the pre-generic body of unsuitable functions
+ not explicitly declared constexpr. */
+ return;
+ }
+
constexpr_fundef entry = {fun, NULL_TREE, NULL_TREE, NULL_TREE};
bool clear_ctx = false;
if (DECL_RESULT (fun) && DECL_CONTEXT (DECL_RESULT (fun)) == NULL_TREE)
lval, non_constant_p, overflow_p);
if (DECL_THUNK_P (fun))
return cxx_eval_thunk_call (ctx, t, fun, lval, non_constant_p, overflow_p);
- if (!DECL_DECLARED_CONSTEXPR_P (fun))
+ if (!maybe_constexpr_fn (fun))
{
if (TREE_CODE (t) == CALL_EXPR
&& cxx_replaceable_global_alloc_fn (fun)
maybe_constexpr_fn (tree t)
{
return (DECL_DECLARED_CONSTEXPR_P (t)
- || (cxx_dialect >= cxx17 && LAMBDA_FUNCTION_P (t)));
+ || (cxx_dialect >= cxx17 && LAMBDA_FUNCTION_P (t))
+ || (flag_implicit_constexpr
+ && DECL_DECLARED_INLINE_P (STRIP_TEMPLATE (t))));
}
/* True if T was declared in a function that might be constexpr: either a
bool
var_in_maybe_constexpr_fn (tree t)
{
- if (cxx_dialect >= cxx17
- && DECL_FUNCTION_SCOPE_P (t)
- && LAMBDA_FUNCTION_P (DECL_CONTEXT (t)))
- return true;
- return var_in_constexpr_fn (t);
+ return (DECL_FUNCTION_SCOPE_P (t)
+ && maybe_constexpr_fn (DECL_CONTEXT (t)));
}
/* We're assigning INIT to TARGET. In do_build_copy_constructor and
{
if (builtin_valid_in_constant_expr_p (fun))
return true;
- if (!DECL_DECLARED_CONSTEXPR_P (fun)
+ if (!maybe_constexpr_fn (fun)
/* Allow any built-in function; if the expansion
isn't constant, we'll deal with that then. */
&& !fndecl_built_in_p (fun)
&& !instantiation_dependent_expression_p (t));
}
+/* True iff FN is an implicitly constexpr function. */
+
+bool
+decl_implicit_constexpr_p (tree fn)
+{
+ if (!(flag_implicit_constexpr
+ && TREE_CODE (fn) == FUNCTION_DECL
+ && DECL_DECLARED_CONSTEXPR_P (fn)))
+ return false;
+
+ if (DECL_CLONED_FUNCTION_P (fn))
+ fn = DECL_CLONED_FUNCTION (fn);
+
+ return (DECL_LANG_SPECIFIC (fn)
+ && DECL_LANG_SPECIFIC (fn)->u.fn.implicit_constexpr);
+}
+
/* Finalize constexpr processing after parsing. */
void
unsigned immediate_fn_p : 1;
unsigned maybe_deleted : 1;
unsigned coroutine_p : 1;
+ unsigned implicit_constexpr : 1;
- unsigned spare : 10;
+ unsigned spare : 9;
/* 32-bits padding on 64-bit host. */
extern tree fold_sizeof_expr (tree);
extern void clear_cv_and_fold_caches (void);
extern tree unshare_constructor (tree CXX_MEM_STAT_INFO);
+extern bool decl_implicit_constexpr_p (tree);
/* An RAII sentinel used to restrict constexpr evaluation so that it
doesn't do anything that causes extra DECL_UID generation. */
}
if (TREE_CODE (old_decl) == FUNCTION_DECL)
{
+ /* With -fimplicit-constexpr, ignore changes in the constexpr
+ keyword. */
+ if (flag_implicit_constexpr
+ && (DECL_IMMEDIATE_FUNCTION_P (new_decl)
+ == DECL_IMMEDIATE_FUNCTION_P (old_decl)))
+ return true;
if (fndecl_built_in_p (old_decl))
{
/* Hide a built-in declaration. */
if (is_list_ctor (decl))
TYPE_HAS_LIST_CTOR (class_type) = 1;
- if (DECL_DECLARED_CONSTEXPR_P (decl)
+ if (maybe_constexpr_fn (decl)
&& !ctor && !move_fn_p (decl))
TYPE_HAS_CONSTEXPR_CTOR (class_type) = 1;
}
exceptions = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (t));
/* Likewise for the constexpr specifier, in case t is a specialization. */
- constexpr_p = DECL_DECLARED_CONSTEXPR_P (t);
+ constexpr_p = (DECL_DECLARED_CONSTEXPR_P (t)
+ && !decl_implicit_constexpr_p (t));
/* Pretty print template instantiations only. */
if (DECL_USE_TEMPLATE (t) && DECL_TEMPLATE_INFO (t)
-// { dg-options -Wabi=9 }
+// { dg-options "-Wabi=9 -fno-implicit-constexpr" }
// { dg-final { scan-assembler "_ZGVZN1N1FEvE4NameB5cxx11" } }
namespace std {
__extension__ inline namespace __cxx11 __attribute__((abi_tag("cxx11"))) {
// { dg-skip-if "PR 70349" { hppa*-*-hpux* && { ! lp64 } } }
-// { dg-options -fabi-version=9 }
+// { dg-options "-fabi-version=9 -fno-implicit-constexpr" }
// { dg-final { scan-assembler "_Z1fB7__test1v" } }
// { dg-final { scan-assembler "_ZZ1fB7__test1vEN1T1gB7__test2Ev" } }
// { dg-final { scan-assembler "_ZZZ1fB7__test1vEN1T1gEvE1x" } }
namespace x {
struct s {
- s() {}
+ s();
static int a;
};
+ s::s() {}
// { dg-final { scan-assembler {.weak[^\n]*_ZGVN1x1bE} } }
struct s __attribute__((weak)) b = s();
}
// PR c++/91241
// { dg-do compile { target c++11 } }
+// { dg-additional-options -fkeep-inline-functions }
struct A {
int *b(const int & = []() -> int { return 0; }(),
// Test of std mangling
// { dg-do compile }
-// { dg-options "-fno-inline" }
+// { dg-options "-fno-inline -fno-implicit-constexpr" }
namespace std {
struct A {
// --------------------
-struct complex // { dg-message "no .constexpr. constructor" }
+struct complex // { dg-message "no .constexpr. constructor" "" { target { ! implicit_constexpr } } }
{
complex(double r, double i) : re(r), im(i) { }
constexpr double real() const { return re; } // { dg-error "not a literal type" "" { target c++11_only } }
double im;
};
-constexpr complex co1(0, 1); // { dg-error "19:the type .const complex. of .constexpr. variable .co1. is not literal" }
-constexpr double dd2 = co1.real(); // { dg-error "|in .constexpr. expansion of " }
+constexpr complex co1(0, 1); // { dg-error "19:the type .const complex. of .constexpr. variable .co1. is not literal" "" { target { ! implicit_constexpr } } }
+constexpr double dd2 = co1.real(); // { dg-error "|in .constexpr. expansion of " "" { target { ! implicit_constexpr } } }
// --------------------
-struct base // { dg-message "no .constexpr. constructor" }
+struct base // { dg-message "no .constexpr. constructor" "" { target { ! implicit_constexpr } } }
{
int _M_i;
base() : _M_i(5) { }
};
-struct derived : public base // { dg-message "base class" }
+struct derived : public base // { dg-message "base class" "" { target { ! implicit_constexpr } } }
{
- constexpr derived(): base() { } // { dg-error "non-.constexpr. function" }
+ constexpr derived(): base() { } // { dg-error "non-.constexpr. function" "" { target { ! implicit_constexpr } } }
};
-constexpr derived obj; // { dg-error "not literal" }
+constexpr derived obj; // { dg-error "not literal" "" { target { ! implicit_constexpr } } }
// --------------------
}
};
constexpr resource f(resource d)
-{ return d; } // { dg-error "non-.constexpr." }
-constexpr resource d = f(9); // { dg-message ".constexpr." }
+{ return d; } // { dg-error "non-.constexpr." "" { target { ! implicit_constexpr } } }
+constexpr resource d = f(9); // { dg-message ".constexpr." "" { target { ! implicit_constexpr } } }
// 4.4 floating-point constant expressions
struct B
{
A a[1];
- constexpr B() : a() {} // { dg-error "non-constant|non-.constexpr." }
+ constexpr B() : a() {} // { dg-error "non-constant|non-.constexpr." "" { target { ! implicit_constexpr } } }
};
C<D> c;
};
-constexpr D d {}; // { dg-error "non-.constexpr. function" }
+constexpr D d {}; // { dg-error "non-.constexpr. function" "" { target { ! implicit_constexpr } } }
struct Y
{
Y() { }
- constexpr Y f(Y y) { return y; } // { dg-error "constexpr" }
- static constexpr Y g(Y y) { return y; } // { dg-error "constexpr" }
+ constexpr Y f(Y y) { return y; } // { dg-error "constexpr" "" { target { ! implicit_constexpr } } }
+ static constexpr Y g(Y y) { return y; } // { dg-error "constexpr" "" { target { ! implicit_constexpr } } }
};
template<typename> struct B
{
A a;
- constexpr int bar() { return a.foo(); } // { dg-error "foo" }
+ constexpr int bar() { return a.foo(); } // { dg-error "foo" "" { target { ! implicit_constexpr } } }
};
-constexpr int i = B<void>().bar(); // { dg-error "bar" }
+constexpr int i = B<void>().bar(); // { dg-error "bar" "" { target { ! implicit_constexpr } } }
template<typename T> constexpr int foo(T);
template<> int foo(int);
-template<> int foo(int); // { dg-message "previous declaration 'int foo" }
-template<> constexpr int foo(int); // { dg-error "redeclaration 'constexpr int foo" }
+template<> int foo(int); // { dg-message "previous declaration 'int foo" "" { target { ! implicit_constexpr } } }
+template<> constexpr int foo(int); // { dg-error "redeclaration 'constexpr int foo" "" { target { ! implicit_constexpr } } }
template<typename T> int bar(T);
template<> constexpr int bar(int);
-template<> constexpr int bar(int); // { dg-message "previous declaration 'constexpr int bar" }
-template<> int bar(int); // { dg-error "redeclaration 'int bar" }
+template<> constexpr int bar(int); // { dg-message "previous declaration 'constexpr int bar" "" { target { ! implicit_constexpr } } }
+template<> int bar(int); // { dg-error "redeclaration 'int bar" "" { target { ! implicit_constexpr } } }
using A::A;
};
-constexpr B b; // { dg-error "literal" }
+constexpr B b; // { dg-error "literal" "" { target { ! implicit_constexpr } } }
// PR c++/81860
// { dg-do compile { target c++11 } }
// { dg-final { scan-assembler "_ZN1AIjEC\[12\]Ev" } }
+// { dg-additional-options -fno-implicit-constexpr }
template <typename T>
struct A
// PR c++/51818
// { dg-do compile { target c++11 } }
// { dg-final { scan-assembler "_ZN1AC1IN3foo3barMUlvE_EEET_" } }
+// { dg-additional-options -fno-implicit-constexpr }
struct A
{
// { dg-do compile { target c++11 } }
+// { dg-additional-options -fkeep-inline-functions }
// { dg-final { scan-assembler "_ZZN1AIiEC4IiEET_S2_Ed_NKUlvE_clEv" } }
template <class T> struct A
// { dg-do compile { target c++14 } }
// { dg-final { scan-assembler "_ZN1AIiEcvDaEv" } }
+// { dg-additional-options -fno-implicit-constexpr }
template <class T>
struct A {
constexpr int count()
{
auto item = thing {};
- for(; (item.foo(), false);); // { dg-error "foo" }
+ for(; (item.foo(), false);); // { dg-error "foo" "" { target { ! implicit_constexpr } } }
return 0;
}
int main()
{
- static_assert( count<int>() == 0, "" ); // { dg-error "" }
+ static_assert( count<int>() == 0, "" ); // { dg-error "" "" { target { ! implicit_constexpr } } }
}
int n;
};
-static_assert( ID (NonLiteral{3}).n == 3); // { dg-error "non-literal" }
+static_assert( ID (NonLiteral{3}).n == 3); // { dg-error "non-literal" "" { target { ! implicit_constexpr } } }
// { dg-prune-output "static assertion" }
constexpr ~S () {}
int s;
};
-struct T // { dg-message "'T' is not literal because" }
-{ // { dg-message "'T' does not have 'constexpr' destructor" "" { target *-*-* } .-1 }
+struct T // { dg-message "'T' is not literal because" "" { target { ! implicit_constexpr } } }
+{ // { dg-message "'T' does not have 'constexpr' destructor" "" { target { ! implicit_constexpr } } .-1 }
constexpr T () : t (0) {}
- ~T () {} // { dg-message "defaulted destructor calls non-'constexpr' 'T::~T\\(\\)'" }
+ ~T () {} // { dg-message "defaulted destructor calls non-'constexpr' 'T::~T\\(\\)'" "" { target { ! implicit_constexpr } } }
int t;
};
struct U : public S
{
constexpr U () : u (0) {}
- constexpr ~U () = default; // { dg-error "explicitly defaulted function 'constexpr U::~U\\(\\)' cannot be declared 'constexpr' because the implicit declaration is not 'constexpr'" }
+ constexpr ~U () = default; // { dg-error "explicitly defaulted function 'constexpr U::~U\\(\\)' cannot be declared 'constexpr' because the implicit declaration is not 'constexpr'" "" { target { ! implicit_constexpr } } }
int u;
T t;
};
struct X : public T
{
constexpr X () : x (0) {}
- constexpr ~X () = default; // { dg-error "explicitly defaulted function 'constexpr X::~X\\(\\)' cannot be declared 'constexpr' because the implicit declaration is not 'constexpr'" }
+ constexpr ~X () = default; // { dg-error "explicitly defaulted function 'constexpr X::~X\\(\\)' cannot be declared 'constexpr' because the implicit declaration is not 'constexpr'" "" { target { ! implicit_constexpr } } }
int x;
};
constexpr S s;
-constexpr T t; // { dg-error "the type 'const T' of 'constexpr' variable 't' is not literal" }
+constexpr T t; // { dg-error "the type 'const T' of 'constexpr' variable 't' is not literal" "" { target { ! implicit_constexpr } } }
constexpr W0 w1;
constexpr W0 w2 = 12;
constexpr W1 w3 = 5; // { dg-message "in 'constexpr' expansion of" }
void
f6 ()
{
- constexpr T t2; // { dg-error "the type 'const T' of 'constexpr' variable 't2' is not literal" }
+ constexpr T t2; // { dg-error "the type 'const T' of 'constexpr' variable 't2' is not literal" "" { target { ! implicit_constexpr } } }
}
constexpr int
f7 ()
{
- constexpr T t3; // { dg-error "the type 'const T' of 'constexpr' variable 't3' is not literal" }
+ constexpr T t3; // { dg-error "the type 'const T' of 'constexpr' variable 't3' is not literal" "" { target { ! implicit_constexpr } } }
return 0;
}
constexpr int
f8 ()
{
- T t4; // { dg-error "variable 't4' of non-literal type 'T' in 'constexpr' function only available with" "" { target c++20_down } }
+ T t4; // { dg-error "variable 't4' of non-literal type 'T' in 'constexpr' function only available with" "" { target { c++20_down && { ! implicit_constexpr } } } }
return 0;
}
struct B : A {
constexpr B () : b (0) {}
- virtual int foo () { return 0 + b * 4; } // { dg-message "declared here" }
+ virtual int foo () { return 0 + b * 4; } // { dg-message "declared here" "" { target { ! implicit_constexpr } } }
int b;
};
{
A *a = new B ();
a->a = 4;
- int r = a->foo (); // { dg-error "call to non-.constexpr. function" }
+ int r = a->foo (); // { dg-error "call to non-.constexpr. function" "" { target { ! implicit_constexpr } } }
delete a;
return r;
}
constinit const int &r3 // { dg-error "variable .r3. does not have a constant initializer" }
= foo (); // { dg-error "call to non-.constexpr. function" }
constinit const literal &r4 = 42;
-constinit const nonliteral &r5 // { dg-error "variable .r5. does not have a constant initializer" }
- = 42; // { dg-error "call to non-.constexpr. function" }
-constinit const int &r6 = nonliteral(2).m; // { dg-error "variable .r6. does not have a constant initializer|call to non-.constexpr. function" }
+constinit const nonliteral &r5 // { dg-error "variable .r5. does not have a constant initializer" "" { target { ! implicit_constexpr } } }
+ = 42; // { dg-error "call to non-.constexpr. function" "" { target { ! implicit_constexpr } } }
+constinit const int &r6 = nonliteral(2).m; // { dg-error "variable .r6. does not have a constant initializer|call to non-.constexpr. function" "" { target { ! implicit_constexpr } } }
constinit pod p1;
constinit pod p2 = { 42 };
pod S::p;
constinit pod S::pc(S::p); // { dg-error "variable .S::pc. does not have a constant initializer|not usable" }
-constinit const nonliteral S::n(42); // { dg-error "variable .S::n. does not have a constant initializer|call to non-.constexpr. function" }
-constinit int n1 = nonliteral{42}.m; // { dg-error "variable .n1. does not have a constant initializer|temporary of non-literal type" }
+constinit const nonliteral S::n(42); // { dg-error "variable .S::n. does not have a constant initializer|call to non-.constexpr. function" "" { target { ! implicit_constexpr } } }
+constinit int n1 = nonliteral{42}.m; // { dg-error "variable .n1. does not have a constant initializer|temporary of non-literal type" "" { target { ! implicit_constexpr } } }
constinit int n2 = literal{42}.m;
void
template <class T>
struct U {
T m;
- constexpr U(int i) : m(i) { } // { dg-error "call to non-.constexpr. function" }
+ constexpr U(int i) : m(i) { } // { dg-error "call to non-.constexpr. function" "" { target { ! implicit_constexpr } } }
};
-constinit U<S> u(42); // { dg-error "does not have a constant initializer|called in a constant expression" }
+constinit U<S> u(42); // { dg-error "does not have a constant initializer|called in a constant expression" "" { target { ! implicit_constexpr } } }
// { dg-do compile { target c++20 } }
struct Value {
- Value() : v{new int{42}} {}
+ Value() : v{new int{42}} {} // { dg-error "result of 'operator new'" "" { target implicit_constexpr } }
int* v;
};
};
struct A {
- constinit static inline B b1{}; // { dg-error "does not have a constant initializer|call to non-.constexpr. function" }
+ constinit static inline B b1{}; // { dg-error "does not have a constant initializer|call to non-.constexpr. function" "" { target { ! implicit_constexpr } } }
};
int main() {
struct B
{
A a;
- bool operator==(const B&) const = default; // { dg-error "A::operator==" }
+ bool operator==(const B&) const = default; // { dg-error "A::operator==" "" { target { ! implicit_constexpr } } }
};
-constexpr bool x = B() == B(); // { dg-error "non-.constexpr" }
+constexpr bool x = B() == B(); // { dg-error "non-.constexpr" "" { target { ! implicit_constexpr } } }
};
constexpr D d{A()};
-static_assert (d == d); // { dg-error "non-constant|constexpr" }
-static_assert (!(d != d)); // { dg-error "non-constant|constexpr" }
+static_assert (d == d); // { dg-error "constant|constexpr" }
+static_assert (!(d != d)); // { dg-error "constant|constexpr" }
// auto operator<=> (const non_literal_fixed_string&) = default;
};
-template <non_literal_class> // { dg-error "11:is not a valid type for a template non-type parameter because it is not structural" }
-int operator"" _udl(); // { dg-error "5:literal operator template .int operator\"\"_udl\\(\\). has invalid parameter list" }
+template <non_literal_class> // { dg-error "11:is not a valid type for a template non-type parameter because it is not structural" "" { target { ! implicit_constexpr } } }
+int operator"" _udl(); // { dg-error "5:literal operator template .int operator\"\"_udl\\(\\). has invalid parameter list" "" { target { ! implicit_constexpr } } }
// PR c++/53756
// { dg-do compile { target c++14 } }
-// { dg-options "-gdwarf-2 -dA -fno-debug-types-section" }
+// { dg-options "-gdwarf-2 -dA -fno-debug-types-section -fno-inline" }
// We're looking for something like
// .uleb128 0x3 # (DIE (0x33) DW_TAG_subprogram)
// origin PR debug/49047
-// { dg-options "-gdwarf-2 -dA -fno-merge-debug-strings" }
+// { dg-options "-gdwarf-2 -dA -fno-merge-debug-strings -fno-implicit-constexpr" }
// { dg-do compile }
struct K
// PR c++/43912
// { dg-do compile { target c++11 } }
-// { dg-options "-gdwarf-2 -dA -fno-merge-debug-strings -gno-strict-dwarf" }
+// { dg-options "-gdwarf-2 -dA -fno-merge-debug-strings -gno-strict-dwarf -fno-inline" }
// Check for the local alias variables that point to the members of the closure.
// { dg-final { scan-assembler-times "DW_TAG_variable\[^.\]*\.ascii \"j.0\"" 4 { xfail { powerpc-ibm-aix* } } } }
// PR debug/54508
// { dg-do compile }
-// { dg-options "-gdwarf-2 -g2 -dA -fno-merge-debug-strings" }
+// { dg-options "-gdwarf-2 -g2 -dA -fno-merge-debug-strings -fno-inline" }
// { dg-final { scan-assembler "\"cbase\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }
// { dg-final { scan-assembler "\"OPCODE\\\\0\"\[ \t\]+\[#;/!|@\]+ +DW_AT_name" } }
// { dg-do compile { target c++11 } }
// { dg-skip-if "" { powerpc-ibm-aix* } }
-// { dg-options "-gpubnames -gdwarf-4 -fno-debug-types-section -dA" }
+// { dg-options "-gpubnames -gdwarf-4 -fno-debug-types-section -dA -fno-inline" }
// { dg-final { scan-assembler-times "\.section\[\t \]\[^\n\]*debug_pubnames" 1 } }
// { dg-final { scan-assembler "\"\\(anonymous namespace\\)\\\\0\"+\[ \t\]+\[#;/|@!]+\[ \t\]+external name" } }
// { dg-final { scan-assembler "\"one\\\\0\"+\[ \t\]+\[#;/|@!]+\[ \t\]+external name" } }
// { dg-do compile { target c++11 } }
// { dg-skip-if "" { powerpc-ibm-aix* } }
-// { dg-options "-gpubnames -gdwarf-4 -fdebug-types-section -dA" }
+// { dg-options "-gpubnames -gdwarf-4 -fdebug-types-section -dA -fno-inline" }
// { dg-final { scan-assembler-times "\.section\[\t \]\[^\n\]*debug_pubnames" 1 } }
// { dg-final { scan-assembler "\"\\(anonymous namespace\\)\\\\0\"+\[ \t\]+\[#;/|@!]+\[ \t\]+external name" } }
// { dg-final { scan-assembler "\"one\\\\0\"+\[ \t\]+\[#;/|@!]+\[ \t\]+external name" } }
int n;
};
+#if __cpp_implicit_constexpr
+static_assert(__is_literal_type(S), "");
+#else
static_assert(!__is_literal_type(S), "");
+#endif
#ifdef __cpp_constexpr_dynamic_alloc
struct T {
// PR c++/35688
// { dg-require-visibility "" }
-// { dg-options "-fvisibility=hidden" }
+// { dg-options "-fvisibility=hidden -fno-inline" }
// { dg-final { scan-hidden "_ZN1s6vectorI1AEC1Ev" } }
// { dg-final { scan-hidden "_ZN1s3fooI1AEEvT_" } }
/* PR 51113 */
-/* { dg-options "-fprofile-arcs -ftest-coverage -fpic" } */
+/* { dg-options "-fprofile-arcs -ftest-coverage -fpic -fno-implicit-constexpr" } */
/* { dg-do run { target native } } */
/* { dg-additional-sources "gcovpart-12b.C" } */
/* Verify line coverage counts for simple member functions. */
-/* { dg-options "-fprofile-arcs -ftest-coverage" } */
+/* { dg-options "-fprofile-arcs -ftest-coverage -fno-implicit-constexpr" } */
/* { dg-do run { target native } } */
class C {
// test2 may change the type of A by placement new.
// C++ standard is bit imprecise about this.
}
-/* { dg-final { scan-tree-dump "converting indirect call to function virtual int B::t" "fre1" } } */
-/* { dg-final { scan-ipa-dump "to virtual int B::t" "devirt" } } */
+/* { dg-final { scan-tree-dump "converting indirect call to function virtual int B::t" "fre1" { target { ! implicit_constexpr } } } } */
+/* { dg-final { scan-ipa-dump "to virtual int B::t" "devirt" { target { ! implicit_constexpr } } } } */
/* { dg-final { scan-ipa-dump "1 speculatively devirtualized" "devirt" } } */
-
// test2 may change the type of A by placement new.
// C++ standard is bit imprecise about this.
}
-/* { dg-final { scan-tree-dump "converting indirect call to function virtual int B::t" "fre1" } } */
-/* { dg-final { scan-ipa-dump "to virtual int B::t" "devirt" } } */
+/* { dg-final { scan-tree-dump "converting indirect call to function virtual int B::t" "fre1" { target { ! implicit_constexpr } } } } */
+/* { dg-final { scan-ipa-dump "to virtual int B::t" "devirt" { target { ! implicit_constexpr } } } } */
/* { dg-final { scan-ipa-dump "1 speculatively devirtualized" "devirt" } } */
/* { dg-final { scan-tree-dump "No dynamic type change found." "fre3" } } */
/* { dg-final { scan-tree-dump "Checking vtbl store:" "fre3" } } */
/* { dg-final { scan-tree-dump "Function call may change dynamic type:extcall" "fre3" } } */
-/* { dg-final { scan-tree-dump "converting indirect call to function virtual void" "fre3" } } */
+/* { dg-final { scan-tree-dump "converting indirect call to function virtual void" "fre3" { target { ! implicit_constexpr } } } } */
/* { dg-do compile } */
-/* { dg-options "-O3 -fno-ipa-cp -fdump-ipa-inline-details -fno-early-inlining" } */
+/* { dg-options "-O3 -fno-ipa-cp -fdump-ipa-inline-details -fno-early-inlining -fno-implicit-constexpr" } */
struct A {
virtual int foo () {return 1;}
void wrapfoo () {foo();}
/* middleman_2 gets early inlined and the virtual call should get turned to
a direct call. */
-/* { dg-final { scan-tree-dump "Inlining int middleman_1" "einline" } } */
-/* { dg-final { scan-tree-dump "Inlining int middleman_2" "einline" } } */
+/* { dg-final { scan-tree-dump "Inlining int middleman_1" "einline" { target { ! implicit_constexpr } } } } */
+/* { dg-final { scan-tree-dump "Inlining int middleman_2" "einline" { target { ! implicit_constexpr } } } } */
/* { dg-final { scan-tree-dump "B::foo \\(" "einline" } } */
/* { dg-final { scan-tree-dump-times "OBJ_TYPE_REF" 2 "einline" } } */
// PR c++/37276
-
+// { dg-additional-options -fno-inline }
// { dg-final { scan-assembler "_ZSt5atanhd" } }
namespace std
// { dg-lto-do link }
-/* { dg-lto-options { "-O2 -fno-early-inlining -flto -fdump-ipa-inline-details" } } */
+/* { dg-lto-options { "-O2 -fno-early-inlining -fno-implicit-constexpr -flto -fdump-ipa-inline-details" } } */
#include "inline-crossmodule-1.h"
int a::key ()
{
// { dg-module-do run }
-// { dg-additional-options "-fmodules-ts -fdump-lang-module-uid" }
+// { dg-additional-options "-fmodules-ts -fdump-lang-module-uid -fno-implicit-constexpr" }
export module enUm;
// { dg-module-cmi "enUm" }
-// { dg-additional-options "-fmodules-ts" }
+// { dg-additional-options "-fmodules-ts -fno-inline" }
import bob;
int main ()
-// { dg-additional-options -fmodule-header }
+// { dg-additional-options "-fmodule-header -fno-implicit-constexpr" }
// { dg-module-cmi {} }
#include "pmf-1.h"
-// { dg-additional-options "-fmodules-ts -fno-module-lazy -fdump-lang-module-alias" }
+// { dg-additional-options "-fmodules-ts -fno-module-lazy -fdump-lang-module-alias -fno-implicit-constexpr" }
#include "pmf-1.h"
import "pmf-1_a.H";
-// { dg-additional-options -fmodules-ts }
+// { dg-additional-options "-fmodules-ts -fno-inline" }
import "used-1_b.H";
// { dg-do compile { target c++11 } }
// { dg-add-options tls }
// { dg-require-effective-target tls_runtime }
-// { dg-additional-options "-fdump-tree-gimple" }
+// { dg-additional-options "-fdump-tree-gimple -fno-implicit-constexpr" }
// { dg-final { scan-tree-dump-times "_ZTW2s1" 2 "gimple" } }
// { dg-final { scan-tree-dump-times "_ZTW2s2" 2 "gimple" } }
// { dg-final { scan-tree-dump-times "_ZTW2s3" 2 "gimple" } }
// { dg-add-options tls }
// { dg-require-alias "" }
// { dg-require-effective-target tls_runtime }
-// { dg-additional-options "-fdump-tree-gimple" }
+// { dg-additional-options "-fdump-tree-gimple -fno-implicit-constexpr" }
// { dg-final { scan-tree-dump-times "_ZTH2s1" 1 "gimple" } }
// { dg-final { scan-tree-dump-times "_ZTH2s2" 1 "gimple" } }
// { dg-final { scan-tree-dump-times "_ZTH2s3" 1 "gimple" } }
// { dg-do compile }
-// { dg-options "-fgnu-tm -O" }
+// { dg-options "-fgnu-tm -O -fno-implicit-constexpr" }
class shared_count
{
// PR c++/70035
// { dg-do run }
// { dg-shouldfail "ubsan" }
-// { dg-options "-fsanitize=vptr -fno-sanitize-recover=undefined" }
+// { dg-options "-fsanitize=vptr -fno-sanitize-recover=undefined -fno-implicit-constexpr" }
struct A {
A (int) {}
int main()
{A *ap=new A;
-delete ap;}
+delete ap;} // { dg-prune-output "unallocated object 'i'" }
set option_list { }
foreach x $std_list {
# Handle "concepts" as C++17 plus Concepts TS.
- if { $x eq "concepts" } then { set x "17 -fconcepts" }
+ if { $x eq "concepts" } then { set x "17 -fconcepts"
+ } elseif { $x eq "impcx" } then { set x "23 -fimplicit-constexpr" }
lappend option_list "${std_prefix}$x"
}
} else {
return [check-flags { "" { } { -fconcepts } }]
}
+proc check_effective_target_implicit_constexpr { } {
+ return [check-flags { "" { } { -fimplicit-constexpr } }]
+}
+
# Return 1 if expensive testcases should be run.
proc check_effective_target_run_expensive_tests { } {
void test01()
{
P p;
- std::to_address(p); // { dg-error "required from here" }
+ std::to_address(p); // { dg-error "" }
}
static constexpr unsigned max() { return 1; }
};
+#if __cpp_implicit_constexpr
+static_assert( std::uniform_random_bit_generator<N12> ); // LWG 3150
+#else
static_assert( ! std::uniform_random_bit_generator<N12> ); // LWG 3150
+#endif
struct N13
{
static unsigned max() { return 1; } // not constexpr
};
+#if __cpp_implicit_constexpr
+static_assert( std::uniform_random_bit_generator<N13> ); // LWG 3150
+#else
static_assert( ! std::uniform_random_bit_generator<N13> ); // LWG 3150
+#endif
struct N14
{
projects / thirdparty / gcc.git / commitdiff
