+2016-03-28 Jason Merrill <jason@redhat.com>
+
+ PR c++/70422
+ PR c++/64266
+ PR c++/70353
+ * decl.c, pt.c, constexpr.c: Revert last patch.
+
2016-03-25 Jason Merrill <jason@redhat.com>
Martin Liška <mliska@suse.cz>
return (*ctx->values->get (t));
case VAR_DECL:
- if (DECL_HAS_VALUE_EXPR_P (t))
- return cxx_eval_constant_expression (ctx, DECL_VALUE_EXPR (t), lval,
- non_constant_p, overflow_p);
- /* Fall through. */
case CONST_DECL:
/* We used to not check lval for CONST_DECL, but darwin.c uses
CONST_DECL for aggregate constants. */
type = cp_build_qualified_type (char_type_node, TYPE_QUAL_CONST);
type = build_cplus_array_type (type, domain);
- *type_p = type_decays_to (type);
+ *type_p = type;
if (init)
TREE_TYPE (init) = type;
else
init = error_mark_node;
- init = decay_conversion (init, tf_warning_or_error);
-
return init;
}
/* As we're using pushdecl_with_scope, we must set the context. */
DECL_CONTEXT (decl) = current_function_decl;
+ TREE_STATIC (decl) = 1;
TREE_READONLY (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
- DECL_DECLARED_CONSTEXPR_P (decl) = 1;
TREE_USED (decl) = 1;
- if (init)
- {
- SET_DECL_VALUE_EXPR (decl, init);
- DECL_HAS_VALUE_EXPR_P (decl) = 1;
- /* For decl_constant_var_p. */
- DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
- }
-
if (current_function_decl)
{
cp_binding_level *b = current_binding_level;
while (b->level_chain->kind != sk_function_parms)
b = b->level_chain;
pushdecl_with_scope (decl, b, /*is_friend=*/false);
- add_decl_expr (decl);
+ cp_finish_decl (decl, init, /*init_const_expr_p=*/false, NULL_TREE,
+ LOOKUP_ONLYCONVERTING);
}
else
{
DECL_THIS_STATIC (decl) = true;
- pushdecl_top_level_and_finish (decl, NULL_TREE);
+ pushdecl_top_level_and_finish (decl, init);
}
return decl;
DECL_CONTEXT (decl) = current_function_decl;
cp_check_omp_declare_reduction (decl);
}
- else if (VAR_P (decl)
- && DECL_PRETTY_FUNCTION_P (decl))
- {
- /* For __PRETTY_FUNCTION__ we have to adjust the
- initializer. */
- const char *const name
- = cxx_printable_name (current_function_decl, 2);
- init = cp_fname_init (name, &TREE_TYPE (decl));
- SET_DECL_VALUE_EXPR (decl, init);
- DECL_HAS_VALUE_EXPR_P (decl) = 1;
- DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P (decl) = 1;
- maybe_push_decl (decl);
- }
else
{
int const_init = false;
maybe_push_decl (decl);
-
- init = tsubst_init (init, decl, args, complain, in_decl);
+ if (VAR_P (decl)
+ && DECL_PRETTY_FUNCTION_P (decl))
+ {
+ /* For __PRETTY_FUNCTION__ we have to adjust the
+ initializer. */
+ const char *const name
+ = cxx_printable_name (current_function_decl, 2);
+ init = cp_fname_init (name, &TREE_TYPE (decl));
+ }
+ else
+ init = tsubst_init (init, decl, args, complain, in_decl);
if (VAR_P (decl))
const_init = (DECL_INITIALIZED_BY_CONSTANT_EXPRESSION_P
+++ /dev/null
-// PR c++/70353
-// { dg-do compile { target c++11 } }
-
-constexpr const char* ce ()
-{
- return __func__;
-}
-
-#define SA(X) static_assert((X),#X)
-SA(ce()[0] == 'c');
+++ /dev/null
-// PR c++/64266
-/* { dg-do compile } */
-
-extern "C" int printf (const char *, ...);
-
-struct A
-{
- void foo(int i)
- {
- printf ("__FUNCTION__ = %s\n", __FUNCTION__);
- printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
- }
-
- void foo()
- {
- printf ("__FUNCTION__ = %s\n", __FUNCTION__);
- }
-};
-
-int
-main ()
-{
- A a;
- a.foo (0);
- a.foo ();
- return 0;
-}
-
-/* { dg-final { scan-assembler-not "_ZZN1A3fooEvE12__FUNCTION__" } } */
-/* { dg-final { scan-assembler-not "_ZZN1A3fooEiE12__FUNCTION__" } } */
-/* { dg-final { scan-assembler-not "_ZZN1A3fooEiE19__PRETTY_FUNCTION__" } } */
-/* { dg-final { scan-assembler ".(string|ascii) \"void A::foo\\(int\\)(.0)?\"" } } */
-/* { dg-final { scan-assembler ".(string|ascii) \"foo(.0)?\"" } } */
--- /dev/null
+// { dg-do run }
+// Copyright (C) 2000 Free Software Foundation, Inc.
+// Contributed by Nathan Sidwell 3 Mar 2000 <nathan@codesourcery.com>
+
+// __PRETTY_FUNCTION__, __FUNCTION__ and __function__ should have the
+// type char const [X], where X is the right value for that particular function
+
+static void const *strings[4];
+static void const *tpls[4];
+static unsigned pos = 0;
+static int fail;
+static void const *ptr = 0;
+
+void unover (char const (*)[5]) {}
+void foo (char const (*)[5]) {}
+void foo (void *) {fail = 1;}
+void foo (void const *) {fail = 1;}
+void baz (char const (&)[5]) {}
+
+template<unsigned I> void PV (char const (&objRef)[I])
+{
+ strings[pos] = objRef;
+ tpls[pos] = __PRETTY_FUNCTION__;
+ pos++;
+}
+
+void fn ()
+{
+ PV (__FUNCTION__);
+ PV (__func__);
+ PV (__PRETTY_FUNCTION__);
+ PV ("wibble");
+}
+
+void baz ()
+{
+ ptr = __FUNCTION__;
+ // there should be no string const merging
+ if (ptr == "baz")
+ fail = 1;
+ // but all uses should be the same.
+ if (ptr != __FUNCTION__)
+ fail = 1;
+}
+int baz (int)
+{
+ return ptr == __FUNCTION__;
+}
+
+int main ()
+{
+ // make sure we actually emit the VAR_DECL when needed, and things have the
+ // expected type.
+ foo (&__FUNCTION__);
+ baz (__FUNCTION__);
+ unover (&__FUNCTION__);
+ if (fail)
+ return 1;
+
+ // __FUNCTION__ should be unique across functions with the same base name
+ // (it's a local static, _not_ a string).
+ baz ();
+ if (fail)
+ return 1;
+ if (baz (1))
+ return 1;
+ fn ();
+
+ // Check the names of fn. They should all be distinct strings (though two
+ // will have the same value).
+ if (strings[0] == strings[1])
+ return 1;
+ if (strings[0] == strings[2])
+ return 1;
+ if (strings[1] == strings[2])
+ return 1;
+
+ // check the names of the template functions so invoked
+ if (tpls[0] != tpls[1])
+ return 1;
+ if (tpls[0] == tpls[2])
+ return 1;
+
+ return 0;
+}
projects / gcc.git / commitdiff